diff --git a/.github/workflows/x-tests.yml b/.github/workflows/x-tests.yml
new file mode 100644
index 00000000..f657d478
--- /dev/null
+++ b/.github/workflows/x-tests.yml
@@ -0,0 +1,40 @@
+name: apps/x tests
+
+on:
+  pull_request:
+    paths:
+      - "apps/x/**"
+      - ".github/workflows/x-tests.yml"
+  push:
+    branches: [main]
+    paths:
+      - "apps/x/**"
+      - ".github/workflows/x-tests.yml"
+  workflow_dispatch:
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    defaults:
+      run:
+        working-directory: apps/x
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: pnpm/action-setup@v4
+        with:
+          version: 10
+
+      - uses: actions/setup-node@v4
+        with:
+          node-version: 22
+          cache: pnpm
+          cache-dependency-path: apps/x/pnpm-lock.yaml
+
+      - name: Install dependencies
+        run: pnpm install --frozen-lockfile
+
+      # Builds @x/shared (core/renderer tests import its dist), then runs
+      # the shared, core, and renderer vitest suites in order.
+      - name: Run tests
+        run: npm test
diff --git a/.gitignore b/.gitignore
index 086ea0b5..c9eee447 100644
--- a/.gitignore
+++ b/.gitignore
@@ -4,3 +4,6 @@
 data/
 .venv/
 .claude/
+
+# Local-only meeting-prep planning doc
+/PLAN.md
diff --git a/AGENTS.md b/AGENTS.md
new file mode 100644
index 00000000..0b40683a
--- /dev/null
+++ b/AGENTS.md
@@ -0,0 +1,101 @@
+# AGENTS.md — Working on the Rowboat runtime
+
+Context for AI coding agents (and humans) working on this repo. General
+codebase orientation lives in `CLAUDE.md`; this file covers the **new
+turn/session runtime** in `apps/x` — its storage, its debugging tools, and
+the invariants you must not break.
+
+## The runtime in one paragraph
+
+Chats are **sessions**; each user message starts a **turn**. Both are
+append-only JSONL event logs under `~/.rowboat/storage/{turns,sessions}/YYYY/MM/DD/`.
+All state is derived by pure reducers (`reduceTurn`, `reduceSession` in
+`@x/shared/src/turns.ts` / `sessions.ts`) shared byte-for-byte between the
+main process and the renderer. Design specs:
+`apps/x/packages/core/docs/turn-runtime-design.md` and `session-design.md` —
+read the relevant spec before changing runtime behavior.
+
+## Storage is reference-based — files store each fact once
+
+Three applications of the same mechanism:
+
+1. **Context**: a session turn's `context` is `{ previousTurnId }`; the
+   conversation prefix is materialized by walking the chain
+   (`TurnRepoContextResolver`).
+2. **Model requests**: `model_call_requested.request.messages` is a list of
+   string refs into the turn's own events — `"context"`, `"input"`,
+   `"assistant:<index>"`, `"toolResult:<toolCallId>"` — recording only what
+   is NEW since the previous call.
+3. **Agent snapshots**: when a turn's system prompt + tools are
+   byte-identical to its predecessor's, `turn_created.agent.resolved` is
+   `{ agentId, model, inheritedFrom }` instead of re-persisting ~70KB. The
+   model stays concrete (mid-session model switches still inherit).
+
+The exact provider payload is rebuilt by `composeModelRequest`
+(`packages/core/src/turns/compose-model-request.ts`) — **the same code path
+the loop transmits through**, so the file plus the composer reproduce the
+wire bytes exactly (there is a property test asserting composed == sent).
+
+## Inspecting turns and sessions
+
+```bash
+cd apps/x/packages/core
+
+# A whole session: title, per-turn status/size/input preview
+npm run inspect -- <sessionId | path/to/session.jsonl>
+
+# One turn: per model call, the EXACT provider payload — resolved system
+# prompt, tool list, wire-form messages (user-message context woven in,
+# tool-result envelopes), and the response/failure
+npm run inspect -- <turnId | path/to/turn.jsonl> [modelCallIndex] [--full]
+
+# Cascade full turn inspection across a session
+npm run inspect -- <sessionId> --turns
+```
+
+`--full` prints untruncated system prompts and message contents. Turn vs
+session ids are auto-detected. This is the intended way to see "what did the
+model actually receive" — the raw JSONL deliberately stores structural facts
+and references, never the derived wire form.
+
+## The legacy runs runtime is code-mode-only
+
+The old runs runtime (`packages/core/src/runs/`, `AgentRuntime`/`streamAgent`
+in `packages/core/src/agents/runtime.ts`, the `runs:*` IPC channels, and the
+renderer's legacy chat-tab state machine in `App.tsx`) remains in the tree
+**solely for code-mode sessions** — a deliberate, documented carve-out:
+
+- A code session IS a run (`sessionId === runId`). Direct-mode prompts drive
+  an external ACP agent and hand-assemble `code-run-event`s into the run log
+  (`code-mode/sessions/service.ts`); rowboat-mode code tabs go through
+  `runs:createMessage` → the old `AgentRuntime` loop.
+- Everything else — main chat, background tasks, live notes, knowledge
+  pipelines, scheduled agents — runs on turns/sessions. Do NOT add new
+  callers of `createRun`/`createMessage`/`streamAgent`; headless work uses
+  `packages/core/src/agents/headless.ts` (`startHeadlessAgent`/
+  `runHeadlessAgent`).
+- Temporary bridges that die when code-mode is unified: the renderer
+  transcript loader's `runs:fetch` fallback (`lib/agent-transcript.ts`), the
+  `runs:downloadLog` fallback in the chat sidebar, and the `notify-user`
+  gate's `fetchRun` fallback (`application/lib/builtin-tools.ts`).
+- The remaining migration (designed but deferred): port code sessions onto
+  sessions/turns — rowboat-mode prompts become normal turns with
+  `codeMode`/`codeCwd` composition (already supported by the agent
+  resolver's composition overrides), direct-mode prompts become a delegated
+  turn kind carrying opaque code events. That project deletes `runs/`
+  entirely.
+
+## Invariants to respect
+
+- Turn/session files are **append-only**; reducers reject impossible
+  histories loudly (`TurnCorruptionError`). Never hand-edit files.
+- Durable events are persisted **before** side effects (model calls, tool
+  invocations). Deltas (`text_delta`, …) are stream-only, never persisted.
+- The reducers in `@x/shared` must stay pure (no I/O, no node imports) —
+  the renderer imports them directly.
+- Every behavior change needs tests: reducers in `packages/shared`,
+  runtime/sessions in `packages/core`, renderer stores/views in
+  `apps/renderer` (all vitest; run `npm test` per package).
+- Schema changes: the schema is pre-release (`schemaVersion: 1` throughout);
+  breaking changes are acceptable but require wiping `~/.rowboat/storage`
+  and a note in the commit message.
diff --git a/CLAUDE.md b/CLAUDE.md
index 75a0f6a5..5e762a33 100644
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -109,7 +109,9 @@ Long-form docs for specific features. Read the relevant file before making chang
 | Feature | Doc |
 |---------|-----|
 | Live Notes — single `live:` frontmatter block (one objective + optional cron / windows / eventMatchCriteria) that turns a note into a self-updating artifact, panel UI, Copilot skill, prompts catalog | `apps/x/LIVE_NOTE.md` |
+| Calls (video mode) — one hands-free call engine with four presets (voice / video / share screen / practice coaching), device-derived surfaces (full-screen ⇄ floating popout), frame pipeline, prompts catalog | `apps/x/VIDEO_MODE.md` |
 | Analytics — PostHog event catalog, person properties, use-case taxonomy, how to add a new event | `apps/x/ANALYTICS.md` |
+| Turn/session runtime — event-sourced storage, reference model, the `npm run inspect` debugger | `AGENTS.md` (repo root), `apps/x/packages/core/docs/turn-runtime-design.md`, `session-design.md` |
 
 ## Common Tasks
 
diff --git a/apps/x/.gitignore b/apps/x/.gitignore
index db195fb4..2c5f63fd 100644
--- a/apps/x/.gitignore
+++ b/apps/x/.gitignore
@@ -1,2 +1,3 @@
 node_modules/
 test-fixtures/
+*.tsbuildinfo
diff --git a/apps/x/.pnpm-store/v11/index.db b/apps/x/.pnpm-store/v11/index.db
new file mode 100644
index 00000000..7f9770bd
Binary files /dev/null and b/apps/x/.pnpm-store/v11/index.db differ
diff --git a/apps/x/ANALYTICS.md b/apps/x/ANALYTICS.md
index 5ddfcf6e..b58d5f25 100644
--- a/apps/x/ANALYTICS.md
+++ b/apps/x/ANALYTICS.md
@@ -92,6 +92,8 @@ All in `apps/renderer/src/lib/analytics.ts`:
 - `chat_message_sent` — `{ voice_input, voice_output, search_enabled }`
 - `oauth_connected` / `oauth_disconnected` — `{ provider }`
 - `voice_input_started` — no properties
+- `call_started` — `{ preset: 'voice' | 'video' | 'share' | 'practice' }` — a hands-free call began (see `apps/x/VIDEO_MODE.md`)
+- `call_turn_latency` — `{ endpoint_to_submit_ms, submit_to_speak_ms, speak_to_audio_ms, total_ms }` — voice-to-voice latency breakdown for one call turn (utterance accepted → submitted → first TTS speak → audio playing)
 - `search_executed` — `{ types: string[] }`
 - `note_exported` — `{ format }`
 
diff --git a/apps/x/VIDEO_MODE.md b/apps/x/VIDEO_MODE.md
new file mode 100644
index 00000000..63b9621e
--- /dev/null
+++ b/apps/x/VIDEO_MODE.md
@@ -0,0 +1,243 @@
+# Calls (Video Mode) — Deep Dive
+
+Calls let the user talk to the assistant hands-free while it *sees* them
+(webcam) and their screen (screen share). There is ONE call engine —
+continuous listening, auto-submitted utterances, forced read-aloud TTS, frame
+capture — entered through four presets that differ only in starting devices.
+This doc covers the product flow, the technical pipeline, and the LLM prompt
+surface with exact pointers.
+
+## Product flow
+
+The composer has a **call split-button** (`chat-input-with-mentions.tsx`).
+The main click is the "work together" default — preset `share`: screen
+sharing ON, camera OFF, floating pill, so the user keeps working while the
+assistant watches along (the button tooltip discloses the screen share). The
+chevron menu holds the deviations. While a call is live the button turns red
+and ends it.
+
+| Preset | Starting devices | First surface |
+|--------|------------------|---------------|
+| `share` — main click | screen on, camera off | floating pill |
+| `voice` — "Voice call" | camera off, screen off | floating mascot pill |
+| `video` — "Video call" | camera on | full-screen call |
+| `practice` — "Practice session" | camera on, + coaching persona | full-screen call |
+
+**One surface rule** (`callSurface` in `App.tsx`): full screen and screen
+sharing are mutually exclusive in both directions — a full-screen call covers
+the screen, so sharing it would show the call itself.
+
+- sharing → floating popout, always (pill = working)
+- not sharing → full screen unless `callMinimized` (full screen = facing
+  each other)
+- expanding the pill auto-STOPS any share; minimizing the full-screen call
+  auto-STARTS one (the pill exists to work together) — presenting from full
+  screen likewise collapses to the pill
+- the camera toggle never changes the surface: turning it on from the pill
+  puts your video IN the pill; expanding is its own explicit action
+
+**Screen-share consent** is three-layered: a toast the moment any share
+starts ("Your screen is being shared… [Stop sharing]"), a persistent
+"Sharing screen" badge on the pill, and macOS's purple recording indicator.
+If the auto-share fails (Screen Recording permission not granted) the call
+starts anyway as a voice call, with a toast linking to System Settings.
+Practice/coaching is always an explicit choice — expanding to full screen
+never turns the coach on.
+
+In-call controls (identical bar on both surfaces): camera toggle (silhouette
+avatar while off, no webcam frames captured), screen share toggle, mascot ⇄
+"R" letter avatar, end call. While the assistant is thinking or speaking, a
+red **Stop** button appears on the mascot tile — it silences TTS instantly,
+skips queued voice segments, and aborts the run if it's still generating
+(stopping a run from anywhere, including the composer, also silences TTS). Captions of the in-progress utterance and the
+assistant's spoken line run along the bottom. Typing in the composer still
+works mid-call; frames ride along with typed messages too.
+
+Outside calls the composer keeps exactly one voice affordance: the **mic
+button** (push-to-talk dictation, untouched). Spoken responses exist only
+inside calls (forced full read-aloud, off on hang-up). The old video
+dropdown, talking-head toggle, read-aloud headphones toggle, and summary/full
+TTS dropdown are all retired — a per-message "read aloud" action on assistant
+messages is the planned replacement for text-in/voice-out.
+
+The call button is disabled unless both voice input (Deepgram) and voice
+output (TTS) are configured. `call_started` (with `preset`) is captured in
+PostHog — the adoption metric for this feature.
+
+**Popout mechanics**: a small always-on-top frameless window (camera tile
+when on + mascot tile, live caption, control bar) floating over every app —
+including Rowboat. Control-bar actions round-trip `video:popoutAction` →
+main → `video:popout-action` → app window, which owns the mic/camera/capture;
+`expand` also refocuses the app window (handled in main).
+
+## Frame pipeline
+
+`apps/renderer/src/hooks/useVideoMode.ts` runs one capture pipe per source
+(stream → offscreen `<video>` → canvas JPEG → ring buffer):
+
+- Cadence: 1 fps (`CAPTURE_INTERVAL_MS`, line 20); ring buffer ~2 min.
+- Webcam: 512px wide, JPEG q0.65, max **12 frames/message** (lines 21, 31).
+- Screen: 1280px wide (text legibility), JPEG q0.7, max **4 frames/message**
+  (lines 24, 32).
+- `collectFrames()` drains frames buffered since the last send, evenly
+  sampled down to the caps, always keeping the newest; grabs one final frame
+  at the moment of send. Falls back to the single latest frame for
+  rapid-fire messages.
+
+`App.tsx` `handlePromptSubmit` attaches the drained frames (whenever a call
+is live) to the outgoing message as `UserImagePart`s and sets
+`composition.videoMode` when the camera or screen is active, plus
+`composition.coachMode` during a practice session. Frames also become
+`isVideoFrame` display attachments (filmstrip in the transcript —
+`chat-message-attachments.tsx`; history hydration in
+`lib/run-to-conversation.ts`).
+
+## Message schema & model encoding
+
+- `packages/shared/src/message.ts:51` — `UserImagePart`: inline base64
+  (`data`, `mediaType`), `source: 'camera' | 'screen'`, `capturedAt`. Unlike
+  file attachments (path references read via the `LLMParse` tool), image
+  parts go to the model as real multimodal image parts.
+- `packages/core/src/agents/runtime.ts` `convertFromMessages` (~line 1013):
+  emits a context line (frame counts + time span), then labeled groups —
+  a `"Webcam frames (oldest to newest):"` text part before camera images and
+  a `"Screen-share frames (oldest to newest):"` text part before screen
+  images — so the model never confuses the user with their screen.
+- Frames stay inline in history (no pruning) deliberately: pruning would
+  bust provider prefix caching every turn and cost more than it saves.
+- The auto-permission classifier stringifies + truncates content to ~3KB per
+  message, so inline base64 can't blow up its prompt.
+
+## Hands-free voice loop
+
+`apps/renderer/src/hooks/useVoiceMode.ts`:
+
+- `startContinuous(onUtterance)` (line 404): push-to-talk params but with
+  `endpointing=1800` (line 25) so thinking pauses don't cut the user off,
+  plus `utterance_end_ms=2000` (line 38) as a second end-of-speech signal.
+  **Gotcha:** Deepgram's `speech_final` usually arrives on a result with an
+  EMPTY transcript — empty finals must reach the endpoint check or
+  utterances never complete (see the NOTE in `ws.onmessage`).
+- `setPaused(true)` (line 414) while the assistant thinks/speaks: drops mic
+  audio (so TTS is never transcribed back), discards half-heard buffer,
+  sends Deepgram KeepAlives every 5s. `App.tsx` drives this from
+  `activeIsProcessing || tts.state !== 'idle'`.
+- Mid-call socket drops reconnect after 1s; the offline audio backlog is
+  capped (~30s).
+
+Call lifecycle lives in `App.tsx` `startCall(preset)` / `endCall()`:
+entering a call saves/forces TTS settings, cancels any push-to-talk
+recording, and starts the continuous loop; ending restores everything.
+Push-to-talk is disabled while a call owns the mic.
+
+## Popout window
+
+- The popout window keeps the Dock icon alive: it uses
+  `setVisibleOnAllWorkspaces(true)` WITHOUT `visibleOnFullScreen` — that flag
+  turns the app into a macOS "agent" app and hides its Dock icon while the
+  window exists (looks like Rowboat vanished). Trade-off: the popout doesn't
+  hover over other apps' fullscreen Spaces.
+- Shown iff the derived `callSurface === 'popout'` (effect in `App.tsx`).
+  Renderer asks `video:setPopout {show}`; main creates a frameless,
+  `alwaysOnTop` ('floating'), all-workspaces BrowserWindow at the top-right
+  of the primary display, loading the renderer bundle with `#video-popout`
+  (`apps/renderer/src/main.tsx` branches on the hash →
+  `components/video-popout.tsx`).
+- Call state streams over the `video:popout-state` push channel; main caches
+  the last payload and replays it on popout load. Shown with
+  `showInactive()` so it never steals focus.
+- The popout captures its **own** camera preview (MediaStreams can't cross
+  windows) and synthesizes the mascot mouth level (no audio in that window).
+- `video:popoutAction` relays control-bar actions to the app window, matched
+  only by real app-window URLs — `getAllWindows()` also contains hidden
+  utility windows (PDF export) that must not be shown or messaged.
+
+## Permissions
+
+- Camera: `voice:ensureCameraAccess` settles the macOS TCC prompt before
+  `getUserMedia` (same pattern as the mic). `NSCameraUsageDescription` is in
+  `forge.config.cjs` `extendInfo`.
+- Screen: `getDisplayMedia` is auto-approved with the primary screen by
+  `setDisplayMediaRequestHandler` in `main.ts` (no picker);
+  `meeting:checkScreenPermission` registers the app in macOS Screen
+  Recording settings on first use.
+
+## LLM prompts catalog
+
+| Prompt | Where |
+|--------|-------|
+| `# Video Mode (Live Camera)` system section — how to use webcam frames, coaching guidance, screen-share rules ("treat the screen as the primary subject", "last screen frame is current"), etiquette (never comment on appearance) | `packages/core/src/agents/runtime.ts:386` (`composeSystemInstructions`, gated on `videoMode`) |
+| `# Practice Session (Coach Mode)` system section — coaching persona: specific/actionable feedback after each take, one-sentence interjections mid-flow, structured debrief on wrap-up | `composeSystemInstructions`, gated on `coachMode` (directly after the video section) |
+| "Driving the app" paragraph in the video-mode section — on calls, prefer app-navigation read-view/open-item (show while telling) over describing or squinting at frames | same `# Video Mode` section; full action docs in the `app-navigation` skill (`application/assistant/skills/app-navigation/skill.ts`) |
+| Per-message frame context line `[Video mode: N live webcam frames … and M frames of the user's shared screen …]` + group labels | `packages/core/src/agents/runtime.ts` (`convertFromMessages`) |
+| `videoMode` / `coachMode` composition overrides (session-sticky; flips bust prefix cache) | `packages/core/src/turns/bridges/real-agent-resolver.ts` (`CompositionOverrides`); set from `App.tsx` `sendConfig` |
+
+Voice input/output prompt sections (`# Voice Input`, `# Voice Output`) are
+reused untouched — calls set `voiceInput` per utterance and force
+`voiceOutput: 'full'`.
+
+## Driving the app on a call
+
+The assistant can drive the Rowboat UI itself via the extended
+`app-navigation` builtin ("app driver"): `open-view` (any main view),
+`read-view` (returns the emails / background agents / chat-history data the
+view renders — and the renderer simultaneously navigates there so the user
+watches it happen), and `open-item` (a specific email thread, note,
+background agent, or past chat, deep-linked on screen). Data comes from the
+same core functions the UI's IPC handlers use (`listImportantThreads` /
+`searchThreads`, background-task `listTasks`, the sessions container) — no
+OCR of screen frames. The renderer applies results via
+`applyAppNavigation` in App.tsx, fed from BOTH event paths: the legacy
+`runs:events` ref-poll AND a watcher over the session-chat conversation (the
+turn runtime does not emit legacy run events — miss this and navigation
+silently no-ops while the tool reports success). Session switches seed the
+watcher so replaying history never navigates. During a call, visible
+navigations also collapse the full-screen call to the pill and focus the app
+window (`app:focusMainWindow`) so the user actually sees the screen change.
+Card labels live in `lib/chat-conversation.ts`. The call prompt and the
+`app-navigation` skill teach the show-while-telling pattern: read-view →
+speak the highlights → open-item when the user picks one.
+
+## Latency
+
+Voice-to-voice latency (user stops talking → assistant audio) is engineered
+at four points; the `call_turn_latency` PostHog event measures the real
+distribution (utterance → submit → first speak → audio playing):
+
+- **Smart endpointing** (`useVoiceMode.ts`): Deepgram endpoints at 600ms and
+  the client decides — a transcript ending in terminal punctuation fires
+  immediately (~600ms after last word); a mid-thought trail holds another
+  1.2s (resumed speech cancels the hold). Complete sentences turn around
+  ~1.2s faster than the old fixed 1800ms endpoint.
+- **Streaming TTS** (`voice:synthesizeStreamStart` → `voice:tts-chunk` →
+  MediaSource playback in `useVoiceTTS.ts`): the first segment of an idle
+  queue plays from the first MP3 chunk instead of after the full body
+  (ElevenLabs `/stream`, flash model). Follow-up segments keep the gapless
+  full-body prefetch path. Falls back to non-streaming on any failure.
+- **Early clause speech** (`turn-view.ts` `applyOverlay`): a still-open
+  `<voice>` block ≥60 chars emits its last complete clause immediately, so
+  speech starts while the rest of the sentence generates.
+- **Acknowledgment cue** (`lib/call-sounds.ts`): a soft blip the instant an
+  utterance is accepted — perceived latency matters as much as measured.
+
+## Cost notes
+
+Webcam frames ≈ 250–350 tokens each (≤12/message ≈ 3–4k); screen frames ≈
+1.5–2k tokens each (≤4/message ≈ 6–8k). History keeps frames inline, so long
+sessions grow but stay prefix-cached. First lever if cost bites: drop to one
+screen frame per message unless the screen changed.
+
+## Known limitations
+
+- Turn-taking is strict — no barge-in (would need echo cancellation against
+  TTS output).
+- Frame sampling, not video: motion between frames is invisible (the prompt
+  tells the model not to claim otherwise).
+- Vocal-delivery feedback is limited: Deepgram reduces speech to text, so
+  "energy" coaching leans on visual cues.
+- Screen share always captures the primary display (no window/display
+  picker yet).
+- The full-screen call covers the chat; there's no in-call transcript drawer.
+- The "attach camera frames to typed chat without a call" combination (the
+  old video+chat mode) was cut in the call-model simplification; if analytics
+  show demand, it should return as an attachment chip, not a mode.
diff --git a/apps/x/apps/main/forge.config.cjs b/apps/x/apps/main/forge.config.cjs
index 3b967655..8cddb529 100644
--- a/apps/x/apps/main/forge.config.cjs
+++ b/apps/x/apps/main/forge.config.cjs
@@ -199,6 +199,7 @@ module.exports = {
         ],
         extendInfo: {
             NSAudioCaptureUsageDescription: 'Rowboat needs access to system audio to transcribe meetings from other apps (Zoom, Meet, etc.)',
+            NSCameraUsageDescription: 'Rowboat uses your camera in video chat mode so the assistant can see you and give feedback (e.g. pitch practice).',
         },
         osxSign: {
             batchCodesignCalls: true,
diff --git a/apps/x/apps/main/src/browser/ipc.ts b/apps/x/apps/main/src/browser/ipc.ts
index fa3b1ac1..1d1bd3b0 100644
--- a/apps/x/apps/main/src/browser/ipc.ts
+++ b/apps/x/apps/main/src/browser/ipc.ts
@@ -1,6 +1,6 @@
 import { BrowserWindow } from 'electron';
 import { ipc } from '@x/shared';
-import { browserViewManager, type BrowserState } from './view.js';
+import { browserViewManager, type BrowserState, type HttpAuthRequest } from './view.js';
 
 type IPCChannels = ipc.IPCChannels;
 
@@ -20,6 +20,7 @@ type BrowserHandlers = {
   'browser:forward': InvokeHandler<'browser:forward'>;
   'browser:reload': InvokeHandler<'browser:reload'>;
   'browser:getState': InvokeHandler<'browser:getState'>;
+  'browser:httpAuthResponse': InvokeHandler<'browser:httpAuthResponse'>;
 };
 
 /**
@@ -62,6 +63,9 @@ export const browserIpcHandlers: BrowserHandlers = {
   'browser:getState': async () => {
     return browserViewManager.getState();
   },
+  'browser:httpAuthResponse': async (_event, args) => {
+    return browserViewManager.respondToHttpAuth(args);
+  },
 };
 
 /**
@@ -70,12 +74,26 @@ export const browserIpcHandlers: BrowserHandlers = {
  * window is created so the manager has a window to attach to.
  */
 export function setupBrowserEventForwarding(): void {
-  browserViewManager.on('state-updated', (state: BrowserState) => {
-    const windows = BrowserWindow.getAllWindows();
-    for (const win of windows) {
-      if (!win.isDestroyed() && win.webContents) {
-        win.webContents.send('browser:didUpdateState', state);
-      }
+  // Only send to app windows, never to OAuth/SSO popup windows created by
+  // page window.open() — those render untrusted web content, and browsing
+  // state / auth-challenge metadata must not cross into them.
+  const broadcast = (channel: string, payload: unknown) => {
+    for (const win of BrowserWindow.getAllWindows()) {
+      if (win.isDestroyed() || !win.webContents) continue;
+      if (browserViewManager.isPopupWindow(win)) continue;
+      win.webContents.send(channel, payload);
     }
+  };
+
+  browserViewManager.on('state-updated', (state: BrowserState) => {
+    broadcast('browser:didUpdateState', state);
+  });
+
+  browserViewManager.on('http-auth-request', (request: HttpAuthRequest) => {
+    broadcast('browser:httpAuthRequest', request);
+  });
+
+  browserViewManager.on('http-auth-resolved', (requestId: string) => {
+    broadcast('browser:httpAuthResolved', { requestId });
   });
 }
diff --git a/apps/x/apps/main/src/browser/view.ts b/apps/x/apps/main/src/browser/view.ts
index 90b7d849..034aa06d 100644
--- a/apps/x/apps/main/src/browser/view.ts
+++ b/apps/x/apps/main/src/browser/view.ts
@@ -1,11 +1,12 @@
 import { randomUUID } from 'node:crypto';
 import { EventEmitter } from 'node:events';
-import { BrowserWindow, WebContentsView, session, shell, type Session } from 'electron';
+import { BrowserWindow, WebContentsView, session, shell, type Session, type WebContents } from 'electron';
 import type {
   BrowserPageElement,
   BrowserPageSnapshot,
   BrowserState,
   BrowserTabState,
+  HttpAuthRequest,
 } from '@x/shared/dist/browser-control.js';
 import { normalizeNavigationTarget } from './navigation.js';
 import {
@@ -20,7 +21,7 @@ import {
   type RawBrowserPageSnapshot,
 } from './page-scripts.js';
 
-export type { BrowserPageSnapshot, BrowserState, BrowserTabState };
+export type { BrowserPageSnapshot, BrowserState, BrowserTabState, HttpAuthRequest };
 
 /**
  * Embedded browser pane implementation.
@@ -36,13 +37,33 @@ export type { BrowserPageSnapshot, BrowserState, BrowserTabState };
 
 export const BROWSER_PARTITION = 'persist:rowboat-browser';
 
-// Claims Chrome 130 on macOS — close enough to recent stable for OAuth servers
-// that sniff the UA looking for "real browser" shapes.
-const SPOOF_UA =
-  'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/130.0.0.0 Safari/537.36';
+// Spoof a real Chrome UA so OAuth servers don't reject the embedded browser.
+// The Chrome major version is derived from the running Chromium at startup:
+// pinning a fixed version goes stale as Electron upgrades, and Chromium keeps
+// emitting Sec-CH-UA client hints with the *real* version — a UA/client-hint
+// version mismatch is a classic bot-detection signal (Google sign-in,
+// Cloudflare). Minor version is frozen at 0.0.0, exactly like real Chrome's
+// reduced UA. The platform token matches the actual OS for the same reason.
+function getChromeMajorVersion(): number {
+  const major = Number.parseInt(process.versions.chrome ?? '', 10);
+  return Number.isFinite(major) && major > 0 ? major : 130;
+}
+
+function buildChromeUserAgent(): string {
+  const platformToken =
+    process.platform === 'darwin'
+      ? 'Macintosh; Intel Mac OS X 10_15_7'
+      : process.platform === 'win32'
+        ? 'Windows NT 10.0; Win64; x64'
+        : 'X11; Linux x86_64';
+  return `Mozilla/5.0 (${platformToken}) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/${getChromeMajorVersion()}.0.0.0 Safari/537.36`;
+}
+
+const SPOOF_UA = buildChromeUserAgent();
 
 const HOME_URL = 'https://www.google.com';
 const NAVIGATION_TIMEOUT_MS = 10000;
+const HTTP_AUTH_TIMEOUT_MS = 120000;
 const POST_ACTION_IDLE_MS = 400;
 const POST_ACTION_MAX_ELEMENTS = 25;
 const POST_ACTION_MAX_TEXT_LENGTH = 4000;
@@ -68,6 +89,13 @@ type CachedSnapshot = {
   elements: Array<{ index: number; selector: string }>;
 };
 
+type PendingHttpAuth = {
+  callback: (username?: string, password?: string) => void;
+  timer: NodeJS.Timeout;
+  // The webContents that raised the challenge, so its teardown can cancel it.
+  webContents: WebContents;
+};
+
 const EMPTY_STATE: BrowserState = {
   activeTabId: null,
   tabs: [],
@@ -109,6 +137,12 @@ export class BrowserViewManager extends EventEmitter {
   private visible = false;
   private bounds: BrowserBounds = { x: 0, y: 0, width: 0, height: 0 };
   private snapshotCache = new Map<string, CachedSnapshot>();
+  private pendingHttpAuth = new Map<string, PendingHttpAuth>();
+  // Child windows created by page window.open() (OAuth/SSO popups). Tracked so
+  // they can be closed when the host window goes away — otherwise an orphaned
+  // popup keeps BrowserWindow.getAllWindows() non-empty and, on macOS, blocks
+  // the app from reopening via the Dock (see main.ts 'activate' handler).
+  private popupWindows = new Set<BrowserWindow>();
   private cleanupWindowListeners: (() => void) | null = null;
 
   attach(window: BrowserWindow): void {
@@ -137,6 +171,7 @@ export class BrowserViewManager extends EventEmitter {
       if (this.window !== window) return;
 
       const tabs = [...this.tabs.values()];
+      const popups = [...this.popupWindows];
       this.cleanupWindowListeners = null;
       this.window = null;
       this.browserSession = null;
@@ -150,6 +185,14 @@ export class BrowserViewManager extends EventEmitter {
       this.attachedTabId = null;
       this.visible = false;
       this.snapshotCache.clear();
+      for (const requestId of [...this.pendingHttpAuth.keys()]) {
+        this.finishHttpAuth(requestId);
+      }
+      // Close any OAuth/SSO popups so they don't outlive the app window.
+      for (const popup of popups) {
+        if (!popup.isDestroyed()) popup.close();
+      }
+      this.popupWindows.clear();
     };
 
     hostWebContents.on('did-start-loading', handleDidStartLoading);
@@ -171,6 +214,36 @@ export class BrowserViewManager extends EventEmitter {
     if (this.browserSession) return this.browserSession;
     const browserSession = session.fromPartition(BROWSER_PARTITION);
     browserSession.setUserAgent(SPOOF_UA);
+
+    // Electron's Sec-CH-UA client hints only carry the "Chromium" brand;
+    // real Chrome also sends "Google Chrome". Some sign-in flows (notably
+    // Google's) distinguish the two, so rewrite the brand list to match what
+    // Chrome sends. Both the low-entropy header (`sec-ch-ua`, major versions)
+    // and the high-entropy one (`sec-ch-ua-full-version-list`, requested via
+    // Accept-CH and carrying full versions) must be rewritten together — a
+    // header that claims "Google Chrome" alongside one that doesn't is a
+    // stronger bot signal than the original. Only headers Chromium already
+    // attached are rewritten — none are added. (navigator.userAgentData JS
+    // brands still report only Chromium; there is no reliable hook to spoof
+    // that under sandbox+contextIsolation, and header-based detection is the
+    // common case.)
+    const chromeMajor = getChromeMajorVersion();
+    const chromeFull = process.versions.chrome ?? `${chromeMajor}.0.0.0`;
+    const brandLists: Record<string, string> = {
+      'sec-ch-ua': `"Chromium";v="${chromeMajor}", "Google Chrome";v="${chromeMajor}", "Not-A.Brand";v="99"`,
+      'sec-ch-ua-full-version-list': `"Chromium";v="${chromeFull}", "Google Chrome";v="${chromeFull}", "Not-A.Brand";v="99.0.0.0"`,
+    };
+    browserSession.webRequest.onBeforeSendHeaders((details, callback) => {
+      const requestHeaders = details.requestHeaders;
+      for (const name of Object.keys(requestHeaders)) {
+        const replacement = brandLists[name.toLowerCase()];
+        if (replacement !== undefined) {
+          requestHeaders[name] = replacement;
+        }
+      }
+      callback({ requestHeaders });
+    });
+
     this.browserSession = browserSession;
     return browserSession;
   }
@@ -196,17 +269,34 @@ export class BrowserViewManager extends EventEmitter {
     return /^https?:\/\//i.test(url) || url === 'about:blank';
   }
 
+  /**
+   * webPreferences shared by browser tabs and OAuth popups. Kept in one place
+   * so the security-sensitive popup surface can never drift from tabs.
+   */
+  private browserWebPreferences(): Electron.WebPreferences {
+    return {
+      session: this.getSession(),
+      contextIsolation: true,
+      sandbox: true,
+      nodeIntegration: false,
+      // Chromium's built-in PDFium viewer, so PDFs render inline instead
+      // of showing a blank page.
+      plugins: true,
+      // Remove the WebAuthn API from the embedded browser only. Electron ships
+      // the API but not Chrome's authenticator UI (Touch ID sheet, QR/phone
+      // hybrid), so passkey challenges hang forever on "Verifying it's you...".
+      // With the API absent, sites feature-detect it and fall back to
+      // password/other verification. Scoped here (not app-wide) so the app's
+      // own renderer keeps WebAuthn.
+      disableBlinkFeatures: 'WebAuth',
+    };
+  }
+
   private createView(): WebContentsView {
     const view = new WebContentsView({
-      webPreferences: {
-        session: this.getSession(),
-        contextIsolation: true,
-        sandbox: true,
-        nodeIntegration: false,
-      },
+      webPreferences: this.browserWebPreferences(),
     });
 
-    view.webContents.setUserAgent(SPOOF_UA);
     return view;
   }
 
@@ -266,16 +356,145 @@ export class BrowserViewManager extends EventEmitter {
     });
     wc.on('page-title-updated', this.emitState.bind(this));
 
-    wc.setWindowOpenHandler(({ url }) => {
-      if (this.isEmbeddedTabUrl(url)) {
-        void this.newTab(url);
-      } else {
-        void shell.openExternal(url);
+    this.wireWindowPolicy(wc);
+  }
+
+  /**
+   * Window-open, popup, and HTTP-auth wiring shared by tabs and popups.
+   */
+  private wireWindowPolicy(wc: WebContents): void {
+    wc.setWindowOpenHandler((details) => this.handleWindowOpen(details));
+    wc.on('did-create-window', (child) => this.wirePopupWindow(child));
+    this.wireHttpAuth(wc);
+  }
+
+  /**
+   * Shared window.open / target=_blank policy for tabs and popups.
+   *
+   * An open that hands a handle back to the opener must become a real child
+   * window so window.opener / postMessage survive — this is how OAuth/SSO
+   * popups (Google, Microsoft, Plaid, ...) return their result; denying them
+   * also makes sites report "popup blocked". Those are: a sized popup
+   * (disposition 'new-window'), a *named* window.open(url, 'name') (non-empty
+   * frameName), or a scripted blank window the opener will populate
+   * (about:blank). A nameless target=_blank link (foreground-tab, empty
+   * frameName) has no opener contract and opens as a tab, matching browser
+   * behavior. Non-web schemes go to the system handler.
+   *
+   * Residual gap: a nameless, featureless window.open(url) is indistinguishable
+   * from a _blank link (both foreground-tab + empty frameName) and opens as a
+   * tab, losing its opener — rare for OAuth, which virtually always names or
+   * sizes its popup.
+   */
+  private handleWindowOpen(details: Electron.HandlerDetails): Electron.WindowOpenHandlerResponse {
+    const { url, disposition, frameName } = details;
+
+    if (this.isEmbeddedTabUrl(url)) {
+      const needsOpener =
+        disposition === 'new-window' || frameName !== '' || url === 'about:blank';
+      if (needsOpener) {
+        return {
+          action: 'allow',
+          overrideBrowserWindowOptions: {
+            autoHideMenuBar: true,
+            webPreferences: this.browserWebPreferences(),
+          },
+        };
       }
+      void this.newTab(url);
       return { action: 'deny' };
+    }
+
+    void shell.openExternal(url);
+    return { action: 'deny' };
+  }
+
+  private wirePopupWindow(child: BrowserWindow): void {
+    this.popupWindows.add(child);
+    child.once('closed', () => this.popupWindows.delete(child));
+    this.wireWindowPolicy(child.webContents);
+  }
+
+  /** True if `win` is an OAuth/SSO popup created by page window.open(). */
+  isPopupWindow(win: BrowserWindow): boolean {
+    return this.popupWindows.has(win);
+  }
+
+  /**
+   * HTTP basic/proxy auth. Chromium's default is to cancel the challenge, so
+   * 401-protected sites and authenticating proxies dead-end. When the browser
+   * pane is on screen to answer, forward the challenge to it as a credential
+   * prompt (cancelled after a timeout if unanswered). When the pane is closed
+   * — e.g. agent-driven navigation — don't preventDefault, so Chromium cancels
+   * immediately and the 401 page is readable rather than hanging.
+   */
+  private wireHttpAuth(wc: WebContents): void {
+    wc.on('login', (event, _details, authInfo, callback) => {
+      if (!this.visible || !this.window) return;
+      event.preventDefault();
+
+      const requestId = randomUUID();
+      const timer = setTimeout(() => {
+        this.finishHttpAuth(requestId);
+      }, HTTP_AUTH_TIMEOUT_MS);
+      this.pendingHttpAuth.set(requestId, { callback, timer, webContents: wc });
+      // If the challenging contents dies before an answer, resolve now so the
+      // native callback and timer don't leak (backstop for paths other than
+      // destroyTab, which cancels explicitly before removeAllListeners()).
+      wc.once('destroyed', () => this.finishHttpAuth(requestId));
+
+      const request: HttpAuthRequest = {
+        requestId,
+        host: authInfo.host,
+        isProxy: authInfo.isProxy,
+        ...(authInfo.realm ? { realm: authInfo.realm } : {}),
+      };
+      this.emit('http-auth-request', request);
     });
   }
 
+  /**
+   * Resolve a pending auth challenge. `username === undefined` cancels it; an
+   * empty-string username is a valid submission (token-style Basic auth).
+   * Always notifies the renderer so a dialog it may still be showing (e.g.
+   * after a timeout or tab close) is pruned.
+   */
+  private finishHttpAuth(requestId: string, username?: string, password?: string): boolean {
+    const pending = this.pendingHttpAuth.get(requestId);
+    if (!pending) return false;
+    this.pendingHttpAuth.delete(requestId);
+    clearTimeout(pending.timer);
+    try {
+      if (username == null) {
+        pending.callback();
+      } else {
+        pending.callback(username, password ?? '');
+      }
+    } catch {
+      // The challenged webContents may already be destroyed.
+    }
+    this.emit('http-auth-resolved', requestId);
+    return true;
+  }
+
+  private cancelHttpAuthForWebContents(wc: WebContents): void {
+    const ids: string[] = [];
+    for (const [requestId, pending] of this.pendingHttpAuth) {
+      if (pending.webContents === wc) ids.push(requestId);
+    }
+    for (const requestId of ids) {
+      this.finishHttpAuth(requestId);
+    }
+  }
+
+  respondToHttpAuth(input: {
+    requestId: string;
+    username?: string;
+    password?: string;
+  }): { ok: boolean } {
+    return { ok: this.finishHttpAuth(input.requestId, input.username, input.password) };
+  }
+
   private snapshotTabState(tab: BrowserTab): BrowserTabState {
     const wc = tab.view.webContents;
     return {
@@ -364,6 +583,10 @@ export class BrowserViewManager extends EventEmitter {
 
   private destroyTab(tab: BrowserTab): void {
     this.invalidateSnapshot(tab.id);
+    // Cancel any auth challenge this tab raised before we drop its listeners,
+    // so the native callback + timer don't leak and the renderer prunes its
+    // dialog (removeAllListeners() below would kill the 'destroyed' backstop).
+    this.cancelHttpAuthForWebContents(tab.view.webContents);
     tab.view.webContents.removeAllListeners();
     if (!tab.view.webContents.isDestroyed()) {
       tab.view.webContents.close();
diff --git a/apps/x/apps/main/src/ipc.ts b/apps/x/apps/main/src/ipc.ts
index c559bf53..bb8faf73 100644
--- a/apps/x/apps/main/src/ipc.ts
+++ b/apps/x/apps/main/src/ipc.ts
@@ -1,7 +1,8 @@
-import { ipcMain, BrowserWindow, shell, dialog, systemPreferences, desktopCapturer, app } from 'electron';
+import { ipcMain, BrowserWindow, shell, dialog, systemPreferences, desktopCapturer, app, screen } from 'electron';
 import { ipc } from '@x/shared';
 import path from 'node:path';
 import os from 'node:os';
+import { fileURLToPath } from 'node:url';
 import {
   connectProvider,
   disconnectProvider,
@@ -24,6 +25,8 @@ const execFileAsync = promisify(execFile);
 
 import { RunEvent } from '@x/shared/dist/runs.js';
 import { ServiceEvent } from '@x/shared/dist/service-events.js';
+import type { SessionBusEvent } from '@x/shared/dist/sessions.js';
+import type { ISessions, EmitterSessionBus } from '@x/core/dist/sessions/index.js';
 import container from '@x/core/dist/di/container.js';
 import { listOnboardingModels } from '@x/core/dist/models/models-dev.js';
 import { testModelConnection, listModelsForProvider, generateOneShot } from '@x/core/dist/models/models.js';
@@ -49,6 +52,8 @@ import type { CodeSession } from '@x/shared/dist/code-sessions.js';
 import { invalidateCopilotInstructionsCache } from '@x/core/dist/application/assistant/instructions.js';
 import { triggerSync as triggerGranolaSync } from '@x/core/dist/knowledge/granola/sync.js';
 import { ISlackConfigRepo } from '@x/core/dist/slack/repo.js';
+import { IChannelsConfigRepo } from '@x/core/dist/channels/repo.js';
+import { applyChannelsConfig, getChannelsStatus, logoutWhatsApp, subscribeChannelsStatus } from '@x/core/dist/channels/service.js';
 import { runAgentSlack, getAgentSlackCliStatus, AgentSlackRunError } from '@x/core/dist/slack/agent-slack-exec.js';
 import { knowledgeSourcesRepo } from '@x/core/dist/knowledge/sources/repo.js';
 import { rankSlackHomeMessages } from '@x/core/dist/knowledge/sources/rank_slack_home.js';
@@ -66,6 +71,9 @@ import { IAgentScheduleRepo } from '@x/core/dist/agent-schedule/repo.js';
 import { IAgentScheduleStateRepo } from '@x/core/dist/agent-schedule/state-repo.js';
 import { triggerRun as triggerAgentScheduleRun } from '@x/core/dist/agent-schedule/runner.js';
 import { search } from '@x/core/dist/search/search.js';
+import { resolveMeetingPrep } from '@x/core/dist/knowledge/meeting_prep.js';
+import { readPrepNoteForEvent } from '@x/core/dist/knowledge/meeting_prep_brief.js';
+import { invalidateKnowledgeIndex } from '@x/core/dist/knowledge/knowledge_index.js';
 import { versionHistory, voice } from '@x/core';
 import { classifySchedule, processRowboatInstruction } from '@x/core/dist/knowledge/inline_tasks.js';
 import { getBillingInfo } from '@x/core/dist/billing/billing.js';
@@ -73,7 +81,7 @@ import { summarizeMeeting } from '@x/core/dist/knowledge/summarize_meeting.js';
 import { getAccessToken } from '@x/core/dist/auth/tokens.js';
 import { getRowboatConfig } from '@x/core/dist/config/rowboat.js';
 import { runLiveNoteAgent } from '@x/core/dist/knowledge/live-note/runner.js';
-import { listImportantThreads, listEverythingElseThreads, saveMessageBodyHeight, triggerSync as triggerGmailSync, sendThreadReply, archiveThread, trashThread, markThreadRead, getAccountEmail, getAccountName, getConnectionStatus as getGmailConnectionStatus } from '@x/core/dist/knowledge/sync_gmail.js';
+import { listImportantThreads, listEverythingElseThreads, saveMessageBodyHeight, triggerSync as triggerGmailSync, sendThreadReply, saveThreadDraft, deleteThreadDraft, listDraftThreads, searchThreads, archiveThread, trashThread, markThreadRead, downloadAttachment, getAccountEmail, getAccountName, getConnectionStatus as getGmailConnectionStatus } from '@x/core/dist/knowledge/sync_gmail.js';
 import { searchContacts as searchGmailContacts, warmContactIndex } from '@x/core/dist/knowledge/gmail_contacts.js';
 import { searchSentContacts, warmSentContacts } from '@x/core/dist/knowledge/gmail_sent_contacts.js';
 import { getGoogleDocsConnectionStatus, importGoogleDoc, syncGoogleDocDown, syncGoogleDocUp, getGoogleDocLink } from '@x/core/dist/knowledge/google_docs.js';
@@ -380,9 +388,36 @@ type InvokeHandlers = {
   [K in InvokeChannels]: InvokeHandler<K>;
 };
 
+// In-flight streaming TTS requests, keyed by renderer-chosen requestId.
+const activeTtsStreams = new Map<string, AbortController>();
+
+// Video-mode popout window (shown for the whole duration of a screen share,
+// floating over every app including Rowboat itself) and the last call state
+// pushed by the main window — replayed to the popout when it finishes loading.
+let videoPopoutWin: BrowserWindow | null = null;
+let lastVideoPopoutState: {
+  ttsState: 'idle' | 'synthesizing' | 'speaking';
+  status: 'listening' | 'thinking' | 'speaking' | null;
+  cameraOn: boolean;
+  screenSharing: boolean;
+  interimText: string | null;
+} | null = null;
+
+// Match only real app windows — getAllWindows() can also contain the popout
+// itself and hidden utility windows (e.g. PDF-export renderers), which must
+// not be shown, focused, or sent app events.
+function findMainAppWindow(): BrowserWindow | undefined {
+  return BrowserWindow.getAllWindows().find((w) => {
+    if (w === videoPopoutWin || w.isDestroyed()) return false;
+    const url = w.webContents.getURL();
+    const isAppWindow = url.startsWith('app://') || url.startsWith('http://localhost');
+    return isAppWindow && !url.includes('#video-popout');
+  });
+}
+
 /**
  * Register all IPC handlers with type safety and runtime validation
- * 
+ *
  * This function ensures:
  * 1. All invoke channels have handlers (exhaustiveness checking)
  * 2. Handler signatures match channel definitions
@@ -511,7 +546,25 @@ function queueChange(relPath: string): void {
 /**
  * Handle workspace change event from core watcher
  */
+function touchesKnowledge(event: z.infer<typeof workspaceShared.WorkspaceChangeEvent>): boolean {
+  const hit = (p: string | undefined) => typeof p === 'string' && p.startsWith('knowledge/');
+  switch (event.type) {
+    case 'created':
+    case 'changed':
+    case 'deleted':
+      return hit(event.path);
+    case 'moved':
+      return hit(event.from) || hit(event.to);
+    case 'bulkChanged':
+      return !event.paths || event.paths.some(hit);
+    default:
+      return false;
+  }
+}
+
 function handleWorkspaceChange(event: z.infer<typeof workspaceShared.WorkspaceChangeEvent>): void {
+  // Any knowledge-base change drops the cached index so the next read rebuilds.
+  if (touchesKnowledge(event)) invalidateKnowledgeIndex();
   // Debounce 'changed' events, emit others immediately
   if (event.type === 'changed' && event.path) {
     queueChange(event.path);
@@ -617,6 +670,39 @@ export async function startRunsWatcher(): Promise<void> {
   });
 }
 
+// New runtime: session bus → renderer windows (session-design.md §10).
+function emitSessionEvent(event: SessionBusEvent): void {
+  const windows = BrowserWindow.getAllWindows();
+  for (const win of windows) {
+    if (!win.isDestroyed() && win.webContents) {
+      win.webContents.send('sessions:events', event);
+    }
+  }
+}
+
+// Mobile channels: status changes (QR pairing, connect/disconnect) → renderer.
+let channelsWatcher: (() => void) | null = null;
+export function startChannelsWatcher(): void {
+  if (channelsWatcher) return;
+  channelsWatcher = subscribeChannelsStatus((status) => {
+    const windows = BrowserWindow.getAllWindows();
+    for (const win of windows) {
+      if (!win.isDestroyed() && win.webContents) {
+        win.webContents.send('channels:status', status);
+      }
+    }
+  });
+}
+
+let sessionsWatcher: (() => void) | null = null;
+export function startSessionsWatcher(): void {
+  if (sessionsWatcher) {
+    return;
+  }
+  const sessionBus = container.resolve<EmitterSessionBus>('sessionBus');
+  sessionsWatcher = sessionBus.subscribe((event) => emitSessionEvent(event));
+}
+
 let servicesWatcher: (() => void) | null = null;
 export async function startServicesWatcher(): Promise<void> {
   if (servicesWatcher) {
@@ -744,6 +830,18 @@ export function setupIpcHandlers() {
     'gmail:sendReply': async (_event, args) => {
       return sendThreadReply(args);
     },
+    'gmail:saveDraft': async (_event, args) => {
+      return saveThreadDraft(args);
+    },
+    'gmail:deleteDraft': async (_event, args) => {
+      return deleteThreadDraft(args.draftId);
+    },
+    'gmail:getDrafts': async () => {
+      return listDraftThreads();
+    },
+    'gmail:search': async (_event, args) => {
+      return searchThreads(args.query, { limit: args.limit });
+    },
     'gmail:getConnectionStatus': async () => {
       return getGmailConnectionStatus();
     },
@@ -760,7 +858,10 @@ export function setupIpcHandlers() {
       return trashThread(args.threadId);
     },
     'gmail:markThreadRead': async (_event, args) => {
-      return markThreadRead(args.threadId);
+      return markThreadRead(args.threadId, args.read);
+    },
+    'gmail:downloadAttachment': async (_event, args) => {
+      return downloadAttachment(args);
     },
     'gmail:saveMessageHeight': async (_event, args) => {
       saveMessageBodyHeight(args.threadId, args.messageId, args.height);
@@ -824,6 +925,82 @@ export function setupIpcHandlers() {
       await runsCore.deleteRun(args.runId);
       return { success: true };
     },
+    // ── New runtime: sessions + turns ─────────────────────────
+    // Thin pass-throughs to the sessions service. sendMessage returns the
+    // turnId immediately; the turn advances in the background and the
+    // renderer reconciles via the sessions:events feed. Input-routing calls
+    // settle with that advance's outcome (the renderer fire-and-forgets).
+    'sessions:create': async (_event, args) => {
+      const sessionId = await container.resolve<ISessions>('sessions').createSession(args);
+      return { sessionId };
+    },
+    'sessions:list': async () => {
+      return { sessions: container.resolve<ISessions>('sessions').listSessions() };
+    },
+    'sessions:get': async (_event, args) => {
+      return container.resolve<ISessions>('sessions').getSession(args.sessionId);
+    },
+    'sessions:getTurn': async (_event, args) => {
+      return container.resolve<ISessions>('sessions').getTurn(args.turnId);
+    },
+    'sessions:sendMessage': async (_event, args) => {
+      return container.resolve<ISessions>('sessions').sendMessage(args.sessionId, args.input, args.config);
+    },
+    'sessions:respondToPermission': async (_event, args) => {
+      await container.resolve<ISessions>('sessions').respondToPermission(args.turnId, args.toolCallId, args.decision, args.metadata);
+      return { success: true };
+    },
+    'sessions:respondToAskHuman': async (_event, args) => {
+      await container.resolve<ISessions>('sessions').respondToAskHuman(args.turnId, args.toolCallId, args.answer);
+      return { success: true };
+    },
+    'sessions:stopTurn': async (_event, args) => {
+      await container.resolve<ISessions>('sessions').stopTurn(args.turnId, args.reason);
+      return { success: true };
+    },
+    'sessions:resumeTurn': async (_event, args) => {
+      await container.resolve<ISessions>('sessions').resumeTurn(args.sessionId);
+      return { success: true };
+    },
+    'sessions:setTitle': async (_event, args) => {
+      await container.resolve<ISessions>('sessions').setTitle(args.sessionId, args.title);
+      return { success: true };
+    },
+    'sessions:delete': async (_event, args) => {
+      await container.resolve<ISessions>('sessions').deleteSession(args.sessionId);
+      return { success: true };
+    },
+    'sessions:downloadLog': async (event, args) => {
+      // Concatenate the session's turn logs into one JSONL for debugging.
+      const sessions = container.resolve<ISessions>('sessions');
+      const state = await sessions.getSession(args.sessionId);
+      const win = BrowserWindow.fromWebContents(event.sender);
+      const result = await dialog.showSaveDialog(win!, {
+        defaultPath: `${args.sessionId}.jsonl.log`,
+        filters: [
+          { name: 'Chat Log', extensions: ['log'] },
+          { name: 'JSONL', extensions: ['jsonl'] },
+          { name: 'All Files', extensions: ['*'] },
+        ],
+      });
+      if (result.canceled || !result.filePath) {
+        return { success: false };
+      }
+      try {
+        const lines: string[] = [];
+        for (const ref of state.turns) {
+          const turn = await sessions.getTurn(ref.turnId);
+          for (const turnEvent of turn.events) {
+            lines.push(JSON.stringify(turnEvent));
+          }
+        }
+        await fs.writeFile(result.filePath, lines.join('\n') + '\n');
+        return { success: true };
+      } catch (err) {
+        const message = err instanceof Error ? err.message : 'Failed to download chat log';
+        return { success: false, error: message };
+      }
+    },
     'runs:downloadLog': async (event, args) => {
       const runFileName = `${args.runId}.jsonl`;
       if (path.basename(runFileName) !== runFileName) {
@@ -1079,6 +1256,22 @@ export function setupIpcHandlers() {
 
       return { success: true };
     },
+    // ── Mobile channels (WhatsApp / Telegram bridge) ─────────────
+    'channels:getConfig': async () => {
+      return container.resolve<IChannelsConfigRepo>('channelsConfigRepo').getConfig();
+    },
+    'channels:setConfig': async (_event, args) => {
+      await container.resolve<IChannelsConfigRepo>('channelsConfigRepo').setConfig(args);
+      await applyChannelsConfig(args);
+      return { success: true };
+    },
+    'channels:getStatus': async () => {
+      return getChannelsStatus();
+    },
+    'channels:whatsappLogout': async () => {
+      await logoutWhatsApp();
+      return { success: true };
+    },
     'slack:getConfig': async () => {
       const repo = container.resolve<ISlackConfigRepo>('slackConfigRepo');
       const config = await repo.getConfig();
@@ -1595,6 +1788,11 @@ export function setupIpcHandlers() {
       const notes = await summarizeMeeting(args.transcript, args.meetingStartTime, args.calendarEventJson);
       return { notes };
     },
+    'meeting-prep:resolve': async (_event, args) => {
+      const result = await resolveMeetingPrep(args.attendees);
+      const prepNote = args.eventId ? await readPrepNoteForEvent(args.eventId) : null;
+      return { ...result, prepNote };
+    },
     'inline-task:classifySchedule': async (_event, args) => {
       const schedule = await classifySchedule(args.instruction);
       return { schedule };
@@ -1608,6 +1806,51 @@ export function setupIpcHandlers() {
     'voice:synthesize': async (_event, args) => {
       return voice.synthesizeSpeech(args.text);
     },
+    'voice:synthesizeStreamStart': async (event, args) => {
+      const { requestId, text } = args;
+      const sender = event.sender;
+      const controller = new AbortController();
+      activeTtsStreams.set(requestId, controller);
+      // Fire-and-forget: chunks are pushed to the renderer as they arrive so
+      // playback can begin immediately; the invoke returns once started.
+      void voice
+        .synthesizeSpeechStream(
+          text,
+          (chunk) => {
+            if (!sender.isDestroyed()) {
+              sender.send('voice:tts-chunk', {
+                requestId,
+                chunkBase64: chunk.toString('base64'),
+                done: false,
+              });
+            }
+          },
+          controller.signal,
+        )
+        .then(() => {
+          if (!sender.isDestroyed()) {
+            sender.send('voice:tts-chunk', { requestId, done: true });
+          }
+        })
+        .catch((err: unknown) => {
+          if (!sender.isDestroyed() && !controller.signal.aborted) {
+            sender.send('voice:tts-chunk', {
+              requestId,
+              done: true,
+              error: err instanceof Error ? err.message : String(err),
+            });
+          }
+        })
+        .finally(() => {
+          activeTtsStreams.delete(requestId);
+        });
+      return { ok: true };
+    },
+    'voice:synthesizeStreamCancel': async (_event, args) => {
+      activeTtsStreams.get(args.requestId)?.abort();
+      activeTtsStreams.delete(args.requestId);
+      return {};
+    },
     'voice:ensureMicAccess': async () => {
       if (process.platform !== 'darwin') return { granted: true };
       const status = systemPreferences.getMediaAccessStatus('microphone');
@@ -1626,6 +1869,113 @@ export function setupIpcHandlers() {
         return { granted: false };
       }
     },
+    'voice:ensureCameraAccess': async () => {
+      if (process.platform !== 'darwin') return { granted: true };
+      const status = systemPreferences.getMediaAccessStatus('camera');
+      console.log('[video] Camera permission status:', status);
+      if (status === 'granted') return { granted: true };
+      // Same flow as the microphone: settle the native TCC prompt before the
+      // renderer's getUserMedia so the first video click doesn't silently fail.
+      try {
+        const granted = await systemPreferences.askForMediaAccess('camera');
+        console.log('[video] Camera permission after prompt:', granted);
+        return { granted };
+      } catch {
+        return { granted: false };
+      }
+    },
+    'video:setPopout': async (_event, args) => {
+      if (!args.show) {
+        if (videoPopoutWin && !videoPopoutWin.isDestroyed()) videoPopoutWin.destroy();
+        videoPopoutWin = null;
+        return {};
+      }
+      if (videoPopoutWin && !videoPopoutWin.isDestroyed()) return {};
+
+      const workArea = screen.getPrimaryDisplay().workArea;
+      const width = 340;
+      const height = 184;
+      const ipcDir = path.dirname(fileURLToPath(import.meta.url));
+      const preloadPath = app.isPackaged
+        ? path.join(ipcDir, '../preload/dist/preload.js')
+        : path.join(ipcDir, '../../../preload/dist/preload.js');
+      const win = new BrowserWindow({
+        width,
+        height,
+        x: workArea.x + workArea.width - width - 24,
+        y: workArea.y + 24,
+        frame: false,
+        resizable: false,
+        alwaysOnTop: true,
+        skipTaskbar: true,
+        show: false,
+        hasShadow: true,
+        backgroundColor: '#171717',
+        webPreferences: {
+          nodeIntegration: false,
+          contextIsolation: true,
+          sandbox: true,
+          preload: preloadPath,
+        },
+      });
+      // Float above other apps on every workspace. Deliberately NOT
+      // `visibleOnFullScreen: true`: on macOS that flag hides the app's Dock
+      // icon for as long as such a window exists (the app becomes an
+      // "agent" app), which reads as Rowboat having vanished. The trade-off
+      // is the popout won't hover over other apps' fullscreen Spaces.
+      win.setAlwaysOnTop(true, 'floating');
+      win.setVisibleOnAllWorkspaces(true);
+      win.webContents.once('did-finish-load', () => {
+        if (lastVideoPopoutState) {
+          win.webContents.send('video:popout-state', lastVideoPopoutState);
+        }
+        // showInactive: appearing must not steal focus from the app the user
+        // switched to — that would immediately re-hide the popout.
+        if (!win.isDestroyed()) win.showInactive();
+      });
+      win.on('closed', () => {
+        if (videoPopoutWin === win) videoPopoutWin = null;
+      });
+      videoPopoutWin = win;
+      if (app.isPackaged) {
+        win.loadURL('app://-/index.html#video-popout');
+      } else {
+        win.loadURL('http://localhost:5173/#video-popout');
+      }
+      return {};
+    },
+    'video:popoutState': async (_event, args) => {
+      lastVideoPopoutState = args;
+      if (videoPopoutWin && !videoPopoutWin.isDestroyed()) {
+        videoPopoutWin.webContents.send('video:popout-state', args);
+      }
+      return {};
+    },
+    'app:focusMainWindow': async () => {
+      const main = findMainAppWindow();
+      if (main) {
+        if (main.isMinimized()) main.restore();
+        main.show();
+        main.focus();
+      }
+      return {};
+    },
+    'video:getPopoutState': async () => {
+      return { state: lastVideoPopoutState };
+    },
+    'video:popoutAction': async (_event, args) => {
+      // Relay a popout control-bar action to the app window, which owns the
+      // call (mic, camera, screen capture) and executes it there. 'expand'
+      // additionally brings the app window back to the foreground.
+      const main = findMainAppWindow();
+      if (args.action === 'expand' && main) {
+        if (main.isMinimized()) main.restore();
+        main.show();
+        main.focus();
+      }
+      main?.webContents.send('video:popout-action', args);
+      return {};
+    },
     // Live-note handlers
     'live-note:run': async (_event, args) => {
       const result = await runLiveNoteAgent(args.filePath, 'manual', args.context);
diff --git a/apps/x/apps/main/src/main.ts b/apps/x/apps/main/src/main.ts
index b455bc0e..8e7dfd5a 100644
--- a/apps/x/apps/main/src/main.ts
+++ b/apps/x/apps/main/src/main.ts
@@ -2,7 +2,8 @@ import { app, BrowserWindow, desktopCapturer, protocol, net, shell, session, typ
 import path from "node:path";
 import {
   setupIpcHandlers,
-  startRunsWatcher,
+  startRunsWatcher, startSessionsWatcher,
+  startChannelsWatcher,
   startCodeSessionStatusWatcher,
   startServicesWatcher,
   startLiveNoteAgentWatcher,
@@ -25,8 +26,10 @@ import { init as initEmailLabeling } from "@x/core/dist/knowledge/label_emails.j
 import { init as initNoteTagging } from "@x/core/dist/knowledge/tag_notes.js";
 import { init as initInlineTasks } from "@x/core/dist/knowledge/inline_tasks.js";
 import { init as initAgentRunner } from "@x/core/dist/agent-schedule/runner.js";
+import { init as initChannels } from "@x/core/dist/channels/service.js";
 import { init as initAgentNotes } from "@x/core/dist/knowledge/agent_notes.js";
 import { init as initCalendarNotifications } from "@x/core/dist/knowledge/notify_calendar_meetings.js";
+import { init as initMeetingPrep } from "@x/core/dist/knowledge/meeting_prep_scheduler.js";
 import { init as initLiveNoteScheduler } from "@x/core/dist/knowledge/live-note/scheduler.js";
 import { init as initEventProcessor, registerConsumer } from "@x/core/dist/events/init.js";
 import { liveNoteEventConsumer } from "@x/core/dist/knowledge/live-note/event-consumer.js";
@@ -36,6 +39,7 @@ import { init as initAppsServer, shutdown as shutdownAppsServer } from "@x/core/
 import { registerAppsHostApi } from "@x/core/dist/apps/host-api.js";
 import { shutdown as shutdownAnalytics } from "@x/core/dist/analytics/posthog.js";
 import { identifyIfSignedIn } from "@x/core/dist/analytics/identify.js";
+import { migrateRuns } from "@x/core/dist/migrations/runs/migrate.js";
 
 import { initConfigs } from "@x/core/dist/config/initConfigs.js";
 import { getAgentSlackCliStatus } from "@x/core/dist/slack/agent-slack-exec.js";
@@ -45,6 +49,7 @@ import { execFileSync } from "node:child_process";
 import { init as initChromeSync } from "@x/core/dist/knowledge/chrome-extension/server/server.js";
 import container, { registerBrowserControlService, registerNotificationService } from "@x/core/dist/di/container.js";
 import type { CodeModeManager } from "@x/core/dist/code-mode/acp/manager.js";
+import type { ISessions } from "@x/core/dist/sessions/index.js";
 import { browserViewManager, BROWSER_PARTITION } from "./browser/view.js";
 import { setupBrowserEventForwarding } from "./browser/ipc.js";
 import { ElectronBrowserControlService } from "./browser/control-service.js";
@@ -388,6 +393,37 @@ app.whenReady().then(async () => {
   // start runs watcher
   startRunsWatcher();
 
+  // One-time: port legacy runs/*.jsonl into the new turn/session runtime.
+  // Must run BEFORE the session index is built so migrated sessions are picked
+  // up by the startup scan. Fully defensive — never blocks boot.
+  try {
+    const migration = migrateRuns();
+    if (migration.scanned > 0) {
+      console.log(
+        `[runs-migration] migrated ${migration.migratedTurns} turn(s) across ` +
+        `${migration.migratedSessions} session(s) from ${migration.scanned} run(s) ` +
+        `(${migration.skipped} skipped, ${migration.failed.length} failed)`,
+      );
+      for (const failure of migration.failed) {
+        console.warn(`[runs-migration] left in place (failed): ${failure.file} — ${failure.error}`);
+      }
+    }
+  } catch (error) {
+    console.error('[runs-migration] pass failed:', error);
+  }
+
+  // New runtime: build the in-memory session index (startup scan) before the
+  // renderer can list sessions, then forward the session bus to windows.
+  await container.resolve<ISessions>('sessions').initialize();
+  startSessionsWatcher();
+
+  // Mobile channels (WhatsApp/Telegram bridge): needs the session index, so
+  // start after initialize(). Failures must never block boot.
+  startChannelsWatcher();
+  initChannels().catch((error) => {
+    console.error('[Channels] Failed to start mobile channels:', error);
+  });
+
   // start code-session status tracker (derives working/needs-you/idle + notifications)
   startCodeSessionStatusWatcher();
 
@@ -451,6 +487,9 @@ app.whenReady().then(async () => {
   // start calendar meeting notification service (fires 1-minute warnings)
   initCalendarNotifications();
 
+  // start meeting prep scheduler (generates prep notes ~6h before a meeting)
+  void initMeetingPrep();
+
   // start chrome extension sync server
   initChromeSync();
 
diff --git a/apps/x/apps/renderer/package.json b/apps/x/apps/renderer/package.json
index eec078d6..0a8c9f9f 100644
--- a/apps/x/apps/renderer/package.json
+++ b/apps/x/apps/renderer/package.json
@@ -6,7 +6,9 @@
     "dev": "vite",
     "build": "tsc -b && vite build",
     "lint": "eslint .",
-    "preview": "vite preview"
+    "preview": "vite preview",
+    "test": "vitest run",
+    "test:watch": "vitest"
   },
   "dependencies": {
     "@codemirror/language": "^6.12.3",
@@ -83,6 +85,9 @@
   },
   "devDependencies": {
     "@eslint/js": "^9.39.1",
+    "@testing-library/dom": "^10.4.1",
+    "@testing-library/jest-dom": "^6.9.1",
+    "@testing-library/react": "^16.3.2",
     "@types/node": "^24.10.1",
     "@types/react": "^19.2.5",
     "@types/react-dom": "^19.2.3",
@@ -91,9 +96,11 @@
     "eslint-plugin-react-hooks": "^7.0.1",
     "eslint-plugin-react-refresh": "^0.4.24",
     "globals": "^16.5.0",
+    "jsdom": "^29.1.1",
     "tw-animate-css": "^1.4.0",
     "typescript": "~5.9.3",
     "typescript-eslint": "^8.46.4",
-    "vite": "^7.2.4"
+    "vite": "^7.2.4",
+    "vitest": "catalog:"
   }
 }
diff --git a/apps/x/apps/renderer/scripts/generate-tour-audio.mjs b/apps/x/apps/renderer/scripts/generate-tour-audio.mjs
new file mode 100644
index 00000000..26d1535a
--- /dev/null
+++ b/apps/x/apps/renderer/scripts/generate-tour-audio.mjs
@@ -0,0 +1,62 @@
+/**
+ * Regenerates the bundled product-tour narration clips.
+ *
+ * Parses the TOUR_STEPS texts straight out of product-tour.tsx (so the code
+ * stays the single source of truth), synthesizes each one via @x/core's
+ * synthesizeSpeech (Rowboat proxy when signed in, direct ElevenLabs otherwise,
+ * using the voice id configured there / in ~/.rowboat/config/elevenlabs.json),
+ * and writes MP3s to src/assets/tour/<step-id>.mp3.
+ *
+ * Run whenever a step's narration text or the tour voice changes:
+ *   cd apps/x && npm run deps   # script imports core's built output
+ *   node apps/renderer/scripts/generate-tour-audio.mjs
+ *
+ * Pass step ids to regenerate only those clips (e.g. to re-roll one whose
+ * synthesis came out glitchy):
+ *   node apps/renderer/scripts/generate-tour-audio.mjs welcome done
+ */
+import { mkdir, readFile, writeFile } from 'node:fs/promises'
+import path from 'node:path'
+import { fileURLToPath } from 'node:url'
+
+const here = path.dirname(fileURLToPath(import.meta.url))
+const tourSource = path.join(here, '../src/components/product-tour.tsx')
+const outDir = path.join(here, '../src/assets/tour')
+const corePath = path.join(here, '../../../packages/core/dist/voice/voice.js')
+
+const { synthesizeSpeech } = await import(corePath)
+
+const src = await readFile(tourSource, 'utf8')
+const start = src.indexOf('const TOUR_STEPS')
+const end = src.indexOf('\n]', start)
+if (start === -1 || end === -1) throw new Error('Could not locate TOUR_STEPS in product-tour.tsx')
+const block = src.slice(start, end)
+
+const steps = []
+// voiceText, when present, is the spoken variant of the bubble text.
+const re = /id: '([^']+)'[\s\S]*?text:\s*("[^"]*"|'[^']*')(?:,\s*voiceText:\s*("[^"]*"|'[^']*'))?/g
+for (let m; (m = re.exec(block)); ) {
+    // The captures are JS string literals from our own source; evaluate them
+    // to resolve the quoting.
+    steps.push({ id: m[1], text: new Function(`return ${m[3] ?? m[2]}`)() })
+}
+if (steps.length === 0) throw new Error('Parsed zero tour steps — regex out of sync with product-tour.tsx?')
+console.log(`Parsed ${steps.length} tour steps`)
+
+const only = process.argv.slice(2)
+if (only.length > 0) {
+    const unknown = only.filter((id) => !steps.some((s) => s.id === id))
+    if (unknown.length > 0) throw new Error(`Unknown step ids: ${unknown.join(', ')}`)
+    steps.splice(0, steps.length, ...steps.filter((s) => only.includes(s.id)))
+    console.log(`Regenerating only: ${only.join(', ')}`)
+}
+
+await mkdir(outDir, { recursive: true })
+for (const step of steps) {
+    process.stdout.write(`synthesizing ${step.id}... `)
+    const { audioBase64 } = await synthesizeSpeech(step.text)
+    const file = path.join(outDir, `${step.id}.mp3`)
+    await writeFile(file, Buffer.from(audioBase64, 'base64'))
+    console.log(`${(audioBase64.length * 0.75 / 1024).toFixed(0)} KB`)
+}
+console.log(`Done — ${steps.length} clips in ${path.relative(process.cwd(), outDir)}`)
diff --git a/apps/x/apps/renderer/src/App.css b/apps/x/apps/renderer/src/App.css
index bdb1430f..d9dff562 100644
--- a/apps/x/apps/renderer/src/App.css
+++ b/apps/x/apps/renderer/src/App.css
@@ -169,6 +169,25 @@
   color: var(--gm-placeholder);
 }
 
+.gmail-search-clear {
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  width: 20px;
+  height: 20px;
+  border: none;
+  border-radius: 4px;
+  background: transparent;
+  color: var(--gm-text-muted);
+  cursor: pointer;
+  transition: background 120ms ease, color 120ms ease;
+}
+
+.gmail-search-clear:hover {
+  background: var(--gm-icon-hover-bg);
+  color: var(--gm-text);
+}
+
 .gmail-icon-button {
   display: inline-flex;
   align-items: center;
@@ -205,6 +224,46 @@
   flex-direction: column;
 }
 
+/* Native list virtualization: offscreen rows skip layout and paint entirely.
+   Applied only to rows without a mounted ThreadDetail (those hold iframes and
+   composers, which must keep rendering while offscreen). */
+.gmail-row-group-cv {
+  content-visibility: auto;
+  contain-intrinsic-size: auto 40px;
+}
+
+/* While the list is scrolling, rows ignore the pointer so hover restyles and
+   prefetch timers don't compete with frame rendering. */
+.gmail-shell[data-scrolling] .gmail-row-shell {
+  pointer-events: none;
+}
+
+/* Archived/trashed rows slide out and collapse before removal. Removing the
+   class (failed action) snaps the row back. */
+.gmail-row-group-leaving {
+  overflow: hidden;
+  pointer-events: none;
+  animation: gmail-row-leave 160ms ease-in forwards;
+}
+
+@keyframes gmail-row-leave {
+  0% {
+    opacity: 1;
+    transform: translateX(0);
+    max-height: 48px;
+  }
+  60% {
+    opacity: 0;
+    transform: translateX(32px);
+    max-height: 48px;
+  }
+  100% {
+    opacity: 0;
+    transform: translateX(32px);
+    max-height: 0;
+  }
+}
+
 .gmail-list-header {
   position: sticky;
   top: 0;
@@ -319,6 +378,20 @@
   background: var(--gm-bg-row-selected-hover);
 }
 
+/* The j/k keyboard cursor. Declared after the hover rules (same specificity)
+   so the focus ring survives hovering the focused row. */
+.gmail-row-focused,
+.gmail-row-focused:hover {
+  background: var(--gm-bg-row-hover);
+  box-shadow: inset 0 0 0 1px var(--gm-accent);
+}
+
+.gmail-row-selected.gmail-row-focused,
+.gmail-row-selected.gmail-row-focused:hover {
+  background: var(--gm-bg-row-selected);
+  box-shadow: inset 2px 0 0 var(--gm-accent), inset 0 0 0 1px var(--gm-accent);
+}
+
 .gmail-row-unread {
   color: var(--gm-text);
 }
@@ -394,12 +467,50 @@
   border-top: 1px solid var(--gm-border);
   border-bottom: 1px solid var(--gm-border);
   box-shadow: inset 2px 0 0 var(--gm-accent);
+  /* Replays whenever the detail is shown — hidden details are display: none,
+     so un-hiding restarts the animation. */
+  animation: gmail-detail-open 140ms ease-out;
 }
 
 .gmail-detail-hidden {
   display: none;
 }
 
+@keyframes gmail-detail-open {
+  from {
+    opacity: 0;
+    transform: translateY(-6px);
+  }
+  to {
+    opacity: 1;
+    transform: none;
+  }
+}
+
+/* The inline reply/forward composer pops in from below the thread. */
+.gmail-compose-inline {
+  animation: gmail-compose-open 140ms ease-out;
+}
+
+@keyframes gmail-compose-open {
+  from {
+    opacity: 0;
+    transform: translateY(8px);
+  }
+  to {
+    opacity: 1;
+    transform: none;
+  }
+}
+
+@media (prefers-reduced-motion: reduce) {
+  .gmail-detail-inline,
+  .gmail-compose-inline,
+  .gmail-row-group-leaving {
+    animation: none;
+  }
+}
+
 .gmail-detail-toolbar {
   display: flex;
   align-items: center;
@@ -1017,6 +1128,17 @@
     var(--rowboat-shadow);
 }
 
+.dark .rowboat-code-chat-input {
+  border-color: color-mix(in oklab, var(--border) 76%, transparent);
+  background: #000000;
+  box-shadow: none;
+}
+
+.dark .rowboat-code-chat-input:focus-within {
+  border-color: color-mix(in oklab, var(--ring) 70%, var(--border) 30%);
+  box-shadow: 0 0 0 1px color-mix(in oklab, var(--ring) 30%, transparent);
+}
+
 [data-slot="message-content"] {
   line-height: 1.62;
 }
diff --git a/apps/x/apps/renderer/src/App.tsx b/apps/x/apps/renderer/src/App.tsx
index 5d657371..6d4765e1 100644
--- a/apps/x/apps/renderer/src/App.tsx
+++ b/apps/x/apps/renderer/src/App.tsx
@@ -1,7 +1,7 @@
 import * as React from 'react'
 import { useCallback, useEffect, useLayoutEffect, useState, useRef } from 'react'
 import { workspace } from '@x/shared';
-import { RunEvent, ListRunsResponse } from '@x/shared/src/runs.js';
+import { RunEvent } from '@x/shared/src/runs.js';
 import type { LanguageModelUsage, ToolUIPart } from 'ai';
 import './App.css'
 import z from 'zod';
@@ -9,9 +9,10 @@ import { CheckIcon, LoaderIcon, PanelLeftIcon, ArrowLeft, ArrowRight, MessageSqu
 import { cn } from '@/lib/utils';
 import { MarkdownEditor, type MarkdownEditorHandle } from './components/markdown-editor';
 import { ChatSidebar } from './components/chat-sidebar';
+import { useSessionChat } from '@/hooks/useSessionChat';
 import { ChatHeader } from './components/chat-header';
 import { ChatEmptyState } from './components/chat-empty-state';
-import { ChatInputWithMentions, type PermissionMode, type StagedAttachment } from './components/chat-input-with-mentions';
+import { ChatInputWithMentions, type CallPreset, type PermissionMode, type StagedAttachment } from './components/chat-input-with-mentions';
 import { ChatMessageAttachments } from '@/components/chat-message-attachments'
 import { GraphView, type GraphEdge, type GraphNode } from '@/components/graph-view';
 import { BasesView, type BaseConfig, DEFAULT_BASE_CONFIG } from '@/components/bases-view';
@@ -119,15 +120,18 @@ import { AgentScheduleConfig } from '@x/shared/dist/agent-schedule.js'
 import { AgentScheduleState } from '@x/shared/dist/agent-schedule-state.js'
 import { toast } from "sonner"
 import { useVoiceMode } from '@/hooks/useVoiceMode'
+import { useVideoMode } from '@/hooks/useVideoMode'
 import { useVoiceTTS } from '@/hooks/useVoiceTTS'
+import { VideoCallView } from '@/components/video-call-view'
+import { ProductTour, type TourNavTarget } from '@/components/product-tour'
 import { useMeetingTranscription, type CalendarEventMeta } from '@/hooks/useMeetingTranscription'
 import { useAnalyticsIdentity } from '@/hooks/useAnalyticsIdentity'
 import * as analytics from '@/lib/analytics'
+import { playAckCue } from '@/lib/call-sounds'
 import { useTheme } from '@/contexts/theme-context'
 
 type DirEntry = z.infer<typeof workspace.DirEntry>
 type RunEventType = z.infer<typeof RunEvent>
-type ListRunsResponseType = z.infer<typeof ListRunsResponse>
 
 interface TreeNode extends DirEntry {
   children?: TreeNode[]
@@ -945,6 +949,10 @@ function App() {
   }, [conversation])
   const [, setModelUsage] = useState<LanguageModelUsage | null>(null)
   const [runId, setRunId] = useState<string | null>(null)
+  // New runtime: the active session's chat data + actions. All logic lives in
+  // SessionChatStore (tested headlessly); the hook is a thin subscription.
+  // runId IS the session id in the sessions runtime.
+  const sessionChat = useSessionChat(runId)
   const runIdRef = useRef<string | null>(null)
   const loadRunRequestIdRef = useRef(0)
   const [isProcessing, setIsProcessing] = useState(false)
@@ -952,17 +960,39 @@ function App() {
   const processingRunIdsRef = useRef<Set<string>>(new Set())
   const streamingBuffersRef = useRef<Map<string, { assistant: string }>>(new Map())
   const [isStopping, setIsStopping] = useState(false)
-  const [stopClickedAt, setStopClickedAt] = useState<number | null>(null)
+  const [, setStopClickedAt] = useState<number | null>(null)
+  // Sessions runtime: hook-derived activity for the ACTIVE chat.
+  // activeIsProcessing blocks the composer until the turn settles;
+  // activeIsThinking ("actively working") drives shimmers and disables
+  // permission/ask-human buttons — false while waiting on the user.
+  const activeIsProcessing = sessionChat.chatState?.isProcessing ?? isProcessing
+  const activeIsThinking = sessionChat.chatState ? sessionChat.chatState.isThinking : isProcessing
+  // A failed session load must be visible, not a blank chat.
+  const sessionLoadErrorItems = React.useMemo<ConversationItem[]>(() => (
+    sessionChat.error
+      ? [{ id: 'session-load-error', kind: 'error', message: `Failed to load chat: ${sessionChat.error}`, timestamp: 0 }]
+      : []
+  ), [sessionChat.error])
   const [agentId] = useState<string>('copilot')
   const [presetMessage, setPresetMessage] = useState<string | undefined>(undefined)
 
   // Voice mode state
   const [voiceAvailable, setVoiceAvailable] = useState(false)
   const [ttsAvailable, setTtsAvailable] = useState(false)
-  const [ttsEnabled, setTtsEnabled] = useState(false)
+  // TTS plays only during calls now (the standing read-aloud toggle was
+  // retired; a per-message "read aloud" action may replace it later).
   const ttsEnabledRef = useRef(false)
-  const [ttsMode, setTtsMode] = useState<'summary' | 'full'>('summary')
+  // Voice-to-voice latency marks for the current call turn (performance.now):
+  // t0 = utterance accepted, submit = message sent, speak = first TTS
+  // speak(). Emitted as call_turn_latency when audio actually starts.
+  const callTurnMarksRef = useRef<{ t0: number; submit?: number; speak?: number } | null>(null)
+  // Late-bound handle to handleStop (defined much further down) so early
+  // call handlers can stop the run without reordering the component.
+  const stopRunRef = useRef<(() => Promise<void>) | null>(null)
+  // Read-aloud style: 'summary' for typed chat, forced to 'full' during a
+  // call and restored after. Context decides — the user never picks it.
   const ttsModeRef = useRef<'summary' | 'full'>('summary')
+  const [tourActive, setTourActive] = useState(false)
   const [isRecording, setIsRecording] = useState(false)
   const voiceTextBufferRef = useRef('')
   const spokenIndexRef = useRef(0)
@@ -972,10 +1002,71 @@ function App() {
   const ttsRef = useRef(tts)
   ttsRef.current = tts
 
+  // Latest assistant line handed to TTS — shown as the caption in the
+  // full-screen call view while the assistant is speaking.
+  const [assistantCaption, setAssistantCaption] = useState('')
+  useEffect(() => {
+    if (tts.state === 'idle') setAssistantCaption('')
+  }, [tts.state])
+
+  // Speak newly completed <voice> blocks from the new runtime's live stream
+  // (parity with the legacy text-delta voice extraction below). The store
+  // accumulates completed blocks in chatState.voiceSegments; we speak only
+  // segments that appeared after the current session became active.
+  const spokenVoiceRef = useRef<{ key: string | null; count: number }>({ key: null, count: 0 })
+  const voiceSegments = sessionChat.chatState?.voiceSegments
+  useEffect(() => {
+    if (!voiceSegments) return
+    if (spokenVoiceRef.current.key !== runId) {
+      // Session switch: skip anything already streamed before we arrived.
+      spokenVoiceRef.current = { key: runId, count: voiceSegments.length }
+      return
+    }
+    while (spokenVoiceRef.current.count < voiceSegments.length) {
+      const segment = voiceSegments[spokenVoiceRef.current.count]
+      spokenVoiceRef.current.count += 1
+      if (ttsEnabledRef.current) {
+        const marks = callTurnMarksRef.current
+        if (marks && marks.speak === undefined) marks.speak = performance.now()
+        ttsRef.current.speak(segment)
+        setAssistantCaption(segment)
+      }
+    }
+  }, [voiceSegments, runId])
+
+  // Emit the turn's voice-to-voice latency breakdown once audio is audible.
+  useEffect(() => {
+    if (tts.state !== 'speaking') return
+    const marks = callTurnMarksRef.current
+    if (!marks || marks.submit === undefined || marks.speak === undefined) return
+    callTurnMarksRef.current = null
+    const now = performance.now()
+    analytics.callTurnLatency({
+      endpointToSubmitMs: marks.submit - marks.t0,
+      submitToSpeakMs: marks.speak - marks.submit,
+      speakToAudioMs: now - marks.speak,
+      totalMs: now - marks.t0,
+    })
+  }, [tts.state])
+
   const voice = useVoiceMode()
   const voiceRef = useRef(voice)
   voiceRef.current = voice
 
+  // Calls: one engine (hands-free voice loop + forced read-aloud TTS + frame
+  // capture), started via presets that only differ in device defaults. The
+  // presentation is DERIVED from devices, never picked: screen sharing →
+  // floating popout; camera on → full-screen call; camera off → popout
+  // (mascot pill). Handlers live below the voice/submit plumbing they drive.
+  const video = useVideoMode()
+  const [inCall, setInCall] = useState(false)
+  const inCallRef = useRef(false)
+  // User explicitly shrank the full-screen call to the floating pill.
+  const [callMinimized, setCallMinimized] = useState(false)
+  // Practice preset: adds the coaching persona to the system prompt.
+  const [practiceMode, setPracticeMode] = useState(false)
+  const practiceModeRef = useRef(false)
+
   const handleToggleMeetingRef = useRef<(() => void) | undefined>(undefined)
   const meetingTranscription = useMeetingTranscription(() => {
     handleToggleMeetingRef.current?.()
@@ -1034,6 +1125,8 @@ function App() {
   }, [])
 
   const handleStartRecording = useCallback(() => {
+    // A live call owns the mic — ignore push-to-talk while one is running.
+    if (inCallRef.current) return
     setIsRecording(true)
     isRecordingRef.current = true
     voice.start()
@@ -1047,8 +1140,9 @@ function App() {
   const editorRefsByTabId = useRef<Map<string, MarkdownEditorHandle>>(new Map())
   const [pendingPaletteSubmit, setPendingPaletteSubmit] = useState<{ text: string; mention: CommandPaletteMention | null } | null>(null)
 
-  const handleSubmitRecording = useCallback(() => {
-    const text = voice.submit()
+  const handleSubmitRecording = useCallback(async () => {
+    if (!isRecordingRef.current) return
+    const text = await voice.submit()
     setIsRecording(false)
     isRecordingRef.current = false
     if (text) {
@@ -1057,28 +1151,207 @@ function App() {
     }
   }, [voice])
 
-  const handleToggleTts = useCallback(() => {
-    setTtsEnabled(prev => {
-      const next = !prev
-      ttsEnabledRef.current = next
-      if (!next) {
-        ttsRef.current.cancel()
-      }
-      return next
-    })
-  }, [])
-
-  const handleTtsModeChange = useCallback((mode: 'summary' | 'full') => {
-    setTtsMode(mode)
-    ttsModeRef.current = mode
-  }, [])
-
   const handleCancelRecording = useCallback(() => {
     voice.cancel()
     setIsRecording(false)
     isRecordingRef.current = false
   }, [voice])
 
+  // Start a call. Presets only differ in device defaults — the engine
+  // (continuous listening, auto-submitted utterances, forced read-aloud TTS,
+  // frame capture) is identical for all of them. The default entry ('share',
+  // the call button's main click) is "work together": screen shared, camera
+  // off, floating pill — the user keeps working while the assistant watches
+  // along. 'video'/'practice' open face-to-face full screen instead.
+  const startCall = useCallback(async (preset: CallPreset) => {
+    if (inCallRef.current) return
+    const camera = preset === 'video' || preset === 'practice'
+    const ok = await video.start({ camera })
+    if (!ok) return // camera denied/unavailable — stay out of the call
+    if (preset === 'share') {
+      // If screen capture fails (usually the macOS Screen Recording
+      // permission), continue as a voice call — sharing is one tap away on
+      // the pill once permission is granted.
+      const shared = await video.startScreenShare()
+      if (!shared) {
+        toast("Couldn't share your screen", {
+          description: 'Grant Rowboat Screen Recording access, then tap the share button on the call.',
+          action: {
+            label: 'Open Settings',
+            onClick: () => void window.ipc.invoke('meeting:openScreenRecordingSettings', null).catch(() => {}),
+          },
+        })
+      }
+    }
+
+    // A manual push-to-talk recording can't coexist with the call's mic.
+    if (isRecordingRef.current) {
+      voiceRef.current.cancel()
+      setIsRecording(false)
+      isRecordingRef.current = false
+    }
+    ttsEnabledRef.current = true
+    ttsModeRef.current = 'full'
+    void voiceRef.current.startContinuous((text) => {
+      // Instant "heard you" feedback + start of the latency clock.
+      playAckCue()
+      callTurnMarksRef.current = { t0: performance.now() }
+      pendingVoiceInputRef.current = true
+      handlePromptSubmitRef.current?.({ text, files: [] })
+    })
+
+    setPracticeMode(preset === 'practice')
+    practiceModeRef.current = preset === 'practice'
+    // Pill-first presets start minimized; face-to-face presets start expanded.
+    setCallMinimized(preset === 'voice' || preset === 'share')
+    inCallRef.current = true
+    setInCall(true)
+    analytics.callStarted(preset)
+  }, [video])
+
+  const endCall = useCallback(() => {
+    if (!inCallRef.current) return
+    voiceRef.current.cancel()
+    ttsEnabledRef.current = false
+    ttsModeRef.current = 'summary'
+    ttsRef.current.cancel()
+    callTurnMarksRef.current = null
+    video.stop()
+    setPracticeMode(false)
+    practiceModeRef.current = false
+    setCallMinimized(false)
+    inCallRef.current = false
+    setInCall(false)
+  }, [video])
+
+  // During a call, mute the mic while the assistant is thinking or speaking
+  // so its own TTS (or a half-turn) never gets transcribed back at it.
+  useEffect(() => {
+    if (!inCall) return
+    voiceRef.current.setPaused(activeIsProcessing || tts.state !== 'idle')
+  }, [inCall, activeIsProcessing, tts.state])
+
+  // Screen sharing: frames of the shared screen ride along with each message
+  // next to the webcam frames. The surface change (full screen → pill) falls
+  // out of the derivation below.
+  const handleToggleScreenShare = useCallback(async () => {
+    if (video.screenState === 'live') {
+      video.stopScreenShare()
+    } else {
+      await video.startScreenShare()
+    }
+  }, [video])
+
+  // Meet-style camera mute: the call (and any screen share) stays on, but no
+  // webcam frames are captured while the camera is off. Deliberately does NOT
+  // change the surface — turning your camera on from the pill puts your video
+  // IN the pill; expanding to full screen is its own explicit action.
+  const handleToggleCamera = useCallback(() => {
+    void video.setCameraEnabled(!video.cameraOn)
+  }, [video])
+
+  // Minimizing the full-screen call drops you back to working — and the pill
+  // exists to work *together*, so sharing starts automatically (the symmetric
+  // twin of expand, which stops it). If capture fails (permission), the call
+  // still minimizes as a plain pill. `callMinimized` is also set so stopping
+  // the share from the pill keeps you in the pill rather than snapping back
+  // to full screen.
+  const handleMinimizeCall = useCallback(async () => {
+    setCallMinimized(true)
+    await video.startScreenShare()
+  }, [video])
+
+  // Interrupt the assistant: silence TTS immediately, skip anything already
+  // queued from the in-flight turn, and stop the run if it's still
+  // generating (if it already finished, stopping the speech is all there is
+  // to do). Wired to the Stop control next to the mascot on both surfaces.
+  const handleInterruptAssistant = useCallback(() => {
+    ttsRef.current.cancel()
+    setAssistantCaption('')
+    if (voiceSegments) {
+      spokenVoiceRef.current.count = voiceSegments.length
+    }
+    if (activeIsProcessing) {
+      void stopRunRef.current?.()
+    }
+  }, [voiceSegments, activeIsProcessing])
+
+  // Current phase of the call (null when not in one).
+  const videoCallStatus: 'listening' | 'thinking' | 'speaking' | null =
+    inCall
+      ? tts.state === 'speaking'
+        ? 'speaking'
+        : tts.state === 'synthesizing' || activeIsProcessing
+          ? 'thinking'
+          : 'listening'
+      : null
+
+  // The call's surface follows one rule: full screen and screen sharing are
+  // mutually exclusive (a full-screen call covers the screen — sharing it
+  // would show the call itself). Sharing → floating pill, always. Not
+  // sharing → full screen unless the user shrank it (`callMinimized`).
+  // Expanding the pill auto-stops any share; presenting from full screen
+  // auto-collapses to the pill.
+  const callSurface: 'fullscreen' | 'popout' | null = !inCall
+    ? null
+    : video.screenState === 'live' || callMinimized
+      ? 'popout'
+      : 'fullscreen'
+
+  useEffect(() => {
+    void window.ipc.invoke('video:setPopout', { show: callSurface === 'popout' }).catch(() => {})
+  }, [callSurface])
+
+  // Consent surface for screen sharing: an unmissable toast the moment any
+  // share starts (auto-started calls included), with one-tap stop. The pill
+  // also carries a persistent "Sharing screen" badge, and macOS shows its
+  // purple recording indicator.
+  const prevScreenStateRef = useRef(video.screenState)
+  useEffect(() => {
+    const prev = prevScreenStateRef.current
+    prevScreenStateRef.current = video.screenState
+    if (video.screenState === 'live' && prev !== 'live') {
+      toast('Your screen is being shared', {
+        description: 'The assistant sees snapshots of it along with what you say.',
+        action: { label: 'Stop sharing', onClick: () => video.stopScreenShare() },
+        duration: 6000,
+      })
+    }
+  }, [video.screenState, video])
+
+  // Keep the popout's mascot/status/devices/caption mirror of the call fresh.
+  // The main process caches the latest state and replays it when the popout
+  // loads.
+  useEffect(() => {
+    if (!inCall) return
+    void window.ipc
+      .invoke('video:popoutState', {
+        ttsState: tts.state,
+        status: videoCallStatus,
+        cameraOn: video.cameraOn,
+        screenSharing: video.screenState === 'live',
+        interimText: voice.interimText || null,
+      })
+      .catch(() => {})
+  }, [inCall, tts.state, videoCallStatus, video.cameraOn, video.screenState, voice.interimText])
+
+  // Execute popout control-bar actions (the popout window has no access to
+  // the call's mic/camera/capture — they live here). 'expand' goes full
+  // screen, which by the exclusivity rule stops any running share; the main
+  // process already refocused the app window.
+  useEffect(() => {
+    return window.ipc.on('video:popout-action', ({ action }) => {
+      if (action === 'toggle-camera') handleToggleCamera()
+      else if (action === 'toggle-share') void handleToggleScreenShare()
+      else if (action === 'stop-speaking') handleInterruptAssistant()
+      else if (action === 'end-call') endCall()
+      else if (action === 'expand') {
+        if (video.screenState === 'live') video.stopScreenShare()
+        setCallMinimized(false)
+      }
+    })
+  }, [handleToggleCamera, handleToggleScreenShare, handleInterruptAssistant, endCall, video])
+
   // Enter to submit voice input, Escape to cancel
   useEffect(() => {
     const handleKeyDown = (e: KeyboardEvent) => {
@@ -1967,21 +2240,16 @@ function App() {
   // Load runs list (all pages)
   const loadRuns = useCallback(async () => {
     try {
-      const allRuns: RunListItem[] = []
-      let cursor: string | undefined = undefined
-
-      // Fetch all pages
-      do {
-        const result: ListRunsResponseType = await window.ipc.invoke('runs:list', { cursor })
-        allRuns.push(...result.runs)
-        cursor = result.nextCursor
-      } while (cursor)
-
-      // Filter for copilot chats only (Code-section sessions live in the Code view)
-      const copilotRuns = allRuns.filter((run: RunListItem) => run.agentId === 'copilot' && run.useCase !== 'code_session')
-      setRuns(copilotRuns)
+      const { sessions } = await window.ipc.invoke('sessions:list', {})
+      setRuns(sessions.map((entry) => ({
+        id: entry.sessionId,
+        title: entry.title ?? 'New chat',
+        createdAt: entry.createdAt,
+        modifiedAt: entry.updatedAt,
+        agentId: entry.lastAgentId ?? 'copilot',
+      })))
     } catch (err) {
-      console.error('Failed to load runs:', err)
+      console.error('Failed to load sessions:', err)
     }
   }, [])
 
@@ -2083,193 +2351,30 @@ function App() {
     }
   }, [backgroundTasks, loadBackgroundTasks])
 
-  // Load a specific run and populate conversation
+  // Switch the active session. The useSessionChat hook loads and follows the
+  // conversation; this only resets composer/tab state.
   const loadRun = useCallback(async (id: string) => {
     const requestId = (loadRunRequestIdRef.current += 1)
+    setConversation([])
+    setCurrentAssistantMessage('')
+    setRunId(id)
+    setMessage('')
+    setIsProcessing(false)
+    setIsStopping(false)
+    setStopClickedAt(null)
+    setPendingPermissionRequests(new Map())
+    setPendingAskHumanRequests(new Map())
+    setAllPermissionRequests(new Map())
+    setPermissionResponses(new Map())
+    setAutoPermissionDecisions(new Map())
     try {
-      const run = await window.ipc.invoke('runs:fetch', { runId: id })
-      if (loadRunRequestIdRef.current !== requestId) return
-
-      // Parse the log events into conversation items
-      const items: ConversationItem[] = []
-      const toolCallMap = new Map<string, ToolCall>()
-
-      for (const event of run.log) {
-        switch (event.type) {
-          case 'message': {
-            const msg = event.message
-            if (msg.role === 'user' || msg.role === 'assistant') {
-              // Extract text content from message
-              let textContent = ''
-              let msgAttachments: ChatMessage['attachments'] = undefined
-              if (typeof msg.content === 'string') {
-                textContent = msg.content
-              } else if (Array.isArray(msg.content)) {
-                const contentParts = msg.content as Array<{
-                  type: string
-                  text?: string
-                  path?: string
-                  filename?: string
-                  mimeType?: string
-                  size?: number
-                  toolCallId?: string
-                  toolName?: string
-                  arguments?: ToolUIPart['input']
-                }>
-
-                textContent = contentParts
-                  .filter((part) => part.type === 'text')
-                  .map((part) => part.text || '')
-                  .join('')
-
-                const attachmentParts = contentParts.filter((part) => part.type === 'attachment' && part.path)
-                if (attachmentParts.length > 0) {
-                  msgAttachments = attachmentParts.map((part) => ({
-                    path: part.path!,
-                    filename: part.filename || part.path!.split('/').pop() || part.path!,
-                    mimeType: part.mimeType || 'application/octet-stream',
-                    size: part.size,
-                  }))
-                }
-
-                // Also extract tool-call parts from assistant messages
-                if (msg.role === 'assistant') {
-                  for (const part of contentParts) {
-                    if (part.type === 'tool-call' && part.toolCallId && part.toolName) {
-                      const toolCall: ToolCall = {
-                        id: part.toolCallId,
-                        name: part.toolName,
-                        input: normalizeToolInput(part.arguments),
-                        status: 'pending',
-                        timestamp: event.ts ? new Date(event.ts).getTime() : Date.now(),
-                      }
-                      toolCallMap.set(toolCall.id, toolCall)
-                      items.push(toolCall)
-                    }
-                  }
-                }
-              }
-              if (textContent || msgAttachments) {
-                items.push({
-                  id: event.messageId,
-                  role: msg.role,
-                  content: textContent,
-                  attachments: msgAttachments,
-                  timestamp: event.ts ? new Date(event.ts).getTime() : Date.now(),
-                })
-              }
-            }
-            break
-          }
-          case 'tool-invocation': {
-            // Update existing tool call status or create new one
-            const existingTool = event.toolCallId ? toolCallMap.get(event.toolCallId) : null
-            if (existingTool) {
-              existingTool.input = normalizeToolInput(event.input)
-              existingTool.status = 'running'
-            } else {
-              const toolCall: ToolCall = {
-                id: event.toolCallId || `tool-${Date.now()}-${Math.random()}`,
-                name: event.toolName,
-                input: normalizeToolInput(event.input),
-                status: 'running',
-                timestamp: event.ts ? new Date(event.ts).getTime() : Date.now(),
-              }
-              toolCallMap.set(toolCall.id, toolCall)
-              items.push(toolCall)
-            }
-            break
-          }
-          case 'tool-result': {
-            const existingTool = event.toolCallId ? toolCallMap.get(event.toolCallId) : null
-            if (existingTool) {
-              existingTool.result = event.result
-              existingTool.status = 'completed'
-            }
-            break
-          }
-          case 'error': {
-            items.push({
-              id: `error-${Date.now()}-${Math.random()}`,
-              kind: 'error',
-              message: event.error,
-              timestamp: event.ts ? new Date(event.ts).getTime() : Date.now(),
-            })
-            break
-          }
-          case 'llm-stream-event': {
-            // We don't need to reconstruct streaming events for history
-            // Reasoning is captured in the final message
-            break
-          }
-        }
-      }
-      if (loadRunRequestIdRef.current !== requestId) return
-
-      // Track permission requests and responses from history
-      const allPermissionRequests = new Map<string, z.infer<typeof ToolPermissionRequestEvent>>()
-      const permResponseMap = new Map<string, 'approve' | 'deny'>()
-      const autoPermissionDecisions = new Map<string, z.infer<typeof ToolPermissionAutoDecisionEvent>>()
-      const askHumanRequests = new Map<string, z.infer<typeof AskHumanRequestEvent>>()
-      const respondedAskHumanIds = new Set<string>()
-
-      for (const event of run.log) {
-        if (event.type === 'tool-permission-request') {
-          allPermissionRequests.set(event.toolCall.toolCallId, event)
-        } else if (event.type === 'tool-permission-response') {
-          permResponseMap.set(event.toolCallId, event.response)
-        } else if (event.type === 'tool-permission-auto-decision') {
-          autoPermissionDecisions.set(event.toolCallId, event)
-        } else if (event.type === 'ask-human-request') {
-          askHumanRequests.set(event.toolCallId, event)
-        } else if (event.type === 'ask-human-response') {
-          respondedAskHumanIds.add(event.toolCallId)
-        }
-      }
-      if (loadRunRequestIdRef.current !== requestId) return
-
-      // Separate pending vs responded permission requests
-      const pendingPerms = new Map<string, z.infer<typeof ToolPermissionRequestEvent>>()
-      for (const [id, req] of allPermissionRequests.entries()) {
-        if (!permResponseMap.has(id)) {
-          pendingPerms.set(id, req)
-        }
-      }
-
-      const pendingAsks = new Map<string, z.infer<typeof AskHumanRequestEvent>>()
-      for (const [id, req] of askHumanRequests.entries()) {
-        if (!respondedAskHumanIds.has(id)) {
-          pendingAsks.set(id, req)
-        }
-      }
-      if (loadRunRequestIdRef.current !== requestId) return
-
-      // Set the conversation and runId
-      setConversation(items)
-      setRunId(id)
-      setMessage('')
-      // Reconcile composer state with THIS run. Loading a run while another one
-      // is mid-turn (e.g. binding a code session steals the single chat tab)
-      // must not leave isProcessing/isStopping pointing at the old run — that
-      // wedges the composer: stop targets the new run (a no-op) while the old
-      // run's processing-end arrives flagged as non-active and clears nothing.
-      setIsProcessing(processingRunIdsRef.current.has(id))
-      setIsStopping(false)
-      setStopClickedAt(null)
-      setCurrentAssistantMessage(streamingBuffersRef.current.get(id)?.assistant ?? '')
-      setPendingPermissionRequests(pendingPerms)
-      setPendingAskHumanRequests(pendingAsks)
-      setAllPermissionRequests(allPermissionRequests)
-      setPermissionResponses(permResponseMap)
-      setAutoPermissionDecisions(autoPermissionDecisions)
-
-      // Restore the run's per-chat work directory into the tab it was loaded into.
+      // Restore the session's per-chat work directory into the active tab.
       const tabId = activeChatTabIdRef.current
       const wd = await loadRunWorkDir(id)
       if (loadRunRequestIdRef.current !== requestId) return
       setWorkDirByTab((prev) => ({ ...prev, [tabId]: wd }))
     } catch (err) {
-      console.error('Failed to load run:', err)
+      console.error('Failed to load session work dir:', err)
     }
   }, [loadRunWorkDir])
 
@@ -2375,6 +2480,7 @@ function App() {
               console.log('[voice] extracted voice tag:', voiceContent)
               if (voiceContent && ttsEnabledRef.current) {
                 ttsRef.current.speak(voiceContent)
+                setAssistantCaption(voiceContent)
               }
               spokenIndexRef.current += voiceMatch.index + voiceMatch[0].length
             }
@@ -2720,7 +2826,7 @@ function App() {
     codeMode?: 'claude' | 'codex',
     permissionMode?: PermissionMode,
   ) => {
-    if (isProcessing) return
+    if (activeIsProcessing) return
 
     const submitTabId = activeChatTabIdRef.current
     const { text } = message
@@ -2730,15 +2836,33 @@ function App() {
 
     setMessage('')
 
+    // Video chat mode: drain the webcam frames buffered since the last send
+    // so they ride along with this message as inline image parts.
+    const marks = callTurnMarksRef.current
+    if (inCallRef.current && marks && marks.submit === undefined) {
+      marks.submit = performance.now()
+    }
+
+    const videoFrames = inCallRef.current ? video.collectFrames() : []
+
     const userMessageId = `user-${Date.now()}`
-    const displayAttachments: ChatMessage['attachments'] = hasAttachments
-      ? stagedAttachments.map((attachment) => ({
-          path: attachment.path,
-          filename: attachment.filename,
-          mimeType: attachment.mimeType,
-          size: attachment.size,
-          thumbnailUrl: attachment.thumbnailUrl,
-        }))
+    const displayAttachments: ChatMessage['attachments'] = hasAttachments || videoFrames.length > 0
+      ? [
+          ...stagedAttachments.map((attachment) => ({
+            path: attachment.path,
+            filename: attachment.filename,
+            mimeType: attachment.mimeType,
+            size: attachment.size,
+            thumbnailUrl: attachment.thumbnailUrl,
+          })),
+          ...videoFrames.map((frame, index) => ({
+            path: '',
+            filename: `${frame.source}-frame-${index + 1}.jpg`,
+            mimeType: frame.mediaType,
+            thumbnailUrl: frame.dataUrl,
+            isVideoFrame: true,
+          })),
+        ]
       : undefined
     setConversation((prev) => [...prev, {
       id: userMessageId,
@@ -2753,15 +2877,11 @@ function App() {
       let currentRunId = runId
       let isNewRun = false
       let newRunCreatedAt: string | null = null
+      const selected = selectedModelByTabRef.current.get(submitTabId)
       if (!currentRunId) {
-        const selected = selectedModelByTabRef.current.get(submitTabId)
-        const run = await window.ipc.invoke('runs:create', {
-          agentId,
-          ...(selected ? { model: selected.model, provider: selected.provider } : {}),
-          permissionMode: permissionMode ?? 'manual',
-        })
-        currentRunId = run.id
-        newRunCreatedAt = run.createdAt
+        const createdSession = await window.ipc.invoke('sessions:create', {})
+        currentRunId = createdSession.sessionId
+        newRunCreatedAt = new Date().toISOString()
         setRunId(currentRunId)
         analytics.chatSessionCreated(currentRunId)
         // Update active chat tab's runId to the new run
@@ -2780,7 +2900,33 @@ function App() {
       let titleSource = userMessage
       const hasMentions = (mentions?.length ?? 0) > 0
 
-      if (hasAttachments || hasMentions) {
+      // Per-message turn config. Composition inputs land in the system prompt
+      // via the agent resolver; keep them session-sticky where possible so the
+      // provider prefix cache survives across turns.
+      const sendConfig = {
+        agent: {
+          agentId,
+          overrides: {
+            ...(selected ? { model: { provider: selected.provider, model: selected.model } } : {}),
+            composition: {
+              workDirId: currentRunId,
+              ...(pendingVoiceInputRef.current ? { voiceInput: true } : {}),
+              ...(ttsEnabledRef.current ? { voiceOutput: ttsModeRef.current } : {}),
+              ...(searchEnabled ? { searchEnabled: true } : {}),
+              ...(codeMode ? { codeMode } : {}),
+              ...(inCallRef.current && (video.cameraOn || video.screenState === 'live') ? { videoMode: true } : {}),
+              ...(practiceModeRef.current ? { coachMode: true } : {}),
+            },
+          },
+        },
+        autoPermission: (permissionMode ?? 'manual') === 'auto',
+      }
+      const userMessageContextFor = (middlePane: Awaited<ReturnType<typeof buildMiddlePaneContext>>) => ({
+        currentDateTime: new Date().toISOString(),
+        middlePane: middlePane ?? { kind: 'empty' as const },
+      })
+
+      if (hasAttachments || hasMentions || videoFrames.length > 0) {
         type ContentPart =
           | { type: 'text'; text: string }
           | {
@@ -2791,6 +2937,13 @@ function App() {
               size?: number
               lineNumber?: number
             }
+          | {
+              type: 'image'
+              data: string
+              mediaType: string
+              source: 'camera' | 'screen'
+              capturedAt: string
+            }
 
         const contentParts: ContentPart[] = []
 
@@ -2822,17 +2975,25 @@ function App() {
           titleSource = stagedAttachments[0]?.filename ?? mentions?.[0]?.displayName ?? mentions?.[0]?.path ?? ''
         }
 
-        // Shared IPC payload types can lag until package rebuilds; runtime validation still enforces schema.
-        const attachmentPayload = contentParts as unknown as string
+        for (const frame of videoFrames) {
+          contentParts.push({
+            type: 'image',
+            data: frame.data,
+            mediaType: frame.mediaType,
+            source: frame.source,
+            capturedAt: frame.capturedAt,
+          })
+        }
+
         const middlePaneContext = await buildMiddlePaneContext()
-        await window.ipc.invoke('runs:createMessage', {
-          runId: currentRunId,
-          message: attachmentPayload,
-          voiceInput: pendingVoiceInputRef.current || undefined,
-          voiceOutput: ttsEnabledRef.current ? ttsModeRef.current : undefined,
-          searchEnabled: searchEnabled || undefined,
-          codeMode: codeMode || undefined,
-          middlePaneContext,
+        await window.ipc.invoke('sessions:sendMessage', {
+          sessionId: currentRunId,
+          input: {
+            role: 'user',
+            content: contentParts,
+            userMessageContext: userMessageContextFor(middlePaneContext),
+          },
+          config: sendConfig,
         })
         analytics.chatMessageSent({
           voiceInput: pendingVoiceInputRef.current || undefined,
@@ -2841,14 +3002,14 @@ function App() {
         })
       } else {
         const middlePaneContext = await buildMiddlePaneContext()
-        await window.ipc.invoke('runs:createMessage', {
-          runId: currentRunId,
-          message: userMessage,
-          voiceInput: pendingVoiceInputRef.current || undefined,
-          voiceOutput: ttsEnabledRef.current ? ttsModeRef.current : undefined,
-          searchEnabled: searchEnabled || undefined,
-          codeMode: codeMode || undefined,
-          middlePaneContext,
+        await window.ipc.invoke('sessions:sendMessage', {
+          sessionId: currentRunId,
+          input: {
+            role: 'user',
+            content: userMessage,
+            userMessageContext: userMessageContextFor(middlePaneContext),
+          },
+          config: sendConfig,
         })
         analytics.chatMessageSent({
           voiceInput: pendingVoiceInputRef.current || undefined,
@@ -2885,20 +3046,30 @@ function App() {
     handlePromptSubmitRef.current?.({ text: `${name} connected successfully.`, files: [] })
   }, [])
 
+  // The composer's stop state clears when the active turn settles.
+  useEffect(() => {
+    if (sessionChat.chatState && !sessionChat.chatState.isProcessing) {
+      setIsStopping(false)
+      setStopClickedAt(null)
+    }
+  }, [sessionChat.chatState])
+
   const handleStop = useCallback(async () => {
     if (!runId) return
-    const now = Date.now()
-    const isForce = isStopping && stopClickedAt !== null && (now - stopClickedAt) < 2000
-
-    setStopClickedAt(now)
+    setStopClickedAt(Date.now())
     setIsStopping(true)
-
+    // Stopping the run must also silence it — the TTS queue holds segments
+    // that were already extracted from the stream and would keep playing
+    // long after the turn is aborted.
+    ttsRef.current.cancel()
+    setAssistantCaption('')
     try {
-      await window.ipc.invoke('runs:stop', { runId, force: isForce })
+      await sessionChat.stop()
     } catch (error) {
-      console.error('Failed to stop run:', error)
+      console.error('Failed to stop turn:', error)
     }
-  }, [runId, isStopping, stopClickedAt])
+  }, [runId, sessionChat])
+  stopRunRef.current = handleStop
 
   const handlePermissionResponse = useCallback(async (
     toolCallId: string,
@@ -2908,33 +3079,17 @@ function App() {
   ) => {
     if (!runId) return
 
-    // Optimistically update the UI immediately
-    setPermissionResponses(prev => {
-      const next = new Map(prev)
-      next.set(toolCallId, response)
-      return next
-    })
-    setPendingPermissionRequests(prev => {
-      const next = new Map(prev)
-      next.delete(toolCallId)
-      return next
-    })
-
+    void subflow // subflows retired with the runs runtime
     try {
-      await window.ipc.invoke('runs:authorizePermission', {
-        runId,
-        authorization: { subflow, toolCallId, response, scope }
-      })
+      await sessionChat.respondToPermission(
+        toolCallId,
+        response === 'approve' ? 'allow' : 'deny',
+        scope ? { scope } : undefined,
+      )
     } catch (error) {
       console.error('Failed to authorize permission:', error)
-      // Revert the optimistic update on error
-      setPermissionResponses(prev => {
-        const next = new Map(prev)
-        next.delete(toolCallId)
-        return next
-      })
     }
-  }, [runId])
+  }, [runId, sessionChat])
 
   // Answer a mid-run permission request from a code_agent_run coding turn. The
   // pending ask lives on the tool call itself, so we optimistically clear it and
@@ -2958,15 +3113,13 @@ function App() {
 
   const handleAskHumanResponse = useCallback(async (toolCallId: string, subflow: string[], response: string) => {
     if (!runId) return
+    void subflow // subflows retired with the runs runtime
     try {
-      await window.ipc.invoke('runs:provideHumanInput', {
-        runId,
-        reply: { subflow, toolCallId, response }
-      })
+      await sessionChat.answerAskHuman(toolCallId, response)
     } catch (error) {
       console.error('Failed to provide human input:', error)
     }
-  }, [runId])
+  }, [runId, sessionChat])
 
   const dismissBrowserOverlay = useCallback(() => {
     setIsBrowserOpen(false)
@@ -4513,22 +4666,61 @@ function App() {
   // External search set by app-navigation tool (passed to BasesView)
   const [externalBaseSearch, setExternalBaseSearch] = useState<string | undefined>(undefined)
 
-  // Process pending app-navigation results
-  useEffect(() => {
-    const result = pendingAppNavRef.current
-    if (!result) return
-    pendingAppNavRef.current = null
+  // Apply an app-navigation tool result to the UI. Shared by both event
+  // paths (legacy runs:events and the session-chat turn runtime).
+  const applyAppNavigation = useCallback((result: Record<string, unknown>) => {
+    // During a call, navigation must be VISIBLE: the full-screen call view
+    // would cover the very thing being shown — collapse it to the pill —
+    // and if the user is in another app, bring Rowboat forward.
+    const visibleActions = ['open-note', 'open-view', 'read-view', 'open-item', 'update-base-view', 'create-base']
+    if (inCallRef.current && visibleActions.includes(result.action as string)) {
+      setCallMinimized(true)
+      void window.ipc.invoke('app:focusMainWindow', null).catch(() => {})
+    }
+
+    // Views the assistant can open (or auto-open while reading them via
+    // read-view — the user should SEE what's being read).
+    const navigateToNamedView = (view: string) => {
+      switch (view) {
+        case 'graph': void navigateToView({ type: 'graph' }); break
+        case 'bases': void navigateToView({ type: 'file', path: BASES_DEFAULT_TAB_PATH }); break
+        case 'home': void navigateToView({ type: 'home' }); break
+        case 'email': void navigateToView({ type: 'email' }); break
+        case 'meetings': void navigateToView({ type: 'meetings' }); break
+        case 'live-notes': void navigateToView({ type: 'live-notes' }); break
+        case 'bg-tasks': void navigateToView({ type: 'bg-tasks' }); break
+        case 'chat-history': void navigateToView({ type: 'chat-history' }); break
+        case 'knowledge': void navigateToView({ type: 'knowledge-view' }); break
+        case 'workspace': void navigateToView({ type: 'workspace' }); break
+        case 'code': void navigateToView({ type: 'code' }); break
+      }
+    }
 
     switch (result.action) {
       case 'open-note':
         navigateToFile(result.path as string)
         break
       case 'open-view':
-        if (result.view === 'graph') void navigateToView({ type: 'graph' })
-        if (result.view === 'bases') {
-          void navigateToView({ type: 'file', path: BASES_DEFAULT_TAB_PATH })
+      case 'read-view':
+        navigateToNamedView(result.view as string)
+        break
+      case 'open-item': {
+        switch (result.kind) {
+          case 'email-thread':
+            void navigateToView({ type: 'email', threadId: result.threadId as string })
+            break
+          case 'note':
+            navigateToFile(result.path as string)
+            break
+          case 'bg-task':
+            void navigateToView({ type: 'task', name: result.taskName as string })
+            break
+          case 'session':
+            void navigateToView({ type: 'chat', runId: result.sessionId as string })
+            break
         }
         break
+      }
       case 'open-app':
         if (result.appId) {
           setAppInitialId(result.appId as string)
@@ -4615,8 +4807,41 @@ function App() {
         }
         break
     }
+  // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [navigateToFile, navigateToView, selectedPath])
+
+  // Legacy runs:events path: handleRunEvent stashes the result in a ref;
+  // polled every render (the triggering event always causes one).
+  useEffect(() => {
+    const result = pendingAppNavRef.current
+    if (!result) return
+    pendingAppNavRef.current = null
+    applyAppNavigation(result)
   })
 
+  // Turn-runtime path: the session-chat store surfaces tool results in the
+  // conversation; apply newly completed app-navigation calls exactly once.
+  // On session switch/load, everything already in the transcript happened in
+  // the past — seed as processed without replaying navigations.
+  const processedAppNavRef = useRef<{ key: string | null; ids: Set<string> }>({ key: null, ids: new Set() })
+  useEffect(() => {
+    const conversation = sessionChat.chatState?.conversation
+    if (!conversation) return
+    const completed = conversation.filter(
+      (item): item is ToolCall => isToolCall(item) && item.name === 'app-navigation' && item.status === 'completed'
+    )
+    if (processedAppNavRef.current.key !== runId) {
+      processedAppNavRef.current = { key: runId, ids: new Set(completed.map((t) => t.id)) }
+      return
+    }
+    for (const tool of completed) {
+      if (processedAppNavRef.current.ids.has(tool.id)) continue
+      processedAppNavRef.current.ids.add(tool.id)
+      const result = tool.result as Record<string, unknown> | undefined
+      if (result && result.success) applyAppNavigation(result)
+    }
+  }, [sessionChat.chatState?.conversation, runId, applyAppNavigation])
+
   const navigateToFullScreenChat = useCallback(() => {
     // Only treat this as navigation when coming from another view
     if (currentViewState.type !== 'chat') {
@@ -5155,6 +5380,33 @@ function App() {
     },
   }), [tree, selectedPath, isGraphOpen, selectedBackgroundTask, workspaceRoot, navigateToFile, navigateToView, openFileInNewTab, fileTabs, closeFileTab, removeEditorCacheForPath])
 
+  // Drives the mascot product tour through the app's main sections
+  const handleTourNavigate = useCallback((target: TourNavTarget) => {
+    switch (target) {
+      case 'home':
+        void navigateToView({ type: 'home' })
+        break
+      case 'email':
+        openEmailView()
+        break
+      case 'meetings':
+        openMeetingsView()
+        break
+      case 'code':
+        openCodeView()
+        break
+      case 'knowledge':
+        knowledgeActions.openKnowledgeView()
+        break
+      case 'agents':
+        openBgTasksView()
+        break
+      case 'workspaces':
+        knowledgeActions.openWorkspaceAt()
+        break
+    }
+  }, [navigateToView, openEmailView, openMeetingsView, openCodeView, knowledgeActions, openBgTasksView])
+
   // Handler for when a voice note is created/updated
   const handleVoiceNoteCreated = useCallback(async (notePath: string) => {
     // Refresh the tree to show the new file/folder
@@ -5342,6 +5594,20 @@ function App() {
     return () => window.removeEventListener('email-block:draft-with-assistant', handler)
   }, [])
 
+  // Meeting prep: create a person note for an unmatched attendee via Copilot.
+  useEffect(() => {
+    const handler = () => {
+      const pending = window.__pendingMeetingPrepCreate
+      if (pending) {
+        setPresetMessage(pending.prompt)
+        setIsChatSidebarOpen(true)
+        window.__pendingMeetingPrepCreate = undefined
+      }
+    }
+    window.addEventListener('meeting-prep:create-note', handler)
+    return () => window.removeEventListener('meeting-prep:create-note', handler)
+  }, [])
+
   const resolveWikiFilePath = useCallback((wikiPath: string) => {
     const normalized = normalizeWikiPath(wikiPath)
     const { path: basePath } = splitWikiFragment(normalized)
@@ -5677,16 +5943,24 @@ function App() {
     return null
   }
 
-  const activeChatTabState = React.useMemo<ChatTabViewState>(() => ({
-    runId,
-    conversation,
-    currentAssistantMessage,
-    pendingAskHumanRequests,
-    allPermissionRequests,
-    permissionResponses,
-    autoPermissionDecisions,
-  }), [
+  // The active chat's view state, backed by the sessions hook (legacy
+  // standalone states remain only as the pre-load fallback until stage 7).
+  const activeChatTabState = React.useMemo<ChatTabViewState>(() => (
+    sessionChat.chatState
+      ? { runId, ...sessionChat.chatState }
+      : {
+          runId,
+          conversation: sessionLoadErrorItems.length > 0 ? sessionLoadErrorItems : conversation,
+          currentAssistantMessage,
+          pendingAskHumanRequests,
+          allPermissionRequests,
+          permissionResponses,
+          autoPermissionDecisions,
+        }
+  ), [
     runId,
+    sessionChat.chatState,
+    sessionLoadErrorItems,
     conversation,
     currentAssistantMessage,
     pendingAskHumanRequests,
@@ -5699,6 +5973,10 @@ function App() {
     if (tabId === activeChatTabId) return activeChatTabState
     return chatViewStateByTab[tabId] ?? emptyChatTabState
   }, [activeChatTabId, activeChatTabState, chatViewStateByTab, emptyChatTabState])
+  const chatTabStatesForRender = React.useMemo(() => ({
+    ...chatViewStateByTab,
+    [activeChatTabId]: activeChatTabState,
+  }), [chatViewStateByTab, activeChatTabId, activeChatTabState])
   const selectedTask = selectedBackgroundTask
     ? backgroundTasks.find(t => t.name === selectedBackgroundTask)
     : null
@@ -5790,6 +6068,7 @@ function App() {
               onNewChat={handleNewChatTab}
               onToggleBrowser={handleToggleBrowser}
               onVoiceNoteCreated={handleVoiceNoteCreated}
+              onStartTour={() => setTourActive(true)}
               meetingRecordingState={meetingTranscription.state}
               recordingMeetingSource={recordingMeetingSource}
               onToggleMeetingRecording={() => { void handleToggleMeeting() }}
@@ -6107,7 +6386,7 @@ function App() {
                     onSelectRun={(rid) => void navigateToView({ type: 'chat', runId: rid })}
                     onDeleteRun={async (rid) => {
                       try {
-                        await window.ipc.invoke('runs:delete', { runId: rid })
+                        await window.ipc.invoke('sessions:delete', { sessionId: rid })
                         await loadRuns()
                       } catch (err) {
                         console.error('Failed to delete run:', err)
@@ -6406,7 +6685,7 @@ function App() {
                                               onApproveSession={() => handlePermissionResponse(permRequest.toolCall.toolCallId, permRequest.subflow, 'approve', 'session')}
                                               onApproveAlways={() => handlePermissionResponse(permRequest.toolCall.toolCallId, permRequest.subflow, 'approve', 'always')}
                                               onDeny={() => handlePermissionResponse(permRequest.toolCall.toolCallId, permRequest.subflow, 'deny')}
-                                              isProcessing={isActive && isProcessing}
+                                              isProcessing={isActive && activeIsThinking}
                                               response={response}
                                             />
                                           )}
@@ -6424,7 +6703,7 @@ function App() {
                                     query={request.query}
                                     options={request.options}
                                     onResponse={(response) => handleAskHumanResponse(request.toolCallId, request.subflow, response)}
-                                    isProcessing={isActive && isProcessing}
+                                    isProcessing={isActive && activeIsThinking}
                                   />
                                 ))}
 
@@ -6436,7 +6715,7 @@ function App() {
                                   </Message>
                                 )}
 
-                                {isActive && isProcessing && !tabState.currentAssistantMessage && (
+                                {isActive && activeIsThinking && !tabState.currentAssistantMessage && (
                                   <Message from="assistant">
                                     <MessageContent>
                                       <Shimmer duration={1}>Thinking...</Shimmer>
@@ -6472,7 +6751,7 @@ function App() {
                             visibleFiles={visibleKnowledgeFiles}
                             onSubmit={handlePromptSubmit}
                             onStop={handleStop}
-                            isProcessing={isActive && isProcessing}
+                            isProcessing={isActive && activeIsProcessing}
                             isStopping={isActive && isStopping}
                             isActive={isActive}
                             presetMessage={isActive ? presetMessage : undefined}
@@ -6492,17 +6771,16 @@ function App() {
                             onWorkDirChange={(v) => setTabWorkDir(tab.id, v)}
                             isRecording={isActive && isRecording}
                             recordingText={isActive ? voice.interimText : undefined}
-                            recordingState={isActive ? (voice.state === 'connecting' ? 'connecting' : 'listening') : undefined}
+                            recordingState={isActive ? (voice.state === 'submitting' ? 'stopping' : voice.state === 'connecting' ? 'connecting' : 'listening') : undefined}
                             audioLevelsRef={voice.audioLevelsRef}
                             onStartRecording={isActive ? handleStartRecording : undefined}
                             onSubmitRecording={isActive ? handleSubmitRecording : undefined}
                             onCancelRecording={isActive ? handleCancelRecording : undefined}
                             voiceAvailable={isActive && voiceAvailable}
-                            ttsAvailable={isActive && ttsAvailable}
-                            ttsEnabled={ttsEnabled}
-                            ttsMode={ttsMode}
-                            onToggleTts={isActive ? handleToggleTts : undefined}
-                            onTtsModeChange={isActive ? handleTtsModeChange : undefined}
+                            inCall={inCall}
+                            onStartCall={isActive ? startCall : undefined}
+                            onEndCall={isActive ? endCall : undefined}
+                            callAvailable={voiceAvailable && ttsAvailable}
                           />
                         </div>
                       )
@@ -6527,6 +6805,7 @@ function App() {
                   session={activeCodeSession.session}
                   status={activeCodeSession.status}
                   onOpenDiff={setCodeDiffPath}
+                  voiceAvailable={voiceAvailable}
                 />
               </ResizableRightPane>
             ) : isRightPaneContext && (
@@ -6553,11 +6832,11 @@ function App() {
                 }}
                 onOpenChatHistory={() => void navigateToView({ type: 'chat-history' })}
                 onOpenFullScreen={toggleRightPaneMaximize}
-                conversation={conversation}
-                currentAssistantMessage={currentAssistantMessage}
-                chatTabStates={chatViewStateByTab}
+                conversation={activeChatTabState.conversation}
+                currentAssistantMessage={activeChatTabState.currentAssistantMessage}
+                chatTabStates={chatTabStatesForRender}
                 viewportAnchors={chatViewportAnchorByTab}
-                isProcessing={isProcessing}
+                isProcessing={activeIsProcessing}
                 isStopping={isStopping}
                 onStop={handleStop}
                 onSubmit={handlePromptSubmit}
@@ -6588,10 +6867,11 @@ function App() {
                     ? { title: activeCodeSession.session.title }
                     : null
                 }
-                pendingAskHumanRequests={pendingAskHumanRequests}
-                allPermissionRequests={allPermissionRequests}
-                permissionResponses={permissionResponses}
-                autoPermissionDecisions={autoPermissionDecisions}
+                pendingAskHumanRequests={activeChatTabState.pendingAskHumanRequests}
+                allPermissionRequests={activeChatTabState.allPermissionRequests}
+                permissionResponses={activeChatTabState.permissionResponses}
+                autoPermissionDecisions={activeChatTabState.autoPermissionDecisions}
+                isThinking={activeIsThinking}
                 onPermissionResponse={handlePermissionResponse}
                 onAskHumanResponse={handleAskHumanResponse}
                 isToolOpenForTab={isToolOpenForTab}
@@ -6601,20 +6881,53 @@ function App() {
                 collapsedLeftPaddingPx={collapsedLeftPaddingPx}
                 isRecording={isRecording}
                 recordingText={voice.interimText}
-                recordingState={voice.state === 'connecting' ? 'connecting' : 'listening'}
+                recordingState={voice.state === 'submitting' ? 'stopping' : voice.state === 'connecting' ? 'connecting' : 'listening'}
                 audioLevelsRef={voice.audioLevelsRef}
                 onStartRecording={handleStartRecording}
                 onSubmitRecording={handleSubmitRecording}
                 onCancelRecording={handleCancelRecording}
                 voiceAvailable={voiceAvailable}
-                ttsAvailable={ttsAvailable}
-                ttsEnabled={ttsEnabled}
-                ttsMode={ttsMode}
-                onToggleTts={handleToggleTts}
-                onTtsModeChange={handleTtsModeChange}
+                inCall={inCall}
+                onStartCall={startCall}
+                onEndCall={endCall}
+                callAvailable={voiceAvailable && ttsAvailable}
                 onComposioConnected={handleComposioConnected}
               />
             )}
+            {/* Full-screen call: user tile + animated mascot tile. Shown only
+                when the derived surface says so (camera on, no screen share,
+                not minimized) — otherwise the call lives in the floating
+                popout window. */}
+            {callSurface === 'fullscreen' && (
+              <VideoCallView
+                streamRef={video.streamRef}
+                onToggleScreenShare={handleToggleScreenShare}
+                cameraOn={video.cameraOn}
+                onToggleCamera={handleToggleCamera}
+                practiceMode={practiceMode}
+                onMinimize={() => void handleMinimizeCall()}
+                onInterrupt={handleInterruptAssistant}
+                ttsState={tts.state}
+                getTtsLevel={tts.getLevel}
+                status={videoCallStatus ?? 'listening'}
+                interimText={voice.interimText}
+                assistantCaption={assistantCaption}
+                onLeave={endCall}
+              />
+            )}
+            {/* Mascot-guided product tour */}
+            {tourActive && (
+              <ProductTour
+                onClose={() => setTourActive(false)}
+                onNavigate={handleTourNavigate}
+                ttsAvailable={ttsAvailable}
+                ttsState={tts.state}
+                speak={tts.speak}
+                speakUrl={tts.speakUrl}
+                cancelSpeech={tts.cancel}
+                getLevel={tts.getLevel}
+              />
+            )}
             {/* Rendered last so its no-drag region paints over the sidebar drag region */}
             <FixedSidebarToggle
               leftInsetPx={isMac ? MACOS_TRAFFIC_LIGHTS_RESERVED_PX : 0}
diff --git a/apps/x/apps/renderer/src/assets/tour/agents.mp3 b/apps/x/apps/renderer/src/assets/tour/agents.mp3
new file mode 100644
index 00000000..91d9597f
Binary files /dev/null and b/apps/x/apps/renderer/src/assets/tour/agents.mp3 differ
diff --git a/apps/x/apps/renderer/src/assets/tour/chats.mp3 b/apps/x/apps/renderer/src/assets/tour/chats.mp3
new file mode 100644
index 00000000..8ffdf12d
Binary files /dev/null and b/apps/x/apps/renderer/src/assets/tour/chats.mp3 differ
diff --git a/apps/x/apps/renderer/src/assets/tour/code.mp3 b/apps/x/apps/renderer/src/assets/tour/code.mp3
new file mode 100644
index 00000000..1ee37a86
Binary files /dev/null and b/apps/x/apps/renderer/src/assets/tour/code.mp3 differ
diff --git a/apps/x/apps/renderer/src/assets/tour/composer.mp3 b/apps/x/apps/renderer/src/assets/tour/composer.mp3
new file mode 100644
index 00000000..abad1126
Binary files /dev/null and b/apps/x/apps/renderer/src/assets/tour/composer.mp3 differ
diff --git a/apps/x/apps/renderer/src/assets/tour/done.mp3 b/apps/x/apps/renderer/src/assets/tour/done.mp3
new file mode 100644
index 00000000..829f42a6
Binary files /dev/null and b/apps/x/apps/renderer/src/assets/tour/done.mp3 differ
diff --git a/apps/x/apps/renderer/src/assets/tour/email.mp3 b/apps/x/apps/renderer/src/assets/tour/email.mp3
new file mode 100644
index 00000000..288461f1
Binary files /dev/null and b/apps/x/apps/renderer/src/assets/tour/email.mp3 differ
diff --git a/apps/x/apps/renderer/src/assets/tour/home.mp3 b/apps/x/apps/renderer/src/assets/tour/home.mp3
new file mode 100644
index 00000000..7c3a622e
Binary files /dev/null and b/apps/x/apps/renderer/src/assets/tour/home.mp3 differ
diff --git a/apps/x/apps/renderer/src/assets/tour/knowledge.mp3 b/apps/x/apps/renderer/src/assets/tour/knowledge.mp3
new file mode 100644
index 00000000..5e259e09
Binary files /dev/null and b/apps/x/apps/renderer/src/assets/tour/knowledge.mp3 differ
diff --git a/apps/x/apps/renderer/src/assets/tour/meetings.mp3 b/apps/x/apps/renderer/src/assets/tour/meetings.mp3
new file mode 100644
index 00000000..6d0f1d85
Binary files /dev/null and b/apps/x/apps/renderer/src/assets/tour/meetings.mp3 differ
diff --git a/apps/x/apps/renderer/src/assets/tour/welcome.mp3 b/apps/x/apps/renderer/src/assets/tour/welcome.mp3
new file mode 100644
index 00000000..846fc872
Binary files /dev/null and b/apps/x/apps/renderer/src/assets/tour/welcome.mp3 differ
diff --git a/apps/x/apps/renderer/src/assets/tour/workspaces.mp3 b/apps/x/apps/renderer/src/assets/tour/workspaces.mp3
new file mode 100644
index 00000000..dc291ce5
Binary files /dev/null and b/apps/x/apps/renderer/src/assets/tour/workspaces.mp3 differ
diff --git a/apps/x/apps/renderer/src/components/ai-elements/conversation.tsx b/apps/x/apps/renderer/src/components/ai-elements/conversation.tsx
index 7a3f8836..6dfeedaf 100644
--- a/apps/x/apps/renderer/src/components/ai-elements/conversation.tsx
+++ b/apps/x/apps/renderer/src/components/ai-elements/conversation.tsx
@@ -43,6 +43,7 @@ export const Conversation = ({
   const contentRef = useRef<HTMLDivElement | null>(null);
   const scrollRef = useRef<HTMLDivElement | null>(null);
   const spacerRef = useRef<HTMLDivElement | null>(null);
+  const stickToBottomRef = useRef(true);
   const [isAtBottom, setIsAtBottom] = useState(true);
 
   const updateBottomState = useCallback(() => {
@@ -50,7 +51,9 @@ export const Conversation = ({
     if (!container) return;
     const distanceFromBottom =
       container.scrollHeight - container.scrollTop - container.clientHeight;
-    setIsAtBottom(distanceFromBottom <= BOTTOM_THRESHOLD_PX);
+    const atBottom = distanceFromBottom <= BOTTOM_THRESHOLD_PX;
+    stickToBottomRef.current = atBottom;
+    setIsAtBottom(atBottom);
   }, []);
 
   const applyAnchorLayout = useCallback(
@@ -131,7 +134,12 @@ export const Conversation = ({
         cancelAnimationFrame(rafId);
       }
       rafId = requestAnimationFrame(() => {
+        const shouldStick = !anchorMessageId && stickToBottomRef.current;
         applyAnchorLayout(false);
+        if (shouldStick) {
+          container.scrollTop = container.scrollHeight;
+          updateBottomState();
+        }
       });
     };
 
@@ -178,6 +186,7 @@ export const Conversation = ({
     const container = scrollRef.current;
     if (!container) return;
     container.scrollTop = container.scrollHeight;
+    stickToBottomRef.current = true;
     updateBottomState();
   }, [updateBottomState]);
 
diff --git a/apps/x/apps/renderer/src/components/bg-tasks-view.tsx b/apps/x/apps/renderer/src/components/bg-tasks-view.tsx
index c48df79e..45e23169 100644
--- a/apps/x/apps/renderer/src/components/bg-tasks-view.tsx
+++ b/apps/x/apps/renderer/src/components/bg-tasks-view.tsx
@@ -6,9 +6,7 @@ import {
     Pencil, Check, PanelRightClose, PanelRightOpen, Sparkles,
     Code2, FolderOpen, LayoutTemplate,
 } from 'lucide-react'
-import type { z } from 'zod'
 import type { BackgroundTask, BackgroundTaskSummary, Triggers } from '@x/shared/dist/background-task.js'
-import type { Run } from '@x/shared/dist/runs.js'
 import { Button } from '@/components/ui/button'
 import { Switch } from '@/components/ui/switch'
 import { Input } from '@/components/ui/input'
@@ -17,7 +15,7 @@ import { useBackgroundTaskAgentStatus } from '@/hooks/use-bg-task-agent-status'
 import { formatRelativeTime } from '@/lib/relative-time'
 import { toast } from '@/lib/toast'
 import type { ConversationItem } from '@/lib/chat-conversation'
-import { runLogToConversation } from '@/lib/run-to-conversation'
+import { fetchAgentRunTranscript, type AgentRunTranscript } from '@/lib/agent-transcript'
 import { CompactConversation } from '@/components/compact-conversation'
 import { RichMarkdownViewer } from '@/components/rich-markdown-viewer'
 import { HtmlFileViewer } from '@/components/html-file-viewer'
@@ -970,10 +968,9 @@ function SetupTab({
 // Runs history tab — list + drill-down transcript view
 //
 // Source of truth: `bg-tasks/<slug>/runs.log` — a plain-text file with one
-// runId per line (newest first). The actual transcripts live at the global
-// `$WorkDir/runs/<runId>.jsonl`, so this tab fetches runIds via the bg-task
-// IPC, then loads each Run through the standard `runs:fetch`. No bg-task-
-// specific transcript path or schema needed.
+// turn id per line (newest first). Transcripts live in the turn runtime's
+// storage; this tab fetches ids via the bg-task IPC, then loads each through
+// the shared agent-transcript loader (turn-first, legacy-run fallback).
 // ---------------------------------------------------------------------------
 
 interface RunRowSummary {
@@ -984,27 +981,6 @@ interface RunRowSummary {
     error?: string
 }
 
-// Pull the bits we want to display for a row out of a full Run's event log.
-function summarizeRun(run: z.infer<typeof Run>): RunRowSummary {
-    const out: RunRowSummary = { runId: run.id, createdAt: run.createdAt, trigger: run.subUseCase }
-    for (const event of run.log) {
-        if (event.type === 'error' && typeof event.error === 'string') {
-            out.error = event.error
-        } else if (event.type === 'message' && event.message?.role === 'assistant') {
-            const content = event.message.content
-            if (typeof content === 'string') {
-                out.summary = content
-            } else if (Array.isArray(content)) {
-                const text = content
-                    .filter((p) => p.type === 'text')
-                    .map((p) => ('text' in p ? p.text : ''))
-                    .join('')
-                if (text) out.summary = text
-            }
-        }
-    }
-    return out
-}
 
 function RunsHistoryTab({ slug, task }: { slug: string; task: BackgroundTask }) {
     const [rows, setRows] = useState<RunRowSummary[]>([])
@@ -1016,19 +992,25 @@ function RunsHistoryTab({ slug, task }: { slug: string; task: BackgroundTask })
         setLoading(true)
         try {
             const { runIds } = await window.ipc.invoke('bg-task:listRunIds', { slug, limit: 100 })
-            // Fetch each Run in parallel via the canonical IPC. Runs whose
-            // jsonl no longer exists (deleted manually, never written, …) are
-            // dropped silently.
+            // Fetch transcripts in parallel (turn-first, legacy-run
+            // fallback). Ids whose files no longer exist keep a bare row so
+            // the user knows the run happened.
             const settled = await Promise.allSettled(
-                runIds.map(runId => window.ipc.invoke('runs:fetch', { runId }))
+                runIds.map(runId => fetchAgentRunTranscript(runId))
             )
             const next: RunRowSummary[] = []
             for (let i = 0; i < settled.length; i++) {
                 const r = settled[i]
-                if (r.status === 'fulfilled' && r.value) {
-                    next.push(summarizeRun(r.value))
+                if (r.status === 'fulfilled') {
+                    const t = r.value
+                    next.push({
+                        runId: t.id,
+                        ...(t.createdAt === undefined ? {} : { createdAt: t.createdAt }),
+                        ...(t.trigger === undefined ? {} : { trigger: t.trigger }),
+                        ...(t.summary === undefined ? {} : { summary: t.summary }),
+                        ...(t.error === undefined ? {} : { error: t.error }),
+                    })
                 } else {
-                    // Keep the row visible with just the id so the user knows it exists.
                     next.push({ runId: runIds[i] })
                 }
             }
@@ -1134,7 +1116,7 @@ function RunTranscriptView({
     isInFlight: boolean
     onBack: () => void
 }) {
-    const [run, setRun] = useState<z.infer<typeof Run> | null>(null)
+    const [transcript, setTranscript] = useState<AgentRunTranscript | null>(null)
     const [loading, setLoading] = useState(true)
     const [error, setError] = useState<string | null>(null)
 
@@ -1144,15 +1126,13 @@ function RunTranscriptView({
         setError(null)
         void (async () => {
             try {
-                // Bg-task transcripts now live at the global runs/ location —
-                // same path resolution as every other run, no special handling.
-                const r = await window.ipc.invoke('runs:fetch', { runId })
+                const t = await fetchAgentRunTranscript(runId)
                 if (cancelled) return
-                setRun(r)
+                setTranscript(t)
             } catch (err) {
                 if (cancelled) return
                 setError(err instanceof Error ? err.message : String(err))
-                setRun(null)
+                setTranscript(null)
             } finally {
                 if (!cancelled) setLoading(false)
             }
@@ -1160,8 +1140,8 @@ function RunTranscriptView({
         return () => { cancelled = true }
     }, [runId])
 
-    const summary = run ? summarizeRun(run) : undefined
-    const items: ConversationItem[] = run ? runLogToConversation(run.log) : []
+    const summary = transcript ?? undefined
+    const items: ConversationItem[] = transcript?.items ?? []
 
     return (
         <div className="flex flex-1 flex-col overflow-hidden">
@@ -1221,10 +1201,10 @@ function RunTranscriptView({
                             Couldn&apos;t load transcript: {error}
                         </div>
                     )}
-                    {run && !loading && items.length === 0 && (
+                    {transcript && !loading && items.length === 0 && (
                         <p className="text-xs italic text-muted-foreground">No messages or tool calls recorded.</p>
                     )}
-                    {run && !loading && items.length > 0 && (
+                    {transcript && !loading && items.length > 0 && (
                         <CompactConversation items={items} />
                     )}
                 </div>
diff --git a/apps/x/apps/renderer/src/components/browser-pane/BrowserPane.tsx b/apps/x/apps/renderer/src/components/browser-pane/BrowserPane.tsx
index a1270706..9736ea84 100644
--- a/apps/x/apps/renderer/src/components/browser-pane/BrowserPane.tsx
+++ b/apps/x/apps/renderer/src/components/browser-pane/BrowserPane.tsx
@@ -1,7 +1,19 @@
 import { useCallback, useEffect, useRef, useState } from 'react'
 import { ArrowLeft, ArrowRight, Loader2, Plus, RotateCw, X } from 'lucide-react'
 
+import type { HttpAuthRequest } from '@x/shared/dist/browser-control.js'
+
 import { TabBar } from '@/components/tab-bar'
+import { Button } from '@/components/ui/button'
+import {
+  Dialog,
+  DialogContent,
+  DialogDescription,
+  DialogFooter,
+  DialogHeader,
+  DialogTitle,
+} from '@/components/ui/dialog'
+import { Input } from '@/components/ui/input'
 import { cn } from '@/lib/utils'
 
 /**
@@ -86,9 +98,80 @@ const getBrowserTabTitle = (tab: BrowserTabState) => {
   }
 }
 
+/**
+ * Credential prompt for HTTP basic/proxy auth challenges raised by pages in
+ * the embedded browser. Rendered as a regular app dialog: BrowserPane already
+ * hides the native WebContentsView whenever a dialog overlay is open, so the
+ * prompt is never obscured by the page that triggered it.
+ */
+function BrowserHttpAuthDialog({
+  request,
+  onSubmit,
+  onCancel,
+}: {
+  request: HttpAuthRequest
+  onSubmit: (username: string, password: string) => void
+  onCancel: () => void
+}) {
+  const [username, setUsername] = useState('')
+  const [password, setPassword] = useState('')
+
+  // Basic auth allows an empty username (token-style `curl -u :TOKEN`), so the
+  // only invalid submission is fully empty. The server decides the rest.
+  const canSubmit = username.length > 0 || password.length > 0
+
+  const handleSubmit = (e: React.FormEvent) => {
+    e.preventDefault()
+    if (!canSubmit) return
+    onSubmit(username, password)
+  }
+
+  return (
+    <Dialog open onOpenChange={(open) => { if (!open) onCancel() }}>
+      <DialogContent className="w-[min(24rem,calc(100%-2rem))] max-w-sm">
+        <DialogHeader>
+          <DialogTitle>Sign in</DialogTitle>
+          <DialogDescription>
+            {request.isProxy
+              ? `The proxy ${request.host} requires a username and password.`
+              : `${request.host} requires a username and password.`}
+            {request.realm ? ` (${request.realm})` : ''}
+          </DialogDescription>
+        </DialogHeader>
+        <form onSubmit={handleSubmit} className="flex flex-col gap-3">
+          <Input
+            autoFocus
+            value={username}
+            onChange={(e) => setUsername(e.target.value)}
+            placeholder="Username"
+            autoCapitalize="off"
+            autoCorrect="off"
+            spellCheck={false}
+          />
+          <Input
+            type="password"
+            value={password}
+            onChange={(e) => setPassword(e.target.value)}
+            placeholder="Password"
+          />
+          <DialogFooter>
+            <Button type="button" variant="outline" onClick={onCancel}>
+              Cancel
+            </Button>
+            <Button type="submit" disabled={!canSubmit}>
+              Sign in
+            </Button>
+          </DialogFooter>
+        </form>
+      </DialogContent>
+    </Dialog>
+  )
+}
+
 export function BrowserPane({ onClose, forceHidden = false }: BrowserPaneProps) {
   const [state, setState] = useState<BrowserState>(EMPTY_STATE)
   const [addressValue, setAddressValue] = useState('')
+  const [authQueue, setAuthQueue] = useState<HttpAuthRequest[]>([])
 
   const activeTabIdRef = useRef<string | null>(null)
   const addressFocusedRef = useRef(false)
@@ -121,6 +204,51 @@ export function BrowserPane({ onClose, forceHidden = false }: BrowserPaneProps)
     return cleanup
   }, [applyState])
 
+  // Mirror of authQueue for the unmount handler, which must read the latest
+  // queue without re-subscribing on every change.
+  const authQueueRef = useRef<HttpAuthRequest[]>([])
+  useEffect(() => {
+    authQueueRef.current = authQueue
+  }, [authQueue])
+
+  useEffect(() => {
+    const offRequest = window.ipc.on('browser:httpAuthRequest', (incoming) => {
+      setAuthQueue((queue) => [...queue, incoming as HttpAuthRequest])
+    })
+    // Main resolved a challenge on its own (timeout, or its tab/window was
+    // destroyed) — drop the corresponding dialog so it can't linger over an
+    // unrelated page with a submit that would no-op.
+    const offResolved = window.ipc.on('browser:httpAuthResolved', (incoming) => {
+      const { requestId } = incoming as { requestId: string }
+      setAuthQueue((queue) => queue.filter((request) => request.requestId !== requestId))
+    })
+    return () => {
+      offRequest()
+      offResolved()
+      // Cancel anything still pending so the main-process login callbacks and
+      // timers are freed immediately instead of waiting out the timeout.
+      for (const request of authQueueRef.current) {
+        void window.ipc.invoke('browser:httpAuthResponse', { requestId: request.requestId })
+      }
+    }
+  }, [])
+
+  const respondToAuth = useCallback(
+    (requestId: string, credentials: { username: string; password: string } | null) => {
+      setAuthQueue((queue) => queue.filter((request) => request.requestId !== requestId))
+      // Omit username to cancel; include it (even empty) to submit.
+      void window.ipc.invoke(
+        'browser:httpAuthResponse',
+        credentials
+          ? { requestId, username: credentials.username, password: credentials.password }
+          : { requestId },
+      )
+    },
+    [],
+  )
+
+  const activeAuthRequest = authQueue[0] ?? null
+
   const setViewVisible = useCallback((visible: boolean) => {
     if (viewVisibleRef.current === visible) return
     viewVisibleRef.current = visible
@@ -420,6 +548,17 @@ export function BrowserPane({ onClose, forceHidden = false }: BrowserPaneProps)
         className="relative min-h-0 min-w-0 flex-1"
         data-browser-viewport
       />
+
+      {activeAuthRequest && (
+        <BrowserHttpAuthDialog
+          key={activeAuthRequest.requestId}
+          request={activeAuthRequest}
+          onSubmit={(username, password) =>
+            respondToAuth(activeAuthRequest.requestId, { username, password })
+          }
+          onCancel={() => respondToAuth(activeAuthRequest.requestId, null)}
+        />
+      )}
     </div>
   )
 }
diff --git a/apps/x/apps/renderer/src/components/chat-input-with-mentions.tsx b/apps/x/apps/renderer/src/components/chat-input-with-mentions.tsx
index f3609212..ba87140d 100644
--- a/apps/x/apps/renderer/src/components/chat-input-with-mentions.tsx
+++ b/apps/x/apps/renderer/src/components/chat-input-with-mentions.tsx
@@ -15,16 +15,19 @@ import {
   FolderCog,
   FolderOpen,
   Globe,
-  Headphones,
   ImagePlus,
   LoaderIcon,
   Lock,
   Mic,
   MoreHorizontal,
+  Phone,
+  PhoneOff,
   Plus,
+  Presentation,
   ShieldCheck,
   Square,
   Terminal,
+  Video,
   X,
 } from 'lucide-react'
 
@@ -210,6 +213,18 @@ function compactWorkDirPath(path: string) {
   return path.replace(/^\/Users\/[^/]+/, '~')
 }
 
+// Call presets: front doors into the same call engine, differing only in
+// starting devices. 'share' is the call button's main click — the "work
+// together" default (screen shared, camera off, floating pill). The chevron
+// menu holds the deviations.
+export type CallPreset = 'voice' | 'video' | 'share' | 'practice'
+
+const CALL_PRESET_MENU: Array<{ preset: CallPreset; label: string; description: string; Icon: typeof Phone }> = [
+  { preset: 'voice', label: 'Voice call', description: 'Just talk — nothing is shared, the mascot hovers while you work', Icon: AudioLines },
+  { preset: 'video', label: 'Video call', description: 'Camera on, face to face — it sees your expressions', Icon: Video },
+  { preset: 'practice', label: 'Practice session', description: 'Rehearse a pitch or interview with live coaching', Icon: Presentation },
+]
+
 interface ChatInputInnerProps {
   onSubmit: (message: PromptInputMessage, mentions?: FileMention[], attachments?: StagedAttachment[], searchEnabled?: boolean, codeMode?: 'claude' | 'codex', permissionMode?: PermissionMode) => void
   onStop?: () => void
@@ -223,18 +238,20 @@ interface ChatInputInnerProps {
   onDraftChange?: (text: string) => void
   isRecording?: boolean
   recordingText?: string
-  recordingState?: 'connecting' | 'listening'
+  recordingState?: 'connecting' | 'listening' | 'stopping'
   /** Live mic amplitude history (RMS per frame) driving the recording waveform. */
   audioLevelsRef?: React.MutableRefObject<number[]>
   onStartRecording?: () => void
-  onSubmitRecording?: () => void
+  onSubmitRecording?: () => void | Promise<void>
   onCancelRecording?: () => void
   voiceAvailable?: boolean
-  ttsAvailable?: boolean
-  ttsEnabled?: boolean
-  ttsMode?: 'summary' | 'full'
-  onToggleTts?: () => void
-  onTtsModeChange?: (mode: 'summary' | 'full') => void
+  /** A call is live (hands-free voice loop + spoken responses). */
+  inCall?: boolean
+  /** Start a call with the given preset's device defaults. */
+  onStartCall?: (preset: CallPreset) => void
+  onEndCall?: () => void
+  /** Calls need both voice input (STT) and voice output (TTS) configured. */
+  callAvailable?: boolean
   /** Fired when the user picks a different model in the dropdown (only when no run exists yet). */
   onSelectedModelChange?: (model: SelectedModel | null) => void
   /** Work directory for this chat (per-chat). Null when none is set. */
@@ -262,16 +279,16 @@ function ChatInputInner({
   onDraftChange,
   isRecording,
   recordingText,
+  recordingState,
   audioLevelsRef,
   onStartRecording,
   onSubmitRecording,
   onCancelRecording,
   voiceAvailable,
-  ttsAvailable,
-  ttsEnabled,
-  ttsMode,
-  onToggleTts,
-  onTtsModeChange,
+  inCall,
+  onStartCall,
+  onEndCall,
+  callAvailable,
   onSelectedModelChange,
   workDir = null,
   onWorkDirChange,
@@ -341,22 +358,15 @@ function ChatInputInner({
     }
   })
 
-  // When a run exists, freeze the dropdown to the run's resolved model+provider.
+  // Sessions runtime: model and permission mode are per-message turn config,
+  // so nothing is frozen for an existing chat — the picker stays live.
   useEffect(() => {
     if (!runId) {
       setLockedModel(null)
       setPermissionMode('auto')
       return
     }
-    let cancelled = false
-    window.ipc.invoke('runs:fetch', { runId }).then((run) => {
-      if (cancelled) return
-      if (run.provider && run.model) {
-        setLockedModel({ provider: run.provider, model: run.model })
-      }
-      setPermissionMode(run.permissionMode ?? 'manual')
-    }).catch(() => { /* legacy run or fetch failure — leave unlocked */ })
-    return () => { cancelled = true }
+    setLockedModel(null)
   }, [runId])
 
   useEffect(() => {
@@ -758,7 +768,7 @@ function ChatInputInner({
   const currentWorkDirPath = effectiveWorkDir ? compactWorkDirPath(effectiveWorkDir) : ''
 
   return (
-    <div className="rowboat-chat-input rounded-lg border border-border bg-background shadow-none">
+    <div data-tour-id="chat-composer" className="rowboat-chat-input rounded-lg border border-border bg-background shadow-none">
       {attachments.length > 0 && (
         <div className="flex flex-wrap gap-2 px-4 pb-1 pt-3">
           {attachments.map((attachment) => {
@@ -829,23 +839,33 @@ function ChatInputInner({
           >
             <X className="h-4 w-4" />
           </button>
-          {/* Audio-reactive waveform only — the transcribed words are intentionally
-              not shown while recording; they're still captured and submitted. */}
-          <div className="flex flex-1 items-center overflow-hidden">
+          <div className="flex min-w-0 flex-1 flex-col gap-1 overflow-hidden">
             <VoiceWaveform audioLevelsRef={audioLevelsRef} />
+            <div
+              className={cn(
+                'min-h-5 truncate text-sm leading-5',
+                recordingText?.trim() ? 'text-foreground' : 'text-muted-foreground'
+              )}
+            >
+              {recordingText?.trim() || (recordingState === 'stopping' ? 'Finalizing...' : 'Listening...')}
+            </div>
           </div>
           <Button
             size="icon"
             onClick={onSubmitRecording}
-            disabled={!recordingText?.trim()}
+            disabled={recordingState === 'stopping'}
             className={cn(
               'h-7 w-7 shrink-0 rounded-full transition-all',
-              recordingText?.trim()
+              recordingState !== 'stopping'
                 ? 'bg-primary text-primary-foreground hover:bg-primary/90'
                 : 'bg-muted text-muted-foreground'
             )}
           >
-            <ArrowUp className="h-4 w-4" />
+            {recordingState === 'stopping' ? (
+              <LoaderIcon className="h-4 w-4 animate-spin" />
+            ) : (
+              <ArrowUp className="h-4 w-4" />
+            )}
           </Button>
         </div>
       ) : (
@@ -1267,48 +1287,66 @@ function ChatInputInner({
             </DropdownMenuContent>
           </DropdownMenu>
         ) : null}
-        {onToggleTts && ttsAvailable && (
+        {onStartCall && (
           <div className="flex shrink-0 items-center">
             <Tooltip delayDuration={CHAT_INPUT_TOOLTIP_DELAY_MS}>
               <TooltipTrigger asChild>
                 <button
                   type="button"
-                  onClick={onToggleTts}
+                  onClick={() => {
+                    if (inCall) {
+                      onEndCall?.()
+                    } else if (callAvailable) {
+                      onStartCall('share')
+                    }
+                  }}
                   className={cn(
-                    'relative flex h-7 w-7 shrink-0 items-center justify-center rounded-full transition-colors',
-                    ttsEnabled
-                      ? 'text-foreground hover:bg-muted'
-                      : 'text-muted-foreground hover:bg-muted hover:text-foreground'
+                    'flex h-7 w-7 shrink-0 items-center justify-center rounded-full transition-colors',
+                    inCall
+                      ? 'bg-red-600 text-white hover:bg-red-500'
+                      : callAvailable
+                        ? 'text-muted-foreground hover:bg-muted hover:text-foreground'
+                        : 'cursor-default text-muted-foreground/40'
                   )}
-                  aria-label={ttsEnabled ? 'Disable voice output' : 'Enable voice output'}
+                  aria-label={inCall ? 'End call' : 'Start a call'}
                 >
-                  <Headphones className="h-4 w-4" />
-                  {!ttsEnabled && (
-                    <span className="absolute inset-0 flex items-center justify-center pointer-events-none">
-                      <span className="block h-[1.5px] w-5 -rotate-45 rounded-full bg-muted-foreground" />
-                    </span>
-                  )}
+                  {inCall ? <PhoneOff className="h-4 w-4" /> : <Phone className="h-4 w-4" />}
                 </button>
               </TooltipTrigger>
               <TooltipContent side="top">
-                {ttsEnabled ? 'Voice output on' : 'Voice output off'}
+                {inCall
+                  ? 'End call'
+                  : callAvailable
+                    ? 'Start a call — it sees your screen while you talk it through'
+                    : 'Calls need voice input and output configured'}
               </TooltipContent>
             </Tooltip>
-            {ttsEnabled && onTtsModeChange && (
+            {!inCall && (
               <DropdownMenu>
                 <DropdownMenuTrigger asChild>
                   <button
                     type="button"
                     className="flex h-7 w-4 shrink-0 items-center justify-center text-muted-foreground transition-colors hover:text-foreground"
+                    aria-label="Call options"
                   >
                     <ChevronDown className="h-3 w-3" />
                   </button>
                 </DropdownMenuTrigger>
-                <DropdownMenuContent align="end">
-                  <DropdownMenuRadioGroup value={ttsMode ?? 'summary'} onValueChange={(v) => onTtsModeChange(v as 'summary' | 'full')}>
-                    <DropdownMenuRadioItem value="summary">Speak summary</DropdownMenuRadioItem>
-                    <DropdownMenuRadioItem value="full">Speak full response</DropdownMenuRadioItem>
-                  </DropdownMenuRadioGroup>
+                <DropdownMenuContent align="end" className="w-72">
+                  {CALL_PRESET_MENU.map(({ preset, label, description, Icon }) => (
+                    <DropdownMenuItem
+                      key={preset}
+                      disabled={!callAvailable}
+                      onSelect={() => onStartCall(preset)}
+                      className="items-start gap-3 py-2"
+                    >
+                      <Icon className="mt-0.5 h-4 w-4 shrink-0 text-muted-foreground" />
+                      <span className="min-w-0">
+                        <span className="block text-sm font-medium leading-tight">{label}</span>
+                        <span className="block pt-0.5 text-xs leading-tight text-muted-foreground">{description}</span>
+                      </span>
+                    </DropdownMenuItem>
+                  ))}
                 </DropdownMenuContent>
               </DropdownMenu>
             )}
@@ -1477,17 +1515,16 @@ export interface ChatInputWithMentionsProps {
   onDraftChange?: (text: string) => void
   isRecording?: boolean
   recordingText?: string
-  recordingState?: 'connecting' | 'listening'
+  recordingState?: 'connecting' | 'listening' | 'stopping'
   audioLevelsRef?: React.MutableRefObject<number[]>
   onStartRecording?: () => void
-  onSubmitRecording?: () => void
+  onSubmitRecording?: () => void | Promise<void>
   onCancelRecording?: () => void
   voiceAvailable?: boolean
-  ttsAvailable?: boolean
-  ttsEnabled?: boolean
-  ttsMode?: 'summary' | 'full'
-  onToggleTts?: () => void
-  onTtsModeChange?: (mode: 'summary' | 'full') => void
+  inCall?: boolean
+  onStartCall?: (preset: CallPreset) => void
+  onEndCall?: () => void
+  callAvailable?: boolean
   onSelectedModelChange?: (model: SelectedModel | null) => void
   workDir?: string | null
   onWorkDirChange?: (value: string | null) => void
@@ -1517,11 +1554,10 @@ export function ChatInputWithMentions({
   onSubmitRecording,
   onCancelRecording,
   voiceAvailable,
-  ttsAvailable,
-  ttsEnabled,
-  ttsMode,
-  onToggleTts,
-  onTtsModeChange,
+  inCall,
+  onStartCall,
+  onEndCall,
+  callAvailable,
   onSelectedModelChange,
   workDir,
   onWorkDirChange,
@@ -1548,11 +1584,10 @@ export function ChatInputWithMentions({
         onSubmitRecording={onSubmitRecording}
         onCancelRecording={onCancelRecording}
         voiceAvailable={voiceAvailable}
-        ttsAvailable={ttsAvailable}
-        ttsEnabled={ttsEnabled}
-        ttsMode={ttsMode}
-        onToggleTts={onToggleTts}
-        onTtsModeChange={onTtsModeChange}
+        inCall={inCall}
+        onStartCall={onStartCall}
+        onEndCall={onEndCall}
+        callAvailable={callAvailable}
         onSelectedModelChange={onSelectedModelChange}
         workDir={workDir}
         onWorkDirChange={onWorkDirChange}
diff --git a/apps/x/apps/renderer/src/components/chat-message-attachments.tsx b/apps/x/apps/renderer/src/components/chat-message-attachments.tsx
index 298e5f03..9a80da00 100644
--- a/apps/x/apps/renderer/src/components/chat-message-attachments.tsx
+++ b/apps/x/apps/renderer/src/components/chat-message-attachments.tsx
@@ -91,11 +91,28 @@ interface ChatMessageAttachmentsProps {
 export function ChatMessageAttachments({ attachments, className }: ChatMessageAttachmentsProps) {
   if (attachments.length === 0) return null
 
-  const imageAttachments = attachments.filter((attachment) => isImageMime(attachment.mimeType))
-  const fileAttachments = attachments.filter((attachment) => !isImageMime(attachment.mimeType))
+  const videoFrames = attachments.filter((attachment) => attachment.isVideoFrame)
+  const imageAttachments = attachments.filter(
+    (attachment) => !attachment.isVideoFrame && isImageMime(attachment.mimeType)
+  )
+  const fileAttachments = attachments.filter(
+    (attachment) => !attachment.isVideoFrame && !isImageMime(attachment.mimeType)
+  )
 
   return (
     <div className={cn('flex flex-col items-end gap-2', className)}>
+      {videoFrames.length > 0 && (
+        <div className="flex max-w-[340px] flex-wrap justify-end gap-1">
+          {videoFrames.map((frame, index) => (
+            <img
+              key={`frame-${index}`}
+              src={frame.thumbnailUrl}
+              alt={`Camera frame ${index + 1}`}
+              className="h-12 w-auto rounded-md border border-border/60 bg-muted object-cover"
+            />
+          ))}
+        </div>
+      )}
       {imageAttachments.length > 0 && (
         <div className="flex flex-wrap justify-end gap-2">
           {imageAttachments.map((attachment, index) => (
diff --git a/apps/x/apps/renderer/src/components/chat-sidebar.tsx b/apps/x/apps/renderer/src/components/chat-sidebar.tsx
index a463b080..453b1e64 100644
--- a/apps/x/apps/renderer/src/components/chat-sidebar.tsx
+++ b/apps/x/apps/renderer/src/components/chat-sidebar.tsx
@@ -37,7 +37,7 @@ import { MarkdownPreOverride } from '@/components/ai-elements/markdown-code-over
 import { defaultRemarkPlugins } from 'streamdown'
 import remarkBreaks from 'remark-breaks'
 import { type ChatTab } from '@/components/tab-bar'
-import { ChatInputWithMentions, type PermissionMode, type StagedAttachment, type SelectedModel } from '@/components/chat-input-with-mentions'
+import { ChatInputWithMentions, type CallPreset, type PermissionMode, type StagedAttachment, type SelectedModel } from '@/components/chat-input-with-mentions'
 import { ChatMessageAttachments } from '@/components/chat-message-attachments'
 import { useSidebar } from '@/components/ui/sidebar'
 import { wikiLabel } from '@/lib/wiki-links'
@@ -142,6 +142,10 @@ interface ChatSidebarProps {
   chatTabStates?: Record<string, ChatTabViewState>
   viewportAnchors?: Record<string, ChatViewportAnchorState>
   isProcessing: boolean
+  // Actively working (sessions runtime). When provided, drives the shimmer
+  // instead of isProcessing so waiting on a permission/ask-human doesn't
+  // render a "Thinking…" under the card.
+  isThinking?: boolean
   isStopping?: boolean
   onStop?: () => void
   onSubmit: (message: PromptInputMessage, mentions?: FileMention[], attachments?: StagedAttachment[], searchEnabled?: boolean, codeMode?: 'claude' | 'codex', permissionMode?: PermissionMode) => void
@@ -177,17 +181,16 @@ interface ChatSidebarProps {
   // Voice / TTS props
   isRecording?: boolean
   recordingText?: string
-  recordingState?: 'connecting' | 'listening'
+  recordingState?: 'connecting' | 'listening' | 'stopping'
   audioLevelsRef?: React.MutableRefObject<number[]>
   onStartRecording?: () => void
-  onSubmitRecording?: () => void
+  onSubmitRecording?: () => void | Promise<void>
   onCancelRecording?: () => void
   voiceAvailable?: boolean
-  ttsAvailable?: boolean
-  ttsEnabled?: boolean
-  ttsMode?: 'summary' | 'full'
-  onToggleTts?: () => void
-  onTtsModeChange?: (mode: 'summary' | 'full') => void
+  inCall?: boolean
+  onStartCall?: (preset: CallPreset) => void
+  onEndCall?: () => void
+  callAvailable?: boolean
   onComposioConnected?: (toolkitSlug: string) => void
 }
 
@@ -211,6 +214,7 @@ export function ChatSidebar({
   chatTabStates = {},
   viewportAnchors = {},
   isProcessing,
+  isThinking,
   isStopping,
   onStop,
   onSubmit,
@@ -246,11 +250,10 @@ export function ChatSidebar({
   onSubmitRecording,
   onCancelRecording,
   voiceAvailable,
-  ttsAvailable,
-  ttsEnabled,
-  ttsMode,
-  onToggleTts,
-  onTtsModeChange,
+  inCall,
+  onStartCall,
+  onEndCall,
+  callAvailable,
   onComposioConnected,
 }: ChatSidebarProps) {
   const { state: sidebarState } = useSidebar()
@@ -373,7 +376,14 @@ export function ChatSidebar({
     }
 
     try {
-      const result = await window.ipc.invoke('runs:downloadLog', { runId: activeRunId })
+      // Session-first (new runtime); legacy runs fallback covers old
+      // background tabs until stage 7 removes the runs runtime.
+      let result: { success: boolean; error?: string }
+      try {
+        result = await window.ipc.invoke('sessions:downloadLog', { sessionId: activeRunId })
+      } catch {
+        result = await window.ipc.invoke('runs:downloadLog', { runId: activeRunId })
+      }
       if (result.success) {
         toast.success('Chat log saved')
       } else if (result.error) {
@@ -725,7 +735,7 @@ export function ChatSidebar({
                                             onApproveSession={() => onPermissionResponse(permRequest.toolCall.toolCallId, permRequest.subflow, 'approve', 'session')}
                                             onApproveAlways={() => onPermissionResponse(permRequest.toolCall.toolCallId, permRequest.subflow, 'approve', 'always')}
                                             onDeny={() => onPermissionResponse(permRequest.toolCall.toolCallId, permRequest.subflow, 'deny')}
-                                            isProcessing={isActive && isProcessing}
+                                            isProcessing={isActive && (isThinking ?? isProcessing)}
                                             response={response}
                                           />
                                         )}
@@ -742,7 +752,7 @@ export function ChatSidebar({
                                   key={request.toolCallId}
                                   query={request.query}
                                   onResponse={(response) => onAskHumanResponse(request.toolCallId, request.subflow, response)}
-                                  isProcessing={isActive && isProcessing}
+                                  isProcessing={isActive && (isThinking ?? isProcessing)}
                                 />
                               ))}
 
@@ -754,7 +764,7 @@ export function ChatSidebar({
                                 </Message>
                               )}
 
-                              {isActive && isProcessing && !tabState.currentAssistantMessage && (
+                              {isActive && (isThinking ?? isProcessing) && !tabState.currentAssistantMessage && (
                                 <Message from="assistant">
                                   <MessageContent>
                                     <Shimmer duration={1}>Thinking...</Shimmer>
@@ -813,11 +823,10 @@ export function ChatSidebar({
                           onSubmitRecording={isActive ? onSubmitRecording : undefined}
                           onCancelRecording={isActive ? onCancelRecording : undefined}
                           voiceAvailable={isActive && voiceAvailable}
-                          ttsAvailable={isActive && ttsAvailable}
-                          ttsEnabled={ttsEnabled}
-                          ttsMode={ttsMode}
-                          onToggleTts={isActive ? onToggleTts : undefined}
-                          onTtsModeChange={isActive ? onTtsModeChange : undefined}
+                          inCall={inCall}
+                          onStartCall={isActive ? onStartCall : undefined}
+                          onEndCall={isActive ? onEndCall : undefined}
+                          callAvailable={callAvailable}
                         />
                       </div>
                     )
diff --git a/apps/x/apps/renderer/src/components/code/cm.ts b/apps/x/apps/renderer/src/components/code/cm.ts
index 4b75c1b2..8fa523f7 100644
--- a/apps/x/apps/renderer/src/components/code/cm.ts
+++ b/apps/x/apps/renderer/src/components/code/cm.ts
@@ -29,6 +29,12 @@ const darkHighlight = HighlightStyle.define([
 ])
 
 export function cmBaseExtensions(isDark: boolean): Extension[] {
+  const bg = isDark ? '#0f1117' : '#ffffff'
+  const panelBg = isDark ? '#151821' : '#f6f8fa'
+  const text = isDark ? '#d4d4d8' : '#24292f'
+  const muted = isDark ? '#7d8590' : '#6e7781'
+  const border = isDark ? '#2f3542' : '#d0d7de'
+
   return [
     lineNumbers(),
     bracketMatching(),
@@ -39,18 +45,62 @@ export function cmBaseExtensions(isDark: boolean): Extension[] {
     EditorView.theme(
       {
         '&': {
-          backgroundColor: 'transparent',
+          backgroundColor: bg,
+          color: text,
           fontSize: '12px',
           height: '100%',
         },
+        '.cm-editor': {
+          backgroundColor: bg,
+          color: text,
+        },
+        '.cm-content': {
+          caretColor: text,
+        },
         '.cm-scroller': {
           fontFamily: 'ui-monospace, SFMono-Regular, Menlo, monospace',
           overflow: 'auto',
         },
+        '.cm-line': {
+          color: text,
+        },
         '.cm-gutters': {
-          backgroundColor: 'transparent',
-          border: 'none',
-          color: isDark ? '#6b7280' : '#9ca3af',
+          backgroundColor: panelBg,
+          borderRight: `1px solid ${border}`,
+          color: muted,
+        },
+        '.cm-activeLine': {
+          backgroundColor: isDark ? 'rgba(110, 118, 129, 0.16)' : 'rgba(175, 184, 193, 0.18)',
+        },
+        '.cm-activeLineGutter': {
+          backgroundColor: isDark ? 'rgba(110, 118, 129, 0.16)' : 'rgba(175, 184, 193, 0.18)',
+        },
+        '.cm-selectionBackground, &.cm-focused .cm-selectionBackground, .cm-content ::selection': {
+          backgroundColor: isDark ? 'rgba(88, 166, 255, 0.32)' : 'rgba(9, 105, 218, 0.22)',
+        },
+        '.cm-panels, .cm-panel': {
+          backgroundColor: panelBg,
+          color: text,
+          borderColor: border,
+        },
+        '.cm-mergeView': {
+          backgroundColor: bg,
+          color: text,
+        },
+        '.cm-mergeViewEditors': {
+          backgroundColor: bg,
+        },
+        '.cm-mergeView .cm-editor': {
+          borderColor: border,
+        },
+        '.cm-changedLine': {
+          backgroundColor: isDark ? 'rgba(56, 139, 253, 0.14)' : 'rgba(9, 105, 218, 0.08)',
+        },
+        '.cm-deletedChunk': {
+          backgroundColor: isDark ? 'rgba(248, 81, 73, 0.14)' : 'rgba(255, 235, 233, 0.95)',
+        },
+        '.cm-insertedLine, .cm-insertedChunk': {
+          backgroundColor: isDark ? 'rgba(63, 185, 80, 0.14)' : 'rgba(234, 255, 234, 0.95)',
         },
         '&.cm-focused': { outline: 'none' },
         // GitHub-style expander bar for folded unchanged regions (@codemirror/merge).
diff --git a/apps/x/apps/renderer/src/components/code/code-chat.tsx b/apps/x/apps/renderer/src/components/code/code-chat.tsx
index 7b1656f3..28a55db5 100644
--- a/apps/x/apps/renderer/src/components/code/code-chat.tsx
+++ b/apps/x/apps/renderer/src/components/code/code-chat.tsx
@@ -1,5 +1,5 @@
-import { useEffect, useRef, useState } from 'react'
-import { ArrowUp, FileText, Loader2, LoaderIcon, Plus, Square, Terminal, X } from 'lucide-react'
+import { useEffect, useRef, useState, type DragEvent, type MutableRefObject } from 'react'
+import { ArrowUp, FileText, Loader2, LoaderIcon, Mic, Plus, Square, Terminal, X } from 'lucide-react'
 import type { CodeSession, CodeSessionStatus } from '@x/shared/src/code-sessions.js'
 import { cn } from '@/lib/utils'
 import { toast } from 'sonner'
@@ -15,9 +15,54 @@ import { CodeRunPermissionRequest, CodingRunTimeline } from '@/components/coding
 import { PermissionRequest } from '@/components/ai-elements/permission-request'
 import { AskHumanRequest } from '@/components/ai-elements/ask-human-request'
 import { WebSearchResult } from '@/components/ai-elements/web-search-result'
+import { useVoiceMode } from '@/hooks/useVoiceMode'
 import { useCodeChat, isDirectTurn, isChatToolCall, isChatErrorMessage, type CodeChatItem } from './use-code-chat'
 
 const AGENT_LABEL: Record<string, string> = { claude: 'Claude Code', codex: 'Codex' }
+const WAVE_BAR_WIDTH = 3
+const WAVE_BAR_GAP = 2
+const WAVE_BAR_MIN = 1.5
+const WAVE_BAR_MAX = 18
+
+function VoiceWaveform({ audioLevelsRef }: { audioLevelsRef: MutableRefObject<number[]> }) {
+  const [bars, setBars] = useState<number[]>([])
+
+  useEffect(() => {
+    let raf = 0
+    let lastSig = ''
+    const tick = () => {
+      const levels = audioLevelsRef.current
+      const next = levels.length > 48 ? levels.slice(levels.length - 48) : levels
+      const sig = `${next.length}:${next.length ? next[next.length - 1] : 0}`
+      if (sig !== lastSig) {
+        lastSig = sig
+        setBars(next.slice())
+      }
+      raf = requestAnimationFrame(tick)
+    }
+    raf = requestAnimationFrame(tick)
+    return () => cancelAnimationFrame(raf)
+  }, [audioLevelsRef])
+
+  return (
+    <div className="flex h-5 w-full items-center overflow-hidden" style={{ gap: WAVE_BAR_GAP }}>
+      {bars.map((level, i) => {
+        const amp = Math.min(1, Math.max(0, level)) ** 0.8
+        return (
+          <span
+            key={i}
+            className="shrink-0 rounded-full bg-primary"
+            style={{
+              width: WAVE_BAR_WIDTH,
+              height: WAVE_BAR_MIN + amp * (WAVE_BAR_MAX - WAVE_BAR_MIN),
+              transition: 'height 90ms linear',
+            }}
+          />
+        )
+      })}
+    </div>
+  )
+}
 
 function RowboatToolCall({ item, onOpenDiff }: { item: ToolCall; onOpenDiff: (path: string) => void }) {
   const [open, setOpen] = useState(false)
@@ -97,20 +142,30 @@ export function CodeChat({
   session,
   status,
   onOpenDiff,
+  voiceAvailable = false,
 }: {
   session: CodeSession
   status: CodeSessionStatus
   onOpenDiff: (path: string) => void
+  voiceAvailable?: boolean
 }) {
   const {
-    items, liveText, isProcessing, pendingPermission, pendingToolPermissions, pendingAskHumans,
+    items, liveText, isProcessing, compactionStatus, contextUsage,
+    pendingPermission, pendingToolPermissions, pendingAskHumans,
     loading, send, stop, resolvePermission, respondToToolPermission, respondToAskHuman,
   } = useCodeChat(session)
   const [draft, setDraft] = useState('')
   const [stopping, setStopping] = useState(false)
   const textareaRef = useRef<HTMLTextAreaElement>(null)
+  const voice = useVoiceMode()
+  const voiceWarmup = voice.warmup
 
   const busy = isProcessing || status === 'working' || status === 'needs-you'
+  const recording = voice.state !== 'idle'
+  const recordingStopping = voice.state === 'submitting'
+  const contextUsedPercent = contextUsage
+    ? Math.min(100, Math.round((contextUsage.used / contextUsage.size) * 100))
+    : null
   // Attached file PATHS — like dragging a file into the Claude Code CLI, the
   // agent receives paths and reads the files itself with its own tools.
   const [attachments, setAttachments] = useState<string[]>([])
@@ -119,6 +174,7 @@ export function CodeChat({
     setDraft('')
     setAttachments([])
     setStopping(false)
+    voice.cancel()
     textareaRef.current?.focus()
   }, [session.id])
 
@@ -126,6 +182,10 @@ export function CodeChat({
     if (!busy) setStopping(false)
   }, [busy])
 
+  useEffect(() => {
+    if (voiceAvailable) voiceWarmup()
+  }, [voiceAvailable, voiceWarmup])
+
   const addAttachments = (paths: string[]) => {
     const cleaned = paths.filter(Boolean)
     if (cleaned.length === 0) return
@@ -141,7 +201,7 @@ export function CodeChat({
     textareaRef.current?.focus()
   }
 
-  const handleDrop = (e: React.DragEvent) => {
+  const handleDrop = (e: DragEvent) => {
     if (!e.dataTransfer?.files?.length) return
     e.preventDefault()
     const paths = Array.from(e.dataTransfer.files)
@@ -175,6 +235,27 @@ export function CodeChat({
     await stop()
   }
 
+  const handleStartRecording = () => {
+    if (busy) return
+    void voice.start()
+  }
+
+  const handleSubmitRecording = async () => {
+    if (!recording || recordingStopping) return
+    const text = await voice.submit()
+    if (!text) return
+    const result = await send(text)
+    if (!result.ok && result.error) {
+      toast.error(result.error)
+      setDraft(text)
+    }
+  }
+
+  const handleCancelRecording = () => {
+    voice.cancel()
+    textareaRef.current?.focus()
+  }
+
   const basename = (p: string) => p.split(/[\\/]/).pop() || p
 
   return (
@@ -188,7 +269,10 @@ export function CodeChat({
         <Terminal className="size-3.5 shrink-0 text-muted-foreground" />
         <div className="min-w-0 flex-1">
           <div className="truncate text-sm font-medium">{session.title}</div>
-          <div className="text-[11px] text-muted-foreground">{AGENT_LABEL[session.agent]} — direct</div>
+          <div className="text-[11px] text-muted-foreground">
+            {AGENT_LABEL[session.agent]} — direct
+            {contextUsedPercent != null ? ` · ${contextUsedPercent}% context used` : ''}
+          </div>
         </div>
       </div>
 
@@ -239,9 +323,19 @@ export function CodeChat({
             />
           ))}
           {busy && !pendingPermission && pendingToolPermissions.size === 0 && pendingAskHumans.size === 0 && (
-            <Shimmer className="text-sm">
-              {stopping ? 'Stopping…' : `${AGENT_LABEL[session.agent]} is working…`}
-            </Shimmer>
+            compactionStatus === 'stalled' ? (
+              <div className="text-sm text-amber-600">
+                Context compaction is taking longer than expected. You can stop and retry in a fresh session.
+              </div>
+            ) : (
+              <Shimmer className="text-sm">
+                {stopping
+                  ? 'Stopping…'
+                  : compactionStatus === 'running'
+                    ? 'Compacting context…'
+                    : `${AGENT_LABEL[session.agent]} is working…`}
+              </Shimmer>
+            )
           )}
         </ConversationContent>
         <ConversationScrollButton />
@@ -249,8 +343,8 @@ export function CodeChat({
 
       {/* Composer — mirrors the assistant chat input's look (rounded card,
           borderless textarea, round primary send / destructive stop). */}
-      <div className="p-3">
-        <div className="rowboat-chat-input mx-auto w-full max-w-3xl rounded-lg border border-border bg-background shadow-none">
+      <div className="bg-background p-3 dark:bg-black">
+        <div className="rowboat-chat-input rowboat-code-chat-input mx-auto w-full max-w-3xl rounded-lg border border-border bg-background shadow-none">
           {attachments.length > 0 && (
             <div className="flex flex-wrap gap-2 px-4 pb-1 pt-3">
               {attachments.map((p) => (
@@ -273,22 +367,58 @@ export function CodeChat({
               ))}
             </div>
           )}
-          <div className="px-4 pb-2 pt-4">
-            <Textarea
-              ref={textareaRef}
-              value={draft}
-              onChange={(e) => setDraft(e.target.value)}
-              onKeyDown={(e) => {
-                if (e.key === 'Enter' && !e.shiftKey) {
-                  e.preventDefault()
-                  void handleSend()
-                }
-              }}
-              placeholder="Type your message..."
-              className="max-h-40 min-h-[24px] w-full resize-none border-0 bg-transparent p-0 text-sm shadow-none outline-none focus-visible:ring-0"
-              rows={2}
-            />
-          </div>
+          {recording ? (
+            <div className="flex items-center gap-3 px-4 py-3">
+              <button
+                type="button"
+                onClick={handleCancelRecording}
+                className="flex h-7 w-7 shrink-0 items-center justify-center rounded-full text-muted-foreground transition-colors hover:bg-muted hover:text-foreground"
+                aria-label="Cancel recording"
+              >
+                <X className="h-4 w-4" />
+              </button>
+              <div className="flex min-w-0 flex-1 flex-col gap-1 overflow-hidden">
+                <VoiceWaveform audioLevelsRef={voice.audioLevelsRef} />
+                <div className={cn('min-h-5 truncate text-sm leading-5', voice.interimText.trim() ? 'text-foreground' : 'text-muted-foreground')}>
+                  {voice.interimText.trim() || (recordingStopping ? 'Finalizing...' : 'Listening...')}
+                </div>
+              </div>
+              <Button
+                size="icon"
+                onClick={() => void handleSubmitRecording()}
+                disabled={recordingStopping}
+                className={cn(
+                  'h-7 w-7 shrink-0 rounded-full transition-all',
+                  recordingStopping
+                    ? 'bg-muted text-muted-foreground'
+                    : 'bg-primary text-primary-foreground hover:bg-primary/90',
+                )}
+              >
+                {recordingStopping ? (
+                  <LoaderIcon className="h-4 w-4 animate-spin" />
+                ) : (
+                  <ArrowUp className="h-4 w-4" />
+                )}
+              </Button>
+            </div>
+          ) : (
+            <div className="px-4 pb-2 pt-4">
+              <Textarea
+                ref={textareaRef}
+                value={draft}
+                onChange={(e) => setDraft(e.target.value)}
+                onKeyDown={(e) => {
+                  if (e.key === 'Enter' && !e.shiftKey) {
+                    e.preventDefault()
+                    void handleSend()
+                  }
+                }}
+                placeholder="Type your message..."
+                className="max-h-40 min-h-[24px] w-full resize-none border-0 bg-transparent p-0 text-sm shadow-none outline-none focus-visible:ring-0"
+                rows={2}
+              />
+            </div>
+          )}
           <div className="flex items-center gap-2 px-3 pb-3">
             <Tooltip>
               <TooltipTrigger asChild>
@@ -303,6 +433,22 @@ export function CodeChat({
               </TooltipTrigger>
               <TooltipContent side="top">Attach files — the agent reads them from disk (or drag & drop)</TooltipContent>
             </Tooltip>
+            {voiceAvailable && (
+              <Tooltip>
+                <TooltipTrigger asChild>
+                  <button
+                    type="button"
+                    onClick={handleStartRecording}
+                    disabled={busy || recording}
+                    className="flex h-7 w-7 shrink-0 items-center justify-center rounded-full text-muted-foreground transition-colors hover:bg-muted hover:text-foreground disabled:cursor-not-allowed disabled:opacity-50"
+                    aria-label="Voice input"
+                  >
+                    <Mic className="h-4 w-4" />
+                  </button>
+                </TooltipTrigger>
+                <TooltipContent side="top">Voice input</TooltipContent>
+              </Tooltip>
+            )}
             <span className="flex min-w-0 items-center gap-1.5 text-xs text-muted-foreground">
               <Terminal className="size-3.5 shrink-0" />
               <span className="truncate">Direct — straight to {AGENT_LABEL[session.agent]}</span>
diff --git a/apps/x/apps/renderer/src/components/code/code-view.tsx b/apps/x/apps/renderer/src/components/code/code-view.tsx
index 7e1f88d3..90654307 100644
--- a/apps/x/apps/renderer/src/components/code/code-view.tsx
+++ b/apps/x/apps/renderer/src/components/code/code-view.tsx
@@ -338,12 +338,14 @@ export function CodeView({
                 {terminalOpen ? <ChevronDown className="size-3.5" /> : <ChevronUp className="size-3.5" />}
               </button>
               {terminalOpen && (
-                <div style={{ height: terminalHeight }}>
-                  <TerminalPane
-                    key={selectedSession.id}
-                    terminalId={selectedSession.id}
-                    cwd={selectedSession.cwd}
-                  />
+                <div className="bg-background pb-3 dark:bg-black" style={{ height: terminalHeight + 12 }}>
+                  <div className="h-full min-h-0">
+                    <TerminalPane
+                      key={selectedSession.id}
+                      terminalId={selectedSession.id}
+                      cwd={selectedSession.cwd}
+                    />
+                  </div>
                 </div>
               )}
             </div>
diff --git a/apps/x/apps/renderer/src/components/code/new-session-dialog.tsx b/apps/x/apps/renderer/src/components/code/new-session-dialog.tsx
index 3d0f5e1a..84d8a1f5 100644
--- a/apps/x/apps/renderer/src/components/code/new-session-dialog.tsx
+++ b/apps/x/apps/renderer/src/components/code/new-session-dialog.tsx
@@ -78,8 +78,8 @@ export function NewSessionDialog({
 }) {
   const [agentStatus, setAgentStatus] = useState<{ claude: AgentStatus; codex: AgentStatus } | null>(null)
   const [agent, setAgent] = useState<CodingAgent>('claude')
-  // Rowboat drives by default — direct CLI access is the power-user opt-in.
-  const [mode, setMode] = useState<CodeSessionMode>('rowboat')
+  // Direct drive by default; Rowboat orchestration remains an opt-in per session.
+  const [mode, setMode] = useState<CodeSessionMode>('direct')
   const [policy, setPolicy] = useState<ApprovalPolicy>('auto-approve-reads')
   const [isolation, setIsolation] = useState<'in-repo' | 'worktree'>('in-repo')
   const [title, setTitle] = useState('')
@@ -101,7 +101,7 @@ export function NewSessionDialog({
     setTitle('')
     setCreating(false)
     setIsolation('in-repo')
-    setMode('rowboat')
+    setMode('direct')
     setModelKey('default')
     setAgentModel('default')
     setAgentEffort('default')
diff --git a/apps/x/apps/renderer/src/components/code/terminal-pane.tsx b/apps/x/apps/renderer/src/components/code/terminal-pane.tsx
index f58fa5d9..22383472 100644
--- a/apps/x/apps/renderer/src/components/code/terminal-pane.tsx
+++ b/apps/x/apps/renderer/src/components/code/terminal-pane.tsx
@@ -6,7 +6,7 @@ import { useTheme } from '@/contexts/theme-context'
 
 // xterm color schemes tuned to the app's light/dark backgrounds.
 const DARK_THEME = {
-  background: '#1b1b1f',
+  background: '#000000',
   foreground: '#d4d4d8',
   cursor: '#d4d4d8',
   selectionBackground: 'rgba(120, 140, 255, 0.3)',
@@ -106,5 +106,11 @@ export function TerminalPane({ terminalId, cwd }: { terminalId: string; cwd: str
     if (term) term.options.theme = resolvedTheme === 'dark' ? DARK_THEME : LIGHT_THEME
   }, [resolvedTheme])
 
-  return <div ref={containerRef} className="h-full w-full overflow-hidden px-2 pt-1" />
+  return (
+    <div
+      ref={containerRef}
+      className="h-full w-full overflow-hidden px-2 pt-1"
+      style={{ backgroundColor: resolvedTheme === 'dark' ? '#000000' : '#ffffff' }}
+    />
+  )
 }
diff --git a/apps/x/apps/renderer/src/components/code/use-code-chat.ts b/apps/x/apps/renderer/src/components/code/use-code-chat.ts
index 08468c49..ce8973c0 100644
--- a/apps/x/apps/renderer/src/components/code/use-code-chat.ts
+++ b/apps/x/apps/renderer/src/components/code/use-code-chat.ts
@@ -41,6 +41,10 @@ export interface PendingCodePermission {
 
 const DIRECT_PREFIX = 'direct-'
 const STRUCTURAL_EVENTS = new Set(['tool_call', 'tool_call_update', 'plan', 'permission'])
+const COMPACTION_TITLE = 'Compacting context'
+const COMPACTION_STALLED_MS = 90_000
+
+export type CompactionStatus = 'idle' | 'running' | 'stalled'
 
 function messageText(content: unknown): string {
   if (typeof content === 'string') return content
@@ -62,6 +66,8 @@ export function useCodeChat(session: CodeSession | null) {
   const [items, setItems] = useState<CodeChatItem[]>([])
   const [liveText, setLiveText] = useState('')
   const [isProcessing, setIsProcessing] = useState(false)
+  const [compactionStatus, setCompactionStatus] = useState<CompactionStatus>('idle')
+  const [contextUsage, setContextUsage] = useState<{ used: number; size: number } | null>(null)
   const [pendingPermission, setPendingPermission] = useState<PendingCodePermission | null>(null)
   // Rowboat-mode copilot gates, same as the main chat: pre-tool-call permission
   // requests and ask-human questions. Keyed by toolCallId.
@@ -69,6 +75,7 @@ export function useCodeChat(session: CodeSession | null) {
   const [pendingAskHumans, setPendingAskHumans] = useState<Map<string, z.infer<typeof AskHumanRequestEvent>>>(new Map())
   const [loading, setLoading] = useState(false)
   const seenMessageIdsRef = useRef<Set<string>>(new Set())
+  const compactionToolIdRef = useRef<string | null>(null)
 
   const applyCodeRunEvent = useCallback((toolCallId: string, event: CodeRunEvent) => {
     if (toolCallId.startsWith(DIRECT_PREFIX)) {
@@ -99,6 +106,9 @@ export function useCodeChat(session: CodeSession | null) {
     if (!sessionId) {
       setItems([])
       setLiveText('')
+      setCompactionStatus('idle')
+      setContextUsage(null)
+      compactionToolIdRef.current = null
       setPendingPermission(null)
       return
     }
@@ -106,6 +116,9 @@ export function useCodeChat(session: CodeSession | null) {
     setLoading(true)
     setItems([])
     setLiveText('')
+    setCompactionStatus('idle')
+    setContextUsage(null)
+    compactionToolIdRef.current = null
     setPendingPermission(null)
     setPendingToolPermissions(new Map())
     setPendingAskHumans(new Map())
@@ -217,6 +230,12 @@ export function useCodeChat(session: CodeSession | null) {
     return () => { cancelled = true }
   }, [sessionId])
 
+  useEffect(() => {
+    if (compactionStatus !== 'running') return
+    const timer = window.setTimeout(() => setCompactionStatus('stalled'), COMPACTION_STALLED_MS)
+    return () => window.clearTimeout(timer)
+  }, [compactionStatus])
+
   // Live event stream.
   useEffect(() => {
     if (!sessionId) return
@@ -230,6 +249,8 @@ export function useCodeChat(session: CodeSession | null) {
           break
         case 'run-processing-end':
           setIsProcessing(false)
+          setCompactionStatus('idle')
+          compactionToolIdRef.current = null
           setPendingPermission(null)
           // Anything still streaming that never landed as a message (e.g. the
           // turn errored) is flushed so the text isn't lost.
@@ -247,6 +268,8 @@ export function useCodeChat(session: CodeSession | null) {
           break
         case 'run-stopped':
           setIsProcessing(false)
+          setCompactionStatus('idle')
+          compactionToolIdRef.current = null
           setPendingPermission(null)
           setPendingToolPermissions(new Map())
           setPendingAskHumans(new Map())
@@ -348,6 +371,19 @@ export function useCodeChat(session: CodeSession | null) {
           break
         case 'code-run-event': {
           setIsProcessing(true)
+          if (event.event.type === 'usage') {
+            setContextUsage({ used: event.event.used, size: event.event.size })
+          }
+          if (event.event.type === 'tool_call' && event.event.title === COMPACTION_TITLE) {
+            compactionToolIdRef.current = event.event.id ?? null
+            setCompactionStatus('running')
+          }
+          if (event.event.type === 'tool_call_update'
+            && event.event.id != null
+            && event.event.id === compactionToolIdRef.current) {
+            compactionToolIdRef.current = null
+            setCompactionStatus('idle')
+          }
           if (event.event.type === 'message' && event.event.role === 'agent' && event.toolCallId.startsWith(DIRECT_PREFIX)) {
             const text = event.event.text
             setLiveText((prev) => prev + text)
@@ -460,6 +496,8 @@ export function useCodeChat(session: CodeSession | null) {
     items,
     liveText,
     isProcessing,
+    compactionStatus,
+    contextUsage,
     pendingPermission,
     pendingToolPermissions,
     pendingAskHumans,
diff --git a/apps/x/apps/renderer/src/components/coding-run.tsx b/apps/x/apps/renderer/src/components/coding-run.tsx
index ea620dc9..916aad37 100644
--- a/apps/x/apps/renderer/src/components/coding-run.tsx
+++ b/apps/x/apps/renderer/src/components/coding-run.tsx
@@ -9,6 +9,7 @@ import {
   Pencil,
   Search,
   ShieldQuestion,
+  Sparkles,
   Terminal,
   Trash2,
   Wrench,
@@ -87,7 +88,8 @@ export function reduceEvents(events: CodeRunEvent[]): Row[] {
   return rows
 }
 
-function toolKindIcon(kind?: string) {
+function toolKindIcon(kind?: string, title?: string) {
+  if (title === 'Compacting context') return <Sparkles className="size-3.5 shrink-0 text-muted-foreground" />
   switch (kind) {
     case 'read': return <Eye className="size-3.5 shrink-0 text-muted-foreground" />
     case 'edit': return <Pencil className="size-3.5 shrink-0 text-muted-foreground" />
@@ -137,7 +139,7 @@ export function CodingRunTimeline({
                 {running
                   ? <Loader className="size-3.5 shrink-0 animate-spin text-muted-foreground" />
                   : <CheckCircle2 className="size-3.5 shrink-0 text-green-600" />}
-                {toolKindIcon(row.toolKind)}
+                {toolKindIcon(row.toolKind, row.title)}
                 <span className="truncate text-foreground/90">{row.title ?? row.toolKind ?? 'Tool call'}</span>
               </div>
               {row.diffs.length > 0 && (
diff --git a/apps/x/apps/renderer/src/components/email-view.tsx b/apps/x/apps/renderer/src/components/email-view.tsx
index 8815723f..b2e7b4f1 100644
--- a/apps/x/apps/renderer/src/components/email-view.tsx
+++ b/apps/x/apps/renderer/src/components/email-view.tsx
@@ -166,6 +166,11 @@ function buildRecipients(
   selfEmail: string,
 ): { to: string[]; cc: string[] } {
   if (mode === 'forward') return { to: [], cc: [] }
+  // Editing an existing draft: recipients are whatever the draft already has.
+  if (mode === 'draft') {
+    const draftMsg = latestMessage(thread)
+    return { to: splitAddresses(draftMsg?.to), cc: splitAddresses(draftMsg?.cc) }
+  }
 
   const latest = latestMessage(thread)
   const self = selfEmail.toLowerCase()
@@ -192,9 +197,41 @@ function buildRecipients(
   return { to, cc }
 }
 
+// Reply-chain headers (and thread placement) for the outgoing message.
+// Replies rebuild the chain from the thread's messages. An edited draft is a
+// single-message pseudo-thread whose own Message-ID must never be referenced
+// (it dies on send, which would break recipients' threading) — reuse the
+// In-Reply-To/References the draft already carries instead. Forwards and new
+// messages start fresh.
+function threadingHeaders(
+  mode: ComposeMode,
+  thread: GmailThread | undefined,
+): { threadId?: string; inReplyTo?: string; references?: string } {
+  if (!thread || mode === 'forward' || mode === 'new') return {}
+  if (mode === 'draft') {
+    const draftMsg = latestMessage(thread)
+    return {
+      // Only a reply draft stays on its thread — a standalone draft's
+      // threadId is the phantom thread holding just the draft itself.
+      threadId: draftMsg?.inReplyToHeader ? thread.threadId : undefined,
+      inReplyTo: draftMsg?.inReplyToHeader,
+      references: draftMsg?.referencesHeader,
+    }
+  }
+  const messageIds = thread.messages
+    .map((m) => m.messageIdHeader)
+    .filter((v): v is string => Boolean(v))
+  return {
+    threadId: thread.threadId,
+    inReplyTo: latestMessage(thread)?.messageIdHeader,
+    references: messageIds.join(' ') || undefined,
+  }
+}
+
 // Subject line for a reply ("Re: …") or forward ("Fwd: …"), avoiding double prefixes.
 function composeSubject(mode: ComposeMode, rawSubject?: string): string {
   const raw = (rawSubject || '').trim()
+  if (mode === 'draft') return raw // keep the draft's own subject verbatim
   if (mode === 'forward') return /^fwd:/i.test(raw) ? raw : `Fwd: ${raw}`.trim()
   return /^re:/i.test(raw) ? raw : `Re: ${raw}`.trim()
 }
@@ -401,6 +438,10 @@ function HtmlMessageBody({ message, threadId }: { message: GmailThreadMessage; t
   const [height, setHeight] = useState(message.bodyHeight ?? 80)
   const [hasQuote, setHasQuote] = useState(false)
   const [showQuotes, setShowQuotes] = useState(false)
+  // Read by handleLoad so a reload (theme switch rebuilds srcDoc) restores the
+  // expanded-quotes state on the fresh document.
+  const showQuotesRef = useRef(showQuotes)
+  useEffect(() => { showQuotesRef.current = showQuotes }, [showQuotes])
 
   const adaptToTheme = useMemo(() => !isStyledHtml(message.bodyHtml!), [message.bodyHtml])
   const srcDoc = useMemo(
@@ -413,6 +454,16 @@ function HtmlMessageBody({ message, threadId }: { message: GmailThreadMessage; t
     const doc = iframe?.contentDocument
     if (!doc?.body) return
     setHasQuote(!!doc.querySelector('.gmail_quote, .gmail_attr, blockquote[type="cite"]'))
+    if (showQuotesRef.current) doc.documentElement.dataset.showQuotes = 'true'
+    // Clicking into the email body focuses the iframe document, which would
+    // otherwise swallow every list/thread shortcut (the parent's document
+    // keydown listeners never fire). The sandbox has allow-same-origin but no
+    // allow-scripts, so we forward from out here; the listener dies with the
+    // document on the next load.
+    doc.addEventListener('keydown', (event) => {
+      const clone = new KeyboardEvent('keydown', event)
+      if (!document.dispatchEvent(clone)) event.preventDefault()
+    })
     const measure = () => {
       // Measure off body only. documentElement.scrollHeight stretches to fill
       // the iframe viewport, so once we size the iframe up (e.g. user expanded
@@ -492,16 +543,32 @@ function formatAttachmentSize(bytes?: number): string {
 }
 
 function MessageAttachments({ attachments }: { attachments: NonNullable<GmailThreadMessage['attachments']> }) {
-  const openAttachment = (path: string, filename: string) => {
-    void window.ipc
-      .invoke('shell:openPath', { path })
-      .then((result) => {
-        if (result?.error) toast(`Could not open ${filename}: ${result.error}`, 'error')
-      })
-      .catch((err) => {
-        const message = err instanceof Error ? err.message : String(err)
-        toast(`Could not open ${filename}: ${message}`, 'error')
-      })
+  const openAttachment = async (att: NonNullable<GmailThreadMessage['attachments']>[number]) => {
+    try {
+      // Ensure the file is on disk before handing off to the OS opener. Inbox
+      // attachments are saved during sync, but search-result attachments are
+      // only fetched on demand. gmail:downloadAttachment short-circuits when the
+      // file already exists, so calling it first is cheap and guarantees the
+      // file is present — we can't rely on shell:openPath reporting a missing
+      // file as an error (xdg-open on Linux reports success even when the path
+      // doesn't exist, so the old open-then-download fallback never fired).
+      if (att.messageId) {
+        const dl = await window.ipc.invoke('gmail:downloadAttachment', {
+          messageId: att.messageId,
+          savedPath: att.savedPath,
+          attachmentId: att.attachmentId,
+        })
+        if (!dl.ok) {
+          toast(`Could not download ${att.filename}: ${dl.error ?? 'unknown error'}`, 'error')
+          return
+        }
+      }
+      const result = await window.ipc.invoke('shell:openPath', { path: att.savedPath })
+      if (result?.error) toast(`Could not open ${att.filename}: ${result.error}`, 'error')
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err)
+      toast(`Could not open ${att.filename}: ${message}`, 'error')
+    }
   }
 
   return (
@@ -513,7 +580,7 @@ function MessageAttachments({ attachments }: { attachments: NonNullable<GmailThr
             key={att.savedPath}
             type="button"
             className="gmail-attachment"
-            onClick={() => openAttachment(att.savedPath, att.filename)}
+            onClick={() => void openAttachment(att)}
             title={`Open ${att.filename}`}
           >
             <Paperclip size={13} />
@@ -526,7 +593,20 @@ function MessageAttachments({ attachments }: { attachments: NonNullable<GmailThr
   )
 }
 
-type ComposeMode = 'reply' | 'replyAll' | 'forward' | 'new'
+type ComposeMode = 'reply' | 'replyAll' | 'forward' | 'new' | 'draft'
+
+// Platform-aware modifier: Cmd on macOS, Ctrl on Windows/Linux (App.tsx pattern).
+const isMac = typeof navigator !== 'undefined' && navigator.platform.toLowerCase().includes('mac')
+
+// True when a keyboard event originated in a text-entry context, so
+// single-letter shortcuts must stay inert.
+function isEditableTarget(target: EventTarget | null): boolean {
+  const el = target as HTMLElement | null
+  return Boolean(
+    el &&
+    (el.tagName === 'INPUT' || el.tagName === 'TEXTAREA' || el.tagName === 'SELECT' || el.isContentEditable)
+  )
+}
 
 function ComposeToolbarButton({
   editor,
@@ -562,8 +642,12 @@ function ComposeToolbarButton({
 }
 
 function ComposeToolbar({ editor, onOpenLink }: { editor: Editor; onOpenLink: () => void }) {
+  // Content-sized (no flex-1: a 0 basis always "fits" the current flex line,
+  // so the toolbar would never wrap — it would get squeezed until its
+  // fixed-size buttons overflowed the neighbors). The inner flex-wrap stacks
+  // the buttons if even a full line is too narrow to hold them.
   return (
-    <div className="flex min-w-0 flex-1 items-center gap-0.5 border-l border-border pl-2.5">
+    <div className="flex flex-wrap items-center gap-0.5 border-l border-border pl-2.5">
       <Button
         type="button"
         variant="ghost"
@@ -701,12 +785,15 @@ function RecipientField({
   onChange,
   autoFocus,
   trailing,
+  focusSignal,
 }: {
   label: string
   value: string[]
   onChange: (next: string[]) => void
   autoFocus?: boolean
   trailing?: React.ReactNode
+  /** Bump to move focus into this field (e.g. after a Cc/Bcc shortcut). */
+  focusSignal?: number
 }) {
   const [draft, setDraft] = useState('')
   const [suggestions, setSuggestions] = useState<ContactSuggestion[]>([])
@@ -722,18 +809,23 @@ function RecipientField({
     if (autoFocus) inputRef.current?.focus()
   }, [autoFocus])
 
+  useEffect(() => {
+    if (focusSignal) inputRef.current?.focus()
+  }, [focusSignal])
+
   const excludeEmails = useMemo(
     () => value.map((token) => extractAddress(token).toLowerCase()).filter(Boolean),
     [value],
   )
 
   // Debounced contact search — only runs when the user has actually typed
-  // something. An empty draft (including the post-pick reset) closes the menu.
+  // something. An emptied draft closes the menu via the onChange handler (and
+  // commit() clears it after a pick); here we just invalidate in-flight
+  // queries so a stale response can't reopen it.
   useEffect(() => {
     const trimmed = draft.trim()
     if (!isFocused || !trimmed) {
       queryTokenRef.current++
-      setSuggestions([])
       return
     }
     const token = ++queryTokenRef.current
@@ -780,6 +872,12 @@ function RecipientField({
 
   const onKeyDown = (event: React.KeyboardEvent<HTMLInputElement>) => {
     const hasSuggestions = suggestions.length > 0
+    if ((event.metaKey || event.ctrlKey) && event.key === 'Enter') {
+      // Cmd/Ctrl+Enter is "send" — commit any half-typed address on the way
+      // and let the event bubble to the composer's send handler.
+      if (draft.trim()) commit(draft)
+      return
+    }
     if (event.key === 'ArrowDown' && hasSuggestions) {
       event.preventDefault()
       setActiveIndex((i) => (i + 1) % suggestions.length)
@@ -792,6 +890,7 @@ function RecipientField({
     }
     if (event.key === 'Escape' && hasSuggestions) {
       event.preventDefault()
+      event.stopPropagation()
       setSuggestions([])
       return
     }
@@ -823,7 +922,10 @@ function RecipientField({
   const showSuggestions = isFocused && suggestions.length > 0
 
   return (
-    <div className="flex items-start gap-2 border-b border-border px-3 py-1.5 text-sm">
+    <div
+      className="flex items-start gap-2 border-b border-border px-3 py-1.5 text-sm"
+      data-suggestions-open={showSuggestions || undefined}
+    >
       <span className="min-w-7 pt-1.5 text-muted-foreground">{label}</span>
       <div className="relative flex min-w-0 flex-1 flex-wrap items-center gap-1" ref={fieldRef}>
         {value.map((token, index) => (
@@ -848,7 +950,11 @@ function RecipientField({
           ref={inputRef}
           className="h-6 min-w-[80px] flex-1 border-0 bg-transparent text-sm text-foreground outline-none placeholder:text-muted-foreground"
           value={draft}
-          onChange={(event) => setDraft(event.target.value)}
+          onChange={(event) => {
+            const next = event.target.value
+            setDraft(next)
+            if (!next.trim()) setSuggestions([])
+          }}
           onKeyDown={onKeyDown}
           onFocus={() => setIsFocused(true)}
           onBlur={() => {
@@ -977,6 +1083,25 @@ const TONE_PRESETS: Array<{ key: string; label: string; instruction: string }> =
   { key: 'longer', label: 'Longer', instruction: 'Rewrite this email to be more detailed and thorough.' },
 ]
 
+// Debounce before autosaving the composer to a Gmail draft after the last edit.
+const DRAFT_AUTOSAVE_MS = 1500
+
+// Shape of the gmail:saveDraft request, kept here so we can stash a snapshot in
+// a ref for the close/unmount flush without re-reading a torn-down editor.
+type DraftPayload = {
+  draftId?: string
+  threadId?: string
+  to?: string
+  cc?: string
+  bcc?: string
+  subject: string
+  bodyHtml: string
+  bodyText: string
+  inReplyTo?: string
+  references?: string
+  attachments?: Array<{ filename: string; mimeType: string; contentBase64: string }>
+}
+
 // Composer for replies, forwards, and (mode 'new') from-scratch emails. With a
 // thread it renders as an inline card under the thread; in 'new' mode it has no
 // thread and renders as a centered modal with the AI writing bar.
@@ -992,7 +1117,8 @@ const ComposeBox = memo(function ComposeBox({
   onClose: () => void
 }) {
   const isNew = mode === 'new'
-  const latest = thread ? latestMessage(thread) : undefined
+  // Drafts and new messages share the full-modal layout (subject line, AI bar).
+  const isModal = isNew || mode === 'draft'
   const initialRecipients = useMemo(
     () => (thread ? buildRecipients(mode, thread, selfEmail) : { to: [], cc: [] }),
     [mode, thread, selfEmail],
@@ -1003,12 +1129,20 @@ const ComposeBox = memo(function ComposeBox({
   const [bccList, setBccList] = useState<string[]>([])
   const [showCc, setShowCc] = useState<boolean>(initialRecipients.cc.length > 0)
   const [showBcc, setShowBcc] = useState<boolean>(false)
+  // Bumped by the Cc/Bcc shortcuts so the freshly revealed field grabs focus.
+  const [ccFocusSignal, setCcFocusSignal] = useState(0)
+  const [bccFocusSignal, setBccFocusSignal] = useState(0)
   const [subject, setSubject] = useState<string>(() => (thread ? composeSubject(mode, thread.subject) : ''))
-  const modeLabel = isNew ? 'New message' : mode === 'forward' ? 'Forward' : mode === 'replyAll' ? 'Reply All' : 'Reply'
+  const modeLabel = mode === 'draft' ? 'Draft' : isNew ? 'New message' : mode === 'forward' ? 'Forward' : mode === 'replyAll' ? 'Reply All' : 'Reply'
 
   const initialContent = useMemo(() => {
     if (!thread) return ''
     if (mode === 'forward') return buildForwardedContent(thread)
+    // For a saved draft, reopen the exact HTML we stored so formatting survives.
+    if (mode === 'draft') {
+      const draftMsg = latestMessage(thread)
+      if (draftMsg?.bodyHtml) return draftMsg.bodyHtml
+    }
     // Gmail-side draft (user's own work) wins over the AI-generated draft.
     const source = stripQuotedReplyText(thread.gmail_draft || thread.draft_response || '')
     if (!source) return ''
@@ -1018,16 +1152,27 @@ const ComposeBox = memo(function ComposeBox({
       .join('')
   }, [mode, thread])
 
+  // Ref so the Tiptap keydown handler (captured once at editor creation)
+  // always calls the latest send closure; assigned below sendInGmail.
+  const sendRef = useRef<() => void>(() => {})
+
   const editor = useEditor({
     extensions: [
       StarterKit.configure({ link: false }),
       Link.configure({ openOnClick: false, autolink: true }),
       Placeholder.configure({
-        placeholder: isNew || mode === 'forward' ? 'Write a message…' : 'Write your reply…',
+        placeholder: isModal || mode === 'forward' ? 'Write a message…' : 'Write your reply…',
       }),
     ],
     editorProps: {
       attributes: { class: 'compose-content' },
+      handleKeyDown: (_view, event) => {
+        if ((event.metaKey || event.ctrlKey) && event.key === 'Enter' && !event.shiftKey) {
+          sendRef.current()
+          return true
+        }
+        return false
+      },
     },
     content: initialContent,
   })
@@ -1255,6 +1400,171 @@ const ComposeBox = memo(function ComposeBox({
     setAttachments((prev) => prev.filter((a) => a.id !== id))
   }
 
+  // ── Draft autosave ─────────────────────────────────────────────────────────
+  // Keep a real Gmail draft in sync with the composer while the user types
+  // (debounced) and flush a final save on close, so closing keeps the work in
+  // Gmail's Drafts folder (synced to every device) instead of discarding it.
+  // Empty/whitespace drafts are skipped. The core saveThreadDraft reuses an
+  // existing thread draft and tracks the id so edits update in place.
+  // Seeded when editing an existing draft so the first save updates it in place.
+  const draftIdRef = useRef<string | undefined>(thread?.draftId)
+  const lastPayloadRef = useRef<DraftPayload | null>(null)
+  const savingRef = useRef(false)        // a saveDraft IPC is in flight
+  const pendingRef = useRef(false)        // edits arrived mid-flight; save once more
+  const sentRef = useRef(false)           // suppress autosave after a successful send
+  const discardedRef = useRef(false)      // suppress autosave after discard
+  const closedRef = useRef(false)         // close already handled; skip unmount flush
+  const dirtyRef = useRef(false)          // user has edited since open
+  const fieldsMounted = useRef(false)     // skip the field effect's initial run
+  const autosaveTimer = useRef<number | null>(null)
+  const saveDraftNowRef = useRef<() => Promise<void>>(undefined)
+
+  const buildDraftPayload = useCallback((): DraftPayload | null => {
+    if (!editor || editor.isDestroyed) return null
+    const text = editor.getText().trim()
+    if (!text) return null // skip empty/whitespace drafts
+    const html = editor.getHTML()
+    const { threadId, inReplyTo, references } = threadingHeaders(mode, thread)
+    return {
+      draftId: draftIdRef.current,
+      threadId,
+      to: toList.join(', '),
+      cc: ccList.length ? ccList.join(', ') : undefined,
+      bcc: bccList.length ? bccList.join(', ') : undefined,
+      subject: subject.trim() || (thread ? composeSubject(mode, thread.subject) : ''),
+      bodyHtml: html,
+      bodyText: text,
+      inReplyTo,
+      references,
+      attachments: attachments.length
+        ? attachments.map(({ filename, mimeType, contentBase64 }) => ({ filename, mimeType, contentBase64 }))
+        : undefined,
+    }
+  }, [editor, thread, mode, toList, ccList, bccList, subject, attachments])
+
+  const saveDraftNow = useCallback(async () => {
+    if (sentRef.current || discardedRef.current) return
+    if (savingRef.current) { pendingRef.current = true; return }
+    const payload = lastPayloadRef.current
+    if (!payload && !draftIdRef.current) return
+    savingRef.current = true
+    pendingRef.current = false
+    try {
+      if (!payload) {
+        // The composer was deliberately emptied after edits — mirror Gmail and
+        // delete the autosaved draft rather than leaving its stale content.
+        const id = draftIdRef.current
+        if (id && dirtyRef.current) {
+          await window.ipc.invoke('gmail:deleteDraft', { draftId: id })
+          // Only forget the id once the delete succeeded (404/410 count as
+          // success server-side); a thrown failure keeps it for a retry.
+          if (draftIdRef.current === id) draftIdRef.current = undefined
+        }
+        return
+      }
+      payload.draftId = draftIdRef.current
+      const res = await window.ipc.invoke('gmail:saveDraft', payload)
+      if (res?.draftId && !discardedRef.current) draftIdRef.current = res.draftId
+    } catch {
+      // Autosave is best-effort; a failure just leaves the prior draft in place.
+    } finally {
+      savingRef.current = false
+      // Coalesce edits that landed mid-flight into one more save.
+      if (pendingRef.current && !sentRef.current && !discardedRef.current) {
+        pendingRef.current = false
+        void saveDraftNowRef.current?.()
+      }
+    }
+  }, [])
+  useEffect(() => { saveDraftNowRef.current = saveDraftNow }, [saveDraftNow])
+
+  const scheduleAutosave = useCallback(() => {
+    if (autosaveTimer.current) window.clearTimeout(autosaveTimer.current)
+    autosaveTimer.current = window.setTimeout(() => { void saveDraftNow() }, DRAFT_AUTOSAVE_MS)
+  }, [saveDraftNow])
+
+  // Wait (briefly, capped) for any in-flight autosave to settle so send/discard
+  // don't race it into a duplicate or orphaned draft.
+  const waitForSaveIdle = useCallback(async () => {
+    for (let guard = 0; savingRef.current && guard < 40; guard++) {
+      await new Promise((r) => window.setTimeout(r, 50))
+    }
+  }, [])
+
+  // Autosave on body edits (typing, AI insert, undo/redo).
+  useEffect(() => {
+    if (!editor) return
+    const onUpdate = () => {
+      dirtyRef.current = true
+      lastPayloadRef.current = buildDraftPayload()
+      scheduleAutosave()
+    }
+    editor.on('update', onUpdate)
+    return () => { editor.off('update', onUpdate) }
+  }, [editor, buildDraftPayload, scheduleAutosave])
+
+  // Autosave on header edits (recipients, subject, attachments), skipping mount.
+  useEffect(() => {
+    if (!fieldsMounted.current) { fieldsMounted.current = true; return }
+    dirtyRef.current = true
+    lastPayloadRef.current = buildDraftPayload()
+    scheduleAutosave()
+  }, [toList, ccList, bccList, subject, attachments, buildDraftPayload, scheduleAutosave])
+
+  // Safety net: if the composer is torn down without an explicit close (e.g.
+  // navigating away), still flush unsaved edits. closedRef guards the common
+  // path where handleClose already saved.
+  useEffect(() => {
+    return () => {
+      if (autosaveTimer.current) window.clearTimeout(autosaveTimer.current)
+      if (closedRef.current || sentRef.current || discardedRef.current || savingRef.current) return
+      if (!dirtyRef.current) return
+      const payload = lastPayloadRef.current
+      if (!payload) {
+        // Edited down to empty, then torn down — drop the stale draft.
+        if (draftIdRef.current) {
+          void window.ipc.invoke('gmail:deleteDraft', { draftId: draftIdRef.current }).catch(() => {})
+        }
+        return
+      }
+      payload.draftId = draftIdRef.current
+      void window.ipc.invoke('gmail:saveDraft', payload).catch(() => {})
+    }
+  }, [])
+
+  // Close (X / click-away): keep the draft. Flush a final save when there are
+  // unsaved edits. If a save is already in flight it will persist the latest
+  // content, so we skip here to avoid creating a duplicate.
+  const handleClose = useCallback(() => {
+    closedRef.current = true
+    if (autosaveTimer.current) window.clearTimeout(autosaveTimer.current)
+    if (!sentRef.current && !discardedRef.current && !savingRef.current && dirtyRef.current) {
+      const payload = buildDraftPayload()
+      if (payload) {
+        payload.draftId = draftIdRef.current
+        void window.ipc.invoke('gmail:saveDraft', payload).catch(() => {})
+      } else if (draftIdRef.current) {
+        // Closed with the body edited down to empty — mirror Gmail and drop
+        // the autosaved draft instead of keeping its stale content.
+        void window.ipc.invoke('gmail:deleteDraft', { draftId: draftIdRef.current }).catch(() => {})
+      }
+    }
+    onClose()
+  }, [buildDraftPayload, onClose])
+
+  // Discard: delete the autosaved draft (if any), then close.
+  const handleDiscard = useCallback(() => {
+    discardedRef.current = true
+    closedRef.current = true
+    if (autosaveTimer.current) window.clearTimeout(autosaveTimer.current)
+    void (async () => {
+      await waitForSaveIdle()
+      const id = draftIdRef.current
+      if (id) await window.ipc.invoke('gmail:deleteDraft', { draftId: id }).catch(() => {})
+    })()
+    onClose()
+  }, [onClose, waitForSaveIdle])
+
   const [sending, setSending] = useState(false)
   const sendInGmail = async () => {
     if (!editor || sending) return
@@ -1270,43 +1580,89 @@ const ComposeBox = memo(function ComposeBox({
       return
     }
 
-    // Build References chain from all known message ids (newest last).
-    const messageIds = (thread?.messages ?? [])
-      .map((m) => m.messageIdHeader)
-      .filter((v): v is string => Boolean(v))
-    const references = messageIds.join(' ')
-    const inReplyTo = latest?.messageIdHeader
-    // Only replies stay on the thread; forwards and new emails start fresh.
-    const isThreaded = Boolean(thread) && mode !== 'forward' && !isNew
+    const { threadId, inReplyTo, references } = threadingHeaders(mode, thread)
 
+    // Stop autosave from racing the send (it would leave an orphaned draft), and
+    // let any in-flight save settle so we know the draft id to clean up.
+    sentRef.current = true
+    if (autosaveTimer.current) window.clearTimeout(autosaveTimer.current)
     setSending(true)
+    await waitForSaveIdle()
     try {
       const result = await window.ipc.invoke('gmail:sendReply', {
-        threadId: isThreaded ? thread?.threadId : undefined,
+        threadId,
         to: toList.join(', '),
         cc: ccList.length ? ccList.join(', ') : undefined,
         bcc: bccList.length ? bccList.join(', ') : undefined,
         subject: subject.trim() || (thread ? composeSubject(mode, thread.subject) : '(No subject)'),
         bodyHtml: html,
         bodyText: text,
-        inReplyTo: isThreaded ? inReplyTo : undefined,
-        references: isThreaded ? references || undefined : undefined,
+        inReplyTo,
+        references,
         attachments: attachments.length
           ? attachments.map(({ filename, mimeType, contentBase64 }) => ({ filename, mimeType, contentBase64 }))
           : undefined,
       })
       if (result.error) {
+        sentRef.current = false // allow autosave to resume on a failed send
         toast(`Send failed: ${result.error}`, 'error')
         return
       }
+      // Gmail only auto-cleans drafts on a threaded send; remove any draft we
+      // autosaved for a brand-new message so it doesn't linger after sending.
+      const leftover = draftIdRef.current
+      if (leftover) {
+        draftIdRef.current = undefined
+        void window.ipc.invoke('gmail:deleteDraft', { draftId: leftover }).catch(() => {})
+      }
       toast('Sent.', 'success')
+      closedRef.current = true
       onClose()
     } catch (err) {
+      sentRef.current = false
       toast(`Send failed: ${err instanceof Error ? err.message : String(err)}`, 'error')
     } finally {
       setSending(false)
     }
   }
+  sendRef.current = () => { void sendInGmail() }
+
+  // Composer-level shortcuts, on the wrapper so they work from any field.
+  // Inner handlers (recipient menu, link bar, AI Enter) preventDefault first
+  // and keep priority via the defaultPrevented check.
+  const onComposerKeyDown = (e: React.KeyboardEvent) => {
+    if (e.defaultPrevented) return
+    const mod = e.metaKey || e.ctrlKey
+    if (mod && e.key === 'Enter' && !e.shiftKey) {
+      e.preventDefault()
+      e.stopPropagation()
+      // Deferred one tick: a recipient field may have just committed a
+      // half-typed address, and send must read the re-rendered list.
+      window.setTimeout(() => sendRef.current(), 0)
+      return
+    }
+    if (mod && e.shiftKey && e.key.toLowerCase() === 'c') {
+      e.preventDefault()
+      e.stopPropagation()
+      setShowCc(true)
+      setCcFocusSignal((n) => n + 1)
+      return
+    }
+    if (mod && e.shiftKey && e.key.toLowerCase() === 'b') {
+      e.preventDefault()
+      e.stopPropagation()
+      setShowBcc(true)
+      setBccFocusSignal((n) => n + 1)
+      return
+    }
+    // The modal variant closes via Radix's own Escape handling.
+    if (!isModal && e.key === 'Escape') {
+      e.preventDefault()
+      e.stopPropagation()
+      if (linkOpen) cancelLink()
+      else handleClose()
+    }
+  }
 
   const refineWithCopilot = () => {
     if (!editor || !thread) return
@@ -1365,8 +1721,8 @@ const ComposeBox = memo(function ComposeBox({
           </div>
         }
       />
-      {showCc && <RecipientField label="Cc" value={ccList} onChange={setCcList} />}
-      {showBcc && <RecipientField label="Bcc" value={bccList} onChange={setBccList} />}
+      {showCc && <RecipientField label="Cc" value={ccList} onChange={setCcList} focusSignal={ccFocusSignal} />}
+      {showBcc && <RecipientField label="Bcc" value={bccList} onChange={setBccList} focusSignal={bccFocusSignal} />}
       <div className="flex items-center gap-2 border-b border-border px-3 py-2">
         <Input
           className="h-8"
@@ -1379,7 +1735,8 @@ const ComposeBox = memo(function ComposeBox({
               : 'Describe your reply and let AI write it…'}
           disabled={generating}
           onKeyDown={(event) => {
-            if (event.key === 'Enter') {
+            // Plain Enter runs the AI writer; Cmd/Ctrl+Enter bubbles to send.
+            if (event.key === 'Enter' && !event.metaKey && !event.ctrlKey) {
               event.preventDefault()
               void runAiBar()
             }
@@ -1419,7 +1776,7 @@ const ComposeBox = memo(function ComposeBox({
           >{preset.label}</Button>
         ))}
       </div>
-      {(isNew || mode === 'forward') && (
+      {(isModal || mode === 'forward') && (
         <div className="flex min-h-8 items-center gap-2 border-b border-border px-3 text-sm">
           <span className="text-muted-foreground">Subject</span>
           <input
@@ -1431,7 +1788,7 @@ const ComposeBox = memo(function ComposeBox({
       )}
       <EditorContent
         editor={editor}
-        className={cn('w-full overflow-y-auto', isNew ? 'min-h-0 flex-1' : 'max-h-[360px]')}
+        className={cn('w-full overflow-y-auto', isModal ? 'min-h-0 flex-1' : 'max-h-[360px]')}
       />
       <input
         ref={fileInputRef}
@@ -1489,8 +1846,11 @@ const ComposeBox = memo(function ComposeBox({
           <Button type="button" variant="outline" size="xs" onClick={cancelLink}>Cancel</Button>
         </div>
       )}
-      <div className="flex items-center gap-3 border-t border-border px-3 py-2.5">
-        <div className="flex shrink-0 items-center gap-2">
+      {/* flex-wrap: every button here is shrink-0, so on a narrow pane the
+          formatting toolbar wraps to its own line instead of overflowing
+          into (and clipping) the Discard button. */}
+      <div className="flex flex-wrap items-center gap-x-3 gap-y-2 border-t border-border px-3 py-2.5">
+        <div className="flex flex-wrap items-center gap-2">
           <Button
             type="button"
             size="sm"
@@ -1525,21 +1885,42 @@ const ComposeBox = memo(function ComposeBox({
             </Button>
           )}
         </div>
-        {editor && <ComposeToolbar editor={editor} onOpenLink={openLink} />}
-        <Button type="button" variant="ghost" size="sm" className="text-muted-foreground" onClick={onClose}>
-          Discard
-        </Button>
+        {/* Toolbar + Discard share one wrap unit so Discard never strands on
+            a line of its own: wide panes show a single row (unit grows, so
+            ml-auto pins Discard to the right edge); narrow panes wrap the
+            whole unit to a second full-width row with the same alignment.
+            flex-auto (content basis) is what makes the unit wrap at all —
+            a flex-1 zero basis would "fit" forever and squeeze instead. */}
+        <div className="flex flex-auto flex-wrap items-center gap-x-3 gap-y-2">
+          {editor && <ComposeToolbar editor={editor} onOpenLink={openLink} />}
+          <Button type="button" variant="ghost" size="sm" className="ml-auto text-muted-foreground" onClick={handleDiscard}>
+            Discard
+          </Button>
+        </div>
       </div>
     </>
   )
 
-  if (isNew) {
+  if (isModal) {
     return (
-      <Dialog open onOpenChange={(open) => { if (!open) onClose() }}>
+      <Dialog open onOpenChange={(open) => { if (!open) handleClose() }}>
         <DialogContent
           showCloseButton={false}
           aria-describedby={undefined}
           className="flex h-[min(720px,calc(100vh-4rem))] flex-col gap-0 overflow-hidden p-0 font-sans sm:max-w-[840px]"
+          onKeyDown={onComposerKeyDown}
+          onEscapeKeyDown={(event) => {
+            // Radix's Escape runs document-capture, before the inner fields
+            // can claim it — let the link bar and an open recipient-suggestion
+            // menu win; only a bare Escape closes the whole composer.
+            if (linkOpen) {
+              event.preventDefault()
+              cancelLink()
+              return
+            }
+            const target = event.target as HTMLElement | null
+            if (target?.closest('[data-suggestions-open]')) event.preventDefault()
+          }}
         >
           <div className="flex h-10 shrink-0 items-center gap-2 border-b border-border px-3">
             <DialogTitle className="flex-1 text-sm font-medium text-foreground">{modeLabel}</DialogTitle>
@@ -1548,7 +1929,7 @@ const ComposeBox = memo(function ComposeBox({
               variant="ghost"
               size="icon-sm"
               className="size-7 text-muted-foreground"
-              onClick={onClose}
+              onClick={handleClose}
               aria-label="Close compose"
             >
               <X className="size-4" />
@@ -1561,7 +1942,10 @@ const ComposeBox = memo(function ComposeBox({
   }
 
   return (
-    <div className="ml-10 max-w-[720px] overflow-hidden rounded-lg border border-border bg-background font-sans">
+    <div
+      className="gmail-compose-inline ml-10 max-w-[720px] overflow-hidden rounded-lg border border-border bg-background font-sans"
+      onKeyDown={onComposerKeyDown}
+    >
       <div className="flex h-8 items-center justify-between border-b border-border px-3">
         <span className="text-xs font-medium text-muted-foreground">{modeLabel}</span>
         <Button
@@ -1569,7 +1953,7 @@ const ComposeBox = memo(function ComposeBox({
           variant="ghost"
           size="icon-xs"
           className="text-muted-foreground"
-          onClick={onClose}
+          onClick={handleClose}
           aria-label="Close compose"
         >
           <X className="size-3.5" />
@@ -1584,10 +1968,16 @@ function ThreadDetail({
   thread,
   onClose,
   hidden,
+  keysDisabled,
+  onComposingChange,
 }: {
   thread: GmailThread
   onClose: () => void
   hidden?: boolean
+  /** True while a dialog is open above the inbox; suspends the reply keys. */
+  keysDisabled?: boolean
+  /** Reports whether the inline composer is open, so list shortcuts pause. */
+  onComposingChange?: (composing: boolean) => void
 }) {
   const [composeMode, setComposeMode] = useState<ComposeMode | null>(null)
   const [selfEmail, setSelfEmail] = useState<string>('')
@@ -1625,6 +2015,46 @@ function ThreadDetail({
     })
   }, [])
 
+  // Let EmailView pause its list shortcuts while our composer is open. The
+  // cleanup resets on hide/unmount so a hidden-but-mounted detail (up to 5 are
+  // kept alive) can't block them.
+  useEffect(() => {
+    if (hidden) return
+    onComposingChange?.(composeMode !== null)
+    return () => onComposingChange?.(false)
+  }, [hidden, composeMode, onComposingChange])
+
+  // Superhuman-style reply keys for the visible thread. Scoped by `hidden` so
+  // only the on-screen ThreadDetail listens. Escape closes the inline composer
+  // first; with none open it falls through to EmailView's close-thread.
+  useEffect(() => {
+    if (hidden || keysDisabled) return
+    const handleKeyDown = (e: KeyboardEvent) => {
+      if (e.isComposing || e.defaultPrevented) return
+      if (e.ctrlKey || e.metaKey || e.altKey || e.shiftKey) return
+      if (e.key === 'Escape') {
+        if (composeMode !== null) {
+          e.preventDefault()
+          setComposeMode(null)
+        }
+        return
+      }
+      if (composeMode !== null || isEditableTarget(e.target)) return
+      if (e.key === 'r') {
+        e.preventDefault()
+        setComposeMode('reply')
+      } else if (e.key === 'a') {
+        e.preventDefault()
+        setComposeMode(canReplyAll ? 'replyAll' : 'reply')
+      } else if (e.key === 'f') {
+        e.preventDefault()
+        setComposeMode('forward')
+      }
+    }
+    document.addEventListener('keydown', handleKeyDown)
+    return () => document.removeEventListener('keydown', handleKeyDown)
+  }, [hidden, keysDisabled, composeMode, canReplyAll])
+
   return (
     <div className={cn('gmail-detail gmail-detail-inline', hidden && 'gmail-detail-hidden')}>
       <div className="gmail-detail-toolbar">
@@ -1709,8 +2139,200 @@ function ThreadDetail({
   )
 }
 
+// One inbox/search row (plus its kept-alive ThreadDetail). Memoized so cursor
+// moves and page appends only re-render the rows whose props actually changed
+// — re-rendering the whole list mid-scroll is what janks the frame.
+const ThreadRow = memo(function ThreadRow({
+  thread,
+  isSelected,
+  isFocused,
+  isMounted,
+  isLeaving,
+  keysDisabled,
+  onToggle,
+  onMarkRead,
+  onArchive,
+  onTrash,
+  onHoverIn,
+  onHoverOut,
+  onCloseThread,
+  onComposingChange,
+}: {
+  thread: GmailThread
+  isSelected: boolean
+  isFocused: boolean
+  isMounted: boolean
+  isLeaving: boolean
+  keysDisabled: boolean
+  onToggle: (thread: GmailThread) => void
+  onMarkRead: (threadId: string, read?: boolean) => Promise<void>
+  onArchive: (threadId: string) => Promise<void>
+  onTrash: (threadId: string) => Promise<void>
+  onHoverIn: (thread: GmailThread) => void
+  onHoverOut: () => void
+  onCloseThread: () => void
+  onComposingChange: (composing: boolean) => void
+}) {
+  const latest = latestMessage(thread)
+  const isUnread = thread.unread === true
+  const stop = (e: React.MouseEvent | React.KeyboardEvent) => {
+    e.stopPropagation()
+  }
+  return (
+    <div className={cn('gmail-row-group', !isMounted && 'gmail-row-group-cv', isLeaving && 'gmail-row-group-leaving')}>
+      <div
+        className={cn('gmail-row-shell', isSelected && 'gmail-row-shell-selected')}
+        data-thread-id={thread.threadId}
+        onMouseEnter={() => onHoverIn(thread)}
+        onMouseLeave={onHoverOut}
+      >
+        <button
+          type="button"
+          className={cn('gmail-row', isSelected && 'gmail-row-selected', isUnread && 'gmail-row-unread', isFocused && 'gmail-row-focused')}
+          onClick={() => onToggle(thread)}
+        >
+          <span className="gmail-row-dot" aria-hidden />
+          <span className="gmail-row-sender">{extractName(latest?.from || thread.from)}</span>
+          <span className="gmail-row-content">
+            <strong>{thread.summary || thread.subject || '(No subject)'}</strong>
+            <span>{thread.summary ? thread.subject : snippet(latest?.body || thread.latest_email)}</span>
+          </span>
+          <span className="gmail-row-date">{formatInboxTime(latest?.date || thread.date)}</span>
+        </button>
+        <div className="gmail-row-actions" onMouseDown={stop} onClick={stop}>
+          <button
+            type="button"
+            className="gmail-row-action"
+            title={isUnread ? 'Mark as read' : 'Mark as unread'}
+            aria-label={isUnread ? 'Mark as read' : 'Mark as unread'}
+            onClick={(e) => { stop(e); void onMarkRead(thread.threadId, isUnread) }}
+          >
+            {isUnread ? <CheckCheck size={15} /> : <Mail size={15} />}
+          </button>
+          <button
+            type="button"
+            className="gmail-row-action"
+            title="Archive"
+            aria-label="Archive"
+            onClick={(e) => { stop(e); void onArchive(thread.threadId) }}
+          >
+            <Archive size={15} />
+          </button>
+          <button
+            type="button"
+            className="gmail-row-action gmail-row-action-danger"
+            title="Delete"
+            aria-label="Delete"
+            onClick={(e) => { stop(e); void onTrash(thread.threadId) }}
+          >
+            <Trash2 size={15} />
+          </button>
+        </div>
+      </div>
+      {/* Drop the detail as soon as the row starts leaving — the collapse
+          keyframe assumes row height, and the thread is being removed anyway. */}
+      {isMounted && !isLeaving && (
+        <ThreadDetail
+          thread={thread}
+          onClose={onCloseThread}
+          hidden={!isSelected}
+          keysDisabled={keysDisabled}
+          onComposingChange={onComposingChange}
+        />
+      )}
+    </div>
+  )
+})
+
+function ShortcutKey({ children }: { children: React.ReactNode }) {
+  return (
+    <kbd className="inline-flex h-5 min-w-5 items-center justify-center rounded border border-border bg-muted px-1.5 font-mono text-[11px] font-medium text-foreground">
+      {children}
+    </kbd>
+  )
+}
+
+// One shortcut line: `combo` keys render as adjacent chips (a chord or a
+// two-key sequence); `alt` is an equivalent alternative shown after "or".
+function ShortcutRow({ combo, alt, label }: { combo: string[]; alt?: string[]; label: string }) {
+  return (
+    <div className="flex items-center justify-between gap-4 py-1">
+      <span className="text-sm text-muted-foreground">{label}</span>
+      <span className="flex shrink-0 items-center gap-1">
+        {combo.map((key) => <ShortcutKey key={key}>{key}</ShortcutKey>)}
+        {alt && (
+          <>
+            <span className="px-0.5 text-xs text-muted-foreground">or</span>
+            {alt.map((key) => <ShortcutKey key={key}>{key}</ShortcutKey>)}
+          </>
+        )}
+      </span>
+    </div>
+  )
+}
+
+function ShortcutSection({ title, children }: { title: string; children: React.ReactNode }) {
+  return (
+    <div>
+      <div className="mb-1.5 text-xs font-semibold uppercase tracking-wide text-muted-foreground">{title}</div>
+      {children}
+    </div>
+  )
+}
+
+// The "?" cheat sheet. Static list — keep in sync with the handlers in
+// EmailView, ThreadDetail, and ComposeBox.
+function ShortcutsHelpDialog({ open, onOpenChange }: { open: boolean; onOpenChange: (open: boolean) => void }) {
+  const mod = isMac ? '⌘' : 'Ctrl'
+  return (
+    <Dialog open={open} onOpenChange={onOpenChange}>
+      <DialogContent aria-describedby={undefined} className="font-sans sm:max-w-[620px]">
+        <DialogTitle className="text-base font-semibold">Keyboard shortcuts</DialogTitle>
+        <div className="grid grid-cols-1 gap-x-10 gap-y-5 sm:grid-cols-2">
+          <ShortcutSection title="Inbox">
+            <ShortcutRow combo={['J']} alt={['↓']} label="Next thread" />
+            <ShortcutRow combo={['K']} alt={['↑']} label="Previous thread" />
+            <ShortcutRow combo={['Enter']} alt={['O']} label="Open / close thread" />
+            <ShortcutRow combo={['Esc']} label="Close thread / clear search" />
+            <ShortcutRow combo={['E']} label="Archive" />
+            <ShortcutRow combo={['#']} label="Move to trash" />
+            <ShortcutRow combo={['U']} label="Mark read / unread" />
+            <ShortcutRow combo={['C']} alt={['N']} label="New message" />
+            <ShortcutRow combo={['/']} label="Search" />
+            <ShortcutRow combo={['G', 'I']} label="Go to inbox" />
+            <ShortcutRow combo={['G', 'D']} label="Go to drafts" />
+            <ShortcutRow combo={['?']} label="Keyboard shortcuts" />
+          </ShortcutSection>
+          <div className="flex flex-col gap-5">
+            <ShortcutSection title="Thread">
+              <ShortcutRow combo={['R']} label="Reply" />
+              <ShortcutRow combo={['A']} label="Reply all" />
+              <ShortcutRow combo={['F']} label="Forward" />
+            </ShortcutSection>
+            <ShortcutSection title="Composer">
+              <ShortcutRow combo={[mod, 'Enter']} label="Send" />
+              <ShortcutRow combo={[mod, 'Shift', 'C']} label="Add Cc" />
+              <ShortcutRow combo={[mod, 'Shift', 'B']} label="Add Bcc" />
+              <ShortcutRow combo={['Esc']} label="Close (saves draft)" />
+            </ShortcutSection>
+          </div>
+        </div>
+      </DialogContent>
+    </Dialog>
+  )
+}
+
 const MAX_KEPT_OPEN = 5
 const PAGE_SIZE = 25
+// Duration of the row slide-out on archive/trash — matches gmail-row-leave.
+const ROW_LEAVE_MS = 160
+// Sticky .gmail-list-header height — rows scrolled to the top stay clear of it.
+const LIST_STICKY_HEADER_PX = 32
+
+function listScrollerFor(row: HTMLElement): HTMLElement | null {
+  const list = row.closest('.gmail-list')
+  return list instanceof HTMLElement ? list : null
+}
 type InboxSection = 'important' | 'other'
 
 interface SectionState {
@@ -1731,6 +2353,8 @@ const initialSectionState: SectionState = {
 // panels and coming back doesn't reload from scratch.
 let persistedImportant: SectionState | null = null
 let persistedOther: SectionState | null = null
+// Last-loaded drafts, kept across EmailView remounts so reopening is instant.
+let persistedDrafts: GmailThread[] | null = null
 
 function clearLoadingFlag(state: SectionState | null): SectionState {
   if (!state) return initialSectionState
@@ -1752,6 +2376,7 @@ export function EmailView({ initialThreadId, threadIdVersion }: EmailViewProps =
   const [openedThreadIds, setOpenedThreadIds] = useState<string[]>(initialThreadId ? [initialThreadId] : [])
   useEffect(() => {
     setSelectedThreadId(initialThreadId ?? null)
+    setFocusedThreadId(initialThreadId ?? null)
     if (initialThreadId) {
       setOpenedThreadIds((prev) => {
         const without = prev.filter((id) => id !== initialThreadId)
@@ -1765,9 +2390,114 @@ export function EmailView({ initialThreadId, threadIdVersion }: EmailViewProps =
   const [composeOpen, setComposeOpen] = useState(false)
   // Stable so the open composer isn't re-rendered on every inbox sync tick.
   const closeCompose = useCallback(() => setComposeOpen(false), [])
+  // Inbox vs Drafts. Drafts are fetched live (they're not in the inbox cache).
+  const [view, setView] = useState<'inbox' | 'drafts'>('inbox')
+  const [drafts, setDrafts] = useState<GmailThread[]>(() => persistedDrafts ?? [])
+  const [draftsLoading, setDraftsLoading] = useState(false)
+  const [draftsError, setDraftsError] = useState<string | null>(null)
+  const [editingDraft, setEditingDraft] = useState<GmailThread | null>(null)
+  // Server-side search across the whole Gmail mailbox (results indexed locally).
+  const [searchResults, setSearchResults] = useState<GmailThread[]>([])
+  const [searching, setSearching] = useState(false)
+  const [searchError, setSearchError] = useState<string | null>(null)
+  const searchEpoch = useRef(0)
   // Gmail sync uses the native Google OAuth connection.
   const [emailConnection, setEmailConnection] = useState<GmailConnectionStatus | null>(null)
   const [settingsOpen, setSettingsOpen] = useState(false)
+  // Keyboard navigation: the j/k focus cursor over the visible rows, plus the
+  // "?" shortcuts overlay. lastFocusedIndexRef remembers the cursor's position
+  // so it can re-anchor when the focused row disappears (archive/trash/reload).
+  const [focusedThreadId, setFocusedThreadId] = useState<string | null>(null)
+  const [helpOpen, setHelpOpen] = useState(false)
+  // Set while the visible ThreadDetail's inline composer is open; list
+  // shortcuts stay inert so typing a reply can't archive threads.
+  const [activeThreadComposing, setActiveThreadComposing] = useState(false)
+  const searchInputRef = useRef<HTMLInputElement>(null)
+  const rootRef = useRef<HTMLDivElement>(null)
+  const lastFocusedIndexRef = useRef(0)
+  const listModeRef = useRef<string | null>(null)
+  // Timestamp of a pending "g" for the two-key g→i / g→d sequences.
+  const gPendingRef = useRef(0)
+  // Rows currently animating out (archive/trash/draft-delete in flight).
+  const [leavingThreadIds, setLeavingThreadIds] = useState<ReadonlySet<string>>(() => new Set())
+  const markLeaving = useCallback((rowId: string, leaving: boolean) => {
+    setLeavingThreadIds((prev) => {
+      if (prev.has(rowId) === leaving) return prev
+      const next = new Set(prev)
+      if (leaving) next.add(rowId)
+      else next.delete(rowId)
+      return next
+    })
+  }, [])
+
+  const loadDrafts = useCallback(async () => {
+    setDraftsLoading(true)
+    setDraftsError(null)
+    try {
+      const res = await window.ipc.invoke('gmail:getDrafts', {})
+      if (res.error) setDraftsError(res.error)
+      setDrafts(res.threads ?? [])
+    } catch (err) {
+      setDraftsError(err instanceof Error ? err.message : String(err))
+    } finally {
+      setDraftsLoading(false)
+    }
+  }, [])
+
+  // Load drafts when the Drafts view is opened.
+  useEffect(() => {
+    if (view === 'drafts') void loadDrafts()
+  }, [view, loadDrafts])
+
+  // Debounced full-mailbox search. Each keystroke bumps an epoch so stale
+  // responses are ignored; an empty query clears results.
+  useEffect(() => {
+    const q = query.trim()
+    searchEpoch.current += 1
+    const epoch = searchEpoch.current
+    if (!q) {
+      setSearchResults([])
+      setSearchError(null)
+      setSearching(false)
+      return
+    }
+    setSearching(true)
+    const handle = window.setTimeout(async () => {
+      try {
+        const res = await window.ipc.invoke('gmail:search', { query: q, limit: 100 })
+        if (searchEpoch.current !== epoch) return
+        setSearchError(res.error ?? null)
+        setSearchResults(res.threads ?? [])
+      } catch (err) {
+        if (searchEpoch.current === epoch) setSearchError(err instanceof Error ? err.message : String(err))
+      } finally {
+        if (searchEpoch.current === epoch) setSearching(false)
+      }
+    }, 400)
+    return () => window.clearTimeout(handle)
+  }, [query])
+
+  const deleteDraftAction = useCallback(async (thread: GmailThread) => {
+    const id = thread.draftId
+    if (!id) return
+    // Slide the row out before dropping it from the list.
+    markLeaving(id, true)
+    await new Promise((resolve) => window.setTimeout(resolve, ROW_LEAVE_MS))
+    setDrafts((prev) => prev.filter((d) => d.draftId !== id))
+    markLeaving(id, false)
+    try {
+      await window.ipc.invoke('gmail:deleteDraft', { draftId: id })
+    } catch (err) {
+      toast(`Could not delete draft: ${err instanceof Error ? err.message : String(err)}`, 'error')
+      void loadDrafts()
+    }
+  }, [loadDrafts, markLeaving])
+
+  // Closing the draft composer may have edited/sent/deleted it — refresh.
+  const closeDraftEditor = useCallback(() => {
+    setEditingDraft(null)
+    void loadDrafts()
+  }, [loadDrafts])
 
   useEffect(() => {
     let cancelled = false
@@ -1794,32 +2524,9 @@ export function EmailView({ initialThreadId, threadIdVersion }: EmailViewProps =
     }
   }, [])
 
-  // Gmail-style "n" to start a new message. EmailView only mounts while the
-  // inbox is open, so this is naturally scoped to that view. Ignored while
-  // typing in any field or when a dialog (compose/settings) is already up.
-  useEffect(() => {
-    const handleKeyDown = (e: KeyboardEvent) => {
-      if (e.key !== 'n' || e.ctrlKey || e.metaKey || e.altKey || e.shiftKey || e.isComposing) return
-      if (composeOpen || settingsOpen) return
-      const target = e.target as HTMLElement | null
-      if (
-        target &&
-        (target.tagName === 'INPUT' ||
-          target.tagName === 'TEXTAREA' ||
-          target.tagName === 'SELECT' ||
-          target.isContentEditable)
-      ) {
-        return
-      }
-      e.preventDefault()
-      setComposeOpen(true)
-    }
-    document.addEventListener('keydown', handleKeyDown)
-    return () => document.removeEventListener('keydown', handleKeyDown)
-  }, [composeOpen, settingsOpen])
-
   useEffect(() => { persistedImportant = important }, [important])
   useEffect(() => { persistedOther = other }, [other])
+  useEffect(() => { persistedDrafts = drafts }, [drafts])
 
   const setSection = useCallback((section: InboxSection, updater: (prev: SectionState) => SectionState) => {
     if (section === 'important') setImportant(updater)
@@ -1833,6 +2540,7 @@ export function EmailView({ initialThreadId, threadIdVersion }: EmailViewProps =
     })
     setImportant(mapSection)
     setOther(mapSection)
+    setSearchResults((prev) => prev.map((t) => (t.threadId === threadId ? updater(t) : t)))
   }, [])
 
   const removeThreadFromState = useCallback((threadId: string) => {
@@ -1842,18 +2550,19 @@ export function EmailView({ initialThreadId, threadIdVersion }: EmailViewProps =
     })
     setImportant(filterSection)
     setOther(filterSection)
+    setSearchResults((prev) => prev.filter((t) => t.threadId !== threadId))
     setSelectedThreadId((current) => (current === threadId ? null : current))
     setOpenedThreadIds((prev) => prev.filter((id) => id !== threadId))
   }, [])
 
-  const markThreadReadAction = useCallback(async (threadId: string) => {
+  const markThreadReadAction = useCallback(async (threadId: string, read: boolean = true) => {
     updateThreadInState(threadId, (t) => ({
       ...t,
-      unread: false,
-      messages: t.messages.map((m) => ({ ...m, unread: false })),
+      unread: !read,
+      messages: t.messages.map((m) => ({ ...m, unread: !read })),
     }))
     try {
-      const result = await window.ipc.invoke('gmail:markThreadRead', { threadId })
+      const result = await window.ipc.invoke('gmail:markThreadRead', { threadId, read })
       if (!result.ok && result.error) console.warn('[Gmail] mark-read failed:', result.error)
     } catch (err) {
       console.warn('[Gmail] mark-read failed:', err)
@@ -1861,8 +2570,14 @@ export function EmailView({ initialThreadId, threadIdVersion }: EmailViewProps =
   }, [updateThreadInState])
 
   const archiveThreadAction = useCallback(async (threadId: string) => {
+    // Start the slide-out right away; the row is removed once both the IPC
+    // and the animation have finished. A failure clears the flag → snap back.
+    markLeaving(threadId, true)
     try {
-      const result = await window.ipc.invoke('gmail:archiveThread', { threadId })
+      const [result] = await Promise.all([
+        window.ipc.invoke('gmail:archiveThread', { threadId }),
+        new Promise((resolve) => window.setTimeout(resolve, ROW_LEAVE_MS)),
+      ])
       if (result.ok) {
         removeThreadFromState(threadId)
       } else if (result.error) {
@@ -1870,12 +2585,18 @@ export function EmailView({ initialThreadId, threadIdVersion }: EmailViewProps =
       }
     } catch (err) {
       toast(`Archive failed: ${err instanceof Error ? err.message : String(err)}`, 'error')
+    } finally {
+      markLeaving(threadId, false)
     }
-  }, [removeThreadFromState])
+  }, [removeThreadFromState, markLeaving])
 
   const trashThreadAction = useCallback(async (threadId: string) => {
+    markLeaving(threadId, true)
     try {
-      const result = await window.ipc.invoke('gmail:trashThread', { threadId })
+      const [result] = await Promise.all([
+        window.ipc.invoke('gmail:trashThread', { threadId }),
+        new Promise((resolve) => window.setTimeout(resolve, ROW_LEAVE_MS)),
+      ])
       if (result.ok) {
         removeThreadFromState(threadId)
       } else if (result.error) {
@@ -1883,10 +2604,13 @@ export function EmailView({ initialThreadId, threadIdVersion }: EmailViewProps =
       }
     } catch (err) {
       toast(`Delete failed: ${err instanceof Error ? err.message : String(err)}`, 'error')
+    } finally {
+      markLeaving(threadId, false)
     }
-  }, [removeThreadFromState])
+  }, [removeThreadFromState, markLeaving])
 
   const toggleThread = useCallback((thread: GmailThread) => {
+    setFocusedThreadId(thread.threadId)
     setSelectedThreadId((current) => {
       const next = current === thread.threadId ? null : thread.threadId
       if (next) {
@@ -2151,98 +2875,374 @@ export function EmailView({ initialThreadId, threadIdVersion }: EmailViewProps =
 
   const visibleImportant = useMemo(() => filterThreads(important.threads), [important.threads, filterThreads])
   const visibleOther = useMemo(() => filterThreads(other.threads), [other.threads, filterThreads])
+  const visibleDrafts = useMemo(() => filterThreads(drafts), [drafts, filterThreads])
+
+  // ── Keyboard shortcuts (Superhuman-style) ───────────────────────────────────
+  // EmailView only mounts while the email tab is open, so these are naturally
+  // scoped to that view. Single-letter keys stay inert while typing in any
+  // field, while a dialog is up, or while the inline reply composer is open.
+
+  const listMode: 'search' | 'drafts' | 'inbox' = query.trim() ? 'search' : view === 'drafts' ? 'drafts' : 'inbox'
+  const anyModalOpen = composeOpen || settingsOpen || Boolean(editingDraft) || helpOpen
+
+  // Row identity for the focus cursor — must match each row's data-thread-id.
+  const rowIdOf = useCallback((thread: GmailThread) => (
+    listMode === 'drafts' ? (thread.draftId || thread.threadId) : thread.threadId
+  ), [listMode])
+
+  // Flattened, ordered list of the rows currently on screen — the domain of
+  // the j/k cursor. Mirrors the render branches below: search results, drafts,
+  // or Important followed by Everything else (which only renders once
+  // Important is exhausted).
+  const visibleList = useMemo<GmailThread[]>(() => {
+    if (query.trim()) return searchResults
+    if (view === 'drafts') return visibleDrafts
+    if (important.hasReachedEnd && other.threads.length > 0) return [...visibleImportant, ...visibleOther]
+    return visibleImportant
+  }, [query, searchResults, view, visibleDrafts, visibleImportant, visibleOther, important.hasReachedEnd, other.threads.length])
+
+  // Keep the cursor valid as the list changes: switching between inbox,
+  // search, and drafts resets it; if the focused row vanished (archived,
+  // trashed, or replaced by a live reload), re-anchor to the same position.
+  useEffect(() => {
+    if (listModeRef.current !== listMode) {
+      const isFirstRun = listModeRef.current === null
+      listModeRef.current = listMode
+      if (!isFirstRun) {
+        lastFocusedIndexRef.current = 0
+        setFocusedThreadId(null)
+        return
+      }
+    }
+    if (!focusedThreadId || visibleList.length === 0) return
+    const idx = visibleList.findIndex((t) => rowIdOf(t) === focusedThreadId)
+    if (idx >= 0) {
+      lastFocusedIndexRef.current = idx
+      return
+    }
+    const fallback = visibleList[Math.min(lastFocusedIndexRef.current, visibleList.length - 1)]
+    setFocusedThreadId(fallback ? rowIdOf(fallback) : null)
+  }, [visibleList, focusedThreadId, listMode, rowIdOf])
+
+  // ── Smooth list scrolling ──────────────────────────────────────────────────
+  // Short ease-out scroll instead of native behavior:'smooth' — it finishes in
+  // ~140ms and retargets cleanly under key-repeat, where the native animation
+  // lags behind and rubber-bands.
+  const scrollAnimRef = useRef<number | null>(null)
+  const smoothScrollTo = useCallback((container: HTMLElement, top: number) => {
+    if (scrollAnimRef.current !== null) window.cancelAnimationFrame(scrollAnimRef.current)
+    const from = container.scrollTop
+    const max = container.scrollHeight - container.clientHeight
+    const target = Math.min(Math.max(top, 0), max)
+    const delta = target - from
+    if (delta === 0) return
+    if (window.matchMedia('(prefers-reduced-motion: reduce)').matches) {
+      container.scrollTop = target
+      return
+    }
+    const start = performance.now()
+    const duration = 140
+    const step = (now: number) => {
+      const t = Math.min(1, (now - start) / duration)
+      const eased = 1 - (1 - t) ** 3
+      container.scrollTop = from + delta * eased
+      scrollAnimRef.current = t < 1 ? window.requestAnimationFrame(step) : null
+    }
+    scrollAnimRef.current = window.requestAnimationFrame(step)
+  }, [])
+
+  useEffect(() => () => {
+    if (scrollAnimRef.current !== null) window.cancelAnimationFrame(scrollAnimRef.current)
+  }, [])
+
+  const rowElementFor = useCallback((rowId: string) => {
+    const el = rootRef.current?.querySelector(`[data-thread-id="${CSS.escape(rowId)}"]`)
+    return el instanceof HTMLElement ? el : null
+  }, [])
+
+  // Keep the focused row on screen during keyboard navigation — "nearest"
+  // semantics with the animated scroll, minding the sticky section header.
+  useEffect(() => {
+    if (!focusedThreadId) return
+    const row = rowElementFor(focusedThreadId)
+    const list = row ? listScrollerFor(row) : null
+    if (!row || !list) return
+    const listRect = list.getBoundingClientRect()
+    const rowRect = row.getBoundingClientRect()
+    const topEdge = listRect.top + LIST_STICKY_HEADER_PX
+    if (rowRect.top < topEdge) {
+      smoothScrollTo(list, list.scrollTop + rowRect.top - topEdge)
+    } else if (rowRect.bottom > listRect.bottom) {
+      smoothScrollTo(list, list.scrollTop + rowRect.bottom - listRect.bottom)
+    }
+  }, [focusedThreadId, rowElementFor, smoothScrollTo])
+
+  // Opening a thread glides its row to the top of the list so the expanded
+  // conversation gets the full viewport. Runs after the focus effect above and
+  // cancels its animation via the shared ref, so on open this scroll wins.
+  useEffect(() => {
+    if (!selectedThreadId) return
+    const row = rowElementFor(selectedThreadId)
+    const list = row ? listScrollerFor(row) : null
+    if (!row || !list) return
+    const rowTop = list.scrollTop + row.getBoundingClientRect().top - list.getBoundingClientRect().top
+    smoothScrollTo(list, rowTop - LIST_STICKY_HEADER_PX)
+  }, [selectedThreadId, rowElementFor, smoothScrollTo])
+
+  // While the list is scrolling, flag the shell so CSS turns off row pointer
+  // events (see .gmail-shell[data-scrolling]) — otherwise every row passing
+  // under the cursor restyles for :hover and schedules a prefetch timer,
+  // stealing frame time. The attribute is toggled straight on the DOM node so
+  // scrolling itself never causes a React render.
+  useEffect(() => {
+    const root = rootRef.current
+    if (!root) return
+    let timer: number | null = null
+    const onScroll = (event: Event) => {
+      const target = event.target
+      if (!(target instanceof Element) || !target.classList.contains('gmail-list')) return
+      if (timer === null) root.setAttribute('data-scrolling', '')
+      else window.clearTimeout(timer)
+      timer = window.setTimeout(() => {
+        timer = null
+        root.removeAttribute('data-scrolling')
+      }, 150)
+    }
+    // Capture phase: scroll events don't bubble, so listen above the scroller.
+    root.addEventListener('scroll', onScroll, { capture: true, passive: true })
+    return () => {
+      root.removeEventListener('scroll', onScroll, { capture: true })
+      if (timer !== null) window.clearTimeout(timer)
+    }
+  }, [])
+
+  useEffect(() => {
+    const handleKeyDown = (e: KeyboardEvent) => {
+      if (e.isComposing || e.defaultPrevented) return
+      // All list keys are unmodified. Shift is allowed through because "#" and
+      // "?" need it; shifted letters produce uppercase e.key and match nothing.
+      if (e.ctrlKey || e.metaKey || e.altKey) return
+      const inEditable = isEditableTarget(e.target)
+
+      if (e.key === 'Escape') {
+        // The search input, recipient fields, and composers own their Escape;
+        // this level only closes the open thread or clears the search.
+        if (inEditable || anyModalOpen || activeThreadComposing) return
+        if (selectedThreadId) {
+          e.preventDefault()
+          setSelectedThreadId(null)
+          return
+        }
+        if (query.trim()) {
+          e.preventDefault()
+          setQuery('')
+        }
+        return
+      }
+
+      if (inEditable || anyModalOpen || activeThreadComposing) return
+
+      // Two-key "go to" sequences: g then i (inbox) / g then d (drafts).
+      if (gPendingRef.current && Date.now() - gPendingRef.current < 1000) {
+        gPendingRef.current = 0
+        if (e.key === 'i' || e.key === 'd') {
+          e.preventDefault()
+          setQuery('')
+          setView(e.key === 'i' ? 'inbox' : 'drafts')
+          return
+        }
+        // Any other key cancels the sequence and is handled normally below.
+      }
+      if (e.key === 'g') {
+        gPendingRef.current = Date.now()
+        return
+      }
+
+      const focusedIndex = focusedThreadId
+        ? visibleList.findIndex((t) => rowIdOf(t) === focusedThreadId)
+        : -1
+
+      const moveFocus = (delta: number) => {
+        if (visibleList.length === 0) return
+        e.preventDefault() // stop arrow keys from also scrolling the list
+        const next = visibleList[Math.min(Math.max(focusedIndex + delta, 0), visibleList.length - 1)]
+        if (next) setFocusedThreadId(rowIdOf(next))
+      }
+
+      switch (e.key) {
+        case 'j':
+        case 'ArrowDown':
+          moveFocus(1)
+          return
+        case 'k':
+        case 'ArrowUp':
+          moveFocus(-1)
+          return
+        case 'Enter':
+        case 'o': {
+          const focused = focusedIndex >= 0 ? visibleList[focusedIndex] : undefined
+          if (!focused) return
+          e.preventDefault()
+          if (listMode === 'drafts') setEditingDraft(focused)
+          else toggleThread(focused)
+          return
+        }
+        case 'c':
+        case 'n':
+          e.preventDefault()
+          setComposeOpen(true)
+          return
+        case '/':
+          e.preventDefault()
+          searchInputRef.current?.focus()
+          return
+        case '?':
+          e.preventDefault()
+          setHelpOpen(true)
+          return
+        case 'e':
+        case '#':
+        case 'u': {
+          if (listMode === 'drafts') return // drafts have no archive/trash/read state
+          // The open thread takes precedence over the cursor.
+          const targetId = selectedThreadId ?? (focusedIndex >= 0 ? visibleList[focusedIndex]?.threadId : undefined)
+          const target = targetId ? visibleList.find((t) => t.threadId === targetId) : undefined
+          if (!target) return
+          e.preventDefault()
+          if (e.key === 'u') void markThreadReadAction(target.threadId, target.unread === true)
+          else if (e.key === 'e') void archiveThreadAction(target.threadId)
+          else void trashThreadAction(target.threadId)
+          return
+        }
+      }
+    }
+    document.addEventListener('keydown', handleKeyDown)
+    return () => document.removeEventListener('keydown', handleKeyDown)
+  }, [
+    visibleList, focusedThreadId, selectedThreadId, query, listMode, anyModalOpen,
+    activeThreadComposing, rowIdOf, toggleThread, markThreadReadAction,
+    archiveThreadAction, trashThreadAction,
+  ])
 
   const hasAny = important.threads.length > 0 || other.threads.length > 0
   const initialLoading = !hasAny && refreshing
   const needsEmailConnect = emailConnection?.connected === false
   const needsEmailReconnect = emailConnection?.connected === true && !emailConnection.hasRequiredScope
 
+  const closeThread = useCallback(() => setSelectedThreadId(null), [])
+
   const renderRow = (thread: GmailThread) => {
-    const latest = latestMessage(thread)
-    const isSelected = thread.threadId === selectedThreadId
-    const isUnread = thread.unread === true
     const isMounted = openedThreadIds.includes(thread.threadId)
-    const stop = (e: React.MouseEvent | React.KeyboardEvent) => {
-      e.stopPropagation()
-    }
     return (
-      <div key={thread.threadId} className="gmail-row-group">
-        <div
-          className={cn('gmail-row-shell', isSelected && 'gmail-row-shell-selected')}
-          onMouseEnter={() => scheduleHoverPrefetch(thread)}
-          onMouseLeave={cancelHoverPrefetch}
-        >
+      <ThreadRow
+        key={thread.threadId}
+        thread={thread}
+        isSelected={thread.threadId === selectedThreadId}
+        isFocused={thread.threadId === focusedThreadId}
+        isMounted={isMounted}
+        isLeaving={leavingThreadIds.has(thread.threadId)}
+        keysDisabled={isMounted && anyModalOpen}
+        onToggle={toggleThread}
+        onMarkRead={markThreadReadAction}
+        onArchive={archiveThreadAction}
+        onTrash={trashThreadAction}
+        onHoverIn={scheduleHoverPrefetch}
+        onHoverOut={cancelHoverPrefetch}
+        onCloseThread={closeThread}
+        onComposingChange={setActiveThreadComposing}
+      />
+    )
+  }
+
+  const renderDraftRow = (thread: GmailThread) => {
+    const stop = (e: React.MouseEvent | React.KeyboardEvent) => { e.stopPropagation() }
+    const recipient = thread.to ? extractName(thread.to) : 'No recipient'
+    const rowId = thread.draftId || thread.threadId
+    const isFocused = rowId === focusedThreadId
+    const isLeaving = leavingThreadIds.has(rowId)
+    return (
+      <div key={rowId} className={cn('gmail-row-group', 'gmail-row-group-cv', isLeaving && 'gmail-row-group-leaving')}>
+        <div className="gmail-row-shell" data-thread-id={rowId}>
           <button
             type="button"
-            className={cn('gmail-row', isSelected && 'gmail-row-selected', isUnread && 'gmail-row-unread')}
-            onClick={() => toggleThread(thread)}
+            className={cn('gmail-row', isFocused && 'gmail-row-focused')}
+            onClick={() => setEditingDraft(thread)}
           >
             <span className="gmail-row-dot" aria-hidden />
-            <span className="gmail-row-sender">{extractName(latest?.from || thread.from)}</span>
+            <span className="gmail-row-sender">To: {recipient}</span>
             <span className="gmail-row-content">
-              <strong>{thread.summary || thread.subject || '(No subject)'}</strong>
-              <span>{thread.summary ? thread.subject : snippet(latest?.body || thread.latest_email)}</span>
+              <strong>{thread.subject || '(No subject)'}</strong>
+              <span>{snippet(thread.gmail_draft || thread.latest_email)}</span>
             </span>
-            <span className="gmail-row-date">{formatInboxTime(latest?.date || thread.date)}</span>
+            <span className="gmail-row-date">{formatInboxTime(thread.date)}</span>
           </button>
           <div className="gmail-row-actions" onMouseDown={stop} onClick={stop}>
-            {isUnread && (
-              <button
-                type="button"
-                className="gmail-row-action"
-                title="Mark as read"
-                aria-label="Mark as read"
-                onClick={(e) => { stop(e); void markThreadReadAction(thread.threadId) }}
-              >
-                <CheckCheck size={15} />
-              </button>
-            )}
-            <button
-              type="button"
-              className="gmail-row-action"
-              title="Archive"
-              aria-label="Archive"
-              onClick={(e) => { stop(e); void archiveThreadAction(thread.threadId) }}
-            >
-              <Archive size={15} />
-            </button>
             <button
               type="button"
               className="gmail-row-action gmail-row-action-danger"
-              title="Delete"
-              aria-label="Delete"
-              onClick={(e) => { stop(e); void trashThreadAction(thread.threadId) }}
+              title="Delete draft"
+              aria-label="Delete draft"
+              onClick={(e) => { stop(e); void deleteDraftAction(thread) }}
             >
               <Trash2 size={15} />
             </button>
           </div>
         </div>
-        {isMounted && (
-          <ThreadDetail
-            thread={thread}
-            onClose={() => setSelectedThreadId(null)}
-            hidden={!isSelected}
-          />
-        )}
       </div>
     )
   }
 
   return (
-    <div className="gmail-shell">
+    <div className="gmail-shell" ref={rootRef}>
       <div className="gmail-main">
         <div className="gmail-topbar">
           <div className="gmail-search">
             <Search size={18} />
             <input
+              ref={searchInputRef}
               value={query}
               onChange={(event) => setQuery(event.target.value)}
-              placeholder="Search loaded mail"
+              placeholder="Search all mail"
+              onKeyDown={(event) => {
+                if (event.key !== 'Escape') return
+                event.preventDefault()
+                event.stopPropagation()
+                if (query) setQuery('')
+                else event.currentTarget.blur()
+              }}
             />
+            {query && (
+              <button
+                type="button"
+                className="gmail-search-clear"
+                onClick={() => setQuery('')}
+                title="Clear search"
+                aria-label="Clear search"
+              >
+                <X size={16} />
+              </button>
+            )}
           </div>
           <div className="gmail-topbar-actions">
-            <button type="button" className="gmail-icon-button" onClick={() => void refresh()} aria-label="Refresh">
-              {refreshing ? <LoaderIcon size={18} className="animate-spin" /> : <RefreshCw size={18} />}
+            <div className="flex items-center rounded-md border border-border p-0.5 text-xs font-medium">
+              <button
+                type="button"
+                className={cn('rounded px-2.5 py-1 transition-colors', view === 'inbox' ? 'bg-accent text-foreground' : 'text-muted-foreground hover:text-foreground')}
+                onClick={() => setView('inbox')}
+              >Inbox</button>
+              <button
+                type="button"
+                className={cn('rounded px-2.5 py-1 transition-colors', view === 'drafts' ? 'bg-accent text-foreground' : 'text-muted-foreground hover:text-foreground')}
+                onClick={() => setView('drafts')}
+              >Drafts{drafts.length > 0 ? ` (${drafts.length})` : ''}</button>
+            </div>
+            <button
+              type="button"
+              className="gmail-icon-button"
+              onClick={() => { if (view === 'drafts') void loadDrafts(); else void refresh() }}
+              aria-label="Refresh"
+            >
+              {(view === 'drafts' ? draftsLoading : refreshing) ? <LoaderIcon size={18} className="animate-spin" /> : <RefreshCw size={18} />}
             </button>
             <button type="button" className="gmail-icon-button" onClick={() => setComposeOpen(true)} aria-label="Compose new email">
               <SquarePen size={18} />
@@ -2250,7 +3250,43 @@ export function EmailView({ initialThreadId, threadIdVersion }: EmailViewProps =
           </div>
         </div>
 
-        {error && !hasAny ? (
+        {query.trim() ? (
+          searchError && searchResults.length === 0 ? (
+            <div className="gmail-empty-state">Could not search: {searchError}</div>
+          ) : searchResults.length > 0 ? (
+            <div className="gmail-list" aria-label="Search results">
+              <section className="gmail-section">
+                <div className="gmail-list-header">
+                  <span>Search results</span>
+                  <span>{searchResults.length} thread{searchResults.length === 1 ? '' : 's'}</span>
+                </div>
+                {searchResults.map(renderRow)}
+              </section>
+            </div>
+          ) : (
+            <div className="gmail-empty-state">
+              {searching ? 'Searching all mail…' : `No results for “${query.trim()}”.`}
+            </div>
+          )
+        ) : view === 'drafts' ? (
+          draftsError && drafts.length === 0 ? (
+            <div className="gmail-empty-state">Could not load drafts: {draftsError}</div>
+          ) : drafts.length > 0 ? (
+            <div className="gmail-list" aria-label="Drafts">
+              <section className="gmail-section">
+                <div className="gmail-list-header">
+                  <span>Drafts</span>
+                  <span>{drafts.length} draft{drafts.length === 1 ? '' : 's'}</span>
+                </div>
+                {visibleDrafts.map(renderDraftRow)}
+              </section>
+            </div>
+          ) : (
+            <div className="gmail-empty-state">
+              {draftsLoading ? 'Loading drafts…' : 'No drafts yet.'}
+            </div>
+          )
+        ) : error && !hasAny ? (
           <div className="gmail-empty-state">Could not load mail: {error}</div>
         ) : hasAny ? (
           <div className="gmail-list" aria-label="Recent emails">
@@ -2315,7 +3351,16 @@ export function EmailView({ initialThreadId, threadIdVersion }: EmailViewProps =
         )}
       </div>
       {composeOpen && <ComposeBox mode="new" onClose={closeCompose} />}
+      {editingDraft && (
+        <ComposeBox
+          mode="draft"
+          thread={editingDraft}
+          selfEmail={emailConnection?.email ?? ''}
+          onClose={closeDraftEditor}
+        />
+      )}
       <SettingsDialog open={settingsOpen} onOpenChange={setSettingsOpen} defaultTab="connections" />
+      <ShortcutsHelpDialog open={helpOpen} onOpenChange={setHelpOpen} />
     </div>
   )
 }
diff --git a/apps/x/apps/renderer/src/components/live-note-sidebar.tsx b/apps/x/apps/renderer/src/components/live-note-sidebar.tsx
index 1510e6c9..18654729 100644
--- a/apps/x/apps/renderer/src/components/live-note-sidebar.tsx
+++ b/apps/x/apps/renderer/src/components/live-note-sidebar.tsx
@@ -11,11 +11,9 @@ import {
   ChevronDown, ChevronRight,
 } from 'lucide-react'
 import { LiveNoteSchema, type LiveNote, type Triggers } from '@x/shared/dist/live-note.js'
-import type { Run } from '@x/shared/dist/runs.js'
-import type z from 'zod'
 import { useLiveNoteAgentStatus } from '@/hooks/use-live-note-agent-status'
 import { formatRelativeTime } from '@/lib/relative-time'
-import { runLogToConversation } from '@/lib/run-to-conversation'
+import { fetchAgentRunTranscript, type AgentRunTranscript } from '@/lib/agent-transcript'
 import { CompactConversation } from '@/components/compact-conversation'
 
 export type OpenLiveNotePanelDetail = {
@@ -661,7 +659,7 @@ function SectionRegion({ label, children }: { label?: string; children: React.Re
 }
 
 function LastRunTab({ live }: { live: LiveNote }) {
-  const [run, setRun] = useState<z.infer<typeof Run> | null>(null)
+  const [transcript, setTranscript] = useState<AgentRunTranscript | null>(null)
   const [loadingRun, setLoadingRun] = useState(false)
   const [fetchError, setFetchError] = useState<string | null>(null)
 
@@ -669,7 +667,7 @@ function LastRunTab({ live }: { live: LiveNote }) {
 
   useEffect(() => {
     if (!runId) {
-      setRun(null)
+      setTranscript(null)
       setFetchError(null)
       setLoadingRun(false)
       return
@@ -679,13 +677,13 @@ function LastRunTab({ live }: { live: LiveNote }) {
     setFetchError(null)
     void (async () => {
       try {
-        const r = await window.ipc.invoke('runs:fetch', { runId })
+        const t = await fetchAgentRunTranscript(runId)
         if (cancelled) return
-        setRun(r)
+        setTranscript(t)
       } catch (err) {
         if (cancelled) return
         setFetchError(err instanceof Error ? err.message : String(err))
-        setRun(null)
+        setTranscript(null)
       } finally {
         if (!cancelled) setLoadingRun(false)
       }
@@ -704,7 +702,7 @@ function LastRunTab({ live }: { live: LiveNote }) {
   }
 
   const isError = !!live.lastRunError
-  const items = run ? runLogToConversation(run.log) : []
+  const items = transcript?.items ?? []
 
   return (
     <div className="flex-1 overflow-auto px-4 py-4 space-y-4">
@@ -751,10 +749,10 @@ function LastRunTab({ live }: { live: LiveNote }) {
             Couldn't load transcript: {fetchError}
           </div>
         )}
-        {run && !loadingRun && items.length === 0 && (
+        {transcript && !loadingRun && items.length === 0 && (
           <p className="text-xs italic text-muted-foreground">No messages or tool calls recorded.</p>
         )}
-        {run && !loadingRun && items.length > 0 && (
+        {transcript && !loadingRun && items.length > 0 && (
           <CompactConversation items={items} />
         )}
       </div>
diff --git a/apps/x/apps/renderer/src/components/meetings-view.tsx b/apps/x/apps/renderer/src/components/meetings-view.tsx
index 2ad04082..49090ce9 100644
--- a/apps/x/apps/renderer/src/components/meetings-view.tsx
+++ b/apps/x/apps/renderer/src/components/meetings-view.tsx
@@ -1,6 +1,7 @@
 import { useCallback, useEffect, useMemo, useRef, useState } from 'react'
 import { createPortal } from 'react-dom'
-import { Calendar, ChevronDown, Clock, ExternalLink, Loader2, MapPin, Mic, Square, UserRound, UsersRound, Video, X } from 'lucide-react'
+import { Calendar, ChevronDown, ChevronRight, Clock, ExternalLink, FileText, Loader2, MapPin, Mic, Sparkles, Square, UserPlus, UserRound, UsersRound, Video, X } from 'lucide-react'
+import { Streamdown } from 'streamdown'
 
 import { Button } from '@/components/ui/button'
 import { Popover, PopoverContent, PopoverTrigger } from '@/components/ui/popover'
@@ -14,6 +15,39 @@ const MEETINGS_ROOT = 'knowledge/Meetings'
 const CALENDAR_DIR = 'calendar_sync'
 const UPCOMING_MAX_DAYS = 4 // today + next 3
 
+declare global {
+  interface Window {
+    __pendingMeetingPrepCreate?: { prompt: string }
+  }
+}
+
+// Mirrors the `meeting-prep:resolve` IPC response shape.
+type PrepNote = {
+  path: string
+  name: string
+  role?: string
+  organization?: string
+  markdown: string
+}
+type PrepAttendee = {
+  label: string
+  email?: string
+  displayName?: string
+  note: PrepNote | null
+}
+type PrepOrg = {
+  path: string
+  name: string
+  markdown: string
+}
+type PrepResult = {
+  attendees: PrepAttendee[]
+  organizations: PrepOrg[]
+  prepNote: { path: string; brief: string } | null
+  matchedCount: number
+  unmatchedCount: number
+}
+
 type MeetingNoteRow = {
   path: string
   name: string
@@ -358,7 +392,178 @@ function parseDescriptionParts(value: string): DescriptionPart[] {
   }).filter((part) => part.text.length > 0)
 }
 
-function UpcomingEvents() {
+// Hand the unmatched attendee off to the Copilot to research + create a note.
+function requestCreateNote(attendee: PrepAttendee, meetingSummary: string) {
+  const who = attendee.displayName || attendee.label
+  const email = attendee.email ? ` <${attendee.email}>` : ''
+  window.__pendingMeetingPrepCreate = {
+    prompt: `Create a person note in my knowledge base for ${who}${email}. They're attending my "${meetingSummary}" meeting. Pull together what you know about them from my emails, past meetings, and calendar.`,
+  }
+  window.dispatchEvent(new Event('meeting-prep:create-note'))
+}
+
+// One note row (used for both people and organizations): a clickable row that
+// navigates to the note. The markdown is NOT rendered inline in the card.
+function PrepNoteRow({ title, subtitle, path, onOpenNote }: {
+  title: string
+  subtitle?: string
+  path: string
+  onOpenNote: (path: string) => void
+}) {
+  return (
+    <button
+      type="button"
+      onClick={() => onOpenNote(path)}
+      title={`Open ${title}`}
+      className="flex w-full items-center gap-3 border-b px-5 py-1.5 text-left transition-colors last:border-b-0 hover:bg-muted/50"
+    >
+      <span className="flex min-w-0 flex-1 flex-col">
+        <span className="truncate text-[12.5px] font-semibold text-foreground">{title}</span>
+        {subtitle ? <span className="truncate text-[11px] text-muted-foreground">{subtitle}</span> : null}
+      </span>
+      <ChevronRight className="size-3.5 shrink-0 text-muted-foreground" />
+    </button>
+  )
+}
+
+function PrepAttendeeNote({ attendee, onOpenNote }: { attendee: PrepAttendee; onOpenNote: (path: string) => void }) {
+  const note = attendee.note
+  if (!note) return null
+  const subtitle = [note.role, note.organization].filter(Boolean).join(' · ')
+  return <PrepNoteRow title={note.name} subtitle={subtitle || undefined} path={note.path} onOpenNote={onOpenNote} />
+}
+
+function PrepUnmatchedSection({ attendees, meetingSummary }: { attendees: PrepAttendee[]; meetingSummary: string }) {
+  const [open, setOpen] = useState(false)
+  if (attendees.length === 0) return null
+
+  return (
+    <div className="border-t bg-muted/20">
+      <button
+        type="button"
+        onClick={() => setOpen((v) => !v)}
+        className="flex w-full items-center gap-3 px-5 py-2.5 text-left transition-colors hover:bg-muted/40"
+      >
+        {open ? <ChevronDown className="size-4 shrink-0 text-muted-foreground" /> : <ChevronRight className="size-4 shrink-0 text-muted-foreground" />}
+        <span className="text-xs font-medium text-muted-foreground">
+          {attendees.length} {attendees.length === 1 ? 'other' : 'others'} — no notes yet
+        </span>
+      </button>
+      {open ? (
+        <div className="flex flex-col gap-1 px-5 pb-3 pl-12">
+          {attendees.map((att, idx) => (
+            <div key={`${att.email ?? att.label}-${idx}`} className="flex items-center justify-between gap-3 py-1">
+              <span className="min-w-0 truncate text-sm text-foreground">{att.label}</span>
+              <button
+                type="button"
+                onClick={() => requestCreateNote(att, meetingSummary)}
+                className="inline-flex shrink-0 items-center gap-1.5 rounded-md border bg-background px-2 py-1 text-xs font-medium text-foreground transition-colors hover:bg-accent"
+              >
+                <UserPlus className="size-3.5" />
+                Create note
+              </button>
+            </div>
+          ))}
+        </div>
+      ) : null}
+    </div>
+  )
+}
+
+// Inline prep for a single event: resolves the attendees against the knowledge
+// base and renders their notes directly beneath the event row. Re-resolves when
+// a person note changes (e.g. after "Create note") so it stays fresh.
+function InlineMeetingPrep({ event, onOpenNote }: { event: UpcomingEvent; onOpenNote: (path: string) => void }) {
+  const [prep, setPrep] = useState<PrepResult | null>(null)
+  const [refreshTick, setRefreshTick] = useState(0)
+
+  useEffect(() => {
+    let cancelled = false
+    const run = async () => {
+      try {
+        const attendees = event.attendees.map((a) => ({ email: a.email, displayName: a.displayName, self: a.self }))
+        const result = await window.ipc.invoke('meeting-prep:resolve', { attendees, eventId: event.id })
+        if (!cancelled) setPrep(result)
+      } catch (err) {
+        console.error('Meeting prep failed:', err)
+        if (!cancelled) setPrep(null)
+      }
+    }
+    void run()
+    return () => {
+      cancelled = true
+    }
+  }, [event.id, refreshTick])
+
+  // Refresh when a People note is created/changed so newly-created notes appear.
+  useEffect(() => {
+    const isPeoplePath = (p: string | undefined) =>
+      typeof p === 'string' && p.startsWith('knowledge/People/')
+    const cleanup = window.ipc.on('workspace:didChange', (e) => {
+      switch (e.type) {
+        case 'created':
+        case 'changed':
+        case 'deleted':
+          if (isPeoplePath(e.path)) setRefreshTick((t) => t + 1)
+          break
+        case 'moved':
+          if (isPeoplePath(e.from) || isPeoplePath(e.to)) setRefreshTick((t) => t + 1)
+          break
+        case 'bulkChanged':
+          if (!e.paths || e.paths.some(isPeoplePath)) setRefreshTick((t) => t + 1)
+          break
+      }
+    })
+    return cleanup
+  }, [])
+
+  if (!prep || prep.attendees.length === 0) return null
+
+  const matched = prep.attendees.filter((a) => a.note)
+  const unmatched = prep.attendees.filter((a) => !a.note)
+
+  return (
+    <div className="bg-muted/10">
+      {prep.prepNote && prep.prepNote.brief ? (
+        <div className="border-b px-5 pb-3 pt-3">
+          <Streamdown className="prose prose-sm dark:prose-invert max-w-none text-foreground/90 [&>*:first-child]:mt-0 [&>*:last-child]:mb-0 [&_p]:my-1 [&_ul]:my-1 [&_ol]:my-1 [&_li]:my-0.5 [&_p]:text-[12.5px] [&_li]:text-[12.5px]">
+            {prep.prepNote.brief}
+          </Streamdown>
+          <button
+            type="button"
+            onClick={() => onOpenNote(prep.prepNote!.path)}
+            className="mt-2 inline-flex items-center gap-1.5 text-xs font-medium text-muted-foreground transition-colors hover:text-foreground"
+          >
+            <FileText className="size-3.5" />
+            Open full prep
+          </button>
+        </div>
+      ) : null}
+      <div className="flex items-center gap-1.5 px-5 pb-1 pt-2.5">
+        <UsersRound className="size-3.5 text-muted-foreground" />
+        <span className="text-[11px] font-medium uppercase tracking-wider text-muted-foreground">People</span>
+      </div>
+      {matched.map((att, idx) => (
+        <PrepAttendeeNote key={att.note!.path + idx} attendee={att} onOpenNote={onOpenNote} />
+      ))}
+      <PrepUnmatchedSection attendees={unmatched} meetingSummary={event.summary} />
+      {prep.organizations.length > 0 ? (
+        <>
+          <div className="px-5 pb-1 pt-2.5">
+            <span className="text-[11px] font-medium uppercase tracking-wider text-muted-foreground">
+              {prep.organizations.length === 1 ? 'Company' : 'Companies'}
+            </span>
+          </div>
+          {prep.organizations.map((org) => (
+            <PrepNoteRow key={org.path} title={org.name} subtitle="Organization" path={org.path} onOpenNote={onOpenNote} />
+          ))}
+        </>
+      ) : null}
+    </div>
+  )
+}
+
+function UpcomingEvents({ onOpenNote }: { onOpenNote: (path: string) => void }) {
   const [events, setEvents] = useState<UpcomingEvent[]>([])
   const [loading, setLoading] = useState(true)
   const [error, setError] = useState<string | null>(null)
@@ -487,6 +692,20 @@ function UpcomingEvents() {
     return selectVisibleDays(window)
   }, [events])
 
+  // The next meeting that's worth prepping for — soonest timed event with at
+  // least one other attendee that hasn't ended. Its row gets inline prep.
+  // `events` is sorted (all-day first, then by start), so `find` returns it.
+  const prepEventId = useMemo(() => {
+    const nowMs = Date.now()
+    const candidate = events.find((ev) => {
+      if (ev.isAllDay) return false
+      if (ev.attendees.every((a) => a.self)) return false
+      const endMs = ev.end ? ev.end.getTime() : ev.start.getTime() + 30 * 60 * 1000
+      return endMs > nowMs
+    })
+    return candidate?.id ?? null
+  }, [events])
+
   const totalVisible = visibleDays.reduce((s, d) => s + d.events.length, 0)
   const now = new Date()
   const todayKey = localDateKey(now)
@@ -532,6 +751,8 @@ function UpcomingEvents() {
                 key={day.dateKey}
                 day={day}
                 isToday={day.dateKey === todayKey}
+                prepEventId={prepEventId}
+                onOpenNote={onOpenNote}
               />
             ))}
           </div>
@@ -542,7 +763,7 @@ function UpcomingEvents() {
   )
 }
 
-function UpcomingDayCard({ day, isToday }: { day: DayGroup; isToday: boolean }) {
+function UpcomingDayCard({ day, isToday, prepEventId, onOpenNote }: { day: DayGroup; isToday: boolean; prepEventId: string | null; onOpenNote: (path: string) => void }) {
   const dayNum = day.date.getDate()
   const month = day.date.toLocaleDateString([], { month: 'short' })
   const weekday = day.date.toLocaleDateString([], { weekday: 'short' })
@@ -573,7 +794,13 @@ function UpcomingDayCard({ day, isToday }: { day: DayGroup; isToday: boolean })
         </div>
       ) : (
         day.events.map((ev, idx) => (
-          <UpcomingEventItem key={ev.id} event={ev} isLast={idx === count - 1} />
+          <UpcomingEventItem
+            key={ev.id}
+            event={ev}
+            isLast={idx === count - 1}
+            isPrepTarget={ev.id === prepEventId}
+            onOpenNote={onOpenNote}
+          />
         ))
       )}
     </div>
@@ -588,14 +815,20 @@ function NowBadge() {
   )
 }
 
-function UpcomingEventItem({ event, isLast }: { event: UpcomingEvent; isLast: boolean }) {
+function UpcomingEventItem({ event, isLast, isPrepTarget, onOpenNote }: { event: UpcomingEvent; isLast: boolean; isPrepTarget: boolean; onOpenNote: (path: string) => void }) {
   const [open, setOpen] = useState(false)
+  // The next meeting auto-expands its prep; any other meeting with attendees
+  // can be expanded on demand via the Prep toggle (resolves lazily on open).
+  const prepEligible = !event.isAllDay && event.attendees.some((a) => !a.self)
+  const [prepOpen, setPrepOpen] = useState(isPrepTarget)
+  const showPrep = prepEligible && prepOpen
   const isNow = isEventNow(event)
   const platform = meetingPlatformLabel(event.conferenceLink)
   const subtitle = platform ?? event.location
   const titleAndLocation = event.location ? `${event.summary} · ${event.location}` : event.summary
 
   return (
+    <div className={cn(!isLast && 'border-b')}>
     <Popover open={open} onOpenChange={setOpen}>
       <PopoverTrigger asChild>
         <div
@@ -604,7 +837,7 @@ function UpcomingEventItem({ event, isLast }: { event: UpcomingEvent; isLast: bo
           title={titleAndLocation}
           className={cn(
             'group flex w-full cursor-pointer items-center gap-4 px-5 py-3 text-left transition-colors',
-            !isLast && 'border-b',
+            showPrep && 'border-b',
             isNow ? 'bg-muted' : 'hover:bg-muted/50',
           )}
         >
@@ -625,7 +858,24 @@ function UpcomingEventItem({ event, isLast }: { event: UpcomingEvent; isLast: bo
               </span>
             ) : null}
           </span>
-          <div className="shrink-0">
+          <div className="flex shrink-0 items-center gap-2">
+            {prepEligible ? (
+              <button
+                type="button"
+                onClick={(e) => { e.stopPropagation(); setPrepOpen((v) => !v) }}
+                onMouseDown={(e) => e.stopPropagation()}
+                aria-expanded={prepOpen}
+                title={prepOpen ? 'Hide prep' : 'Show meeting prep'}
+                className={cn(
+                  'inline-flex items-center gap-1.5 rounded-md border px-2.5 py-1.5 text-xs font-medium transition-colors',
+                  prepOpen ? 'bg-accent text-foreground' : 'bg-background text-foreground hover:bg-accent',
+                )}
+              >
+                <Sparkles className="size-3.5" />
+                Prep
+                <ChevronDown className={cn('size-3 transition-transform', prepOpen && 'rotate-180')} />
+              </button>
+            ) : null}
             {event.conferenceLink ? (
               <SplitJoinButton
                 onJoinAndNotes={() => triggerMeetingCapture(event, true)}
@@ -647,6 +897,8 @@ function UpcomingEventItem({ event, isLast }: { event: UpcomingEvent; isLast: bo
       </PopoverTrigger>
       <EventDetailsPopover event={event} onClose={() => setOpen(false)} />
     </Popover>
+    {showPrep ? <InlineMeetingPrep event={event} onOpenNote={onOpenNote} /> : null}
+    </div>
   )
 }
 
@@ -917,6 +1169,9 @@ export function MeetingsView({ onOpenNote, onTakeMeetingNotes, meetingState, mee
 
       const rows = entries
 	        .filter((entry) => entry.kind === 'file' && entry.name.endsWith('.md'))
+	        // Generated prep notes live under Meetings/prep/ — they're upcoming
+	        // prep, not past meeting notes, so keep them out of this table.
+	        .filter((entry) => !entry.path.startsWith(`${MEETINGS_ROOT}/prep/`))
 	        .map((entry) => {
 	          const relative = entry.path.slice(`${MEETINGS_ROOT}/`.length)
 	          const parts = relative.split('/')
@@ -1017,7 +1272,7 @@ export function MeetingsView({ onOpenNote, onTakeMeetingNotes, meetingState, mee
         </p>
       </div>
       <div className="flex-1 overflow-auto">
-        <UpcomingEvents />
+        <UpcomingEvents onOpenNote={onOpenNote} />
         <div className="p-6">
         {loading ? (
           <div className="flex items-center justify-center py-10">
diff --git a/apps/x/apps/renderer/src/components/product-tour.tsx b/apps/x/apps/renderer/src/components/product-tour.tsx
new file mode 100644
index 00000000..b6e5fe8d
--- /dev/null
+++ b/apps/x/apps/renderer/src/components/product-tour.tsx
@@ -0,0 +1,878 @@
+import { useCallback, useEffect, useLayoutEffect, useMemo, useRef, useState } from 'react'
+import { createPortal } from 'react-dom'
+import { X } from 'lucide-react'
+import { Button } from '@/components/ui/button'
+import { TalkingHead, type MascotHat } from '@/components/talking-head'
+import { AgentsFleet, MascotVignette, type TourVignetteKind } from '@/components/tour-vignettes'
+import { TourSounds } from '@/lib/tour-sounds'
+import type { TTSState } from '@/hooks/useVoiceTTS'
+import { cn } from '@/lib/utils'
+import tourClipWelcome from '@/assets/tour/welcome.mp3'
+import tourClipHome from '@/assets/tour/home.mp3'
+import tourClipEmail from '@/assets/tour/email.mp3'
+import tourClipMeetings from '@/assets/tour/meetings.mp3'
+import tourClipCode from '@/assets/tour/code.mp3'
+import tourClipKnowledge from '@/assets/tour/knowledge.mp3'
+import tourClipAgents from '@/assets/tour/agents.mp3'
+import tourClipWorkspaces from '@/assets/tour/workspaces.mp3'
+import tourClipChats from '@/assets/tour/chats.mp3'
+import tourClipComposer from '@/assets/tour/composer.mp3'
+import tourClipDone from '@/assets/tour/done.mp3'
+
+export type TourNavTarget =
+  | 'home'
+  | 'email'
+  | 'meetings'
+  | 'code'
+  | 'knowledge'
+  | 'agents'
+  | 'workspaces'
+
+type TourStep = {
+  id: string
+  /** Matches a [data-tour-id] element. Steps whose target is absent are skipped. */
+  targetId?: string
+  /** View to open when the step starts, via App's navigation handlers. */
+  navigate?: TourNavTarget
+  /** Costume the mascot wears at this stop. */
+  hat?: MascotHat
+  /** Looping animation staged around the mascot while it presents this stop. */
+  vignette?: TourVignetteKind
+  title: string
+  text: string
+  /** Spoken narration, when it should differ from the bubble text. */
+  voiceText?: string
+}
+
+const TOUR_STEPS: TourStep[] = [
+  {
+    id: 'welcome',
+    title: 'All aboard! ⚓',
+    text: "I'm your captain for the next minute. The lights are down and the water's in — let me row you across Rowboat, one stop at a time. Use Next or your arrow keys.",
+    voiceText: "I'm your captain for the next minute. The lights are down and the water's in — let me row you across Rowboat, one stop at a time.",
+  },
+  {
+    id: 'home',
+    targetId: 'nav-home',
+    navigate: 'home',
+    title: 'First stop: Home',
+    text: 'Home is your landing spot — a quick overview of what needs your attention to get you back into the flow.',
+  },
+  {
+    id: 'email',
+    targetId: 'nav-email',
+    navigate: 'email',
+    hat: 'mailcap',
+    vignette: 'email',
+    title: 'Email',
+    text: 'Read and triage your inbox right here. Rowboat can summarize threads, label messages, and help you draft replies.',
+  },
+  {
+    id: 'meetings',
+    targetId: 'nav-meetings',
+    navigate: 'meetings',
+    hat: 'headphones',
+    vignette: 'meetings',
+    title: 'Meetings',
+    text: 'Record or join meetings, and get transcripts and notes automatically — prep briefs show up before your calls, too.',
+  },
+  {
+    id: 'code',
+    targetId: 'nav-code',
+    navigate: 'code',
+    hat: 'hardhat',
+    title: 'Code',
+    text: 'The Code section runs coding agents on your projects — point one at a folder and drive it from a chat.',
+  },
+  {
+    id: 'knowledge',
+    targetId: 'nav-knowledge',
+    navigate: 'knowledge',
+    hat: 'gradcap',
+    vignette: 'brain',
+    title: 'Brain',
+    text: "Brain is your knowledge base — notes, files, and everything Rowboat learns for you, all connected and searchable.",
+  },
+  {
+    id: 'agents',
+    targetId: 'nav-agents',
+    navigate: 'agents',
+    hat: 'captain',
+    vignette: 'agents',
+    title: 'Background agents',
+    text: 'Background agents work on schedules — they keep your Brain fresh and take care of recurring tasks while you row elsewhere.',
+  },
+  {
+    id: 'workspaces',
+    targetId: 'nav-workspaces',
+    navigate: 'workspaces',
+    hat: 'explorer',
+    title: 'Workspaces',
+    text: 'Workspaces hold your project folders and files, so related work stays docked together.',
+  },
+  {
+    id: 'chats',
+    targetId: 'nav-chats',
+    title: 'Chats',
+    text: 'Your recent conversations live here — pick any of them back up right where you left off.',
+  },
+  {
+    id: 'composer',
+    targetId: 'chat-composer',
+    title: 'Talk to Rowboat',
+    text: 'And this is where we talk! Type, dictate with the mic, or turn on voice output — tap my face button and I’ll read replies out loud myself.',
+  },
+  {
+    id: 'done',
+    hat: 'party',
+    title: "Land ho! 🎉",
+    text: "That's the whole bay — and there's my wake to prove it. Take this voyage again anytime from the bottom of the sidebar. Happy rowing!",
+  },
+]
+
+// Pre-recorded narration bundled with the app (no TTS API call, works
+// offline/signed-out). Regenerate with scripts/generate-tour-audio.mjs after
+// editing any step's text. Steps without a clip fall back to live TTS.
+const TOUR_CLIPS: Record<string, string> = {
+  welcome: tourClipWelcome,
+  home: tourClipHome,
+  email: tourClipEmail,
+  meetings: tourClipMeetings,
+  code: tourClipCode,
+  knowledge: tourClipKnowledge,
+  agents: tourClipAgents,
+  workspaces: tourClipWorkspaces,
+  chats: tourClipChats,
+  composer: tourClipComposer,
+  done: tourClipDone,
+}
+
+const MASCOT_SIZE = 120
+const VIEWPORT_MARGIN = 16
+const BUBBLE_WIDTH = 288
+const TARGET_RESOLVE_TIMEOUT_MS = 1500
+const ZOOM_SCALE = 1.05
+const GLIDE_EASING = 'cubic-bezier(0.45, 0, 0.2, 1)'
+
+type Pt = { x: number; y: number }
+type Rect = { left: number; top: number; width: number; height: number }
+type Spot = Rect & { round: boolean }
+
+function clamp(v: number, min: number, max: number): number {
+  return Math.max(min, Math.min(max, v))
+}
+
+function easeInOutCubic(t: number): number {
+  return t < 0.5 ? 4 * t * t * t : 1 - Math.pow(-2 * t + 2, 3) / 2
+}
+
+function quadPoint(p0: Pt, c: Pt, p1: Pt, t: number): Pt {
+  const u = 1 - t
+  return {
+    x: u * u * p0.x + 2 * u * t * c.x + t * t * p1.x,
+    y: u * u * p0.y + 2 * u * t * c.y + t * t * p1.y,
+  }
+}
+
+function quadPathLength(d: string): number {
+  const p = document.createElementNS('http://www.w3.org/2000/svg', 'path')
+  p.setAttribute('d', d)
+  return p.getTotalLength()
+}
+
+// A data-tour-id can legitimately appear on several elements (e.g. the chat
+// composer renders in both the full-screen chat and the side pane) — pick the
+// one that is actually laid out.
+function findTourTarget(targetId: string): HTMLElement | null {
+  const nodes = document.querySelectorAll<HTMLElement>(`[data-tour-id="${targetId}"]`)
+  for (const el of nodes) {
+    const rect = el.getBoundingClientRect()
+    if (rect.width > 0 && rect.height > 0) return el
+  }
+  return null
+}
+
+function mascotDestForCenter(): Pt {
+  return {
+    x: window.innerWidth / 2 - MASCOT_SIZE / 2 - BUBBLE_WIDTH / 2,
+    y: window.innerHeight / 2 - MASCOT_SIZE / 2,
+  }
+}
+
+function mascotDestForRect(rect: Rect): Pt {
+  let x: number
+  let y: number
+  const fitsRight = rect.left + rect.width + MASCOT_SIZE + BUBBLE_WIDTH + VIEWPORT_MARGIN * 3 < window.innerWidth
+  if (fitsRight) {
+    x = rect.left + rect.width + 20
+    y = rect.top + rect.height / 2 - MASCOT_SIZE / 2
+  } else if (rect.top > MASCOT_SIZE + VIEWPORT_MARGIN * 2) {
+    x = rect.left + rect.width / 2 - MASCOT_SIZE / 2
+    y = rect.top - MASCOT_SIZE - 20
+  } else {
+    x = rect.left - MASCOT_SIZE - 20
+    y = rect.top + rect.height / 2 - MASCOT_SIZE / 2
+  }
+  return {
+    x: clamp(x, VIEWPORT_MARGIN, window.innerWidth - MASCOT_SIZE - VIEWPORT_MARGIN),
+    y: clamp(y, VIEWPORT_MARGIN, window.innerHeight - MASCOT_SIZE - VIEWPORT_MARGIN),
+  }
+}
+
+function spotForRect(rect: Rect): Spot {
+  return {
+    left: rect.left - 6,
+    top: rect.top - 6,
+    width: rect.width + 12,
+    height: rect.height + 12,
+    round: false,
+  }
+}
+
+function spotForMascot(dest: Pt): Spot {
+  return {
+    left: dest.x - 26,
+    top: dest.y - 18,
+    width: MASCOT_SIZE + 52,
+    height: MASCOT_SIZE + 44,
+    round: true,
+  }
+}
+
+type ProductTourProps = {
+  onClose: () => void
+  onNavigate: (target: TourNavTarget) => void
+  ttsAvailable: boolean
+  ttsState: TTSState
+  speak: (text: string) => void
+  speakUrl: (url: string) => void
+  cancelSpeech: () => void
+  getLevel: () => number
+}
+
+/**
+ * The Grand Voyage: a mascot-guided walkthrough where the app dims to a
+ * night-time bay, the boat rows curved routes between [data-tour-id] anchors
+ * (leaving a dotted wake behind it), a spotlight and gentle camera zoom reveal
+ * each section, and a parchment mini-map charts progress. Narrated with TTS
+ * lip sync when available; ends in confetti.
+ *
+ * Rendered through a portal to <body> so the camera zoom applied to the app
+ * shell never transforms the tour's own fixed-position layers.
+ */
+export function ProductTour({
+  onClose,
+  onNavigate,
+  ttsAvailable,
+  ttsState,
+  speak,
+  speakUrl,
+  cancelSpeech,
+  getLevel,
+}: ProductTourProps) {
+  const [stepIndex, setStepIndex] = useState(0)
+  const [arrived, setArrived] = useState(false)
+  const [rowing, setRowing] = useState(false)
+  const [flipped, setFlipped] = useState(false)
+  const [bubbleSide, setBubbleSide] = useState<'left' | 'right'>('right')
+  const [spot, setSpot] = useState<Spot | null>(null)
+  const [wakes, setWakes] = useState<{ id: number; d: string }[]>([])
+  const [activeWake, setActiveWake] = useState<{ d: string; len: number } | null>(null)
+  const [confettiOn, setConfettiOn] = useState(false)
+  const [resizeNonce, setResizeNonce] = useState(0)
+
+  const reducedMotion = useMemo(
+    () => window.matchMedia('(prefers-reduced-motion: reduce)').matches,
+    []
+  )
+
+  // Mascot position is animated by mutating the container's transform directly
+  // (60fps travel without re-rendering React); posRef is the source of truth.
+  const mascotElRef = useRef<HTMLDivElement>(null)
+  const posRef = useRef<Pt>({
+    x: window.innerWidth / 2 - MASCOT_SIZE / 2,
+    y: window.innerHeight + 60,
+  })
+  const travelRafRef = useRef(0)
+  const wakePathElRef = useRef<SVGPathElement>(null)
+  const wakeIdRef = useRef(0)
+  const curveSideRef = useRef(1)
+  const lastSplashRef = useRef(0)
+
+  const directionRef = useRef(1)
+  const enteredStepRef = useRef(-1)
+  const stepIndexRef = useRef(stepIndex)
+
+  // Camera zoom state applied to the app shell (outside the portal)
+  const shellRef = useRef<HTMLElement | null>(null)
+  const zoomRef = useRef<{ ox: number; oy: number; s: number } | null>(null)
+
+  const soundsRef = useRef<TourSounds | null>(null)
+
+  const onCloseRef = useRef(onClose)
+  const onNavigateRef = useRef(onNavigate)
+  const speakRef = useRef(speak)
+  const speakUrlRef = useRef(speakUrl)
+  const cancelSpeechRef = useRef(cancelSpeech)
+  const ttsAvailableRef = useRef(ttsAvailable)
+
+  // Keep latest callbacks/state in refs so the step effect and key handlers
+  // stay stable. Runs before the step effect below (effect order = call order).
+  useEffect(() => {
+    stepIndexRef.current = stepIndex
+    onCloseRef.current = onClose
+    onNavigateRef.current = onNavigate
+    speakRef.current = speak
+    speakUrlRef.current = speakUrl
+    cancelSpeechRef.current = cancelSpeech
+    ttsAvailableRef.current = ttsAvailable
+  })
+
+  useLayoutEffect(() => {
+    if (mascotElRef.current) {
+      mascotElRef.current.style.transform = `translate(${posRef.current.x}px, ${posRef.current.y}px)`
+    }
+    soundsRef.current = new TourSounds()
+    return () => {
+      soundsRef.current?.dispose()
+      soundsRef.current = null
+    }
+  }, [])
+
+  // Grab the app shell for the camera zoom; restore it when the tour ends
+  useEffect(() => {
+    const shell = document.querySelector<HTMLElement>('.rowboat-shell')
+    shellRef.current = shell
+    return () => {
+      if (shell) {
+        shell.style.transform = ''
+        shell.style.transformOrigin = ''
+        shell.style.transition = ''
+      }
+      shellRef.current = null
+      zoomRef.current = null
+    }
+  }, [])
+
+  const applyZoom = useCallback((origin: { ox: number; oy: number } | null) => {
+    const shell = shellRef.current
+    if (!shell || reducedMotion) return
+    if (origin) {
+      // transform-origin transitions too, so moving between targets pans
+      // smoothly instead of jumping when the origin changes
+      shell.style.transition = `transform 0.9s ${GLIDE_EASING}, transform-origin 0.9s ${GLIDE_EASING}`
+      shell.style.transformOrigin = `${origin.ox}px ${origin.oy}px`
+      shell.style.transform = `scale(${ZOOM_SCALE})`
+      zoomRef.current = { ox: origin.ox, oy: origin.oy, s: ZOOM_SCALE }
+    } else {
+      shell.style.transition = `transform 0.9s ${GLIDE_EASING}, transform-origin 0.9s ${GLIDE_EASING}`
+      shell.style.transform = 'scale(1)'
+      zoomRef.current = null
+    }
+  }, [reducedMotion])
+
+  // Where the element will sit on screen once this step's zoom settles:
+  // undo the current zoom mathematically, then apply the upcoming one (whose
+  // origin is the target's own center, so the center never moves).
+  const displayedRect = useCallback((el: HTMLElement, willZoom: boolean): { rect: Rect; origin: { ox: number; oy: number } } => {
+    const m = el.getBoundingClientRect()
+    const z = zoomRef.current
+    let cx = m.left + m.width / 2
+    let cy = m.top + m.height / 2
+    let w = m.width
+    let h = m.height
+    if (z) {
+      cx = z.ox + (cx - z.ox) / z.s
+      cy = z.oy + (cy - z.oy) / z.s
+      w /= z.s
+      h /= z.s
+    }
+    const s = willZoom && !reducedMotion ? ZOOM_SCALE : 1
+    return {
+      rect: { left: cx - (w * s) / 2, top: cy - (h * s) / 2, width: w * s, height: h * s },
+      origin: { ox: cx, oy: cy },
+    }
+  }, [reducedMotion])
+
+  const cancelTravel = useCallback(() => {
+    cancelAnimationFrame(travelRafRef.current)
+  }, [])
+
+  const moveMascot = useCallback((p: Pt) => {
+    posRef.current = p
+    if (mascotElRef.current) {
+      mascotElRef.current.style.transform = `translate(${p.x}px, ${p.y}px)`
+    }
+  }, [])
+
+  // Row along a curved path from the current position, drawing the wake as we
+  // go and splashing the oar; commits the wake as a dotted trail on arrival.
+  const startTravel = useCallback((dest: Pt, onArrive: () => void) => {
+    cancelTravel()
+    const from = { ...posRef.current }
+    const dist = Math.hypot(dest.x - from.x, dest.y - from.y)
+    if (dist < 6 || reducedMotion) {
+      moveMascot(dest)
+      setRowing(false)
+      onArrive()
+      return
+    }
+    const dur = clamp(dist * 1.1, 550, 1500)
+    curveSideRef.current = -curveSideRef.current
+    const mx = (from.x + dest.x) / 2
+    const my = (from.y + dest.y) / 2
+    const nx = -(dest.y - from.y) / dist
+    const ny = (dest.x - from.x) / dist
+    const mag = Math.min(140, dist * 0.3) * curveSideRef.current
+    const c = { x: mx + nx * mag, y: my + ny * mag }
+
+    // Wake follows the stern (bottom-center of the mascot box)
+    const sternX = MASCOT_SIZE / 2
+    const sternY = MASCOT_SIZE * 0.82
+    const d = `M ${from.x + sternX} ${from.y + sternY} Q ${c.x + sternX} ${c.y + sternY} ${dest.x + sternX} ${dest.y + sternY}`
+    const len = quadPathLength(d)
+    setActiveWake({ d, len })
+    setFlipped(dest.x < from.x - 4)
+    setRowing(true)
+    lastSplashRef.current = 0
+
+    const t0 = performance.now()
+    const frame = (now: number) => {
+      const raw = Math.min(1, (now - t0) / dur)
+      const t = easeInOutCubic(raw)
+      moveMascot(quadPoint(from, c, dest, t))
+      if (wakePathElRef.current) {
+        wakePathElRef.current.style.strokeDashoffset = String(len * (1 - t))
+      }
+      if (now - lastSplashRef.current > 420) {
+        lastSplashRef.current = now
+        soundsRef.current?.splash()
+      }
+      if (raw < 1) {
+        travelRafRef.current = requestAnimationFrame(frame)
+      } else {
+        setRowing(false)
+        setActiveWake(null)
+        setWakes((ws) => [...ws, { id: wakeIdRef.current++, d }])
+        onArrive()
+      }
+    }
+    travelRafRef.current = requestAnimationFrame(frame)
+  }, [cancelTravel, moveMascot, reducedMotion])
+
+  const playDing = useCallback(() => soundsRef.current?.ding(), [])
+
+  const finish = useCallback(() => {
+    cancelSpeechRef.current()
+    onCloseRef.current()
+  }, [])
+
+  const goTo = useCallback((index: number, direction: 1 | -1) => {
+    directionRef.current = direction
+    if (index < 0) return
+    if (index >= TOUR_STEPS.length) {
+      finish()
+      return
+    }
+    // Silence the current step's narration right away — not on arrival —
+    // so it can't talk over (or into) the next step's speech.
+    cancelSpeechRef.current()
+    setStepIndex(index)
+  }, [finish])
+
+  // Stop any in-flight narration when the tour unmounts
+  useEffect(() => () => cancelSpeechRef.current(), [])
+
+  useEffect(() => {
+    const handleResize = () => setResizeNonce((n) => n + 1)
+    window.addEventListener('resize', handleResize)
+    return () => window.removeEventListener('resize', handleResize)
+  }, [])
+
+  // Enter the current step: navigate, wait for its anchor, aim the spotlight
+  // and camera, row over, then narrate. Re-runs on resize to re-anchor.
+  useEffect(() => {
+    const step = TOUR_STEPS[stepIndex]
+    const entering = enteredStepRef.current !== stepIndex
+    let cancelled = false
+
+    if (entering && step.navigate) {
+      onNavigateRef.current(step.navigate)
+    }
+
+    const settle = (dest: Pt, side: 'left' | 'right', spotlight: Spot, origin: { ox: number; oy: number } | null) => {
+      applyZoom(origin)
+      setSpot(spotlight)
+      setBubbleSide(side)
+      if (!entering) {
+        // Resize while already at this step: jump, keep the bubble up
+        cancelTravel()
+        moveMascot(dest)
+        return
+      }
+      enteredStepRef.current = stepIndex
+      setArrived(false)
+      startTravel(dest, () => {
+        if (cancelled) return
+        setArrived(true)
+        soundsRef.current?.bump()
+        cancelSpeechRef.current()
+        const clip = TOUR_CLIPS[step.id]
+        if (clip) {
+          speakUrlRef.current(clip)
+        } else if (ttsAvailableRef.current) {
+          speakRef.current(step.voiceText ?? step.text)
+        }
+        if (stepIndex === TOUR_STEPS.length - 1) {
+          setConfettiOn(true)
+          soundsRef.current?.fanfare()
+        }
+      })
+    }
+
+    if (!step.targetId) {
+      const dest = mascotDestForCenter()
+      applyZoom(null)
+      settle(dest, 'right', spotForMascot(dest), null)
+      return () => {
+        cancelled = true
+        cancelTravel()
+      }
+    }
+
+    const startedAt = performance.now()
+    let pollRaf = 0
+    const attempt = () => {
+      if (cancelled) return
+      const el = findTourTarget(step.targetId!)
+      if (el) {
+        const { rect, origin } = displayedRect(el, true)
+        const dest = mascotDestForRect(rect)
+        const side: 'left' | 'right' = dest.x + MASCOT_SIZE / 2 < window.innerWidth / 2 ? 'right' : 'left'
+        settle(dest, side, spotForRect(rect), origin)
+        return
+      }
+      if (performance.now() - startedAt < TARGET_RESOLVE_TIMEOUT_MS) {
+        pollRaf = requestAnimationFrame(attempt)
+      } else if (entering) {
+        // Anchor never appeared (feature disabled / pane closed) — skip past it
+        goTo(stepIndex + directionRef.current, directionRef.current as 1 | -1)
+      }
+    }
+    attempt()
+    return () => {
+      cancelled = true
+      cancelAnimationFrame(pollRaf)
+      cancelTravel()
+    }
+  }, [stepIndex, resizeNonce, goTo, applyZoom, displayedRect, startTravel, cancelTravel, moveMascot])
+
+  useEffect(() => {
+    const handleKeyDown = (e: KeyboardEvent) => {
+      if (e.key === 'Escape') {
+        e.preventDefault()
+        finish()
+      } else if (e.key === 'ArrowRight' || e.key === 'Enter') {
+        e.preventDefault()
+        goTo(stepIndexRef.current + 1, 1)
+      } else if (e.key === 'ArrowLeft') {
+        e.preventDefault()
+        goTo(stepIndexRef.current - 1, -1)
+      }
+    }
+    window.addEventListener('keydown', handleKeyDown)
+    return () => window.removeEventListener('keydown', handleKeyDown)
+  }, [finish, goTo])
+
+  const step = TOUR_STEPS[stepIndex]
+  const isFirst = stepIndex === 0
+  const isLast = stepIndex === TOUR_STEPS.length - 1
+
+  return createPortal(
+    <>
+      <style>{`
+        @keyframes tour-bubble-in {
+          0% { opacity: 0; transform: translateY(6px) scale(0.97); }
+          100% { opacity: 1; transform: translateY(0) scale(1); }
+        }
+        @keyframes tour-wave-drift {
+          from { transform: translateX(0); }
+          to { transform: translateX(-50%); }
+        }
+        @keyframes tour-stamp-in {
+          0% { opacity: 0; transform: scale(2); }
+          100% { opacity: 1; transform: scale(1); }
+        }
+      `}</style>
+
+      {/* night falls: dim everything except the spotlight cutout */}
+      {spot && (
+        <div
+          className="pointer-events-none fixed z-[64]"
+          style={{
+            left: spot.left,
+            top: spot.top,
+            width: spot.width,
+            height: spot.height,
+            borderRadius: spot.round ? 9999 : 14,
+            boxShadow: '0 0 0 200vmax rgba(7, 14, 26, 0.52)',
+            transition: `all 0.9s ${GLIDE_EASING}`,
+          }}
+        />
+      )}
+
+      <TourWater />
+
+      {/* wake trails: the committed dotted route + the wake being drawn now */}
+      <svg className="pointer-events-none fixed inset-0 z-[66] h-full w-full">
+        {wakes.map((w) => (
+          <path
+            key={w.id}
+            d={w.d}
+            fill="none"
+            stroke="#9CCBEA"
+            strokeWidth={4}
+            strokeLinecap="round"
+            strokeDasharray="1 11"
+            opacity={0.75}
+          />
+        ))}
+        {activeWake && (
+          <path
+            ref={wakePathElRef}
+            d={activeWake.d}
+            fill="none"
+            stroke="#BFE0F5"
+            strokeWidth={5}
+            strokeLinecap="round"
+            strokeDasharray={activeWake.len}
+            strokeDashoffset={activeWake.len}
+            opacity={0.8}
+          />
+        )}
+      </svg>
+
+      <TourMiniMap total={TOUR_STEPS.length} current={stepIndex} arrived={arrived} />
+
+      {/* the boat (position driven imperatively during travel) */}
+      <div
+        ref={mascotElRef}
+        className="fixed left-0 top-0 z-[70]"
+        style={{ width: MASCOT_SIZE, pointerEvents: 'none' }}
+      >
+        {arrived && !reducedMotion && step.vignette && step.vignette !== 'agents' && (
+          <MascotVignette kind={step.vignette} playDing={playDing} />
+        )}
+        <div style={{ transform: flipped ? 'scaleX(-1)' : undefined, transition: 'transform 0.35s ease-in-out' }}>
+          <TalkingHead ttsState={ttsState} getLevel={getLevel} size={MASCOT_SIZE} hat={step.hat} rowing={rowing} />
+        </div>
+        {arrived && (
+          <div
+            key={step.id}
+            className={cn(
+              'pointer-events-auto absolute top-0 z-10 rounded-xl border border-border bg-popover p-4 text-popover-foreground shadow-lg',
+              bubbleSide === 'right' ? 'left-full ml-3' : 'right-full mr-3'
+            )}
+            style={{
+              width: BUBBLE_WIDTH,
+              animation: 'tour-bubble-in 0.25s ease-out',
+            }}
+          >
+            <button
+              type="button"
+              onClick={finish}
+              className="absolute right-2 top-2 flex h-6 w-6 items-center justify-center rounded-md text-muted-foreground transition-colors hover:bg-muted hover:text-foreground"
+              aria-label="End tour"
+            >
+              <X className="h-3.5 w-3.5" />
+            </button>
+            <p className="pr-6 text-sm font-semibold">{step.title}</p>
+            <p className="mt-1.5 text-sm text-muted-foreground">{step.text}</p>
+            <div className="mt-3 flex items-center justify-between">
+              <span className="text-xs tabular-nums text-muted-foreground">
+                {stepIndex + 1} / {TOUR_STEPS.length}
+              </span>
+              <div className="flex items-center gap-1.5">
+                {!isFirst && (
+                  <Button variant="ghost" size="sm" className="h-7 px-2.5" onClick={() => goTo(stepIndex - 1, -1)}>
+                    Back
+                  </Button>
+                )}
+                <Button
+                  size="sm"
+                  className="h-7 px-3"
+                  onClick={() => (isLast ? finish() : goTo(stepIndex + 1, 1))}
+                >
+                  {isLast ? 'Done' : 'Next'}
+                </Button>
+              </div>
+            </div>
+          </div>
+        )}
+      </div>
+
+      {arrived && !reducedMotion && step.vignette === 'agents' && <AgentsFleet />}
+
+      {confettiOn && !reducedMotion && <ConfettiBurst />}
+    </>,
+    document.body
+  )
+}
+
+/** Animated translucent waves lapping at the bottom of the screen. */
+function TourWater() {
+  const back = useMemo(() => wavePath(2400, 96, 8, 22), [])
+  const front = useMemo(() => wavePath(2400, 96, 12, 30), [])
+  return (
+    <div className="pointer-events-none fixed inset-x-0 bottom-0 z-[65] h-24 overflow-hidden" aria-hidden="true">
+      <svg
+        className="absolute bottom-0 left-0 h-full"
+        style={{ width: '200%', animation: 'tour-wave-drift 11s linear infinite' }}
+        viewBox="0 0 2400 96"
+        preserveAspectRatio="none"
+      >
+        <path d={back} fill="#5F9BC9" opacity={0.3} />
+      </svg>
+      <svg
+        className="absolute bottom-0 left-0 h-full"
+        style={{ width: '200%', animation: 'tour-wave-drift 7s linear infinite reverse' }}
+        viewBox="0 0 2400 96"
+        preserveAspectRatio="none"
+      >
+        <path d={front} fill="#8FB6D9" opacity={0.35} />
+      </svg>
+    </div>
+  )
+}
+
+// Periodic wave: alternating up/down humps so a -50% translate loops seamlessly
+// (both hump counts are even, so half the width is a whole number of periods).
+function wavePath(width: number, height: number, humps: number, amp: number): string {
+  const yTop = 34
+  const seg = width / humps
+  let d = `M 0 ${yTop}`
+  for (let i = 0; i < humps; i++) {
+    d += ` q ${seg / 2} ${i % 2 === 0 ? -amp : amp} ${seg} 0`
+  }
+  d += ` L ${width} ${height} L 0 ${height} Z`
+  return d
+}
+
+/** Parchment chart in the corner: islands per stop, dotted route, boat marker. */
+function TourMiniMap({ total, current, arrived }: { total: number; current: number; arrived: boolean }) {
+  const MW = 184
+  const MH = 96
+  const points = useMemo(
+    () =>
+      Array.from({ length: total }, (_, i) => {
+        const t = total === 1 ? 0 : i / (total - 1)
+        return {
+          x: 14 + (MW - 28) * t,
+          y: MH / 2 + 4 + Math.sin(t * Math.PI * 1.5 + 0.6) * (MH * 0.26),
+        }
+      }),
+    [total]
+  )
+  const route = points.map((p, i) => (i === 0 ? `M ${p.x} ${p.y}` : `L ${p.x} ${p.y}`)).join(' ')
+  const boat = points[clamp(current, 0, total - 1)]
+
+  return (
+    <div
+      className="fixed bottom-5 left-5 z-[71] rounded-lg border-2 border-[#8A6B3D]/60 bg-[#F4E9CE] px-2 pb-1.5 pt-2 shadow-xl"
+      style={{ transform: 'rotate(-1.2deg)' }}
+      aria-hidden="true"
+    >
+      <p className="mb-0.5 px-1 text-[9px] font-semibold uppercase tracking-[0.22em] text-[#6B5138]">
+        Voyage chart
+      </p>
+      <svg width={MW} height={MH} viewBox={`0 0 ${MW} ${MH}`}>
+        <path d={route} fill="none" stroke="#8A6B3D" strokeWidth={1.5} strokeDasharray="3 4" opacity={0.65} />
+        {points.map((p, i) => {
+          const visited = i < current || (i === current && arrived)
+          return (
+            <g key={i}>
+              <ellipse cx={p.x} cy={p.y} rx={7} ry={5} fill="#DFC896" stroke="#8A6B3D" strokeWidth={1.5} />
+              {visited && (
+                <g style={{ animation: 'tour-stamp-in 0.3s ease-out backwards' }}>
+                  <line x1={p.x - 1} y1={p.y - 13} x2={p.x - 1} y2={p.y - 3} stroke="#7A4A21" strokeWidth={1.5} />
+                  <path d={`M ${p.x - 1} ${p.y - 13} L ${p.x + 6} ${p.y - 10.5} L ${p.x - 1} ${p.y - 8} Z`} fill="#D9534F" />
+                </g>
+              )}
+            </g>
+          )
+        })}
+        {/* boat marker glides between islands in step with the real mascot */}
+        <g style={{ transform: `translate(${boat.x}px, ${boat.y - 7}px)`, transition: `transform 0.9s ${GLIDE_EASING}` }}>
+          <path d="M -7 0 Q 0 4 7 0 Q 4 6 0 6 Q -4 6 -7 0 Z" fill="#54402F" stroke="#3E2E24" strokeWidth={1} />
+          <circle cx={0} cy={-3} r={3} fill="#E8E9F5" stroke="#17171B" strokeWidth={1} />
+        </g>
+      </svg>
+    </div>
+  )
+}
+
+/** Two confetti cannons firing from the bottom corners, canvas-driven. */
+function ConfettiBurst() {
+  const canvasRef = useRef<HTMLCanvasElement>(null)
+
+  useEffect(() => {
+    const canvas = canvasRef.current
+    const ctx = canvas?.getContext('2d')
+    if (!canvas || !ctx) return
+    const w = window.innerWidth
+    const h = window.innerHeight
+    const dpr = window.devicePixelRatio || 1
+    canvas.width = w * dpr
+    canvas.height = h * dpr
+    ctx.scale(dpr, dpr)
+
+    const colors = ['#5B8DEF', '#F2B8BE', '#FFD166', '#7AC74F', '#8FB6D9', '#F2699C']
+    const parts = Array.from({ length: 150 }, (_, i) => {
+      const fromLeft = i % 2 === 0
+      return {
+        x: fromLeft ? 24 : w - 24,
+        y: h - 40,
+        vx: (fromLeft ? 1 : -1) * (2.5 + Math.random() * 6.5),
+        vy: -(9 + Math.random() * 8),
+        size: 5 + Math.random() * 5,
+        color: colors[i % colors.length],
+        rot: Math.random() * Math.PI,
+        vr: (Math.random() - 0.5) * 0.3,
+      }
+    })
+
+    let raf = 0
+    const t0 = performance.now()
+    const frame = (now: number) => {
+      ctx.clearRect(0, 0, w, h)
+      for (const p of parts) {
+        p.vy += 0.18
+        p.vx *= 0.99
+        p.x += p.vx
+        p.y += p.vy
+        p.rot += p.vr
+        ctx.save()
+        ctx.translate(p.x, p.y)
+        ctx.rotate(p.rot)
+        ctx.fillStyle = p.color
+        ctx.fillRect(-p.size / 2, -p.size / 3, p.size, p.size * 0.66)
+        ctx.restore()
+      }
+      if (now - t0 < 3200) {
+        raf = requestAnimationFrame(frame)
+      } else {
+        ctx.clearRect(0, 0, w, h)
+      }
+    }
+    raf = requestAnimationFrame(frame)
+    return () => cancelAnimationFrame(raf)
+  }, [])
+
+  return (
+    <canvas
+      ref={canvasRef}
+      className="pointer-events-none fixed inset-0 z-[72]"
+      style={{ width: '100vw', height: '100vh' }}
+    />
+  )
+}
diff --git a/apps/x/apps/renderer/src/components/settings-dialog.tsx b/apps/x/apps/renderer/src/components/settings-dialog.tsx
index 6200cef9..e89e69f7 100644
--- a/apps/x/apps/renderer/src/components/settings-dialog.tsx
+++ b/apps/x/apps/renderer/src/components/settings-dialog.tsx
@@ -2,7 +2,7 @@
 
 import * as React from "react"
 import { useState, useEffect, useCallback, useMemo } from "react"
-import { Server, Key, Shield, Palette, Monitor, Sun, Moon, Loader2, CheckCircle2, Plus, X, Wrench, Search, ChevronRight, Link2, Tags, Mail, BookOpen, User, Plug, HelpCircle, MessageCircle, Bug, Terminal, AlertTriangle, RefreshCw, PanelRight, Bell } from "lucide-react"
+import { Server, Key, Shield, Palette, Monitor, Sun, Moon, Loader2, CheckCircle2, Plus, X, Wrench, Search, ChevronRight, Link2, Tags, Mail, BookOpen, User, Plug, HelpCircle, MessageCircle, Bug, Terminal, AlertTriangle, RefreshCw, PanelRight, Bell, Smartphone } from "lucide-react"
 
 import {
   Dialog,
@@ -25,10 +25,11 @@ import { useTheme } from "@/contexts/theme-context"
 import { toast } from "sonner"
 import { AccountSettings } from "@/components/settings/account-settings"
 import { ConnectedAccountsSettings } from "@/components/settings/connected-accounts-settings"
+import { MobileChannelsSettings } from "@/components/settings/mobile-channels-settings"
 import type { ApprovalPolicy } from "@x/shared/src/code-mode.js"
 import { startProvisioning, useProvisioning, enabledOptimistic, type AgentStatus, type CodeModeAgentStatus } from "@/lib/code-mode-provisioning"
 
-type ConfigTab = "account" | "connections" | "models" | "mcp" | "security" | "code-mode" | "appearance" | "notifications" | "note-tagging" | "help"
+type ConfigTab = "account" | "connections" | "mobile" | "models" | "mcp" | "security" | "code-mode" | "appearance" | "notifications" | "note-tagging" | "help"
 
 interface TabConfig {
   id: ConfigTab
@@ -51,6 +52,12 @@ const tabs: TabConfig[] = [
     icon: Plug,
     description: "Manage accounts and tools",
   },
+  {
+    id: "mobile",
+    label: "Mobile",
+    icon: Smartphone,
+    description: "Chat with Rowboat from WhatsApp or Telegram",
+  },
   {
     id: "models",
     label: "Models",
@@ -2216,7 +2223,7 @@ export function SettingsDialog({ children, defaultTab = "account", open: control
             </div>
 
             {/* Content */}
-            <div className={cn("flex-1 p-4 min-h-0", (activeTab === "models" || activeTab === "connections" || activeTab === "account" || activeTab === "code-mode" || activeTab === "notifications") ? "overflow-y-auto" : activeTab === "note-tagging" ? "overflow-hidden flex flex-col" : "overflow-hidden")}>
+            <div className={cn("flex-1 p-4 min-h-0", (activeTab === "models" || activeTab === "connections" || activeTab === "mobile" || activeTab === "account" || activeTab === "code-mode" || activeTab === "notifications") ? "overflow-y-auto" : activeTab === "note-tagging" ? "overflow-hidden flex flex-col" : "overflow-hidden")}>
               {activeTab === "account" ? (
                 <AccountSettings dialogOpen={open} />
               ) : activeTab === "connections" ? (
@@ -2231,6 +2238,8 @@ export function SettingsDialog({ children, defaultTab = "account", open: control
                     <ToolsLibrarySettings dialogOpen={open} rowboatConnected={rowboatConnected} />
                   </div>
                 </div>
+              ) : activeTab === "mobile" ? (
+                <MobileChannelsSettings dialogOpen={open} />
               ) : activeTab === "models" ? (
                 rowboatConnected
                   ? <RowboatModelSettings dialogOpen={open} />
diff --git a/apps/x/apps/renderer/src/components/settings/mobile-channels-settings.tsx b/apps/x/apps/renderer/src/components/settings/mobile-channels-settings.tsx
new file mode 100644
index 00000000..9ca775e5
--- /dev/null
+++ b/apps/x/apps/renderer/src/components/settings/mobile-channels-settings.tsx
@@ -0,0 +1,287 @@
+"use client"
+
+import { useCallback, useEffect, useState } from "react"
+import type { z } from "zod"
+import { Loader2, MessageCircle, Send, Smartphone } from "lucide-react"
+import { Button } from "@/components/ui/button"
+import { Input } from "@/components/ui/input"
+import { Separator } from "@/components/ui/separator"
+import { Switch } from "@/components/ui/switch"
+import { toast } from "sonner"
+import type { ChannelsConfig, ChannelsStatus } from "@x/shared/src/channels.js"
+
+type Config = z.infer<typeof ChannelsConfig>
+type Status = z.infer<typeof ChannelsStatus>
+
+// Comma/newline separated entries; each entry keeps digits only, so a
+// formatted number like "+1 (415) 555-1234" survives as one entry instead of
+// being shattered at the spaces.
+function parseIdList(draft: string): string[] {
+  return draft
+    .split(/[,;\n]+/)
+    .map((s) => s.replace(/\D/g, ""))
+    .filter(Boolean)
+}
+
+export function MobileChannelsSettings({ dialogOpen }: { dialogOpen: boolean }) {
+  const [config, setConfig] = useState<Config | null>(null)
+  const [status, setStatus] = useState<Status | null>(null)
+  const [tokenDraft, setTokenDraft] = useState("")
+  const [waAllowDraft, setWaAllowDraft] = useState("")
+  const [tgAllowDraft, setTgAllowDraft] = useState("")
+  const [saving, setSaving] = useState(false)
+
+  useEffect(() => {
+    if (!dialogOpen) return
+    let cancelled = false
+    void (async () => {
+      try {
+        const [cfg, st] = await Promise.all([
+          window.ipc.invoke("channels:getConfig", null),
+          window.ipc.invoke("channels:getStatus", null),
+        ])
+        if (cancelled) return
+        setConfig(cfg)
+        setStatus(st)
+        setTokenDraft(cfg.telegram.botToken)
+        setWaAllowDraft(cfg.whatsapp.allowFrom.join(", "))
+        setTgAllowDraft(cfg.telegram.allowFrom.join(", "))
+      } catch {
+        if (!cancelled) toast.error("Failed to load mobile channel settings")
+      }
+    })()
+    const unsubscribe = window.ipc.on("channels:status", (st) => {
+      setStatus(st)
+    })
+    return () => {
+      cancelled = true
+      unsubscribe()
+    }
+  }, [dialogOpen])
+
+  const save = useCallback(async (next: Config) => {
+    setConfig(next)
+    setSaving(true)
+    try {
+      await window.ipc.invoke("channels:setConfig", next)
+    } catch (error) {
+      toast.error(error instanceof Error ? error.message : "Failed to save channel settings")
+    } finally {
+      setSaving(false)
+    }
+  }, [])
+
+  if (!config) {
+    return (
+      <div className="flex items-center justify-center py-8 text-muted-foreground">
+        <Loader2 className="size-4 animate-spin" />
+      </div>
+    )
+  }
+
+  const wa = status?.whatsapp
+  const tg = status?.telegram
+
+  return (
+    <div className="space-y-6">
+      <div className="flex items-start gap-2.5 rounded-md bg-muted/50 px-3 py-2.5">
+        <Smartphone className="size-4 mt-0.5 shrink-0 text-muted-foreground" />
+        <p className="text-xs text-muted-foreground">
+          Chat with Rowboat from your phone. Send <span className="font-mono">help</span> for
+          commands (<span className="font-mono">list</span>, <span className="font-mono">resume 2</span>,{" "}
+          <span className="font-mono">new</span>, <span className="font-mono">stop</span>) — anything
+          else is a message to the current chat. Your computer must be on with Rowboat running.
+        </p>
+      </div>
+
+      {/* WhatsApp */}
+      <div className="space-y-3">
+        <div className="flex items-center justify-between">
+          <div className="flex items-center gap-2.5">
+            <div className="flex size-8 items-center justify-center rounded-md bg-muted">
+              <MessageCircle className="size-4" />
+            </div>
+            <div className="flex flex-col">
+              <span className="text-sm font-medium">WhatsApp</span>
+              <span className="text-xs text-muted-foreground">
+                {wa?.state === "connected"
+                  ? `Linked as +${wa.self ?? "?"} — message yourself to use it`
+                  : wa?.state === "qr"
+                    ? "Scan the QR below with your phone"
+                    : wa?.state === "starting"
+                      ? "Connecting…"
+                      : wa?.state === "error"
+                        ? wa.error ?? "Error"
+                        : "Links your own WhatsApp as a companion device"}
+              </span>
+            </div>
+          </div>
+          <div className="flex items-center gap-2">
+            {wa?.state === "connected" && (
+              <Button
+                variant="outline"
+                size="sm"
+                className="h-7 px-3 text-xs"
+                onClick={() => {
+                  void window.ipc.invoke("channels:whatsappLogout", null).catch(() => {
+                    toast.error("Failed to unlink WhatsApp")
+                  })
+                }}
+              >
+                Unlink
+              </Button>
+            )}
+            <Switch
+              checked={config.whatsapp.enabled}
+              disabled={saving}
+              onCheckedChange={(enabled) =>
+                void save({ ...config, whatsapp: { ...config.whatsapp, enabled } })
+              }
+            />
+          </div>
+        </div>
+
+        {config.whatsapp.enabled && wa?.state === "qr" && wa.qrDataUrl && (
+          <div className="flex items-center gap-4 rounded-md border p-3">
+            <img src={wa.qrDataUrl} alt="WhatsApp pairing QR" className="size-40 rounded" />
+            <div className="text-xs text-muted-foreground space-y-1">
+              <p className="font-medium text-foreground">Link Rowboat to WhatsApp</p>
+              <p>1. Open WhatsApp on your phone</p>
+              <p>2. Settings → Linked Devices → Link a Device</p>
+              <p>3. Scan this code</p>
+              <p className="pt-1">
+                Then message <span className="font-medium">yourself</span> (your own contact) to talk
+                to Rowboat.
+              </p>
+            </div>
+          </div>
+        )}
+
+        {config.whatsapp.enabled && (
+          <div className="space-y-1.5">
+            <label className="text-xs font-medium">Additional allowed numbers</label>
+            <div className="flex gap-2">
+              <Input
+                value={waAllowDraft}
+                onChange={(e) => setWaAllowDraft(e.target.value)}
+                placeholder="e.g. 14155551234, 919876543210"
+                className="h-8 text-xs"
+              />
+              <Button
+                variant="outline"
+                size="sm"
+                className="h-8 px-3 text-xs"
+                disabled={saving}
+                onClick={() =>
+                  void save({
+                    ...config,
+                    whatsapp: { ...config.whatsapp, allowFrom: parseIdList(waAllowDraft) },
+                  })
+                }
+              >
+                Save
+              </Button>
+            </div>
+            <p className="text-xs text-muted-foreground">
+              Your own number (self-chat) is always allowed. Digits only, with country code.
+            </p>
+          </div>
+        )}
+      </div>
+
+      <Separator />
+
+      {/* Telegram */}
+      <div className="space-y-3">
+        <div className="flex items-center justify-between">
+          <div className="flex items-center gap-2.5">
+            <div className="flex size-8 items-center justify-center rounded-md bg-muted">
+              <Send className="size-4" />
+            </div>
+            <div className="flex flex-col">
+              <span className="text-sm font-medium">Telegram</span>
+              <span className="text-xs text-muted-foreground">
+                {tg?.state === "polling"
+                  ? `Listening${tg.botUsername ? ` as @${tg.botUsername}` : ""}`
+                  : tg?.state === "starting"
+                    ? "Connecting…"
+                    : tg?.state === "error"
+                      ? tg.error ?? "Error"
+                      : "Uses your own bot — create one with @BotFather"}
+              </span>
+            </div>
+          </div>
+          <Switch
+            checked={config.telegram.enabled}
+            disabled={saving}
+            onCheckedChange={(enabled) =>
+              void save({ ...config, telegram: { ...config.telegram, enabled } })
+            }
+          />
+        </div>
+
+        {config.telegram.enabled && (
+          <>
+            <div className="space-y-1.5">
+              <label className="text-xs font-medium">Bot token</label>
+              <div className="flex gap-2">
+                <Input
+                  type="password"
+                  value={tokenDraft}
+                  onChange={(e) => setTokenDraft(e.target.value)}
+                  placeholder="123456789:AAF…"
+                  className="h-8 text-xs font-mono"
+                />
+                <Button
+                  variant="outline"
+                  size="sm"
+                  className="h-8 px-3 text-xs"
+                  disabled={saving}
+                  onClick={() =>
+                    void save({
+                      ...config,
+                      telegram: { ...config.telegram, botToken: tokenDraft.trim() },
+                    })
+                  }
+                >
+                  Save
+                </Button>
+              </div>
+              <p className="text-xs text-muted-foreground">
+                Message @BotFather on Telegram → /newbot → paste the token here.
+              </p>
+            </div>
+            <div className="space-y-1.5">
+              <label className="text-xs font-medium">Allowed chat IDs</label>
+              <div className="flex gap-2">
+                <Input
+                  value={tgAllowDraft}
+                  onChange={(e) => setTgAllowDraft(e.target.value)}
+                  placeholder="e.g. 123456789"
+                  className="h-8 text-xs"
+                />
+                <Button
+                  variant="outline"
+                  size="sm"
+                  className="h-8 px-3 text-xs"
+                  disabled={saving}
+                  onClick={() =>
+                    void save({
+                      ...config,
+                      telegram: { ...config.telegram, allowFrom: parseIdList(tgAllowDraft) },
+                    })
+                  }
+                >
+                  Save
+                </Button>
+              </div>
+              <p className="text-xs text-muted-foreground">
+                Message your bot once — it replies with your chat ID to add here.
+              </p>
+            </div>
+          </>
+        )}
+      </div>
+    </div>
+  )
+}
diff --git a/apps/x/apps/renderer/src/components/sidebar-content.tsx b/apps/x/apps/renderer/src/components/sidebar-content.tsx
index 3158e0b8..ae4bd155 100644
--- a/apps/x/apps/renderer/src/components/sidebar-content.tsx
+++ b/apps/x/apps/renderer/src/components/sidebar-content.tsx
@@ -60,6 +60,7 @@ import {
 } from "@/components/ui/tooltip"
 import { cn } from "@/lib/utils"
 import { SettingsDialog } from "@/components/settings-dialog"
+import { MascotFaceIcon } from "@/components/talking-head"
 import { extractConferenceLink } from "@/lib/calendar-event"
 import { useBilling } from "@/hooks/useBilling"
 import { toast } from "@/lib/toast"
@@ -172,6 +173,8 @@ type SidebarContentPanelProps = {
   onNewChat?: () => void
   onToggleBrowser?: () => void
   onVoiceNoteCreated?: (path: string) => void
+  /** Starts the mascot-guided product tour. */
+  onStartTour?: () => void
   /** Which primary destination is currently active, for nav highlighting. */
   activeNav?: 'home' | 'email' | 'meetings' | 'code' | 'knowledge' | 'agents' | 'apps' | 'workspaces' | null
   /** Live meeting recording state, so the recording row can show its indicator/stop. */
@@ -421,6 +424,7 @@ export function SidebarContentPanel({
   onNewChat,
   onToggleBrowser,
   onVoiceNoteCreated,
+  onStartTour,
   activeNav,
   meetingRecordingState = 'idle',
   recordingMeetingSource = null,
@@ -698,13 +702,14 @@ export function SidebarContentPanel({
           <SidebarGroupContent>
             <SidebarMenu>
               <SidebarMenuItem>
-                <SidebarMenuButton isActive={activeNav === 'home'} onClick={onOpenHome}>
+                <SidebarMenuButton data-tour-id="nav-home" isActive={activeNav === 'home'} onClick={onOpenHome}>
                   <Home className="size-4 shrink-0" />
                   <span className="flex-1 truncate">Home</span>
                 </SidebarMenuButton>
               </SidebarMenuItem>
               <SidebarMenuItem>
                 <SidebarMenuButton
+                  data-tour-id="nav-email"
                   isActive={activeNav === 'email'}
                   onClick={() => onOpenEmail?.()}
                   className={previewEmail ? 'h-auto py-1.5' : undefined}
@@ -727,6 +732,7 @@ export function SidebarContentPanel({
               </SidebarMenuItem>
               <SidebarMenuItem>
                 <SidebarMenuButton
+                  data-tour-id="nav-meetings"
                   isActive={activeNav === 'meetings'}
                   onClick={onOpenMeetings}
                   className={meetingSublabel ? 'h-auto py-1.5' : undefined}
@@ -805,7 +811,7 @@ export function SidebarContentPanel({
               </SidebarMenuItem>
               {codeModeEnabled && (
                 <SidebarMenuItem>
-                  <SidebarMenuButton isActive={activeNav === 'code'} onClick={onOpenCode}>
+                  <SidebarMenuButton data-tour-id="nav-code" isActive={activeNav === 'code'} onClick={onOpenCode}>
                     <Code2 className="size-4 shrink-0" />
                     <span className="flex-1 truncate">Code</span>
                   </SidebarMenuButton>
@@ -813,6 +819,7 @@ export function SidebarContentPanel({
               )}
               <SidebarMenuItem>
                 <SidebarMenuButton
+                  data-tour-id="nav-knowledge"
                   isActive={activeNav === 'knowledge'}
                   onClick={() => knowledgeActions.openKnowledgeView()}
                   className={knowledgeUpdatedLabel ? 'h-auto py-1.5' : undefined}
@@ -833,6 +840,7 @@ export function SidebarContentPanel({
             <SidebarMenu>
               <SidebarMenuItem>
                 <SidebarMenuButton
+                  data-tour-id="nav-agents"
                   isActive={activeNav === 'agents'}
                   onClick={onOpenBgTasks}
                   className={bgAgentsLabel ? 'h-auto py-1.5' : undefined}
@@ -857,11 +865,12 @@ export function SidebarContentPanel({
                   onClick={onOpenApps}
                 >
                   <LayoutGrid className="size-4 shrink-0 text-muted-foreground" />
-                  <span className="flex-1 truncate text-muted-foreground">Mini Apps</span>
+                  <span className="flex-1 truncate text-muted-foreground">Apps</span>
                 </SidebarMenuButton>
               </SidebarMenuItem>
               <SidebarMenuItem>
                 <SidebarMenuButton
+                  data-tour-id="nav-workspaces"
                   isActive={activeNav === 'workspaces'}
                   onClick={() => knowledgeActions.openWorkspaceAt()}
                   className="h-auto py-1.5"
@@ -886,6 +895,7 @@ export function SidebarContentPanel({
           <SidebarGroupContent>
             <button
               type="button"
+              data-tour-id="nav-chats"
               onClick={() => setChatsExpanded((v) => !v)}
               className="flex w-full items-center gap-1.5 px-3 py-1 text-[10.5px] font-semibold uppercase tracking-wider text-muted-foreground"
             >
@@ -1027,6 +1037,15 @@ export function SidebarContentPanel({
               </AlertDialog>
             )}
           </div>
+          {onStartTour && (
+            <button
+              onClick={onStartTour}
+              className="flex w-full items-center gap-2 rounded-md px-2 py-1 text-xs text-sidebar-foreground/70 hover:bg-sidebar-accent hover:text-sidebar-accent-foreground transition-colors"
+            >
+              <MascotFaceIcon className="size-4" />
+              <span>Take a tour</span>
+            </button>
+          )}
           <SettingsDialog>
             <button className="flex w-full items-center gap-2 rounded-md px-2 py-1 text-xs text-sidebar-foreground/70 hover:bg-sidebar-accent hover:text-sidebar-accent-foreground transition-colors">
               <Settings className="size-4" />
diff --git a/apps/x/apps/renderer/src/components/talking-head.tsx b/apps/x/apps/renderer/src/components/talking-head.tsx
new file mode 100644
index 00000000..fee8f7db
--- /dev/null
+++ b/apps/x/apps/renderer/src/components/talking-head.tsx
@@ -0,0 +1,487 @@
+import { useCallback, useEffect, useRef, useState } from 'react'
+import { X } from 'lucide-react'
+import type { TTSState } from '@/hooks/useVoiceTTS'
+import { cn } from '@/lib/utils'
+
+const POSITION_STORAGE_KEY = 'talking-head-position'
+
+// Must match the overlay's `bottom-28 right-8` anchor classes.
+const ANCHOR_RIGHT_PX = 32
+const ANCHOR_BOTTOM_PX = 112
+const VIEWPORT_MARGIN_PX = 8
+
+// Palette pulled from the mascot artwork: pale lavender body, dark walnut boat.
+const BODY_FILL = '#E8E9F5'
+const BODY_STROKE = '#17171B'
+const CHEEK_FILL = '#F2B8BE'
+const BOAT_DARK = '#3E2E24'
+const BOAT_MID = '#54402F'
+const BOAT_LIGHT = '#6B5138'
+const MOUTH_FILL = '#2A1E19'
+
+export type MascotHat =
+  | 'mailcap'
+  | 'headphones'
+  | 'hardhat'
+  | 'gradcap'
+  | 'captain'
+  | 'explorer'
+  | 'party'
+
+type TalkingHeadProps = {
+  ttsState: TTSState
+  getLevel: () => number
+  size?: number
+  /** Costume piece drawn on the head (used by the product tour). */
+  hat?: MascotHat
+  /** Paddle hard: fast bobbing + oar strokes, e.g. while traveling in the tour. */
+  rowing?: boolean
+}
+
+/**
+ * The Rowboat mascot as an animated inline SVG: a round pale character sitting
+ * in a wooden rowboat holding an oar. The mouth is driven every animation
+ * frame from the live TTS audio level; eyes blink on a randomized timer.
+ */
+export function TalkingHead({ ttsState, getLevel, size = 160, hat, rowing = false }: TalkingHeadProps) {
+  const mouthOpenRef = useRef<SVGEllipseElement>(null)
+  const mouthSmileRef = useRef<SVGPathElement>(null)
+  const oarRef = useRef<SVGGElement>(null)
+  const smoothedRef = useRef(0)
+  const [blinking, setBlinking] = useState(false)
+
+  const speaking = ttsState === 'speaking'
+  const thinking = ttsState === 'synthesizing'
+
+  // Lip sync + oar paddle loop. Writes SVG attributes directly to avoid
+  // re-rendering React at 60fps. Stops itself once speech has ended and the
+  // mouth has settled closed; restarts when `speaking` flips this effect.
+  useEffect(() => {
+    let raf = 0
+    let t = 0
+    const tick = () => {
+      const target = speaking ? getLevel() : 0
+      const prev = smoothedRef.current
+      // Fast attack, slower decay reads as natural mouth movement
+      const smoothed = target > prev ? prev + (target - prev) * 0.5 : prev + (target - prev) * 0.2
+      const settled = !speaking && !rowing && smoothed < 0.005
+      smoothedRef.current = settled ? 0 : smoothed
+      const open = settled ? 0 : Math.min(1, smoothed * 1.6)
+
+      const mouthOpen = mouthOpenRef.current
+      const mouthSmile = mouthSmileRef.current
+      if (mouthOpen && mouthSmile) {
+        if (open > 0.06) {
+          mouthOpen.setAttribute('rx', String(6.5 + open * 4))
+          mouthOpen.setAttribute('ry', String(1.5 + open * 9))
+          mouthOpen.style.opacity = '1'
+          mouthSmile.style.opacity = '0'
+        } else {
+          mouthOpen.style.opacity = '0'
+          mouthSmile.style.opacity = '1'
+        }
+      }
+
+      const oar = oarRef.current
+      if (oar) {
+        if (rowing) {
+          t += 0.14
+          const angle = Math.sin(t) * 13
+          oar.setAttribute('transform', `rotate(${angle.toFixed(2)} 128 118)`)
+        } else if (speaking) {
+          t += 0.045
+          const angle = Math.sin(t) * 7
+          oar.setAttribute('transform', `rotate(${angle.toFixed(2)} 128 118)`)
+        } else {
+          oar.setAttribute('transform', 'rotate(0 128 118)')
+        }
+      }
+
+      if (!settled) {
+        raf = requestAnimationFrame(tick)
+      }
+    }
+    raf = requestAnimationFrame(tick)
+    return () => cancelAnimationFrame(raf)
+  }, [speaking, rowing, getLevel])
+
+  // Randomized blinking
+  useEffect(() => {
+    let timeout: ReturnType<typeof setTimeout>
+    let cancelled = false
+    const scheduleBlink = () => {
+      timeout = setTimeout(() => {
+        if (cancelled) return
+        setBlinking(true)
+        setTimeout(() => {
+          if (cancelled) return
+          setBlinking(false)
+          scheduleBlink()
+        }, 140)
+      }, 2400 + Math.random() * 2600)
+    }
+    scheduleBlink()
+    return () => {
+      cancelled = true
+      clearTimeout(timeout)
+    }
+  }, [])
+
+  return (
+    <div
+      className="talking-head-bob relative select-none"
+      style={{
+        width: size,
+        height: size,
+        animationDuration: rowing ? '0.8s' : speaking ? '1.6s' : '3.2s',
+      }}
+    >
+      <style>{`
+        @keyframes talking-head-bob {
+          0%, 100% { transform: translateY(0) rotate(-1.6deg); }
+          50% { transform: translateY(-4px) rotate(1.6deg); }
+        }
+        .talking-head-bob {
+          animation-name: talking-head-bob;
+          animation-timing-function: ease-in-out;
+          animation-iteration-count: infinite;
+        }
+        @keyframes talking-head-ripple {
+          0% { transform: scale(0.6); opacity: 0.5; }
+          100% { transform: scale(1.25); opacity: 0; }
+        }
+        .talking-head-ripple {
+          transform-origin: center;
+          transform-box: fill-box;
+          animation: talking-head-ripple 2.6s ease-out infinite;
+        }
+        @keyframes talking-head-bubble {
+          0%, 100% { opacity: 0.25; transform: translateY(0); }
+          50% { opacity: 1; transform: translateY(-2px); }
+        }
+        .talking-head-bubble {
+          animation: talking-head-bubble 1.2s ease-in-out infinite;
+        }
+      `}</style>
+      <svg viewBox="0 0 200 190" width={size} height={size} aria-hidden="true">
+        {/* water ripples under the boat */}
+        <g>
+          <ellipse className="talking-head-ripple" cx="100" cy="168" rx="62" ry="9" fill="none" stroke="#8FB6D9" strokeWidth="2" style={{ animationDelay: '0s' }} />
+          <ellipse className="talking-head-ripple" cx="100" cy="168" rx="62" ry="9" fill="none" stroke="#8FB6D9" strokeWidth="2" style={{ animationDelay: '1.3s' }} />
+          <ellipse cx="100" cy="168" rx="52" ry="7" fill="#8FB6D9" opacity="0.18" />
+        </g>
+
+        {/* thinking bubbles while synthesizing */}
+        {thinking && (
+          <g fill={BODY_STROKE} opacity="0.75">
+            <circle className="talking-head-bubble" cx="146" cy="34" r="3" style={{ animationDelay: '0s' }} />
+            <circle className="talking-head-bubble" cx="157" cy="26" r="4.2" style={{ animationDelay: '0.2s' }} />
+            <circle className="talking-head-bubble" cx="170" cy="16" r="5.4" style={{ animationDelay: '0.4s' }} />
+          </g>
+        )}
+
+        {/* character: head + body blob */}
+        <g>
+          <path
+            d="M 100 22
+               C 129 22 148 43 148 68
+               C 148 82 141 93 131 100
+               C 141 107 147 117 148 128
+               L 52 128
+               C 53 115 60 105 69 99
+               C 59 92 52 81 52 68
+               C 52 43 71 22 100 22 Z"
+            fill={BODY_FILL}
+            stroke={BODY_STROKE}
+            strokeWidth="5"
+            strokeLinejoin="round"
+          />
+          {/* eyes */}
+          <g style={{ transform: thinking ? 'translateY(-2.5px)' : undefined, transition: 'transform 0.3s' }}>
+            <ellipse
+              cx="84" cy="64" rx="5" ry={blinking ? 0.8 : 7}
+              fill={BODY_STROKE}
+              style={{ transition: 'ry 0.06s' }}
+            />
+            <ellipse
+              cx="116" cy="64" rx="5" ry={blinking ? 0.8 : 7}
+              fill={BODY_STROKE}
+              style={{ transition: 'ry 0.06s' }}
+            />
+            <circle cx="86" cy="61" r="1.6" fill="#FFFFFF" opacity={blinking ? 0 : 0.9} />
+            <circle cx="118" cy="61" r="1.6" fill="#FFFFFF" opacity={blinking ? 0 : 0.9} />
+          </g>
+          {/* cheeks */}
+          <ellipse cx="72" cy="76" rx="6.5" ry="4" fill={CHEEK_FILL} opacity="0.85" />
+          <ellipse cx="128" cy="76" rx="6.5" ry="4" fill={CHEEK_FILL} opacity="0.85" />
+          {/* mouth: smile when quiet, open ellipse driven by audio level */}
+          <path
+            ref={mouthSmileRef}
+            d="M 91 80 Q 100 88 109 80"
+            fill="none"
+            stroke={BODY_STROKE}
+            strokeWidth="4"
+            strokeLinecap="round"
+          />
+          <ellipse
+            ref={mouthOpenRef}
+            cx="100" cy="84" rx="7" ry="2"
+            fill={MOUTH_FILL}
+            stroke={BODY_STROKE}
+            strokeWidth="3"
+            style={{ opacity: 0 }}
+          />
+          {hat && <MascotHatArt hat={hat} />}
+        </g>
+
+        {/* oar (rotates while speaking) */}
+        <g ref={oarRef}>
+          <line x1="158" y1="88" x2="88" y2="152" stroke={BODY_STROKE} strokeWidth="12" strokeLinecap="round" />
+          <line x1="158" y1="88" x2="88" y2="152" stroke={BOAT_MID} strokeWidth="7" strokeLinecap="round" />
+          <path
+            d="M 84 148 L 56 170 C 52 173 52 178 57 178 L 90 165 Z"
+            fill={BOAT_DARK}
+            stroke={BODY_STROKE}
+            strokeWidth="4"
+            strokeLinejoin="round"
+          />
+        </g>
+
+        {/* hand resting over the oar */}
+        <ellipse cx="121" cy="120" rx="10" ry="8" fill={BODY_FILL} stroke={BODY_STROKE} strokeWidth="4" />
+
+        {/* boat hull (drawn last so it overlaps the body) */}
+        <g>
+          <path
+            d="M 30 120
+               C 50 132 150 132 170 120
+               C 168 142 152 160 100 160
+               C 48 160 32 142 30 120 Z"
+            fill={BOAT_MID}
+            stroke={BODY_STROKE}
+            strokeWidth="5"
+            strokeLinejoin="round"
+          />
+          {/* plank lines */}
+          <path d="M 36 133 C 60 143 140 143 164 133" fill="none" stroke={BOAT_DARK} strokeWidth="3" strokeLinecap="round" />
+          <path d="M 44 145 C 66 153 134 153 156 145" fill="none" stroke={BOAT_DARK} strokeWidth="3" strokeLinecap="round" />
+          {/* gunwale highlight */}
+          <path d="M 33 121 C 52 131 148 131 167 121" fill="none" stroke={BOAT_LIGHT} strokeWidth="4" strokeLinecap="round" />
+        </g>
+      </svg>
+    </div>
+  )
+}
+
+type TalkingHeadOverlayProps = {
+  ttsState: TTSState
+  getLevel: () => number
+  onDismiss?: () => void
+}
+
+// Keep the widget fully on-screen relative to its bottom-right CSS anchor.
+// Falls back to the default render size when the element isn't mounted yet.
+function clampPositionToViewport(pos: { x: number; y: number }, el: HTMLDivElement | null): { x: number; y: number } {
+  const width = el?.offsetWidth ?? 160
+  const height = el?.offsetHeight ?? 160
+  const baseLeft = window.innerWidth - ANCHOR_RIGHT_PX - width
+  const baseTop = window.innerHeight - ANCHOR_BOTTOM_PX - height
+  const clamp = (v: number, min: number, max: number) => Math.max(min, Math.min(max, v))
+  return {
+    x: clamp(pos.x, VIEWPORT_MARGIN_PX - baseLeft, window.innerWidth - VIEWPORT_MARGIN_PX - width - baseLeft),
+    y: clamp(pos.y, VIEWPORT_MARGIN_PX - baseTop, window.innerHeight - VIEWPORT_MARGIN_PX - height - baseTop),
+  }
+}
+
+function loadStoredPosition(): { x: number; y: number } {
+  try {
+    const raw = localStorage.getItem(POSITION_STORAGE_KEY)
+    if (raw) {
+      const parsed = JSON.parse(raw)
+      if (typeof parsed?.x === 'number' && typeof parsed?.y === 'number') {
+        return parsed
+      }
+    }
+  } catch {
+    // ignore corrupt stored position
+  }
+  return { x: 0, y: 0 }
+}
+
+/**
+ * Floating, draggable widget that hosts the talking head. Anchored to the
+ * bottom-right of the window (above the composer) and offset by a persisted
+ * drag position, so it hovers over whatever view is active.
+ */
+export function TalkingHeadOverlay({ ttsState, getLevel, onDismiss }: TalkingHeadOverlayProps) {
+  // Clamp the stored offset at init so a stale position (e.g. saved on a
+  // bigger window) can't leave the widget stranded off-screen.
+  const [offset, setOffset] = useState(() => clampPositionToViewport(loadStoredPosition(), null))
+  const [dragging, setDragging] = useState(false)
+  const dragStartRef = useRef<{ pointerX: number; pointerY: number; x: number; y: number } | null>(null)
+  const containerRef = useRef<HTMLDivElement>(null)
+
+  const clampToViewport = useCallback(
+    (pos: { x: number; y: number }) => clampPositionToViewport(pos, containerRef.current),
+    []
+  )
+
+  // Re-clamp when the window shrinks
+  useEffect(() => {
+    const handleResize = () => setOffset(prev => clampToViewport(prev))
+    window.addEventListener('resize', handleResize)
+    return () => window.removeEventListener('resize', handleResize)
+  }, [clampToViewport])
+
+  const handlePointerDown = useCallback((e: React.PointerEvent<HTMLDivElement>) => {
+    if (e.button !== 0) return
+    dragStartRef.current = { pointerX: e.clientX, pointerY: e.clientY, x: offset.x, y: offset.y }
+    setDragging(true)
+    e.currentTarget.setPointerCapture(e.pointerId)
+  }, [offset])
+
+  const handlePointerMove = useCallback((e: React.PointerEvent<HTMLDivElement>) => {
+    const start = dragStartRef.current
+    if (!start) return
+    setOffset({
+      x: start.x + (e.clientX - start.pointerX),
+      y: start.y + (e.clientY - start.pointerY),
+    })
+  }, [])
+
+  const handlePointerUp = useCallback((e: React.PointerEvent<HTMLDivElement>) => {
+    if (!dragStartRef.current) return
+    dragStartRef.current = null
+    setDragging(false)
+    setOffset(prev => clampToViewport(prev))
+    e.currentTarget.releasePointerCapture(e.pointerId)
+  }, [clampToViewport])
+
+  useEffect(() => {
+    if (dragging) return
+    try {
+      localStorage.setItem(POSITION_STORAGE_KEY, JSON.stringify(offset))
+    } catch {
+      // best-effort persistence
+    }
+  }, [offset, dragging])
+
+  return (
+    <div
+      ref={containerRef}
+      className={cn(
+        'group fixed bottom-28 right-8 z-50 touch-none',
+        dragging ? 'cursor-grabbing' : 'cursor-grab'
+      )}
+      style={{
+        transform: `translate(${offset.x}px, ${offset.y}px)`,
+        // Constant value so the entrance animation runs once on mount and
+        // never restarts (re-applying it after a drag would replay the pop).
+        animation: 'talking-head-pop 0.35s cubic-bezier(0.34, 1.56, 0.64, 1)',
+      }}
+      onPointerDown={handlePointerDown}
+      onPointerMove={handlePointerMove}
+      onPointerUp={handlePointerUp}
+      onPointerCancel={handlePointerUp}
+      role="img"
+      aria-label="Rowboat talking head"
+    >
+      <style>{`
+        @keyframes talking-head-pop {
+          0% { opacity: 0; scale: 0.4; }
+          100% { opacity: 1; scale: 1; }
+        }
+      `}</style>
+      {onDismiss && (
+        <button
+          type="button"
+          onPointerDown={(e) => e.stopPropagation()}
+          onClick={onDismiss}
+          className="absolute -right-1 -top-1 z-10 flex h-5 w-5 items-center justify-center rounded-full border border-border bg-background text-muted-foreground opacity-0 shadow-sm transition-opacity hover:text-foreground group-hover:opacity-100"
+          aria-label="Hide talking head"
+        >
+          <X className="h-3 w-3" />
+        </button>
+      )}
+      <TalkingHead ttsState={ttsState} getLevel={getLevel} />
+    </div>
+  )
+}
+
+/** Costume pieces for the product tour, drawn on the mascot's head. */
+function MascotHatArt({ hat }: { hat: MascotHat }) {
+  const outline = { stroke: BODY_STROKE, strokeWidth: 4, strokeLinejoin: 'round' as const }
+  switch (hat) {
+    case 'mailcap':
+      return (
+        <g>
+          <path d="M 68 36 Q 100 4 132 36 Q 100 26 68 36 Z" fill="#4A7DDB" {...outline} />
+          <path d="M 126 33 Q 148 31 150 39 Q 132 42 124 39 Z" fill="#3D68B8" {...outline} />
+        </g>
+      )
+    case 'headphones':
+      return (
+        <g>
+          <path d="M 64 58 Q 100 2 136 58" fill="none" stroke={BODY_STROKE} strokeWidth="11" strokeLinecap="round" />
+          <path d="M 64 58 Q 100 2 136 58" fill="none" stroke="#4B5563" strokeWidth="6" strokeLinecap="round" />
+          <ellipse cx="64" cy="61" rx="8" ry="11" fill="#4B5563" {...outline} />
+          <ellipse cx="136" cy="61" rx="8" ry="11" fill="#4B5563" {...outline} />
+        </g>
+      )
+    case 'hardhat':
+      return (
+        <g>
+          <path d="M 66 38 Q 100 0 134 38 Z" fill="#F6C445" {...outline} />
+          <path d="M 96 10 Q 94 22 96 36 L 106 36 Q 107 22 105 9 Z" fill="#E0AC2C" stroke="none" />
+          <path d="M 56 38 L 144 38" fill="none" stroke={BODY_STROKE} strokeWidth="9" strokeLinecap="round" />
+          <path d="M 58 38 L 142 38" fill="none" stroke="#F6C445" strokeWidth="5" strokeLinecap="round" />
+        </g>
+      )
+    case 'gradcap':
+      return (
+        <g>
+          <path d="M 80 28 Q 100 42 120 28 L 120 38 Q 100 50 80 38 Z" fill="#232838" {...outline} />
+          <path d="M 100 2 L 144 20 L 100 38 L 56 20 Z" fill="#2E3450" {...outline} />
+          <path d="M 100 20 Q 124 26 136 34" fill="none" stroke="#E8B94A" strokeWidth="3" strokeLinecap="round" />
+          <circle cx="137" cy="38" r="4" fill="#E8B94A" stroke={BODY_STROKE} strokeWidth="3" />
+        </g>
+      )
+    case 'captain':
+      return (
+        <g>
+          <path d="M 68 36 Q 100 -2 132 36 Q 100 28 68 36 Z" fill="#F4F5F9" {...outline} />
+          <path d="M 66 36 Q 100 46 134 36 L 134 42 Q 100 52 66 42 Z" fill="#22262E" {...outline} />
+          <path d="M 122 42 Q 146 42 148 48 Q 130 52 120 48 Z" fill="#22262E" {...outline} />
+          <circle cx="100" cy="38" r="4.5" fill="#E8B94A" stroke={BODY_STROKE} strokeWidth="3" />
+        </g>
+      )
+    case 'explorer':
+      return (
+        <g>
+          <ellipse cx="100" cy="35" rx="46" ry="9" fill="#C9A46B" {...outline} />
+          <path d="M 72 34 Q 100 4 128 34 Z" fill="#C9A46B" {...outline} />
+          <path d="M 76 30 Q 100 38 124 30" fill="none" stroke="#8A6B3D" strokeWidth="4" strokeLinecap="round" />
+        </g>
+      )
+    case 'party':
+      return (
+        <g>
+          <path d="M 100 -2 L 84 34 L 116 34 Z" fill="#F2699C" {...outline} />
+          <path d="M 92 16 L 111 22 M 88 26 L 114 31" fill="none" stroke="#FFD166" strokeWidth="3.5" strokeLinecap="round" />
+          <circle cx="100" cy="0" r="5" fill="#FFD166" stroke={BODY_STROKE} strokeWidth="3" />
+        </g>
+      )
+  }
+}
+
+/** Small static mascot face used as the toolbar toggle icon. */
+export function MascotFaceIcon({ className }: { className?: string }) {
+  return (
+    <svg viewBox="0 0 24 24" width="16" height="16" className={className} aria-hidden="true">
+      <circle cx="12" cy="12" r="9.5" fill="none" stroke="currentColor" strokeWidth="1.8" />
+      <ellipse cx="8.6" cy="10.5" rx="1.3" ry="1.8" fill="currentColor" />
+      <ellipse cx="15.4" cy="10.5" rx="1.3" ry="1.8" fill="currentColor" />
+      <path d="M 9 14.5 Q 12 17 15 14.5" fill="none" stroke="currentColor" strokeWidth="1.8" strokeLinecap="round" />
+    </svg>
+  )
+}
diff --git a/apps/x/apps/renderer/src/components/tour-vignettes.tsx b/apps/x/apps/renderer/src/components/tour-vignettes.tsx
new file mode 100644
index 00000000..909409e7
--- /dev/null
+++ b/apps/x/apps/renderer/src/components/tour-vignettes.tsx
@@ -0,0 +1,262 @@
+import { useEffect } from 'react'
+
+export type MascotVignetteKind = 'email' | 'meetings' | 'brain'
+export type TourVignetteKind = MascotVignetteKind | 'agents'
+
+/**
+ * Little looping "shows" staged around the mascot while it presents a section
+ * during the product tour. Purely decorative: everything is pointer-events-none
+ * and rendered on the tour's own layers, never inside the section's real UI.
+ */
+export function MascotVignette({ kind, playDing }: { kind: MascotVignetteKind; playDing?: () => void }) {
+  // One round of dings as the first envelopes land, then let the loop run silent
+  useEffect(() => {
+    if (kind !== 'email' || !playDing) return
+    const timers = [900, 1900, 2900].map((ms) => setTimeout(playDing, ms))
+    return () => timers.forEach(clearTimeout)
+  }, [kind, playDing])
+
+  return (
+    <div className="pointer-events-none absolute left-1/2 top-0 z-0 -translate-x-1/2" aria-hidden="true">
+      <style>{`
+        @keyframes tour-env-left {
+          0% { opacity: 0; transform: translate(-150px, -130px) rotate(-26deg); }
+          10% { opacity: 1; }
+          52% { opacity: 1; transform: translate(0px, 0px) rotate(5deg); }
+          64% { opacity: 0; transform: translate(2px, 12px) rotate(5deg); }
+          100% { opacity: 0; transform: translate(2px, 12px) rotate(5deg); }
+        }
+        @keyframes tour-env-right {
+          0% { opacity: 0; transform: translate(150px, -140px) rotate(26deg); }
+          10% { opacity: 1; }
+          52% { opacity: 1; transform: translate(0px, 0px) rotate(-5deg); }
+          64% { opacity: 0; transform: translate(-2px, 12px) rotate(-5deg); }
+          100% { opacity: 0; transform: translate(-2px, 12px) rotate(-5deg); }
+        }
+        @keyframes tour-badge-pulse {
+          0%, 100% { transform: scale(1); }
+          50% { transform: scale(1.15); }
+        }
+        @keyframes tour-note-line {
+          0% { width: 0; }
+          18% { width: var(--w); }
+          80% { width: var(--w); opacity: 1; }
+          92%, 100% { width: var(--w); opacity: 0; }
+        }
+        @keyframes tour-quill-bob {
+          0% { transform: translate(4px, 26px) rotate(-8deg); }
+          25% { transform: translate(46px, 30px) rotate(4deg); }
+          50% { transform: translate(6px, 40px) rotate(-8deg); }
+          75% { transform: translate(48px, 44px) rotate(4deg); }
+          100% { transform: translate(4px, 26px) rotate(-8deg); }
+        }
+        @keyframes tour-voice-bar {
+          0%, 100% { transform: scaleY(0.35); }
+          50% { transform: scaleY(1); }
+        }
+        @keyframes tour-orb {
+          0% { opacity: 0; transform: translate(var(--from-x), var(--from-y)) scale(0.5); }
+          15% { opacity: 0.9; }
+          70% { opacity: 0.9; transform: translate(0, 0) scale(1); }
+          85%, 100% { opacity: 0; transform: translate(0, 6px) scale(0.3); }
+        }
+        @keyframes tour-node-pulse {
+          0%, 100% { opacity: 0.55; }
+          50% { opacity: 1; }
+        }
+        @keyframes tour-edge-draw {
+          from { stroke-dashoffset: 60; }
+          to { stroke-dashoffset: 0; }
+        }
+      `}</style>
+
+      {kind === 'email' && (
+        <div className="relative" style={{ width: 240, height: 150 }}>
+          {[
+            { anim: 'tour-env-left', delay: 0, x: 78, y: 96 },
+            { anim: 'tour-env-right', delay: 1.0, x: 128, y: 102 },
+            { anim: 'tour-env-left', delay: 2.0, x: 104, y: 92 },
+            { anim: 'tour-env-right', delay: 3.0, x: 90, y: 104 },
+          ].map((e, i) => (
+            <div
+              key={i}
+              className="absolute"
+              style={{ left: e.x, top: e.y, animation: `${e.anim} 4s ease-in-out ${e.delay}s infinite both` }}
+            >
+              <svg width="34" height="24" viewBox="0 0 34 24">
+                <rect x="1.5" y="1.5" width="31" height="21" rx="3" fill="#FFF8E7" stroke="#17171B" strokeWidth="2.5" />
+                <path d="M 2 4 L 17 14 L 32 4" fill="none" stroke="#17171B" strokeWidth="2.5" strokeLinejoin="round" />
+              </svg>
+            </div>
+          ))}
+          <div
+            className="absolute"
+            style={{ left: 148, top: 78, animation: 'tour-badge-pulse 2s ease-in-out infinite' }}
+          >
+            <svg width="22" height="22" viewBox="0 0 22 22">
+              <circle cx="11" cy="11" r="9.5" fill="#3FA95C" stroke="#17171B" strokeWidth="2.5" />
+              <path d="M 6.5 11.5 L 9.5 14.5 L 15.5 8" fill="none" stroke="#FFFFFF" strokeWidth="2.5" strokeLinecap="round" strokeLinejoin="round" />
+            </svg>
+          </div>
+        </div>
+      )}
+
+      {kind === 'meetings' && (
+        <div className="relative" style={{ width: 220, height: 160, top: -110 }}>
+          {/* someone's talking */}
+          <div className="absolute left-1/2 flex -translate-x-1/2 items-end gap-1" style={{ top: 0, height: 26 }}>
+            {[0.9, 1.1, 0.7, 1.3, 0.8].map((dur, i) => (
+              <div
+                key={i}
+                className="w-1.5 origin-bottom rounded-full bg-[#8FB6D9]"
+                style={{ height: 22, animation: `tour-voice-bar ${dur}s ease-in-out ${i * 0.12}s infinite` }}
+              />
+            ))}
+          </div>
+          {/* ...and the notepad writes itself */}
+          <div
+            className="absolute left-1/2 rounded-md border-2 border-[#17171B] bg-[#FFFDF6] shadow-md"
+            style={{ top: 36, width: 96, height: 104, transform: 'translateX(-50%) rotate(-3deg)' }}
+          >
+            <div className="mx-2 mt-2 h-1.5 rounded bg-[#D9534F]/70" />
+            {[64, 52, 60, 44].map((w, i) => (
+              <div
+                key={i}
+                className="ml-2 mt-3 h-1.5 rounded bg-[#9AA1AE]"
+                style={{ ['--w' as string]: `${w}px`, animation: `tour-note-line 5s ease-out ${i * 1.1}s infinite both` }}
+              />
+            ))}
+            <svg
+              className="absolute left-0 top-0"
+              width="26"
+              height="26"
+              viewBox="0 0 26 26"
+              style={{ animation: 'tour-quill-bob 5s ease-in-out infinite' }}
+            >
+              <path d="M 4 22 L 10 12 Q 14 4 22 2 Q 18 10 12 14 Z" fill="#6B5138" stroke="#17171B" strokeWidth="2" strokeLinejoin="round" />
+            </svg>
+          </div>
+        </div>
+      )}
+
+      {kind === 'brain' && (
+        <div className="relative" style={{ width: 260, height: 180, top: -128 }}>
+          {/* constellation assembling above the head */}
+          <svg className="absolute left-1/2 -translate-x-1/2" width="140" height="80" viewBox="0 0 140 80" style={{ top: 0 }}>
+            {[
+              'M 22 58 L 52 24',
+              'M 52 24 L 88 40',
+              'M 88 40 L 120 18',
+              'M 88 40 L 70 66',
+            ].map((d, i) => (
+              <path
+                key={i}
+                d={d}
+                fill="none"
+                stroke="#9CCBEA"
+                strokeWidth="2"
+                strokeDasharray="60"
+                style={{ animation: `tour-edge-draw 1.2s ease-out ${0.4 + i * 0.35}s both` }}
+              />
+            ))}
+            {[
+              [22, 58], [52, 24], [88, 40], [120, 18], [70, 66],
+            ].map(([cx, cy], i) => (
+              <circle
+                key={i}
+                cx={cx}
+                cy={cy}
+                r={5}
+                fill="#BFE0F5"
+                stroke="#17171B"
+                strokeWidth="2"
+                style={{ animation: `tour-node-pulse 2.4s ease-in-out ${i * 0.3}s infinite` }}
+              />
+            ))}
+          </svg>
+          {/* thought-orbs drifting into the head */}
+          {[
+            { fx: '-120px', fy: '-30px', delay: 0 },
+            { fx: '120px', fy: '-40px', delay: 1.1 },
+            { fx: '-90px', fy: '50px', delay: 2.2 },
+            { fx: '110px', fy: '46px', delay: 3.3 },
+          ].map((o, i) => (
+            <div
+              key={i}
+              className="absolute rounded-full"
+              style={{
+                left: 122,
+                top: 118,
+                width: 16,
+                height: 16,
+                background: 'radial-gradient(circle, #FFF3B8 20%, #FFD166 60%, transparent 75%)',
+                ['--from-x' as string]: o.fx,
+                ['--from-y' as string]: o.fy,
+                animation: `tour-orb 4.4s ease-in-out ${o.delay}s infinite both`,
+              }}
+            />
+          ))}
+        </div>
+      )}
+    </div>
+  )
+}
+
+/**
+ * Background-agents vignette: a fleet of tiny mascots rowing across the water
+ * at the bottom of the screen while the big one takes a break.
+ */
+export function AgentsFleet() {
+  return (
+    <div className="pointer-events-none fixed inset-x-0 bottom-0 z-[67] h-28 overflow-hidden" aria-hidden="true">
+      <style>{`
+        @keyframes tour-fleet-right {
+          from { transform: translateX(-18vw); }
+          to { transform: translateX(112vw); }
+        }
+        @keyframes tour-fleet-left {
+          from { transform: translateX(112vw); }
+          to { transform: translateX(-18vw); }
+        }
+        @keyframes tour-fleet-bob {
+          0%, 100% { transform: translateY(0) rotate(-2deg); }
+          50% { transform: translateY(-3px) rotate(2deg); }
+        }
+      `}</style>
+      {[
+        { size: 46, bottom: 4, dur: 16, delay: 0, dir: 'tour-fleet-right' },
+        { size: 34, bottom: 22, dur: 22, delay: -8, dir: 'tour-fleet-left' },
+        { size: 28, bottom: 14, dur: 27, delay: -3, dir: 'tour-fleet-right' },
+      ].map((b, i) => (
+        <div
+          key={i}
+          className="absolute left-0"
+          style={{ bottom: b.bottom, animation: `${b.dir} ${b.dur}s linear ${b.delay}s infinite` }}
+        >
+          <div style={{ animation: 'tour-fleet-bob 1.4s ease-in-out infinite', transform: b.dir === 'tour-fleet-left' ? 'scaleX(-1)' : undefined }}>
+            <MiniRower size={b.size} flipped={b.dir === 'tour-fleet-left'} />
+          </div>
+        </div>
+      ))}
+    </div>
+  )
+}
+
+function MiniRower({ size, flipped }: { size: number; flipped: boolean }) {
+  return (
+    <svg
+      width={size}
+      height={size * 0.75}
+      viewBox="0 0 60 45"
+      style={{ transform: flipped ? 'scaleX(-1)' : undefined }}
+    >
+      <circle cx="27" cy="13" r="10" fill="#E8E9F5" stroke="#17171B" strokeWidth="3" />
+      <circle cx="23.5" cy="11.5" r="1.4" fill="#17171B" />
+      <circle cx="30.5" cy="11.5" r="1.4" fill="#17171B" />
+      <path d="M 23 16 Q 27 19 31 16" fill="none" stroke="#17171B" strokeWidth="1.6" strokeLinecap="round" />
+      <line x1="40" y1="14" x2="20" y2="38" stroke="#17171B" strokeWidth="4.5" strokeLinecap="round" />
+      <line x1="40" y1="14" x2="20" y2="38" stroke="#54402F" strokeWidth="2.5" strokeLinecap="round" />
+      <path d="M 7 25 C 17 31 43 31 53 25 C 51 37 43 42 30 42 C 17 42 9 37 7 25 Z" fill="#54402F" stroke="#17171B" strokeWidth="3" strokeLinejoin="round" />
+    </svg>
+  )
+}
diff --git a/apps/x/apps/renderer/src/components/video-call-view.tsx b/apps/x/apps/renderer/src/components/video-call-view.tsx
new file mode 100644
index 00000000..38031b68
--- /dev/null
+++ b/apps/x/apps/renderer/src/components/video-call-view.tsx
@@ -0,0 +1,238 @@
+import { useEffect, useRef, useState } from 'react'
+import { Minimize2, MonitorUp, PhoneOff, Presentation, Square, User, Video, VideoOff } from 'lucide-react'
+
+import { MascotFaceIcon, TalkingHead } from '@/components/talking-head'
+import type { TTSState } from '@/hooks/useVoiceTTS'
+import { cn } from '@/lib/utils'
+
+export type VideoCallStatus = 'listening' | 'thinking' | 'speaking'
+
+interface VideoCallViewProps {
+  /** Live camera stream from useVideoMode — attached to the user's tile. */
+  streamRef: React.MutableRefObject<MediaStream | null>
+  cameraOn: boolean
+  onToggleCamera: () => void
+  /** Starting a share collapses this view into the floating popout (the
+   *  surface is derived from devices — see App.tsx). */
+  onToggleScreenShare: () => void
+  /** Practice preset: the assistant is coaching this session. */
+  practiceMode?: boolean
+  /** Shrink to the floating pill without touching any devices. */
+  onMinimize: () => void
+  /** Stop the assistant: silence speech and abort the run if still going. */
+  onInterrupt: () => void
+  ttsState: TTSState
+  /** Live TTS output level — drives the mascot's mouth animation. */
+  getTtsLevel: () => number
+  status: VideoCallStatus
+  /** Live transcript of the user's in-progress utterance. */
+  interimText?: string
+  /** The assistant line currently being spoken aloud. */
+  assistantCaption?: string
+  onLeave: () => void
+}
+
+const STATUS_DISPLAY: Record<VideoCallStatus, { label: string; dotClass: string }> = {
+  listening: { label: 'Listening', dotClass: 'bg-green-500 animate-pulse' },
+  thinking: { label: 'Thinking…', dotClass: 'bg-amber-400' },
+  speaking: { label: 'Speaking', dotClass: 'bg-sky-400 animate-pulse' },
+}
+
+/**
+ * Full-screen call surface: a Meet-style two-tile layout with the user's
+ * webcam on one side and the mascot as the other participant. Shown only
+ * while the camera is on with no screen share (the derived-surface rule in
+ * App.tsx) — sharing or muting the camera moves the call into the floating
+ * popout. The mascot animates with the assistant's speech; dismissing it
+ * swaps in a Meet-style letter avatar ("R"). Live captions run along the
+ * bottom.
+ */
+export function VideoCallView({
+  streamRef,
+  cameraOn,
+  onToggleCamera,
+  onToggleScreenShare,
+  practiceMode,
+  onMinimize,
+  onInterrupt,
+  ttsState,
+  getTtsLevel,
+  status,
+  interimText,
+  assistantCaption,
+  onLeave,
+}: VideoCallViewProps) {
+  const videoRef = useRef<HTMLVideoElement | null>(null)
+  const [mascotVisible, setMascotVisible] = useState(true)
+
+  useEffect(() => {
+    if (!cameraOn) return
+    const videoEl = videoRef.current
+    if (!videoEl) return
+    videoEl.srcObject = streamRef.current
+    videoEl.play().catch(() => {})
+    return () => {
+      videoEl.srcObject = null
+    }
+  }, [streamRef, cameraOn])
+
+  const userSpeaking = status === 'listening' && Boolean(interimText)
+  const assistantSpeaking = ttsState === 'speaking'
+
+  const caption = assistantSpeaking && assistantCaption
+    ? { who: 'Rowboat', text: assistantCaption }
+    : interimText
+      ? { who: 'You', text: interimText }
+      : null
+
+  return (
+    <div className="fixed inset-0 z-[100] flex flex-col bg-neutral-950">
+      {practiceMode && (
+        <span className="absolute left-4 top-4 z-10 flex items-center gap-1.5 rounded-full bg-violet-600/90 px-3 py-1 text-xs font-medium text-white">
+          <Presentation className="h-3.5 w-3.5" />
+          Practice session
+        </span>
+      )}
+      <button
+        type="button"
+        onClick={onMinimize}
+        className="absolute right-4 top-4 z-10 flex h-8 w-8 items-center justify-center rounded-full bg-neutral-800 text-white/80 transition-colors hover:bg-neutral-700 hover:text-white"
+        aria-label="Minimize call (shares your screen)"
+        title="Minimize — shares your screen so it can help you work"
+      >
+        <Minimize2 className="h-4 w-4" />
+      </button>
+
+      {/* Participant tiles */}
+      <div className="grid min-h-0 flex-1 grid-cols-1 gap-3 p-4 pb-2 md:grid-cols-2">
+        {/* User */}
+        <div
+          className={cn(
+            'relative flex items-center justify-center overflow-hidden rounded-2xl bg-neutral-900 transition-shadow',
+            userSpeaking && 'ring-2 ring-green-500/80'
+          )}
+        >
+          {cameraOn ? (
+            <video
+              ref={videoRef}
+              muted
+              playsInline
+              className="h-full w-full object-cover"
+              style={{ transform: 'scaleX(-1)' }}
+            />
+          ) : (
+            <span className="flex h-40 w-40 items-center justify-center rounded-full bg-neutral-700 text-neutral-400" aria-label="Camera off">
+              <User className="h-20 w-20" />
+            </span>
+          )}
+          <span className="absolute bottom-3 left-3 rounded-md bg-black/50 px-2 py-0.5 text-sm text-white">
+            You
+          </span>
+        </div>
+
+        {/* Assistant */}
+        <div
+          className={cn(
+            'group relative flex items-center justify-center overflow-hidden rounded-2xl bg-neutral-900 transition-shadow',
+            assistantSpeaking && 'ring-2 ring-sky-400/80'
+          )}
+        >
+          {mascotVisible ? (
+            <TalkingHead ttsState={ttsState} getLevel={getTtsLevel} size={220} />
+          ) : (
+            <span
+              className="flex h-40 w-40 items-center justify-center rounded-full bg-sky-600 text-7xl font-medium text-white"
+              aria-label="Rowboat"
+            >
+              R
+            </span>
+          )}
+          <span className="absolute bottom-3 left-3 rounded-md bg-black/50 px-2 py-0.5 text-sm text-white">
+            Rowboat
+          </span>
+          {status !== 'listening' && (
+            <button
+              type="button"
+              onClick={onInterrupt}
+              className="absolute bottom-3 right-3 flex items-center gap-1.5 rounded-md bg-red-600/90 px-2.5 py-1 text-sm font-medium text-white transition-colors hover:bg-red-500"
+              aria-label="Stop the assistant"
+              title={status === 'speaking' ? 'Stop speaking' : 'Stop responding'}
+            >
+              <Square className="h-3 w-3 fill-current" />
+              Stop
+            </button>
+          )}
+          <button
+            type="button"
+            onClick={() => setMascotVisible((v) => !v)}
+            className="absolute right-3 top-3 rounded-md bg-black/50 px-2 py-1 text-xs text-white/80 opacity-0 transition-opacity hover:text-white group-hover:opacity-100"
+          >
+            {mascotVisible ? 'Hide mascot' : 'Show mascot'}
+          </button>
+        </div>
+      </div>
+
+      {/* Captions */}
+      <div className="flex h-14 items-center justify-center px-6">
+        {caption && (
+          <div className="max-w-3xl truncate rounded-lg bg-black/60 px-4 py-2 text-sm text-white/90">
+            <span className="mr-2 font-semibold text-white">{caption.who}:</span>
+            {caption.text}
+          </div>
+        )}
+      </div>
+
+      {/* Control bar */}
+      <div className="flex items-center justify-center gap-4 pb-5">
+        <span className="flex items-center gap-2 rounded-full bg-neutral-800 px-3 py-1.5 text-xs font-medium text-white/90">
+          <span className={cn('block h-2 w-2 rounded-full', STATUS_DISPLAY[status].dotClass)} />
+          {STATUS_DISPLAY[status].label}
+        </span>
+        <button
+          type="button"
+          onClick={onToggleCamera}
+          className={cn(
+            'flex h-10 w-10 items-center justify-center rounded-full transition-colors',
+            cameraOn
+              ? 'bg-neutral-800 text-white/90 hover:bg-neutral-700'
+              : 'bg-red-600 text-white hover:bg-red-500'
+          )}
+          aria-label={cameraOn ? 'Turn off camera' : 'Turn on camera'}
+          title={cameraOn ? 'Turn off camera' : 'Turn on camera'}
+        >
+          {cameraOn ? <Video className="h-5 w-5" /> : <VideoOff className="h-5 w-5" />}
+        </button>
+        <button
+          type="button"
+          onClick={onToggleScreenShare}
+          className="flex h-10 w-10 items-center justify-center rounded-full bg-neutral-800 text-white/90 transition-colors hover:bg-neutral-700"
+          aria-label="Present your screen"
+          title="Present your screen"
+        >
+          <MonitorUp className="h-5 w-5" />
+        </button>
+        <button
+          type="button"
+          onClick={() => setMascotVisible((v) => !v)}
+          className="relative flex h-10 w-10 items-center justify-center rounded-full bg-neutral-800 text-white/90 transition-colors hover:bg-neutral-700"
+          aria-label={mascotVisible ? 'Hide mascot' : 'Show mascot'}
+        >
+          <MascotFaceIcon />
+          {!mascotVisible && (
+            <span className="absolute inset-0 flex items-center justify-center pointer-events-none">
+              <span className="block h-[1.5px] w-6 -rotate-45 rounded-full bg-white/80" />
+            </span>
+          )}
+        </button>
+        <button
+          type="button"
+          onClick={onLeave}
+          className="flex h-10 w-14 items-center justify-center rounded-full bg-red-600 text-white transition-colors hover:bg-red-500"
+          aria-label="End call"
+        >
+          <PhoneOff className="h-5 w-5" />
+        </button>
+      </div>
+    </div>
+  )
+}
diff --git a/apps/x/apps/renderer/src/components/video-popout.tsx b/apps/x/apps/renderer/src/components/video-popout.tsx
new file mode 100644
index 00000000..a3c50436
--- /dev/null
+++ b/apps/x/apps/renderer/src/components/video-popout.tsx
@@ -0,0 +1,207 @@
+import { useCallback, useEffect, useRef, useState } from 'react'
+import { Maximize2, MonitorUp, PhoneOff, Square, User, Video, VideoOff } from 'lucide-react'
+
+import { TalkingHead } from '@/components/talking-head'
+
+type PopoutState = {
+  ttsState: 'idle' | 'synthesizing' | 'speaking'
+  status: 'listening' | 'thinking' | 'speaking' | null
+  cameraOn: boolean
+  screenSharing: boolean
+  interimText: string | null
+}
+
+const STATUS_DISPLAY: Record<NonNullable<PopoutState['status']>, { label: string; dotClass: string }> = {
+  listening: { label: 'Listening', dotClass: 'bg-green-500 animate-pulse' },
+  thinking: { label: 'Thinking…', dotClass: 'bg-amber-400' },
+  speaking: { label: 'Speaking', dotClass: 'bg-sky-400 animate-pulse' },
+}
+
+const dragRegion = { WebkitAppRegion: 'drag' } as React.CSSProperties
+const noDragRegion = { WebkitAppRegion: 'no-drag' } as React.CSSProperties
+
+/**
+ * Content of the always-on-top popout window shown for the whole duration of
+ * a screen share (Meet-style floating mini-call) — it floats over every app,
+ * including Rowboat itself, and is the call's control surface while sharing:
+ * camera toggle, share toggle, end-call. Rendered in its own BrowserWindow
+ * (see `video:setPopout` in the main process); call state streams in over
+ * the `video:popout-state` push channel and control actions round-trip back
+ * through `video:popoutAction`. Captures its own webcam feed — MediaStreams
+ * can't cross windows.
+ */
+export function VideoPopout() {
+  // Camera defaults OFF: guessing "on" would flash the user's video for a
+  // beat before the real state arrives — which reads as a bug. The true
+  // state is fetched immediately below.
+  const [state, setState] = useState<PopoutState>({ ttsState: 'idle', status: null, cameraOn: false, screenSharing: false, interimText: null })
+  const videoRef = useRef<HTMLVideoElement | null>(null)
+
+  useEffect(() => {
+    const cleanup = window.ipc.on('video:popout-state', (next) => setState(next))
+    // The main process replays the cached state on did-finish-load, but that
+    // can race this listener's registration — fetch it explicitly too.
+    window.ipc
+      .invoke('video:getPopoutState', null)
+      .then(({ state: cached }) => {
+        if (cached) setState(cached)
+      })
+      .catch(() => {})
+    return cleanup
+  }, [])
+
+  // Own camera feed, following the main window's camera-on/off state.
+  useEffect(() => {
+    if (!state.cameraOn) return
+    let stream: MediaStream | null = null
+    let cancelled = false
+    navigator.mediaDevices
+      .getUserMedia({ video: { width: { ideal: 640 }, facingMode: 'user' }, audio: false })
+      .then((s) => {
+        if (cancelled) {
+          s.getTracks().forEach((t) => t.stop())
+          return
+        }
+        stream = s
+        if (videoRef.current) {
+          videoRef.current.srcObject = s
+          videoRef.current.play().catch(() => {})
+        }
+      })
+      .catch((err) => console.error('[popout] camera failed:', err))
+    return () => {
+      cancelled = true
+      stream?.getTracks().forEach((t) => t.stop())
+      if (videoRef.current) videoRef.current.srcObject = null
+    }
+  }, [state.cameraOn])
+
+  // The popout has no TTS audio pipeline — synthesize a plausible mouth level
+  // so the mascot still animates while the assistant speaks in the main window.
+  const getLevel = useCallback(() => 0.45 + 0.35 * Math.sin(performance.now() / 90), [])
+
+  const sendAction = useCallback((action: 'toggle-camera' | 'toggle-share' | 'stop-speaking' | 'end-call' | 'expand') => {
+    void window.ipc.invoke('video:popoutAction', { action }).catch(() => {})
+  }, [])
+
+  const statusDisplay = state.status ? STATUS_DISPLAY[state.status] : null
+
+  return (
+    <div
+      className="relative flex h-screen w-screen select-none flex-col gap-1.5 bg-neutral-900 p-1.5"
+      style={dragRegion}
+    >
+      <div className="flex min-h-0 flex-1 gap-1.5">
+        <div className="relative flex-1 overflow-hidden rounded-lg bg-neutral-800">
+          {state.cameraOn ? (
+            <video
+              ref={videoRef}
+              muted
+              playsInline
+              className="h-full w-full object-cover"
+              style={{ transform: 'scaleX(-1)' }}
+            />
+          ) : (
+            <div className="flex h-full w-full items-center justify-center">
+              <span className="flex h-12 w-12 items-center justify-center rounded-full bg-neutral-700 text-neutral-400">
+                <User className="h-6 w-6" />
+              </span>
+            </div>
+          )}
+          <span className="absolute bottom-1 left-1.5 rounded bg-black/50 px-1 py-px text-[10px] text-white">
+            You
+          </span>
+          {/* Persistent consent badge — the user must always be able to see
+              at a glance that their screen is going out. */}
+          {state.screenSharing && (
+            <span className="absolute left-1.5 top-1.5 flex items-center gap-1 rounded-full bg-sky-600/90 px-1.5 py-0.5 text-[10px] font-medium text-white">
+              <span className="block h-1.5 w-1.5 animate-pulse rounded-full bg-white" />
+              Sharing screen
+            </span>
+          )}
+        </div>
+        <div className="relative flex flex-1 items-center justify-center overflow-hidden rounded-lg bg-neutral-800">
+          <TalkingHead ttsState={state.ttsState} getLevel={getLevel} size={84} />
+          <span className="absolute bottom-1 left-1.5 rounded bg-black/50 px-1 py-px text-[10px] text-white">
+            Rowboat
+          </span>
+          {statusDisplay && (
+            <span className="absolute right-1.5 top-1.5 flex items-center gap-1 rounded-full bg-black/50 px-1.5 py-0.5 text-[10px] font-medium text-white">
+              <span className={`block h-1.5 w-1.5 rounded-full ${statusDisplay.dotClass}`} />
+              {statusDisplay.label}
+            </span>
+          )}
+          {(state.status === 'speaking' || state.status === 'thinking') && (
+            <button
+              type="button"
+              onClick={() => sendAction('stop-speaking')}
+              className="absolute bottom-1 right-1.5 flex items-center gap-1 rounded bg-red-600/90 px-1.5 py-0.5 text-[10px] font-medium text-white hover:bg-red-500"
+              style={noDragRegion}
+              aria-label="Stop the assistant"
+              title={state.status === 'speaking' ? 'Stop speaking' : 'Stop responding'}
+            >
+              <Square className="h-2.5 w-2.5 fill-current" />
+              Stop
+            </button>
+          )}
+        </div>
+        {/* Live caption of the in-progress utterance, floating over the tiles */}
+        {state.interimText && (
+          <div className="pointer-events-none absolute inset-x-1.5 bottom-9 flex justify-center">
+            <span className="max-w-full truncate rounded bg-black/70 px-1.5 py-0.5 text-[10px] text-white/90">
+              {state.interimText}
+            </span>
+          </div>
+        )}
+      </div>
+
+      {/* Control bar — actions execute in the main app window */}
+      <div className="flex h-7 shrink-0 items-center justify-center gap-2" style={noDragRegion}>
+        <button
+          type="button"
+          onClick={() => sendAction('toggle-camera')}
+          className={`flex h-6 w-6 items-center justify-center rounded-full transition-colors ${
+            state.cameraOn
+              ? 'bg-neutral-700 text-white/90 hover:bg-neutral-600'
+              : 'bg-red-600 text-white hover:bg-red-500'
+          }`}
+          aria-label={state.cameraOn ? 'Turn off camera' : 'Turn on camera'}
+          title={state.cameraOn ? 'Turn off camera' : 'Turn on camera'}
+        >
+          {state.cameraOn ? <Video className="h-3.5 w-3.5" /> : <VideoOff className="h-3.5 w-3.5" />}
+        </button>
+        <button
+          type="button"
+          onClick={() => sendAction('toggle-share')}
+          className={`flex h-6 w-6 items-center justify-center rounded-full transition-colors ${
+            state.screenSharing
+              ? 'bg-sky-600 text-white hover:bg-sky-500'
+              : 'bg-neutral-700 text-white/90 hover:bg-neutral-600'
+          }`}
+          aria-label={state.screenSharing ? 'Stop sharing screen' : 'Share your screen'}
+          title={state.screenSharing ? 'Stop sharing screen' : 'Share your screen'}
+        >
+          <MonitorUp className="h-3.5 w-3.5" />
+        </button>
+        <button
+          type="button"
+          onClick={() => sendAction('end-call')}
+          className="flex h-6 w-8 items-center justify-center rounded-full bg-red-600 text-white transition-colors hover:bg-red-500"
+          aria-label="End call"
+          title="End call"
+        >
+          <PhoneOff className="h-3.5 w-3.5" />
+        </button>
+        <button
+          type="button"
+          onClick={() => sendAction('expand')}
+          className="flex h-6 w-6 items-center justify-center rounded-full bg-neutral-700 text-white/90 transition-colors hover:bg-neutral-600"
+          aria-label="Expand to full screen (stops screen sharing)"
+          title="Expand to full screen (stops sharing)"
+        >
+          <Maximize2 className="h-3.5 w-3.5" />
+        </button>
+      </div>
+    </div>
+  )
+}
diff --git a/apps/x/apps/renderer/src/hooks/useMeetingTranscription.ts b/apps/x/apps/renderer/src/hooks/useMeetingTranscription.ts
index 96f42412..75b4d91f 100644
--- a/apps/x/apps/renderer/src/hooks/useMeetingTranscription.ts
+++ b/apps/x/apps/renderer/src/hooks/useMeetingTranscription.ts
@@ -1,6 +1,7 @@
 import { useCallback, useRef, useState } from 'react';
 import { toast } from 'sonner';
 import { buildDeepgramListenUrl } from '@/lib/deepgram-listen-url';
+import { finalizeDeepgramStream } from '@/lib/deepgram-finalize';
 import { useRowboatAccount } from '@/hooks/useRowboatAccount';
 
 export type MeetingTranscriptionState = 'idle' | 'connecting' | 'recording' | 'stopping';
@@ -196,6 +197,25 @@ export function useMeetingTranscription(onAutoStop?: () => void) {
         }, 1000);
     }, [writeTranscriptToFile]);
 
+    const stopInputCapture = useCallback(() => {
+        if (processorRef.current) {
+            processorRef.current.disconnect();
+            processorRef.current = null;
+        }
+        if (audioCtxRef.current) {
+            audioCtxRef.current.close();
+            audioCtxRef.current = null;
+        }
+        if (micStreamRef.current) {
+            micStreamRef.current.getTracks().forEach(t => t.stop());
+            micStreamRef.current = null;
+        }
+        if (systemStreamRef.current) {
+            systemStreamRef.current.getTracks().forEach(t => t.stop());
+            systemStreamRef.current = null;
+        }
+    }, []);
+
     const cleanup = useCallback(() => {
         if (writeTimerRef.current) {
             clearTimeout(writeTimerRef.current);
@@ -213,28 +233,13 @@ export function useMeetingTranscription(onAutoStop?: () => void) {
             clearInterval(trackPollingRef.current);
             trackPollingRef.current = null;
         }
-        if (processorRef.current) {
-            processorRef.current.disconnect();
-            processorRef.current = null;
-        }
-        if (audioCtxRef.current) {
-            audioCtxRef.current.close();
-            audioCtxRef.current = null;
-        }
-        if (micStreamRef.current) {
-            micStreamRef.current.getTracks().forEach(t => t.stop());
-            micStreamRef.current = null;
-        }
-        if (systemStreamRef.current) {
-            systemStreamRef.current.getTracks().forEach(t => t.stop());
-            systemStreamRef.current = null;
-        }
+        stopInputCapture();
         if (wsRef.current) {
             wsRef.current.onclose = null;
             wsRef.current.close();
             wsRef.current = null;
         }
-    }, []);
+    }, [stopInputCapture]);
 
     const start = useCallback(async (calendarEvent?: CalendarEventMeta): Promise<string | null> => {
         if (state !== 'idle') return null;
@@ -551,12 +556,14 @@ export function useMeetingTranscription(onAutoStop?: () => void) {
         if (state !== 'recording') return;
         setState('stopping');
 
+        stopInputCapture();
+        await finalizeDeepgramStream(wsRef.current, 2200);
         cleanup();
-        interimRef.current = new Map();
         await writeTranscriptToFile();
+        interimRef.current = new Map();
 
         setState('idle');
-    }, [state, cleanup, writeTranscriptToFile]);
+    }, [state, cleanup, stopInputCapture, writeTranscriptToFile]);
 
     return { state, start, stop };
 }
diff --git a/apps/x/apps/renderer/src/hooks/useSessionChat.test.tsx b/apps/x/apps/renderer/src/hooks/useSessionChat.test.tsx
new file mode 100644
index 00000000..b1b57124
--- /dev/null
+++ b/apps/x/apps/renderer/src/hooks/useSessionChat.test.tsx
@@ -0,0 +1,123 @@
+import { StrictMode } from 'react'
+import { act, renderHook, waitFor } from '@testing-library/react'
+import { describe, expect, it } from 'vitest'
+import type { SessionBusEvent } from '@x/shared/src/sessions.js'
+import type { SessionsClient } from '@/lib/session-chat/client'
+import type { SessionFeedListener } from '@/lib/session-chat/feed'
+import {
+  assistantText,
+  completed,
+  completedTurnLog,
+  created,
+  requested,
+  sessionState,
+  turnCompleted,
+  user,
+} from '@/lib/session-chat/test-fixtures'
+import { isChatMessage } from '@/lib/chat-conversation'
+import { useSessionChat } from './useSessionChat'
+
+const S1 = 'sess-1'
+
+function makeDeps() {
+  const calls: Array<{ method: string; args: unknown[] }> = []
+  let emit: SessionFeedListener = () => undefined
+  let unsubscribed = 0
+  const sessions = new Map([[S1, sessionState(S1, ['turn-1'])]])
+  const turns = new Map([['turn-1', completedTurnLog('turn-1', S1, 'q1', 'a1')]])
+  const client: SessionsClient = {
+    create: async () => ({ sessionId: 'x' }),
+    list: async () => ({ sessions: [] }),
+    get: async (sessionId) => {
+      const state = sessions.get(sessionId)
+      if (!state) throw new Error('session not found')
+      return state
+    },
+    getTurn: async (turnId) => ({ turnId, events: turns.get(turnId) ?? [] }),
+    sendMessage: async (...args) => {
+      calls.push({ method: 'sendMessage', args })
+      return { turnId: 'turn-2' }
+    },
+    respondToPermission: async (...args) => {
+      calls.push({ method: 'respondToPermission', args })
+    },
+    respondToAskHuman: async (...args) => {
+      calls.push({ method: 'respondToAskHuman', args })
+    },
+    stopTurn: async (...args) => {
+      calls.push({ method: 'stopTurn', args })
+    },
+    resumeTurn: async () => undefined,
+    setTitle: async () => undefined,
+    delete: async () => undefined,
+  }
+  return {
+    deps: {
+      client,
+      subscribeFeed: (listener: SessionFeedListener) => {
+        emit = listener
+        return () => {
+          unsubscribed += 1
+        }
+      },
+    },
+    calls,
+    emit: (event: SessionBusEvent) => emit(event),
+    getUnsubscribed: () => unsubscribed,
+  }
+}
+
+describe('useSessionChat', () => {
+  it('seeds from the session, follows live events, and routes actions', async () => {
+    const { deps, calls, emit } = makeDeps()
+    const { result } = renderHook(() => useSessionChat(S1, deps), { wrapper: StrictMode })
+
+    await waitFor(() => {
+      expect(result.current.latestTurnId).toBe('turn-1')
+    })
+    expect(
+      result.current.chatState?.conversation.filter(isChatMessage).map((m) => m.content),
+    ).toEqual(['q1', 'a1'])
+
+    // A new turn streams in over the feed.
+    act(() => {
+      emit({ kind: 'turn-event', sessionId: S1, turnId: 'turn-2', event: created('turn-2', S1, user('q2')) })
+      emit({ kind: 'turn-event', sessionId: S1, turnId: 'turn-2', event: requested('turn-2', 0) })
+      emit({
+        kind: 'turn-event',
+        sessionId: S1,
+        turnId: 'turn-2',
+        event: { type: 'text_delta', turnId: 'turn-2', modelCallIndex: 0, delta: 'a2…' },
+      })
+    })
+    expect(result.current.latestTurnId).toBe('turn-2')
+    expect(result.current.chatState?.currentAssistantMessage).toBe('a2…')
+    expect(result.current.chatState?.isProcessing).toBe(true)
+
+    act(() => {
+      emit({ kind: 'turn-event', sessionId: S1, turnId: 'turn-2', event: completed('turn-2', 0, assistantText('a2')) })
+      emit({ kind: 'turn-event', sessionId: S1, turnId: 'turn-2', event: turnCompleted('turn-2', 'a2') })
+    })
+    expect(result.current.chatState?.isProcessing).toBe(false)
+
+    await act(async () => {
+      await result.current.respondToPermission('tc1', 'deny')
+      await result.current.stop()
+    })
+    expect(calls).toEqual([
+      { method: 'respondToPermission', args: ['turn-2', 'tc1', 'deny', undefined] },
+      { method: 'stopTurn', args: ['turn-2'] },
+    ])
+  })
+
+  it('unsubscribes from the feed on unmount (StrictMode double-mounts included)', async () => {
+    const { deps, getUnsubscribed } = makeDeps()
+    const { unmount } = renderHook(() => useSessionChat(S1, deps), {
+      wrapper: StrictMode,
+    })
+    unmount()
+    // StrictMode's simulated cleanup plus the real unmount: every subscribe
+    // was matched by an unsubscribe.
+    expect(getUnsubscribed()).toBe(2)
+  })
+})
diff --git a/apps/x/apps/renderer/src/hooks/useSessionChat.ts b/apps/x/apps/renderer/src/hooks/useSessionChat.ts
new file mode 100644
index 00000000..6f8ee5ce
--- /dev/null
+++ b/apps/x/apps/renderer/src/hooks/useSessionChat.ts
@@ -0,0 +1,36 @@
+import { useEffect, useMemo, useState, useSyncExternalStore } from 'react'
+import { ipcSessionsClient } from '@/lib/session-chat/client'
+import { subscribeSessionFeed } from '@/lib/session-chat/feed'
+import { SessionChatStore, type SessionChatStoreDeps } from '@/lib/session-chat/store'
+
+const defaultDeps: SessionChatStoreDeps = {
+  client: ipcSessionsClient,
+  subscribeFeed: subscribeSessionFeed,
+}
+
+// Thin subscription over SessionChatStore — all logic (seeding, feed events,
+// reducer, overlay, action routing) lives in the store, which is unit-tested
+// without React. `deps` is injectable for tests.
+export function useSessionChat(
+  sessionId: string | null,
+  deps: SessionChatStoreDeps = defaultDeps,
+) {
+  const [store] = useState(() => new SessionChatStore(deps))
+  useEffect(() => store.connect(), [store])
+  useEffect(() => {
+    void store.setSession(sessionId)
+  }, [store, sessionId])
+  const snapshot = useSyncExternalStore(store.subscribe, store.getSnapshot)
+  return useMemo(
+    () => ({
+      ...snapshot,
+      sendMessage: store.sendMessage,
+      respondToPermission: store.respondToPermission,
+      answerAskHuman: store.answerAskHuman,
+      stop: store.stop,
+    }),
+    [snapshot, store],
+  )
+}
+
+export type SessionChat = ReturnType<typeof useSessionChat>
diff --git a/apps/x/apps/renderer/src/hooks/useSessions.ts b/apps/x/apps/renderer/src/hooks/useSessions.ts
new file mode 100644
index 00000000..9c4a7213
--- /dev/null
+++ b/apps/x/apps/renderer/src/hooks/useSessions.ts
@@ -0,0 +1,33 @@
+import { useEffect, useMemo, useState, useSyncExternalStore } from 'react'
+import { ipcSessionsClient } from '@/lib/session-chat/client'
+import { subscribeSessionFeed } from '@/lib/session-chat/feed'
+import { SessionListStore, type SessionChatStoreDeps } from '@/lib/session-chat/store'
+
+const defaultDeps: SessionChatStoreDeps = {
+  client: ipcSessionsClient,
+  subscribeFeed: subscribeSessionFeed,
+}
+
+// The session list (chat history sidebar): seeded from sessions:list, kept
+// current by index-changed feed events. Logic lives in SessionListStore.
+export function useSessions(deps: SessionChatStoreDeps = defaultDeps) {
+  const [store] = useState(() => new SessionListStore(deps))
+  useEffect(() => {
+    const disconnect = store.connect()
+    void store.load()
+    return disconnect
+  }, [store])
+  const snapshot = useSyncExternalStore(store.subscribe, store.getSnapshot)
+  const client = deps.client
+  return useMemo(
+    () => ({
+      ...snapshot,
+      createSession: (input: { title?: string } = {}) => client.create(input),
+      deleteSession: (sessionId: string) => client.delete(sessionId),
+      setTitle: (sessionId: string, title: string) => client.setTitle(sessionId, title),
+    }),
+    [snapshot, client],
+  )
+}
+
+export type Sessions = ReturnType<typeof useSessions>
diff --git a/apps/x/apps/renderer/src/hooks/useVideoMode.ts b/apps/x/apps/renderer/src/hooks/useVideoMode.ts
new file mode 100644
index 00000000..022131af
--- /dev/null
+++ b/apps/x/apps/renderer/src/hooks/useVideoMode.ts
@@ -0,0 +1,312 @@
+import { useCallback, useEffect, useRef, useState } from 'react';
+
+export type VideoModeState = 'idle' | 'starting' | 'live';
+export type ScreenShareState = 'idle' | 'starting' | 'live';
+
+export interface CapturedVideoFrame {
+    /** base64-encoded JPEG bytes (no data: prefix) — shape of the UserImagePart wire format */
+    data: string;
+    mediaType: string;
+    capturedAt: string; // ISO timestamp
+    /** data: URL of the same frame, for direct display in the transcript */
+    dataUrl: string;
+    source: 'camera' | 'screen';
+}
+
+// Frames are grabbed once per second — dense enough to catch expression and
+// posture changes while the user talks. Per message we attach at most
+// MAX_*_FRAMES_PER_MESSAGE frames, evenly sampled across the window since the
+// last send, so long monologues don't balloon the request.
+const CAPTURE_INTERVAL_MS = 1000;
+const MAX_CAMERA_FRAMES_PER_MESSAGE = 12;
+// Screen frames are ~4x the resolution (and tokens) of camera frames, and the
+// latest view matters far more than the trajectory — keep the cap small.
+const MAX_SCREEN_FRAMES_PER_MESSAGE = 4;
+// Rolling buffer bound (~2 minutes). The buffer only needs to cover the gap
+// between two sends; anything older is stale context anyway.
+const MAX_BUFFERED_FRAMES = 120;
+// Downscale targets. 512px wide JPEG keeps a webcam frame around 20-40KB —
+// cheap enough to inline a dozen per message as multimodal image parts.
+// Screen captures keep 1280px so on-screen text stays legible to the model.
+const CAMERA_FRAME_WIDTH = 512;
+const SCREEN_FRAME_WIDTH = 1280;
+const CAMERA_JPEG_QUALITY = 0.65;
+const SCREEN_JPEG_QUALITY = 0.7;
+
+interface BufferedFrame {
+    dataUrl: string;
+    capturedAt: string;
+    ts: number;
+}
+
+// One capture pipeline: stream → offscreen <video> → canvas JPEG → ring buffer.
+interface CapturePipe {
+    stream: MediaStream | null;
+    videoEl: HTMLVideoElement | null;
+    canvas: HTMLCanvasElement | null;
+    interval: ReturnType<typeof setInterval> | null;
+    frames: BufferedFrame[];
+    lastCollectTs: number;
+}
+
+const emptyPipe = (): CapturePipe => ({
+    stream: null,
+    videoEl: null,
+    canvas: null,
+    interval: null,
+    frames: [],
+    lastCollectTs: 0,
+});
+
+function capturePipeFrame(pipe: CapturePipe, width: number, quality: number) {
+    const videoEl = pipe.videoEl;
+    if (!videoEl || videoEl.readyState < 2 || videoEl.videoWidth === 0) return;
+    if (!pipe.canvas) {
+        pipe.canvas = document.createElement('canvas');
+    }
+    const canvas = pipe.canvas;
+    const scale = Math.min(1, width / videoEl.videoWidth);
+    canvas.width = Math.round(videoEl.videoWidth * scale);
+    canvas.height = Math.round(videoEl.videoHeight * scale);
+    const ctx = canvas.getContext('2d');
+    if (!ctx) return;
+    ctx.drawImage(videoEl, 0, 0, canvas.width, canvas.height);
+    const dataUrl = canvas.toDataURL('image/jpeg', quality);
+    // A near-empty data URL means the frame was blank (source still warming up)
+    if (dataUrl.length < 100) return;
+    pipe.frames.push({ dataUrl, capturedAt: new Date().toISOString(), ts: Date.now() });
+    if (pipe.frames.length > MAX_BUFFERED_FRAMES) {
+        pipe.frames.splice(0, pipe.frames.length - MAX_BUFFERED_FRAMES);
+    }
+}
+
+function attachPipeSource(pipe: CapturePipe, stream: MediaStream, grab: () => void) {
+    pipe.stream = stream;
+    // Offscreen <video> that feeds the capture canvas; any visible preview
+    // attaches to the same MediaStream separately.
+    const videoEl = document.createElement('video');
+    videoEl.muted = true;
+    videoEl.playsInline = true;
+    videoEl.srcObject = stream;
+    pipe.videoEl = videoEl;
+    videoEl.play().catch(() => {});
+    // First frame as soon as the source delivers data, then steady-state cadence.
+    videoEl.addEventListener('loadeddata', () => grab(), { once: true });
+    pipe.interval = setInterval(grab, CAPTURE_INTERVAL_MS);
+}
+
+function teardownPipe(pipe: CapturePipe) {
+    if (pipe.interval) {
+        clearInterval(pipe.interval);
+        pipe.interval = null;
+    }
+    if (pipe.videoEl) {
+        pipe.videoEl.srcObject = null;
+        pipe.videoEl = null;
+    }
+    if (pipe.stream) {
+        pipe.stream.getTracks().forEach((t) => t.stop());
+        pipe.stream = null;
+    }
+    pipe.frames = [];
+    pipe.lastCollectTs = 0;
+}
+
+/**
+ * Drain frames captured since the previous collection, evenly sampled down to
+ * `max` (always keeping the newest). Falls back to the single most recent
+ * frame when nothing new accumulated (rapid-fire messages), so every message
+ * carries at least one frame once the source has warmed up.
+ */
+function drainPipe(pipe: CapturePipe, max: number, source: CapturedVideoFrame['source']): CapturedVideoFrame[] {
+    const all = pipe.frames;
+    if (all.length === 0) return [];
+
+    let window_ = all.filter((f) => f.ts > pipe.lastCollectTs);
+    if (window_.length === 0) {
+        window_ = [all[all.length - 1]];
+    }
+    pipe.lastCollectTs = window_[window_.length - 1].ts;
+
+    let sampled: BufferedFrame[];
+    if (window_.length <= max) {
+        sampled = window_;
+    } else {
+        sampled = [];
+        const step = (window_.length - 1) / (max - 1);
+        for (let i = 0; i < max; i++) {
+            sampled.push(window_[Math.round(i * step)]);
+        }
+    }
+
+    return sampled.map((f) => ({
+        data: f.dataUrl.slice(f.dataUrl.indexOf(',') + 1),
+        mediaType: 'image/jpeg',
+        capturedAt: f.capturedAt,
+        dataUrl: f.dataUrl,
+        source,
+    }));
+}
+
+export function useVideoMode() {
+    const [state, setState] = useState<VideoModeState>('idle');
+    const [screenState, setScreenState] = useState<ScreenShareState>('idle');
+    // Camera can be turned off mid-session (Meet-style) while the mode — and
+    // any screen share — keeps running. Resets to on for the next session.
+    const [cameraOn, setCameraOn] = useState(true);
+    const cameraPipeRef = useRef<CapturePipe>(emptyPipe());
+    const screenPipeRef = useRef<CapturePipe>(emptyPipe());
+    // Stable stream refs for preview components (<video srcObject>).
+    const streamRef = useRef<MediaStream | null>(null);
+    const screenStreamRef = useRef<MediaStream | null>(null);
+    const stateRef = useRef<VideoModeState>('idle');
+    stateRef.current = state;
+    const screenStateRef = useRef<ScreenShareState>('idle');
+    screenStateRef.current = screenState;
+
+    const captureCameraFrame = useCallback(() => {
+        capturePipeFrame(cameraPipeRef.current, CAMERA_FRAME_WIDTH, CAMERA_JPEG_QUALITY);
+    }, []);
+
+    const captureScreenFrame = useCallback(() => {
+        capturePipeFrame(screenPipeRef.current, SCREEN_FRAME_WIDTH, SCREEN_JPEG_QUALITY);
+    }, []);
+
+    const stopScreenShare = useCallback(() => {
+        teardownPipe(screenPipeRef.current);
+        screenStreamRef.current = null;
+        setScreenState('idle');
+    }, []);
+
+    const stop = useCallback(() => {
+        teardownPipe(cameraPipeRef.current);
+        streamRef.current = null;
+        setState('idle');
+        setCameraOn(true);
+        stopScreenShare();
+    }, [stopScreenShare]);
+
+    // Acquire the webcam and start its capture pipeline. Shared by start()
+    // and by re-enabling the camera mid-session.
+    const acquireCamera = useCallback(async (): Promise<boolean> => {
+        // Settle the macOS TCC camera permission before getUserMedia, same as
+        // voice mode does for the mic — otherwise the first click silently
+        // fails while the native prompt is still up.
+        const access = await window.ipc
+            .invoke('voice:ensureCameraAccess', null)
+            .catch(() => ({ granted: true }));
+        if (!access.granted) {
+            console.error('[video] Camera access denied');
+            return false;
+        }
+
+        let stream: MediaStream | null = null;
+        try {
+            stream = await navigator.mediaDevices.getUserMedia({
+                video: { width: { ideal: 1280 }, height: { ideal: 720 }, facingMode: 'user' },
+                audio: false,
+            });
+        } catch (err) {
+            console.error('[video] Camera access failed:', err);
+            return false;
+        }
+
+        streamRef.current = stream;
+        attachPipeSource(cameraPipeRef.current, stream, captureCameraFrame);
+        return true;
+    }, [captureCameraFrame]);
+
+    /**
+     * Turn the camera off/on without leaving video mode (Meet-style). While
+     * off, no webcam frames are captured or attached; screen-share frames
+     * (if presenting) keep flowing.
+     */
+    const setCameraEnabled = useCallback(async (enabled: boolean): Promise<boolean> => {
+        if (stateRef.current !== 'live') return false;
+        if (enabled) {
+            const ok = await acquireCamera();
+            if (ok) setCameraOn(true);
+            return ok;
+        }
+        teardownPipe(cameraPipeRef.current);
+        streamRef.current = null;
+        setCameraOn(false);
+        return true;
+    }, [acquireCamera]);
+
+    /**
+     * Start video mode. `camera: false` starts a camera-less session (voice
+     * call / screen-share-only) — the mode is live so frames can flow from
+     * other sources, and the camera can be enabled later via setCameraEnabled.
+     */
+    const start = useCallback(async ({ camera = true }: { camera?: boolean } = {}): Promise<boolean> => {
+        if (stateRef.current !== 'idle') return true;
+        setState('starting');
+        if (camera) {
+            const ok = await acquireCamera();
+            if (!ok) {
+                setState('idle');
+                return false;
+            }
+        }
+        setCameraOn(camera);
+        setState('live');
+        return true;
+    }, [acquireCamera]);
+
+    /**
+     * Share the screen. The main process auto-approves getDisplayMedia with
+     * the primary screen (see setDisplayMediaRequestHandler in main.ts), so
+     * no source picker appears. Returns false if capture couldn't start
+     * (usually the macOS Screen Recording permission).
+     */
+    const startScreenShare = useCallback(async (): Promise<boolean> => {
+        if (screenStateRef.current !== 'idle') return true;
+        setScreenState('starting');
+
+        // Surfaces the macOS Screen Recording permission state and, on first
+        // use, registers the app in System Settings (same flow meetings use).
+        await window.ipc.invoke('meeting:checkScreenPermission', null).catch(() => null);
+
+        let stream: MediaStream | null = null;
+        try {
+            stream = await navigator.mediaDevices.getDisplayMedia({
+                video: { frameRate: { ideal: 5 } },
+                audio: false,
+            });
+        } catch (err) {
+            console.error('[video] Screen share failed:', err);
+            setScreenState('idle');
+            return false;
+        }
+
+        screenStreamRef.current = stream;
+        // The capture can end outside our UI (display unplugged, OS revokes) —
+        // tear down cleanly so the UI doesn't show a dead share.
+        stream.getVideoTracks()[0]?.addEventListener('ended', () => stopScreenShare(), { once: true });
+        attachPipeSource(screenPipeRef.current, stream, captureScreenFrame);
+        setScreenState('live');
+        return true;
+    }, [captureScreenFrame, stopScreenShare]);
+
+    /**
+     * Drain webcam + screen-share frames buffered since the last send, tagged
+     * by source. Webcam frames come first, then screen frames.
+     */
+    const collectFrames = useCallback((): CapturedVideoFrame[] => {
+        if (stateRef.current !== 'live') return [];
+        // Grab a frame right now so the message always includes the moment of send.
+        captureCameraFrame();
+        const frames = drainPipe(cameraPipeRef.current, MAX_CAMERA_FRAMES_PER_MESSAGE, 'camera');
+        if (screenStateRef.current === 'live') {
+            captureScreenFrame();
+            frames.push(...drainPipe(screenPipeRef.current, MAX_SCREEN_FRAMES_PER_MESSAGE, 'screen'));
+        }
+        return frames;
+    }, [captureCameraFrame, captureScreenFrame]);
+
+    // Release the camera/screen if the component unmounts with video mode on.
+    useEffect(() => stop, [stop]);
+
+    return { state, screenState, cameraOn, streamRef, screenStreamRef, start, stop, startScreenShare, stopScreenShare, setCameraEnabled, collectFrames };
+}
diff --git a/apps/x/apps/renderer/src/hooks/useVoiceMode.ts b/apps/x/apps/renderer/src/hooks/useVoiceMode.ts
index 8263e45d..d8c49098 100644
--- a/apps/x/apps/renderer/src/hooks/useVoiceMode.ts
+++ b/apps/x/apps/renderer/src/hooks/useVoiceMode.ts
@@ -1,10 +1,11 @@
 import { useCallback, useRef, useState } from 'react';
 import { buildDeepgramListenUrl } from '@/lib/deepgram-listen-url';
+import { finalizeDeepgramStream } from '@/lib/deepgram-finalize';
 import { useRowboatAccount } from '@/hooks/useRowboatAccount';
 import posthog from 'posthog-js';
 import * as analytics from '@/lib/analytics';
 
-export type VoiceState = 'idle' | 'connecting' | 'listening';
+export type VoiceState = 'idle' | 'connecting' | 'listening' | 'submitting';
 
 const DEEPGRAM_PARAMS = new URLSearchParams({
     model: 'nova-3',
@@ -18,7 +19,35 @@ const DEEPGRAM_PARAMS = new URLSearchParams({
     endpointing: '100',
     no_delay: 'true',
 });
-const DEEPGRAM_LISTEN_URL = `wss://api.deepgram.com/v1/listen?${DEEPGRAM_PARAMS.toString()}`;
+// Hands-free (continuous) mode: Deepgram's endpoint fires FAST (600ms of
+// silence) and we apply smart hold logic on our side — if the transcript
+// already reads as a complete thought (terminal punctuation) the utterance
+// fires immediately, otherwise we hold INCOMPLETE_HOLD_MS longer in case the
+// user was mid-thought. Net effect: complete sentences turn around ~1.2s
+// faster than the old fixed 1800ms endpoint, while thinking pauses still get
+// the same total grace (~1.8s).
+const CONTINUOUS_ENDPOINTING_MS = 600;
+const INCOMPLETE_HOLD_MS = 1200;
+// While the mic is paused (assistant speaking), keep the idle Deepgram socket
+// alive — it closes after ~10s without audio otherwise.
+const KEEPALIVE_INTERVAL_MS = 5000;
+
+// Deepgram punctuates finals (punctuate=true) — a transcript ending in
+// terminal punctuation (optionally inside a closing quote/paren) is treated
+// as a complete thought.
+const COMPLETE_THOUGHT_RE = /[.!?…]["')\]]*\s*$/;
+
+function deepgramParams(continuous: boolean): URLSearchParams {
+    if (!continuous) return DEEPGRAM_PARAMS;
+    const params = new URLSearchParams(DEEPGRAM_PARAMS);
+    params.set('endpointing', String(CONTINUOUS_ENDPOINTING_MS));
+    // Second end-of-speech signal: speech_final can be missed (it often rides
+    // on a result with an empty transcript, or never fires when background
+    // noise keeps the endpointer engaged). UtteranceEnd is word-timing based
+    // and arrives as its own message type, so we listen for both.
+    params.set('utterance_end_ms', '1000');
+    return params;
+}
 
 // Cap on retained per-frame amplitude samples (~64ms/frame ⇒ ~5 min of history).
 // The waveform only ever displays the most recent window, so older samples are dropped.
@@ -52,6 +81,13 @@ export function useVoiceMode() {
     const audioLevelsRef = useRef<number[]>([]);
     // Running peak amplitude for the waveform auto-gain (see PEAK_DECAY/MIN_PEAK).
     const audioPeakRef = useRef(0);
+    // Hands-free mode: invoked with each completed utterance (speech_final).
+    const continuousCbRef = useRef<((text: string) => void) | null>(null);
+    // While true (assistant is speaking), mic audio is dropped instead of streamed.
+    const pausedRef = useRef(false);
+    const keepAliveTimerRef = useRef<ReturnType<typeof setInterval> | null>(null);
+    // Pending mid-thought hold (smart endpointing) — see maybeEndUtterance.
+    const holdTimerRef = useRef<ReturnType<typeof setTimeout> | null>(null);
 
     // Refresh cached auth details (called on warmup, not on mic click)
     const refreshAuth = useCallback(async () => {
@@ -70,9 +106,44 @@ export function useVoiceMode() {
         }
     }, [refreshRowboatAccount]);
 
+    // Hands-free mode: flush the accumulated utterance to the callback.
+    // Both end-of-speech signals may fire for the same utterance — the second
+    // finds an empty buffer and is a no-op.
+    const fireContinuousUtterance = useCallback(() => {
+        if (holdTimerRef.current) {
+            clearTimeout(holdTimerRef.current);
+            holdTimerRef.current = null;
+        }
+        if (!continuousCbRef.current || pausedRef.current) return;
+        const utterance = transcriptBufferRef.current.trim();
+        transcriptBufferRef.current = '';
+        interimRef.current = '';
+        setInterimText('');
+        if (utterance) continuousCbRef.current(utterance);
+    }, []);
+
+    // Smart endpoint: Deepgram's endpoint fires fast (600ms). If the
+    // transcript reads as a complete thought, hand it off immediately; if it
+    // trails off mid-sentence ("so what I want is…"), hold a little longer —
+    // resumed speech cancels the hold and the utterance keeps growing.
+    const maybeEndUtterance = useCallback(() => {
+        if (!continuousCbRef.current || pausedRef.current) return;
+        const buffered = transcriptBufferRef.current.trim();
+        if (!buffered) return;
+        if (COMPLETE_THOUGHT_RE.test(buffered)) {
+            fireContinuousUtterance();
+            return;
+        }
+        if (holdTimerRef.current) clearTimeout(holdTimerRef.current);
+        holdTimerRef.current = setTimeout(() => {
+            holdTimerRef.current = null;
+            fireContinuousUtterance();
+        }, INCOMPLETE_HOLD_MS);
+    }, [fireContinuousUtterance]);
+
     // Create and connect a Deepgram WebSocket using cached auth.
     // Starts the connection and returns immediately (does not wait for open).
-    const connectWs = useCallback(async () => {
+    const connectWs = useCallback(async (continuous = false) => {
         if (wsRef.current && (wsRef.current.readyState === WebSocket.OPEN || wsRef.current.readyState === WebSocket.CONNECTING)) return;
 
         // Refresh auth if we don't have it cached yet
@@ -81,12 +152,13 @@ export function useVoiceMode() {
         }
         if (!cachedAuth) return;
 
+        const params = deepgramParams(continuous);
         let ws: WebSocket;
         if (cachedAuth.type === 'rowboat') {
-            const listenUrl = buildDeepgramListenUrl(cachedAuth.url, DEEPGRAM_PARAMS);
+            const listenUrl = buildDeepgramListenUrl(cachedAuth.url, params);
             ws = new WebSocket(listenUrl, ['bearer', cachedAuth.token]);
         } else {
-            ws = new WebSocket(DEEPGRAM_LISTEN_URL, ['token', cachedAuth.apiKey]);
+            ws = new WebSocket(`wss://api.deepgram.com/v1/listen?${params.toString()}`, ['token', cachedAuth.apiKey]);
         }
         wsRef.current = ws;
 
@@ -102,16 +174,43 @@ export function useVoiceMode() {
 
         ws.onmessage = (event) => {
             const data = JSON.parse(event.data);
-            if (!data.channel?.alternatives?.[0]) return;
 
+            // Hands-free mode: word-timing based end-of-speech marker.
+            if (data.type === 'UtteranceEnd') {
+                maybeEndUtterance();
+                return;
+            }
+
+            if (!data.channel?.alternatives?.[0]) return;
             const transcript = data.channel.alternatives[0].transcript;
-            if (!transcript) return;
+
+            // The user resumed speaking — cancel any pending mid-thought hold
+            // so the utterance keeps growing instead of firing under them.
+            if (transcript && holdTimerRef.current) {
+                clearTimeout(holdTimerRef.current);
+                holdTimerRef.current = null;
+            }
 
             if (data.is_final) {
-                transcriptBufferRef.current += (transcriptBufferRef.current ? ' ' : '') + transcript;
-                interimRef.current = '';
-                setInterimText(transcriptBufferRef.current);
-            } else {
+                // NOTE: the endpoint marker (speech_final) usually arrives on a
+                // result whose transcript is EMPTY — the silence after the user
+                // stops talking. Empty finals must still reach the speech_final
+                // check below or hands-free utterances never complete.
+                if (transcript) {
+                    transcriptBufferRef.current += (transcriptBufferRef.current ? ' ' : '') + transcript;
+                    interimRef.current = '';
+                }
+                // Hands-free mode: an endpoint may complete the utterance —
+                // immediately for complete thoughts, after a short hold for
+                // mid-sentence trails.
+                if (continuousCbRef.current && data.speech_final) {
+                    maybeEndUtterance();
+                    return;
+                }
+                if (transcript) {
+                    setInterimText(transcriptBufferRef.current);
+                }
+            } else if (transcript) {
                 interimRef.current = transcript;
                 setInterimText(transcriptBufferRef.current + (transcriptBufferRef.current ? ' ' : '') + transcript);
             }
@@ -126,11 +225,57 @@ export function useVoiceMode() {
         ws.onclose = () => {
             console.log('[voice] WebSocket closed');
             wsRef.current = null;
+            // A hands-free call is long-lived — if the socket drops while the
+            // call is still on, reconnect instead of silently going deaf.
+            if (continuousCbRef.current) {
+                setTimeout(() => {
+                    if (continuousCbRef.current && !wsRef.current) {
+                        void connectWs(true);
+                    }
+                }, 1000);
+            }
         };
-    }, [refreshAuth]);
+    }, [refreshAuth, maybeEndUtterance]);
 
-    // Stop audio capture and close WS
-    const stopAudioCapture = useCallback(() => {
+    const waitForWsOpen = useCallback(async (timeoutMs = 1500): Promise<boolean> => {
+        const ws = wsRef.current;
+        if (!ws) return false;
+        if (ws.readyState === WebSocket.OPEN) return true;
+        if (ws.readyState !== WebSocket.CONNECTING) return false;
+
+        return new Promise<boolean>((resolve) => {
+            let done = false;
+            let timeout: ReturnType<typeof setTimeout>;
+            const finish = (ok: boolean) => {
+                if (done) return;
+                done = true;
+                clearTimeout(timeout);
+                ws.removeEventListener('open', onOpen);
+                ws.removeEventListener('error', onError);
+                ws.removeEventListener('close', onClose);
+                resolve(ok);
+            };
+            const onOpen = () => finish(true);
+            const onError = () => finish(false);
+            const onClose = () => finish(false);
+            timeout = setTimeout(() => finish(false), timeoutMs);
+            ws.addEventListener('open', onOpen);
+            ws.addEventListener('error', onError);
+            ws.addEventListener('close', onClose);
+        });
+    }, []);
+
+    const flushBufferedAudio = useCallback(() => {
+        const ws = wsRef.current;
+        if (!ws || ws.readyState !== WebSocket.OPEN) return;
+        const buffered = audioBufferRef.current;
+        audioBufferRef.current = [];
+        for (const chunk of buffered) {
+            ws.send(chunk);
+        }
+    }, []);
+
+    const stopInputCapture = useCallback(() => {
         if (processorRef.current) {
             processorRef.current.disconnect();
             processorRef.current = null;
@@ -143,11 +288,26 @@ export function useVoiceMode() {
             mediaStreamRef.current.getTracks().forEach(t => t.stop());
             mediaStreamRef.current = null;
         }
+    }, []);
+
+    // Stop audio capture and close WS
+    const stopAudioCapture = useCallback(() => {
+        stopInputCapture();
         if (wsRef.current) {
             wsRef.current.onclose = null;
             wsRef.current.close();
             wsRef.current = null;
         }
+        continuousCbRef.current = null;
+        pausedRef.current = false;
+        if (holdTimerRef.current) {
+            clearTimeout(holdTimerRef.current);
+            holdTimerRef.current = null;
+        }
+        if (keepAliveTimerRef.current) {
+            clearInterval(keepAliveTimerRef.current);
+            keepAliveTimerRef.current = null;
+        }
         audioBufferRef.current = [];
         audioLevelsRef.current = [];
         audioPeakRef.current = 0;
@@ -155,9 +315,9 @@ export function useVoiceMode() {
         transcriptBufferRef.current = '';
         interimRef.current = '';
         setState('idle');
-    }, []);
+    }, [stopInputCapture]);
 
-    const start = useCallback(async () => {
+    const start = useCallback(async (continuous = false) => {
         if (state !== 'idle') return;
 
         transcriptBufferRef.current = '';
@@ -192,7 +352,7 @@ export function useVoiceMode() {
                 console.error('Microphone access denied:', err);
                 return null;
             }),
-            connectWs(),
+            connectWs(continuous),
         ]);
 
         if (!stream) {
@@ -216,6 +376,9 @@ export function useVoiceMode() {
         processorRef.current = processor;
 
         processor.onaudioprocess = (e) => {
+            // Paused (assistant is speaking in a call): drop mic audio so the
+            // assistant's own TTS never gets transcribed back at it.
+            if (pausedRef.current) return;
             const float32 = e.inputBuffer.getChannelData(0);
             const int16 = new Int16Array(float32.length);
             let sumSquares = 0;
@@ -240,8 +403,13 @@ export function useVoiceMode() {
             if (wsRef.current?.readyState === WebSocket.OPEN) {
                 wsRef.current.send(buffer);
             } else {
-                // WebSocket still connecting — buffer the audio
+                // WebSocket still connecting (or reconnecting mid-call) —
+                // buffer the audio, bounded so an unreachable server during a
+                // long call can't grow it without limit (~30s at 64ms/chunk).
                 audioBufferRef.current.push(buffer);
+                if (audioBufferRef.current.length > 500) {
+                    audioBufferRef.current.shift();
+                }
             }
         };
 
@@ -250,25 +418,71 @@ export function useVoiceMode() {
     }, [state, connectWs, stopAudioCapture]);
 
     /** Stop recording and return the full transcript (finalized + any current interim) */
-    const submit = useCallback((): string => {
+    const submit = useCallback(async (): Promise<string> => {
+        setState('submitting');
+        stopInputCapture();
+
+        if (wsRef.current?.readyState === WebSocket.CONNECTING) {
+            await waitForWsOpen();
+        }
+        flushBufferedAudio();
+        await finalizeDeepgramStream(wsRef.current);
+
         let text = transcriptBufferRef.current;
         if (interimRef.current) {
             text += (text ? ' ' : '') + interimRef.current;
         }
         text = text.trim();
+
         stopAudioCapture();
         return text;
-    }, [stopAudioCapture]);
+    }, [flushBufferedAudio, stopAudioCapture, stopInputCapture, waitForWsOpen]);
 
     /** Cancel recording without returning transcript */
     const cancel = useCallback(() => {
         stopAudioCapture();
     }, [stopAudioCapture]);
 
+    /**
+     * Hands-free (call) mode: listen continuously and invoke `onUtterance`
+     * with each completed utterance. Runs until cancel()/stop.
+     */
+    const startContinuous = useCallback(async (onUtterance: (text: string) => void) => {
+        continuousCbRef.current = onUtterance;
+        await start(true);
+    }, [start]);
+
+    /**
+     * Mute/unmute the continuous stream (used while the assistant is
+     * thinking/speaking). Keeps the Deepgram socket alive with KeepAlives and
+     * discards any half-heard utterance from before the pause.
+     */
+    const setPaused = useCallback((paused: boolean) => {
+        if (pausedRef.current === paused) return;
+        pausedRef.current = paused;
+        if (paused) {
+            if (holdTimerRef.current) {
+                clearTimeout(holdTimerRef.current);
+                holdTimerRef.current = null;
+            }
+            transcriptBufferRef.current = '';
+            interimRef.current = '';
+            setInterimText('');
+            keepAliveTimerRef.current = setInterval(() => {
+                if (wsRef.current?.readyState === WebSocket.OPEN) {
+                    wsRef.current.send(JSON.stringify({ type: 'KeepAlive' }));
+                }
+            }, KEEPALIVE_INTERVAL_MS);
+        } else if (keepAliveTimerRef.current) {
+            clearInterval(keepAliveTimerRef.current);
+            keepAliveTimerRef.current = null;
+        }
+    }, []);
+
     /** Pre-cache auth details so mic click skips IPC round-trips */
     const warmup = useCallback(() => {
         refreshAuth().catch(() => {});
     }, [refreshAuth]);
 
-    return { state, interimText, audioLevelsRef, start, submit, cancel, warmup };
+    return { state, interimText, audioLevelsRef, start, submit, cancel, warmup, startContinuous, setPaused };
 }
diff --git a/apps/x/apps/renderer/src/hooks/useVoiceTTS.ts b/apps/x/apps/renderer/src/hooks/useVoiceTTS.ts
index c0737bf8..bfdcc4ae 100644
--- a/apps/x/apps/renderer/src/hooks/useVoiceTTS.ts
+++ b/apps/x/apps/renderer/src/hooks/useVoiceTTS.ts
@@ -1,4 +1,4 @@
-import { useCallback, useRef, useState } from 'react';
+import { useCallback, useEffect, useRef, useState } from 'react';
 
 export type TTSState = 'idle' | 'synthesizing' | 'speaking';
 
@@ -14,14 +14,23 @@ function synthesize(text: string): Promise<SynthesizedAudio> {
     );
 }
 
-function playAudio(dataUrl: string, audioRef: React.MutableRefObject<HTMLAudioElement | null>): Promise<void> {
+function playAudio(
+    dataUrl: string,
+    audioRef: React.MutableRefObject<HTMLAudioElement | null>,
+    onAudioElement?: (audio: HTMLAudioElement) => void
+): Promise<void> {
     return new Promise<void>((resolve, reject) => {
         const audio = new Audio(dataUrl);
         audioRef.current = audio;
+        onAudioElement?.(audio);
         audio.onended = () => {
             console.log('[tts] audio ended');
             resolve();
         };
+        // pause() (from cancel) must settle this promise too, or the queue
+        // loop stays parked on it forever. Natural end also fires 'pause'
+        // just before 'ended'; double-resolve is harmless.
+        audio.onpause = () => resolve();
         audio.onerror = (e) => {
             console.error('[tts] audio error:', e);
             reject(new Error('Audio playback failed'));
@@ -35,47 +44,282 @@ function playAudio(dataUrl: string, audioRef: React.MutableRefObject<HTMLAudioEl
     });
 }
 
+/** A queue entry: text to synthesize, or a ready-to-play audio URL (e.g. a bundled clip). */
+type QueueItem = { text: string } | { url: string };
+
+type TtsChunkMsg = { requestId: string; chunkBase64?: string; done: boolean; error?: string };
+
 export function useVoiceTTS() {
     const [state, setState] = useState<TTSState>('idle');
     const audioRef = useRef<HTMLAudioElement | null>(null);
-    const queueRef = useRef<string[]>([]);
+    const queueRef = useRef<QueueItem[]>([]);
     const processingRef = useRef(false);
     // Pre-fetched audio ready to play immediately
     const prefetchedRef = useRef<Promise<SynthesizedAudio> | null>(null);
+    // Streaming synthesis: per-request chunk handlers + the in-flight request
+    // id (so cancel() can abort the main-process fetch).
+    const streamHandlersRef = useRef<Map<string, (msg: TtsChunkMsg) => void>>(new Map());
+    const activeStreamIdRef = useRef<string | null>(null);
+    // Bumped by cancel(). A queue loop that awaited across a cancel sees a
+    // stale generation and exits instead of playing audio that was cancelled
+    // while still synthesizing (which would overlap the next utterance).
+    const generationRef = useRef(0);
+    // Web Audio analyser tap for lip-sync (talking head)
+    const audioCtxRef = useRef<AudioContext | null>(null);
+    const analyserRef = useRef<AnalyserNode | null>(null);
+    const levelBufferRef = useRef<Uint8Array<ArrayBuffer> | null>(null);
+
+    // Route playback through an AnalyserNode so consumers can read the live
+    // output level. If Web Audio wiring fails, the element still plays directly.
+    const connectAnalyser = useCallback((audio: HTMLAudioElement) => {
+        try {
+            let ctx = audioCtxRef.current;
+            if (!ctx) {
+                ctx = new AudioContext();
+                audioCtxRef.current = ctx;
+                const analyser = ctx.createAnalyser();
+                analyser.fftSize = 512;
+                analyser.smoothingTimeConstant = 0.5;
+                analyser.connect(ctx.destination);
+                analyserRef.current = analyser;
+            }
+            if (ctx.state === 'suspended') {
+                void ctx.resume();
+            }
+            const source = ctx.createMediaElementSource(audio);
+            source.connect(analyserRef.current!);
+            // Detach once this chunk is done (ended, cancelled via pause, or
+            // failed) so source nodes don't accumulate over a long session.
+            const disconnect = () => {
+                try {
+                    source.disconnect();
+                } catch {
+                    // already disconnected
+                }
+            };
+            audio.addEventListener('ended', disconnect, { once: true });
+            audio.addEventListener('pause', disconnect, { once: true });
+            audio.addEventListener('error', disconnect, { once: true });
+        } catch (err) {
+            console.error('[tts] analyser hookup failed:', err);
+        }
+    }, []);
+
+    // Current output level, 0..1. Safe to call every animation frame.
+    // Release the audio graph when the owning component unmounts
+    useEffect(() => () => {
+        audioCtxRef.current?.close().catch(() => {});
+        audioCtxRef.current = null;
+        analyserRef.current = null;
+    }, []);
+
+    // Route streaming TTS chunks to whichever request is waiting for them.
+    useEffect(() => {
+        return window.ipc.on('voice:tts-chunk', (msg) => {
+            streamHandlersRef.current.get(msg.requestId)?.(msg);
+        });
+    }, []);
+
+    /**
+     * Streaming synthesis + playback via MediaSource: audio starts on the
+     * first chunk instead of after the full body. Rejects (for caller
+     * fallback to non-streaming synth) if the stream fails before any audio
+     * arrived; resolves when playback finishes.
+     */
+    const streamSynthesizeAndPlay = useCallback((text: string, onStarted: () => void): Promise<void> => {
+        return new Promise<void>((resolve, reject) => {
+            if (typeof MediaSource === 'undefined' || !MediaSource.isTypeSupported('audio/mpeg')) {
+                reject(new Error('MSE audio/mpeg unsupported'));
+                return;
+            }
+            const requestId = `tts-${Date.now()}-${Math.random().toString(36).slice(2, 10)}`;
+            const mediaSource = new MediaSource();
+            const audio = new Audio();
+            audio.src = URL.createObjectURL(mediaSource);
+            audioRef.current = audio;
+            connectAnalyser(audio);
+            activeStreamIdRef.current = requestId;
+
+            let sourceBuffer: SourceBuffer | null = null;
+            const pending: Uint8Array[] = [];
+            let streamDone = false;
+            let gotAudio = false;
+            let settled = false;
+
+            const cleanup = () => {
+                streamHandlersRef.current.delete(requestId);
+                if (activeStreamIdRef.current === requestId) activeStreamIdRef.current = null;
+                URL.revokeObjectURL(audio.src);
+            };
+            const finish = (err?: Error) => {
+                if (settled) return;
+                settled = true;
+                cleanup();
+                if (err) reject(err);
+                else resolve();
+            };
+
+            // Drain pending chunks into the SourceBuffer one at a time
+            // (appendBuffer is async; only one append may be in flight).
+            const pump = () => {
+                if (!sourceBuffer || sourceBuffer.updating || settled) return;
+                const chunk = pending.shift();
+                if (chunk) {
+                    try {
+                        sourceBuffer.appendBuffer(chunk as BufferSource);
+                    } catch (e) {
+                        finish(e as Error);
+                    }
+                    return;
+                }
+                if (streamDone && mediaSource.readyState === 'open') {
+                    try {
+                        mediaSource.endOfStream();
+                    } catch { /* already ended */ }
+                }
+            };
+
+            mediaSource.addEventListener('sourceopen', () => {
+                try {
+                    sourceBuffer = mediaSource.addSourceBuffer('audio/mpeg');
+                } catch (e) {
+                    finish(e as Error);
+                    return;
+                }
+                sourceBuffer.addEventListener('updateend', pump);
+                pump();
+            }, { once: true });
+
+            streamHandlersRef.current.set(requestId, (msg) => {
+                if (msg.error && !gotAudio) {
+                    streamDone = true;
+                    finish(new Error(msg.error));
+                    return;
+                }
+                if (msg.chunkBase64) {
+                    gotAudio = true;
+                    const bin = atob(msg.chunkBase64);
+                    const bytes = new Uint8Array(bin.length);
+                    for (let i = 0; i < bin.length; i++) bytes[i] = bin.charCodeAt(i);
+                    pending.push(bytes);
+                    pump();
+                }
+                if (msg.done) {
+                    streamDone = true;
+                    pump();
+                }
+            });
+
+            audio.addEventListener('playing', () => onStarted(), { once: true });
+            audio.onended = () => finish();
+            // pause() (from cancel) must settle this promise too; natural end
+            // also fires 'pause' just before 'ended'; double-settle is a no-op.
+            audio.onpause = () => finish();
+            audio.onerror = () => finish(new Error('stream playback failed'));
+
+            window.ipc
+                .invoke('voice:synthesizeStreamStart', { requestId, text })
+                .then((res) => {
+                    if (!res.ok) finish(new Error(res.error || 'stream start failed'));
+                })
+                .catch((e) => finish(e as Error));
+
+            // Starts as soon as the first appended data is decodable.
+            audio.play().catch(() => { /* surfaced via onerror / chunk error */ });
+
+            // Nothing arrived at all — bail so the caller can fall back.
+            setTimeout(() => {
+                if (!gotAudio && !settled) finish(new Error('stream timeout'));
+            }, 10_000);
+        });
+    }, [connectAnalyser]);
+
+    const getLevel = useCallback((): number => {
+        const analyser = analyserRef.current;
+        if (!analyser) return 0;
+        let buffer = levelBufferRef.current;
+        if (!buffer || buffer.length !== analyser.fftSize) {
+            buffer = new Uint8Array(analyser.fftSize);
+            levelBufferRef.current = buffer;
+        }
+        analyser.getByteTimeDomainData(buffer);
+        let sum = 0;
+        for (let i = 0; i < buffer.length; i++) {
+            const d = (buffer[i] - 128) / 128;
+            sum += d * d;
+        }
+        const rms = Math.sqrt(sum / buffer.length);
+        return Math.min(1, rms * 4);
+    }, []);
 
     const processQueue = useCallback(async () => {
         if (processingRef.current) return;
         processingRef.current = true;
+        const gen = generationRef.current;
+
+        // Kick off full-body pre-fetch for the next queued text while the
+        // current one plays — keeps sentence-to-sentence playback gapless.
+        const prefetchNext = () => {
+            const next = queueRef.current[0];
+            if (next && 'text' in next && next.text.trim() && !prefetchedRef.current) {
+                console.log('[tts] pre-fetching next:', next.text.substring(0, 80));
+                prefetchedRef.current = synthesize(next.text);
+            }
+        };
 
         while (queueRef.current.length > 0) {
-            const text = queueRef.current.shift()!;
-            if (!text.trim()) continue;
+            const item = queueRef.current.shift()!;
+            if ('text' in item && !item.text.trim()) continue;
+
+            // Cold start (nothing playing, nothing pre-fetched): stream the
+            // synthesis so audio begins on the first chunk instead of after
+            // the full body — this is where first-response latency lives.
+            if ('text' in item && !prefetchedRef.current) {
+                setState('synthesizing');
+                console.log('[tts] stream-synthesizing:', item.text.substring(0, 80));
+                try {
+                    await streamSynthesizeAndPlay(item.text, () => {
+                        if (generationRef.current !== gen) return;
+                        setState('speaking');
+                        prefetchNext();
+                    });
+                    if (generationRef.current !== gen) return;
+                    continue;
+                } catch (err) {
+                    if (generationRef.current !== gen) return;
+                    console.error('[tts] stream failed, falling back to full synth:', err);
+                    // fall through to the non-streaming path below
+                }
+            }
 
             try {
-                // Use pre-fetched result if available, otherwise synthesize now
+                // Pre-recorded URL plays as-is; text uses the pre-fetched
+                // result if available, otherwise synthesizes now.
                 let audioPromise: Promise<SynthesizedAudio>;
-                if (prefetchedRef.current) {
+                if ('url' in item) {
+                    audioPromise = Promise.resolve({ dataUrl: item.url });
+                } else if (prefetchedRef.current) {
                     console.log('[tts] using pre-fetched audio');
                     audioPromise = prefetchedRef.current;
                     prefetchedRef.current = null;
                 } else {
                     setState('synthesizing');
-                    console.log('[tts] synthesizing:', text.substring(0, 80));
-                    audioPromise = synthesize(text);
+                    console.log('[tts] synthesizing:', item.text.substring(0, 80));
+                    audioPromise = synthesize(item.text);
                 }
 
                 const audio = await audioPromise;
+                // Cancelled while synthesizing — cancel() already reset all
+                // state (and a new loop may be running), so just bail.
+                if (generationRef.current !== gen) return;
                 setState('speaking');
 
-                // Kick off pre-fetch for next chunk while this one plays
-                const nextText = queueRef.current[0];
-                if (nextText?.trim()) {
-                    console.log('[tts] pre-fetching next:', nextText.substring(0, 80));
-                    prefetchedRef.current = synthesize(nextText);
-                }
+                prefetchNext();
 
-                await playAudio(audio.dataUrl, audioRef);
+                await playAudio(audio.dataUrl, audioRef, connectAnalyser);
+                if (generationRef.current !== gen) return;
             } catch (err) {
+                if (generationRef.current !== gen) return;
                 console.error('[tts] error:', err);
                 prefetchedRef.current = null;
             }
@@ -85,17 +329,33 @@ export function useVoiceTTS() {
         prefetchedRef.current = null;
         processingRef.current = false;
         setState('idle');
-    }, []);
+    }, [connectAnalyser, streamSynthesizeAndPlay]);
 
     const speak = useCallback((text: string) => {
         console.log('[tts] speak() called:', text.substring(0, 80));
-        queueRef.current.push(text);
+        queueRef.current.push({ text });
+        processQueue();
+    }, [processQueue]);
+
+    // Play a pre-recorded clip (e.g. bundled tour narration) through the same
+    // queue, so lip-sync levels, state, and cancel() all work unchanged.
+    const speakUrl = useCallback((url: string) => {
+        console.log('[tts] speakUrl() called:', url.substring(0, 120));
+        queueRef.current.push({ url });
         processQueue();
     }, [processQueue]);
 
     const cancel = useCallback(() => {
+        generationRef.current++;
         queueRef.current = [];
         prefetchedRef.current = null;
+        // Abort any in-flight streaming synthesis in the main process.
+        if (activeStreamIdRef.current) {
+            void window.ipc
+                .invoke('voice:synthesizeStreamCancel', { requestId: activeStreamIdRef.current })
+                .catch(() => {});
+            activeStreamIdRef.current = null;
+        }
         if (audioRef.current) {
             audioRef.current.pause();
             audioRef.current = null;
@@ -104,5 +364,5 @@ export function useVoiceTTS() {
         setState('idle');
     }, []);
 
-    return { state, speak, cancel };
+    return { state, speak, speakUrl, cancel, getLevel };
 }
diff --git a/apps/x/apps/renderer/src/lib/agent-transcript.test.ts b/apps/x/apps/renderer/src/lib/agent-transcript.test.ts
new file mode 100644
index 00000000..311309f3
--- /dev/null
+++ b/apps/x/apps/renderer/src/lib/agent-transcript.test.ts
@@ -0,0 +1,28 @@
+import { describe, expect, it } from 'vitest'
+import { turnToTranscript } from './agent-transcript'
+import { completedTurnLog, created, requested, user } from './session-chat/test-fixtures'
+
+describe('turnToTranscript', () => {
+  it('maps a completed turn to id/createdAt/summary/items', () => {
+    const events = completedTurnLog('turn-1', 'sess-1', 'do the thing', 'all done')
+    const t = turnToTranscript('turn-1', events)
+    expect(t.id).toBe('turn-1')
+    expect(t.createdAt).toBeDefined()
+    expect(t.summary).toBe('all done')
+    expect(t.error).toBeUndefined()
+    expect(t.trigger).toBeUndefined()
+    expect(t.items.length).toBeGreaterThan(0)
+  })
+
+  it('surfaces turn_failed as error with no summary', () => {
+    const events = [
+      created('turn-2', 'sess-1', user('go')),
+      requested('turn-2', 0),
+      { type: 'model_call_failed' as const, turnId: 'turn-2', ts: '2026-07-02T10:00:00Z', modelCallIndex: 0, error: 'boom' },
+      { type: 'turn_failed' as const, turnId: 'turn-2', ts: '2026-07-02T10:00:00Z', error: 'boom', usage: {} },
+    ]
+    const t = turnToTranscript('turn-2', events)
+    expect(t.error).toBe('boom')
+    expect(t.summary).toBeUndefined()
+  })
+})
diff --git a/apps/x/apps/renderer/src/lib/agent-transcript.ts b/apps/x/apps/renderer/src/lib/agent-transcript.ts
new file mode 100644
index 00000000..71c4f75e
--- /dev/null
+++ b/apps/x/apps/renderer/src/lib/agent-transcript.ts
@@ -0,0 +1,89 @@
+import type { z } from 'zod'
+import type { Run } from '@x/shared/src/runs.js'
+import { reduceTurn, type TurnEvent } from '@x/shared/src/turns.js'
+import type { ConversationItem } from '@/lib/chat-conversation'
+import { runLogToConversation } from '@/lib/run-to-conversation'
+import { buildTurnConversation } from '@/lib/session-chat/turn-view'
+
+// Unified read model for a headless agent run's transcript, whether the id
+// is a turn (new runtime) or a legacy run (pre-turn-runtime files under
+// $WorkDir/runs/). Used by the background-tasks and live-note history views.
+
+export interface AgentRunTranscript {
+  id: string
+  createdAt?: string
+  // Legacy runs only (subUseCase); turns carry the trigger inside the
+  // message text instead.
+  trigger?: string
+  summary?: string
+  error?: string
+  items: ConversationItem[]
+}
+
+export function turnToTranscript(
+  turnId: string,
+  events: Array<z.infer<typeof TurnEvent>>,
+): AgentRunTranscript {
+  const state = reduceTurn(events)
+  const out: AgentRunTranscript = {
+    id: turnId,
+    createdAt: state.definition.ts,
+    items: buildTurnConversation(state),
+  }
+  if (state.terminal?.type === 'turn_failed') {
+    out.error = state.terminal.error
+  }
+  for (let i = state.modelCalls.length - 1; i >= 0; i--) {
+    const response = state.modelCalls[i].response
+    if (!response) continue
+    const content = response.content
+    const text =
+      typeof content === 'string'
+        ? content
+        : content.map((p) => (p.type === 'text' ? p.text : '')).join('')
+    if (text) {
+      out.summary = text
+      break
+    }
+  }
+  return out
+}
+
+export function runToTranscript(run: z.infer<typeof Run>): AgentRunTranscript {
+  const out: AgentRunTranscript = {
+    id: run.id,
+    createdAt: run.createdAt,
+    trigger: run.subUseCase,
+    items: runLogToConversation(run.log),
+  }
+  for (const event of run.log) {
+    if (event.type === 'error' && typeof event.error === 'string') {
+      out.error = event.error
+    } else if (event.type === 'message' && event.message?.role === 'assistant') {
+      const content = event.message.content
+      if (typeof content === 'string') {
+        out.summary = content
+      } else if (Array.isArray(content)) {
+        const text = content
+          .filter((p) => p.type === 'text')
+          .map((p) => ('text' in p ? p.text : ''))
+          .join('')
+        if (text) out.summary = text
+      }
+    }
+  }
+  return out
+}
+
+// Turn-first with a legacy-run fallback so histories recorded before the
+// turn-runtime migration stay readable. The fallback goes away with the
+// runs runtime (stage 7).
+export async function fetchAgentRunTranscript(id: string): Promise<AgentRunTranscript> {
+  try {
+    const turn = await window.ipc.invoke('sessions:getTurn', { turnId: id })
+    return turnToTranscript(id, turn.events)
+  } catch {
+    const run = await window.ipc.invoke('runs:fetch', { runId: id })
+    return runToTranscript(run)
+  }
+}
diff --git a/apps/x/apps/renderer/src/lib/analytics.ts b/apps/x/apps/renderer/src/lib/analytics.ts
index 219baae4..131d1477 100644
--- a/apps/x/apps/renderer/src/lib/analytics.ts
+++ b/apps/x/apps/renderer/src/lib/analytics.ts
@@ -69,6 +69,26 @@ export function voiceInputStarted() {
   posthog.capture('voice_input_started')
 }
 
+export function callStarted(preset: 'voice' | 'video' | 'share' | 'practice') {
+  posthog.capture('call_started', { preset })
+}
+
+// Voice-to-voice latency breakdown for one call turn (all milliseconds):
+// utterance accepted → message submitted → first TTS speak() → audio playing.
+export function callTurnLatency(props: {
+  endpointToSubmitMs: number
+  submitToSpeakMs: number
+  speakToAudioMs: number
+  totalMs: number
+}) {
+  posthog.capture('call_turn_latency', {
+    endpoint_to_submit_ms: Math.round(props.endpointToSubmitMs),
+    submit_to_speak_ms: Math.round(props.submitToSpeakMs),
+    speak_to_audio_ms: Math.round(props.speakToAudioMs),
+    total_ms: Math.round(props.totalMs),
+  })
+}
+
 export function searchExecuted(types: string[]) {
   posthog.capture('search_executed', { types })
 }
diff --git a/apps/x/apps/renderer/src/lib/call-sounds.ts b/apps/x/apps/renderer/src/lib/call-sounds.ts
new file mode 100644
index 00000000..f7d20607
--- /dev/null
+++ b/apps/x/apps/renderer/src/lib/call-sounds.ts
@@ -0,0 +1,30 @@
+// Tiny synthesized UI sounds for calls — no audio assets, one lazy context.
+
+let ctx: AudioContext | null = null
+
+/**
+ * Soft rising blip played the instant an utterance is accepted — sub-second
+ * acknowledgment makes the (still ongoing) model turn feel responsive
+ * instead of dead air.
+ */
+export function playAckCue() {
+  try {
+    if (!ctx) ctx = new AudioContext()
+    if (ctx.state === 'suspended') void ctx.resume()
+    const t = ctx.currentTime
+    const osc = ctx.createOscillator()
+    const gain = ctx.createGain()
+    osc.type = 'sine'
+    osc.frequency.setValueAtTime(880, t)
+    osc.frequency.exponentialRampToValueAtTime(1320, t + 0.08)
+    gain.gain.setValueAtTime(0.0001, t)
+    gain.gain.exponentialRampToValueAtTime(0.08, t + 0.015)
+    gain.gain.exponentialRampToValueAtTime(0.0001, t + 0.12)
+    osc.connect(gain)
+    gain.connect(ctx.destination)
+    osc.start(t)
+    osc.stop(t + 0.13)
+  } catch {
+    // cosmetic — never let a sound failure affect the call
+  }
+}
diff --git a/apps/x/apps/renderer/src/lib/chat-conversation.ts b/apps/x/apps/renderer/src/lib/chat-conversation.ts
index 59365430..dfc4045c 100644
--- a/apps/x/apps/renderer/src/lib/chat-conversation.ts
+++ b/apps/x/apps/renderer/src/lib/chat-conversation.ts
@@ -10,6 +10,9 @@ export interface MessageAttachment {
   mimeType: string
   size?: number
   thumbnailUrl?: string
+  /** Live webcam frame from video chat mode — rendered as a compact filmstrip.
+   *  Carries no path; thumbnailUrl holds the frame as a data: URL. */
+  isVideoFrame?: boolean
 }
 
 export interface ChatMessage {
@@ -198,6 +201,22 @@ const summarizeFilterUpdates = (updates: Record<string, unknown>): string => {
   return parts.length > 0 ? parts.join(', ') : 'Updated view'
 }
 
+const APP_VIEW_LABELS: Record<string, string> = {
+  home: 'home',
+  email: 'email',
+  meetings: 'meetings',
+  'live-notes': 'live notes',
+  'bg-tasks': 'background agents',
+  'chat-history': 'chat history',
+  knowledge: 'knowledge',
+  workspace: 'workspace',
+  code: 'code',
+  bases: 'bases',
+  graph: 'graph',
+}
+
+const appViewLabel = (view: unknown): string => APP_VIEW_LABELS[view as string] ?? String(view ?? 'view')
+
 export const getAppActionCardData = (tool: ToolCall): AppActionCardData | null => {
   if (tool.name !== 'app-navigation') return null
   const result = tool.result as Record<string, unknown> | undefined
@@ -209,8 +228,10 @@ export const getAppActionCardData = (tool: ToolCall): AppActionCardData | null =
     const action = input.action as string
     switch (action) {
       case 'open-note': return { action, label: `Opening ${(input.path as string || '').split('/').pop()?.replace(/\.md$/, '') || 'note'}...` }
-      case 'open-view': return { action, label: `Opening ${input.view} view...` }
+      case 'open-view': return { action, label: `Opening ${appViewLabel(input.view)}...` }
       case 'open-app': return { action, label: `Opening ${input.appId || 'app'}...` }
+      case 'read-view': return { action, label: `Reading ${appViewLabel(input.view)}...` }
+      case 'open-item': return { action, label: 'Opening...' }
       case 'update-base-view': return { action, label: 'Updating view...' }
       case 'create-base': return { action, label: `Creating "${input.name}"...` }
       case 'get-base-state': return null // renders as normal tool block
@@ -225,9 +246,33 @@ export const getAppActionCardData = (tool: ToolCall): AppActionCardData | null =
       return { action: 'open-note', label: `Opened ${name}` }
     }
     case 'open-view':
-      return { action: 'open-view', label: `Opened ${result.view} view` }
+      return { action: 'open-view', label: `Opened ${appViewLabel(result.view)}` }
     case 'open-app':
       return { action: 'open-app', label: `Opened ${result.appName || result.appId || 'app'}` }
+    case 'read-view': {
+      const counted =
+        (result.threads as unknown[] | undefined)?.length ??
+        (result.agents as unknown[] | undefined)?.length ??
+        (result.sessions as unknown[] | undefined)?.length
+      return {
+        action: 'read-view',
+        label: counted !== undefined
+          ? `Read ${appViewLabel(result.view)} (${counted} item${counted === 1 ? '' : 's'})`
+          : `Read ${appViewLabel(result.view)}`,
+      }
+    }
+    case 'open-item': {
+      switch (result.kind) {
+        case 'email-thread': return { action: 'open-item', label: 'Opened email thread' }
+        case 'note': {
+          const name = (result.path as string || '').split('/').pop()?.replace(/\.md$/, '') || 'note'
+          return { action: 'open-item', label: `Opened ${name}` }
+        }
+        case 'bg-task': return { action: 'open-item', label: `Opened agent "${result.taskName}"` }
+        case 'session': return { action: 'open-item', label: 'Opened chat' }
+        default: return { action: 'open-item', label: 'Opened item' }
+      }
+    }
     case 'update-base-view':
       return {
         action: 'update-base-view',
diff --git a/apps/x/apps/renderer/src/lib/deepgram-finalize.ts b/apps/x/apps/renderer/src/lib/deepgram-finalize.ts
new file mode 100644
index 00000000..91c3e37f
--- /dev/null
+++ b/apps/x/apps/renderer/src/lib/deepgram-finalize.ts
@@ -0,0 +1,33 @@
+export async function finalizeDeepgramStream(ws: WebSocket | null, timeoutMs = 1800): Promise<void> {
+  if (!ws || ws.readyState !== WebSocket.OPEN) return;
+
+  await new Promise<void>((resolve) => {
+    let done = false;
+    let timeout: ReturnType<typeof setTimeout>;
+    const finish = () => {
+      if (done) return;
+      done = true;
+      clearTimeout(timeout);
+      ws.removeEventListener('message', onMessage);
+      resolve();
+    };
+    timeout = setTimeout(finish, timeoutMs);
+    const onMessage = (event: MessageEvent) => {
+      try {
+        const data = JSON.parse(event.data);
+        if (data?.is_final || data?.speech_final || data?.type === 'UtteranceEnd') {
+          finish();
+        }
+      } catch {
+        // Ignore non-JSON control frames.
+      }
+    };
+
+    ws.addEventListener('message', onMessage);
+    try {
+      ws.send(JSON.stringify({ type: 'Finalize' }));
+    } catch {
+      finish();
+    }
+  });
+}
diff --git a/apps/x/apps/renderer/src/lib/run-to-conversation.ts b/apps/x/apps/renderer/src/lib/run-to-conversation.ts
index be182773..ecce30df 100644
--- a/apps/x/apps/renderer/src/lib/run-to-conversation.ts
+++ b/apps/x/apps/renderer/src/lib/run-to-conversation.ts
@@ -41,6 +41,9 @@ export function runLogToConversation(log: RunLog): ConversationItem[] {
             filename?: string
             mimeType?: string
             size?: number
+            data?: string
+            mediaType?: string
+            source?: string
             toolCallId?: string
             toolName?: string
             arguments?: unknown
@@ -52,13 +55,24 @@ export function runLogToConversation(log: RunLog): ConversationItem[] {
             .join('')
 
           const attachmentParts = parts.filter((p) => p.type === 'attachment' && p.path)
-          if (attachmentParts.length > 0) {
-            msgAttachments = attachmentParts.map((p) => ({
-              path: p.path!,
-              filename: p.filename || p.path!.split('/').pop() || p.path!,
-              mimeType: p.mimeType || 'application/octet-stream',
-              size: p.size,
-            }))
+          // Video-mode webcam frames — inline base64 image parts, shown as a filmstrip
+          const imageParts = parts.filter((p) => p.type === 'image' && p.data)
+          if (attachmentParts.length > 0 || imageParts.length > 0) {
+            msgAttachments = [
+              ...attachmentParts.map((p) => ({
+                path: p.path!,
+                filename: p.filename || p.path!.split('/').pop() || p.path!,
+                mimeType: p.mimeType || 'application/octet-stream',
+                size: p.size,
+              })),
+              ...imageParts.map((p, index) => ({
+                path: '',
+                filename: `${p.source === 'screen' ? 'screen' : 'camera'}-frame-${index + 1}.jpg`,
+                mimeType: p.mediaType || 'image/jpeg',
+                thumbnailUrl: `data:${p.mediaType || 'image/jpeg'};base64,${p.data}`,
+                isVideoFrame: true,
+              })),
+            ]
           }
 
           if (msg.role === 'assistant') {
diff --git a/apps/x/apps/renderer/src/lib/session-chat/client.ts b/apps/x/apps/renderer/src/lib/session-chat/client.ts
new file mode 100644
index 00000000..87df44f0
--- /dev/null
+++ b/apps/x/apps/renderer/src/lib/session-chat/client.ts
@@ -0,0 +1,70 @@
+import type { z } from 'zod'
+import type { UserMessage } from '@x/shared/src/message.js'
+import type { SessionIndexEntry, SessionState } from '@x/shared/src/sessions.js'
+import type { JsonValue, RequestedAgent, TurnEvent } from '@x/shared/src/turns.js'
+
+// Narrow, injectable surface over the sessions IPC channels so stores are
+// testable with a plain fake instead of a window.ipc stub.
+export interface SendMessageConfig {
+  agent: z.infer<typeof RequestedAgent>
+  autoPermission?: boolean
+  maxModelCalls?: number
+}
+
+export interface SessionsClient {
+  create(input: { title?: string }): Promise<{ sessionId: string }>
+  list(): Promise<{ sessions: SessionIndexEntry[] }>
+  get(sessionId: string): Promise<SessionState>
+  getTurn(turnId: string): Promise<{ turnId: string; events: Array<z.infer<typeof TurnEvent>> }>
+  sendMessage(
+    sessionId: string,
+    input: z.infer<typeof UserMessage>,
+    config: SendMessageConfig,
+  ): Promise<{ turnId: string }>
+  respondToPermission(
+    turnId: string,
+    toolCallId: string,
+    decision: 'allow' | 'deny',
+    metadata?: JsonValue,
+  ): Promise<void>
+  respondToAskHuman(turnId: string, toolCallId: string, answer: string): Promise<void>
+  stopTurn(turnId: string, reason?: string): Promise<void>
+  resumeTurn(sessionId: string): Promise<void>
+  setTitle(sessionId: string, title: string): Promise<void>
+  delete(sessionId: string): Promise<void>
+}
+
+export const ipcSessionsClient: SessionsClient = {
+  create: (input) => window.ipc.invoke('sessions:create', input),
+  list: () => window.ipc.invoke('sessions:list', {}),
+  get: (sessionId) => window.ipc.invoke('sessions:get', { sessionId }),
+  getTurn: (turnId) => window.ipc.invoke('sessions:getTurn', { turnId }),
+  sendMessage: (sessionId, input, config) =>
+    window.ipc.invoke('sessions:sendMessage', { sessionId, input, config }),
+  respondToPermission: async (turnId, toolCallId, decision, metadata) => {
+    await window.ipc.invoke('sessions:respondToPermission', {
+      turnId,
+      toolCallId,
+      decision,
+      ...(metadata === undefined ? {} : { metadata }),
+    })
+  },
+  respondToAskHuman: async (turnId, toolCallId, answer) => {
+    await window.ipc.invoke('sessions:respondToAskHuman', { turnId, toolCallId, answer })
+  },
+  stopTurn: async (turnId, reason) => {
+    await window.ipc.invoke('sessions:stopTurn', {
+      turnId,
+      ...(reason === undefined ? {} : { reason }),
+    })
+  },
+  resumeTurn: async (sessionId) => {
+    await window.ipc.invoke('sessions:resumeTurn', { sessionId })
+  },
+  setTitle: async (sessionId, title) => {
+    await window.ipc.invoke('sessions:setTitle', { sessionId, title })
+  },
+  delete: async (sessionId) => {
+    await window.ipc.invoke('sessions:delete', { sessionId })
+  },
+}
diff --git a/apps/x/apps/renderer/src/lib/session-chat/feed.test.ts b/apps/x/apps/renderer/src/lib/session-chat/feed.test.ts
new file mode 100644
index 00000000..86d00bbd
--- /dev/null
+++ b/apps/x/apps/renderer/src/lib/session-chat/feed.test.ts
@@ -0,0 +1,52 @@
+import { describe, expect, it } from 'vitest'
+import type { SessionBusEvent } from '@x/shared/src/sessions.js'
+import { createSessionFeed, type SessionFeedListener } from './feed'
+
+const event: SessionBusEvent = {
+  kind: 'index-changed',
+  sessionId: 's1',
+  entry: null,
+}
+
+describe('createSessionFeed', () => {
+  it('starts the source lazily on first subscribe and fans events out', () => {
+    let sourceStarted = 0
+    let push: SessionFeedListener = () => undefined
+    const feed = createSessionFeed((listener) => {
+      sourceStarted += 1
+      push = listener
+      return () => undefined
+    })
+    expect(sourceStarted).toBe(0)
+
+    const seenA: SessionBusEvent[] = []
+    const seenB: SessionBusEvent[] = []
+    feed.subscribe((e) => seenA.push(e))
+    feed.subscribe((e) => seenB.push(e))
+    expect(sourceStarted).toBe(1) // one shared IPC listener
+
+    push(event)
+    expect(seenA).toEqual([event])
+    expect(seenB).toEqual([event])
+  })
+
+  it('unsubscribes cleanly and isolates a throwing listener', () => {
+    let push: SessionFeedListener = () => undefined
+    const feed = createSessionFeed((listener) => {
+      push = listener
+      return () => undefined
+    })
+    const seen: SessionBusEvent[] = []
+    feed.subscribe(() => {
+      throw new Error('bad subscriber')
+    })
+    const unsubscribe = feed.subscribe((e) => seen.push(e))
+
+    push(event)
+    expect(seen).toEqual([event])
+
+    unsubscribe()
+    push(event)
+    expect(seen).toEqual([event])
+  })
+})
diff --git a/apps/x/apps/renderer/src/lib/session-chat/feed.ts b/apps/x/apps/renderer/src/lib/session-chat/feed.ts
new file mode 100644
index 00000000..bac8a735
--- /dev/null
+++ b/apps/x/apps/renderer/src/lib/session-chat/feed.ts
@@ -0,0 +1,42 @@
+import type { SessionBusEvent } from '@x/shared/src/sessions.js'
+
+export type SessionFeedListener = (event: SessionBusEvent) => void
+export type SessionFeedSource = (listener: SessionFeedListener) => () => void
+
+// One shared consumer of the sessions:events push channel; stores tap this
+// fan-out instead of each opening their own IPC listener. Factory so tests
+// can drive a fake source.
+export function createSessionFeed(source: SessionFeedSource) {
+  const listeners = new Set<SessionFeedListener>()
+  let detach: (() => void) | null = null
+
+  const ensureStarted = () => {
+    if (detach) return
+    detach = source((event) => {
+      // Copy so (un)subscribing during dispatch is safe.
+      for (const listener of [...listeners]) {
+        try {
+          listener(event)
+        } catch {
+          // A misbehaving subscriber must never break the feed.
+        }
+      }
+    })
+  }
+
+  return {
+    subscribe(listener: SessionFeedListener): () => void {
+      ensureStarted()
+      listeners.add(listener)
+      return () => {
+        listeners.delete(listener)
+      }
+    },
+  }
+}
+
+const appFeed = createSessionFeed((listener) => window.ipc.on('sessions:events', listener))
+
+export function subscribeSessionFeed(listener: SessionFeedListener): () => void {
+  return appFeed.subscribe(listener)
+}
diff --git a/apps/x/apps/renderer/src/lib/session-chat/store.test.ts b/apps/x/apps/renderer/src/lib/session-chat/store.test.ts
new file mode 100644
index 00000000..9c5e0e9c
--- /dev/null
+++ b/apps/x/apps/renderer/src/lib/session-chat/store.test.ts
@@ -0,0 +1,314 @@
+import { describe, expect, it } from 'vitest'
+import type { SessionBusEvent, SessionState } from '@x/shared/src/sessions.js'
+import { isChatMessage } from '@/lib/chat-conversation'
+import type { SessionsClient } from './client'
+import type { SessionFeedListener } from './feed'
+import { SessionChatStore, SessionListStore } from './store'
+import {
+  assistantText,
+  completed,
+  completedTurnLog,
+  created,
+  indexEntry,
+  requested,
+  sessionState,
+  turnCompleted,
+  user,
+  type TEvent,
+} from './test-fixtures'
+
+const S1 = 'sess-1'
+
+class FakeClient implements SessionsClient {
+  sessions = new Map<string, SessionState>()
+  turns = new Map<string, TEvent[]>()
+  calls: Array<{ method: string; args: unknown[] }> = []
+  // When set, get() defers until the returned resolver is invoked.
+  deferredGet: (() => void) | null = null
+
+  private record(method: string, ...args: unknown[]) {
+    this.calls.push({ method, args })
+  }
+
+  async create(input: { title?: string }) {
+    this.record('create', input)
+    return { sessionId: 'new-session' }
+  }
+  async list() {
+    this.record('list')
+    return { sessions: [...this.sessions.keys()].map((id) => indexEntry(id)) }
+  }
+  async get(sessionId: string) {
+    this.record('get', sessionId)
+    if (this.deferredGet === null) {
+      const state = this.sessions.get(sessionId)
+      if (!state) throw new Error(`session not found: ${sessionId}`)
+      return state
+    }
+    return new Promise<SessionState>((resolve, reject) => {
+      this.deferredGet = () => {
+        const state = this.sessions.get(sessionId)
+        if (state) resolve(state)
+        else reject(new Error(`session not found: ${sessionId}`))
+      }
+    })
+  }
+  async getTurn(turnId: string) {
+    this.record('getTurn', turnId)
+    const events = this.turns.get(turnId)
+    if (!events) throw new Error(`turn not found: ${turnId}`)
+    return { turnId, events }
+  }
+  async sendMessage(sessionId: string, input: unknown, config: unknown) {
+    this.record('sendMessage', sessionId, input, config)
+    return { turnId: 'turn-next' }
+  }
+  async respondToPermission(...args: unknown[]) {
+    this.record('respondToPermission', ...args)
+  }
+  async respondToAskHuman(...args: unknown[]) {
+    this.record('respondToAskHuman', ...args)
+  }
+  async stopTurn(...args: unknown[]) {
+    this.record('stopTurn', ...args)
+  }
+  async resumeTurn(...args: unknown[]) {
+    this.record('resumeTurn', ...args)
+  }
+  async setTitle(...args: unknown[]) {
+    this.record('setTitle', ...args)
+  }
+  async delete(...args: unknown[]) {
+    this.record('delete', ...args)
+  }
+}
+
+function makeStore() {
+  const client = new FakeClient()
+  let emit: SessionFeedListener = () => undefined
+  let subscribed = 0
+  let unsubscribed = 0
+  const store = new SessionChatStore({
+    client,
+    subscribeFeed: (listener) => {
+      subscribed += 1
+      emit = listener
+      return () => {
+        unsubscribed += 1
+        emit = () => undefined
+      }
+    },
+  })
+  const disconnect = store.connect()
+  return {
+    client,
+    store,
+    disconnect,
+    emit: (event: SessionBusEvent) => emit(event),
+    getSubscribed: () => subscribed,
+    getUnsubscribed: () => unsubscribed,
+  }
+}
+
+function turnEvent(
+  sessionId: string,
+  turnId: string,
+  event:
+    | TEvent
+    | { type: 'text_delta' | 'reasoning_delta'; turnId: string; modelCallIndex: number; delta: string },
+): SessionBusEvent {
+  return { kind: 'turn-event', sessionId, turnId, event }
+}
+
+describe('SessionChatStore', () => {
+  it('seeds a session: prior turns frozen, latest live, conversation composed', async () => {
+    const { client, store } = makeStore()
+    client.sessions.set(S1, sessionState(S1, ['turn-1', 'turn-2']))
+    client.turns.set('turn-1', completedTurnLog('turn-1', S1, 'first?', 'first answer'))
+    client.turns.set('turn-2', completedTurnLog('turn-2', S1, 'second?', 'second answer'))
+
+    await store.setSession(S1)
+    const snapshot = store.getSnapshot()
+    expect(snapshot.loading).toBe(false)
+    expect(snapshot.latestTurnId).toBe('turn-2')
+    expect(
+      snapshot.chatState?.conversation.filter(isChatMessage).map((m) => m.content),
+    ).toEqual(['first?', 'first answer', 'second?', 'second answer'])
+    expect(snapshot.chatState?.isProcessing).toBe(false)
+  })
+
+  it('applies live durable events through the shared reducer', async () => {
+    const { client, store, emit } = makeStore()
+    client.sessions.set(S1, sessionState(S1, []))
+    await store.setSession(S1)
+
+    emit(turnEvent(S1, 'turn-1', created('turn-1', S1, user('go'))))
+    emit(turnEvent(S1, 'turn-1', requested('turn-1', 0)))
+    expect(store.getSnapshot().chatState?.isThinking).toBe(true)
+
+    emit(turnEvent(S1, 'turn-1', completed('turn-1', 0, assistantText('done'))))
+    emit(turnEvent(S1, 'turn-1', turnCompleted('turn-1')))
+    const snapshot = store.getSnapshot()
+    expect(snapshot.latestTurnId).toBe('turn-1')
+    expect(snapshot.chatState?.isProcessing).toBe(false)
+    expect(
+      snapshot.chatState?.conversation.filter(isChatMessage).map((m) => m.content),
+    ).toEqual(['go', 'done'])
+  })
+
+  it('accumulates text deltas and clears them on the canonical response', async () => {
+    const { client, store, emit } = makeStore()
+    client.sessions.set(S1, sessionState(S1, []))
+    await store.setSession(S1)
+    emit(turnEvent(S1, 'turn-1', created('turn-1', S1, user('go'))))
+    emit(turnEvent(S1, 'turn-1', requested('turn-1', 0)))
+    emit(turnEvent(S1, 'turn-1', { type: 'text_delta', turnId: 'turn-1', modelCallIndex: 0, delta: 'he' }))
+    emit(turnEvent(S1, 'turn-1', { type: 'text_delta', turnId: 'turn-1', modelCallIndex: 0, delta: 'y' }))
+    expect(store.getSnapshot().chatState?.currentAssistantMessage).toBe('hey')
+
+    emit(turnEvent(S1, 'turn-1', completed('turn-1', 0, assistantText('hey'))))
+    expect(store.getSnapshot().chatState?.currentAssistantMessage).toBe('')
+  })
+
+  it('freezes the previous latest turn when a new turn starts', async () => {
+    const { client, store, emit } = makeStore()
+    client.sessions.set(S1, sessionState(S1, ['turn-1']))
+    client.turns.set('turn-1', completedTurnLog('turn-1', S1, 'q1', 'a1'))
+    await store.setSession(S1)
+
+    emit(turnEvent(S1, 'turn-2', created('turn-2', S1, user('q2'))))
+    const snapshot = store.getSnapshot()
+    expect(snapshot.latestTurnId).toBe('turn-2')
+    expect(
+      snapshot.chatState?.conversation.filter(isChatMessage).map((m) => m.content),
+    ).toEqual(['q1', 'a1', 'q2'])
+  })
+
+  it('ignores events for other sessions', async () => {
+    const { client, store, emit } = makeStore()
+    client.sessions.set(S1, sessionState(S1, []))
+    await store.setSession(S1)
+    emit(turnEvent('other-session', 'turn-x', created('turn-x', 'other-session')))
+    expect(store.getSnapshot().chatState?.conversation).toEqual([])
+  })
+
+  it('reconciles an unknown mid-turn event by refetching the turn', async () => {
+    const { client, store, emit } = makeStore()
+    client.sessions.set(S1, sessionState(S1, []))
+    await store.setSession(S1)
+    // The feed attached mid-turn: we never saw turn_created for turn-9.
+    client.turns.set('turn-9', [
+      created('turn-9', S1, user('missed')),
+      requested('turn-9', 0),
+    ])
+    emit(turnEvent(S1, 'turn-9', completed('turn-9', 0, assistantText('caught up'))))
+    await Promise.resolve()
+    await Promise.resolve()
+    expect(store.getSnapshot().latestTurnId).toBe('turn-9')
+  })
+
+  it('routes actions against the latest turn', async () => {
+    const { client, store, emit } = makeStore()
+    client.sessions.set(S1, sessionState(S1, []))
+    await store.setSession(S1)
+    emit(turnEvent(S1, 'turn-1', created('turn-1', S1)))
+
+    await store.sendMessage(user('next'), { agent: { agentId: 'copilot' } })
+    await store.respondToPermission('tc1', 'allow')
+    await store.answerAskHuman('ah1', '42')
+    await store.stop()
+
+    expect(client.calls.filter((c) => c.method !== 'get' && c.method !== 'getTurn')).toEqual([
+      { method: 'sendMessage', args: [S1, user('next'), { agent: { agentId: 'copilot' } }] },
+      { method: 'respondToPermission', args: ['turn-1', 'tc1', 'allow', undefined] },
+      { method: 'respondToAskHuman', args: ['turn-1', 'ah1', '42'] },
+      { method: 'stopTurn', args: ['turn-1'] },
+    ])
+  })
+
+  it('rejects sendMessage without an active session', async () => {
+    const { store } = makeStore()
+    await expect(
+      store.sendMessage(user('x'), { agent: { agentId: 'copilot' } }),
+    ).rejects.toThrowError('No active session')
+  })
+
+  it('drops stale loads after a session switch', async () => {
+    const { client, store } = makeStore()
+    client.sessions.set(S1, sessionState(S1, ['turn-1']))
+    client.turns.set('turn-1', completedTurnLog('turn-1', S1, 'old', 'old answer'))
+    client.sessions.set('sess-2', sessionState('sess-2', []))
+
+    client.deferredGet = () => undefined // arm deferral
+    const first = store.setSession(S1)
+    const release = client.deferredGet
+    client.deferredGet = null
+    const second = store.setSession('sess-2')
+    release?.() // S1's get resolves after the switch
+    await Promise.all([first, second])
+
+    expect(store.getSnapshot().sessionId).toBe('sess-2')
+    expect(store.getSnapshot().chatState?.conversation).toEqual([])
+  })
+
+  it('surfaces load errors and disconnects its feed subscription', async () => {
+    const { store, disconnect, getUnsubscribed } = makeStore()
+    await store.setSession('missing-session')
+    expect(store.getSnapshot().error).toMatch(/session not found/)
+    disconnect()
+    expect(getUnsubscribed()).toBe(1)
+    void store
+  })
+
+  it('survives a StrictMode-style connect -> cleanup -> connect cycle', async () => {
+    // React StrictMode runs every effect's mount/cleanup/mount cycle in dev;
+    // the feed must re-attach or the store goes permanently deaf (the bug
+    // this test pins: a constructor-made subscription torn down by the first
+    // cleanup was never restored, leaving the chat stuck at "Thinking…").
+    const { client, store, disconnect, emit, getSubscribed } = makeStore()
+    client.sessions.set(S1, sessionState(S1, []))
+    disconnect()
+    const disconnect2 = store.connect()
+    expect(getSubscribed()).toBe(2)
+
+    await store.setSession(S1)
+    emit(turnEvent(S1, 'turn-1', created('turn-1', S1, user('go'))))
+    emit(turnEvent(S1, 'turn-1', requested('turn-1', 0)))
+    emit(turnEvent(S1, 'turn-1', completed('turn-1', 0, assistantText('done'))))
+    emit(turnEvent(S1, 'turn-1', turnCompleted('turn-1')))
+    expect(store.getSnapshot().chatState?.isProcessing).toBe(false)
+    expect(
+      store.getSnapshot().chatState?.conversation.filter(isChatMessage).map((m) => m.content),
+    ).toEqual(['go', 'done'])
+    disconnect2()
+  })
+})
+
+describe('SessionListStore', () => {
+  it('loads, applies index updates and deletions, and sorts by updatedAt', async () => {
+    const client = new FakeClient()
+    client.sessions.set('a', sessionState('a', []))
+    client.sessions.set('b', sessionState('b', []))
+    let emit: SessionFeedListener = () => undefined
+    const store = new SessionListStore({
+      client,
+      subscribeFeed: (listener) => {
+        emit = listener
+        return () => undefined
+      },
+    })
+    store.connect()
+    await store.load()
+    expect(store.getSnapshot().sessions.map((s) => s.sessionId).sort()).toEqual(['a', 'b'])
+
+    emit({
+      kind: 'index-changed',
+      sessionId: 'c',
+      entry: indexEntry('c', { updatedAt: '2026-07-03T00:00:00Z' }),
+    })
+    expect(store.getSnapshot().sessions[0].sessionId).toBe('c')
+
+    emit({ kind: 'index-changed', sessionId: 'a', entry: null })
+    expect(store.getSnapshot().sessions.map((s) => s.sessionId)).toEqual(['c', 'b'])
+  })
+})
diff --git a/apps/x/apps/renderer/src/lib/session-chat/store.ts b/apps/x/apps/renderer/src/lib/session-chat/store.ts
new file mode 100644
index 00000000..2bd0b4b4
--- /dev/null
+++ b/apps/x/apps/renderer/src/lib/session-chat/store.ts
@@ -0,0 +1,314 @@
+import type { z } from 'zod'
+import type { UserMessage } from '@x/shared/src/message.js'
+import type { SessionBusEvent, SessionIndexEntry } from '@x/shared/src/sessions.js'
+import {
+  reduceTurn,
+  type JsonValue,
+  type TurnEvent,
+  type TurnState,
+  type TurnStreamEvent,
+} from '@x/shared/src/turns.js'
+import type { SendMessageConfig, SessionsClient } from './client'
+import type { SessionFeedListener } from './feed'
+import {
+  applyOverlay,
+  buildSessionChatState,
+  emptyOverlay,
+  type LiveOverlay,
+  type SessionChatState,
+} from './turn-view'
+
+type TEvent = z.infer<typeof TurnEvent>
+
+export interface SessionChatSnapshot {
+  sessionId: string | null
+  chatState: SessionChatState | null
+  latestTurnId: string | null
+  loading: boolean
+  error: string | null
+}
+
+export interface SessionChatStoreDeps {
+  client: SessionsClient
+  subscribeFeed: (listener: SessionFeedListener) => () => void
+}
+
+// Framework-agnostic controller for one active session's chat. Owns all the
+// logic (seeding via getSession/getTurn, applying live feed events with the
+// shared reducer, the ephemeral overlay, action routing); the useSessionChat
+// hook is a thin useSyncExternalStore subscription over it.
+export class SessionChatStore {
+  private readonly client: SessionsClient
+  private readonly subscribeFeed: (listener: SessionFeedListener) => () => void
+  private feedDisconnect: (() => void) | null = null
+  private readonly listeners = new Set<() => void>()
+
+  private sessionId: string | null = null
+  // Settled earlier turns, reduced once and frozen.
+  private priorTurns: TurnState[] = []
+  // The latest turn's raw event log; re-reduced on each durable event.
+  private latestEvents: TEvent[] | null = null
+  private overlay: LiveOverlay = emptyOverlay()
+  private loading = false
+  private error: string | null = null
+  // Guards stale async loads after a session switch.
+  private generation = 0
+
+  private snapshot: SessionChatSnapshot = {
+    sessionId: null,
+    chatState: null,
+    latestTurnId: null,
+    loading: false,
+    error: null,
+  }
+
+  constructor(deps: SessionChatStoreDeps) {
+    this.client = deps.client
+    this.subscribeFeed = deps.subscribeFeed
+  }
+
+  // Feed attachment is effect-managed and idempotent so React StrictMode's
+  // mount -> cleanup -> mount cycle re-attaches cleanly (a constructor-made
+  // subscription would be torn down by the first cleanup and never restored).
+  connect(): () => void {
+    if (!this.feedDisconnect) {
+      this.feedDisconnect = this.subscribeFeed(this.onFeedEvent)
+    }
+    return () => {
+      this.feedDisconnect?.()
+      this.feedDisconnect = null
+    }
+  }
+
+  subscribe = (onChange: () => void): (() => void) => {
+    this.listeners.add(onChange)
+    return () => {
+      this.listeners.delete(onChange)
+    }
+  }
+
+  getSnapshot = (): SessionChatSnapshot => this.snapshot
+
+  async setSession(sessionId: string | null): Promise<void> {
+    if (sessionId === this.sessionId) return
+    this.generation += 1
+    const generation = this.generation
+    this.sessionId = sessionId
+    this.priorTurns = []
+    this.latestEvents = null
+    this.overlay = emptyOverlay()
+    this.error = null
+    this.loading = sessionId !== null
+    this.emit()
+    if (sessionId === null) return
+
+    try {
+      const state = await this.client.get(sessionId)
+      const turns = await Promise.all(
+        state.turns.map((ref) => this.client.getTurn(ref.turnId)),
+      )
+      if (generation !== this.generation) return
+      const reduced = turns.map((turn) => reduceTurn(turn.events))
+      this.priorTurns = reduced.slice(0, -1)
+      this.latestEvents = turns.length > 0 ? turns[turns.length - 1].events : null
+      this.loading = false
+      this.emit()
+    } catch (error) {
+      if (generation !== this.generation) return
+      console.error('[session-chat] failed to load session', sessionId, error)
+      this.loading = false
+      this.error = error instanceof Error ? error.message : String(error)
+      this.emit()
+    }
+  }
+
+  private onFeedEvent: SessionFeedListener = (event: SessionBusEvent) => {
+    if (event.kind !== 'turn-event' || event.sessionId !== this.sessionId) return
+    const turnEvent = event.event
+    if (isDurable(turnEvent)) {
+      if (turnEvent.type === 'turn_created') {
+        // A new turn started for this session: freeze the previous latest.
+        this.freezeLatest()
+        this.latestEvents = [turnEvent]
+        this.overlay = emptyOverlay()
+      } else if (this.latestEvents && this.latestEvents[0].turnId === turnEvent.turnId) {
+        this.latestEvents.push(turnEvent)
+      } else {
+        // An event for a turn we haven't seen (missed turn_created, e.g. the
+        // feed attached mid-turn): reconcile by refetching that turn.
+        void this.reloadTurn(event.turnId)
+        return
+      }
+    }
+    this.overlay = applyOverlay(this.overlay, turnEvent)
+    this.emit()
+  }
+
+  private freezeLatest(): void {
+    if (!this.latestEvents) return
+    try {
+      this.priorTurns = [...this.priorTurns, reduceTurn(this.latestEvents)]
+    } catch {
+      // A turn we can't reduce is dropped from history rather than wedging
+      // the whole conversation.
+    }
+    this.latestEvents = null
+  }
+
+  private async reloadTurn(turnId: string): Promise<void> {
+    const generation = this.generation
+    try {
+      const turn = await this.client.getTurn(turnId)
+      if (generation !== this.generation) return
+      if (this.latestEvents && this.latestEvents[0].turnId !== turnId) {
+        this.freezeLatest()
+      }
+      this.latestEvents = turn.events
+      this.emit()
+    } catch (error) {
+      // The next snapshot-worthy event will retry.
+      console.error('[session-chat] failed to reload turn', turnId, error)
+    }
+  }
+
+  // ── Actions ─────────────────────────────────────────────────────────────
+
+  sendMessage = async (
+    input: z.infer<typeof UserMessage>,
+    config: SendMessageConfig,
+  ): Promise<{ turnId: string }> => {
+    if (!this.sessionId) throw new Error('No active session')
+    return this.client.sendMessage(this.sessionId, input, config)
+  }
+
+  respondToPermission = async (
+    toolCallId: string,
+    decision: 'allow' | 'deny',
+    metadata?: JsonValue,
+  ): Promise<void> => {
+    const turnId = this.snapshot.latestTurnId
+    if (!turnId) return
+    await this.client.respondToPermission(turnId, toolCallId, decision, metadata)
+  }
+
+  answerAskHuman = async (toolCallId: string, answer: string): Promise<void> => {
+    const turnId = this.snapshot.latestTurnId
+    if (!turnId) return
+    await this.client.respondToAskHuman(turnId, toolCallId, answer)
+  }
+
+  stop = async (): Promise<void> => {
+    const turnId = this.snapshot.latestTurnId
+    if (!turnId) return
+    await this.client.stopTurn(turnId)
+  }
+
+  // ── Derivation ──────────────────────────────────────────────────────────
+
+  private emit(): void {
+    this.snapshot = this.derive()
+    for (const listener of [...this.listeners]) {
+      listener()
+    }
+  }
+
+  private derive(): SessionChatSnapshot {
+    let turns = this.priorTurns
+    let error = this.error
+    if (this.latestEvents) {
+      try {
+        turns = [...this.priorTurns, reduceTurn(this.latestEvents)]
+      } catch (reduceError) {
+        error =
+          reduceError instanceof Error ? reduceError.message : String(reduceError)
+      }
+    }
+    const latest = turns[turns.length - 1]
+    return {
+      sessionId: this.sessionId,
+      chatState:
+        this.sessionId !== null && !this.loading
+          ? buildSessionChatState(turns, this.overlay)
+          : null,
+      latestTurnId: latest?.definition.turnId ?? null,
+      loading: this.loading,
+      error,
+    }
+  }
+}
+
+function isDurable(event: TurnStreamEvent): event is TEvent {
+  return event.type !== 'text_delta' && event.type !== 'reasoning_delta'
+}
+
+// ---------------------------------------------------------------------------
+// Session list store
+// ---------------------------------------------------------------------------
+
+export interface SessionListSnapshot {
+  sessions: SessionIndexEntry[]
+  loading: boolean
+}
+
+export class SessionListStore {
+  private readonly client: SessionsClient
+  private readonly subscribeFeed: (listener: SessionFeedListener) => () => void
+  private feedDisconnect: (() => void) | null = null
+  private readonly listeners = new Set<() => void>()
+  private entries = new Map<string, SessionIndexEntry>()
+  private loading = true
+  private snapshot: SessionListSnapshot = { sessions: [], loading: true }
+
+  constructor(deps: SessionChatStoreDeps) {
+    this.client = deps.client
+    this.subscribeFeed = deps.subscribeFeed
+  }
+
+  connect(): () => void {
+    if (!this.feedDisconnect) {
+      this.feedDisconnect = this.subscribeFeed(this.onFeedEvent)
+    }
+    return () => {
+      this.feedDisconnect?.()
+      this.feedDisconnect = null
+    }
+  }
+
+  subscribe = (onChange: () => void): (() => void) => {
+    this.listeners.add(onChange)
+    return () => {
+      this.listeners.delete(onChange)
+    }
+  }
+
+  getSnapshot = (): SessionListSnapshot => this.snapshot
+
+  async load(): Promise<void> {
+    const { sessions } = await this.client.list()
+    this.entries = new Map(sessions.map((entry) => [entry.sessionId, entry]))
+    this.loading = false
+    this.emit()
+  }
+
+  private onFeedEvent: SessionFeedListener = (event: SessionBusEvent) => {
+    if (event.kind !== 'index-changed') return
+    if (event.entry === null) {
+      this.entries.delete(event.sessionId)
+    } else {
+      this.entries.set(event.sessionId, event.entry)
+    }
+    this.emit()
+  }
+
+  private emit(): void {
+    this.snapshot = {
+      sessions: [...this.entries.values()].sort((a, b) =>
+        b.updatedAt.localeCompare(a.updatedAt),
+      ),
+      loading: this.loading,
+    }
+    for (const listener of [...this.listeners]) {
+      listener()
+    }
+  }
+}
diff --git a/apps/x/apps/renderer/src/lib/session-chat/test-fixtures.ts b/apps/x/apps/renderer/src/lib/session-chat/test-fixtures.ts
new file mode 100644
index 00000000..3df22529
--- /dev/null
+++ b/apps/x/apps/renderer/src/lib/session-chat/test-fixtures.ts
@@ -0,0 +1,171 @@
+import type { z } from 'zod'
+import type { SessionIndexEntry, SessionState } from '@x/shared/src/sessions.js'
+import type { ResolvedAgent, TurnEvent } from '@x/shared/src/turns.js'
+
+// Compact turn-event builders for renderer tests. Sequences must satisfy the
+// shared reducer's invariants (reduceTurn is what the store runs on them).
+
+export type TEvent = z.infer<typeof TurnEvent>
+
+export const TS = '2026-07-02T10:00:00Z'
+
+export const FIXTURE_AGENT: z.infer<typeof ResolvedAgent> = {
+  agentId: 'copilot',
+  systemPrompt: 'SYS',
+  model: { provider: 'openai', model: 'gpt-fixture' },
+  tools: [],
+}
+
+export function user(text: string) {
+  return { role: 'user' as const, content: text }
+}
+
+export function assistantText(text: string) {
+  return { role: 'assistant' as const, content: text }
+}
+
+export function toolCallPart(id: string, name: string, args: unknown = {}) {
+  return { type: 'tool-call' as const, toolCallId: id, toolName: name, arguments: args }
+}
+
+export function created(
+  turnId: string,
+  sessionId: string,
+  input: ReturnType<typeof user> = user('hello'),
+): TEvent {
+  return {
+    type: 'turn_created',
+    schemaVersion: 1,
+    turnId,
+    ts: TS,
+    sessionId,
+    agent: { requested: { agentId: 'copilot' }, resolved: FIXTURE_AGENT },
+    context: [],
+    input,
+    config: { autoPermission: false, humanAvailable: true, maxModelCalls: 20 },
+  }
+}
+
+export function requested(
+  turnId: string,
+  index: number,
+  refs: string[] = ['input'],
+): TEvent {
+  return {
+    type: 'model_call_requested',
+    turnId,
+    ts: TS,
+    modelCallIndex: index,
+    request: {
+      messages: refs,
+      parameters: {},
+    },
+  }
+}
+
+export function completed(
+  turnId: string,
+  index: number,
+  message: { role: 'assistant'; content: unknown },
+): TEvent {
+  return {
+    type: 'model_call_completed',
+    turnId,
+    ts: TS,
+    modelCallIndex: index,
+    message: message as never,
+    finishReason: 'stop',
+    usage: {},
+  }
+}
+
+export function invocation(turnId: string, toolCallId: string, name: string): TEvent {
+  return {
+    type: 'tool_invocation_requested',
+    turnId,
+    ts: TS,
+    toolCallId,
+    toolId: `builtin:${name}`,
+    toolName: name,
+    execution: 'sync',
+    input: {},
+  }
+}
+
+export function toolResult(
+  turnId: string,
+  toolCallId: string,
+  name: string,
+  output: unknown = 'ok',
+): TEvent {
+  return {
+    type: 'tool_result',
+    turnId,
+    ts: TS,
+    toolCallId,
+    toolName: name,
+    source: 'sync',
+    result: { output: output as never, isError: false },
+  }
+}
+
+export function turnCompleted(turnId: string, text = 'done'): TEvent {
+  return {
+    type: 'turn_completed',
+    turnId,
+    ts: TS,
+    output: assistantText(text),
+    finishReason: 'stop',
+    usage: {},
+  }
+}
+
+// A settled single-response turn.
+export function completedTurnLog(
+  turnId: string,
+  sessionId: string,
+  question: string,
+  answer: string,
+): TEvent[] {
+  return [
+    created(turnId, sessionId, user(question)),
+    requested(turnId, 0),
+    completed(turnId, 0, assistantText(answer)),
+    turnCompleted(turnId, answer),
+  ]
+}
+
+export function indexEntry(
+  sessionId: string,
+  overrides: Partial<SessionIndexEntry> = {},
+): SessionIndexEntry {
+  return {
+    sessionId,
+    title: `Session ${sessionId}`,
+    createdAt: TS,
+    updatedAt: TS,
+    turnCount: 1,
+    latestTurnStatus: 'completed',
+    ...overrides,
+  }
+}
+
+export function sessionState(
+  sessionId: string,
+  turnIds: string[],
+): SessionState {
+  return {
+    definition: { type: 'session_created', schemaVersion: 1, sessionId, ts: TS },
+    title: `Session ${sessionId}`,
+    turns: turnIds.map((turnId, i) => ({
+      turnId,
+      sessionSeq: i + 1,
+      agentId: 'copilot',
+      model: FIXTURE_AGENT.model,
+      ts: TS,
+    })),
+    latestTurnId: turnIds[turnIds.length - 1],
+    createdAt: TS,
+    updatedAt: TS,
+  }
+}
diff --git a/apps/x/apps/renderer/src/lib/session-chat/turn-view.test.ts b/apps/x/apps/renderer/src/lib/session-chat/turn-view.test.ts
new file mode 100644
index 00000000..342dc16f
--- /dev/null
+++ b/apps/x/apps/renderer/src/lib/session-chat/turn-view.test.ts
@@ -0,0 +1,333 @@
+import { describe, expect, it } from 'vitest'
+import { reduceTurn } from '@x/shared/src/turns.js'
+import { isChatMessage, isErrorMessage, isToolCall } from '@/lib/chat-conversation'
+import {
+  applyOverlay,
+  buildSessionChatState,
+  buildTurnConversation,
+  emptyOverlay,
+} from './turn-view'
+import {
+  TS,
+  assistantText,
+  completed,
+  completedTurnLog,
+  created,
+  invocation,
+  requested,
+  toolCallPart,
+  toolResult,
+  turnCompleted,
+  user,
+  type TEvent,
+} from './test-fixtures'
+
+const T1 = 'turn-1'
+const S1 = 'sess-1'
+
+function assistantCalls(...parts: Array<ReturnType<typeof toolCallPart>>) {
+  return { role: 'assistant' as const, content: parts }
+}
+
+describe('applyOverlay', () => {
+  it('accumulates text and reasoning deltas', () => {
+    let overlay = emptyOverlay()
+    overlay = applyOverlay(overlay, { type: 'text_delta', turnId: T1, modelCallIndex: 0, delta: 'he' })
+    overlay = applyOverlay(overlay, { type: 'text_delta', turnId: T1, modelCallIndex: 0, delta: 'y' })
+    overlay = applyOverlay(overlay, {
+      type: 'reasoning_delta',
+      turnId: T1,
+      modelCallIndex: 0,
+      delta: 'hmm',
+    })
+    expect(overlay.text).toBe('hey')
+    expect(overlay.reasoning).toBe('hmm')
+  })
+
+  it('clears text/reasoning when the canonical model response arrives', () => {
+    let overlay = { ...emptyOverlay(), text: 'streaming', reasoning: 'thinking' }
+    overlay = applyOverlay(overlay, completed(T1, 0, assistantText('final')))
+    expect(overlay.text).toBe('')
+    expect(overlay.reasoning).toBe('')
+  })
+
+  it('accumulates tool-output progress chunks and drops them on the terminal result', () => {
+    let overlay = emptyOverlay()
+    const progress = (chunk: string): TEvent => ({
+      type: 'tool_progress',
+      turnId: T1,
+      ts: TS,
+      toolCallId: 'tc1',
+      source: 'sync',
+      progress: { kind: 'tool-output', chunk },
+    })
+    overlay = applyOverlay(overlay, progress('$ ls\n'))
+    overlay = applyOverlay(overlay, progress('README.md\n'))
+    expect(overlay.toolOutput.tc1).toBe('$ ls\nREADME.md\n')
+
+    overlay = applyOverlay(overlay, toolResult(T1, 'tc1', 'executeCommand'))
+    expect(overlay.toolOutput.tc1).toBeUndefined()
+  })
+
+  it('ignores non-output progress payloads', () => {
+    const overlay = applyOverlay(emptyOverlay(), {
+      type: 'tool_progress',
+      turnId: T1,
+      ts: TS,
+      toolCallId: 'tc1',
+      source: 'sync',
+      progress: { pct: 50 },
+    })
+    expect(overlay.toolOutput).toEqual({})
+  })
+})
+
+describe('voice output', () => {
+  const delta = (d: string): Parameters<typeof applyOverlay>[1] =>
+    ({ type: 'text_delta', turnId: T1, modelCallIndex: 0, delta: d })
+
+  it('extracts completed <voice> blocks across split deltas', () => {
+    let overlay = emptyOverlay()
+    overlay = applyOverlay(overlay, delta('Sure! <voi'))
+    expect(overlay.voiceSegments).toEqual([])
+    overlay = applyOverlay(overlay, delta('ce>hello there</voice> and <voice>bye'))
+    expect(overlay.voiceSegments).toEqual(['hello there'])
+    overlay = applyOverlay(overlay, delta('</voice> done'))
+    expect(overlay.voiceSegments).toEqual(['hello there', 'bye'])
+  })
+
+  it('emits an early clause from a long open block, then the remainder on close', () => {
+    let overlay = emptyOverlay()
+    const longClause = 'Okay so the first thing I would look at here is the error message,'
+    overlay = applyOverlay(overlay, delta(`<voice>${longClause} because`))
+    // Open block crossed the early-speech threshold at a clause boundary.
+    expect(overlay.voiceSegments).toEqual([longClause])
+    overlay = applyOverlay(overlay, delta(' it tells you the root cause.</voice>'))
+    // Remainder only — the early clause is not repeated.
+    expect(overlay.voiceSegments).toEqual([longClause, 'because it tells you the root cause.'])
+  })
+
+  it('does not emit early clauses from short open blocks', () => {
+    let overlay = emptyOverlay()
+    overlay = applyOverlay(overlay, delta('<voice>Sure, one sec'))
+    expect(overlay.voiceSegments).toEqual([])
+    overlay = applyOverlay(overlay, delta('.</voice>'))
+    expect(overlay.voiceSegments).toEqual(['Sure, one sec.'])
+  })
+
+  it('keeps segments but resets the scan on model_call_completed', () => {
+    let overlay = emptyOverlay()
+    overlay = applyOverlay(overlay, delta('<voice>one</voice>'))
+    overlay = applyOverlay(overlay, completed(T1, 0, assistantText('<voice>one</voice>')))
+    expect(overlay.voiceSegments).toEqual(['one'])
+    expect(overlay.text).toBe('')
+    overlay = applyOverlay(overlay, delta('<voice>two</voice>'))
+    expect(overlay.voiceSegments).toEqual(['one', 'two'])
+  })
+
+  it('strips voice tags from the streaming message and exposes segments on state', () => {
+    const turn = reduceTurn([created(T1, S1), requested(T1, 0)])
+    let overlay = emptyOverlay()
+    overlay = applyOverlay(overlay, delta('Plan: <voice>speak this</voice> rest'))
+    const state = buildSessionChatState([turn], overlay)
+    expect(state.currentAssistantMessage).toBe('Plan: speak this rest')
+    expect(state.voiceSegments).toEqual(['speak this'])
+  })
+
+  it('strips voice tags from persisted assistant messages', () => {
+    const state = reduceTurn(
+      completedTurnLog(T1, S1, 'q', 'Sure. <voice>Here you go.</voice> Done.'),
+    )
+    const items = buildTurnConversation(state)
+    const assistant = items.find((i) => isChatMessage(i) && i.role === 'assistant')
+    expect(isChatMessage(assistant!) && assistant.content).toBe('Sure. Here you go. Done.')
+  })
+})
+
+describe('buildTurnConversation', () => {
+  it('maps user input, assistant text, and settled tool calls', () => {
+    const call = assistantCalls(toolCallPart('tc1', 'echo', { x: 1 }))
+    const state = reduceTurn([
+      created(T1, S1, user('run it')),
+      requested(T1, 0),
+      completed(T1, 0, call),
+      invocation(T1, 'tc1', 'echo'),
+      toolResult(T1, 'tc1', 'echo', { echoed: true }),
+      requested(T1, 1, [
+        'assistant:0',
+        'toolResult:tc1',
+      ]),
+      completed(T1, 1, assistantText('all done')),
+      turnCompleted(T1, 'all done'),
+    ])
+    const items = buildTurnConversation(state)
+    expect(items.map((i) => (isToolCall(i) ? `tool:${i.name}:${i.status}` : isChatMessage(i) ? `${i.role}` : 'x'))).toEqual([
+      'user',
+      'tool:echo:completed',
+      'assistant',
+    ])
+    const tool = items.find(isToolCall)
+    expect(tool?.result).toEqual({ echoed: true })
+    expect(tool?.input).toEqual({ x: 1 })
+  })
+
+  it('marks permission-pending tools pending and running tools running', () => {
+    const state = reduceTurn([
+      created(T1, S1),
+      requested(T1, 0),
+      completed(T1, 0, assistantCalls(toolCallPart('p1', 'executeCommand'), toolCallPart('r1', 'echo'))),
+      {
+        type: 'tool_permission_required',
+        turnId: T1,
+        ts: TS,
+        toolCallId: 'p1',
+        toolName: 'executeCommand',
+        request: { kind: 'command', commandNames: ['rm'] },
+      },
+      invocation(T1, 'r1', 'echo'),
+    ])
+    const items = buildTurnConversation(state).filter(isToolCall)
+    expect(items.map((i) => i.status)).toEqual(['pending', 'running'])
+  })
+
+  it('renders user attachments and a failed turn as an error item', () => {
+    const input = {
+      role: 'user' as const,
+      content: [
+        { type: 'text' as const, text: 'see file' },
+        { type: 'attachment' as const, path: '/tmp/a.png', filename: 'a.png', mimeType: 'image/png' },
+      ],
+    }
+    const state = reduceTurn([
+      created(T1, S1, input as never),
+      requested(T1, 0),
+      { type: 'model_call_failed', turnId: T1, ts: TS, modelCallIndex: 0, error: 'boom' },
+      { type: 'turn_failed', turnId: T1, ts: TS, error: 'boom', usage: {} },
+    ])
+    const items = buildTurnConversation(state)
+    expect(isChatMessage(items[0]) && items[0].attachments?.[0].filename).toBe('a.png')
+    expect(isErrorMessage(items[1]) && items[1].message).toBe('boom')
+  })
+})
+
+describe('buildSessionChatState', () => {
+  it('composes the conversation across turns and derives processing flags', () => {
+    const prior = reduceTurn(completedTurnLog('turn-1', S1, 'first?', 'first answer'))
+    const latest = reduceTurn([
+      created('turn-2', S1, user('second?')),
+      requested('turn-2', 0),
+    ])
+    const state = buildSessionChatState([prior, latest], emptyOverlay())
+    expect(
+      state.conversation.filter(isChatMessage).map((m) => m.content),
+    ).toEqual(['first?', 'first answer', 'second?'])
+    expect(state.isProcessing).toBe(true) // latest turn idle = actively working
+    expect(state.isThinking).toBe(true)
+  })
+
+  it('is settled (not processing) when the latest turn is terminal', () => {
+    const turn = reduceTurn(completedTurnLog(T1, S1, 'q', 'a'))
+    const state = buildSessionChatState([turn], emptyOverlay())
+    expect(state.isProcessing).toBe(false)
+    expect(state.isThinking).toBe(false)
+  })
+
+  it('exposes pending permissions as request events; waiting is not thinking', () => {
+    const turn = reduceTurn([
+      created(T1, S1),
+      requested(T1, 0),
+      completed(T1, 0, assistantCalls(toolCallPart('p1', 'executeCommand', { command: 'rm -rf /' }))),
+      {
+        type: 'tool_permission_required',
+        turnId: T1,
+        ts: TS,
+        toolCallId: 'p1',
+        toolName: 'executeCommand',
+        request: { kind: 'command', commandNames: ['rm'] },
+      },
+      {
+        type: 'turn_suspended',
+        turnId: T1,
+        ts: TS,
+        pendingPermissions: [
+          { toolCallId: 'p1', toolName: 'executeCommand', request: { kind: 'command', commandNames: ['rm'] } },
+        ],
+        pendingAsyncTools: [],
+        usage: {},
+      },
+    ])
+    const state = buildSessionChatState([turn], emptyOverlay())
+    const request = state.allPermissionRequests.get('p1')
+    expect(request).toMatchObject({
+      type: 'tool-permission-request',
+      toolCall: { toolCallId: 'p1', toolName: 'executeCommand' },
+      permission: { kind: 'command', commandNames: ['rm'] },
+    })
+    expect(state.isProcessing).toBe(true)
+    expect(state.isThinking).toBe(false)
+  })
+
+  it('maps human decisions to responses and classifier decisions to auto-decisions', () => {
+    const turn = reduceTurn([
+      created(T1, S1),
+      requested(T1, 0),
+      completed(T1, 0, assistantCalls(toolCallPart('h1', 'echo'), toolCallPart('c1', 'echo'))),
+      { type: 'tool_permission_required', turnId: T1, ts: TS, toolCallId: 'h1', toolName: 'echo', request: { kind: 'command', commandNames: ['x'] } },
+      { type: 'tool_permission_required', turnId: T1, ts: TS, toolCallId: 'c1', toolName: 'echo', request: { kind: 'command', commandNames: ['y'] } },
+      { type: 'tool_permission_resolved', turnId: T1, ts: TS, toolCallId: 'h1', decision: 'allow', source: 'human' },
+      { type: 'tool_permission_resolved', turnId: T1, ts: TS, toolCallId: 'c1', decision: 'deny', source: 'classifier', reason: 'risky' },
+      { type: 'tool_result', turnId: T1, ts: TS, toolCallId: 'c1', toolName: 'echo', source: 'runtime', result: { output: 'denied', isError: true } },
+      invocation(T1, 'h1', 'echo'),
+      toolResult(T1, 'h1', 'echo'),
+    ])
+    const state = buildSessionChatState([turn], emptyOverlay())
+    expect(state.permissionResponses.get('h1')).toBe('approve')
+    expect(state.autoPermissionDecisions.get('c1')).toMatchObject({
+      decision: 'deny',
+      reason: 'risky',
+    })
+  })
+
+  it('exposes pending ask-human calls with question and options', () => {
+    const turn = reduceTurn([
+      created(T1, S1),
+      requested(T1, 0),
+      completed(T1, 0, assistantCalls(toolCallPart('ah1', 'ask-human', { question: 'Deploy?', options: ['Yes', 'No'] }))),
+      {
+        type: 'tool_invocation_requested',
+        turnId: T1,
+        ts: TS,
+        toolCallId: 'ah1',
+        toolId: 'builtin:ask-human',
+        toolName: 'ask-human',
+        execution: 'async',
+        input: { question: 'Deploy?', options: ['Yes', 'No'] },
+      },
+    ])
+    const state = buildSessionChatState([turn], emptyOverlay())
+    expect(state.pendingAskHumanRequests.get('ah1')).toMatchObject({
+      query: 'Deploy?',
+      options: ['Yes', 'No'],
+    })
+    expect(state.isThinking).toBe(false) // waiting on the human, no shimmer
+  })
+
+  it('stitches live tool output onto the matching tool item', () => {
+    const turn = reduceTurn([
+      created(T1, S1),
+      requested(T1, 0),
+      completed(T1, 0, assistantCalls(toolCallPart('tc1', 'executeCommand'))),
+      invocation(T1, 'tc1', 'executeCommand'),
+    ])
+    const overlay = { ...emptyOverlay(), toolOutput: { tc1: 'partial output' } }
+    const state = buildSessionChatState([turn], overlay)
+    const tool = state.conversation.filter(isToolCall)[0]
+    expect(tool.streamingOutput).toBe('partial output')
+  })
+
+  it('surfaces streaming text as currentAssistantMessage', () => {
+    const turn = reduceTurn([created(T1, S1), requested(T1, 0)])
+    const state = buildSessionChatState([turn], { ...emptyOverlay(), text: 'typing…' })
+    expect(state.currentAssistantMessage).toBe('typing…')
+  })
+})
diff --git a/apps/x/apps/renderer/src/lib/session-chat/turn-view.ts b/apps/x/apps/renderer/src/lib/session-chat/turn-view.ts
new file mode 100644
index 00000000..0d5413c1
--- /dev/null
+++ b/apps/x/apps/renderer/src/lib/session-chat/turn-view.ts
@@ -0,0 +1,395 @@
+import type { z } from 'zod'
+import type {
+  AskHumanRequestEvent,
+  ToolPermissionAutoDecisionEvent,
+  ToolPermissionMetadata,
+  ToolPermissionRequestEvent,
+} from '@x/shared/src/runs.js'
+import {
+  deriveTurnStatus,
+  outstandingAsyncTools,
+  outstandingPermissions,
+  type ToolCallState,
+  type TurnState,
+  type TurnStreamEvent,
+} from '@x/shared/src/turns.js'
+import type {
+  ChatMessage,
+  ConversationItem,
+  ErrorMessage,
+  MessageAttachment,
+  PermissionResponse,
+  ToolCall,
+} from '@/lib/chat-conversation'
+
+// Pure derivations from reduced turn state (+ the ephemeral live overlay) to
+// the view shapes the existing chat components already consume. No IPC, no
+// React — everything here is unit-testable with plain state values.
+
+// ---------------------------------------------------------------------------
+// Live overlay: ephemeral streaming buffers (turn-runtime-design.md §14.4).
+// ---------------------------------------------------------------------------
+
+export type LiveOverlay = {
+  text: string
+  reasoning: string
+  toolOutput: Record<string, string>
+  // Speakable segments seen while streaming, in order, monotonically growing
+  // for the lifetime of the overlay (i.e. one active turn). Usually the
+  // contents of completed <voice>…</voice> blocks, but a long still-open
+  // block may emit an early clause (see EARLY_SPEECH_MIN_CHARS) so speech
+  // can start before the sentence finishes generating. Consumers speak
+  // segments beyond what they've already spoken; the overlay reset on turn
+  // switch starts a fresh list.
+  voiceSegments: string[]
+  // Scan cursor into `text` — everything before it has been checked for
+  // complete voice blocks.
+  voiceScanIndex: number
+  // Chars of the currently-open voice block's content already emitted as an
+  // early clause — the block's remainder (on close) excludes them.
+  voicePartialConsumed: number
+}
+
+export const emptyOverlay = (): LiveOverlay => ({
+  text: '',
+  reasoning: '',
+  toolOutput: {},
+  voiceSegments: [],
+  voiceScanIndex: 0,
+  voicePartialConsumed: 0,
+})
+
+// The model emits <voice>…</voice> around speakable text when voice output
+// is enabled; tags are never shown to the user.
+export function stripVoiceTags(text: string): string {
+  return text.replace(/<\/?voice>/g, '')
+}
+
+const VOICE_BLOCK = /<voice>([\s\S]*?)<\/voice>/g
+const VOICE_OPEN_TAG = '<voice>'
+
+// Early speech: once an open block has this many unconsumed chars, its last
+// complete clause is emitted immediately instead of waiting for </voice> —
+// TTS starts on the first clause while the rest of the sentence generates.
+const EARLY_SPEECH_MIN_CHARS = 60
+// ...but never emit a fragment shorter than this (prosody suffers).
+const EARLY_SPEECH_MIN_EMIT = 30
+// Clause boundaries (punctuation, optionally inside closing quote/paren,
+// followed by whitespace or end-of-buffer).
+const CLAUSE_BOUNDARY = /[,;:.!?…—]["')\]]*(?=\s|$)/g
+
+// Accumulates deltas; canonical durable events supersede the buffers (the
+// committed transcript now contains what was streaming).
+export function applyOverlay(overlay: LiveOverlay, event: TurnStreamEvent): LiveOverlay {
+  switch (event.type) {
+    case 'text_delta': {
+      const text = overlay.text + event.delta
+      // Extract complete voice blocks past the scan cursor. Incomplete
+      // blocks (opening tag seen, closing not yet) stay unconsumed until a
+      // later delta completes them. The first complete block may have had an
+      // early clause emitted while it was open — skip those chars.
+      const segments: string[] = []
+      let scanIndex = overlay.voiceScanIndex
+      let partialConsumed = overlay.voicePartialConsumed
+      VOICE_BLOCK.lastIndex = scanIndex
+      for (let m = VOICE_BLOCK.exec(text); m; m = VOICE_BLOCK.exec(text)) {
+        const content = m[1].slice(partialConsumed).trim()
+        partialConsumed = 0
+        if (content) segments.push(content)
+        scanIndex = m.index + m[0].length
+      }
+
+      // Early speech: if a voice block is still open and has accumulated a
+      // long unconsumed run, emit its last complete clause now — speech can
+      // start while the rest of the sentence is still generating.
+      const openIdx = text.indexOf(VOICE_OPEN_TAG, scanIndex)
+      if (openIdx !== -1) {
+        const unconsumed = text.slice(openIdx + VOICE_OPEN_TAG.length + partialConsumed)
+        if (unconsumed.length >= EARLY_SPEECH_MIN_CHARS) {
+          let lastBoundaryEnd = -1
+          CLAUSE_BOUNDARY.lastIndex = 0
+          for (let b = CLAUSE_BOUNDARY.exec(unconsumed); b; b = CLAUSE_BOUNDARY.exec(unconsumed)) {
+            lastBoundaryEnd = b.index + b[0].length
+          }
+          if (lastBoundaryEnd >= EARLY_SPEECH_MIN_EMIT) {
+            const clause = unconsumed.slice(0, lastBoundaryEnd).trim()
+            if (clause) segments.push(clause)
+            partialConsumed += lastBoundaryEnd
+          }
+        }
+      } else {
+        // No open block — any partial bookkeeping belongs to a block that
+        // has since closed.
+        partialConsumed = 0
+      }
+
+      return {
+        ...overlay,
+        text,
+        ...(segments.length > 0
+          ? { voiceSegments: [...overlay.voiceSegments, ...segments] }
+          : {}),
+        voiceScanIndex: scanIndex,
+        voicePartialConsumed: partialConsumed,
+      }
+    }
+    case 'reasoning_delta':
+      return { ...overlay, reasoning: overlay.reasoning + event.delta }
+    case 'model_call_completed':
+      return { ...overlay, text: '', reasoning: '', voiceScanIndex: 0, voicePartialConsumed: 0 }
+    case 'tool_progress': {
+      const progress = event.progress
+      if (
+        progress &&
+        typeof progress === 'object' &&
+        !Array.isArray(progress) &&
+        (progress as { kind?: unknown }).kind === 'tool-output' &&
+        typeof (progress as { chunk?: unknown }).chunk === 'string'
+      ) {
+        const chunk = (progress as { chunk: string }).chunk
+        return {
+          ...overlay,
+          toolOutput: {
+            ...overlay.toolOutput,
+            [event.toolCallId]: (overlay.toolOutput[event.toolCallId] ?? '') + chunk,
+          },
+        }
+      }
+      return overlay
+    }
+    case 'tool_result': {
+      if (!(event.toolCallId in overlay.toolOutput)) return overlay
+      const toolOutput = { ...overlay.toolOutput }
+      delete toolOutput[event.toolCallId]
+      return { ...overlay, toolOutput }
+    }
+    default:
+      return overlay
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Conversation items
+// ---------------------------------------------------------------------------
+
+type UserContent = TurnState['definition']['input']['content']
+
+function extractText(content: UserContent): string {
+  if (typeof content === 'string') return content
+  return content
+    .map((part) => (part.type === 'text' ? part.text : ''))
+    .filter(Boolean)
+    .join('\n')
+}
+
+function extractAttachments(content: UserContent): MessageAttachment[] | undefined {
+  if (typeof content === 'string') return undefined
+  const attachments = content.flatMap((part) =>
+    part.type === 'attachment'
+      ? [
+          {
+            path: part.path,
+            filename: part.filename,
+            mimeType: part.mimeType,
+            ...(part.size === undefined ? {} : { size: part.size }),
+          },
+        ]
+      : [],
+  )
+  return attachments.length > 0 ? attachments : undefined
+}
+
+function toolStatus(tc: ToolCallState): ToolCall['status'] {
+  if (tc.result) return 'completed'
+  if (tc.permission && !tc.permission.resolved) return 'pending'
+  return 'running'
+}
+
+// One turn's contribution to the conversation: the user input, then per
+// completed model call its text and tool calls (with live status/results).
+export function buildTurnConversation(state: TurnState): ConversationItem[] {
+  const items: ConversationItem[] = []
+  const turnId = state.definition.turnId
+  let seq = 0
+  const ts = () => Date.parse(state.definition.ts) + seq++
+
+  const userText = extractText(state.definition.input.content)
+  const attachments = extractAttachments(state.definition.input.content)
+  if (userText || attachments) {
+    items.push({
+      id: `${turnId}:user`,
+      role: 'user',
+      content: userText,
+      timestamp: ts(),
+      ...(attachments ? { attachments } : {}),
+    } satisfies ChatMessage)
+  }
+
+  const toolCallsById = new Map(state.toolCalls.map((tc) => [tc.toolCallId, tc]))
+  for (const call of state.modelCalls) {
+    if (call.response === undefined) continue
+    const content = call.response.content
+    // Voice tags are model-facing markup, never shown (parity with the
+    // legacy path's display-time strip).
+    const text = stripVoiceTags(
+      typeof content === 'string'
+        ? content
+        : content
+            .map((part) => (part.type === 'text' ? part.text : ''))
+            .filter(Boolean)
+            .join('\n'),
+    )
+    if (text) {
+      items.push({
+        id: `${turnId}:a${call.index}`,
+        role: 'assistant',
+        content: text,
+        timestamp: ts(),
+      } satisfies ChatMessage)
+    }
+    if (Array.isArray(content)) {
+      for (const part of content) {
+        if (part.type !== 'tool-call') continue
+        const tc = toolCallsById.get(part.toolCallId)
+        items.push({
+          id: part.toolCallId,
+          name: part.toolName,
+          input: part.arguments as ToolCall['input'],
+          ...(tc?.result ? { result: tc.result.result.output as ToolCall['result'] } : {}),
+          status: tc ? toolStatus(tc) : 'running',
+          timestamp: ts(),
+        } satisfies ToolCall)
+      }
+    }
+  }
+
+  if (state.terminal?.type === 'turn_failed') {
+    items.push({
+      id: `${turnId}:error`,
+      kind: 'error',
+      message: state.terminal.error,
+      timestamp: ts(),
+    } satisfies ErrorMessage)
+  }
+
+  return items
+}
+
+// ---------------------------------------------------------------------------
+// Session chat state (superset of the ChatTabViewState fields)
+// ---------------------------------------------------------------------------
+
+type PermMeta = z.infer<typeof ToolPermissionMetadata>
+
+export type SessionChatState = {
+  conversation: ConversationItem[]
+  currentAssistantMessage: string
+  // See LiveOverlay.voiceSegments.
+  voiceSegments: string[]
+  pendingAskHumanRequests: Map<string, z.infer<typeof AskHumanRequestEvent>>
+  allPermissionRequests: Map<string, z.infer<typeof ToolPermissionRequestEvent>>
+  permissionResponses: Map<string, PermissionResponse>
+  autoPermissionDecisions: Map<string, z.infer<typeof ToolPermissionAutoDecisionEvent>>
+  // Composer blocked / Stop shown until the latest turn settles (waiting on a
+  // permission or ask-human still counts as processing).
+  isProcessing: boolean
+  // Actively working (non-terminal, nothing waiting on the user) — drives the
+  // "Thinking…" shimmer; deliberately false under permission/ask-human cards.
+  isThinking: boolean
+}
+
+function toolCallPartOf(tc: ToolCallState) {
+  return {
+    type: 'tool-call' as const,
+    toolCallId: tc.toolCallId,
+    toolName: tc.toolName,
+    arguments: tc.input,
+  }
+}
+
+// Compose the whole session's conversation: prior (settled) turns plus the
+// latest turn, with the live overlay stitched onto the latest turn's items.
+export function buildSessionChatState(
+  turns: TurnState[],
+  overlay: LiveOverlay,
+): SessionChatState {
+  const conversation: ConversationItem[] = []
+  for (const turn of turns) {
+    conversation.push(...buildTurnConversation(turn))
+  }
+  for (let i = 0; i < conversation.length; i++) {
+    const item = conversation[i]
+    if ('name' in item && overlay.toolOutput[item.id]) {
+      conversation[i] = { ...item, streamingOutput: overlay.toolOutput[item.id] }
+    }
+  }
+
+  const latest = turns[turns.length - 1]
+  const status = latest ? deriveTurnStatus(latest) : undefined
+  const latestTurnId = latest?.definition.turnId ?? ''
+
+  const allPermissionRequests = new Map<string, z.infer<typeof ToolPermissionRequestEvent>>()
+  const permissionResponses = new Map<string, PermissionResponse>()
+  const autoPermissionDecisions = new Map<
+    string,
+    z.infer<typeof ToolPermissionAutoDecisionEvent>
+  >()
+  const pendingAskHumanRequests = new Map<string, z.infer<typeof AskHumanRequestEvent>>()
+
+  if (latest) {
+    for (const tc of outstandingPermissions(latest)) {
+      allPermissionRequests.set(tc.toolCallId, {
+        runId: latestTurnId,
+        type: 'tool-permission-request',
+        subflow: [],
+        toolCall: toolCallPartOf(tc),
+        permission: tc.permission?.required.request as PermMeta,
+      })
+    }
+    for (const tc of latest.toolCalls) {
+      const resolved = tc.permission?.resolved
+      if (!resolved) continue
+      if (resolved.source === 'human') {
+        permissionResponses.set(tc.toolCallId, resolved.decision === 'allow' ? 'approve' : 'deny')
+      } else if (resolved.source === 'classifier') {
+        autoPermissionDecisions.set(tc.toolCallId, {
+          runId: latestTurnId,
+          type: 'tool-permission-auto-decision',
+          subflow: [],
+          toolCallId: tc.toolCallId,
+          toolCall: toolCallPartOf(tc),
+          permission: tc.permission?.required.request as PermMeta,
+          decision: resolved.decision,
+          reason: resolved.reason ?? '',
+        })
+      }
+    }
+    for (const tc of outstandingAsyncTools(latest)) {
+      if (tc.toolName !== 'ask-human') continue
+      const input = (tc.input ?? {}) as { question?: unknown; options?: unknown }
+      pendingAskHumanRequests.set(tc.toolCallId, {
+        runId: latestTurnId,
+        type: 'ask-human-request',
+        toolCallId: tc.toolCallId,
+        subflow: [],
+        query: typeof input.question === 'string' ? input.question : '',
+        ...(Array.isArray(input.options) && input.options.every((o) => typeof o === 'string')
+          ? { options: input.options }
+          : {}),
+      })
+    }
+  }
+
+  const settled = status === 'completed' || status === 'failed' || status === 'cancelled'
+  return {
+    conversation,
+    currentAssistantMessage: stripVoiceTags(overlay.text),
+    voiceSegments: overlay.voiceSegments,
+    pendingAskHumanRequests,
+    allPermissionRequests,
+    permissionResponses,
+    autoPermissionDecisions,
+    isProcessing: latest !== undefined && !settled,
+    isThinking: status === 'idle',
+  }
+}
diff --git a/apps/x/apps/renderer/src/lib/tour-sounds.ts b/apps/x/apps/renderer/src/lib/tour-sounds.ts
new file mode 100644
index 00000000..cc6bf62d
--- /dev/null
+++ b/apps/x/apps/renderer/src/lib/tour-sounds.ts
@@ -0,0 +1,109 @@
+/**
+ * Tiny synthesized sound effects for the product tour — oar splashes, dock
+ * bumps, and an arrival fanfare. Everything is generated with Web Audio
+ * oscillators/noise so no audio assets are needed. All methods fail silently
+ * if audio is unavailable.
+ */
+export class TourSounds {
+    private ctx: AudioContext | null = null
+    private master: GainNode | null = null
+
+    private ensure(): AudioContext | null {
+        try {
+            if (!this.ctx) {
+                this.ctx = new AudioContext()
+                this.master = this.ctx.createGain()
+                this.master.gain.value = 0.5
+                this.master.connect(this.ctx.destination)
+            }
+            if (this.ctx.state === 'suspended') void this.ctx.resume()
+            return this.ctx
+        } catch {
+            return null
+        }
+    }
+
+    /** Short filtered-noise burst with a falling pitch — an oar dipping. */
+    splash() {
+        const ctx = this.ensure()
+        if (!ctx || !this.master) return
+        const dur = 0.22
+        const noise = ctx.createBufferSource()
+        const buffer = ctx.createBuffer(1, Math.ceil(ctx.sampleRate * dur), ctx.sampleRate)
+        const data = buffer.getChannelData(0)
+        for (let i = 0; i < data.length; i++) data[i] = Math.random() * 2 - 1
+        noise.buffer = buffer
+
+        const filter = ctx.createBiquadFilter()
+        filter.type = 'bandpass'
+        filter.Q.value = 1.2
+        filter.frequency.setValueAtTime(1600, ctx.currentTime)
+        filter.frequency.exponentialRampToValueAtTime(350, ctx.currentTime + dur)
+
+        const gain = ctx.createGain()
+        gain.gain.setValueAtTime(0.14, ctx.currentTime)
+        gain.gain.exponentialRampToValueAtTime(0.001, ctx.currentTime + dur)
+
+        noise.connect(filter).connect(gain).connect(this.master)
+        noise.start()
+        noise.stop(ctx.currentTime + dur)
+    }
+
+    /** Soft low thump — the boat nudging a dock. */
+    bump() {
+        const ctx = this.ensure()
+        if (!ctx || !this.master) return
+        const osc = ctx.createOscillator()
+        osc.type = 'sine'
+        osc.frequency.setValueAtTime(150, ctx.currentTime)
+        osc.frequency.exponentialRampToValueAtTime(70, ctx.currentTime + 0.18)
+        const gain = ctx.createGain()
+        gain.gain.setValueAtTime(0.2, ctx.currentTime)
+        gain.gain.exponentialRampToValueAtTime(0.001, ctx.currentTime + 0.25)
+        osc.connect(gain).connect(this.master)
+        osc.start()
+        osc.stop(ctx.currentTime + 0.3)
+    }
+
+    /** Gentle high blip — an email landing in the boat. */
+    ding() {
+        const ctx = this.ensure()
+        if (!ctx || !this.master) return
+        const osc = ctx.createOscillator()
+        osc.type = 'sine'
+        osc.frequency.setValueAtTime(880, ctx.currentTime)
+        osc.frequency.exponentialRampToValueAtTime(1320, ctx.currentTime + 0.05)
+        const gain = ctx.createGain()
+        gain.gain.setValueAtTime(0.08, ctx.currentTime)
+        gain.gain.exponentialRampToValueAtTime(0.001, ctx.currentTime + 0.3)
+        osc.connect(gain).connect(this.master)
+        osc.start()
+        osc.stop(ctx.currentTime + 0.35)
+    }
+
+    /** Little four-note arpeggio for the tour finale. */
+    fanfare() {
+        const ctx = this.ensure()
+        if (!ctx || !this.master) return
+        const notes = [523.25, 659.25, 783.99, 1046.5] // C5 E5 G5 C6
+        notes.forEach((freq, i) => {
+            const start = ctx.currentTime + i * 0.13
+            const osc = ctx.createOscillator()
+            osc.type = 'triangle'
+            osc.frequency.value = freq
+            const gain = ctx.createGain()
+            gain.gain.setValueAtTime(0.0001, start)
+            gain.gain.exponentialRampToValueAtTime(0.16, start + 0.02)
+            gain.gain.exponentialRampToValueAtTime(0.001, start + (i === notes.length - 1 ? 0.7 : 0.3))
+            osc.connect(gain).connect(this.master!)
+            osc.start(start)
+            osc.stop(start + 0.8)
+        })
+    }
+
+    dispose() {
+        this.ctx?.close().catch(() => {})
+        this.ctx = null
+        this.master = null
+    }
+}
diff --git a/apps/x/apps/renderer/src/main.tsx b/apps/x/apps/renderer/src/main.tsx
index 7999061d..ddd4c27e 100644
--- a/apps/x/apps/renderer/src/main.tsx
+++ b/apps/x/apps/renderer/src/main.tsx
@@ -6,6 +6,7 @@ import { PostHogProvider } from 'posthog-js/react'
 import type { CaptureResult } from 'posthog-js'
 import { ThemeProvider } from '@/contexts/theme-context'
 import { configureAnalyticsContext } from './lib/analytics'
+import { VideoPopout } from '@/components/video-popout'
 
 // Fetch the stable installation ID from main so renderer + main share one
 // PostHog distinct_id. Falls back to PostHog's auto-generated anonymous ID
@@ -57,4 +58,14 @@ async function bootstrap() {
   // The loaded callback applies api_url/app_version once PostHog has initialized.
 }
 
-bootstrap()
+// The video-mode popout window loads the same bundle with a hash route and
+// renders only the mini-call UI — no analytics or app bootstrap needed.
+if (window.location.hash === '#video-popout') {
+  createRoot(document.getElementById('root')!).render(
+    <StrictMode>
+      <VideoPopout />
+    </StrictMode>,
+  )
+} else {
+  bootstrap()
+}
diff --git a/apps/x/apps/renderer/src/test/setup.ts b/apps/x/apps/renderer/src/test/setup.ts
new file mode 100644
index 00000000..a9d0dd31
--- /dev/null
+++ b/apps/x/apps/renderer/src/test/setup.ts
@@ -0,0 +1 @@
+import '@testing-library/jest-dom/vitest'
diff --git a/apps/x/apps/renderer/vite.config.ts b/apps/x/apps/renderer/vite.config.ts
index 9bcca968..20b2b43b 100644
--- a/apps/x/apps/renderer/vite.config.ts
+++ b/apps/x/apps/renderer/vite.config.ts
@@ -1,5 +1,5 @@
 import path from "path"
-import { defineConfig } from 'vite'
+import { defineConfig } from 'vitest/config'
 import react from '@vitejs/plugin-react'
 import tailwindcss from '@tailwindcss/vite'
 
@@ -18,4 +18,10 @@ export default defineConfig({
   build: {
     outDir: 'dist',
   },
+  test: {
+    environment: 'jsdom',
+    setupFiles: ['./src/test/setup.ts'],
+    include: ['src/**/*.test.{ts,tsx}'],
+    css: false,
+  },
 })
diff --git a/apps/x/package.json b/apps/x/package.json
index 5d875653..d0931dc7 100644
--- a/apps/x/package.json
+++ b/apps/x/package.json
@@ -12,7 +12,11 @@
     "deps": "npm run shared && npm run core && npm run preload",
     "main": "wait-on http://localhost:5173 && cd apps/main && npm run build && npm run start",
     "lint": "eslint .",
-    "lint:fix": "eslint . --fix"
+    "lint:fix": "eslint . --fix",
+    "test": "npm run shared && npm run test:shared && npm run test:core && npm run test:renderer",
+    "test:shared": "cd packages/shared && npm test",
+    "test:core": "cd packages/core && npm test",
+    "test:renderer": "cd apps/renderer && npm test"
   },
   "devDependencies": {
     "@eslint/js": "^9.39.2",
@@ -26,4 +30,4 @@
     "typescript-eslint": "^8.50.1",
     "wait-on": "^9.0.3"
   }
-}
\ No newline at end of file
+}
diff --git a/apps/x/packages/core/docs/session-design.md b/apps/x/packages/core/docs/session-design.md
new file mode 100644
index 00000000..2694f9e9
--- /dev/null
+++ b/apps/x/packages/core/docs/session-design.md
@@ -0,0 +1,561 @@
+# Session Layer Technical Specification
+
+Status: design complete for the session layer v1. No implementation exists
+yet.
+
+This document specifies the session layer that sits above the turn runtime
+defined in `turn-runtime-design.md`. That document is assumed context; this
+one does not restate turn semantics.
+
+## 1. Goals
+
+The session layer must:
+
+1. Own conversations composed of ordered turns.
+2. Persist each session as one append-only JSONL file with the same
+   validation discipline as turn files.
+3. Enforce one active turn per session.
+4. Assemble each turn's context as a reference to the previous turn.
+5. Maintain an in-memory index for listing, sorting, and filtering sessions,
+   updated write-through and rebuilt by scanning at startup.
+6. Route external inputs — permission decisions, ask-human answers, async
+   tool results — to the correct turn through dedicated APIs.
+7. Forward live turn events to the renderer over IPC.
+8. Provide headless standalone turns outside any session.
+
+## 2. Non-goals (v1)
+
+- Queued user messages. The committed future shape is in section 12.1.
+- Steering / mid-turn message injection (section 12.4).
+- Session-scoped permission grants ("always allow for this chat"); every
+  applicable tool call prompts in v1 (section 12.2).
+- Context compaction; a viable mechanism sketch is recorded in section 12.3.
+  V1 behavior on context overflow is the turn-level model failure.
+- LLM auto-titling (section 12.6).
+- A persisted index cache; startup always scans (section 12.5).
+- Cross-process coordination. A single main process is enforced.
+- Data migration from the current runs system. Old conversations are not
+  converted; the old code path remains readable until it is deleted.
+- Session list pagination. The index is in-memory and shipped whole.
+
+## 3. Terminology
+
+A **session** is a durable, ordered chain of turns plus presentation
+metadata (title). Conversation content lives exclusively in turn files; the
+session file stores turn references with denormalized metadata.
+
+The **index** is an in-memory projection over all session files, used for
+the session list UI. It is never a source of truth.
+
+A **standalone turn** is a turn with `sessionId: null`, created outside any
+session by headless callers. Standalone turns do not appear in the index.
+
+## 4. Storage design
+
+### 4.1 File location
+
+Session files live under:
+
+```text
+WorkDir/storage/sessions/YYYY/MM/DD/<sessionId>.jsonl
+```
+
+Session IDs come from the existing
+`IMonotonicallyIncreasingIdGenerator`, and the repository derives the
+date-partitioned path from the ID exactly as the turn repository does,
+including format validation and path-traversal rejection.
+
+### 4.2 File rules
+
+Identical discipline to turn files:
+
+- The first line is always `session_created` with `schemaVersion: 1`.
+- Every event contains `sessionId` and an ISO timestamp `ts`.
+- Physical line order is authoritative.
+- Reads validate every line strictly; any malformed line makes the session
+  corrupt; no truncation, repair, or skipping.
+- Unknown schema versions and unknown event types fail loudly. Future
+  additive event types (queueing, grants, compaction) arrive as a schema
+  version bump; the reducer will accept old and new versions and write the
+  newest.
+- Appends are awaited but not explicitly `fsync`ed.
+
+### 4.3 Repository contract
+
+```ts
+interface ISessionRepo {
+  create(event: SessionCreated): Promise<void>;
+  read(sessionId: string): Promise<SessionEvent[]>;
+  append(sessionId: string, events: SessionEvent[]): Promise<void>;
+  withLock<T>(sessionId: string, fn: () => Promise<T>): Promise<T>;
+  listSessionIds(): Promise<string[]>;
+  delete(sessionId: string): Promise<void>;
+}
+```
+
+- `create` fails if the file exists.
+- `listSessionIds` enumerates the partition directories for the startup
+  scan.
+- `delete` removes the session file only. Turn files referenced by the
+  session are left in place as harmless orphans (see section 9, deletion).
+- `withLock` is in-process per-session exclusion, mirroring the turn repo.
+
+## 5. Event schemas
+
+All session event schemas live in `@x/shared` alongside the turn schemas.
+
+```ts
+interface BaseSessionEvent {
+  sessionId: string;
+  ts: string;
+}
+
+interface SessionCreated extends BaseSessionEvent {
+  type: "session_created";
+  schemaVersion: 1;
+  title?: string;
+}
+
+interface SessionTurnAppended extends BaseSessionEvent {
+  type: "turn_appended";
+  turnId: string;
+  sessionSeq: number; // 1-based position of the turn in the session
+  agentId: string;
+  model: ModelDescriptor; // resolved provider/model for the turn
+}
+
+interface SessionTitleChanged extends BaseSessionEvent {
+  type: "title_changed";
+  title: string;
+}
+
+type SessionEvent =
+  | SessionCreated
+  | SessionTurnAppended
+  | SessionTitleChanged;
+```
+
+`turn_appended` deliberately denormalizes `agentId` and `model` from the
+turn so the index can fold from session files without opening turn files.
+The turn file remains authoritative for the turn's actual configuration.
+
+The session file never mirrors turn outcomes. Turn lifecycle facts live only
+in turn files; deriving "is this session busy/suspended/failed" reads the
+latest turn (section 8).
+
+## 6. Session reducer
+
+`@x/shared` owns one pure reducer shared by core and renderer:
+
+```ts
+function reduceSession(events: SessionEvent[]): SessionState;
+
+interface SessionState {
+  definition: SessionCreated;
+  title?: string;
+  turns: Array<{
+    turnId: string;
+    sessionSeq: number;
+    agentId: string;
+    model: ModelDescriptor;
+    ts: string;
+  }>;
+  latestTurnId?: string;
+  createdAt: string; // definition.ts
+  updatedAt: string; // ts of the last event
+}
+```
+
+Invariants (violations throw, as with the turn reducer):
+
+- `session_created` is present, first, and unique.
+- All event `sessionId` values match.
+- `sessionSeq` is strictly increasing starting at 1, with no gaps.
+- `turnId` values are unique.
+- Unsupported schema versions and unknown event types fail loudly.
+
+## 7. Write ordering and consistency
+
+Per user message, the session layer performs, in order:
+
+1. `turnRuntime.createTurn(...)` — the turn file is created.
+2. `sessionRepo.append(turn_appended)` — the session references the turn.
+3. `advanceTurn(...)` — execution begins.
+
+Rules:
+
+- A crash between steps 1 and 2 leaves an orphan turn file: unreferenced,
+  never advanced, and benign. Turns are only ever found by reference, so an
+  orphan is invisible. V1 does not garbage-collect orphans.
+- The reverse order is forbidden: a `turn_appended` referencing a turn file
+  that was never created would be a dangling reference, which is corruption.
+- Step 2 precedes step 3 so that a turn that is executing is always already
+  referenced by its session.
+- Session-file appends happen under the session lock; turn-file appends are
+  the turn runtime's concern.
+
+## 8. In-memory index
+
+### 8.1 Shape
+
+```ts
+interface SessionIndexEntry {
+  sessionId: string;
+  title?: string;
+  createdAt: string;
+  updatedAt: string;
+  turnCount: number;
+  lastAgentId?: string;
+  lastModel?: ModelDescriptor;
+  latestTurnId?: string;
+  latestTurnStatus:
+    | "none" // session has no turns yet
+    | "completed"
+    | "failed"
+    | "cancelled"
+    | "suspended" // durable suspension: pending permissions/async tools
+    | "idle"; // non-terminal, not suspended: interrupted by a crash
+}
+```
+
+`latestTurnStatus` is derived from the latest turn's reduced state, using
+the same derivation everywhere: terminal event kind if present, else
+`suspended` if a suspension with outstanding work is the resting state, else
+`idle`. Whether a turn is *actively processing right now* is not in the
+index; it is ephemeral bus state (`turn-processing-start/end`), per the turn
+specification.
+
+### 8.2 Startup scan
+
+1. `listSessionIds()`.
+2. For each session: read and reduce the session file, producing the entry's
+   session-derived fields.
+3. For each session with turns: read and reduce the latest turn file only,
+   producing `latestTurnStatus`.
+4. Publish the completed index to the renderer.
+
+A corrupt session file or corrupt latest-turn file does not abort startup:
+the entry is surfaced in an errored state (identifiable in the UI, excluded
+from normal interaction) and the scan continues.
+
+### 8.3 Maintenance
+
+- Every session mutation updates the entry in the same code path that
+  appends to the session file (write-through), then publishes a
+  `session-index-changed` event on the application bus.
+- When an `advanceTurn` outcome settles, the session layer updates
+  `latestTurnStatus` and publishes `session-index-changed`.
+- There is no filesystem watcher. Out-of-band edits to session or turn files
+  while the app runs are unsupported; offline changes are reconciled by the
+  next startup scan.
+- The main process enforces single-instance via
+  `app.requestSingleInstanceLock()`; all locking in both layers is
+  in-process.
+
+## 9. Sessions API
+
+```ts
+interface SendMessageConfig {
+  agent: RequestedAgent; // agent id + optional model override
+  autoPermission?: boolean; // default false
+  maxModelCalls?: number; // default per turn spec
+}
+
+interface ISessions {
+  createSession(input?: { title?: string }): Promise<string>;
+  listSessions(): SessionIndexEntry[];
+  getSession(sessionId: string): Promise<SessionState>;
+  getTurn(turnId: string): Promise<Turn>; // passthrough to turn runtime
+
+  sendMessage(
+    sessionId: string,
+    input: UserMessage,
+    config: SendMessageConfig,
+  ): Promise<{ turnId: string }>;
+
+  respondToPermission(
+    turnId: string,
+    toolCallId: string,
+    decision: "allow" | "deny",
+    metadata?: JsonValue,
+  ): Promise<void>;
+
+  respondToAskHuman(
+    turnId: string,
+    toolCallId: string,
+    answer: string,
+  ): Promise<void>;
+
+  deliverAsyncToolResult(
+    turnId: string,
+    toolCallId: string,
+    result: ToolResultData,
+  ): Promise<void>;
+
+  stopTurn(turnId: string, reason?: string): Promise<void>;
+  resumeTurn(sessionId: string): Promise<void>;
+
+  setTitle(sessionId: string, title: string): Promise<void>;
+  deleteSession(sessionId: string): Promise<void>;
+}
+```
+
+### 9.1 sendMessage
+
+Under the per-session lock:
+
+1. Read and reduce the session.
+2. If the session has turns, read and reduce the latest turn. If it is
+   non-terminal — running, suspended, or idle — reject with a typed
+   `TurnNotSettledError`. There is no implicit queueing, steering, or
+   cancel-and-replace, and no implicit routing to a pending ask-human.
+3. Build context: `[]` (inline, empty) for the first turn, else
+   `{ previousTurnId: latestTurnId }`.
+4. Create the turn: config from `SendMessageConfig` lands on the turn
+   (`humanAvailable: true` always, for session turns). Sessions store no
+   configuration; every turn is self-describing.
+5. Append `turn_appended` with the next `sessionSeq` and denormalized
+   agent/model.
+6. If the session has no title, append `title_changed` derived from the
+   truncated first user message.
+7. Start `advanceTurn` in the background; consume its events (section 10).
+8. Return `{ turnId }` immediately. The renderer follows progress through
+   events, not the return value.
+
+Continuation after a failed or exhausted (`code: "model-call-limit"`) turn
+is just `sendMessage`: failed turns are terminal, and the new turn's context
+reference includes the failed turn's structurally complete transcript.
+
+### 9.2 External inputs
+
+`respondToPermission`, `respondToAskHuman`, and `deliverAsyncToolResult`
+each translate to one `advanceTurn(turnId, input)` call with the
+corresponding `TurnExternalInput`. `respondToAskHuman` is the dedicated
+endpoint for the `ask-human` tool — a thin wrapper over
+`async_tool_result` — and is deliberately separate from `sendMessage`.
+Validation (unknown call, already-resolved call, terminal turn) is the turn
+runtime's job; the session layer passes its errors through.
+
+### 9.3 stopTurn and resumeTurn
+
+- `stopTurn` cancels via the turn runtime: aborting the active invocation's
+  signal if one is running, else advancing a suspended turn with a `cancel`
+  input.
+- `resumeTurn` re-enters the latest turn with no input — the turn spec's
+  recovery entry point — for turns left `idle` by a crash. There is no
+  automatic resume sweep at startup: recovery re-issues interrupted model
+  calls, so resumption must be an explicit user action. Suspended turns need
+  no resumption; they advance when their inputs arrive.
+
+### 9.4 Deletion
+
+`deleteSession` removes the session file and the index entry, and publishes
+`session-index-changed`. Referenced turn files are retained as orphans:
+turns are only discoverable by reference, so orphaned files are inert.
+Deleting an entity's file is not a violation of append-only discipline,
+which governs mutation of live logs, not their removal.
+
+## 10. Event forwarding and live UI
+
+1. For every `advanceTurn` it initiates, the session layer consumes
+   `TurnExecution.events` and forwards each `TurnStreamEvent` — tagged with
+   `sessionId` — through the application bus to renderer windows over one
+   IPC channel (`sessions:events`).
+2. When `outcome` settles, the session layer updates the index entry and
+   publishes `session-index-changed`.
+3. The renderer follows the turn spec's historical/live pattern: fetch
+   turns via `getTurn`, run the shared `reduceTurn` per turn, compose the
+   session timeline turn-by-turn (each turn renders its input and its own
+   activity; the referenced prefix is never re-rendered from context),
+   append live durable events and re-reduce, and keep text/reasoning deltas
+   in an ephemeral overlay cleared by canonical responses.
+4. Pending approvals and ask-human prompts render from the suspended turn's
+   reduced state, so they survive restarts without any session-layer
+   bookkeeping.
+
+## 11. Headless standalone turns
+
+A helper covers the non-session callers (background tasks, live notes,
+knowledge pipelines, scheduled agents):
+
+```ts
+function runHeadlessTurn(input: {
+  agent: RequestedAgent;
+  context?: ConversationMessage[]; // inline; defaults to []
+  input: UserMessage;
+  maxModelCalls?: number;
+  signal?: AbortSignal;
+}): Promise<TurnOutcome>;
+```
+
+- `sessionId: null`, `autoPermission: true`, `humanAvailable: false`.
+- Creates the turn, advances to the first settled outcome, and returns it.
+- Standalone turns never appear in the index; callers keep their own turn
+  IDs if they need history.
+
+## 12. Deferred designs with committed shapes
+
+These are not implemented in v1. Their shapes are recorded so v1 decisions
+stay compatible; each arrives as a session schema version bump.
+
+### 12.1 Queued messages
+
+```ts
+{ type: "message_queued", queueId, message, ts }
+{ type: "queued_message_replaced", queueId, message, ts } // edit
+{ type: "queued_message_removed", queueId, ts }           // cancel
+// promotion: turn_appended gains consumedQueueIds?: string[]
+```
+
+The reducer derives the pending queue by supersession. Promotion rules
+(collapse-into-one-turn vs FIFO, behavior after failed turns) are decided
+together with steering.
+
+### 12.2 Session permission grants
+
+```ts
+{ type: "permission_grant_added", grantId, toolId, ts }
+{ type: "permission_grant_removed", grantId, ts }
+```
+
+The injected `IPermissionChecker` consults a session-keyed grants view
+before answering `required: true`. V1 grants would be blanket per-toolId;
+argument-pattern matchers are a separate, security-sensitive project.
+
+### 12.3 Compaction (mechanism sketch)
+
+Compaction requires zero turn-schema change. A session-level compaction
+event records `{ compactionId, summary, firstKeptTurnId }`; the next turn
+after a compaction uses **inline** context (summary message + kept
+transcript), which restarts the reference chain and bounds resolution depth
+by construction. Trigger policy and summarizer design are unspecified.
+
+### 12.4 Steering
+
+Rides the queue events with a different promotion rule, and additionally
+requires a turn-level `steer` external input (a turn schema bump) with an
+injection boundary after tool-batch completion. Recorded here so the session
+design does not foreclose it.
+
+### 12.5 Persisted index cache
+
+If the startup scan ever gets slow, a single cache file keyed by file
+mtimes can be added. It is a rebuildable cache, never a source of truth:
+missing, stale, or invalid means rebuild from session files.
+
+### 12.6 Auto-titling
+
+An LLM-generated title replacing the truncated-first-message default,
+appended as an ordinary `title_changed` event.
+
+## 13. Required test scenarios
+
+All tests use the in-memory/mocked turn runtime and repo fakes.
+
+### 13.1 Reducer
+
+- Valid event sequences reduce to expected state.
+- Every invariant violation throws: missing/duplicate `session_created`,
+  mismatched sessionId, non-monotonic or gapped `sessionSeq`, duplicate
+  turnIds, unknown type/version.
+- Title folding: default, explicit changes, last-wins.
+
+### 13.2 Repository
+
+- Date-partitioned paths, ID validation, create-if-absent.
+- Strict line validation on read; corrupt files rejected whole.
+- `listSessionIds` enumeration across partitions.
+- Deletion removes only the session file.
+
+### 13.3 sendMessage
+
+- First turn: inline `[]` context, `sessionSeq: 1`, default title appended.
+- Subsequent turns: context references the latest turn; seq increments.
+- Rejection with `TurnNotSettledError` when the latest turn is running,
+  suspended, or idle — and success after it settles.
+- Continuation after failed and model-call-limit turns.
+- Concurrent sendMessage calls serialize under the session lock; exactly
+  one wins, the other rejects.
+- Config lands on the turn; the session file stores only denormalized
+  agent/model on `turn_appended`.
+
+### 13.4 Ordering and crash simulation
+
+- Simulated crash between `createTurn` and `turn_appended`: orphan turn
+  file, session unchanged, retry produces a fresh turn.
+- `turn_appended` is present before the first advance begins.
+
+### 13.5 External inputs
+
+- Permission decision, ask-human answer, and async result each advance the
+  correct turn with the correct input type.
+- Turn-runtime rejections (unknown call, terminal turn) pass through.
+- `sendMessage` never routes to ask-human.
+
+### 13.6 Index
+
+- Startup fold matches write-through state for the same history.
+- Latest-turn status derivation for every status value.
+- Corrupt session file yields an errored entry without aborting the scan.
+- Mutations publish `session-index-changed`; deletion removes the entry.
+
+### 13.7 Event forwarding
+
+- Forwarded events are tagged with sessionId and arrive in order.
+- Outcome settlement updates `latestTurnStatus`.
+
+### 13.8 Headless
+
+- Standalone turns: `sessionId: null`, auto permission, human unavailable,
+  absent from the index.
+
+## 14. Suggested module layout
+
+```text
+apps/x/packages/shared/src/sessions.ts   # event schemas, reducer, index types
+
+apps/x/packages/core/src/sessions/
+  sessions.ts      # ISessions implementation
+  repo.ts          # ISessionRepo contract
+  fs-repo.ts       # filesystem implementation
+  index.ts         # in-memory index + startup scan
+  headless.ts      # runHeadlessTurn
+```
+
+Awilix registration mirrors the turn runtime: singleton scope, PROXY
+constructor injection, no container resolution from inside the classes.
+
+## 15. Integration sequence
+
+The rollout is staged as commits on one branch (squash-merge acceptable);
+old and new stacks coexist briefly but never share state, and no data is
+migrated:
+
+1. `@x/shared`: turn + session schemas and reducers.
+2. Turn runtime + fs turn repo (unit tests only, wired to nothing).
+3. Session layer + index (unit tests only).
+4. Bridges: agent resolver, context resolver, tool runner, permission
+   checker/classifier — adapted from the `new-runtime` reference
+   implementation where applicable.
+5. IPC (`sessions:*`) + renderer swap: Copilot chat UI moves to the
+   sessions API.
+6. Headless callers move to `runHeadlessTurn`.
+7. Delete the old runs runtime.
+
+## 16. Implementation acceptance criteria
+
+The session layer is implementation-complete only when:
+
+1. Session event schemas and `reduceSession` live in `@x/shared` and are
+   consumed unchanged by core and renderer.
+2. Session files follow the partitioned append-only JSONL layout with
+   strict validation.
+3. Turn-file-first write ordering is enforced; orphan turns are benign.
+4. `sendMessage` rejects non-terminal latest turns with a typed error; no
+   implicit queueing, steering, or ask-human routing exists.
+5. Ask-human answers flow only through the dedicated endpoint.
+6. The index is write-through with a startup scan, no watcher, and no
+   persisted cache; single-instance is enforced.
+7. Deletion removes only the session file.
+8. Headless callers run standalone turns and appear nowhere in the index.
+9. All required test scenarios pass with mocked dependencies.
diff --git a/apps/x/packages/core/docs/turn-runtime-design.md b/apps/x/packages/core/docs/turn-runtime-design.md
new file mode 100644
index 00000000..d199fabe
--- /dev/null
+++ b/apps/x/packages/core/docs/turn-runtime-design.md
@@ -0,0 +1,1887 @@
+# Turn Runtime Technical Specification
+
+Status: implemented and live. All chat, background, and knowledge callers
+run on this runtime; the legacy runs runtime remains only for code-mode
+sessions (see the carve-out section in the repo-root `AGENTS.md`). The
+companion session layer is specified in `session-design.md`.
+
+This document specifies a new turn-oriented agent loop for `@x/core`. It is
+intended to replace the behavioral responsibilities of the current run runtime
+eventually, but migration and replacement are explicitly outside the initial
+implementation scope.
+
+The design was developed independently of sessions. Session storage,
+conversation ordering, queued user messages, context compaction, and selection
+of the next active turn will be designed separately.
+
+## 1. Goals
+
+The turn runtime must:
+
+1. Execute one complete agent turn from one user input.
+2. Repeatedly call a model and process tool calls until the model produces a
+   final response, the turn suspends, or the turn reaches a terminal outcome.
+3. Persist every durable fact to one append-only JSONL file per turn.
+4. Support turns that do not belong to a session.
+5. Support suspension for human permission decisions and externally executed
+   asynchronous tools.
+6. Recover deterministically from the durable log after a process restart.
+7. Keep all runtime dependencies explicit and injectable.
+8. Keep the core loop small and focused on flow control.
+9. Expose normalized live events without coupling turn correctness to event
+   consumption.
+10. Make historical turns reconstructable for the UI and other consumers.
+
+## 2. Non-goals
+
+The first implementation will not include:
+
+- Session storage or session scheduling.
+- Queued user messages.
+- Enforcement of the session-level one-active-turn rule.
+- Context pruning or compaction.
+- Agent-as-tool behavior. An agent tool handler may implement this separately,
+  but the parent turn sees it only as a normal sync or async tool.
+- Inline, caller-supplied agents.
+- Mid-turn agent, model, prompt, or tool-set switching.
+- Tool argument validation beyond what the model/tool integration already
+  provides.
+- External-input idempotency keys or duplicate-delivery handling.
+- Automatic model-call retries.
+- Cross-process locking.
+- Explicit `fsync` after every append.
+- Automatic repair of corrupt JSONL files.
+- Stream backpressure or bounded event buffering.
+- A shared UI timeline selector.
+- Migration from the current run system.
+
+## 3. Core terminology
+
+### 3.1 Turn
+
+A turn starts with one intentional user message and contains all agent work
+caused by that message:
+
+- Model requests and responses.
+- Permission checks and decisions.
+- Sync tool executions.
+- Async tool requests, progress, and results.
+- Repeated model calls after tool results.
+- Final completion, failure, cancellation, or suspension.
+
+Permission decisions and async tool results do not create new turns. They
+advance the existing turn.
+
+### 3.2 Session
+
+A session is an optional higher-level conversation and scheduling concept. A
+turn has `sessionId: string | null`, but turn execution never reads session
+state.
+
+The session layer will eventually own:
+
+- Turn ordering.
+- One-active-turn enforcement.
+- Queued user messages.
+- Context construction from prior turns.
+- Context pruning and compaction.
+- Session-wide permission grants.
+
+### 3.3 Agent
+
+An agent is a reusable execution preset consisting primarily of:
+
+- A system prompt.
+- A model/provider selection.
+- A set of tools.
+
+The current codebase follows this model across Copilot, background-task,
+live-note, knowledge-sync, and user-defined agents.
+
+An agent is resolved once when a turn is created. The resulting execution
+snapshot is immutable for the lifetime of the turn.
+
+## 4. Architectural principles
+
+### 4.1 The JSONL log is the source of truth
+
+There is one JSONL file per turn. Every line contains one validated JSON event.
+State is always reconstructed by replaying the file from the beginning.
+
+There are no mutable summary files, checkpoints, or storage sidecars.
+
+### 4.2 Events describe facts, not current process liveness
+
+The durable log must never claim that a turn is currently running. A process
+can crash at any time and make such a claim false.
+
+Durable events may state that:
+
+- A model request was prepared and requested.
+- A tool invocation was requested.
+- A result was received.
+- A turn suspended.
+- A turn completed, failed, or was cancelled.
+
+Whether an `advanceTurn` invocation is currently active is ephemeral
+application state communicated through the application bus.
+
+### 4.3 The turn runtime has no hidden dependencies
+
+`TurnRuntime` is a class used as an immutable dependency container. It holds no
+mutable per-turn execution state. All active turn state is reconstructed from
+the repository inside each invocation.
+
+Awilix constructs the singleton using PROXY/destructured-object injection.
+`TurnRuntime` must never resolve dependencies from the Awilix container itself.
+
+### 4.4 Durable barriers precede side effects
+
+When a durable event represents intent to perform an external side effect, the
+event is successfully appended before the side effect begins.
+
+Examples:
+
+- Append `model_call_requested` before calling the model.
+- Append `tool_invocation_requested` before invoking a sync tool or exposing an
+  async tool request.
+
+This does not provide exactly-once execution. It provides conservative recovery
+semantics after ambiguous interruptions.
+
+### 4.5 Execution order and model-facing order are separate
+
+Tool calls may complete in any order. The next model request must always contain
+tool results in the original order emitted by the model.
+
+The initial implementation may execute sync tools sequentially for simplicity.
+Async tools naturally complete independently. No behavior may rely on physical
+completion order.
+
+## 5. Storage design
+
+### 5.1 File location
+
+Turn files live under:
+
+```text
+WorkDir/storage/turns/YYYY/MM/DD/<turnId>.jsonl
+```
+
+The existing time-based `IMonotonicallyIncreasingIdGenerator` produces IDs such
+as:
+
+```text
+2025-11-11T04-36-29Z-0001234-000
+```
+
+The deterministic path is therefore:
+
+```text
+WorkDir/storage/turns/2025/11/11/2025-11-11T04-36-29Z-0001234-000.jsonl
+```
+
+The repository validates the ID format before deriving the path. It extracts
+the UTC `YYYY-MM-DD` prefix and rejects malformed or path-like values.
+
+### 5.2 File rules
+
+- The first line is always `turn_created`.
+- The first line contains `schemaVersion: 1`.
+- Every event contains `turnId` and an ISO timestamp `ts`.
+- Physical line order is authoritative event order.
+- There are no generic event IDs or sequence numbers.
+- Domain identifiers such as `toolCallId` and `modelCallIndex` remain explicit.
+- Every event must be JSON-serializable.
+- `undefined`, `BigInt`, functions, cyclic data, class instances, and raw
+  `Error` objects are rejected.
+- Reads validate every line strictly.
+- Any malformed line, including a malformed final line, makes the turn corrupt.
+- The repository does not truncate, repair, or skip malformed lines.
+- Unknown schema versions and unknown event types fail loudly.
+- Appends are awaited but are not explicitly flushed with `fsync` initially.
+
+### 5.3 Repository contract
+
+```ts
+interface ITurnRepo {
+  create(event: TurnCreated): Promise<void>;
+  read(turnId: string): Promise<TurnEvent[]>;
+  append(turnId: string, events: TurnEvent[]): Promise<void>;
+  withLock<T>(turnId: string, fn: () => Promise<T>): Promise<T>;
+}
+```
+
+Rules:
+
+- `create` fails if the target file already exists.
+- `append` validates events before writing.
+- `read` validates every line and verifies event `turnId` values.
+- `withLock` provides in-process per-turn exclusion.
+- Cross-process coordination is out of scope.
+- Whether lock contention waits or reports busy is an implementation detail for
+  the first version.
+- Listing, deletion, session lookup, and presentation metadata are not required
+  by the loop-facing repository contract.
+
+## 6. Agent resolution
+
+### 6.1 Caller input
+
+`createTurn` accepts a registered agent ID and an optional atomic model
+override:
+
+```ts
+type JsonPrimitive = string | number | boolean | null;
+type JsonValue =
+  | JsonPrimitive
+  | JsonValue[]
+  | { [key: string]: JsonValue };
+
+interface ModelDescriptor {
+  provider: string;
+  model: string;
+}
+
+interface RequestedAgent {
+  agentId: string;
+  overrides?: {
+    model?: ModelDescriptor;
+    // Opaque composition hints interpreted by the agent resolver (e.g.
+    // work-dir id, voice/search/code modes). Persisted verbatim for audit.
+    // The resolver decides which keys affect system-prompt bytes; callers
+    // should keep prompt-affecting inputs session-sticky to preserve
+    // provider prefix caching across turns.
+    composition?: JsonValue;
+  };
+}
+```
+
+Provider and model are overridden together. Independent partial provider/model
+overrides are not supported.
+
+Inline resolved agents are not supported initially because there is no current
+application use case.
+
+### 6.2 AgentResolver responsibilities
+
+`IAgentResolver` absorbs the current agent-assembly responsibilities:
+
+- Built-in agent selection currently handled by `loadAgent`.
+- User-defined agent loading from `IAgentsRepo`.
+- Dynamic Copilot, background-task, live-note, and knowledge-agent builders.
+- Agent-specific system-prompt augmentation.
+- Agent Notes, work-directory context, and similar prompt assembly.
+- Model override, agent configuration, and application-default precedence.
+- Tool attachment resolution.
+- Tool availability filtering.
+- Creation of immutable serializable tool descriptors.
+
+```ts
+interface ResolvedAgent {
+  agentId: string;
+  systemPrompt: string;
+  model: ModelDescriptor;
+  tools: ToolDescriptor[];
+}
+
+interface IAgentResolver {
+  resolve(agent: RequestedAgent): Promise<ResolvedAgent>;
+}
+```
+
+The resolved system prompt is the final byte-for-byte string used by model
+requests. The turn loop never appends additional instructions.
+
+Model resolution precedence is:
+
+1. `createTurn` model override.
+2. Model/provider configured on the agent.
+3. Application default model/provider.
+
+### 6.3 Tool identity
+
+Model-facing names and runtime implementation identities are distinct:
+
+```ts
+interface ToolDescriptor {
+  toolId: string;
+  name: string;
+  description: string;
+  inputSchema: JsonValue;
+  execution: "sync" | "async";
+  requiresHuman: boolean;
+}
+```
+
+- `toolId` is the stable registry lookup identity.
+- `name` is the name advertised to the model.
+- The distinction supports aliases and MCP-backed tools.
+- The descriptor is fully snapshotted at turn creation.
+- `advanceTurn` may not silently add, remove, or modify tools.
+
+### 6.4 Requested and resolved agent snapshots
+
+`turn_created` stores both caller intent and resolved output:
+
+```ts
+agent: {
+  requested: RequestedAgent;
+  resolved: ResolvedAgent;
+}
+```
+
+This makes defaults, aliases, and overrides visible during debugging.
+
+If agent resolution fails, `createTurn` rejects without creating a turn file.
+
+### 6.5 Model and tool implementation materialization
+
+Agent resolution and live runtime materialization are separate responsibilities,
+but all dependencies are constructor-injected:
+
+- `IAgentResolver` creates the immutable serializable snapshot during
+  `createTurn`.
+- `IModelRegistry` resolves the persisted model descriptor to a live AI SDK
+  model during `advanceTurn`.
+- `IToolRegistry` resolves persisted tool descriptors to live implementations
+  during `advanceTurn`.
+
+This lets an old turn resume from its snapshot even if the registered agent
+definition later changes.
+
+### 6.6 Context references and materialization
+
+Session turns do not inline their conversation prefix. Context is either an
+inline message array or a reference to the immediately preceding turn:
+
+```ts
+type TurnContext =
+  | { previousTurnId: string }
+  | ConversationMessage[];
+```
+
+- `{ previousTurnId }` references an immutable prior turn. The materialized
+  context is that turn's closed transcript: its own materialized context,
+  followed by its input and every message it produced, including synthetic
+  closure results for failed, cancelled, or interrupted work.
+- Inline arrays are used by standalone turns and by callers that assemble
+  context themselves (for example after a future compaction).
+
+Materialization is performed by an injected resolver:
+
+```ts
+interface IContextResolver {
+  resolve(context: TurnContext): Promise<ConversationMessage[]>;
+}
+```
+
+Rules:
+
+- Resolution happens at the start of every `advanceTurn` invocation, from
+  durable state only. Normal execution and crash recovery therefore share one
+  code path.
+- Resolution traverses references recursively until an inline context
+  terminates the chain.
+- Turns with any terminal status participate in resolution. Their transcripts
+  are structurally complete because unresolved work receives synthetic
+  results before a terminal event is appended.
+- A reference to a missing or corrupt turn file is an infrastructure error.
+  It rejects the execution and does not append `turn_failed`.
+- The reducer treats `context` as opaque data and never resolves references.
+
+### 6.7 Agent snapshot inheritance
+
+Session turns whose resolved system prompt and tool set are byte-identical
+to the context predecessor's materialized snapshot persist an inherited
+form instead of repeating ~tens of KB per turn:
+
+```ts
+type ResolvedAgentSnapshot =
+  | ResolvedAgent
+  | { agentId: string; model: ModelDescriptor; inheritedFrom: string };
+```
+
+Rules:
+
+- Inheritance is decided at `createTurn` by comparing against the
+  predecessor's materialized snapshot; any difference in system prompt or
+  tools persists the full snapshot. An unreadable predecessor falls back to
+  the full snapshot.
+- The model stays concrete: it is small, the session index denormalizes it,
+  and a mid-session model switch must not block inheritance. On
+  materialization the inherited record's own `agentId`/`model` win; only the
+  heavy fields come from the chain base.
+- `inheritedFrom` must equal the turn's `context.previousTurnId` (reducer
+  invariant); materialization walks the chain with cycle detection
+  (`IContextResolver.resolveAgent`), exactly like context references.
+- The reducer treats inherited snapshots as opaque: tool identity for
+  extraction arrives via `tool_invocation_requested` events instead of the
+  descriptor lookup.
+
+## 7. Turn creation schema
+
+The authoritative initial event is:
+
+```ts
+interface TurnCreated {
+  type: "turn_created";
+  schemaVersion: 1;
+  turnId: string;
+  ts: string;
+  sessionId: string | null;
+
+  agent: {
+    requested: RequestedAgent;
+    resolved: ResolvedAgent;
+  };
+
+  context: TurnContext;
+  input: UserMessage;
+
+  config: {
+    autoPermission: boolean;
+    humanAvailable: boolean;
+    maxModelCalls: number;
+  };
+}
+```
+
+Rules:
+
+- `sessionId` is explicitly nullable.
+- `context` is either an inline message array or a reference to the previous
+  turn (section 6.6).
+- Inline context contains prior user, assistant, and tool messages only.
+- System-role messages in inline context are rejected.
+- A context reference is resolved by the injected context resolver during
+  `advanceTurn`, never at creation and never by the reducer.
+- The resolved agent owns the single authoritative system prompt.
+- `input` is the user message that defines this turn boundary.
+- `autoPermission` defaults to `false` before persistence.
+- `humanAvailable` is required explicitly.
+- `maxModelCalls` defaults to `20` before persistence.
+- Persisted values are fully resolved and immutable.
+
+The capability is named `humanAvailable`, not `headless`. `headless` describes
+one deployment mode, while this flag states the exact runtime capability used
+by permission fallback and human-dependent tools.
+
+The canonical system prompt is written once in `turn_created`. It may be
+deliberately duplicated inside each `model_call_requested.request` because that
+event records the exact model input for auditing.
+
+## 8. Shared event schemas
+
+All durable serializable event schemas live in `@x/shared`. The repository,
+runtime, live stream implementation, and filesystem behavior live in `@x/core`.
+
+### 8.1 Base event
+
+```ts
+interface BaseTurnEvent {
+  turnId: string;
+  ts: string;
+}
+```
+
+### 8.2 Usage
+
+Usage means token usage only. Monetary pricing and cost calculation are out of
+scope.
+
+```ts
+interface TurnUsage {
+  inputTokens?: number;
+  outputTokens?: number;
+  totalTokens?: number;
+  reasoningTokens?: number;
+  cachedInputTokens?: number;
+}
+```
+
+Usage is stored per completed model call and aggregated across the turn.
+
+### 8.3 Model request events
+
+Every AI SDK `streamText` invocation performs exactly one model step. Tool
+execution is controlled manually by the turn loop.
+
+```ts
+// Compact string refs, so raw JSONL reads naturally:
+//   "context"                  the inline context block
+//   "input"                    the turn's user message
+//   "assistant:<index>"        → that model_call_completed's message
+//   "toolResult:<toolCallId>"  → that tool_result
+type ModelRequestMessageRef = string;
+
+interface ModelRequest {
+  contextRef?: { previousTurnId: string };  // call 0 only (cross-turn prefix)
+  messages: ModelRequestMessageRef[];       // what is NEW since the previous call
+  parameters: Record<string, JsonValue>;
+}
+
+interface ModelCallRequested extends BaseTurnEvent {
+  type: "model_call_requested";
+  modelCallIndex: number;
+  request: ModelRequest;
+}
+```
+
+`modelCallIndex` starts at `0` and increments monotonically for each primary
+agent model call in the turn.
+
+`request` is a list of references into the turn's own events: every
+referenced byte exists exactly once in the file. A request records only what
+is new since the previous model call — call 0 is `["context"?, "input"]`
+(context only when inline and nonempty; cross-turn prefixes ride
+`contextRef`); call N is `["assistant:N-1", …that batch's
+"toolResult:<id>" refs in source order]`; a re-issued call after an
+interruption is `[]`. The system
+prompt and tool set are not repeated: they are byte-identical to
+`turn_created.agent.resolved` by construction.
+
+The exact provider payload is rebuilt by the request composer
+(`composeModelRequest` in core): resolved system prompt, wrapped tool
+definitions, the materialized cross-turn prefix, and every request's
+references resolved against the turn's events, all passed through the model
+bridge's `encodeMessages` (the deterministic structural→wire conversion —
+user-message context weaving, attachment rendering, tool-result enveloping).
+The loop transmits exactly the composer's output, and debugging/audit calls
+the same function, so the durable file plus the composer reproduce the wire
+bytes and the two views cannot diverge.
+
+Requests exclude credentials, auth headers, functions, model objects, and
+transport objects.
+
+The name `requested` is intentional. The event proves durable intent, not that
+the provider definitely received the request.
+
+### 8.4 Provider step events
+
+Normalized AI SDK step events may be persisted for debugging:
+
+```ts
+interface ModelStepEvent extends BaseTurnEvent {
+  type: "model_step_event";
+  modelCallIndex: number;
+  event: DurableLlmStepStreamEvent;
+}
+```
+
+The wrapper may contain normalized events such as:
+
+- Text start/end.
+- Reasoning start/end.
+- Completed tool calls.
+- Finish-step metadata and usage.
+- Normalized provider errors.
+
+Raw text and reasoning delta events are not durable. Partial tool-argument
+fragments are also not required; completed parsed tool calls are durable.
+
+There is one `TurnEvent` union. Events are not permanently classified as
+"state" or "diagnostic" because reducer usage will evolve. The reducer decides
+which known events currently affect derived state.
+
+### 8.5 Completed and failed model calls
+
+```ts
+interface ModelCallCompleted extends BaseTurnEvent {
+  type: "model_call_completed";
+  modelCallIndex: number;
+  message: AssistantMessage;
+  finishReason: string;
+  usage: TurnUsage;
+  providerMetadata?: JsonValue;
+}
+
+interface ModelCallFailed extends BaseTurnEvent {
+  type: "model_call_failed";
+  modelCallIndex: number;
+  error: string;
+}
+```
+
+`model_call_completed` is the canonical completed model response even when its
+content duplicates provider step events.
+
+Any successfully completed assistant response without tool calls completes the
+turn, including responses whose finish reason is `length` or `content-filter`.
+Provider and stream failures fail the turn.
+
+Only the primary model calls directly controlled by the turn loop are recorded
+as model calls. Internal model calls hidden inside the permission classifier or
+tool implementations belong to those dependencies and are not turn-loop model
+calls.
+
+## 9. Permission model
+
+### 9.1 Dependencies
+
+An injected permission checker determines whether a tool call needs permission:
+
+```ts
+interface PermissionCheckAllowed {
+  required: false;
+}
+
+interface PermissionCheckRequired {
+  required: true;
+  request: JsonValue;
+}
+
+interface IPermissionChecker {
+  check(input: PermissionCheckInput): Promise<
+    PermissionCheckAllowed | PermissionCheckRequired
+  >;
+}
+```
+
+Tool-specific policy, command analysis, filesystem boundaries, and allowlists
+remain outside the loop.
+
+When automatic permission is enabled, the injected classifier handles all
+permission-required calls from one model response in one batch:
+
+```ts
+interface PermissionClassification {
+  toolCallId: string;
+  decision: "allow" | "deny" | "defer";
+  reason: string;
+}
+
+interface PermissionClassificationBatch {
+  turnId: string;
+  // Conversation context: resolved context plus current-turn settled
+  // messages (the pending batch's tool results are not yet terminal).
+  messages: ConversationMessage[];
+  requests: PermissionClassificationInput[];
+}
+
+interface IPermissionClassifier {
+  classify(
+    batch: PermissionClassificationBatch,
+    signal: AbortSignal,
+  ): Promise<PermissionClassification[]>;
+}
+```
+
+The classifier's internal implementation and internal model calls are opaque to
+the turn loop.
+
+### 9.2 Permission events
+
+```ts
+interface ToolPermissionRequired extends BaseTurnEvent {
+  type: "tool_permission_required";
+  toolCallId: string;
+  toolName: string;
+  request: JsonValue;
+  checkerError?: string;
+}
+
+interface ToolPermissionClassified extends BaseTurnEvent {
+  type: "tool_permission_classified";
+  toolCallId: string;
+  decision: "allow" | "deny" | "defer";
+  reason: string;
+}
+
+interface ToolPermissionClassificationFailed extends BaseTurnEvent {
+  type: "tool_permission_classification_failed";
+  toolCallIds: string[];
+  error: string;
+}
+
+interface ToolPermissionResolved extends BaseTurnEvent {
+  type: "tool_permission_resolved";
+  toolCallId: string;
+  decision: "allow" | "deny";
+  source: "classifier" | "human" | "human_unavailable";
+  reason?: string;
+  metadata?: JsonValue;
+}
+```
+
+Only `tool_permission_resolved` is an effective execution decision.
+
+### 9.3 Permission behavior matrix
+
+`autoPermission` and `humanAvailable` are orthogonal:
+
+| autoPermission | humanAvailable | Behavior |
+| --- | --- | --- |
+| false | true | Ask human and suspend. |
+| false | false | Deny and continue with an error tool result. |
+| true | true | Classify; deferred calls ask human. |
+| true | false | Classify; deferred calls are denied. |
+
+Classifier decisions behave as follows:
+
+- `allow`: resolve allow and execute/dispatch immediately.
+- `deny`: resolve deny and create an error tool result.
+- `defer`: ask a human if available; otherwise deny.
+- Classifier failure or omitted decision: record failure and treat as `defer`.
+
+If the permission checker itself throws, the loop fails closed:
+
+- Record the checker error as a permission-required event.
+- Ask a human if available.
+- Otherwise create a denied error result.
+- Never execute automatically.
+
+### 9.4 Partial decisions
+
+Permission resolution is per tool call, not a batch barrier.
+
+When one permission decision arrives:
+
+- An allowed sync tool executes immediately.
+- An allowed async tool is exposed immediately.
+- A denied tool receives an immediate error result.
+- Other unresolved permission requests remain pending.
+- The turn suspends again if any external inputs remain outstanding.
+
+Permission responses are accepted one at a time. The caller is never required
+to batch external inputs.
+
+### 9.5 Permission scopes
+
+The turn consumes only the effective allow/deny decision for the current tool
+call. Session-wide or global approval grants are persisted by the caller before
+advancing the turn. Scope may be retained as audit metadata, but the loop does
+not interpret or apply it.
+
+## 10. Tool model
+
+### 10.1 Runtime tools
+
+Sync and async execution are immutable tool metadata:
+
+```ts
+interface ToolExecutionContext {
+  turnId: string;
+  toolCallId: string;
+  signal: AbortSignal;
+  reportProgress(progress: JsonValue): Promise<void>;
+}
+
+interface SyncRuntimeTool {
+  descriptor: ToolDescriptor & { execution: "sync" };
+  execute(
+    input: JsonValue,
+    context: ToolExecutionContext,
+  ): Promise<ToolResultData>;
+}
+
+interface AsyncRuntimeTool {
+  descriptor: ToolDescriptor & { execution: "async" };
+}
+
+type RuntimeTool = SyncRuntimeTool | AsyncRuntimeTool;
+```
+
+An async tool has no in-process executor. Its request is exposed externally and
+its progress/result is later supplied through `advanceTurn`.
+
+`ask-human` is an ordinary async tool. Other externally resolved async tools may
+be added without changing the loop.
+
+### 10.2 Human-dependent tools
+
+`requiresHuman` is generic metadata, not a hard-coded `ask-human` name check.
+
+If `requiresHuman` is true and `humanAvailable` is false:
+
+- Append the tool invocation request.
+- Append an immediate runtime error result such as "Human input is unavailable
+  for this turn."
+- Continue the tool batch.
+
+`humanAvailable` affects human-dependent tools and permission fallback. It does
+not disable other async tools.
+
+### 10.3 Tool events
+
+```ts
+interface ToolInvocationRequested extends BaseTurnEvent {
+  type: "tool_invocation_requested";
+  toolCallId: string;
+  toolId: string;
+  toolName: string;
+  execution: "sync" | "async";
+  input: JsonValue;
+}
+
+interface ToolProgress extends BaseTurnEvent {
+  type: "tool_progress";
+  toolCallId: string;
+  source: "sync" | "async";
+  progress: JsonValue;
+}
+
+interface ToolResultData {
+  output: JsonValue;
+  isError: boolean;
+  metadata?: JsonValue;
+}
+
+interface ToolResult extends BaseTurnEvent {
+  type: "tool_result";
+  toolCallId: string;
+  toolName: string;
+  source: "sync" | "async" | "runtime";
+  result: ToolResultData;
+}
+```
+
+`runtime` results cover:
+
+- Permission denial.
+- Unknown tools.
+- Invalid or unusable model tool calls.
+- Human unavailability.
+- Cancellation.
+- Interrupted sync execution.
+
+A tool result may exist without an invocation event when execution is rejected
+before dispatch, such as permission denial or unknown tool handling.
+
+### 10.4 Progress
+
+Any sync or async tool may report progress.
+
+- Sync tools call and await `reportProgress`.
+- The loop appends `tool_progress` before resolving that callback.
+- Async progress arrives as one external `advanceTurn` input.
+- Progress is durable and informational.
+- Progress does not satisfy the pending tool call.
+- Progress after a terminal tool result is rejected.
+- Backend flow control may ignore progress while UI reducers retain it.
+
+No progress write queue or non-blocking batching is included initially.
+
+### 10.5 Tool scheduling and ordering
+
+For one completed assistant response:
+
+1. Identify all model-produced tool calls and their source order.
+2. Determine permission requirements.
+3. Apply automatic permission decisions when enabled.
+4. Advance each tool independently as its permission is resolved.
+5. Execute allowed sync tools using a simple sequential policy initially.
+6. Expose allowed async tool requests.
+7. Suspend when any permissions or async results remain outstanding.
+8. Once all calls have terminal results, build the next model request with
+   results in original model-call order.
+
+The model is not called while any tool in the current batch lacks a terminal
+result.
+
+## 11. Suspension and external inputs
+
+### 11.1 Suspension event
+
+```ts
+interface TurnSuspended extends BaseTurnEvent {
+  type: "turn_suspended";
+  pendingPermissions: Array<{
+    toolCallId: string;
+    toolName: string;
+    request: JsonValue;
+  }>;
+  pendingAsyncTools: Array<{
+    toolCallId: string;
+    toolId: string;
+    toolName: string;
+    input: JsonValue;
+  }>;
+  usage: TurnUsage;
+}
+```
+
+Before an invocation returns suspended, it appends a full snapshot of currently
+pending external work.
+
+Calling `advanceTurn` with no input when the turn is already suspended returns
+the current suspended outcome without appending a duplicate event.
+
+After a valid external input, if work remains pending, a new suspension snapshot
+is appended before returning.
+
+### 11.2 One input per invocation
+
+```ts
+type TurnExternalInput =
+  | {
+      type: "permission_decision";
+      toolCallId: string;
+      decision: "allow" | "deny";
+      metadata?: JsonValue;
+    }
+  | {
+      type: "async_tool_progress";
+      toolCallId: string;
+      progress: JsonValue;
+    }
+  | {
+      type: "async_tool_result";
+      toolCallId: string;
+      result: ToolResultData;
+    }
+  | {
+      type: "cancel";
+      reason?: string;
+    };
+```
+
+Each `advanceTurn` accepts at most one input. It validates that input against the
+current durable pending state, persists the resulting semantic event, advances
+as far as possible, and settles again.
+
+Inputs targeting calls that are no longer pending are rejected.
+
+No caller-generated input IDs or duplicate-delivery semantics are included.
+
+### 11.3 Partial async results
+
+Async progress and results may arrive independently and in any order.
+
+- Persist each input immediately.
+- Keep the turn suspended while any permission or async result remains pending.
+- Do not initiate the next model call until every original tool call has a
+  terminal result.
+
+## 12. Terminal events
+
+```ts
+interface TurnCompleted extends BaseTurnEvent {
+  type: "turn_completed";
+  output: AssistantMessage;
+  finishReason: string;
+  usage: TurnUsage;
+}
+
+interface TurnFailed extends BaseTurnEvent {
+  type: "turn_failed";
+  error: string;
+  code?: string;
+  usage: TurnUsage;
+}
+
+interface TurnCancelled extends BaseTurnEvent {
+  type: "turn_cancelled";
+  reason?: string;
+  usage: TurnUsage;
+}
+```
+
+The completed event deliberately duplicates the final assistant message,
+finish reason, and aggregate usage so the final line is a self-contained
+completion summary.
+
+Errors begin as a single descriptive string. Structured details may be added
+later when they are naturally available upstream; the loop does not invent
+structure by parsing arbitrary errors.
+
+`code` is an optional machine-readable discriminator for failures that
+callers must tell apart. This specification defines `"model-call-limit"`
+(section 20); other codes may be added when a caller concretely needs them.
+
+Terminal states are immutable:
+
+- Events may not be appended after completion, failure, or cancellation.
+- Re-advancing a terminal turn returns its existing outcome.
+- Retrying a failed turn means creating a new turn with a new ID.
+
+## 13. Turn event union and live deltas
+
+```ts
+type TurnEvent =
+  | TurnCreated
+  | ModelCallRequested
+  | ModelStepEvent
+  | ModelCallCompleted
+  | ModelCallFailed
+  | ToolPermissionRequired
+  | ToolPermissionClassified
+  | ToolPermissionClassificationFailed
+  | ToolPermissionResolved
+  | ToolInvocationRequested
+  | ToolProgress
+  | ToolResult
+  | TurnSuspended
+  | TurnCompleted
+  | TurnFailed
+  | TurnCancelled;
+```
+
+Ephemeral model deltas are stream-only:
+
+```ts
+interface TextDelta {
+  type: "text_delta";
+  turnId: string;
+  modelCallIndex: number;
+  delta: string;
+}
+
+interface ReasoningDelta {
+  type: "reasoning_delta";
+  turnId: string;
+  modelCallIndex: number;
+  delta: string;
+}
+
+type TurnStreamEvent = TurnEvent | TextDelta | ReasoningDelta;
+```
+
+All durable provider step events are appended before the loop reads the next
+provider stream event. This intentionally applies simple filesystem
+backpressure. Text and reasoning deltas bypass storage.
+
+## 14. Derived turn state
+
+### 14.1 One canonical reducer
+
+`@x/shared` owns one pure reducer used by core and renderer:
+
+```ts
+function reduceTurn(events: TurnEvent[]): TurnState;
+```
+
+Properties:
+
+- Pure and deterministic.
+- Performs no I/O.
+- Performs no expensive external work.
+- Replays the full bounded turn log from the beginning.
+- Known events that do not currently affect state may be ignored.
+- Invalid event transitions throw a corruption/state error.
+- There is no incremental reducer API initially.
+
+Consumers may append a newly received durable event to their local event list
+and call `reduceTurn` again.
+
+### 14.2 State shape
+
+```ts
+interface TurnState {
+  definition: TurnCreated;
+  modelCalls: ModelCallState[];
+  toolCalls: ToolCallState[];
+  suspension?: TurnSuspended;
+  terminal?: TurnCompleted | TurnFailed | TurnCancelled;
+  usage: TurnUsage;
+}
+
+interface ModelCallState {
+  index: number;
+  request: ModelRequest;
+  stepEvents: DurableLlmStepStreamEvent[];
+  response?: AssistantMessage;
+  finishReason?: string;
+  usage?: TurnUsage;
+  error?: string;
+}
+
+interface ToolCallState {
+  modelCallIndex: number;
+  order: number;
+  toolCallId: string;
+  toolId?: string;
+  toolName: string;
+  input: JsonValue;
+  execution?: "sync" | "async";
+
+  permission?: {
+    required: ToolPermissionRequired;
+    classification?: ToolPermissionClassified;
+    resolved?: ToolPermissionResolved;
+  };
+
+  invocation?: ToolInvocationRequested;
+  progress: ToolProgress[];
+  result?: ToolResult;
+}
+```
+
+The exact implementation may refine these field names, but the state must
+retain enough information for both execution and historical presentation.
+
+### 14.3 No durable or derived running status
+
+`TurnState` does not contain a single status field.
+
+Consumers derive what they need from:
+
+- `suspension`.
+- `terminal`.
+- Outstanding model and tool records.
+- Ephemeral application bus activity.
+
+This avoids encoding process liveness in durable or replayed state.
+
+### 14.4 No transient streaming buffer
+
+`TurnState` contains only durable projections. It does not contain partial text
+or reasoning buffers. The renderer owns those ephemeral buffers while handling
+live deltas and discards them when a canonical model response arrives.
+
+### 14.5 No shared timeline selector initially
+
+The renderer may interpret `modelCalls` and `toolCalls` directly. A shared
+semantic timeline selector can be added later if duplicated presentation logic
+becomes a concrete problem.
+
+### 14.6 Historical read API
+
+```ts
+interface Turn {
+  turnId: string;
+  events: TurnEvent[];
+}
+
+interface ITurnRuntime {
+  getTurn(turnId: string): Promise<Turn>;
+}
+```
+
+`getTurn` is strictly read-only:
+
+- It reads and validates the JSONL file.
+- It returns the validated event list.
+- It never resumes work.
+- It never appends recovery records.
+- Callers use the shared reducer to obtain `TurnState`.
+
+Only `advanceTurn` may reconcile or advance execution.
+
+Prior session context remains inside `state.definition.context`. Historical UI
+for one turn should normally show the triggering input and activity produced by
+that turn, not repeat the prior context. Session presentation will handle
+composition later.
+
+## 15. TurnRuntime API and dependency injection
+
+### 15.1 Constructor
+
+```ts
+interface TurnRuntimeDependencies {
+  turnRepo: ITurnRepo;
+  idGenerator: IMonotonicallyIncreasingIdGenerator;
+  clock: IClock;
+  agentResolver: IAgentResolver;
+  modelRegistry: IModelRegistry;
+  toolRegistry: IToolRegistry;
+  contextResolver: IContextResolver;
+  permissionChecker: IPermissionChecker;
+  permissionClassifier: IPermissionClassifier;
+  lifecycleBus: ITurnLifecycleBus;
+}
+
+class TurnRuntime implements ITurnRuntime {
+  constructor({
+    turnRepo,
+    idGenerator,
+    clock,
+    agentResolver,
+    modelRegistry,
+    toolRegistry,
+    contextResolver,
+    permissionChecker,
+    permissionClassifier,
+    lifecycleBus,
+  }: TurnRuntimeDependencies);
+}
+```
+
+The injected clock exposes a simple deterministic timestamp source for unit
+tests. The existing ID generator remains responsible for turn IDs.
+
+Awilix registration is singleton-scoped:
+
+```ts
+turnRepo: asClass<ITurnRepo>(FSTurnRepo).singleton(),
+turnRuntime: asClass<ITurnRuntime>(TurnRuntime).singleton(),
+```
+
+Model, tool, permission, clock, and bus dependencies are also explicitly
+registered and injected.
+
+### 15.2 Public API
+
+```ts
+interface CreateTurnInput {
+  agent: RequestedAgent;
+  sessionId?: string | null;
+  context: TurnContext;
+  input: UserMessage;
+  config: {
+    autoPermission?: boolean;
+    humanAvailable: boolean;
+    maxModelCalls?: number;
+  };
+}
+
+interface ITurnRuntime {
+  createTurn(input: CreateTurnInput): Promise<string>;
+
+  advanceTurn(
+    turnId: string,
+    input?: TurnExternalInput,
+    options?: { signal?: AbortSignal },
+  ): TurnExecution;
+
+  getTurn(turnId: string): Promise<Turn>;
+}
+```
+
+Creation and execution remain separate operations. A turn may exist before its
+first model call.
+
+### 15.3 Runtime dependency validation
+
+Before advancing, the runtime resolves live model and tool implementations from
+the persisted descriptors and validates compatibility.
+
+Missing or mismatched runtime dependencies:
+
+- Reject the execution.
+- Do not append `turn_failed`.
+- Leave the turn unchanged so the caller can fix its environment and retry.
+
+Provider failures after actual execution begins are modeled turn failures.
+
+## 16. Hot TurnExecution stream
+
+### 16.1 Shape
+
+```ts
+interface TurnExecution {
+  events: AsyncIterable<TurnStreamEvent>;
+  outcome: Promise<TurnOutcome>;
+}
+```
+
+`advanceTurn` returns immediately with a hot execution object. Execution starts
+independently of event consumption.
+
+### 16.2 Rationale
+
+A plain async generator would make execution pull-driven:
+
+- Never consuming it would mean execution never starts.
+- Slow consumers would pause the loop at every yield.
+- Abandoning a partially consumed iterator could leave execution paused and a
+  lock held indefinitely.
+
+The hot stream prevents turn correctness and lock release from depending on an
+observer.
+
+### 16.3 Initial stream semantics
+
+- One event consumer is assumed.
+- The caller may fan events out through its own event emitter or bus bridge.
+- Events produced by that `advanceTurn` invocation only are emitted.
+- Historical events are not replayed.
+- Durable events enter the stream only after successful persistence.
+- Text and reasoning deltas enter without persistence.
+- The stream uses a simple in-memory queue.
+- There is no backpressure or queue bound initially.
+- A slow or absent consumer may cause memory growth.
+- If the consumer closes, subsequent events are dropped.
+- Closing or abandoning event consumption does not cancel turn execution.
+- Cancellation is explicit through `AbortSignal` or a cancel input.
+- `outcome` may be awaited independently of `events`.
+
+### 16.4 Outcome
+
+```ts
+type TurnOutcome =
+  | {
+      status: "completed";
+      output: AssistantMessage;
+      finishReason: string;
+      usage: TurnUsage;
+    }
+  | {
+      status: "suspended";
+      pendingPermissions: TurnSuspended["pendingPermissions"];
+      pendingAsyncTools: TurnSuspended["pendingAsyncTools"];
+      usage: TurnUsage;
+    }
+  | {
+      status: "failed";
+      error: string;
+      usage: TurnUsage;
+    }
+  | {
+      status: "cancelled";
+      reason?: string;
+      usage: TurnUsage;
+    };
+```
+
+### 16.5 Infrastructure errors
+
+If trustworthy turn state cannot be established:
+
+- Event iteration terminates by throwing the infrastructure error.
+- `outcome` rejects with the same error.
+- Already persisted events remain in the file.
+- No synthetic `turn_failed` is appended unless the failure is explicitly a
+  modeled turn failure.
+
+Infrastructure examples:
+
+- Corrupt JSONL.
+- Repository failure.
+- Lock failure.
+- Missing or mismatched injected runtime dependency.
+
+## 17. Ephemeral application lifecycle events
+
+`TurnRuntime` publishes process-lifecycle events through the injected bus:
+
+```ts
+interface TurnProcessingStart {
+  type: "turn-processing-start";
+  turnId: string;
+}
+
+interface TurnProcessingEnd {
+  type: "turn-processing-end";
+  turnId: string;
+}
+```
+
+These events are never written to `TurnRepo` and never replayed.
+
+The UI may maintain an in-memory set of active turn IDs. If the process crashes,
+that set disappears, which accurately reflects that no execution is known to be
+active.
+
+Lifecycle publication is observational and must not alter durable turn
+semantics. Live durable events and deltas are consumed from `TurnExecution` by
+the application and may be forwarded over the existing bus/IPC bridge.
+
+## 18. Main execution algorithm
+
+At a high level, `advanceTurn` performs:
+
+```text
+1. Start hot execution task.
+2. Acquire per-turn lock.
+3. Publish turn-processing-start.
+4. Read and validate JSONL.
+5. Reduce events to TurnState.
+6. Materialize context through the injected context resolver.
+7. Validate terminal state, input, and runtime dependencies.
+8. Apply the optional single external input.
+9. Repeatedly advance deterministic work:
+   a. Recover from the current durable boundary.
+   b. Resolve permissions.
+   c. Execute eligible sync tools.
+   d. Expose eligible async tools.
+   e. If external work remains, append turn_suspended and settle.
+   f. If a tool batch is complete, build ordered tool-result messages.
+   g. If no model-call budget remains, fail.
+   h. Append model_call_requested with exact input.
+   i. Call streamText for one step.
+   j. Persist normalized non-delta events and stream deltas.
+   k. Append model_call_completed or model_call_failed.
+   l. Complete when the response has no tool calls.
+10. Publish turn-processing-end in finalization.
+11. Release the lock.
+12. Resolve/reject outcome and close/error event stream.
+```
+
+The loop does not read session queues, accept new user messages, switch agents,
+or transform context.
+
+## 19. Context and model requests
+
+Context selection before turn creation belongs to the caller/session layer.
+The turn receives either inline messages or a reference to the previous turn
+(section 6.6). Within a turn:
+
+- The initial context — inline or resolved from the reference — is immutable.
+- The system prompt is immutable.
+- The model and tools are immutable.
+- The loop appends current-turn assistant messages and ordered tool results.
+- No pruning or compaction occurs.
+- Context overflow is a model failure.
+
+Every model call persists the current-turn portion of its request
+byte-for-byte, even when it duplicates earlier events in the same file
+(section 8.3). The referenced prefix is deterministic and is not re-inlined.
+Within-turn storage size is not treated as a constraint.
+
+## 20. Model-call limit
+
+`maxModelCalls` limits primary agent model calls, not permission-classifier or
+tool-internal model calls.
+
+When the final allowed model call returns tool calls:
+
+1. Resolve permissions.
+2. Execute/dispatch and collect the complete tool batch.
+3. Do not make a disallowed next model call.
+4. Append `turn_failed` with `code: "model-call-limit"`.
+
+If the final allowed call returns a response without tool calls, complete
+normally.
+
+Limit exhaustion is a distinguishable outcome, not a generic failure. The
+transcript is structurally complete — every tool call has a result — so a
+caller such as the session layer can offer continuation by creating a new
+turn whose context references the exhausted turn.
+
+## 21. Failure semantics
+
+### 21.1 Model failures
+
+- No automatic retry in the turn loop.
+- The injected model/provider may perform internal transport retries.
+- Append `model_call_failed`.
+- Append `turn_failed`.
+- Return a failed outcome.
+
+These rules apply to failures observed during live execution. Closing a model
+call that was interrupted by a process crash is a recovery action (section
+23) and does not fail the turn.
+
+### 21.2 Tool failures
+
+Tool failures do not fail the turn:
+
+- Sync tool throws: append an error tool result.
+- Async tool reports failure: append an error tool result.
+- Permission denial: append an error tool result.
+- Human unavailable: append an error tool result.
+
+Once every call has a result, send all results to the model in source order.
+
+### 21.3 Unknown tools and unusable calls
+
+Unknown tools and unusable model tool calls become runtime error results so the
+model can observe and potentially correct its behavior. They do not fail the
+turn directly.
+
+### 21.4 Storage and configuration failures
+
+Repository failures, corrupt data, and incompatible live dependencies reject
+the execution without pretending the agent turn itself failed.
+
+## 22. Cancellation
+
+Cancellation enters through:
+
+- An `AbortSignal` for an active invocation.
+- A `{ type: "cancel" }` external input for a suspended turn.
+
+Rules:
+
+- Propagate the signal to the model, permission classifier, and sync tools.
+- Create synthetic cancellation results for unresolved tool calls from a
+  completed assistant response.
+- Append `model_call_failed` when an active model call is cancelled.
+- Append `turn_cancelled`.
+- Never initiate another model call.
+- Reject late permission decisions, progress, and results after cancellation.
+
+Sync tools are cooperatively cancellable. A tool that ignores the signal may not
+settle immediately. The runtime cannot guarantee rollback of external side
+effects.
+
+## 23. Recovery model
+
+Provider streams are not resumable. Sync tool side effects are not assumed
+idempotent. Recovery never repeats side-effecting work; side-effect-free
+model calls are re-issued rather than failing the turn.
+
+Calling `advanceTurn(turnId)` with no external input is the recovery entry point.
+
+| Last durable condition | Recovery behavior |
+| --- | --- |
+| `turn_created` only | Safely initiate the first model call. |
+| `model_call_requested` without completion/failure | Append `model_call_failed` (interrupted) to close the call, then re-issue the request as a new model call with the next index. The re-issue counts against `maxModelCalls`. No `turn_failed`. |
+| Completed model response before permission/tool processing | Safely continue processing. |
+| Permission required/classification partially processed | Continue unresolved permission work safely. |
+| Permission resolved allow before invocation | Safely invoke the tool. |
+| Sync `tool_invocation_requested` without result | Append an indeterminate error tool result and continue the turn; never re-execute. No `turn_failed`. |
+| Async `tool_invocation_requested` without result | Remain suspended awaiting external result. |
+| Some async results present | Preserve them and await remaining inputs. |
+| All tool results present before next model request | Safely initiate the next model call. |
+| Terminal event present | Return existing outcome without writing or executing. |
+| Corrupt JSONL | Reject as infrastructure error. |
+
+The synthetic interrupted sync result should communicate:
+
+```text
+Tool execution was interrupted; its outcome is unknown and it was not retried.
+```
+
+This preserves a structurally complete transcript for later session context
+without claiming that the side effect did or did not happen. The model sees
+the indeterminate result on the next model call and can decide whether to
+re-run the tool, verify its effect, or proceed — consistent with section
+21.2's rule that tool-level problems are conversational, not terminal.
+
+Async invocation requests act as durable external requests. Exactly-once
+delivery is not guaranteed. External systems that perform side effects should
+use `toolCallId` as a correlation/deduplication key if they need that guarantee,
+but the first turn implementation does not enforce it.
+
+## 24. Reducer invariants
+
+`reduceTurn` must reject impossible histories, including:
+
+- Missing or non-first `turn_created`.
+- Multiple `turn_created` events.
+- Mismatched turn IDs.
+- Unsupported schema version.
+- Model-call indices that are reused or out of order.
+- Concurrent unresolved primary model requests.
+- Model completion/failure without a matching request.
+- Duplicate model completion/failure.
+- Duplicate tool-call IDs within one model response.
+- Permission records targeting unknown tool calls.
+- Conflicting effective permission decisions.
+- Tool progress after a terminal tool result.
+- Duplicate terminal tool results.
+- Async external results for sync tools.
+- Sync execution results for async tools unless explicitly represented as
+  runtime-generated errors.
+- Starting the next model call before all prior tool calls have results.
+- Model-facing tool-result ordering that differs from original call order.
+- Completion while tool calls remain unresolved.
+- Terminal turn events while unresolved calls lack synthetic terminal results.
+- Multiple terminal turn events.
+- Any event after a terminal turn event.
+- Mutation of immutable turn definition data.
+- `model_call_requested.contextRef` values inconsistent with the turn
+  definition's context, or present on a non-initial model call.
+- Request references that do not match the transcript: call 0 must be
+  `[{context}?, {input}]`; call N must reference the previous completed
+  call's response and its batch's tool results in source order (or nothing,
+  after an interrupted call).
+
+The reducer validates `context` structurally but treats it as opaque; it
+never resolves references (section 6.6).
+
+## 25. Historical and live UI behavior
+
+### 25.1 Historical load
+
+```text
+1. UI requests a turn by ID.
+2. TurnRuntime.getTurn reads and validates the JSONL file.
+3. Core returns { turnId, events }.
+4. Renderer calls reduceTurn(events).
+5. Renderer renders messages, tools, progress, permissions, usage, and terminal
+   information from TurnState.
+```
+
+### 25.2 Live updates
+
+```text
+1. TurnRuntime publishes turn-processing-start.
+2. The application consumes TurnExecution.events.
+3. The application forwards events through the existing bus/IPC bridge.
+4. The renderer appends each durable TurnEvent to its local event list.
+5. The renderer reruns reduceTurn(events).
+6. Text/reasoning deltas update separate ephemeral renderer buffers.
+7. A canonical completed model response replaces/clears partial display state.
+8. TurnRuntime publishes turn-processing-end.
+```
+
+The UI derives current activity from ephemeral bus events. It does not infer
+that a turn is running from the JSONL log.
+
+## 26. Required unit-test scenarios
+
+All dependencies are injectable, so these tests must use fakes/mocks and avoid
+real providers, tools, clocks, filesystems where unnecessary, and permission
+classifiers.
+
+### 26.1 Plain model response
+
+Expected sequence:
+
+```text
+turn_created
+model_call_requested
+model_step_event(s)
+model_call_completed
+turn_completed
+```
+
+Assertions:
+
+- Exact model request is persisted.
+- Deltas are streamed but absent from JSONL.
+- Completed response includes finish reason and usage.
+- Terminal event duplicates final output and aggregate usage.
+- Bus processing events are emitted but not persisted.
+
+### 26.2 Mixed sync and async tools
+
+Model order:
+
+```text
+sync-A, async-B, sync-C, async-D
+```
+
+Assertions:
+
+- Sync tools execute and store results.
+- Async invocation requests are exposed and turn suspends.
+- Async results can arrive in reverse order.
+- The next model request contains results in original source order.
+- Physical event order does not change model-facing order.
+
+### 26.3 Partial human permission decisions
+
+Assertions:
+
+- All required permissions are recorded.
+- One approval advances only its tool.
+- Approved sync tools execute immediately.
+- Approved async tools become pending immediately.
+- Denied calls receive runtime error results.
+- Remaining permissions and async tools coexist in one suspension snapshot.
+- Async results may arrive while other permissions remain unresolved.
+- No next model call occurs until all original calls have terminal results.
+
+### 26.4 Automatic permission classification
+
+Test `allow`, `deny`, and `defer` in one classifier batch.
+
+Assertions:
+
+- Classifier decisions and effective decisions are distinct records.
+- Allow executes.
+- Deny creates an error result without invocation.
+- Defer asks a human when available.
+- Defer denies when no human is available.
+- Classifier failure and missing decisions normalize to defer.
+- Manual mode never calls the classifier.
+
+### 26.5 Cancellation
+
+Test cancellation:
+
+- While suspended.
+- During a model call.
+- During a sync tool.
+
+Assertions:
+
+- Signals are propagated.
+- Unresolved calls receive synthetic cancellation results.
+- Turn becomes terminal cancelled.
+- No subsequent model request occurs.
+- Late external inputs are rejected.
+
+### 26.6 Failures
+
+Assertions:
+
+- Provider failure appends model and turn failures.
+- Sync throw becomes an error tool result and does not fail the turn.
+- Async failure becomes an error tool result.
+- Permission-checker failure fails closed.
+- Repository, corruption, and dependency errors reject stream and outcome.
+- Infrastructure errors do not append a false `turn_failed` event.
+
+### 26.7 Process crash and recovery
+
+Construct logs ending at every recovery boundary in the recovery table.
+
+Assertions:
+
+- Safe boundaries resume.
+- Unmatched model requests are closed as interrupted and re-issued; the
+  re-issue counts against the model-call budget and no `turn_failed` is
+  appended.
+- Unmatched sync invocation requests get indeterminate error results and the
+  turn continues.
+- Unmatched async requests remain pending.
+- Completed tool batches proceed to the next model call.
+- Terminal turns perform no writes or side effects.
+
+### 26.8 Historical and live reconstruction
+
+Assertions:
+
+- `getTurn` is read-only.
+- Full replay reconstructs messages, model calls, tools, progress, permissions,
+  usage, suspension, and terminal data.
+- Appending a durable live event and rerunning the reducer matches full replay.
+- Ephemeral deltas are absent after reload.
+- Final completed messages remain available after reload.
+- No running state is inferred from durable events.
+
+### 26.9 Model-call limit
+
+With `maxModelCalls = 10`:
+
+- A tool-free response on call 10 completes normally.
+- Tool calls from call 10 are fully processed.
+- Call 11 is never made.
+- After the call-10 tool batch completes, the turn fails with a limit error.
+- The limit failure carries `code: "model-call-limit"`.
+
+## 27. Additional unit-test coverage
+
+Beyond the nine end-to-end loop scenarios, implementation should include focused
+tests for:
+
+### 27.1 Repository
+
+- Deterministic date-partitioned paths.
+- ID path-traversal rejection.
+- Create-if-absent behavior.
+- Append ordering.
+- Read/write schema validation.
+- Mismatched turn IDs.
+- Empty files.
+- Malformed first, middle, and final lines.
+- Unsupported schema versions.
+- In-process locking.
+
+### 27.2 Reducer
+
+- Every valid event transition.
+- Every corruption invariant.
+- Usage aggregation.
+- Original tool-call ordering.
+- Suspension replacement/invalidation after new inputs.
+- Terminal immutability.
+- Multiple model iterations.
+- Progress retention.
+- Requested versus resolved agent snapshots.
+
+### 27.3 Hot stream
+
+- Execution starts without event consumption.
+- Outcome resolves without draining events.
+- Events retain order.
+- Durable events appear only after repository append.
+- Closing the consumer drops future events without cancelling execution.
+- Producer completion closes events.
+- Infrastructure failure errors events and rejects outcome with the same error.
+- Cancellation remains explicit.
+
+### 27.4 Agent resolution
+
+- Override precedence.
+- Application-default fallback.
+- Final system prompt snapshot.
+- Tool availability filtering.
+- Tool aliases and stable `toolId` resolution.
+- Resolution failure creates no file.
+- Agent edits after creation do not alter the turn.
+- Runtime dependency mismatch leaves the turn unchanged.
+
+### 27.5 Context resolution
+
+- Inline context passes through unchanged.
+- A single reference materializes the referenced turn's closed transcript.
+- A chain of references materializes recursively down to the inline base.
+- Referenced failed/cancelled/exhausted turns contribute their synthetic
+  closure results.
+- A reference to a missing or corrupt turn file is an infrastructure error
+  and appends nothing.
+- The composed request equals what the loop sent (byte-for-byte property:
+  durable file + composer reproduce the provider payload).
+- The reducer never resolves references.
+
+## 28. Suggested module layout
+
+This is a suggested organization, not a locked implementation requirement:
+
+```text
+apps/x/packages/shared/src/turns.ts
+
+apps/x/packages/core/src/turns/
+  runtime.ts
+  reducer.ts              # if implementation is re-exported through shared,
+                          # locate pure code to avoid dependency cycles
+  repo.ts
+  fs-repo.ts
+  stream.ts
+  agent-resolver.ts
+  context-resolver.ts
+  model-registry.ts
+  tool-registry.ts
+  permission.ts
+  index.ts
+```
+
+The final reducer location must permit both core and renderer to use exactly the
+same pure implementation. It may therefore live entirely in `@x/shared` despite
+being used heavily by `@x/core`.
+
+## 29. Deferred design work
+
+The following topics must be handled in later specifications rather than
+implicitly added to the turn loop:
+
+### 29.1 Sessions
+
+The session layer is specified in `session-design.md`. It covers the session
+JSONL schema, turn references and ordering, one-active-turn enforcement,
+context assembly through turn references, the in-memory index, session UI
+projections, and startup reconciliation. Queued user messages, steering,
+session-level permission grants, and compaction remain deferred there with
+committed future shapes.
+
+### 29.2 Agent-as-tool
+
+The main loop treats agent tools as ordinary sync or async tools. A dedicated
+tool handler may create and execute child turns, forward progress, and return a
+parent tool result. No subflow or parent-turn concept is added to this initial
+turn schema.
+
+### 29.3 Reliability enhancements
+
+- External-input idempotency.
+- Exactly-once async dispatch acknowledgements.
+- Tool retry-safety metadata.
+- Automatic retry policies.
+- Cross-process locking.
+- `fsync` durability.
+- Torn-write repair.
+- Event-stream bounds and backpressure.
+- Large-blob sidecars, if ever required.
+
+### 29.4 API refinements
+
+- Inline agent support if a real use case appears.
+- Explicit tool-argument validation.
+- Shared semantic timeline selectors.
+- Public query projections beyond `getTurn`.
+- Turn listing and deletion APIs.
+
+## 30. Implementation acceptance criteria
+
+The turn layer is implementation-complete only when:
+
+1. All durable schemas are defined and exported from `@x/shared`.
+2. Filesystem storage follows the deterministic partitioned JSONL layout.
+3. `TurnRuntime` uses explicit PROXY constructor injection.
+4. Agent resolution produces one immutable snapshot.
+5. Each model invocation is exactly one AI SDK model step.
+6. Sync, async, permission, suspension, cancellation, and recovery behavior
+   matches this specification.
+7. The pure reducer is shared by core and renderer.
+8. No durable running state exists.
+9. The hot stream is independent of consumer progress.
+10. Every required scenario and focused test group passes using mocked
+    dependencies.
+11. No session, agent-as-tool, compaction, or migration behavior leaks into the
+    turn loop.
diff --git a/apps/x/packages/core/package.json b/apps/x/packages/core/package.json
index 08c2644d..f17f0bc4 100644
--- a/apps/x/packages/core/package.json
+++ b/apps/x/packages/core/package.json
@@ -8,7 +8,9 @@
     "build": "rm -rf dist && tsc -p tsconfig.build.json",
     "dev": "tsc -w -p tsconfig.build.json",
     "test": "vitest run",
-    "test:watch": "vitest"
+    "test:watch": "vitest",
+    "inspect-turn": "node dist/turns/inspect-cli.js",
+    "inspect": "node dist/turns/inspect-cli.js"
   },
   "dependencies": {
     "@agentclientprotocol/claude-agent-acp": "^0.39.0",
@@ -28,6 +30,7 @@
     "@x/shared": "workspace:*",
     "ai": "^5.0.133",
     "awilix": "^12.0.5",
+    "baileys": "7.0.0-rc13",
     "chokidar": "^4.0.3",
     "cors": "^2.8.6",
     "cron-parser": "^5.5.0",
@@ -43,6 +46,7 @@
     "papaparse": "^5.5.3",
     "pdf-parse": "^2.4.5",
     "posthog-node": "^4.18.0",
+    "qrcode": "^1.5.4",
     "react": "^19.2.3",
     "xlsx": "^0.18.5",
     "yaml": "^2.8.2",
@@ -54,6 +58,7 @@
     "@types/node": "^25.0.3",
     "@types/papaparse": "^5.5.2",
     "@types/pdf-parse": "^1.1.5",
+    "@types/qrcode": "^1.5.6",
     "vitest": "catalog:"
   }
 }
diff --git a/apps/x/packages/core/src/agent-schedule/runner.ts b/apps/x/packages/core/src/agent-schedule/runner.ts
index 44dac07d..bd818388 100644
--- a/apps/x/packages/core/src/agent-schedule/runner.ts
+++ b/apps/x/packages/core/src/agent-schedule/runner.ts
@@ -2,13 +2,10 @@ import { CronExpressionParser } from "cron-parser";
 import container from "../di/container.js";
 import { IAgentScheduleRepo } from "./repo.js";
 import { IAgentScheduleStateRepo } from "./state-repo.js";
-import { IRunsRepo } from "../runs/repo.js";
-import { IAgentRuntime } from "../agents/runtime.js";
-import { IMonotonicallyIncreasingIdGenerator } from "../application/lib/id-gen.js";
 import { AgentScheduleConfig, AgentScheduleEntry } from "@x/shared/dist/agent-schedule.js";
 import { AgentScheduleState, AgentScheduleStateEntry } from "@x/shared/dist/agent-schedule-state.js";
-import { MessageEvent } from "@x/shared/dist/runs.js";
-import { createRun } from "../runs/runs.js";
+import { startHeadlessAgent } from "../agents/headless-app.js";
+import { withUseCase } from "../analytics/use_case.js";
 import z from "zod";
 
 const DEFAULT_STARTING_MESSAGE = "go";
@@ -147,10 +144,7 @@ function shouldRunNow(
 async function runAgent(
     agentName: string,
     entry: z.infer<typeof AgentScheduleEntry>,
-    stateRepo: IAgentScheduleStateRepo,
-    runsRepo: IRunsRepo,
-    agentRuntime: IAgentRuntime,
-    idGenerator: IMonotonicallyIncreasingIdGenerator
+    stateRepo: IAgentScheduleStateRepo
 ): Promise<void> {
     console.log(`[AgentRunner] Starting agent: ${agentName}`);
 
@@ -163,31 +157,24 @@ async function runAgent(
     });
 
     try {
-        // Create a new run via core (resolves agent + default model+provider).
-        const run = await createRun({
-            agentId: agentName,
-            useCase: 'copilot_chat',
-            subUseCase: 'scheduled',
-        });
-        console.log(`[AgentRunner] Created run ${run.id} for agent ${agentName}`);
-
-        // Add the starting message as a user message
+        // Start a standalone turn (resolves agent + default model/provider).
+        // Fire-and-forget like the old trigger(): the schedule state machine
+        // below runs on wall-clock; completion is observed only for logging.
+        // The signal caps a hung turn at the same TIMEOUT_MS the state-based
+        // watchdog uses.
         const startingMessage = entry.startingMessage ?? DEFAULT_STARTING_MESSAGE;
-        const messageEvent: z.infer<typeof MessageEvent> = {
-            runId: run.id,
-            type: "message",
-            messageId: await idGenerator.next(),
-            message: {
-                role: "user",
-                content: startingMessage,
-            },
-            subflow: [],
-        };
-        await runsRepo.appendEvents(run.id, [messageEvent]);
-        console.log(`[AgentRunner] Sent starting message to agent ${agentName}: "${startingMessage}"`);
-
-        // Trigger the run
-        await agentRuntime.trigger(run.id);
+        const handle = await withUseCase(
+            { useCase: 'copilot_chat', subUseCase: 'scheduled' },
+            () => startHeadlessAgent({
+                agentId: agentName,
+                message: startingMessage,
+                signal: AbortSignal.timeout(TIMEOUT_MS),
+            }),
+        );
+        console.log(`[AgentRunner] Started turn ${handle.turnId} for agent ${agentName}: "${startingMessage}"`);
+        void handle.done
+            .then((result) => console.log(`[AgentRunner] Turn ${handle.turnId} (${agentName}) settled: ${result.outcome.status}`))
+            .catch((error) => console.error(`[AgentRunner] Turn ${handle.turnId} (${agentName}) errored:`, error instanceof Error ? error.message : error));
 
         // Calculate next run time
         const nextRunAt = calculateNextRunAt(entry.schedule);
@@ -264,9 +251,6 @@ async function checkForTimeouts(
 async function pollAndRun(): Promise<void> {
     const scheduleRepo = container.resolve<IAgentScheduleRepo>("agentScheduleRepo");
     const stateRepo = container.resolve<IAgentScheduleStateRepo>("agentScheduleStateRepo");
-    const runsRepo = container.resolve<IRunsRepo>("runsRepo");
-    const agentRuntime = container.resolve<IAgentRuntime>("agentRuntime");
-    const idGenerator = container.resolve<IMonotonicallyIncreasingIdGenerator>("idGenerator");
 
     // Load config and state
     let config: z.infer<typeof AgentScheduleConfig>;
@@ -314,7 +298,7 @@ async function pollAndRun(): Promise<void> {
 
         if (shouldRunNow(entry, agentState)) {
             // Run agent (don't await - let it run in background)
-            runAgent(agentName, entry, stateRepo, runsRepo, agentRuntime, idGenerator).catch((error) => {
+            runAgent(agentName, entry, stateRepo).catch((error) => {
                 console.error(`[AgentRunner] Unhandled error in runAgent for ${agentName}:`, error);
             });
         }
diff --git a/apps/x/packages/core/src/agents/headless-app.ts b/apps/x/packages/core/src/agents/headless-app.ts
new file mode 100644
index 00000000..d9b78f3a
--- /dev/null
+++ b/apps/x/packages/core/src/agents/headless-app.ts
@@ -0,0 +1,25 @@
+import container from "../di/container.js";
+import {
+    type HeadlessAgentHandle,
+    type HeadlessAgentOptions,
+    type HeadlessAgentResult,
+    type IHeadlessAgentRunner,
+} from "./headless.js";
+
+function runner(): IHeadlessAgentRunner {
+    return container.resolve<IHeadlessAgentRunner>("headlessAgentRunner");
+}
+
+export function startHeadlessAgent(
+    options: HeadlessAgentOptions,
+): Promise<HeadlessAgentHandle> {
+    return runner().start(options);
+}
+
+export function runHeadlessAgent(
+    options: HeadlessAgentOptions,
+): Promise<HeadlessAgentResult & { turnId: string }> {
+    return runner().run(options);
+}
+
+export { toolInputPaths } from "./headless.js";
diff --git a/apps/x/packages/core/src/agents/headless.test.ts b/apps/x/packages/core/src/agents/headless.test.ts
new file mode 100644
index 00000000..1f756ffd
--- /dev/null
+++ b/apps/x/packages/core/src/agents/headless.test.ts
@@ -0,0 +1,300 @@
+import { describe, expect, it, vi } from "vitest";
+import type { z } from "zod";
+import { reduceTurn, type TurnEvent } from "@x/shared/dist/turns.js";
+import type {
+    CreateTurnInput,
+    ITurnRuntime,
+    TurnExecution,
+    TurnOutcome,
+} from "../turns/api.js";
+import {
+    HeadlessRunError,
+    HeadlessAgentRunner,
+    assistantText,
+    lastAssistantText,
+    toolInputPaths,
+} from "./headless.js";
+import type { IDefaultModelResolver } from "../models/default-model-resolver.js";
+
+type TEvent = z.infer<typeof TurnEvent>;
+
+const TURN_ID = "2026-07-02T10-00-00Z-0000001-000";
+const TS = "2026-07-02T10:00:00Z";
+
+const echoTool = {
+    toolId: "builtin:file-editText",
+    name: "file-editText",
+    description: "Edit",
+    inputSchema: {},
+    execution: "sync" as const,
+    requiresHuman: false,
+};
+
+function turnLog(opts: {
+    responseText?: string;
+    toolCalls?: Array<{ id: string; name: string; input: unknown; invoked: boolean }>;
+    failed?: string;
+}): TEvent[] {
+    const events: TEvent[] = [
+        {
+            type: "turn_created",
+            schemaVersion: 1,
+            turnId: TURN_ID,
+            ts: TS,
+            sessionId: null,
+            agent: {
+                requested: { agentId: "worker" },
+                resolved: {
+                    agentId: "worker",
+                    systemPrompt: "SYS",
+                    model: { provider: "fake", model: "m" },
+                    tools: [echoTool],
+                },
+            },
+            context: [],
+            input: { role: "user", content: "go" },
+            config: { autoPermission: true, humanAvailable: false, maxModelCalls: 20 },
+        },
+        {
+            type: "model_call_requested",
+            turnId: TURN_ID,
+            ts: TS,
+            modelCallIndex: 0,
+            request: { messages: ["input"], parameters: {} },
+        },
+    ];
+    const toolCalls = opts.toolCalls ?? [];
+    if (toolCalls.length > 0) {
+        events.push({
+            type: "model_call_completed",
+            turnId: TURN_ID,
+            ts: TS,
+            modelCallIndex: 0,
+            message: {
+                role: "assistant",
+                content: toolCalls.map((tc) => ({
+                    type: "tool-call" as const,
+                    toolCallId: tc.id,
+                    toolName: tc.name,
+                    arguments: tc.input as never,
+                })),
+            },
+            finishReason: "tool-calls",
+            usage: {},
+        });
+        for (const tc of toolCalls) {
+            if (!tc.invoked) continue;
+            events.push({
+                type: "tool_invocation_requested",
+                turnId: TURN_ID,
+                ts: TS,
+                toolCallId: tc.id,
+                toolId: "builtin:" + tc.name,
+                toolName: tc.name,
+                execution: "sync",
+                input: tc.input as never,
+            });
+            events.push({
+                type: "tool_result",
+                turnId: TURN_ID,
+                ts: TS,
+                toolCallId: tc.id,
+                toolName: tc.name,
+                source: "sync",
+                result: { output: "ok", isError: false },
+            });
+        }
+    }
+    if (opts.failed) {
+        events.push({
+            type: "model_call_failed",
+            turnId: TURN_ID,
+            ts: TS,
+            modelCallIndex: 0,
+            error: opts.failed,
+        });
+        events.push({ type: "turn_failed", turnId: TURN_ID, ts: TS, error: opts.failed, usage: {} });
+    } else if (opts.responseText !== undefined && toolCalls.length === 0) {
+        events.push({
+            type: "model_call_completed",
+            turnId: TURN_ID,
+            ts: TS,
+            modelCallIndex: 0,
+            message: { role: "assistant", content: opts.responseText },
+            finishReason: "stop",
+            usage: {},
+        });
+        events.push({
+            type: "turn_completed",
+            turnId: TURN_ID,
+            ts: TS,
+            output: { role: "assistant", content: opts.responseText },
+            finishReason: "stop",
+            usage: {},
+        });
+    }
+    return events;
+}
+
+class FakeRuntime implements ITurnRuntime {
+    createInputs: CreateTurnInput[] = [];
+    constructor(
+        private readonly log: TEvent[],
+        private readonly outcome: TurnOutcome,
+    ) {}
+
+    async createTurn(input: CreateTurnInput): Promise<string> {
+        this.createInputs.push(input);
+        return TURN_ID;
+    }
+
+    advanceTurn(): TurnExecution {
+        return {
+            events: (async function* () {})(),
+            outcome: Promise.resolve(this.outcome),
+        };
+    }
+
+    async getTurn() {
+        return { turnId: TURN_ID, events: this.log };
+    }
+}
+
+const completedOutcome: TurnOutcome = {
+    status: "completed",
+    output: { role: "assistant", content: "done" },
+    finishReason: "stop",
+    usage: {},
+};
+
+function createRunner(
+    runtime: ITurnRuntime,
+    resolve = vi.fn(async () => ({
+        provider: "default-provider",
+        model: "default-model",
+    })),
+): { runner: HeadlessAgentRunner; resolve: IDefaultModelResolver["resolve"] } {
+    return {
+        runner: new HeadlessAgentRunner({
+            turnRuntime: runtime,
+            defaultModelResolver: { resolve },
+        }),
+        resolve,
+    };
+}
+
+describe("headless agent helpers", () => {
+    it("assistantText handles string and parts content", () => {
+        expect(assistantText({ role: "assistant", content: "hi" })).toBe("hi");
+        expect(
+            assistantText({
+                role: "assistant",
+                content: [
+                    { type: "reasoning", text: "hmm" },
+                    { type: "text", text: "a" },
+                    { type: "text", text: "b" },
+                ],
+            }),
+        ).toBe("ab");
+        expect(assistantText({ role: "assistant", content: "" })).toBeNull();
+    });
+
+    it("lastAssistantText returns the final assistant text in the transcript", () => {
+        const state = reduceTurn(turnLog({ responseText: "the summary" }));
+        expect(lastAssistantText(state)).toBe("the summary");
+        expect(lastAssistantText(reduceTurn(turnLog({ failed: "boom" })))).toBeNull();
+    });
+
+    it("toolInputPaths collects paths of invoked calls only", () => {
+        const state = reduceTurn(
+            turnLog({
+                toolCalls: [
+                    { id: "a", name: "file-editText", input: { path: "notes/x.md" }, invoked: true },
+                    { id: "b", name: "file-editText", input: { path: "notes/y.md" }, invoked: true },
+                    { id: "c", name: "file-writeText", input: { path: "notes/z.md" }, invoked: true },
+                    { id: "d", name: "file-editText", input: { path: "never-ran.md" }, invoked: false },
+                ],
+            }),
+        );
+        expect(toolInputPaths(state, ["file-editText"])).toEqual(
+            new Set(["notes/x.md", "notes/y.md"]),
+        );
+        expect(toolInputPaths(state, ["file-writeText"])).toEqual(new Set(["notes/z.md"]));
+    });
+});
+
+describe("HeadlessAgentRunner", () => {
+    it("creates a standalone auto-permission turn and returns the id before settling", async () => {
+        const runtime = new FakeRuntime(turnLog({ responseText: "the summary" }), completedOutcome);
+        const { runner, resolve } = createRunner(runtime);
+        const handle = await runner.start({
+            agentId: "worker",
+            message: "go",
+            model: "m",
+            provider: "fake",
+        });
+        expect(handle.turnId).toBe(TURN_ID);
+        expect(resolve).not.toHaveBeenCalled();
+        expect(runtime.createInputs[0]).toMatchObject({
+            agent: { agentId: "worker", overrides: { model: { provider: "fake", model: "m" } } },
+            sessionId: null,
+            context: [],
+            input: { role: "user", content: "go" },
+            config: { autoPermission: true, humanAvailable: false },
+        });
+        const result = await handle.done;
+        expect(result.outcome.status).toBe("completed");
+        expect(result.summary).toBe("the summary");
+    });
+
+    it("omits the model override when neither model nor provider is set", async () => {
+        const runtime = new FakeRuntime(turnLog({ responseText: "ok" }), completedOutcome);
+        const { runner, resolve } = createRunner(runtime);
+        await runner.start({ agentId: "worker", message: "go" });
+        expect(resolve).not.toHaveBeenCalled();
+        expect(runtime.createInputs[0].agent.overrides).toBeUndefined();
+    });
+
+    it("uses an injected default only for a partial model override", async () => {
+        const runtime = new FakeRuntime(turnLog({ responseText: "ok" }), completedOutcome);
+        const { runner, resolve } = createRunner(runtime);
+        await runner.start({
+            agentId: "worker",
+            message: "go",
+            model: "custom-model",
+        });
+        expect(resolve).toHaveBeenCalledOnce();
+        expect(runtime.createInputs[0].agent.overrides).toEqual({
+            model: { provider: "default-provider", model: "custom-model" },
+        });
+    });
+
+    it("throwOnError rejects done with HeadlessRunError on failed outcomes", async () => {
+        const runtime = new FakeRuntime(turnLog({ failed: "provider exploded" }), {
+            status: "failed",
+            error: "provider exploded",
+            usage: {},
+        });
+        const { runner } = createRunner(runtime);
+        const handle = await runner.start({
+            agentId: "worker",
+            message: "go",
+            throwOnError: true,
+        });
+        await expect(handle.done).rejects.toThrowError(HeadlessRunError);
+        await expect(handle.done).rejects.toThrowError("provider exploded");
+    });
+
+    it("without throwOnError a failed outcome resolves (old wait semantics)", async () => {
+        const runtime = new FakeRuntime(turnLog({ failed: "boom" }), {
+            status: "failed",
+            error: "boom",
+            usage: {},
+        });
+        const { runner } = createRunner(runtime);
+        const handle = await runner.start({ agentId: "worker", message: "go" });
+        const result = await handle.done;
+        expect(result.outcome.status).toBe("failed");
+        expect(result.summary).toBeNull();
+    });
+});
diff --git a/apps/x/packages/core/src/agents/headless.ts b/apps/x/packages/core/src/agents/headless.ts
new file mode 100644
index 00000000..d974a5fd
--- /dev/null
+++ b/apps/x/packages/core/src/agents/headless.ts
@@ -0,0 +1,182 @@
+import type { z } from "zod";
+import type { AssistantMessage } from "@x/shared/dist/message.js";
+import {
+    reduceTurn,
+    type TurnState,
+} from "@x/shared/dist/turns.js";
+import type { ITurnRuntime, TurnOutcome } from "../turns/api.js";
+import type { IDefaultModelResolver } from "../models/default-model-resolver.js";
+
+// Drop-in replacement for the old headless runs pattern
+// (createRun → createMessage → waitForRunCompletion → extractAgentResponse):
+// one standalone turn per invocation (sessionId null, automatic permissions,
+// no human). HeadlessAgentRunner.start returns the turn id immediately (callers
+// record it in pointer files / bus events before completion); `done` settles
+// with the outcome, the reduced turn state, and the final assistant text.
+
+export class HeadlessRunError extends Error {
+    constructor(
+        message: string,
+        readonly turnId: string,
+        readonly outcome: TurnOutcome,
+    ) {
+        super(message);
+        this.name = "HeadlessRunError";
+    }
+}
+
+export interface HeadlessAgentOptions {
+    agentId: string;
+    message: string;
+    // Model id; when set without provider, the app-default provider applies.
+    model?: string;
+    provider?: string;
+    maxModelCalls?: number;
+    signal?: AbortSignal;
+    // Old waitForRunCompletion({ throwOnError: true }) semantics: `done`
+    // rejects with HeadlessRunError unless the turn completes.
+    throwOnError?: boolean;
+}
+
+export interface HeadlessAgentResult {
+    outcome: TurnOutcome;
+    state: TurnState;
+    // Last assistant text in the transcript (old extractAgentResponse).
+    summary: string | null;
+}
+
+export interface HeadlessAgentHandle {
+    turnId: string;
+    done: Promise<HeadlessAgentResult>;
+}
+
+export interface HeadlessAgentRunnerDependencies {
+    turnRuntime: ITurnRuntime;
+    defaultModelResolver: IDefaultModelResolver;
+}
+
+export interface IHeadlessAgentRunner {
+    start(options: HeadlessAgentOptions): Promise<HeadlessAgentHandle>;
+    run(
+        options: HeadlessAgentOptions,
+    ): Promise<HeadlessAgentResult & { turnId: string }>;
+}
+
+export function assistantText(
+    message: z.infer<typeof AssistantMessage>,
+): string | null {
+    const content = message.content;
+    if (typeof content === "string") {
+        return content || null;
+    }
+    const text = content
+        .map((part) => (part.type === "text" ? part.text : ""))
+        .join("");
+    return text || null;
+}
+
+export function lastAssistantText(state: TurnState): string | null {
+    for (let i = state.modelCalls.length - 1; i >= 0; i--) {
+        const response = state.modelCalls[i].response;
+        if (response) {
+            const text = assistantText(response);
+            if (text) {
+                return text;
+            }
+        }
+    }
+    return null;
+}
+
+// Paths passed to the given file tools across the turn — replaces the old
+// pattern of subscribing to the run bus for tool-invocation events. Only
+// actually-invoked calls count (denied/unknown calls never ran).
+export function toolInputPaths(
+    state: TurnState,
+    toolNames: string[],
+): Set<string> {
+    const paths = new Set<string>();
+    for (const toolCall of state.toolCalls) {
+        if (!toolNames.includes(toolCall.toolName) || !toolCall.invocation) {
+            continue;
+        }
+        const input = toolCall.input as { path?: unknown } | null | undefined;
+        if (input && typeof input === "object" && typeof input.path === "string") {
+            paths.add(input.path);
+        }
+    }
+    return paths;
+}
+
+export class HeadlessAgentRunner implements IHeadlessAgentRunner {
+    private readonly turnRuntime: ITurnRuntime;
+    private readonly defaultModelResolver: IDefaultModelResolver;
+
+    constructor({
+        turnRuntime,
+        defaultModelResolver,
+    }: HeadlessAgentRunnerDependencies) {
+        this.turnRuntime = turnRuntime;
+        this.defaultModelResolver = defaultModelResolver;
+    }
+
+    async start(options: HeadlessAgentOptions): Promise<HeadlessAgentHandle> {
+        let modelOverride: { provider: string; model: string } | undefined;
+        if (options.model && options.provider) {
+            modelOverride = { provider: options.provider, model: options.model };
+        } else if (options.model || options.provider) {
+            const defaults = await this.defaultModelResolver.resolve();
+            modelOverride = {
+                provider: options.provider ?? defaults.provider,
+                model: options.model ?? defaults.model,
+            };
+        }
+
+        const turnId = await this.turnRuntime.createTurn({
+            agent: {
+                agentId: options.agentId,
+                ...(modelOverride ? { overrides: { model: modelOverride } } : {}),
+            },
+            sessionId: null,
+            context: [],
+            input: { role: "user", content: options.message },
+            config: {
+                autoPermission: true,
+                humanAvailable: false,
+                ...(options.maxModelCalls === undefined
+                    ? {}
+                    : { maxModelCalls: options.maxModelCalls }),
+            },
+        });
+
+        const execution = this.turnRuntime.advanceTurn(turnId, undefined, {
+            signal: options.signal,
+        });
+        const done = execution.outcome.then(async (outcome) => {
+            const state = reduceTurn(
+                (await this.turnRuntime.getTurn(turnId)).events,
+            );
+            if (options.throwOnError && outcome.status !== "completed") {
+                throw new HeadlessRunError(
+                    outcome.status === "failed"
+                        ? outcome.error
+                        : `turn ${outcome.status}`,
+                    turnId,
+                    outcome,
+                );
+            }
+            return { outcome, state, summary: lastAssistantText(state) };
+        });
+        // The handle may be used fire-and-forget; rejections surface when awaited.
+        done.catch(() => undefined);
+        return { turnId, done };
+    }
+
+    async run(
+        options: HeadlessAgentOptions,
+    ): Promise<HeadlessAgentResult & { turnId: string }> {
+        const handle = await this.start(options);
+        const result = await handle.done;
+        return { turnId: handle.turnId, ...result };
+    }
+}
diff --git a/apps/x/packages/core/src/agents/runtime.ts b/apps/x/packages/core/src/agents/runtime.ts
index 8e4f4a0e..73ca5007 100644
--- a/apps/x/packages/core/src/agents/runtime.ts
+++ b/apps/x/packages/core/src/agents/runtime.ts
@@ -114,7 +114,7 @@ function filePermissionTargets(toolName: string, args: Record<string, unknown>):
     }
 }
 
-async function getToolPermissionMetadata(
+export async function getToolPermissionMetadata(
     toolCall: z.infer<typeof ToolCallPart>,
     underlyingTool: z.infer<typeof ToolAttachment>,
     sessionAllowedCommands: Set<string>,
@@ -172,7 +172,7 @@ async function getToolPermissionMetadata(
     };
 }
 
-function loadUserWorkDir(runId: string): string | null {
+export function loadUserWorkDir(runId: string): string | null {
     try {
         const file = workDirConfigFile(runId);
         if (!fs.existsSync(file)) return null;
@@ -185,7 +185,7 @@ function loadUserWorkDir(runId: string): string | null {
     }
 }
 
-function loadAgentNotesContext(): string | null {
+export function loadAgentNotesContext(): string | null {
     const sections: string[] = [];
 
     const userFile = path.join(AGENT_NOTES_DIR, 'user.md');
@@ -327,6 +327,129 @@ If Middle pane state is note, the supplied path and content are available so you
 
 If Middle pane state is browser, only the URL and page title are supplied; the page content itself is NOT included. If you need the page content to answer, use the browser tools available to you to read the page. The user may or may not be talking about this page. Only reference or act on this page when the user's message clearly relates to it, such as "this page", "this article", "what I'm looking at", "this site", or "summarize this". For unrelated questions, ignore this page entirely and answer normally. Do not mention that you can see the browser unless it is relevant to the answer.`;
 
+
+export interface ComposeSystemInstructionsInput {
+    instructions: string;
+    agentNotesContext: string | null;
+    userWorkDir: string | null;
+    voiceInput: boolean;
+    voiceOutput: 'summary' | 'full' | null;
+    searchEnabled: boolean;
+    codeMode: 'claude' | 'codex' | null;
+    codeCwd: string | null;
+    // Optional so legacy callers (old streamAgent path) are unaffected.
+    videoMode?: boolean;
+    coachMode?: boolean;
+}
+
+// System-prompt assembly, extracted verbatim from streamAgent so the new turn
+// runtime's agent resolver composes byte-identical prompts. Pure: callers
+// load agent notes / work dir themselves.
+export function composeSystemInstructions({
+    instructions,
+    agentNotesContext,
+    userWorkDir,
+    voiceInput,
+    voiceOutput,
+    searchEnabled,
+    codeMode,
+    codeCwd,
+    videoMode,
+    coachMode,
+}: ComposeSystemInstructionsInput): string {
+    let instructionsWithDateTime = `${instructions}\n\n${USER_CONTEXT_SYSTEM_INSTRUCTIONS}`;
+        if (agentNotesContext) {
+            instructionsWithDateTime += `\n\n${agentNotesContext}`;
+        }
+        if (userWorkDir) {
+                instructionsWithDateTime += `\n\n# User Work Directory
+The user has chosen the following directory as their current **work directory**:
+
+\`${userWorkDir}\`
+
+Treat this as the **default location** for file operations whenever the user refers to files generically:
+- "list the files", "show me what's in here", "what's the latest report" — list or look in the work directory.
+- "save this", "export it", "write that to a file" — write the output into the work directory unless the user names another location.
+- "open the file I was just working on", "the doc from earlier" — assume the work directory first.
+
+Use absolute paths rooted at this directory with the \`file-*\` tools. For example, list with \`file-list({ path: "${userWorkDir}" })\`, read text with \`file-readText\`, and write text with \`file-writeText\`. For PDFs, Office docs, images, scanned docs, and other non-text files, use \`parseFile\` or \`LLMParse\` with the absolute path; you do NOT need to copy the file into the workspace first.
+
+**Exceptions — these ALWAYS take precedence over the work directory default:**
+1. **Knowledge base questions.** If the user asks about anything in the knowledge graph (notes, people, organizations, projects, topics) or paths starting with \`knowledge/\`, use file tools against \`knowledge/\` as documented above. Do NOT redirect those into the work directory.
+2. **Explicit paths.** If the user names a different directory or gives an absolute/relative path (e.g. "in ~/Downloads", "from /tmp/foo", "the Desktop"), honor that path exactly and ignore the work-directory default for that request.
+3. **Workspace-specific operations.** Anything that obviously belongs in the Rowboat workspace (config files, MCP servers, agent schedules, etc.) stays in the workspace, not the work directory.
+
+Do not announce the work directory unless it's relevant. Just use it.`;
+        }
+        if (voiceInput) {
+            instructionsWithDateTime += `\n\n# Voice Input\nThe user's message was transcribed from speech. Be aware that:\n- There may be transcription errors. Silently correct obvious ones (e.g. homophones, misheard words). If an error is genuinely ambiguous, briefly mention your interpretation (e.g. "I'm assuming you meant X").\n- Spoken messages are often long-winded. The user may ramble, repeat themselves, or correct something they said earlier in the same message. Focus on their final intent, not every word verbatim.`;
+        }
+        if (videoMode) {
+            instructionsWithDateTime += `\n\n# Video Mode (Live Camera)
+The user has turned on video mode: their webcam is on, and their messages arrive with a series of live webcam frames (ordered oldest to newest) captured while they were speaking or typing. The frames are a live view of the user themselves — not a document or file to analyze.
+
+How to use the frames:
+- Use them for what visual awareness genuinely adds: the user's expressions, body language, posture, gestures, eye contact with the camera, visible energy, anything they hold up to the camera, and their surroundings when relevant.
+- Compare across frames to notice change over time within a message (e.g. increasingly slouched, started smiling, looked away for most of the message).
+- When the user practices something performative (a pitch, presentation, interview, talk) or asks for delivery feedback, give specific, actionable coaching grounded in what you actually see — cite concrete observations ("in the last few frames you looked down and away from the camera") rather than generic advice. Cover posture, eye contact, facial expressiveness, gesturing, and visible energy.
+- If they show something to the camera (an object, document, whiteboard), read or describe it and respond accordingly.
+
+Driving the app:
+- You can control the Rowboat app the user is looking at via the app-navigation tool (load the app-navigation skill first): open views, READ a view's contents as data (emails, background agents, chat history), and open specific items on their screen.
+- When the user asks about anything that lives inside Rowboat ("what emails do I have?", "what agents are running?", "open the one from Arjun"), prefer driving over describing: read-view shows the view on their screen while returning its data, then answer out loud briefly; open-item when they pick one. Narrate as you act ("pulling up your inbox…"). Reading a view's data beats squinting at screen-share frames — it's exact.
+
+Screen sharing:
+- The user may also share their screen. Screen-share frames arrive in a separately labeled group after the webcam frames; they show the user's screen, not the user.
+- When screen frames are present, treat them as the primary subject: the user is usually asking about, or working on, what's visible there. Read the screen carefully — code, documents, error messages, UI state — and help with it concretely.
+- The LAST screen frame is the most current view of their screen; earlier ones show how it changed while they spoke.
+- Frames are downscaled captures: small text may be hard to read. If something crucial is illegible, say what you need ("zoom into the error message" / "make that panel bigger") rather than guessing.
+
+Etiquette:
+- Do not narrate or list what you see in every response. Bring up visual observations only when relevant to the user's request or clearly worth mentioning.
+- Never comment on the user's physical appearance, attractiveness, or personal attributes — visual feedback is strictly about delivery, expression, and body language.
+- Frames are periodic snapshots, not continuous video; moments between frames are missing. Don't claim certainty about motion you couldn't have seen.`;
+        }
+        if (coachMode) {
+            instructionsWithDateTime += `\n\n# Practice Session (Coach Mode)
+The user started a practice session: they are rehearsing something performative — a pitch, presentation, interview answer, or talk — and want live coaching. You are their coach for this session.
+
+How to coach:
+- Watch and listen for delivery: pacing, filler words, rambling, structure, and (from the webcam frames) posture, eye contact with the camera, facial expressiveness, gesturing, and visible energy.
+- After each take or answer, give brief, specific, actionable feedback: 2-3 concrete observations, quoting what you actually saw or heard ("you looked down during the ask", "the opening 'um, so, basically' undercuts your hook"). Then let them go again.
+- If they are clearly mid-flow, keep any interjection to one short sentence — or stay silent and save it for the break.
+- Ask what they're practicing for at the start if it isn't obvious (investor pitch? interview? conference talk?) and tailor feedback to that audience.
+- When they say they're done or wrap up, give a structured debrief: what's working, the top 3 things to improve, and one concrete drill or reframe to try next time.
+- Be encouraging but honest — vague praise wastes their rehearsal time. Never comment on physical appearance; delivery, expression, and body language only.`;
+        }
+        if (voiceOutput === 'summary') {
+            instructionsWithDateTime += `\n\n# Voice Output (MANDATORY — READ THIS FIRST)\nThe user has voice output enabled. THIS IS YOUR #1 PRIORITY: you MUST start your response with <voice></voice> tags. If your response does not begin with <voice> tags, the user will hear nothing — which is a broken experience. NEVER skip this.\n\nRules:\n1. YOUR VERY FIRST OUTPUT MUST BE A <voice> TAG. No exceptions. Do not start with markdown, headings, or any other text. The literal first characters of your response must be "<voice>".\n2. Place ALL <voice> tags at the BEGINNING of your response, before any detailed content. Do NOT intersperse <voice> tags throughout the response.\n3. Wrap EACH spoken sentence in its own separate <voice> tag so it can be spoken incrementally. Do NOT wrap everything in a single <voice> block.\n4. Use voice as a TL;DR and navigation aid — do NOT read the entire response aloud.\n5. After all <voice> tags, you may include detailed written content (markdown, tables, code, etc.) that will be shown visually but not spoken.\n\n## Examples\n\nExample 1 — User asks: "what happened in my meeting with Alex yesterday?"\n\n<voice>Your meeting with Alex covered three main things: the Q2 roadmap timeline, hiring for the backend role, and the client demo next week.</voice>\n<voice>I've pulled out the key details and action items below — the demo prep notes are at the end.</voice>\n\n## Meeting with Alex — March 11\n### Roadmap\n- Agreed to push Q2 launch to April 15...\n(detailed written content continues)\n\nExample 2 — User asks: "summarize my emails"\n\n<voice>You have five new emails since this morning.</voice>\n<voice>Two are from your team — Jordan sent the RFC you requested and Taylor flagged a contract issue.</voice>\n<voice>There's also a warm intro from a VC partner connecting you with someone at a prospective customer.</voice>\n<voice>I've drafted responses for three of them. The details and drafts are below.</voice>\n\n(email blocks, tables, and detailed content follow)\n\nExample 3 — User asks: "what's on my calendar today?"\n\n<voice>You've got a pretty packed day — seven meetings starting with standup at 9.</voice>\n<voice>The big ones are your investor call at 11, lunch with a partner from your lead VC at 12:30, and a customer call at 4.</voice>\n<voice>Your only free block for deep work is 2:30 to 4.</voice>\n\n(calendar block with full event details follows)\n\nExample 4 — User asks: "draft an email to Sam with our metrics"\n\n<voice>Done — I've drafted the email to Sam with your latest WAU and churn numbers.</voice>\n<voice>Take a look at the draft below and send it when you're ready.</voice>\n\n(email block with draft follows)\n\nREMEMBER: If you do not start with <voice> tags, the user hears silence. Always speak first, then write.`;
+        } else if (voiceOutput === 'full') {
+            instructionsWithDateTime += `\n\n# Voice Output — Full Read-Aloud (MANDATORY — READ THIS FIRST)\nThe user wants your ENTIRE response spoken aloud. THIS IS YOUR #1 PRIORITY: every single sentence must be wrapped in <voice></voice> tags. If you write anything outside <voice> tags, the user will not hear it — which is a broken experience. NEVER skip this.\n\nRules:\n1. YOUR VERY FIRST OUTPUT MUST BE A <voice> TAG. No exceptions. The literal first characters of your response must be "<voice>".\n2. Wrap EACH sentence in its own separate <voice> tag so it can be spoken incrementally.\n3. Write your response in a natural, conversational style suitable for listening — no markdown headings, bullet points, or formatting symbols. Use plain spoken language.\n4. Structure the content as if you are speaking to the user directly. Use transitions like "first", "also", "one more thing" instead of visual formatting.\n5. EVERY sentence MUST be inside a <voice> tag. Do not leave ANY content outside <voice> tags. If it's not in a <voice> tag, the user cannot hear it.\n\n## Examples\n\nExample 1 — User asks: "what happened in my meeting with Alex yesterday?"\n\n<voice>Your meeting with Alex covered three main things.</voice>\n<voice>First, you discussed the Q2 roadmap timeline and agreed to push the launch to April.</voice>\n<voice>Second, you talked about hiring for the backend role — Alex will send over two candidates by Friday.</voice>\n<voice>And lastly, the client demo is next week on Thursday at 2pm, and you're handling the intro slides.</voice>\n\nExample 2 — User asks: "summarize my emails"\n\n<voice>You've got five new emails since this morning.</voice>\n<voice>Two are from your team — Jordan sent the RFC you asked for, and Taylor flagged a contract issue that needs your sign-off.</voice>\n<voice>There's a warm intro from a VC partner connecting you with an engineering lead at a potential customer.</voice>\n<voice>And someone from a prospective client wants to confirm your API tier before your call this afternoon.</voice>\n<voice>I've drafted replies for three of them — the metrics update, the intro, and the API question.</voice>\n<voice>The only one I left for you is Taylor's contract redline, since that needs your judgment on the liability cap.</voice>\n\nExample 3 — User asks: "what's on my calendar today?"\n\n<voice>You've got a packed day — seven meetings starting with standup at 9.</voice>\n<voice>The highlights are your investor call at 11, lunch with a VC partner at 12:30, and a customer call at 4.</voice>\n<voice>Your only open block for deep work is 2:30 to 4, so plan accordingly.</voice>\n<voice>Oh, and your 1-on-1 with your co-founder is at 5:30 — that's a walking meeting.</voice>\n\nExample 4 — User asks: "how are our metrics looking?"\n\n<voice>Metrics are looking strong this week.</voice>\n<voice>You hit 2,573 weekly active users, which is up 12% week over week.</voice>\n<voice>That means you've crossed the 2,500 milestone — worth calling out in your next investor update.</voice>\n<voice>Churn is down to 4.1%, improving month over month.</voice>\n<voice>The trailing 8-week compound growth rate is about 10%.</voice>\n\nREMEMBER: Start with <voice> immediately. No preamble, no markdown before it. Speak first.`;
+        }
+        if (searchEnabled) {
+            instructionsWithDateTime += `\n\n# Search\nThe user has requested a search. Use the web-search tool to answer their query.`;
+        }
+        if (codeMode) {
+            const agentDisplay = codeMode === 'claude' ? 'Claude Code' : 'Codex';
+            instructionsWithDateTime += `\n\n# Code Mode (Active) — Agent: ${agentDisplay}
+The user has turned on **code mode** and the composer chip is set to **${agentDisplay}** (\`${codeMode}\`). For EVERY coding task this turn, use **${agentDisplay}**, and narrate that agent ("Using ${agentDisplay} to …").
+
+The chip is the single source of truth for which agent runs:
+- Do NOT carry over a different agent from earlier in this thread — even if a previous run used the other agent, use **${agentDisplay}** now.
+- Do NOT switch agents based on an in-chat text request ("use codex", "switch to claude"). The agent only changes when the user toggles the chip; if they ask in chat, tell them to toggle the chip.
+
+**How to run coding work — call the \`code_agent_run\` tool** with:
+- \`agent\`: \`${codeMode}\` (always — match the chip).
+- \`cwd\`: ${codeCwd ? `\`${codeCwd}\` (always — this coding session is pinned to that directory; never use another path)` : `the absolute project/working directory (resolve it per the code-with-agents skill — a path the user named, the "# User Work Directory" block, or ask once)`}.
+- \`prompt\`: a clear, self-contained coding instruction.
+
+The tool runs the agent on-device and streams its tool calls, file diffs, and plan into the chat; any action needing approval surfaces as an inline permission card, so you do NOT pre-confirm with an in-chat "reply yes". This chat keeps ONE persistent agent session, so follow-up coding requests automatically resume with full context — just call \`code_agent_run\` again. Do NOT shell out to \`acpx\` or \`executeCommand\` for coding, and do NOT fall back to your own file tools.
+
+If the user's message is clearly NOT a coding request (small talk, an unrelated question), answer directly without invoking the coding agent. Code mode signals readiness, not that every message must route through the agent.`;
+        }
+        return instructionsWithDateTime;
+}
+
 export interface IAgentRuntime {
     trigger(runId: string): Promise<void>;
 }
@@ -861,15 +984,27 @@ export function convertFromMessages(messages: z.infer<typeof Message>[]): ModelM
                         providerOptions,
                     });
                 } else {
-                    // New content parts array — collapse to text for LLM
+                    // New content parts array — collapse text/attachments to text
+                    // for the LLM; inline image parts (video-mode webcam and
+                    // screen-share frames) are passed through as real multimodal
+                    // image parts, grouped under labeled text headers so the
+                    // model knows which images show the user vs their screen.
                     const textSegments: string[] = userMessageContextPrefix ? [userMessageContextPrefix] : [];
                     const attachmentLines: string[] = [];
+                    type EncodedImagePart = { type: "image"; image: string; mediaType: string };
+                    const cameraParts: EncodedImagePart[] = [];
+                    const screenParts: EncodedImagePart[] = [];
+                    const frameTimes: string[] = [];
 
                     for (const part of msg.content) {
                         if (part.type === "attachment") {
                             const sizeStr = part.size ? `, ${formatBytes(part.size)}` : '';
                             const lineStr = part.lineNumber ? ` (line ${part.lineNumber})` : '';
                             attachmentLines.push(`- ${part.filename} (${part.mimeType}${sizeStr}) at ${part.path}${lineStr}`);
+                        } else if (part.type === "image") {
+                            const target = part.source === "screen" ? screenParts : cameraParts;
+                            target.push({ type: "image", image: part.data, mediaType: part.mediaType });
+                            if (part.capturedAt) frameTimes.push(part.capturedAt);
                         } else {
                             textSegments.push(part.text);
                         }
@@ -883,11 +1018,38 @@ export function convertFromMessages(messages: z.infer<typeof Message>[]): ModelM
                         }
                     }
 
-                    result.push({
-                        role: "user",
-                        content: textSegments.join("\n"),
-                        providerOptions,
-                    });
+                    const imageCount = cameraParts.length + screenParts.length;
+                    if (imageCount > 0) {
+                        const span = frameTimes.length >= 2
+                            ? ` spanning ${frameTimes[0]} to ${frameTimes[frameTimes.length - 1]}`
+                            : frameTimes.length === 1
+                                ? ` captured at ${frameTimes[0]}`
+                                : '';
+                        const kinds: string[] = [];
+                        if (cameraParts.length > 0) kinds.push(`${cameraParts.length} live webcam frame${cameraParts.length === 1 ? '' : 's'} of the user`);
+                        if (screenParts.length > 0) kinds.push(`${screenParts.length} frame${screenParts.length === 1 ? '' : 's'} of the user's shared screen`);
+                        textSegments.push(`[Video mode: ${kinds.join(' and ')} attached below, each group oldest to newest,${span ? span + ',' : ''} recorded while they composed this message.]`);
+                        const content: Array<{ type: "text"; text: string } | EncodedImagePart> = [
+                            { type: "text", text: textSegments.join("\n") },
+                        ];
+                        if (cameraParts.length > 0) {
+                            content.push({ type: "text", text: "Webcam frames (oldest to newest):" }, ...cameraParts);
+                        }
+                        if (screenParts.length > 0) {
+                            content.push({ type: "text", text: "Screen-share frames (oldest to newest):" }, ...screenParts);
+                        }
+                        result.push({
+                            role: "user",
+                            content,
+                            providerOptions,
+                        });
+                    } else {
+                        result.push({
+                            role: "user",
+                            content: textSegments.join("\n"),
+                            providerOptions,
+                        });
+                    }
                 }
                 break;
             }
@@ -1423,70 +1585,17 @@ export async function* streamAgent({
         loopLogger.log('running llm turn');
         // stream agent response and build message
         const messageBuilder = new StreamStepMessageBuilder();
-        let instructionsWithDateTime = `${agent.instructions}\n\n${USER_CONTEXT_SYSTEM_INSTRUCTIONS}`;
-        // Inject Agent Notes context for copilot
-        if (state.agentName === 'copilot' || state.agentName === 'rowboatx') {
-            const agentNotesContext = loadAgentNotesContext();
-            if (agentNotesContext) {
-                instructionsWithDateTime += `\n\n${agentNotesContext}`;
-            }
-            const userWorkDir = loadUserWorkDir(runId);
-            if (userWorkDir) {
-                loopLogger.log('injecting user work directory', userWorkDir);
-                instructionsWithDateTime += `\n\n# User Work Directory
-The user has chosen the following directory as their current **work directory**:
-
-\`${userWorkDir}\`
-
-Treat this as the **default location** for file operations whenever the user refers to files generically:
-- "list the files", "show me what's in here", "what's the latest report" — list or look in the work directory.
-- "save this", "export it", "write that to a file" — write the output into the work directory unless the user names another location.
-- "open the file I was just working on", "the doc from earlier" — assume the work directory first.
-
-Use absolute paths rooted at this directory with the \`file-*\` tools. For example, list with \`file-list({ path: "${userWorkDir}" })\`, read text with \`file-readText\`, and write text with \`file-writeText\`. For PDFs, Office docs, images, scanned docs, and other non-text files, use \`parseFile\` or \`LLMParse\` with the absolute path; you do NOT need to copy the file into the workspace first.
-
-**Exceptions — these ALWAYS take precedence over the work directory default:**
-1. **Knowledge base questions.** If the user asks about anything in the knowledge graph (notes, people, organizations, projects, topics) or paths starting with \`knowledge/\`, use file tools against \`knowledge/\` as documented above. Do NOT redirect those into the work directory.
-2. **Explicit paths.** If the user names a different directory or gives an absolute/relative path (e.g. "in ~/Downloads", "from /tmp/foo", "the Desktop"), honor that path exactly and ignore the work-directory default for that request.
-3. **Workspace-specific operations.** Anything that obviously belongs in the Rowboat workspace (config files, MCP servers, agent schedules, etc.) stays in the workspace, not the work directory.
-
-Do not announce the work directory unless it's relevant. Just use it.`;
-            }
-        }
-        if (voiceInput) {
-            loopLogger.log('voice input enabled, injecting voice input prompt');
-            instructionsWithDateTime += `\n\n# Voice Input\nThe user's message was transcribed from speech. Be aware that:\n- There may be transcription errors. Silently correct obvious ones (e.g. homophones, misheard words). If an error is genuinely ambiguous, briefly mention your interpretation (e.g. "I'm assuming you meant X").\n- Spoken messages are often long-winded. The user may ramble, repeat themselves, or correct something they said earlier in the same message. Focus on their final intent, not every word verbatim.`;
-        }
-        if (voiceOutput === 'summary') {
-            loopLogger.log('voice output enabled (summary mode), injecting voice output prompt');
-            instructionsWithDateTime += `\n\n# Voice Output (MANDATORY — READ THIS FIRST)\nThe user has voice output enabled. THIS IS YOUR #1 PRIORITY: you MUST start your response with <voice></voice> tags. If your response does not begin with <voice> tags, the user will hear nothing — which is a broken experience. NEVER skip this.\n\nRules:\n1. YOUR VERY FIRST OUTPUT MUST BE A <voice> TAG. No exceptions. Do not start with markdown, headings, or any other text. The literal first characters of your response must be "<voice>".\n2. Place ALL <voice> tags at the BEGINNING of your response, before any detailed content. Do NOT intersperse <voice> tags throughout the response.\n3. Wrap EACH spoken sentence in its own separate <voice> tag so it can be spoken incrementally. Do NOT wrap everything in a single <voice> block.\n4. Use voice as a TL;DR and navigation aid — do NOT read the entire response aloud.\n5. After all <voice> tags, you may include detailed written content (markdown, tables, code, etc.) that will be shown visually but not spoken.\n\n## Examples\n\nExample 1 — User asks: "what happened in my meeting with Alex yesterday?"\n\n<voice>Your meeting with Alex covered three main things: the Q2 roadmap timeline, hiring for the backend role, and the client demo next week.</voice>\n<voice>I've pulled out the key details and action items below — the demo prep notes are at the end.</voice>\n\n## Meeting with Alex — March 11\n### Roadmap\n- Agreed to push Q2 launch to April 15...\n(detailed written content continues)\n\nExample 2 — User asks: "summarize my emails"\n\n<voice>You have five new emails since this morning.</voice>\n<voice>Two are from your team — Jordan sent the RFC you requested and Taylor flagged a contract issue.</voice>\n<voice>There's also a warm intro from a VC partner connecting you with someone at a prospective customer.</voice>\n<voice>I've drafted responses for three of them. The details and drafts are below.</voice>\n\n(email blocks, tables, and detailed content follow)\n\nExample 3 — User asks: "what's on my calendar today?"\n\n<voice>You've got a pretty packed day — seven meetings starting with standup at 9.</voice>\n<voice>The big ones are your investor call at 11, lunch with a partner from your lead VC at 12:30, and a customer call at 4.</voice>\n<voice>Your only free block for deep work is 2:30 to 4.</voice>\n\n(calendar block with full event details follows)\n\nExample 4 — User asks: "draft an email to Sam with our metrics"\n\n<voice>Done — I've drafted the email to Sam with your latest WAU and churn numbers.</voice>\n<voice>Take a look at the draft below and send it when you're ready.</voice>\n\n(email block with draft follows)\n\nREMEMBER: If you do not start with <voice> tags, the user hears silence. Always speak first, then write.`;
-        } else if (voiceOutput === 'full') {
-            loopLogger.log('voice output enabled (full mode), injecting voice output prompt');
-            instructionsWithDateTime += `\n\n# Voice Output — Full Read-Aloud (MANDATORY — READ THIS FIRST)\nThe user wants your ENTIRE response spoken aloud. THIS IS YOUR #1 PRIORITY: every single sentence must be wrapped in <voice></voice> tags. If you write anything outside <voice> tags, the user will not hear it — which is a broken experience. NEVER skip this.\n\nRules:\n1. YOUR VERY FIRST OUTPUT MUST BE A <voice> TAG. No exceptions. The literal first characters of your response must be "<voice>".\n2. Wrap EACH sentence in its own separate <voice> tag so it can be spoken incrementally.\n3. Write your response in a natural, conversational style suitable for listening — no markdown headings, bullet points, or formatting symbols. Use plain spoken language.\n4. Structure the content as if you are speaking to the user directly. Use transitions like "first", "also", "one more thing" instead of visual formatting.\n5. EVERY sentence MUST be inside a <voice> tag. Do not leave ANY content outside <voice> tags. If it's not in a <voice> tag, the user cannot hear it.\n\n## Examples\n\nExample 1 — User asks: "what happened in my meeting with Alex yesterday?"\n\n<voice>Your meeting with Alex covered three main things.</voice>\n<voice>First, you discussed the Q2 roadmap timeline and agreed to push the launch to April.</voice>\n<voice>Second, you talked about hiring for the backend role — Alex will send over two candidates by Friday.</voice>\n<voice>And lastly, the client demo is next week on Thursday at 2pm, and you're handling the intro slides.</voice>\n\nExample 2 — User asks: "summarize my emails"\n\n<voice>You've got five new emails since this morning.</voice>\n<voice>Two are from your team — Jordan sent the RFC you asked for, and Taylor flagged a contract issue that needs your sign-off.</voice>\n<voice>There's a warm intro from a VC partner connecting you with an engineering lead at a potential customer.</voice>\n<voice>And someone from a prospective client wants to confirm your API tier before your call this afternoon.</voice>\n<voice>I've drafted replies for three of them — the metrics update, the intro, and the API question.</voice>\n<voice>The only one I left for you is Taylor's contract redline, since that needs your judgment on the liability cap.</voice>\n\nExample 3 — User asks: "what's on my calendar today?"\n\n<voice>You've got a packed day — seven meetings starting with standup at 9.</voice>\n<voice>The highlights are your investor call at 11, lunch with a VC partner at 12:30, and a customer call at 4.</voice>\n<voice>Your only open block for deep work is 2:30 to 4, so plan accordingly.</voice>\n<voice>Oh, and your 1-on-1 with your co-founder is at 5:30 — that's a walking meeting.</voice>\n\nExample 4 — User asks: "how are our metrics looking?"\n\n<voice>Metrics are looking strong this week.</voice>\n<voice>You hit 2,573 weekly active users, which is up 12% week over week.</voice>\n<voice>That means you've crossed the 2,500 milestone — worth calling out in your next investor update.</voice>\n<voice>Churn is down to 4.1%, improving month over month.</voice>\n<voice>The trailing 8-week compound growth rate is about 10%.</voice>\n\nREMEMBER: Start with <voice> immediately. No preamble, no markdown before it. Speak first.`;
-        }
-        if (searchEnabled) {
-            loopLogger.log('search enabled, injecting search prompt');
-            instructionsWithDateTime += `\n\n# Search\nThe user has requested a search. Use the web-search tool to answer their query.`;
-        }
-        if (codeMode) {
-            loopLogger.log('code mode enabled, injecting coding-agent context', codeMode);
-            const agentDisplay = codeMode === 'claude' ? 'Claude Code' : 'Codex';
-            instructionsWithDateTime += `\n\n# Code Mode (Active) — Agent: ${agentDisplay}
-The user has turned on **code mode** and the composer chip is set to **${agentDisplay}** (\`${codeMode}\`). For EVERY coding task this turn, use **${agentDisplay}**, and narrate that agent ("Using ${agentDisplay} to …").
-
-The chip is the single source of truth for which agent runs:
-- Do NOT carry over a different agent from earlier in this thread — even if a previous run used the other agent, use **${agentDisplay}** now.
-- Do NOT switch agents based on an in-chat text request ("use codex", "switch to claude"). The agent only changes when the user toggles the chip; if they ask in chat, tell them to toggle the chip.
-
-**How to run coding work — call the \`code_agent_run\` tool** with:
-- \`agent\`: \`${codeMode}\` (always — match the chip).
-- \`cwd\`: ${codeCwd ? `\`${codeCwd}\` (always — this coding session is pinned to that directory; never use another path)` : `the absolute project/working directory (resolve it per the code-with-agents skill — a path the user named, the "# User Work Directory" block, or ask once)`}.
-- \`prompt\`: a clear, self-contained coding instruction.
-
-The tool runs the agent on-device and streams its tool calls, file diffs, and plan into the chat; any action needing approval surfaces as an inline permission card, so you do NOT pre-confirm with an in-chat "reply yes". This chat keeps ONE persistent agent session, so follow-up coding requests automatically resume with full context — just call \`code_agent_run\` again. Do NOT shell out to \`acpx\` or \`executeCommand\` for coding, and do NOT fall back to your own file tools.
-
-If the user's message is clearly NOT a coding request (small talk, an unrelated question), answer directly without invoking the coding agent. Code mode signals readiness, not that every message must route through the agent.`;
-        }
+        const composeCopilotContext = state.agentName === 'copilot' || state.agentName === 'rowboatx';
+        const instructionsWithDateTime = composeSystemInstructions({
+            instructions: agent.instructions,
+            agentNotesContext: composeCopilotContext ? loadAgentNotesContext() : null,
+            userWorkDir: composeCopilotContext ? loadUserWorkDir(runId) : null,
+            voiceInput,
+            voiceOutput,
+            searchEnabled,
+            codeMode,
+            codeCwd,
+        });
         let streamError: string | null = null;
         for await (const event of streamLlm(
             model,
diff --git a/apps/x/packages/core/src/analytics/use_case.ts b/apps/x/packages/core/src/analytics/use_case.ts
index 45f38093..34d886eb 100644
--- a/apps/x/packages/core/src/analytics/use_case.ts
+++ b/apps/x/packages/core/src/analytics/use_case.ts
@@ -1,6 +1,6 @@
 import { AsyncLocalStorage } from 'node:async_hooks';
 
-export type UseCase = 'copilot_chat' | 'live_note_agent' | 'background_task_agent' | 'meeting_note' | 'knowledge_sync' | 'code_session' | 'app_llm_generate' | 'app_copilot_run';
+export type UseCase = 'copilot_chat' | 'live_note_agent' | 'background_task_agent' | 'meeting_note' | 'meeting_prep' | 'knowledge_sync' | 'code_session' | 'app_llm_generate' | 'app_copilot_run';
 
 export interface UseCaseContext {
   useCase: UseCase;
diff --git a/apps/x/packages/core/src/application/assistant/instructions.ts b/apps/x/packages/core/src/application/assistant/instructions.ts
index 7f9136c7..366d4bfd 100644
--- a/apps/x/packages/core/src/application/assistant/instructions.ts
+++ b/apps/x/packages/core/src/application/assistant/instructions.ts
@@ -114,7 +114,7 @@ ${codeModeEnabled
     ? `**Code with Agents:** When users ask you to write code, build a project, create a script, fix a bug, or do any software development task — **including simple things like "create a .c file" or "write a hello-world in Python"** — your FIRST action MUST be \`loadSkill('code-with-agents')\`. Do NOT reach for \`executeCommand\` (PowerShell / bash / shell) or any workspace file tool to do code work yourself before loading this skill. The skill decides whether to delegate to Claude Code / Codex (via acpx) or hand control back to you, and it presents the user a one-click choice when needed. Paths outside the Rowboat workspace root (e.g. \`G:/...\`, \`~/projects/...\`) are NORMAL for coding tasks — do NOT raise "outside workspace" concerns or fall back to your own tools.`
     : `**Code with Agents (disabled):** Code mode is currently OFF in the user's settings. Do NOT load \`code-with-agents\` and do NOT call acpx. Handle coding requests yourself with your normal tools if you can. After answering, add a final line letting the user know they can delegate coding to Claude Code or Codex by enabling Code Mode in Settings → Code Mode.`}
 
-**App Control:** When users ask you to open notes, show the bases or graph view, filter or search notes, or manage saved views, load the \`app-navigation\` skill first. It provides structured guidance for navigating the app UI and controlling the knowledge base view.
+**App Control (drive the app):** You can drive the Rowboat UI the user is looking at — open any view (email, meetings, background agents, chat history, knowledge, workspace, code, bases, graph), READ what a view contains (\`read-view\` returns emails / background agents / past chats as data while showing the view on screen), and open specific items (an email thread, a note, an agent, a past chat). When users ask to open, show, find, or ask about anything that lives inside Rowboat, load the \`app-navigation\` skill first — it documents the show-while-telling pattern. This matters most on calls: navigate so the user sees what you see, then answer briefly.
 
 **Background Tasks (Self-Running Work):** Rowboat can run *background tasks* — persistent instructions the agent fires on a schedule and/or in response to incoming emails / calendar events. A bg-task either maintains a snapshot in its \`index.md\` (digest, dashboard, rolling summary) or performs a recurring side-effect (send a Slack message, draft an email, post to a webhook, call an API). This is the flagship surface for *anything recurring*.
 
@@ -295,7 +295,7 @@ ${runtimeContextPrompt}
 - \`addMcpServer\`, \`listMcpServers\`, \`listMcpTools\`, \`executeMcpTool\` - MCP server management and execution
 - \`loadSkill\` - Skill loading
 ${slackToolsLine}- \`web-search\` - Search the web. Returns rich results with full text, highlights, and metadata. The \`category\` parameter defaults to \`general\` (full web search) — only use a specific category like \`news\`, \`company\`, \`research paper\` etc. when the query is clearly about that type. For everyday queries (weather, restaurants, prices, how-to), use \`general\`.
-- \`app-navigation\` - Control the app UI: open notes, switch views, filter/search the knowledge base, manage saved views. **Load the \`app-navigation\` skill before using this tool.**
+- \`app-navigation\` - Drive the app UI: open any view, read a view's contents (emails / background agents / chat history), open specific items (email thread, note, agent, past chat), filter/search the knowledge base, manage saved views. **Load the \`app-navigation\` skill before using this tool.**
 - \`browser-control\` - Control the embedded browser pane: open sites, inspect the live page, switch tabs, and interact with indexed page elements. **Load the \`browser-control\` skill before using this tool.**
 - \`save-to-memory\` - Save observations about the user to the agent memory system. Use this proactively during conversations.
 ${composioToolsLine}
diff --git a/apps/x/packages/core/src/application/assistant/skills/app-navigation/skill.ts b/apps/x/packages/core/src/application/assistant/skills/app-navigation/skill.ts
index 98956d30..3f19f0e3 100644
--- a/apps/x/packages/core/src/application/assistant/skills/app-navigation/skill.ts
+++ b/apps/x/packages/core/src/application/assistant/skills/app-navigation/skill.ts
@@ -1,82 +1,91 @@
 export const skill = String.raw`
-# App Navigation Skill
+# App Driving Skill
 
-You have access to the **app-navigation** tool which lets you control the Rowboat UI directly — opening notes, switching views, filtering the knowledge base, and creating saved views.
+You have the **app-navigation** tool: you can DRIVE the Rowboat app the user
+is looking at — open any view, read what a view contains, open specific items
+(an email thread, a note, a background agent, a past chat), filter the
+knowledge base, and manage saved views. Navigation happens on the USER'S
+screen: when you open something, they watch it open.
+
+## The core pattern: show while telling
+
+When the user asks about something that lives inside Rowboat ("what emails do
+I have?", "what background agents are running?", "open the note about Acme"),
+don't answer blind. Drive:
+
+1. **read-view** the relevant view — this returns the actual data AND
+   navigates the user's screen to that view at the same time.
+2. Answer from the returned data, concisely.
+3. If they ask about one item ("open the one from Arjun"), **open-item** it —
+   it appears on their screen — and summarize what's in it if useful.
+
+This matters most during a call: the user is talking to you hands-free and
+watching the screen. Navigate so they see what you see, and keep spoken
+answers short.
 
 ## Actions
 
+### read-view — read a view's contents (and show it)
+Returns the same data the view renders; the app simultaneously navigates to
+that view so the user sees it.
+
+- ` + "`view: \"email\"`" + ` → latest important inbox threads: ` + "`{ threadId, subject, from, date, unread, summary }`" + `.
+  Pass ` + "`query`" + ` to search instead (sender name, subject words — e.g. ` + "`query: \"from Arjun\"`" + ` or just ` + "`\"Arjun\"`" + `).
+- ` + "`view: \"bg-tasks\"`" + ` → background agents: ` + "`{ name, slug, active, triggers, lastRunAt, lastRunSummary, lastRunError }`" + `.
+- ` + "`view: \"chat-history\"`" + ` → past chats: ` + "`{ sessionId, title, updatedAt, turnCount }`" + `.
+- ` + "`limit`" + ` (optional, default 15).
+
+For notes, meetings, and live notes use the ` + "`file-*`" + ` tools (they are
+markdown files in the workspace) and then open-note / open-item to show them.
+
+### open-item — open one specific thing on screen
+- ` + "`kind: \"email-thread\"`" + ` + ` + "`threadId`" + ` (from read-view email)
+- ` + "`kind: \"note\"`" + ` + ` + "`path`" + `
+- ` + "`kind: \"bg-task\"`" + ` + ` + "`taskName`" + ` (from read-view bg-tasks; validated against real tasks)
+- ` + "`kind: \"session\"`" + ` + ` + "`sessionId`" + ` (from read-view chat-history)
+
+### open-view — just switch the screen
+` + "`view`" + `: ` + "`home | email | meetings | live-notes | bg-tasks | chat-history | knowledge | workspace | code | bases | graph`" + `
+Use when the user asks to "go to"/"show" a view without a question to answer.
+
 ### open-note
-Open a specific knowledge file in the editor pane.
+Open a knowledge file in the editor. ` + "`path`" + `: full workspace-relative path
+(e.g. ` + "`knowledge/People/John Smith.md`" + `). Use ` + "`file-grep`" + ` first if unsure
+of the exact path.
 
-**When to use:** When the user asks to see, open, or view a specific note (e.g., "open John's note", "show me the Acme project page").
+### update-base-view / get-base-state / create-base
+Knowledge-base table control (unchanged):
+- ` + "`update-base-view`" + `: ` + "`filters`" + ` (` + "`set/add/remove/clear`" + ` of ` + "`{category, value}`" + `),
+  ` + "`sort`" + ` (` + "`{field, dir}`" + `), ` + "`search`" + `. **Never pass ` + "`columns`" + ` unless the user
+  explicitly asks to change columns** — it overrides their layout.
+- ` + "`get-base-state`" + `: available filter categories/values and note count.
+- ` + "`create-base`" + `: save the current view configuration under ` + "`name`" + `.
 
-**Parameters:**
-- ` + "`path`" + `: Full workspace-relative path (e.g., ` + "`knowledge/People/John Smith.md`" + `)
+## Worked examples
 
-**Tips:**
-- Use ` + "`file-grep`" + ` first to find the exact path if you're unsure of the filename.
-- Always pass the full ` + "`knowledge/...`" + ` path, not just the filename.
+**"What emails do I have?"** (on a call)
+1. ` + "`app-navigation({ action: \"read-view\", view: \"email\" })`" + ` — email view opens on their screen.
+2. Speak the highlights: "You've got six new ones — the ones that matter are from Arjun about the deck and from Stripe about billing."
 
-### open-view
-Switch the UI to the graph or bases view.
+**"Open the one from Arjun."**
+1. Find Arjun's thread in the data you already have (or ` + "`read-view`" + ` with ` + "`query: \"Arjun\"`" + `).
+2. ` + "`app-navigation({ action: \"open-item\", kind: \"email-thread\", threadId: \"...\" })`" + `
+3. "It's open — he's asking whether Thursday works for the pitch review."
 
-**When to use:** When the user asks to see the knowledge graph, view all notes, or open the bases/table view.
+**"What background agents do I have?"**
+1. ` + "`app-navigation({ action: \"read-view\", view: \"bg-tasks\" })`" + `
+2. "Three: the inbox summarizer ran an hour ago, the meeting-prep agent is active, and the Linear digest failed its last run — want me to open that one?"
 
-**Parameters:**
-- ` + "`view`" + `: ` + "`\"graph\"`" + ` or ` + "`\"bases\"`" + `
+**"Show me all active customers"**
+1. ` + "`get-base-state`" + ` to see available categories, then
+2. ` + "`update-base-view`" + ` with ` + "`filters.set: [{ category: \"relationship\", value: \"customer\" }]`" + `
 
-### update-base-view
-Change filters, columns, sort order, or search in the bases (table) view.
-
-**When to use:** When the user asks to find, filter, sort, or search notes. Examples: "show me all active customers", "filter by topic=hiring", "sort by name", "search for pricing".
-
-**Parameters:**
-- ` + "`filters`" + `: Object with ` + "`set`" + `, ` + "`add`" + `, ` + "`remove`" + `, or ` + "`clear`" + ` — each takes an array of ` + "`{ category, value }`" + ` pairs.
-  - ` + "`set`" + `: Replace ALL current filters with these.
-  - ` + "`add`" + `: Append filters without removing existing ones.
-  - ` + "`remove`" + `: Remove specific filters.
-  - ` + "`clear: true`" + `: Remove all filters.
-- ` + "`columns`" + `: Object with ` + "`set`" + `, ` + "`add`" + `, or ` + "`remove`" + ` — each takes an array of column names (frontmatter keys).
-- ` + "`sort`" + `: ` + "`{ field, dir }`" + ` where dir is ` + "`\"asc\"`" + ` or ` + "`\"desc\"`" + `.
-- ` + "`search`" + `: Free-text search string.
-
-**Tips:**
-- If unsure what categories/values are available, call ` + "`get-base-state`" + ` first.
-- For "show me X", prefer ` + "`filters.set`" + ` to start fresh rather than ` + "`filters.add`" + `.
-- Categories come from frontmatter keys (e.g., relationship, status, topic, type).
-- **CRITICAL: Do NOT pass ` + "`columns`" + ` unless the user explicitly asks to show/hide specific columns.** Omit the ` + "`columns`" + ` parameter entirely when only filtering, sorting, or searching. Passing ` + "`columns`" + ` will override the user's current column layout and can make the view appear empty.
-
-### get-base-state
-Retrieve information about what's in the knowledge base — available filter categories, values, and note count.
-
-**When to use:** When you need to know what properties exist before filtering, or when the user asks "what can I filter by?", "how many notes are there?", etc.
-
-**Parameters:**
-- ` + "`base_name`" + ` (optional): Name of a saved base to inspect.
-
-### create-base
-Save the current view configuration as a named base.
-
-**When to use:** When the user asks to save a filtered view, create a saved search, or says "save this as [name]".
-
-**Parameters:**
-- ` + "`name`" + `: Human-readable name for the base.
-
-## Workflow Example
-
-1. User: "Show me all people who are customers"
-2. First, check what properties are available:
-   ` + "`app-navigation({ action: \"get-base-state\" })`" + `
-3. Apply filters based on the available properties:
-   ` + "`app-navigation({ action: \"update-base-view\", filters: { set: [{ category: \"relationship\", value: \"customer\" }] } })`" + `
-4. If the user wants to save it:
-   ` + "`app-navigation({ action: \"create-base\", name: \"Customers\" })`" + `
-
-## Important Notes
-- The ` + "`update-base-view`" + ` action will automatically navigate to the bases view if the user isn't already there.
-- ` + "`open-note`" + ` validates that the file exists before navigating.
-- Filter categories and values come from frontmatter in knowledge files.
-- **Never send ` + "`columns`" + ` or ` + "`sort`" + ` with ` + "`update-base-view`" + ` unless the user specifically asks to change them.** Only pass the parameters you intend to change — omitted parameters are left untouched.
+## Notes
+- read-view/open-view/open-item change what the user is looking at — that is
+  the point, but don't bounce their screen around needlessly; navigate when
+  it serves the question.
+- open-note and open-item validate the target exists before navigating.
+- update-base-view auto-navigates to the bases view.
 `;
 
 export default skill;
diff --git a/apps/x/packages/core/src/application/lib/builtin-tools.ts b/apps/x/packages/core/src/application/lib/builtin-tools.ts
index 2b53ab26..cc31969b 100644
--- a/apps/x/packages/core/src/application/lib/builtin-tools.ts
+++ b/apps/x/packages/core/src/application/lib/builtin-tools.ts
@@ -24,6 +24,9 @@ import { ICodeModeConfigRepo } from "../../code-mode/repo.js";
 import type { ApprovalPolicy } from "@x/shared/dist/code-mode.js";
 import type { ICodeProjectsRepo } from "../../code-mode/projects/repo.js";
 import * as gitService from "../../code-mode/git/service.js";
+import { listImportantThreads, searchThreads } from "../../knowledge/sync_gmail.js";
+import { listTasks as listBackgroundTasks } from "../../background-tasks/fileops.js";
+import type { ISessions } from "../../sessions/api.js";
 
 // Inputs for the bg-task builtin tools. Reuse the canonical schema field
 // descriptions; only `triggers` gets a tighter contextual override (the
@@ -1068,15 +1071,24 @@ export const BuiltinTools: z.infer<typeof BuiltinToolsSchema> = {
     // ============================================================================
 
     'app-navigation': {
-        description: 'Control the app UI - navigate to notes, switch views, filter/search the knowledge base, and manage saved views.',
+        description: 'Drive the Rowboat app UI: navigate to any view, read what a view contains (emails, background agents, chat history), open specific items (an email thread, a note, an agent, a past chat), filter/search the knowledge base, and manage saved views. Use it to SHOW the user things while telling them — navigation happens on their screen.',
         inputSchema: z.object({
-            action: z.enum(["open-note", "open-view", "open-app", "update-base-view", "get-base-state", "create-base"]).describe("The navigation action to perform"),
+            action: z.enum(["open-note", "open-view", "open-app", "read-view", "open-item", "update-base-view", "get-base-state", "create-base"]).describe("The navigation action to perform"),
             // open-note
             path: z.string().optional().describe("Knowledge file path for open-note, e.g. knowledge/People/John.md"),
             // open-app
-            appId: z.string().optional().describe("Mini App id (folder name under ~/.rowboat/apps) for open-app — opens it in the middle pane under Mini Apps."),
-            // open-view
-            view: z.enum(["bases", "graph"]).optional().describe("Which view to open (for open-view action)"),
+            appId: z.string().optional().describe("App folder slug under ~/.rowboat/apps (for open-app) — opens the app in the middle pane."),
+            // open-view / read-view
+            view: z.enum(["home", "email", "meetings", "live-notes", "bg-tasks", "chat-history", "knowledge", "workspace", "code", "bases", "graph"]).optional().describe("Which view to open (open-view) or read (read-view; supported for read: email, bg-tasks, chat-history)"),
+            // read-view (email)
+            query: z.string().optional().describe("For read-view on email: search query (sender name, subject words, etc.). Omit to list the latest important inbox threads."),
+            limit: z.number().int().min(1).max(50).optional().describe("For read-view: max items to return (default 15)"),
+            // open-item
+            kind: z.enum(["email-thread", "note", "bg-task", "session"]).optional().describe("What to open (for open-item)"),
+            threadId: z.string().optional().describe("Gmail thread id (open-item kind=email-thread; get it from read-view email)"),
+            taskName: z.string().optional().describe("Background task/agent name (open-item kind=bg-task; get it from read-view bg-tasks)"),
+            sessionId: z.string().optional().describe("Chat session id (open-item kind=session; get it from read-view chat-history)"),
+
             // update-base-view
             filters: z.object({
                 set: z.array(z.object({ category: z.string(), value: z.string() })).optional().describe("Replace all filters with these"),
@@ -1136,6 +1148,110 @@ export const BuiltinTools: z.infer<typeof BuiltinToolsSchema> = {
                     return { success: true, action: 'open-app', appId, appName };
                 }
 
+                case 'read-view': {
+                    // Returns the same data the view renders, so the assistant
+                    // can answer precisely — and the renderer navigates to the
+                    // view at the same time so the user SEES what's being read.
+                    const view = input.view as string;
+                    const limit = (input.limit as number | undefined) ?? 15;
+                    try {
+                        switch (view) {
+                            case 'email': {
+                                const query = (input.query as string | undefined)?.trim();
+                                const result = query
+                                    ? await searchThreads(query, { limit })
+                                    : listImportantThreads({ limit });
+                                const threads = (result.threads ?? []).slice(0, limit).map((t) => ({
+                                    threadId: t.threadId,
+                                    subject: t.subject ?? '(no subject)',
+                                    from: t.from ?? '',
+                                    date: t.date ?? '',
+                                    unread: t.unread ?? false,
+                                    summary: t.summary ? t.summary.slice(0, 200) : undefined,
+                                }));
+                                return { success: true, action: 'read-view', view, query, threads };
+                            }
+                            case 'bg-tasks': {
+                                const { items } = await listBackgroundTasks({ limit });
+                                const agents = items.map((t) => ({
+                                    name: t.name,
+                                    slug: t.slug,
+                                    active: t.active,
+                                    triggers: t.triggers,
+                                    lastRunAt: t.lastRunAt,
+                                    lastRunSummary: t.lastRunSummary ? t.lastRunSummary.slice(0, 200) : undefined,
+                                    lastRunError: t.lastRunError ? t.lastRunError.slice(0, 200) : undefined,
+                                }));
+                                return { success: true, action: 'read-view', view, agents };
+                            }
+                            case 'chat-history': {
+                                const sessions = container.resolve<ISessions>('sessions')
+                                    .listSessions()
+                                    .slice(0, limit)
+                                    .map((s) => ({
+                                        sessionId: s.sessionId,
+                                        title: s.title ?? '(untitled)',
+                                        updatedAt: s.updatedAt,
+                                        turnCount: s.turnCount,
+                                    }));
+                                return { success: true, action: 'read-view', view, sessions };
+                            }
+                            default:
+                                return {
+                                    success: false,
+                                    error: `read-view supports: email, bg-tasks, chat-history. For notes/meetings/live-notes use the file-* tools (they are files under the workspace); for other views use open-view and describe what you need.`,
+                                };
+                        }
+                    } catch (error) {
+                        return {
+                            success: false,
+                            error: error instanceof Error ? error.message : `Failed to read ${view}`,
+                        };
+                    }
+                }
+
+                case 'open-item': {
+                    const kind = input.kind as string;
+                    switch (kind) {
+                        case 'email-thread': {
+                            const threadId = input.threadId as string | undefined;
+                            if (!threadId) return { success: false, error: 'threadId is required for kind=email-thread' };
+                            return { success: true, action: 'open-item', kind, threadId };
+                        }
+                        case 'note': {
+                            const filePath = input.path as string | undefined;
+                            if (!filePath) return { success: false, error: 'path is required for kind=note' };
+                            const result = await files.exists(filePath);
+                            if (!result.exists) return { success: false, error: `File not found: ${filePath}` };
+                            return { success: true, action: 'open-item', kind, path: filePath };
+                        }
+                        case 'bg-task': {
+                            const taskName = input.taskName as string | undefined;
+                            if (!taskName) return { success: false, error: 'taskName is required for kind=bg-task' };
+                            // Validate (and canonicalize) against the real task list.
+                            const { items: tasks } = await listBackgroundTasks({});
+                            const match = tasks.find(
+                                (t) => t.name === taskName || t.slug === taskName
+                                    || t.name.toLowerCase() === taskName.toLowerCase(),
+                            );
+                            if (!match) {
+                                return {
+                                    success: false,
+                                    error: `No background task named "${taskName}". Known tasks: ${tasks.map((t) => t.name).join(', ') || '(none)'}`,
+                                };
+                            }
+                            return { success: true, action: 'open-item', kind, taskName: match.name };
+                        }
+                        case 'session': {
+                            const sessionId = input.sessionId as string | undefined;
+                            if (!sessionId) return { success: false, error: 'sessionId is required for kind=session' };
+                            return { success: true, action: 'open-item', kind, sessionId };
+                        }
+                        default:
+                            return { success: false, error: `Unknown item kind: ${kind}` };
+                    }
+                }
+
                 case 'update-base-view': {
                     const updates: Record<string, unknown> = {};
                     if (input.filters) updates.filters = input.filters;
diff --git a/apps/x/packages/core/src/background-tasks/runner.ts b/apps/x/packages/core/src/background-tasks/runner.ts
index dee147d8..700f203a 100644
--- a/apps/x/packages/core/src/background-tasks/runner.ts
+++ b/apps/x/packages/core/src/background-tasks/runner.ts
@@ -1,9 +1,8 @@
 import type { BackgroundTask, BackgroundTaskTriggerType } from '@x/shared/dist/background-task.js';
 import { PrefixLogger } from '@x/shared/dist/prefix-logger.js';
 import { fetchTask, patchTask, prependRunId } from './fileops.js';
-import { createRun, createMessage } from '../runs/runs.js';
 import { getBackgroundTaskAgentModel } from '../models/defaults.js';
-import { extractAgentResponse, waitForRunCompletion } from '../agents/utils.js';
+import { startHeadlessAgent } from '../agents/headless-app.js';
 import { buildTriggerBlock } from '../agents/build-trigger-block.js';
 import { backgroundTaskBus } from './bus.js';
 import { withUseCase } from '../analytics/use_case.js';
@@ -139,20 +138,25 @@ export async function runBackgroundTask(
         }
 
         const model = task.model || await getBackgroundTaskAgentModel();
-        const agentRun = await createRun({
-            agentId: 'background-task-agent',
-            model,
-            ...(task.provider ? { provider: task.provider } : {}),
-            useCase: 'background_task_agent',
-            // Granular trigger as analytics sub-use-case — matches live-note's
-            // pattern at runner.ts:149.
-            subUseCase: trigger,
-        });
+        // Establish the use-case context for the whole turn so every tool the
+        // agent calls (notably notify-user) reads `background_task_agent` via
+        // getCurrentUseCase(); the AsyncLocalStorage context set here flows
+        // through the turn's async execution chain.
+        const handle = await withUseCase(
+            { useCase: 'background_task_agent', subUseCase: trigger },
+            () => startHeadlessAgent({
+                agentId: 'background-task-agent',
+                message: buildMessage(slug, task, trigger, context, codeProject),
+                model,
+                ...(task.provider ? { provider: task.provider } : {}),
+                throwOnError: true,
+            }),
+        );
 
-        const runId = agentRun.id;
-        // Record this run in the task's runs.log pointer file (newest first).
-        // The transcript itself lives at the global $WorkDir/runs/<runId>.jsonl
-        // — runs.log is just an index that ties runIds to this task.
+        const runId = handle.turnId;
+        // Record this turn in the task's runs.log pointer file (newest first).
+        // The transcript itself lives at $WorkDir/storage/turns/YYYY/MM/DD/
+        // — runs.log is just an index that ties turn ids to this task.
         await prependRunId(slug, runId);
         const startedAt = new Date().toISOString();
 
@@ -184,20 +188,7 @@ export async function runBackgroundTask(
         });
 
         try {
-            // Establish the use-case context for the whole run so every tool the
-            // agent calls (notably notify-user) reads `background_task_agent` via
-            // getCurrentUseCase(). createMessage synchronously fires
-            // agentRuntime.trigger(), so the detached run loop — and the tool
-            // calls within it — inherit this AsyncLocalStorage context. (The
-            // runtime's own enterUseCase runs inside an async generator and
-            // doesn't reliably propagate to tool execution, so we set it here at
-            // the trigger point instead.)
-            await withUseCase(
-                { useCase: 'background_task_agent', subUseCase: trigger },
-                () => createMessage(runId, buildMessage(slug, task, trigger, context, codeProject)),
-            );
-            await waitForRunCompletion(runId, { throwOnError: true });
-            const summary = await extractAgentResponse(runId);
+            const { summary } = await handle.done;
 
             // Success — bump cycle anchor, refresh summary, clear any prior error.
             await patchTask(slug, {
diff --git a/apps/x/packages/core/src/channels/bridge.test.ts b/apps/x/packages/core/src/channels/bridge.test.ts
new file mode 100644
index 00000000..2c78f90a
--- /dev/null
+++ b/apps/x/packages/core/src/channels/bridge.test.ts
@@ -0,0 +1,278 @@
+import { describe, expect, it, vi } from "vitest";
+import type { SessionIndexEntry } from "@x/shared/dist/sessions.js";
+import type { TurnStreamEvent } from "@x/shared/dist/turns.js";
+import { EmitterSessionBus } from "../sessions/bus.js";
+import { TurnInputError } from "../turns/api.js";
+import type { ISessions } from "../sessions/api.js";
+import { ChannelBridge, type ModelChoice } from "./bridge.js";
+
+const SENDER = "test:1";
+
+function entry(overrides: Partial<SessionIndexEntry>): SessionIndexEntry {
+    return {
+        sessionId: "s1",
+        createdAt: "2026-07-01T00:00:00Z",
+        updatedAt: "2026-07-01T00:00:00Z",
+        turnCount: 1,
+        latestTurnStatus: "completed",
+        ...overrides,
+    };
+}
+
+function completedEvent(turnId: string, text: string): TurnStreamEvent {
+    return {
+        type: "turn_completed",
+        turnId,
+        ts: "2026-07-01T00:00:00Z",
+        output: { role: "assistant", content: text },
+        finishReason: "stop",
+        usage: {},
+    } as unknown as TurnStreamEvent;
+}
+
+function askEvent(turnId: string, question: string, options?: string[]): TurnStreamEvent {
+    return {
+        type: "turn_suspended",
+        turnId,
+        ts: "2026-07-01T00:00:00Z",
+        pendingPermissions: [],
+        pendingAsyncTools: [
+            {
+                toolCallId: "call_1",
+                toolId: "builtin:ask-human",
+                toolName: "ask-human",
+                input: { question, ...(options ? { options } : {}) },
+            },
+        ],
+        usage: {},
+    } as unknown as TurnStreamEvent;
+}
+
+interface Harness {
+    bridge: ChannelBridge;
+    bus: EmitterSessionBus;
+    replies: string[];
+    reply: (text: string) => Promise<void>;
+    sessions: {
+        createSession: ReturnType<typeof vi.fn>;
+        sendMessage: ReturnType<typeof vi.fn>;
+        respondToAskHuman: ReturnType<typeof vi.fn>;
+        stopTurn: ReturnType<typeof vi.fn>;
+        getTurn: ReturnType<typeof vi.fn>;
+        listSessions: ReturnType<typeof vi.fn>;
+    };
+    listModels: ReturnType<typeof vi.fn>;
+    publish: (turnId: string, event: TurnStreamEvent) => void;
+}
+
+const MODELS: ModelChoice[] = [
+    { provider: "anthropic", model: "claude-fable-5", label: "Fable 5 — Anthropic" },
+    { provider: "anthropic", model: "claude-sonnet-5", label: "Sonnet 5 — Anthropic" },
+    { provider: "openai", model: "gpt-5", label: "GPT-5 — OpenAI" },
+];
+
+function harness(entries: SessionIndexEntry[] = []): Harness {
+    const bus = new EmitterSessionBus();
+    const publish = (turnId: string, event: TurnStreamEvent) =>
+        bus.publish({ kind: "turn-event", sessionId: "s1", turnId, event });
+    const sessions = {
+        createSession: vi.fn(async () => "s1"),
+        sendMessage: vi.fn(async () => ({ turnId: "t1" })),
+        respondToAskHuman: vi.fn(async () => undefined),
+        stopTurn: vi.fn(async () => undefined),
+        getTurn: vi.fn(async () => ({ turnId: "t1", events: [] })),
+        listSessions: vi.fn(() => entries),
+    };
+    const listModels = vi.fn(async () => MODELS);
+    const bridge = new ChannelBridge({
+        sessions: sessions as unknown as ISessions,
+        sessionBus: bus,
+        listModels,
+    });
+    const replies: string[] = [];
+    const reply = async (text: string) => {
+        replies.push(text);
+    };
+    return { bridge, bus, replies, reply, sessions, listModels, publish };
+}
+
+// Settle the turn as soon as sendMessage is called: the watcher subscribes
+// before sendMessage, so a synchronous publish lands in its buffer — the
+// exact race the buffering exists for.
+function settleOnSend(h: Harness, event: TurnStreamEvent, turnId = "t1"): void {
+    h.sessions.sendMessage.mockImplementation(async () => {
+        h.publish(turnId, event);
+        return { turnId };
+    });
+}
+
+describe("ChannelBridge commands", () => {
+    it("replies with help text", async () => {
+        const h = harness();
+        await h.bridge.handleInbound(SENDER, "help", h.reply);
+        expect(h.replies).toHaveLength(1);
+        expect(h.replies[0]).toContain("Rowboat commands");
+    });
+
+    it("lists recent sessions newest-first and resumes by index", async () => {
+        const h = harness([
+            entry({ sessionId: "old", title: "Old chat", updatedAt: "2026-07-01T00:00:00Z" }),
+            entry({ sessionId: "new", title: "New chat", updatedAt: "2026-07-02T00:00:00Z" }),
+        ]);
+        await h.bridge.handleInbound(SENDER, "list", h.reply);
+        expect(h.replies[0]).toContain("1. New chat");
+        expect(h.replies[0]).toContain("2. Old chat");
+
+        await h.bridge.handleInbound(SENDER, "resume 2", h.reply);
+        expect(h.replies[1]).toContain('Resumed "Old chat"');
+
+        settleOnSend(h, completedEvent("t1", "done"));
+        await h.bridge.handleInbound(SENDER, "hello again", h.reply);
+        expect(h.sessions.sendMessage).toHaveBeenCalledWith(
+            "old",
+            expect.objectContaining({ content: "hello again" }),
+            expect.objectContaining({ autoPermission: true }),
+        );
+    });
+
+    it("rejects resume with an out-of-range index", async () => {
+        const h = harness([entry({ sessionId: "s1", title: "Only chat" })]);
+        await h.bridge.handleInbound(SENDER, "resume 5", h.reply);
+        expect(h.replies[0]).toContain("No chat #5");
+    });
+});
+
+describe("ChannelBridge model selection", () => {
+    it("lists models and applies a by-index selection to later turns", async () => {
+        const h = harness();
+        await h.bridge.handleInbound(SENDER, "model", h.reply);
+        expect(h.replies[0]).toContain("1. Fable 5 — Anthropic");
+        expect(h.replies[0]).toContain("app default");
+
+        await h.bridge.handleInbound(SENDER, "model 3", h.reply);
+        expect(h.replies[1]).toContain("GPT-5");
+
+        settleOnSend(h, completedEvent("t1", "done"));
+        await h.bridge.handleInbound(SENDER, "hello", h.reply);
+        expect(h.sessions.sendMessage).toHaveBeenCalledWith(
+            "s1",
+            expect.anything(),
+            expect.objectContaining({
+                agent: {
+                    agentId: "copilot",
+                    overrides: { model: { provider: "openai", model: "gpt-5" } },
+                },
+            }),
+        );
+    });
+
+    it("selects by unique name match and resets on 'model default'", async () => {
+        const h = harness();
+        await h.bridge.handleInbound(SENDER, "model fable", h.reply);
+        expect(h.replies[0]).toContain("Fable 5");
+
+        settleOnSend(h, completedEvent("t1", "done"));
+        await h.bridge.handleInbound(SENDER, "hi", h.reply);
+        expect(h.sessions.sendMessage).toHaveBeenCalledWith(
+            "s1",
+            expect.anything(),
+            expect.objectContaining({
+                agent: expect.objectContaining({
+                    overrides: { model: { provider: "anthropic", model: "claude-fable-5" } },
+                }),
+            }),
+        );
+
+        await h.bridge.handleInbound(SENDER, "model default", h.reply);
+        settleOnSend(h, completedEvent("t2", "done"), "t2");
+        await h.bridge.handleInbound(SENDER, "hi again", h.reply);
+        expect(h.sessions.sendMessage).toHaveBeenLastCalledWith(
+            "s1",
+            expect.anything(),
+            expect.objectContaining({ agent: { agentId: "copilot" } }),
+        );
+    });
+
+    it("asks for disambiguation on an ambiguous name and rejects unknown ones", async () => {
+        const h = harness();
+        await h.bridge.handleInbound(SENDER, "model claude", h.reply);
+        expect(h.replies[0]).toContain("matches 2 models");
+
+        await h.bridge.handleInbound(SENDER, "model llama", h.reply);
+        expect(h.replies[1]).toContain('No model matching "llama"');
+    });
+});
+
+describe("ChannelBridge message flow", () => {
+    it("creates a session, acks, and delivers the completed text", async () => {
+        const h = harness();
+        settleOnSend(h, completedEvent("t1", "The answer is 42."));
+        await h.bridge.handleInbound(SENDER, "what is the answer?", h.reply);
+        expect(h.sessions.createSession).toHaveBeenCalledOnce();
+        expect(h.replies[0]).toContain("Working on it");
+        expect(h.replies[1]).toBe("The answer is 42.");
+    });
+
+    it("delivers a failed turn as an error reply", async () => {
+        const h = harness();
+        settleOnSend(h, {
+            type: "turn_failed",
+            turnId: "t1",
+            ts: "2026-07-01T00:00:00Z",
+            error: "model exploded",
+            usage: {},
+        } as unknown as TurnStreamEvent);
+        await h.bridge.handleInbound(SENDER, "do a thing", h.reply);
+        expect(h.replies[1]).toContain("model exploded");
+    });
+
+    it("relays the ask-human question text and options, then routes the answer", async () => {
+        const h = harness();
+        settleOnSend(h, askEvent("t1", "Which lane?", ["fast", "slow"]));
+        await h.bridge.handleInbound(SENDER, "start task", h.reply);
+        expect(h.replies[1]).toContain("Which lane?");
+        expect(h.replies[1]).toContain("1. fast");
+
+        // The answer resolves the ask; the turn then completes.
+        h.sessions.respondToAskHuman.mockImplementation(async () => {
+            h.publish("t1", completedEvent("t1", "Took the fast lane."));
+        });
+        await h.bridge.handleInbound(SENDER, "fast", h.reply);
+        expect(h.sessions.respondToAskHuman).toHaveBeenCalledWith("t1", "call_1", "fast");
+        expect(h.replies[3]).toBe("Took the fast lane.");
+    });
+
+    it("falls back to a normal message when the ask was already answered elsewhere", async () => {
+        const h = harness();
+        settleOnSend(h, askEvent("t1", "Which lane?"));
+        await h.bridge.handleInbound(SENDER, "start task", h.reply);
+
+        h.sessions.respondToAskHuman.mockRejectedValue(
+            new TurnInputError("no pending async tool call call_1"),
+        );
+        settleOnSend(h, completedEvent("t2", "Handled as a new message."), "t2");
+        await h.bridge.handleInbound(SENDER, "actually do this instead", h.reply);
+        expect(h.sessions.sendMessage).toHaveBeenLastCalledWith(
+            "s1",
+            expect.objectContaining({ content: "actually do this instead" }),
+            expect.anything(),
+        );
+        expect(h.replies.at(-1)).toBe("Handled as a new message.");
+    });
+
+    it("reports busy while a turn is in flight", async () => {
+        const h = harness();
+        let releaseTurn!: () => void;
+        h.sessions.sendMessage.mockImplementation(async () => {
+            releaseTurn = () => h.publish("t1", completedEvent("t1", "finally"));
+            return { turnId: "t1" };
+        });
+        const first = h.bridge.handleInbound(SENDER, "slow task", h.reply);
+        await new Promise((resolve) => setTimeout(resolve, 0));
+        await h.bridge.handleInbound(SENDER, "impatient follow-up", h.reply);
+        expect(h.replies.some((r) => r.includes("Still working"))).toBe(true);
+        releaseTurn();
+        await first;
+        expect(h.replies.at(-1)).toBe("finally");
+    });
+});
diff --git a/apps/x/packages/core/src/channels/bridge.ts b/apps/x/packages/core/src/channels/bridge.ts
new file mode 100644
index 00000000..e53be4d8
--- /dev/null
+++ b/apps/x/packages/core/src/channels/bridge.ts
@@ -0,0 +1,540 @@
+import type { SessionIndexEntry } from "@x/shared/dist/sessions.js";
+import { reduceTurn, type TurnStreamEvent } from "@x/shared/dist/turns.js";
+import { assistantText, lastAssistantText } from "../agents/headless.js";
+import { TurnInputError } from "../turns/api.js";
+import { ASK_HUMAN_TOOL } from "../turns/bridges/real-agent-resolver.js";
+import { TurnNotSettledError, type ISessions } from "../sessions/api.js";
+import type { EmitterSessionBus } from "../sessions/bus.js";
+
+// Transport-agnostic command layer: inbound texts from a messaging channel
+// are parsed into commands (list / resume / new / stop / status) or forwarded
+// into a regular chat session; the turn's final assistant text is sent back
+// through the transport's reply callback. Turns run with autoPermission and
+// show up live in the desktop UI like any other session.
+
+const AGENT_ID = "copilot";
+const TURN_TIMEOUT_MS = 30 * 60 * 1000;
+const LIST_LIMIT = 10;
+// Telegram caps messages at 4096 chars; WhatsApp is far higher. Long replies
+// are chunked, then truncated — the desktop app has the full text.
+const REPLY_CHUNK_SIZE = 3500;
+const MAX_REPLY_CHUNKS = 3;
+
+const ASK_HUMAN_TOOL_ID = `builtin:${ASK_HUMAN_TOOL}`;
+
+const HELP_TEXT = [
+    "🤖 Rowboat commands:",
+    "• list — recent chats",
+    "• resume N — continue chat N from the list",
+    "• new [message] — start a fresh chat",
+    "• model [N or name] — pick the model (\"model default\" resets)",
+    "• status — current chat and what it's doing",
+    "• stop — cancel the running task",
+    "",
+    "Anything else is sent to the current chat.",
+].join("\n");
+
+const MODEL_LIST_LIMIT = 20;
+
+export type ReplyFn = (text: string) => Promise<void>;
+
+export interface ModelChoice {
+    provider: string;
+    model: string;
+    label: string;
+}
+
+interface SenderState {
+    activeSessionId: string | null;
+    // sessionIds as last shown by `list` (1-based indexing for `resume N`).
+    lastList: string[];
+    // Choices as last shown by `model` (1-based indexing for `model N`).
+    lastModels: ModelChoice[];
+    // Per-sender override passed on every turn; null = app default model.
+    model: { provider: string; model: string } | null;
+    pendingAsk: { turnId: string; toolCallId: string } | null;
+    busy: boolean;
+}
+
+type Settled =
+    | { kind: "completed"; text: string | null }
+    | { kind: "failed"; error: string }
+    | { kind: "cancelled" }
+    | { kind: "ask_human"; toolCallId: string; query: string; options?: string[] }
+    | { kind: "suspended" }
+    | { kind: "timeout" };
+
+function settleOf(event: TurnStreamEvent): Settled | null {
+    switch (event.type) {
+        case "turn_completed":
+            return { kind: "completed", text: assistantText(event.output) };
+        case "turn_failed":
+            return { kind: "failed", error: event.error };
+        case "turn_cancelled":
+            return { kind: "cancelled" };
+        case "turn_suspended": {
+            const ask = event.pendingAsyncTools.find(
+                (t) => t.toolId === ASK_HUMAN_TOOL_ID || t.toolName === ASK_HUMAN_TOOL,
+            );
+            if (ask) {
+                const input = ask.input as { question?: unknown; options?: unknown } | null;
+                const query =
+                    typeof input?.question === "string" && input.question
+                        ? input.question
+                        : "The agent needs your input.";
+                const options = Array.isArray(input?.options)
+                    ? input.options.filter((o): o is string => typeof o === "string")
+                    : undefined;
+                return { kind: "ask_human", toolCallId: ask.toolCallId, query, options };
+            }
+            // Other async tools settle on their own and the turn resumes;
+            // keep waiting. Pending permissions need the desktop.
+            if (event.pendingAsyncTools.length === 0 && event.pendingPermissions.length > 0) {
+                return { kind: "suspended" };
+            }
+            return null;
+        }
+        default:
+            return null;
+    }
+}
+
+function relativeTime(iso: string): string {
+    const then = Date.parse(iso);
+    if (!Number.isFinite(then)) return "";
+    const diffSec = Math.round((Date.now() - then) / 1000);
+    if (diffSec < 60) return "just now";
+    const diffMin = Math.round(diffSec / 60);
+    if (diffMin < 60) return `${diffMin}m ago`;
+    const diffHr = Math.round(diffMin / 60);
+    if (diffHr < 24) return `${diffHr}h ago`;
+    return `${Math.round(diffHr / 24)}d ago`;
+}
+
+function chunkReply(text: string): string[] {
+    if (text.length <= REPLY_CHUNK_SIZE) return [text];
+    const parts: string[] = [];
+    let rest = text;
+    while (rest.length > 0 && parts.length < MAX_REPLY_CHUNKS) {
+        parts.push(rest.slice(0, REPLY_CHUNK_SIZE));
+        rest = rest.slice(REPLY_CHUNK_SIZE);
+    }
+    if (rest.length > 0) {
+        parts[parts.length - 1] += "\n… (truncated — open Rowboat for the full reply)";
+    }
+    return parts;
+}
+
+interface TurnWatcher {
+    waitFor(turnId: string, timeoutMs: number): Promise<Settled>;
+    dispose(): void;
+}
+
+export class ChannelBridge {
+    private senders = new Map<string, SenderState>();
+
+    constructor(
+        private readonly deps: {
+            sessions: ISessions;
+            sessionBus: EmitterSessionBus;
+            listModels: () => Promise<ModelChoice[]>;
+        },
+    ) {}
+
+    async handleInbound(senderKey: string, text: string, reply: ReplyFn): Promise<void> {
+        const trimmed = text.trim();
+        if (!trimmed) return;
+        const state = this.senderState(senderKey);
+        const lower = trimmed.toLowerCase();
+
+        try {
+            if (lower === "help" || lower === "?") {
+                await reply(HELP_TEXT);
+                return;
+            }
+            if (lower === "list" || lower === "chats") {
+                await reply(this.renderList(state));
+                return;
+            }
+            const resume = /^(?:resume|open)\s+(\d+)$/.exec(lower);
+            if (resume) {
+                await reply(this.resumeSession(state, Number(resume[1])));
+                return;
+            }
+            if (lower === "model" || lower === "models") {
+                await reply(await this.renderModelList(state));
+                return;
+            }
+            const model = /^model\s+(.+)$/i.exec(trimmed);
+            if (model) {
+                await reply(await this.selectModel(state, model[1].trim()));
+                return;
+            }
+            if (lower === "status") {
+                await reply(this.renderStatus(state));
+                return;
+            }
+            if (lower === "stop") {
+                await reply(await this.stopActive(state));
+                return;
+            }
+            if (lower === "new") {
+                state.activeSessionId = null;
+                state.pendingAsk = null;
+                await reply("🆕 Fresh chat — send your first message.");
+                return;
+            }
+            const newWithText = /^new\s+([\s\S]+)$/i.exec(trimmed);
+            if (newWithText) {
+                state.activeSessionId = null;
+                state.pendingAsk = null;
+                await this.runMessage(state, newWithText[1].trim(), reply);
+                return;
+            }
+            await this.runMessage(state, trimmed, reply);
+        } catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            await reply(`❌ ${message}`).catch(() => undefined);
+        }
+    }
+
+    private senderState(senderKey: string): SenderState {
+        let state = this.senders.get(senderKey);
+        if (!state) {
+            state = {
+                activeSessionId: null,
+                lastList: [],
+                lastModels: [],
+                model: null,
+                pendingAsk: null,
+                busy: false,
+            };
+            this.senders.set(senderKey, state);
+        }
+        return state;
+    }
+
+    private isCurrentModel(state: SenderState, choice: ModelChoice): boolean {
+        return (
+            state.model?.provider === choice.provider && state.model?.model === choice.model
+        );
+    }
+
+    private async renderModelList(state: SenderState): Promise<string> {
+        const choices = await this.deps.listModels();
+        if (choices.length === 0) {
+            return "No models available — configure one in Rowboat → Settings → Models.";
+        }
+        state.lastModels = choices;
+        const shown = choices.slice(0, MODEL_LIST_LIMIT);
+        const lines = shown.map((c, i) => {
+            const current = this.isCurrentModel(state, c) ? " ← current" : "";
+            return `${i + 1}. ${c.label}${current}`;
+        });
+        if (choices.length > shown.length) {
+            lines.push(`… and ${choices.length - shown.length} more — pick by name.`);
+        }
+        return [
+            `Models${state.model ? "" : " (using app default)"}:`,
+            ...lines,
+            "",
+            `Reply "model N" or "model <name>" to switch, "model default" to reset.`,
+        ].join("\n");
+    }
+
+    private async selectModel(state: SenderState, arg: string): Promise<string> {
+        const lower = arg.toLowerCase();
+        if (lower === "default" || lower === "reset") {
+            state.model = null;
+            return "✅ Using the app default model.";
+        }
+        if (state.lastModels.length === 0) {
+            state.lastModels = await this.deps.listModels();
+        }
+        let choice: ModelChoice | undefined;
+        if (/^\d+$/.test(lower)) {
+            choice = state.lastModels[Number(lower) - 1];
+            if (!choice) {
+                return `No model #${lower} — send "model" to see the list.`;
+            }
+        } else {
+            const matches = state.lastModels.filter(
+                (c) =>
+                    c.label.toLowerCase().includes(lower) ||
+                    c.model.toLowerCase().includes(lower),
+            );
+            if (matches.length === 0) {
+                return `No model matching "${arg}" — send "model" to see the list.`;
+            }
+            if (matches.length > 1) {
+                const preview = matches.slice(0, 5).map((c) => `• ${c.label}`);
+                return [`"${arg}" matches ${matches.length} models:`, ...preview, "", "Be more specific."].join("\n");
+            }
+            choice = matches[0];
+        }
+        state.model = { provider: choice.provider, model: choice.model };
+        return `✅ Model set to ${choice.label} for your chats from here.`;
+    }
+
+    private sessionEntry(sessionId: string): SessionIndexEntry | undefined {
+        return this.deps.sessions.listSessions().find((e) => e.sessionId === sessionId);
+    }
+
+    private recentSessions(): SessionIndexEntry[] {
+        return this.deps.sessions
+            .listSessions()
+            .filter((e) => !e.error)
+            .sort((a, b) => b.updatedAt.localeCompare(a.updatedAt))
+            .slice(0, LIST_LIMIT);
+    }
+
+    private renderList(state: SenderState): string {
+        const entries = this.recentSessions();
+        if (entries.length === 0) {
+            return "No chats yet — just send a message to start one.";
+        }
+        state.lastList = entries.map((e) => e.sessionId);
+        const lines = entries.map((e, i) => {
+            const marker =
+                e.latestTurnStatus === "suspended" ? " ⚠️" :
+                e.latestTurnStatus === "idle" ? " ⏳" : "";
+            const active = e.sessionId === state.activeSessionId ? " ← current" : "";
+            return `${i + 1}. ${e.title ?? "Untitled"}${marker} (${relativeTime(e.updatedAt)})${active}`;
+        });
+        return [
+            "Recent chats:",
+            ...lines,
+            "",
+            `Reply "resume N" to continue one.`,
+        ].join("\n");
+    }
+
+    private resumeSession(state: SenderState, index: number): string {
+        if (state.lastList.length === 0) {
+            state.lastList = this.recentSessions().map((e) => e.sessionId);
+        }
+        const sessionId = state.lastList[index - 1];
+        if (!sessionId) {
+            return `No chat #${index} — send "list" to see recent chats.`;
+        }
+        state.activeSessionId = sessionId;
+        state.pendingAsk = null;
+        const entry = this.sessionEntry(sessionId);
+        return `▶️ Resumed "${entry?.title ?? "Untitled"}" — send a message to continue.`;
+    }
+
+    private renderStatus(state: SenderState): string {
+        if (!state.activeSessionId) {
+            return "No current chat — your next message starts a new one.";
+        }
+        const entry = this.sessionEntry(state.activeSessionId);
+        if (!entry) return "Current chat no longer exists — send a message to start fresh.";
+        const status = state.busy
+            ? "working"
+            : entry.latestTurnStatus === "suspended"
+              ? "waiting on input"
+              : entry.latestTurnStatus;
+        return `Current chat: "${entry.title ?? "Untitled"}" — ${status}.`;
+    }
+
+    private async stopActive(state: SenderState): Promise<string> {
+        state.pendingAsk = null;
+        if (!state.activeSessionId) return "Nothing to stop.";
+        const entry = this.sessionEntry(state.activeSessionId);
+        if (!entry?.latestTurnId) return "Nothing to stop.";
+        if (
+            entry.latestTurnStatus === "completed" ||
+            entry.latestTurnStatus === "failed" ||
+            entry.latestTurnStatus === "cancelled"
+        ) {
+            return "Nothing running in the current chat.";
+        }
+        await this.deps.sessions.stopTurn(entry.latestTurnId, "stopped from mobile channel");
+        return "🛑 Stop requested.";
+    }
+
+    private async runMessage(state: SenderState, text: string, reply: ReplyFn): Promise<void> {
+        if (state.busy) {
+            await reply('⏳ Still working on the previous message — send "stop" to cancel it.');
+            return;
+        }
+        state.busy = true;
+        try {
+            await reply("⏳ Working on it…");
+            if (state.pendingAsk) {
+                const ask = state.pendingAsk;
+                state.pendingAsk = null;
+                const answered = await this.answerAsk(state, ask, text, reply);
+                if (answered) return;
+                // The ask was already resolved elsewhere (e.g. answered in the
+                // desktop UI) or the turn is terminal — treat the text as a
+                // normal message instead of discarding it.
+            }
+            await this.sendToSession(state, text, reply);
+        } catch (error) {
+            if (error instanceof TurnNotSettledError) {
+                await reply(
+                    '⏳ That chat is still working on something — send "stop" to cancel it, or "new" to start a fresh chat.',
+                );
+                return;
+            }
+            throw error;
+        } finally {
+            state.busy = false;
+        }
+    }
+
+    private async sendToSession(state: SenderState, text: string, reply: ReplyFn): Promise<void> {
+        // Subscribe before advancing so no settle event can slip past.
+        const watcher = this.watchBus();
+        try {
+            if (!state.activeSessionId) {
+                state.activeSessionId = await this.deps.sessions.createSession();
+            }
+            const sent = await this.deps.sessions.sendMessage(
+                state.activeSessionId,
+                { role: "user", content: text },
+                {
+                    agent: {
+                        agentId: AGENT_ID,
+                        ...(state.model ? { overrides: { model: state.model } } : {}),
+                    },
+                    autoPermission: true,
+                },
+            );
+            const settled = await watcher.waitFor(sent.turnId, TURN_TIMEOUT_MS);
+            await this.deliverSettled(state, sent.turnId, settled, reply);
+        } finally {
+            watcher.dispose();
+        }
+    }
+
+    // Returns false when the ask was stale (already answered on the desktop /
+    // turn terminal) — the caller then routes the text as a normal message.
+    private async answerAsk(
+        state: SenderState,
+        ask: { turnId: string; toolCallId: string },
+        text: string,
+        reply: ReplyFn,
+    ): Promise<boolean> {
+        const watcher = this.watchBus();
+        try {
+            const settledPromise = watcher.waitFor(ask.turnId, TURN_TIMEOUT_MS);
+            // respondToAskHuman resolves only when the whole advance settles,
+            // so it must not be awaited ahead of the watcher (that would
+            // bypass TURN_TIMEOUT_MS). Race instead: its rejection (stale
+            // ask) must beat the 30-minute timeout; its success defers to the
+            // settle event.
+            const settled = await Promise.race([
+                settledPromise,
+                this.deps.sessions
+                    .respondToAskHuman(ask.turnId, ask.toolCallId, text)
+                    .then(() => settledPromise),
+            ]);
+            await this.deliverSettled(state, ask.turnId, settled, reply);
+            return true;
+        } catch (error) {
+            if (error instanceof TurnInputError) return false;
+            throw error;
+        } finally {
+            watcher.dispose();
+        }
+    }
+
+    private async deliverSettled(
+        state: SenderState,
+        turnId: string,
+        settled: Settled,
+        reply: ReplyFn,
+    ): Promise<void> {
+        switch (settled.kind) {
+            case "completed": {
+                let text = settled.text;
+                if (!text) {
+                    // Rare: final message had no text parts; recover the last
+                    // assistant text from the persisted turn.
+                    try {
+                        const turn = await this.deps.sessions.getTurn(turnId);
+                        text = lastAssistantText(reduceTurn(turn.events));
+                    } catch {
+                        text = null;
+                    }
+                }
+                for (const chunk of chunkReply(text ?? "✅ Done (no text reply).")) {
+                    await reply(chunk);
+                }
+                return;
+            }
+            case "failed":
+                await reply(`❌ Task failed: ${settled.error}`);
+                return;
+            case "cancelled":
+                await reply("🛑 Stopped.");
+                return;
+            case "ask_human": {
+                state.pendingAsk = { turnId, toolCallId: settled.toolCallId };
+                const lines = [`❓ ${settled.query}`];
+                if (settled.options?.length) {
+                    lines.push(...settled.options.map((o, i) => `${i + 1}. ${o}`));
+                }
+                lines.push("", "Reply with your answer.");
+                await reply(lines.join("\n"));
+                return;
+            }
+            case "suspended":
+                await reply(
+                    "⚠️ The agent is waiting for a permission approval — open Rowboat on your desktop to continue.",
+                );
+                return;
+            case "timeout":
+                await reply(
+                    "⏱️ Still running after 30 minutes — check the desktop app for progress.",
+                );
+                return;
+        }
+    }
+
+    // Buffers settle-relevant events (≈1 per turn) from the moment of
+    // subscription so a settle firing between advance-start and waitFor() is
+    // never lost — without retaining the per-token delta stream of every
+    // concurrent session. One watcher per in-flight message.
+    private watchBus(): TurnWatcher {
+        const buffered: Array<{ turnId: string; settled: Settled }> = [];
+        let waiter: { turnId: string; resolve: (settled: Settled) => void } | null = null;
+        let cancelTimer: (() => void) | null = null;
+        const unsubscribe = this.deps.sessionBus.subscribe((event) => {
+            if (event.kind !== "turn-event") return;
+            const settled = settleOf(event.event);
+            if (!settled) return;
+            if (waiter) {
+                if (event.turnId === waiter.turnId) waiter.resolve(settled);
+                return;
+            }
+            buffered.push({ turnId: event.turnId, settled });
+        });
+        return {
+            waitFor: (turnId: string, timeoutMs: number): Promise<Settled> =>
+                new Promise<Settled>((resolve) => {
+                    const hit = buffered.find((b) => b.turnId === turnId);
+                    if (hit) {
+                        resolve(hit.settled);
+                        return;
+                    }
+                    buffered.length = 0;
+                    const timer = setTimeout(() => resolve({ kind: "timeout" }), timeoutMs);
+                    cancelTimer = () => clearTimeout(timer);
+                    waiter = {
+                        turnId,
+                        resolve: (settled) => {
+                            clearTimeout(timer);
+                            resolve(settled);
+                        },
+                    };
+                }),
+            dispose: () => {
+                unsubscribe();
+                cancelTimer?.();
+            },
+        };
+    }
+}
diff --git a/apps/x/packages/core/src/channels/repo.ts b/apps/x/packages/core/src/channels/repo.ts
new file mode 100644
index 00000000..d0ee2607
--- /dev/null
+++ b/apps/x/packages/core/src/channels/repo.ts
@@ -0,0 +1,40 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import type { z } from 'zod';
+import { WorkDir } from '../config/config.js';
+import { ChannelsConfig, DEFAULT_CHANNELS_CONFIG } from '@x/shared/dist/channels.js';
+
+export interface IChannelsConfigRepo {
+    getConfig(): Promise<z.infer<typeof ChannelsConfig>>;
+    setConfig(config: z.infer<typeof ChannelsConfig>): Promise<void>;
+}
+
+export class FSChannelsConfigRepo implements IChannelsConfigRepo {
+    private readonly configPath = path.join(WorkDir, 'config', 'channels.json');
+
+    constructor() {
+        this.ensureConfigFile();
+    }
+
+    private async ensureConfigFile(): Promise<void> {
+        try {
+            await fs.access(this.configPath);
+        } catch {
+            await fs.writeFile(this.configPath, JSON.stringify(DEFAULT_CHANNELS_CONFIG, null, 2));
+        }
+    }
+
+    async getConfig(): Promise<z.infer<typeof ChannelsConfig>> {
+        try {
+            const content = await fs.readFile(this.configPath, 'utf8');
+            return ChannelsConfig.parse(JSON.parse(content));
+        } catch {
+            return DEFAULT_CHANNELS_CONFIG;
+        }
+    }
+
+    async setConfig(config: z.infer<typeof ChannelsConfig>): Promise<void> {
+        const validated = ChannelsConfig.parse(config);
+        await fs.writeFile(this.configPath, JSON.stringify(validated, null, 2));
+    }
+}
diff --git a/apps/x/packages/core/src/channels/service.ts b/apps/x/packages/core/src/channels/service.ts
new file mode 100644
index 00000000..097d415a
--- /dev/null
+++ b/apps/x/packages/core/src/channels/service.ts
@@ -0,0 +1,251 @@
+import path from "node:path";
+import fs from "node:fs/promises";
+import type { z } from "zod";
+import type { ChannelsConfig, ChannelsStatus } from "@x/shared/dist/channels.js";
+import container from "../di/container.js";
+import { WorkDir } from "../config/config.js";
+import type { ISessions } from "../sessions/api.js";
+import type { EmitterSessionBus } from "../sessions/bus.js";
+import { isSignedIn } from "../account/account.js";
+import { listGatewayModels } from "../models/gateway.js";
+import { listOnboardingModels } from "../models/models-dev.js";
+import { ChannelBridge, type ModelChoice } from "./bridge.js";
+import type { IChannelsConfigRepo } from "./repo.js";
+import { TelegramTransport } from "./transports/telegram.js";
+// Type-only: the real module (which pulls the ~9MB baileys dependency) is
+// loaded dynamically in startWhatsApp, so boot pays nothing while disabled.
+import type { WhatsAppTransport } from "./transports/whatsapp.js";
+
+// Lifecycle owner for the mobile channels: reads config, runs the enabled
+// transports against one shared ChannelBridge, and fans status out to the
+// renderer (QR pairing, connection state). init() from main after
+// sessions.initialize(); applyChannelsConfig() on every settings save.
+
+type Config = z.infer<typeof ChannelsConfig>;
+type Status = z.infer<typeof ChannelsStatus>;
+
+const WHATSAPP_AUTH_DIR = path.join(WorkDir, "channels", "whatsapp-auth");
+const TELEGRAM_STATE_FILE = path.join(WorkDir, "channels", "telegram-state.json");
+
+let bridge: ChannelBridge | null = null;
+let whatsapp: WhatsAppTransport | null = null;
+let telegram: TelegramTransport | null = null;
+
+const status: Status = {
+    whatsapp: { state: "disabled" },
+    telegram: { state: "disabled" },
+};
+
+const statusListeners = new Set<(status: Status) => void>();
+
+// Serializes apply/logout so a fast settings double-save can't interleave
+// transport teardown and startup. enqueue() recovers the chain before adding
+// a step — a rejected step must fail only its own caller, never poison every
+// later settings save.
+let lifecycle: Promise<void> = Promise.resolve();
+
+function enqueue(step: () => Promise<void>): Promise<void> {
+    const run = lifecycle.catch(() => undefined).then(step);
+    lifecycle = run.catch(() => undefined);
+    return run;
+}
+
+function notifyStatus(): void {
+    const snapshot = structuredClone(status);
+    for (const listener of statusListeners) {
+        try {
+            listener(snapshot);
+        } catch {
+            // observers must never affect the channels
+        }
+    }
+}
+
+function setWhatsAppStatus(next: Status["whatsapp"]): void {
+    status.whatsapp = next;
+    notifyStatus();
+}
+
+function setTelegramStatus(next: Status["telegram"]): void {
+    status.telegram = next;
+    notifyStatus();
+}
+
+export function getChannelsStatus(): Status {
+    return structuredClone(status);
+}
+
+export function subscribeChannelsStatus(listener: (status: Status) => void): () => void {
+    statusListeners.add(listener);
+    return () => statusListeners.delete(listener);
+}
+
+// Same catalog the desktop model picker uses (models:list IPC).
+async function listBridgeModels(): Promise<ModelChoice[]> {
+    const catalog = (await isSignedIn())
+        ? await listGatewayModels()
+        : await listOnboardingModels();
+    return catalog.providers.flatMap((provider) =>
+        provider.models.map((m) => ({
+            provider: provider.id,
+            model: m.id,
+            label: `${m.name ?? m.id} — ${provider.name}`,
+        })),
+    );
+}
+
+function ensureBridge(): ChannelBridge {
+    if (!bridge) {
+        bridge = new ChannelBridge({
+            sessions: container.resolve<ISessions>("sessions"),
+            sessionBus: container.resolve<EmitterSessionBus>("sessionBus"),
+            listModels: listBridgeModels,
+        });
+    }
+    return bridge;
+}
+
+async function stopWhatsApp(): Promise<void> {
+    if (!whatsapp) return;
+    const stopping = whatsapp;
+    whatsapp = null;
+    await stopping.stop().catch(() => undefined);
+    setWhatsAppStatus({ state: "disabled" });
+}
+
+function stopTelegram(): void {
+    if (!telegram) return;
+    const stopping = telegram;
+    telegram = null;
+    stopping.stop();
+    setTelegramStatus({ state: "disabled" });
+}
+
+// Invalidates pending async QR renders whenever a newer status lands.
+let qrSeq = 0;
+
+async function startWhatsApp(config: Config["whatsapp"]): Promise<void> {
+    if (!config.enabled) {
+        setWhatsAppStatus({ state: "disabled" });
+        return;
+    }
+    const channelBridge = ensureBridge();
+    const [{ WhatsAppTransport: Transport }, QRCode] = await Promise.all([
+        import("./transports/whatsapp.js"),
+        import("qrcode").then((m) => m.default),
+    ]);
+    const transport = new Transport({
+        authDir: WHATSAPP_AUTH_DIR,
+        allowFrom: config.allowFrom,
+        onInbound: (senderKey, chatJid, text) => {
+            // Route replies through whichever transport is current at send
+            // time — the originating instance may have been replaced by a
+            // settings save while the turn was running.
+            const reply = async (replyText: string) => {
+                const current = whatsapp;
+                if (!current) throw new Error("WhatsApp channel is disabled");
+                await current.send(chatJid, replyText);
+            };
+            void channelBridge.handleInbound(senderKey, text, reply);
+        },
+        onStatus: (update) => {
+            if (whatsapp !== transport) return; // superseded instance
+            if (update.state === "qr" && update.qr) {
+                const seq = ++qrSeq;
+                // Render the pairing QR main-side so the renderer just shows
+                // an <img>; the raw pairing string never leaves core.
+                QRCode.toDataURL(update.qr, { margin: 1, width: 256 })
+                    .then((qrDataUrl) => {
+                        if (whatsapp === transport && seq === qrSeq) {
+                            setWhatsAppStatus({ state: "qr", qrDataUrl });
+                        }
+                    })
+                    .catch(() => {
+                        if (whatsapp === transport && seq === qrSeq) {
+                            setWhatsAppStatus({ state: "error", error: "Failed to render pairing QR" });
+                        }
+                    });
+                return;
+            }
+            qrSeq++;
+            setWhatsAppStatus({
+                state: update.state,
+                ...(update.self ? { self: update.self } : {}),
+                ...(update.error ? { error: update.error } : {}),
+            });
+        },
+    });
+    whatsapp = transport;
+    transport.start().catch((error) => {
+        if (whatsapp !== transport) return;
+        setWhatsAppStatus({
+            state: "error",
+            error: error instanceof Error ? error.message : String(error),
+        });
+    });
+}
+
+function startTelegram(config: Config["telegram"]): void {
+    if (!config.enabled) {
+        setTelegramStatus({ state: "disabled" });
+        return;
+    }
+    if (!config.botToken) {
+        setTelegramStatus({ state: "error", error: "Bot token missing — create one with @BotFather" });
+        return;
+    }
+    const channelBridge = ensureBridge();
+    const transport = new TelegramTransport({
+        botToken: config.botToken,
+        allowFrom: config.allowFrom,
+        stateFile: TELEGRAM_STATE_FILE,
+        onInbound: (senderKey, chatId, text) => {
+            const reply = async (replyText: string) => {
+                const current = telegram;
+                if (!current) throw new Error("Telegram channel is disabled");
+                await current.send(chatId, replyText);
+            };
+            void channelBridge.handleInbound(senderKey, text, reply);
+        },
+        onStatus: (update) => {
+            if (telegram !== transport) return; // superseded instance
+            setTelegramStatus(update);
+        },
+    });
+    telegram = transport;
+    void transport.start();
+}
+
+export function applyChannelsConfig(config: Config): Promise<void> {
+    return enqueue(async () => {
+        await stopWhatsApp();
+        stopTelegram();
+        await startWhatsApp(config.whatsapp);
+        startTelegram(config.telegram);
+    });
+}
+
+// Unlink the WhatsApp device and, if the channel is still enabled, restart it
+// so a fresh pairing QR appears. Telegram is left untouched.
+export function logoutWhatsApp(): Promise<void> {
+    return enqueue(async () => {
+        if (whatsapp) {
+            const out = whatsapp;
+            whatsapp = null;
+            await out.logout().catch(() => undefined);
+        } else {
+            await fs.rm(WHATSAPP_AUTH_DIR, { recursive: true, force: true }).catch(() => undefined);
+        }
+        const config = await container
+            .resolve<IChannelsConfigRepo>("channelsConfigRepo")
+            .getConfig();
+        await startWhatsApp(config.whatsapp);
+    });
+}
+
+export async function init(): Promise<void> {
+    const config = await container
+        .resolve<IChannelsConfigRepo>("channelsConfigRepo")
+        .getConfig();
+    await applyChannelsConfig(config);
+}
diff --git a/apps/x/packages/core/src/channels/transports/telegram.ts b/apps/x/packages/core/src/channels/transports/telegram.ts
new file mode 100644
index 00000000..b4616fd7
--- /dev/null
+++ b/apps/x/packages/core/src/channels/transports/telegram.ts
@@ -0,0 +1,218 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import type { z } from "zod";
+import type { TelegramChannelStatus } from "@x/shared/dist/channels.js";
+
+// Telegram Bot API transport. Deliberately dependency-free: the Bot API is
+// plain HTTPS — getUpdates long polling (outbound connection, works behind
+// NAT) plus sendMessage. The user supplies their own bot token (@BotFather).
+//
+// The getUpdates offset is persisted to disk after each processed batch:
+// Telegram only marks updates confirmed when a LATER getUpdates call passes a
+// higher offset, so without persistence every transport restart (app relaunch
+// or settings save) would redeliver — and re-execute — the last batch.
+
+const POLL_TIMEOUT_S = 50;
+const RETRY_DELAY_MS = 5000;
+const MAX_RETRY_DELAY_MS = 60_000;
+
+type Status = z.infer<typeof TelegramChannelStatus>;
+
+class TelegramApiError extends Error {
+    constructor(
+        message: string,
+        readonly code?: number,
+    ) {
+        super(message);
+        this.name = "TelegramApiError";
+    }
+}
+
+// 401 = token revoked/invalid, 404 = bot deleted / malformed token. Retrying
+// these forever would hammer the API and show a misleading "polling" status.
+function isTerminal(error: unknown): boolean {
+    return error instanceof TelegramApiError && (error.code === 401 || error.code === 404);
+}
+
+interface TelegramUpdate {
+    update_id: number;
+    message?: {
+        message_id: number;
+        text?: string;
+        chat: { id: number; type: string };
+        from?: { id: number; is_bot?: boolean };
+    };
+}
+
+export interface TelegramTransportOptions {
+    botToken: string;
+    allowFrom: string[];
+    // JSON file holding { offset } across restarts.
+    stateFile: string;
+    // chatId is the address to reply to; the caller owns reply routing.
+    onInbound: (senderKey: string, chatId: string, text: string) => void;
+    onStatus: (status: Status) => void;
+}
+
+export class TelegramTransport {
+    private abort: AbortController | null = null;
+    private stopped = false;
+    private offset = 0;
+    private botUsername: string | undefined;
+
+    constructor(private readonly opts: TelegramTransportOptions) {}
+
+    async start(): Promise<void> {
+        this.stopped = false;
+        this.opts.onStatus({ state: "starting" });
+        void this.run();
+    }
+
+    stop(): void {
+        this.stopped = true;
+        this.abort?.abort();
+        this.opts.onStatus({ state: "disabled" });
+    }
+
+    private async call(method: string, body?: unknown, signal?: AbortSignal): Promise<unknown> {
+        const res = await fetch(`https://api.telegram.org/bot${this.opts.botToken}/${method}`, {
+            method: "POST",
+            headers: { "content-type": "application/json" },
+            body: body === undefined ? undefined : JSON.stringify(body),
+            ...(signal ? { signal } : {}),
+        });
+        const payload = (await res.json()) as {
+            ok: boolean;
+            result?: unknown;
+            description?: string;
+            error_code?: number;
+        };
+        if (!payload.ok) {
+            throw new TelegramApiError(
+                payload.description ?? `Telegram API error (${method})`,
+                payload.error_code,
+            );
+        }
+        return payload.result;
+    }
+
+    private async loadOffset(): Promise<void> {
+        try {
+            const raw = await fs.readFile(this.opts.stateFile, "utf8");
+            const parsed = JSON.parse(raw) as { offset?: unknown };
+            if (typeof parsed.offset === "number" && Number.isFinite(parsed.offset)) {
+                this.offset = parsed.offset;
+            }
+        } catch {
+            // first run or unreadable state — start from 0
+        }
+    }
+
+    private async saveOffset(): Promise<void> {
+        try {
+            await fs.mkdir(path.dirname(this.opts.stateFile), { recursive: true });
+            await fs.writeFile(this.opts.stateFile, JSON.stringify({ offset: this.offset }));
+        } catch {
+            // best effort — worst case is one redelivered batch after restart
+        }
+    }
+
+    private async sleep(ms: number): Promise<void> {
+        await new Promise((resolve) => setTimeout(resolve, ms));
+    }
+
+    private async run(): Promise<void> {
+        await this.loadOffset();
+
+        // Validate the token, retrying transient failures (the app often
+        // starts at login before the network is up). Only a definitive
+        // API rejection is terminal.
+        let delay = RETRY_DELAY_MS;
+        while (!this.stopped) {
+            try {
+                const me = (await this.call("getMe")) as { username?: string };
+                if (this.stopped) return;
+                this.botUsername = me.username;
+                this.opts.onStatus({ state: "polling", botUsername: me.username });
+                break;
+            } catch (error) {
+                if (this.stopped) return;
+                const message = error instanceof Error ? error.message : String(error);
+                if (isTerminal(error)) {
+                    this.opts.onStatus({
+                        state: "error",
+                        error: `Bot token rejected (${message}) — create a new token with @BotFather.`,
+                    });
+                    return;
+                }
+                this.opts.onStatus({ state: "error", error: message });
+                await this.sleep(delay);
+                delay = Math.min(delay * 2, MAX_RETRY_DELAY_MS);
+            }
+        }
+
+        delay = RETRY_DELAY_MS;
+        let healthy = true;
+        while (!this.stopped) {
+            this.abort = new AbortController();
+            try {
+                const updates = (await this.call(
+                    "getUpdates",
+                    {
+                        timeout: POLL_TIMEOUT_S,
+                        offset: this.offset,
+                        allowed_updates: ["message"],
+                    },
+                    this.abort.signal,
+                )) as TelegramUpdate[];
+                for (const update of updates) {
+                    this.offset = update.update_id + 1;
+                    this.handleUpdate(update);
+                }
+                if (updates.length > 0) {
+                    await this.saveOffset();
+                }
+                if (!healthy) {
+                    // Restore the healthy status only after a successful poll.
+                    healthy = true;
+                    this.opts.onStatus({ state: "polling", botUsername: this.botUsername });
+                }
+                delay = RETRY_DELAY_MS;
+            } catch (error) {
+                if (this.stopped) return;
+                const message = error instanceof Error ? error.message : String(error);
+                if (isTerminal(error)) {
+                    this.opts.onStatus({
+                        state: "error",
+                        error: `Bot token rejected (${message}) — create a new token with @BotFather.`,
+                    });
+                    return;
+                }
+                healthy = false;
+                this.opts.onStatus({ state: "error", error: message });
+                await this.sleep(delay);
+                delay = Math.min(delay * 2, MAX_RETRY_DELAY_MS);
+            }
+        }
+    }
+
+    private handleUpdate(update: TelegramUpdate): void {
+        const message = update.message;
+        if (!message?.text || message.from?.is_bot) return;
+        // DMs only: group chats would let any member drive the bridge.
+        if (message.chat.type !== "private") return;
+        const chatId = String(message.chat.id);
+        if (!this.opts.allowFrom.includes(chatId)) {
+            void this.send(
+                chatId,
+                `⛔ Not authorized. Your chat ID is ${chatId} — add it under Rowboat → Settings → Mobile to pair this chat.`,
+            ).catch(() => undefined);
+            return;
+        }
+        this.opts.onInbound(`telegram:${chatId}`, chatId, message.text);
+    }
+
+    async send(chatId: string, text: string): Promise<void> {
+        await this.call("sendMessage", { chat_id: chatId, text });
+    }
+}
diff --git a/apps/x/packages/core/src/channels/transports/whatsapp.ts b/apps/x/packages/core/src/channels/transports/whatsapp.ts
new file mode 100644
index 00000000..52852a52
--- /dev/null
+++ b/apps/x/packages/core/src/channels/transports/whatsapp.ts
@@ -0,0 +1,219 @@
+import fs from "node:fs/promises";
+import makeWASocket, {
+    DisconnectReason,
+    areJidsSameUser,
+    isJidGroup,
+    jidDecode,
+    useMultiFileAuthState,
+} from "baileys";
+
+// WhatsApp transport via Baileys: the app links to the user's own WhatsApp
+// account as a linked device (QR pairing, same as WhatsApp Web) over an
+// outbound WebSocket — no server, no port forwarding.
+//
+// Access model: the linked account's own self-chat ("message yourself") is
+// always allowed; other senders must be explicitly allowlisted by phone
+// number. Group chats are ignored entirely.
+
+type WASocket = ReturnType<typeof makeWASocket>;
+
+const RECONNECT_DELAY_MS = 3000;
+// Marks bridge-sent messages. In the self-chat our own replies come back on
+// messages.upsert like any other message; the marker (plus sent-id tracking)
+// keeps the bridge from answering itself in a loop.
+const REPLY_MARKER = "🤖 ";
+
+export interface WhatsAppTransportStatus {
+    state: "starting" | "qr" | "connected" | "error" | "disabled";
+    qr?: string;
+    self?: string;
+    error?: string;
+}
+
+export interface WhatsAppTransportOptions {
+    authDir: string;
+    allowFrom: string[];
+    // chatJid is the address to reply to; the caller owns reply routing so a
+    // reply can go through whichever transport instance is current by then.
+    onInbound: (senderKey: string, chatJid: string, text: string) => void;
+    onStatus: (status: WhatsAppTransportStatus) => void;
+}
+
+interface TextishMessage {
+    conversation?: unknown;
+    extendedTextMessage?: { text?: unknown };
+    ephemeralMessage?: { message?: TextishMessage };
+}
+
+interface InboundWAMessage {
+    key?: {
+        remoteJid?: string | null;
+        // Phone-number JID when remoteJid is a LID (anonymized) JID.
+        remoteJidAlt?: string | null;
+        fromMe?: boolean | null;
+        id?: string | null;
+    };
+    message?: unknown;
+}
+
+function messageText(message: unknown): string | null {
+    if (!message || typeof message !== "object") return null;
+    const m = message as TextishMessage;
+    const unwrapped = m.ephemeralMessage?.message ?? m;
+    const text: unknown = unwrapped.conversation ?? unwrapped.extendedTextMessage?.text;
+    return typeof text === "string" && text ? text : null;
+}
+
+export class WhatsAppTransport {
+    private sock: WASocket | null = null;
+    private stopped = false;
+    // Bumped on every connect/stop/logout; handlers close over their own
+    // generation and go inert the moment they are superseded, so a stop()
+    // racing an await inside connect() cannot leave a zombie socket
+    // processing messages alongside its replacement.
+    private generation = 0;
+    private sentIds = new Set<string>();
+
+    constructor(private readonly opts: WhatsAppTransportOptions) {}
+
+    async start(): Promise<void> {
+        this.stopped = false;
+        this.opts.onStatus({ state: "starting" });
+        await this.connect();
+    }
+
+    async stop(): Promise<void> {
+        this.stopped = true;
+        this.generation++;
+        try {
+            this.sock?.end(undefined);
+        } catch {
+            // already closed
+        }
+        this.sock = null;
+        this.opts.onStatus({ state: "disabled" });
+    }
+
+    // Unlink this device: invalidates the pairing on the phone and clears
+    // local credentials so the next start shows a fresh QR.
+    async logout(): Promise<void> {
+        this.stopped = true;
+        this.generation++;
+        try {
+            await this.sock?.logout();
+        } catch {
+            // best effort — clearing creds below is what actually unpairs us
+        }
+        this.sock = null;
+        await fs.rm(this.opts.authDir, { recursive: true, force: true });
+        this.opts.onStatus({ state: "disabled" });
+    }
+
+    private async connect(): Promise<void> {
+        if (this.stopped) return;
+        const generation = ++this.generation;
+        const { state, saveCreds } = await useMultiFileAuthState(this.opts.authDir);
+        if (this.stopped || generation !== this.generation) return;
+        const sock = makeWASocket({
+            auth: state,
+            syncFullHistory: false,
+            markOnlineOnConnect: false,
+        });
+        this.sock = sock;
+        const isCurrent = () =>
+            !this.stopped && generation === this.generation && this.sock === sock;
+
+        sock.ev.on("creds.update", saveCreds);
+
+        sock.ev.on("connection.update", (update) => {
+            if (!isCurrent()) return;
+            if (update.qr) {
+                this.opts.onStatus({ state: "qr", qr: update.qr });
+            }
+            if (update.connection === "open") {
+                const self = jidDecode(sock.user?.id ?? "")?.user;
+                this.opts.onStatus({ state: "connected", ...(self ? { self } : {}) });
+            }
+            if (update.connection === "close") {
+                const statusCode = (update.lastDisconnect?.error as { output?: { statusCode?: number } } | undefined)
+                    ?.output?.statusCode;
+                if (statusCode === DisconnectReason.loggedOut) {
+                    // Unlinked from the phone; stale creds would loop forever.
+                    void fs.rm(this.opts.authDir, { recursive: true, force: true });
+                    this.opts.onStatus({
+                        state: "error",
+                        error: "Logged out from the phone — toggle WhatsApp off and on to pair again.",
+                    });
+                    return;
+                }
+                setTimeout(() => {
+                    if (!isCurrent()) return;
+                    this.connect().catch((error) => {
+                        this.opts.onStatus({
+                            state: "error",
+                            error: error instanceof Error ? error.message : String(error),
+                        });
+                    });
+                }, RECONNECT_DELAY_MS);
+            }
+        });
+
+        sock.ev.on("messages.upsert", ({ messages, type }) => {
+            if (!isCurrent() || type !== "notify") return;
+            for (const msg of messages) {
+                this.handleMessage(sock, msg);
+            }
+        });
+    }
+
+    private handleMessage(sock: WASocket, msg: InboundWAMessage): void {
+        const jid: string | undefined = msg.key?.remoteJid ?? undefined;
+        if (!jid || isJidGroup(jid) || jid === "status@broadcast") return;
+        const messageId: string | undefined = msg.key?.id ?? undefined;
+        if (messageId && this.sentIds.has(messageId)) return;
+        const text = messageText(msg.message);
+        if (!text || text.startsWith(REPLY_MARKER)) return;
+
+        // LID-addressed chats put the anonymized id in remoteJid and (when
+        // the server supplies it) the real phone-number JID in remoteJidAlt.
+        // Identity checks must consider both.
+        const altJid: string | undefined = msg.key?.remoteJidAlt ?? undefined;
+        const chatJids = altJid ? [jid, altJid] : [jid];
+        const user = sock.user as { id?: string; lid?: string } | undefined;
+        const selfIds = [user?.id, user?.lid].filter((v): v is string => Boolean(v));
+        const isSelfChat = chatJids.some((j) =>
+            selfIds.some((selfId) => areJidsSameUser(j, selfId)),
+        );
+        const senderNumbers = chatJids.flatMap((j) => {
+            const decoded = jidDecode(j)?.user;
+            return decoded ? [decoded] : [];
+        });
+
+        // Self-chat is the owner by definition. Anyone else must be
+        // allowlisted — this bridge is remote control over the desktop agent.
+        if (!isSelfChat) {
+            if (msg.key?.fromMe) return;
+            if (!senderNumbers.some((n) => this.opts.allowFrom.includes(n))) return;
+        }
+
+        // Prefer the phone number (altJid decodes to it when present) as the
+        // stable sender identity.
+        const senderId = altJid
+            ? (jidDecode(altJid)?.user ?? senderNumbers[0] ?? jid)
+            : (senderNumbers[0] ?? jid);
+        this.opts.onInbound(`whatsapp:${senderId}`, jid, text);
+    }
+
+    async send(jid: string, text: string): Promise<void> {
+        const sock = this.sock;
+        if (!sock) throw new Error("WhatsApp is not connected");
+        const sent = await sock.sendMessage(jid, { text: `${REPLY_MARKER}${text}` });
+        const id = sent?.key?.id;
+        if (id) {
+            this.sentIds.add(id);
+            if (this.sentIds.size > 500) {
+                this.sentIds = new Set(Array.from(this.sentIds).slice(-250));
+            }
+        }
+    }
+}
diff --git a/apps/x/packages/core/src/code-mode/acp/client.ts b/apps/x/packages/core/src/code-mode/acp/client.ts
index b78c5619..f7351604 100644
--- a/apps/x/packages/core/src/code-mode/acp/client.ts
+++ b/apps/x/packages/core/src/code-mode/acp/client.ts
@@ -139,6 +139,8 @@ function toEvent(update: SessionUpdate): CodeRunEvent {
                     priority: e.priority ?? undefined,
                 })),
             };
+        case 'usage_update':
+            return { type: 'usage', used: update.used, size: update.size };
         default:
             return { type: 'other', sessionUpdate: update.sessionUpdate };
     }
diff --git a/apps/x/packages/core/src/config/config.ts b/apps/x/packages/core/src/config/config.ts
index 7f230514..82b2021e 100644
--- a/apps/x/packages/core/src/config/config.ts
+++ b/apps/x/packages/core/src/config/config.ts
@@ -44,6 +44,17 @@ function ensureDefaultConfigs() {
             configured: false
         }, null, 2));
     }
+
+    // Create gmail_sync.json with the default onboarding email count if it
+    // doesn't exist, so the "how many emails to backfill" setting is
+    // discoverable and editable. Keep the default in sync with
+    // DEFAULT_MAX_EMAILS in gmail_sync_config.ts.
+    const gmailSyncConfig = path.join(WorkDir, "config", "gmail_sync.json");
+    if (!fs.existsSync(gmailSyncConfig)) {
+        fs.writeFileSync(gmailSyncConfig, JSON.stringify({
+            maxEmails: 500
+        }, null, 2));
+    }
 }
 
 ensureDirs();
diff --git a/apps/x/packages/core/src/config/gmail_sync_config.ts b/apps/x/packages/core/src/config/gmail_sync_config.ts
new file mode 100644
index 00000000..d59be6cf
--- /dev/null
+++ b/apps/x/packages/core/src/config/gmail_sync_config.ts
@@ -0,0 +1,69 @@
+import fs from 'fs';
+import path from 'path';
+import { WorkDir } from './config.js';
+
+const CONFIG_FILE = path.join(WorkDir, 'config', 'gmail_sync.json');
+
+/**
+ * How many of the newest email threads the initial (onboarding) / recovery
+ * Gmail sync pulls down. This bounds the sync by a COUNT of recent threads
+ * rather than a fixed date window, so a fresh account backfills its most recent
+ * `maxEmails` emails even when they span more than a week.
+ */
+export const DEFAULT_MAX_EMAILS = 500;
+
+// Guard rails: at least one email, and a hard ceiling so a misconfigured value
+// can't trigger a runaway onboarding sync (each thread costs a threads.get plus
+// an LLM classification).
+const MIN_MAX_EMAILS = 1;
+const MAX_MAX_EMAILS = 5000;
+
+interface GmailSyncConfig {
+    maxEmails: number;
+}
+
+function clampMaxEmails(value: number): number {
+    return Math.max(MIN_MAX_EMAILS, Math.min(MAX_MAX_EMAILS, Math.floor(value)));
+}
+
+function readConfig(): Partial<GmailSyncConfig> {
+    try {
+        if (fs.existsSync(CONFIG_FILE)) {
+            const raw = fs.readFileSync(CONFIG_FILE, 'utf-8');
+            return JSON.parse(raw) as Partial<GmailSyncConfig>;
+        }
+    } catch (err) {
+        console.warn('[GmailSyncConfig] Failed to read gmail_sync.json:', err);
+    }
+    return {};
+}
+
+function writeConfig(config: Partial<GmailSyncConfig>): void {
+    const configDir = path.dirname(CONFIG_FILE);
+    if (!fs.existsSync(configDir)) {
+        fs.mkdirSync(configDir, { recursive: true });
+    }
+    fs.writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2));
+}
+
+/**
+ * Read the configured max email count for the onboarding/full sync.
+ * Falls back to {@link DEFAULT_MAX_EMAILS} when the file is missing, malformed,
+ * or holds an out-of-range value.
+ */
+export function getMaxEmails(): number {
+    const value = Number(readConfig()?.maxEmails);
+    if (Number.isFinite(value) && value > 0) {
+        return clampMaxEmails(value);
+    }
+    return DEFAULT_MAX_EMAILS;
+}
+
+/**
+ * Persist the max email count used by the onboarding/full sync. The value is
+ * clamped into the supported range before writing.
+ */
+export function setMaxEmails(maxEmails: number): void {
+    writeConfig({ ...readConfig(), maxEmails: clampMaxEmails(maxEmails) });
+}
+
diff --git a/apps/x/packages/core/src/di/container.ts b/apps/x/packages/core/src/di/container.ts
index 4bfc92ed..eefdaa5f 100644
--- a/apps/x/packages/core/src/di/container.ts
+++ b/apps/x/packages/core/src/di/container.ts
@@ -1,4 +1,6 @@
-import { asClass, asValue, createContainer, InjectionMode } from "awilix";
+import path from "node:path";
+import { asClass, asFunction, asValue, createContainer, InjectionMode } from "awilix";
+import { WorkDir } from "../config/config.js";
 import { FSModelConfigRepo, IModelConfigRepo } from "../models/repo.js";
 import { FSMcpConfigRepo, IMcpConfigRepo } from "../mcp/repo.js";
 import { FSAgentsRepo, IAgentsRepo } from "../agents/repo.js";
@@ -16,6 +18,7 @@ import { IAbortRegistry, InMemoryAbortRegistry } from "../runs/abort-registry.js
 import { FSAgentScheduleRepo, IAgentScheduleRepo } from "../agent-schedule/repo.js";
 import { FSAgentScheduleStateRepo, IAgentScheduleStateRepo } from "../agent-schedule/state-repo.js";
 import { FSSlackConfigRepo, ISlackConfigRepo } from "../slack/repo.js";
+import { FSChannelsConfigRepo, IChannelsConfigRepo } from "../channels/repo.js";
 import { CodeModeManager } from "../code-mode/acp/manager.js";
 import { CodePermissionRegistry } from "../code-mode/acp/permission-registry.js";
 import { FSCodeProjectsRepo, ICodeProjectsRepo } from "../code-mode/projects/repo.js";
@@ -24,6 +27,37 @@ import { CodeSessionService } from "../code-mode/sessions/service.js";
 import { CodeSessionStatusTracker } from "../code-mode/sessions/status-tracker.js";
 import type { IBrowserControlService } from "../application/browser-control/service.js";
 import type { INotificationService } from "../application/notification/service.js";
+import { SystemClock, type IClock } from "../turns/clock.js";
+import { FSTurnRepo } from "../turns/fs-repo.js";
+import type { ITurnRepo } from "../turns/repo.js";
+import { TurnRepoContextResolver, type IContextResolver } from "../turns/context-resolver.js";
+import { EmitterTurnLifecycleBus, type ITurnLifecycleBus } from "../turns/bus.js";
+import { RealUsageReporter } from "../turns/bridges/real-usage-reporter.js";
+import type { IUsageReporter } from "../turns/usage-reporter.js";
+import { TurnRuntime } from "../turns/runtime.js";
+import type { ITurnRuntime } from "../turns/api.js";
+import type { IAgentResolver } from "../turns/agent-resolver.js";
+import type { IModelRegistry } from "../turns/model-registry.js";
+import type { IToolRegistry } from "../turns/tool-registry.js";
+import type { IPermissionChecker, IPermissionClassifier } from "../turns/permission.js";
+import { RealAgentResolver } from "../turns/bridges/real-agent-resolver.js";
+import { RealModelRegistry } from "../turns/bridges/real-model-registry.js";
+import { RealToolRegistry } from "../turns/bridges/real-tool-registry.js";
+import { RealPermissionChecker } from "../turns/bridges/real-permission-checker.js";
+import { RealPermissionClassifier } from "../turns/bridges/real-permission-classifier.js";
+import { FSSessionRepo } from "../sessions/fs-repo.js";
+import type { ISessionRepo } from "../sessions/repo.js";
+import { EmitterSessionBus, type ISessionBus } from "../sessions/bus.js";
+import { SessionsImpl } from "../sessions/sessions.js";
+import type { ISessions } from "../sessions/api.js";
+import {
+    DefaultModelResolver,
+    type IDefaultModelResolver,
+} from "../models/default-model-resolver.js";
+import {
+    HeadlessAgentRunner,
+    type IHeadlessAgentRunner,
+} from "../agents/headless.js";
 
 const container = createContainer({
     injectionMode: InjectionMode.PROXY,
@@ -36,7 +70,15 @@ container.register({
     bus: asClass<IBus>(InMemoryBus).singleton(),
     runsLock: asClass<IRunsLock>(InMemoryRunsLock).singleton(),
     abortRegistry: asClass<IAbortRegistry>(InMemoryAbortRegistry).singleton(),
-    agentRuntime: asClass<IAgentRuntime>(AgentRuntime).singleton(),
+    // Lazy: agents/runtime.js participates in an import cycle with this
+    // module (and is now also reachable via the turn-runtime bridges), so the
+    // class binding may not be initialized yet when this body runs.
+    agentRuntime: asFunction<IAgentRuntime>(
+        (cradle) =>
+            new AgentRuntime(
+                cradle as unknown as ConstructorParameters<typeof AgentRuntime>[0],
+            ),
+    ).singleton(),
 
     mcpConfigRepo: asClass<IMcpConfigRepo>(FSMcpConfigRepo).singleton(),
     modelConfigRepo: asClass<IModelConfigRepo>(FSModelConfigRepo).singleton(),
@@ -49,6 +91,7 @@ container.register({
     agentScheduleRepo: asClass<IAgentScheduleRepo>(FSAgentScheduleRepo).singleton(),
     agentScheduleStateRepo: asClass<IAgentScheduleStateRepo>(FSAgentScheduleStateRepo).singleton(),
     slackConfigRepo: asClass<ISlackConfigRepo>(FSSlackConfigRepo).singleton(),
+    channelsConfigRepo: asClass<IChannelsConfigRepo>(FSChannelsConfigRepo).singleton(),
 
     // ACP code-mode engine: the manager holds a live agent connection per chat only
     // around an active turn (torn down after a short idle grace; resumed via
@@ -62,6 +105,30 @@ container.register({
     codeSessionsRepo: asClass<ICodeSessionsRepo>(FSCodeSessionsRepo).singleton(),
     codeSessionService: asClass(CodeSessionService).singleton(),
     codeSessionStatusTracker: asClass(CodeSessionStatusTracker).singleton(),
+
+    // New turn/session runtime (turn-runtime-design.md / session-design.md).
+    // Bridges are constructed via asFunction so their optional test seams
+    // don't collide with strict PROXY cradle resolution.
+    clock: asClass<IClock>(SystemClock).singleton(),
+    turnsRootDir: asValue(path.join(WorkDir, "storage", "turns")),
+    sessionsRootDir: asValue(path.join(WorkDir, "storage", "sessions")),
+    turnRepo: asClass<ITurnRepo>(FSTurnRepo).singleton(),
+    contextResolver: asClass<IContextResolver>(TurnRepoContextResolver).singleton(),
+    lifecycleBus: asClass<ITurnLifecycleBus>(EmitterTurnLifecycleBus).singleton(),
+    usageReporter: asClass<IUsageReporter>(RealUsageReporter).singleton(),
+    agentResolver: asFunction<IAgentResolver>(() => new RealAgentResolver()).singleton(),
+    modelRegistry: asFunction<IModelRegistry>(() => new RealModelRegistry()).singleton(),
+    toolRegistry: asFunction<IToolRegistry>(() => new RealToolRegistry()).singleton(),
+    permissionChecker: asFunction<IPermissionChecker>(() => new RealPermissionChecker()).singleton(),
+    permissionClassifier: asFunction<IPermissionClassifier>(() => new RealPermissionClassifier()).singleton(),
+    turnRuntime: asClass<ITurnRuntime>(TurnRuntime).singleton(),
+    sessionRepo: asClass<ISessionRepo>(FSSessionRepo).singleton(),
+    sessionBus: asClass<ISessionBus>(EmitterSessionBus).singleton(),
+    sessions: asClass<ISessions>(SessionsImpl).singleton(),
+    defaultModelResolver:
+        asClass<IDefaultModelResolver>(DefaultModelResolver).singleton(),
+    headlessAgentRunner:
+        asClass<IHeadlessAgentRunner>(HeadlessAgentRunner).singleton(),
 });
 
 export default container;
diff --git a/apps/x/packages/core/src/knowledge/agent_notes.ts b/apps/x/packages/core/src/knowledge/agent_notes.ts
index f1380c4a..091b4d78 100644
--- a/apps/x/packages/core/src/knowledge/agent_notes.ts
+++ b/apps/x/packages/core/src/knowledge/agent_notes.ts
@@ -2,9 +2,9 @@ import fs from 'fs';
 import path from 'path';
 import { google } from 'googleapis';
 import { WorkDir } from '../config/config.js';
-import { createRun, createMessage } from '../runs/runs.js';
+import { runHeadlessAgent } from '../agents/headless-app.js';
 import { getKgModel } from '../models/defaults.js';
-import { getErrorDetails, waitForRunCompletion } from '../agents/utils.js';
+import { getErrorDetails } from '../agents/utils.js';
 import { serviceLogger } from '../services/service_logger.js';
 import { loadUserConfig, updateUserEmail } from '../config/user_config.js';
 import { GoogleClientFactory } from './google-client-factory.js';
@@ -281,14 +281,12 @@ async function processAgentNotes(): Promise<void> {
         const timestamp = new Date().toISOString();
         const message = `Current timestamp: ${timestamp}\n\nProcess the following source material and update the Agent Notes folder accordingly.\n\n${messageParts.join('\n\n')}`;
 
-        const agentRun = await createRun({
+        await runHeadlessAgent({
             agentId: AGENT_ID,
+            message,
             model: await getKgModel(),
-            useCase: 'knowledge_sync',
-            subUseCase: 'agent_notes',
+            throwOnError: true,
         });
-        await createMessage(agentRun.id, message);
-        await waitForRunCompletion(agentRun.id, { throwOnError: true });
 
         // Mark everything as processed
         for (const p of emailPaths) {
diff --git a/apps/x/packages/core/src/knowledge/build_graph.ts b/apps/x/packages/core/src/knowledge/build_graph.ts
index ccfeea49..03dcef73 100644
--- a/apps/x/packages/core/src/knowledge/build_graph.ts
+++ b/apps/x/packages/core/src/knowledge/build_graph.ts
@@ -2,9 +2,8 @@ import fs from 'fs';
 import path from 'path';
 import { WorkDir } from '../config/config.js';
 import { getKgModel } from '../models/defaults.js';
-import { createRun, createMessage } from '../runs/runs.js';
-import { bus } from '../runs/bus.js';
-import { getErrorDetails, waitForRunCompletion } from '../agents/utils.js';
+import { runHeadlessAgent, toolInputPaths } from '../agents/headless-app.js';
+import { getErrorDetails } from '../agents/utils.js';
 import { serviceLogger, type ServiceRunContext } from '../services/service_logger.js';
 import {
     loadState,
@@ -89,14 +88,6 @@ function hasNoiseLabels(content: string): boolean {
     return false;
 }
 
-function extractPathFromToolInput(input: string): string | null {
-    try {
-        const parsed = JSON.parse(input) as { path?: string };
-        return typeof parsed.path === 'string' ? parsed.path : null;
-    } catch {
-        return null;
-    }
-}
 
 function ensureSuggestedTopicsFileLocation(): string {
     if (fs.existsSync(SUGGESTED_TOPICS_PATH)) {
@@ -252,13 +243,6 @@ async function createNotesFromBatch(
         fs.mkdirSync(NOTES_OUTPUT_DIR, { recursive: true });
     }
 
-    // Create a run for the note creation agent
-    const run = await createRun({
-        agentId: NOTE_CREATION_AGENT,
-        model: await getKgModel(),
-        useCase: 'knowledge_sync',
-        subUseCase: 'build_graph',
-    });
     const suggestedTopicsContent = readSuggestedTopicsFile();
 
     // Build message with index and all files in the batch
@@ -293,37 +277,19 @@ async function createNotesFromBatch(
         message += `\n\n---\n\n`;
     });
 
-    const notesCreated = new Set<string>();
-    const notesModified = new Set<string>();
-
-    const unsubscribe = await bus.subscribe(run.id, async (event) => {
-        if (event.type !== "tool-invocation") {
-            return;
-        }
-        if (event.toolName !== "file-writeText" && event.toolName !== "file-editText") {
-            return;
-        }
-        const toolPath = extractPathFromToolInput(event.input);
-        if (!toolPath) {
-            return;
-        }
-        if (event.toolName === "file-writeText") {
-            notesCreated.add(toolPath);
-        } else if (event.toolName === "file-editText") {
-            notesModified.add(toolPath);
-        }
+    const { turnId, state } = await runHeadlessAgent({
+        agentId: NOTE_CREATION_AGENT,
+        message,
+        model: await getKgModel(),
+        throwOnError: true,
     });
 
-    await createMessage(run.id, message);
+    // Created/modified paths come from the durable turn state instead of
+    // streaming bus subscriptions.
+    const notesCreated = toolInputPaths(state, ["file-writeText"]);
+    const notesModified = toolInputPaths(state, ["file-editText"]);
 
-    // Wait for the run to complete
-    try {
-        await waitForRunCompletion(run.id, { throwOnError: true });
-    } finally {
-        unsubscribe();
-    }
-
-    return { runId: run.id, notesCreated, notesModified };
+    return { runId: turnId, notesCreated, notesModified };
 }
 
 /**
diff --git a/apps/x/packages/core/src/knowledge/inline_tasks.ts b/apps/x/packages/core/src/knowledge/inline_tasks.ts
index cd2f23c0..f24972ed 100644
--- a/apps/x/packages/core/src/knowledge/inline_tasks.ts
+++ b/apps/x/packages/core/src/knowledge/inline_tasks.ts
@@ -3,13 +3,12 @@ import path from 'path';
 import { CronExpressionParser } from 'cron-parser';
 import { generateText } from 'ai';
 import { WorkDir } from '../config/config.js';
-import { createRun, createMessage, fetchRun } from '../runs/runs.js';
+import { runHeadlessAgent } from '../agents/headless-app.js';
 import { getKgModel } from '../models/defaults.js';
 import container from '../di/container.js';
 import type { IModelConfigRepo } from '../models/repo.js';
 import { createProvider } from '../models/models.js';
 import { inlineTask } from '@x/shared';
-import { extractAgentResponse, waitForRunCompletion } from '../agents/utils.js';
 import { captureLlmUsage } from '../analytics/usage.js';
 import { withUseCase } from '../analytics/use_case.js';
 
@@ -470,13 +469,6 @@ async function processInlineTasks(): Promise<void> {
             console.log(`[InlineTasks] Running task: "${task.instruction.slice(0, 80)}..."`);
 
             try {
-                const run = await createRun({
-                    agentId: INLINE_TASK_AGENT,
-                    model: await getKgModel(),
-                    useCase: 'knowledge_sync',
-                    subUseCase: 'inline_task_run',
-                });
-
                 const message = [
                     `Execute the following instruction from the note "${relativePath}":`,
                     '',
@@ -488,10 +480,11 @@ async function processInlineTasks(): Promise<void> {
                     '```',
                 ].join('\n');
 
-                await createMessage(run.id, message);
-                await waitForRunCompletion(run.id);
-
-                const result = await extractAgentResponse(run.id);
+                const { summary: result } = await runHeadlessAgent({
+                    agentId: INLINE_TASK_AGENT,
+                    message,
+                    model: await getKgModel(),
+                });
                 if (result) {
                     if (task.targetId) {
                         // Recurring task with target region — replace content inside the region
@@ -555,13 +548,6 @@ export async function processRowboatInstruction(
     scheduleLabel: string | null;
     response: string | null;
 }> {
-    const run = await createRun({
-        agentId: INLINE_TASK_AGENT,
-        model: await getKgModel(),
-        useCase: 'knowledge_sync',
-        subUseCase: 'inline_task_run',
-    });
-
     const message = [
         `Process the following @rowboat instruction from the note "${notePath}":`,
         '',
@@ -573,10 +559,11 @@ export async function processRowboatInstruction(
         '```',
     ].join('\n');
 
-    await createMessage(run.id, message);
-    await waitForRunCompletion(run.id);
-
-    const rawResponse = await extractAgentResponse(run.id);
+    const { summary: rawResponse } = await runHeadlessAgent({
+        agentId: INLINE_TASK_AGENT,
+        message,
+        model: await getKgModel(),
+    });
     if (!rawResponse) {
         return { instruction, schedule: null, scheduleLabel: null, response: null };
     }
diff --git a/apps/x/packages/core/src/knowledge/knowledge_index.ts b/apps/x/packages/core/src/knowledge/knowledge_index.ts
index 2df46ca3..0d2ef435 100644
--- a/apps/x/packages/core/src/knowledge/knowledge_index.ts
+++ b/apps/x/packages/core/src/knowledge/knowledge_index.ts
@@ -73,8 +73,10 @@ export interface KnowledgeIndex {
  * Looks for patterns like **Field:** value or **Field:** [[Link]]
  */
 function extractField(content: string, fieldName: string): string | undefined {
-    // Match **Field:** value (handles [[links]] and plain text)
-    const pattern = new RegExp(`\\*\\*${fieldName}:\\*\\*\\s*(.+?)(?:\\n|$)`, 'i');
+    // Match **Field:** value (handles [[links]] and plain text). Only consume
+    // spaces/tabs after the label — NOT newlines — so an empty field returns
+    // undefined instead of bleeding the next line's value into it.
+    const pattern = new RegExp(`\\*\\*${fieldName}:\\*\\*[ \\t]*(.+?)(?:\\r?\\n|$)`, 'i');
     const match = content.match(pattern);
     if (match) {
         let value = match[1].trim();
@@ -275,6 +277,34 @@ export function buildKnowledgeIndex(): KnowledgeIndex {
     return index;
 }
 
+// ---------------------------------------------------------------------------
+// Cached access
+// ---------------------------------------------------------------------------
+// buildKnowledgeIndex() does a synchronous recursive scan + read of the whole
+// knowledge dir, so callers that run often (e.g. meeting prep) should use the
+// cached accessor and rely on invalidateKnowledgeIndex() being called whenever
+// a knowledge file changes (wired to the workspace watcher in the main process).
+
+let cachedIndex: KnowledgeIndex | null = null;
+
+/**
+ * Return the knowledge index, building it once and reusing it until invalidated.
+ */
+export function getKnowledgeIndex(): KnowledgeIndex {
+    if (!cachedIndex) {
+        cachedIndex = buildKnowledgeIndex();
+    }
+    return cachedIndex;
+}
+
+/**
+ * Drop the cached index so the next getKnowledgeIndex() rebuilds it. Call this
+ * whenever a file under knowledge/ is created, changed, moved, or deleted.
+ */
+export function invalidateKnowledgeIndex(): void {
+    cachedIndex = null;
+}
+
 /**
  * Format the index as a string for inclusion in agent prompts
  */
diff --git a/apps/x/packages/core/src/knowledge/label_emails.ts b/apps/x/packages/core/src/knowledge/label_emails.ts
index ebb940c6..db462d93 100644
--- a/apps/x/packages/core/src/knowledge/label_emails.ts
+++ b/apps/x/packages/core/src/knowledge/label_emails.ts
@@ -1,10 +1,9 @@
 import fs from 'fs';
 import path from 'path';
 import { WorkDir } from '../config/config.js';
-import { createRun, createMessage } from '../runs/runs.js';
+import { runHeadlessAgent, toolInputPaths } from '../agents/headless-app.js';
 import { getKgModel } from '../models/defaults.js';
-import { bus } from '../runs/bus.js';
-import { getErrorDetails, waitForRunCompletion } from '../agents/utils.js';
+import { getErrorDetails } from '../agents/utils.js';
 import { serviceLogger } from '../services/service_logger.js';
 import { limitEventItems } from './limit_event_items.js';
 import {
@@ -70,13 +69,6 @@ function getUnlabeledEmails(state: LabelingState): string[] {
 async function labelEmailBatch(
     files: { path: string; content: string }[]
 ): Promise<{ runId: string; filesEdited: Set<string> }> {
-    const run = await createRun({
-        agentId: LABELING_AGENT,
-        model: await getKgModel(),
-        useCase: 'knowledge_sync',
-        subUseCase: 'label_emails',
-    });
-
     let message = `Label the following ${files.length} email files by prepending YAML frontmatter.\n\n`;
     message += `**Important:** Use workspace-relative paths with file-editText (e.g. "gmail_sync/email.md", NOT absolute paths).\n\n`;
 
@@ -92,33 +84,16 @@ async function labelEmailBatch(
         message += `\n\n---\n\n`;
     }
 
-    const filesEdited = new Set<string>();
-
-    const unsubscribe = await bus.subscribe(run.id, async (event) => {
-        if (event.type !== 'tool-invocation') {
-            return;
-        }
-        if (event.toolName !== 'file-editText') {
-            return;
-        }
-        try {
-            const parsed = JSON.parse(event.input) as { path?: string };
-            if (typeof parsed.path === 'string') {
-                filesEdited.add(parsed.path);
-            }
-        } catch {
-            // ignore parse errors
-        }
+    const { turnId, state } = await runHeadlessAgent({
+        agentId: LABELING_AGENT,
+        message,
+        model: await getKgModel(),
+        throwOnError: true,
     });
 
-    await createMessage(run.id, message);
-    try {
-        await waitForRunCompletion(run.id, { throwOnError: true });
-    } finally {
-        unsubscribe();
-    }
-
-    return { runId: run.id, filesEdited };
+    // Edited paths come from the durable turn state instead of streaming
+    // bus subscriptions.
+    return { runId: turnId, filesEdited: toolInputPaths(state, ['file-editText']) };
 }
 
 /**
diff --git a/apps/x/packages/core/src/knowledge/live-note/runner.ts b/apps/x/packages/core/src/knowledge/live-note/runner.ts
index b263c3e5..61b2b0b0 100644
--- a/apps/x/packages/core/src/knowledge/live-note/runner.ts
+++ b/apps/x/packages/core/src/knowledge/live-note/runner.ts
@@ -1,8 +1,8 @@
 import type { LiveNote, LiveNoteTriggerType } from '@x/shared/dist/live-note.js';
 import { fetchLiveNote, patchLiveNote, readNoteBody } from './fileops.js';
-import { createRun, createMessage } from '../../runs/runs.js';
 import { getLiveNoteAgentModel } from '../../models/defaults.js';
-import { extractAgentResponse, waitForRunCompletion } from '../../agents/utils.js';
+import { startHeadlessAgent } from '../../agents/headless-app.js';
+import { withUseCase } from '../../analytics/use_case.js';
 import { buildTriggerBlock } from '../../agents/build-trigger-block.js';
 import { liveNoteBus } from './bus.js';
 import { PrefixLogger } from '@x/shared/dist/prefix-logger.js';
@@ -109,17 +109,20 @@ export async function runLiveNoteAgent(
         const bodyBefore = await readNoteBody(filePath);
 
         const model = live.model ?? await getLiveNoteAgentModel();
-        const agentRun = await createRun({
-            agentId: 'live-note-agent',
-            model,
-            ...(live.provider ? { provider: live.provider } : {}),
-            useCase: 'live_note_agent',
-            // Use the granular trigger as the analytics sub-use-case so
-            // dashboards can break down agent runs by what woke them up
-            // (manual / cron / window / event). Pass 1 routing emits the
-            // separate `routing` sub-use-case from routing.ts.
-            subUseCase: trigger,
-        });
+        // The use-case context propagates to every tool the agent calls; the
+        // granular trigger doubles as the sub-use-case (manual / cron /
+        // window / event) so dashboards can break down what woke the agent.
+        const handle = await withUseCase(
+            { useCase: 'live_note_agent', subUseCase: trigger },
+            () => startHeadlessAgent({
+                agentId: 'live-note-agent',
+                message: buildMessage(filePath, live, trigger, context),
+                model,
+                ...(live.provider ? { provider: live.provider } : {}),
+                throwOnError: true,
+            }),
+        );
+        const agentRun = { id: handle.turnId };
 
         log.log(`${filePath} — start trigger=${trigger} runId=${agentRun.id}`);
 
@@ -141,14 +144,11 @@ export async function runLiveNoteAgent(
         });
 
         try {
-            await createMessage(agentRun.id, buildMessage(filePath, live, trigger, context));
-            // throwOnError: surface any error event in the run's log (LLM API
-            // failures, tool errors, billing/credit issues) as a rejection so
-            // the failure branch records lastRunError. Without this the run
-            // can "complete" with errors silently and we'd hit the success
-            // branch with an empty summary, clobbering any prior lastRunError.
-            await waitForRunCompletion(agentRun.id, { throwOnError: true });
-            const summary = await extractAgentResponse(agentRun.id);
+            // throwOnError: a failed/cancelled turn rejects here so the
+            // failure branch records lastRunError. Without this the turn
+            // could settle silently and we'd hit the success branch with an
+            // empty summary, clobbering any prior lastRunError.
+            const { summary } = await handle.done;
 
             const bodyAfter = await readNoteBody(filePath);
             const didUpdate = bodyAfter !== bodyBefore;
diff --git a/apps/x/packages/core/src/knowledge/meeting_prep.ts b/apps/x/packages/core/src/knowledge/meeting_prep.ts
new file mode 100644
index 00000000..34e0afb6
--- /dev/null
+++ b/apps/x/packages/core/src/knowledge/meeting_prep.ts
@@ -0,0 +1,230 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { WorkDir } from '../config/config.js';
+import { getKnowledgeIndex } from './knowledge_index.js';
+
+const KNOWLEDGE_DIR = path.join(WorkDir, 'knowledge');
+
+/**
+ * A calendar attendee as it arrives from the renderer (sourced from the
+ * Google Calendar event's `attendees[]`).
+ */
+export interface MeetingPrepAttendee {
+    email?: string;
+    displayName?: string;
+    self?: boolean;
+}
+
+/**
+ * The note we resolved for a matched attendee. `markdown` is the full note
+ * body so the renderer can render it as-is — no LLM, no summarisation.
+ */
+export interface MeetingPrepNote {
+    /** Workspace-relative path, e.g. "knowledge/People/Sarah Chen.md". */
+    path: string;
+    name: string;
+    role?: string;
+    organization?: string;
+    markdown: string;
+}
+
+/**
+ * One attendee after resolution. `note` is set when we found a person note,
+ * `null` otherwise (the "no note yet" case the UI offers to create).
+ */
+export interface MeetingPrepResolved {
+    /** Best display label — the note name, else displayName, else email. */
+    label: string;
+    email?: string;
+    displayName?: string;
+    note: MeetingPrepNote | null;
+}
+
+/** An organization note relevant to the meeting (resolved from attendee domains). */
+export interface MeetingPrepOrg {
+    path: string;
+    name: string;
+    markdown: string;
+}
+
+export interface MeetingPrepResult {
+    /** Resolved attendees, matched ones first (notes-first ordering). */
+    attendees: MeetingPrepResolved[];
+    /** Distinct external organizations in the meeting that have a note. */
+    organizations: MeetingPrepOrg[];
+    /** How many have a note vs. not — convenience for the UI header. */
+    matchedCount: number;
+    unmatchedCount: number;
+}
+
+function norm(value: string | undefined): string {
+    return (value ?? '').trim().toLowerCase();
+}
+
+/** Normalize a display name for matching: drop parenthetical suffixes like
+ *  "(via Google Calendar)" / "(Guest)" that calendars sometimes append. */
+function normName(value: string | undefined): string {
+    return norm((value ?? '').replace(/\s*\([^)]*\)\s*$/g, ''));
+}
+
+/** Lowercased domain part of an email, or '' if there isn't one. */
+function domainOf(email: string | undefined): string {
+    const e = norm(email);
+    const at = e.lastIndexOf('@');
+    return at >= 0 ? e.slice(at + 1) : '';
+}
+
+/** Tidy a field value for display: strip a leading knowledge folder segment so
+ *  a link target like "Organizations/Rowboat Labs" reads as "Rowboat Labs". */
+function displayRef(value: string | undefined): string | undefined {
+    if (!value) return undefined;
+    const m = value.match(/^(?:People|Organizations|Projects|Topics)\/(.+)$/i);
+    return (m ? m[1] : value).trim() || undefined;
+}
+
+/**
+ * Resolve a meeting's attendees against the knowledge base, returning each
+ * attendee's existing person note (or null). Deterministic: email-exact match
+ * first, then an unambiguous name/alias match on the display name.
+ */
+export async function resolveMeetingPrep(
+    attendees: MeetingPrepAttendee[],
+): Promise<MeetingPrepResult> {
+    const index = getKnowledgeIndex();
+
+    // email -> person (first wins; emails are effectively unique).
+    const byEmail = new Map<string, (typeof index.people)[number]>();
+    // normalized name/alias -> people that carry it (for ambiguity checks).
+    const byName = new Map<string, (typeof index.people)[number][]>();
+
+    for (const person of index.people) {
+        const email = norm(person.email);
+        if (email && !byEmail.has(email)) byEmail.set(email, person);
+
+        for (const key of [person.name, ...person.aliases]) {
+            const nk = normName(key);
+            if (!nk) continue;
+            const list = byName.get(nk) ?? [];
+            list.push(person);
+            byName.set(nk, list);
+        }
+    }
+
+    // domain -> organization, and name/alias -> organization, for resolving the
+    // companies in the meeting from attendee email domains.
+    const orgByDomain = new Map<string, (typeof index.organizations)[number]>();
+    const orgByName = new Map<string, (typeof index.organizations)[number]>();
+    for (const org of index.organizations) {
+        const d = norm(org.domain);
+        if (d && !orgByDomain.has(d)) orgByDomain.set(d, org);
+        for (const key of [org.name, ...org.aliases]) {
+            const nk = norm(key);
+            if (nk && !orgByName.has(nk)) orgByName.set(nk, org);
+        }
+    }
+
+    // The user's own domain (from the self attendee) is "internal" — we never
+    // surface the user's own company as meeting context.
+    const selfDomain = domainOf(attendees.find((a) => a.self)?.email);
+
+    // Cache note reads so a person listed under multiple keys is read once.
+    const noteCache = new Map<string, MeetingPrepNote | null>();
+    const readNote = async (person: (typeof index.people)[number]): Promise<MeetingPrepNote | null> => {
+        if (noteCache.has(person.file)) return noteCache.get(person.file)!;
+        let note: MeetingPrepNote | null = null;
+        try {
+            const markdown = await fs.readFile(path.join(KNOWLEDGE_DIR, person.file), 'utf-8');
+            note = {
+                path: path.posix.join('knowledge', person.file.split(path.sep).join('/')),
+                name: person.name,
+                role: displayRef(person.role),
+                organization: displayRef(person.organization),
+                markdown,
+            };
+        } catch {
+            // Indexed file vanished between index build and read — treat as no note.
+            note = null;
+        }
+        noteCache.set(person.file, note);
+        return note;
+    };
+
+    const resolved: MeetingPrepResolved[] = [];
+    const seenFiles = new Set<string>();
+    // Distinct external orgs to surface, keyed by note file.
+    const orgEntries = new Map<string, (typeof index.organizations)[number]>();
+
+    for (const attendee of attendees) {
+        if (attendee.self) continue;
+
+        const email = norm(attendee.email);
+        const displayName = normName(attendee.displayName);
+        const domain = domainOf(attendee.email);
+
+        let person = email ? byEmail.get(email) : undefined;
+        if (!person && displayName) {
+            const candidates = byName.get(displayName);
+            // Only a single, unambiguous hit counts — never guess between two
+            // people who happen to share a name.
+            if (candidates && candidates.length === 1) person = candidates[0];
+        }
+
+        // Resolve the attendee's company — but only for external domains, so an
+        // internal standup doesn't surface the user's own org note. Prefer a
+        // domain match; fall back to the matched person's Organization field.
+        if (domain && domain !== selfDomain) {
+            const org =
+                orgByDomain.get(domain) ??
+                (person?.organization ? orgByName.get(norm(person.organization)) : undefined);
+            if (org) orgEntries.set(org.file, org);
+        }
+
+        const label =
+            person?.name ||
+            attendee.displayName?.trim() ||
+            attendee.email?.trim() ||
+            'Unknown';
+
+        const note = person ? await readNote(person) : null;
+        // Dedupe: the same person can appear once even if the calendar lists
+        // them twice (e.g. organizer + attendee).
+        if (note && seenFiles.has(note.path)) continue;
+        if (note) seenFiles.add(note.path);
+
+        resolved.push({
+            label,
+            email: attendee.email?.trim() || undefined,
+            displayName: attendee.displayName?.trim() || undefined,
+            note,
+        });
+    }
+
+    // Notes-first ordering; stable within each group.
+    resolved.sort((a, b) => {
+        if (Boolean(a.note) === Boolean(b.note)) return 0;
+        return a.note ? -1 : 1;
+    });
+
+    // Read the resolved org notes (skip any whose file vanished).
+    const organizations: MeetingPrepOrg[] = [];
+    for (const org of orgEntries.values()) {
+        try {
+            const markdown = await fs.readFile(path.join(KNOWLEDGE_DIR, org.file), 'utf-8');
+            organizations.push({
+                path: path.posix.join('knowledge', org.file.split(path.sep).join('/')),
+                name: org.name,
+                markdown,
+            });
+        } catch {
+            // Indexed file vanished between index build and read — skip it.
+        }
+    }
+
+    const matchedCount = resolved.filter((a) => a.note).length;
+    return {
+        attendees: resolved,
+        organizations,
+        matchedCount,
+        unmatchedCount: resolved.length - matchedCount,
+    };
+}
diff --git a/apps/x/packages/core/src/knowledge/meeting_prep_brief.ts b/apps/x/packages/core/src/knowledge/meeting_prep_brief.ts
new file mode 100644
index 00000000..45cb26e0
--- /dev/null
+++ b/apps/x/packages/core/src/knowledge/meeting_prep_brief.ts
@@ -0,0 +1,307 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { generateText } from 'ai';
+import { WorkDir } from '../config/config.js';
+import { createProvider } from '../models/models.js';
+import { getDefaultModelAndProvider, getMeetingNotesModel, resolveProviderConfig } from '../models/defaults.js';
+import { captureLlmUsage } from '../analytics/usage.js';
+import { withUseCase } from '../analytics/use_case.js';
+import { parseFrontmatter } from '../application/lib/parse-frontmatter.js';
+import { resolveMeetingPrep, type MeetingPrepResult } from './meeting_prep.js';
+
+const MEETINGS_DIR = path.join(WorkDir, 'knowledge', 'Meetings');
+const PREP_DIR = path.join(MEETINGS_DIR, 'prep');
+
+/** The bits of a Google Calendar event we use for prep. */
+interface CalendarEvent {
+    id?: string;
+    summary?: string;
+    description?: string;
+    status?: string;
+    recurringEventId?: string;
+    start?: { dateTime?: string; date?: string };
+    attendees?: Array<{ email?: string; displayName?: string; self?: boolean; responseStatus?: string }>;
+}
+
+export interface PrepNoteResult {
+    /** Workspace-relative path of the written note. */
+    path: string;
+}
+
+function norm(s: string | undefined): string {
+    return (s ?? '').trim().toLowerCase();
+}
+
+function slugify(s: string): string {
+    return (s || 'meeting')
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, '-')
+        .replace(/^-+|-+$/g, '')
+        .slice(0, 60) || 'meeting';
+}
+
+/** Local YYYY-MM-DD for the event's start. */
+function eventDateKey(event: CalendarEvent): string {
+    const iso = event.start?.dateTime ?? event.start?.date ?? '';
+    const d = iso ? new Date(iso) : null;
+    if (!d || Number.isNaN(d.getTime())) return 'undated';
+    const y = d.getFullYear();
+    const m = String(d.getMonth() + 1).padStart(2, '0');
+    const day = String(d.getDate()).padStart(2, '0');
+    return `${y}-${m}-${day}`;
+}
+
+/** Pull a "## Heading" section's body (until the next "## " or end). */
+function extractSection(markdown: string, heading: string): string {
+    const headRe = new RegExp(`^##\\s+${heading}\\s*$`, 'i');
+    const out: string[] = [];
+    let capturing = false;
+    for (const line of markdown.split('\n')) {
+        if (capturing) {
+            if (/^##\s/.test(line)) break;
+            out.push(line);
+        } else if (headRe.test(line)) {
+            capturing = true;
+        }
+    }
+    return out.join('\n').trim();
+}
+
+interface PriorNote {
+    file: string; // workspace-relative
+    title: string;
+    date: string;
+    actionItems: string;
+    body: string;
+}
+
+/**
+ * Find the most recent prior meeting note for this series. We match by title
+ * resemblance to the event summary (notes don't yet store an event id), and
+ * only consider notes dated before the meeting.
+ */
+async function findLastMeetingNote(event: CalendarEvent): Promise<PriorNote | null> {
+    const summaryNorm = norm(event.summary);
+    if (!summaryNorm) return null;
+    const meetingDate = eventDateKey(event);
+
+    let entries: string[] = [];
+    try {
+        entries = (await fs.readdir(MEETINGS_DIR, { recursive: true }))
+            .filter((p) => p.endsWith('.md'));
+    } catch {
+        return null;
+    }
+
+    const candidates: PriorNote[] = [];
+    for (const rel of entries) {
+        // Skip our own generated prep notes.
+        if (rel.startsWith('prep/') || rel.startsWith(`prep${path.sep}`)) continue;
+        let raw: string;
+        try {
+            raw = await fs.readFile(path.join(MEETINGS_DIR, rel), 'utf-8');
+        } catch {
+            continue;
+        }
+        const { frontmatter, content } = parseFrontmatter(raw);
+        const fm = (frontmatter ?? {}) as Record<string, unknown>;
+        const title = String(fm.title ?? (content.match(/^#\s+(.+)$/m)?.[1] ?? '')).trim();
+        const date = String(fm.date ?? '').trim();
+        const titleNorm = norm(title);
+        // Series match: the event summary appears in the note title (e.g.
+        // "standup" within "Eng Standup — 2026-06-18").
+        if (!titleNorm || !titleNorm.includes(summaryNorm)) continue;
+        // Only prior instances.
+        if (date && meetingDate !== 'undated' && date >= meetingDate) continue;
+        candidates.push({
+            file: path.posix.join('knowledge', 'Meetings', rel.split(path.sep).join('/')),
+            title,
+            date,
+            actionItems: extractSection(content, 'Action items'),
+            body: content,
+        });
+    }
+
+    if (candidates.length === 0) return null;
+    // Most recent by date (notes without a date sort last).
+    candidates.sort((a, b) => (b.date || '').localeCompare(a.date || ''));
+    return candidates[0];
+}
+
+/** True when this looks like a recurring meeting we have history for. */
+function isRecurring(event: CalendarEvent, prior: PriorNote | null): boolean {
+    return Boolean(event.recurringEventId) && prior !== null;
+}
+
+/** Assemble the deterministic prep context for an event. */
+async function assembleContext(event: CalendarEvent): Promise<{
+    roster: MeetingPrepResult;
+    prior: PriorNote | null;
+    recurring: boolean;
+    agenda: string;
+}> {
+    const attendees = (event.attendees ?? []).map((a) => ({
+        email: a.email,
+        displayName: a.displayName,
+        self: a.self,
+    }));
+    const roster = await resolveMeetingPrep(attendees);
+    const prior = await findLastMeetingNote(event);
+    return {
+        roster,
+        prior,
+        recurring: isRecurring(event, prior),
+        agenda: (event.description ?? '').trim(),
+    };
+}
+
+const BRIEF_SYSTEM = `You write a short, concrete "what matters for this meeting" brief.
+Rules:
+- Use ONLY the context provided. Never invent facts, names, or commitments.
+- 3-5 bullet points, one line each. No preamble, no headings, no sign-off.
+- Lead with what the user should focus on or decide. Reference open items and
+  prior commitments by name where the context supplies them.
+- If the context is thin, say so in one line rather than padding.`;
+
+/** Generate the "what matters" brief via the user's configured model. */
+async function generateBrief(event: CalendarEvent, ctx: Awaited<ReturnType<typeof assembleContext>>): Promise<string> {
+    const parts: string[] = [`Meeting: ${event.summary || '(untitled)'}`];
+    if (ctx.agenda) parts.push(`Agenda:\n${ctx.agenda}`);
+    if (ctx.prior?.actionItems) parts.push(`Action items from last time (${ctx.prior.date || 'prior'}):\n${ctx.prior.actionItems}`);
+    const attendeeLines = ctx.roster.attendees.map((a) => {
+        if (!a.note) return `- ${a.label} (no note)`;
+        const sub = [a.note.role, a.note.organization].filter(Boolean).join(', ');
+        return `- ${a.note.name}${sub ? ` — ${sub}` : ''}`;
+    });
+    if (attendeeLines.length) parts.push(`Attendees:\n${attendeeLines.join('\n')}`);
+
+    const modelId = await getMeetingNotesModel();
+    const { provider: providerName } = await getDefaultModelAndProvider();
+    const providerConfig = await resolveProviderConfig(providerName);
+    const model = createProvider(providerConfig).languageModel(modelId);
+
+    const result = await withUseCase({ useCase: 'meeting_prep' }, () => generateText({
+        model,
+        system: BRIEF_SYSTEM,
+        prompt: parts.join('\n\n'),
+    }));
+    captureLlmUsage({ useCase: 'meeting_prep', model: modelId, provider: providerName, usage: result.usage });
+    return result.text.trim();
+}
+
+/** Render the prep note's markdown body (brief is optional). */
+function renderPrepNote(event: CalendarEvent, ctx: Awaited<ReturnType<typeof assembleContext>>, brief: string, generatedAt: string): string {
+    const fm = [
+        '---',
+        'source: meeting-prep',
+        `title: "Prep: ${(event.summary || 'Meeting').replace(/"/g, "'")}"`,
+        `meetingDate: "${eventDateKey(event)}"`,
+        event.id ? `eventId: "${event.id}"` : null,
+        event.recurringEventId ? `recurringEventId: "${event.recurringEventId}"` : null,
+        `generatedAt: "${generatedAt}"`,
+        '---',
+        '',
+    ].filter((l) => l !== null).join('\n');
+
+    const lines: string[] = [`# Prep: ${event.summary || 'Meeting'}`, ''];
+
+    if (brief) {
+        lines.push('## What matters', '', brief, '');
+    }
+
+    // Adaptive ordering: recurring → recap first; new → agenda first.
+    const recapBlock = ctx.prior
+        ? ['## Last time', '', ctx.prior.actionItems
+            ? ctx.prior.actionItems
+            : `See [[${ctx.prior.title}]].`, '']
+        : [];
+    const agendaBlock = ctx.agenda ? ['## Agenda', '', ctx.agenda, ''] : [];
+    if (ctx.recurring) {
+        lines.push(...recapBlock, ...agendaBlock);
+    } else {
+        lines.push(...agendaBlock, ...recapBlock);
+    }
+
+    // Roster — every attendee, linking to their note when we have one.
+    lines.push('## Who’s coming', '');
+    for (const a of ctx.roster.attendees) {
+        if (a.note) {
+            const sub = [a.note.role, a.note.organization].filter(Boolean).join(', ');
+            lines.push(`- [[${a.note.name}]]${sub ? ` — ${sub}` : ''}`);
+        } else {
+            lines.push(`- ${a.label} _(no note yet)_`);
+        }
+    }
+    lines.push('');
+
+    if (ctx.roster.organizations.length > 0) {
+        lines.push('## Companies', '');
+        for (const org of ctx.roster.organizations) lines.push(`- [[${org.name}]]`);
+        lines.push('');
+    }
+
+    return fm + lines.join('\n').trimEnd() + '\n';
+}
+
+/**
+ * Generate and write the prep note for a calendar event. Returns the note path,
+ * or null when there's nothing to prep (no other attendees). The AI brief is
+ * best-effort — if no model is configured the note is still written with the
+ * deterministic sections.
+ */
+export async function generateAndWritePrep(eventJson: string): Promise<PrepNoteResult | null> {
+    const event = JSON.parse(eventJson) as CalendarEvent;
+    if (event.status === 'cancelled') return null;
+    if (!(event.attendees ?? []).some((a) => !a.self)) return null; // nobody else
+
+    const ctx = await assembleContext(event);
+    if (ctx.roster.attendees.length === 0) return null;
+
+    let brief = '';
+    try {
+        brief = await generateBrief(event, ctx);
+    } catch (err) {
+        console.error('[MeetingPrep] brief generation failed:', err);
+    }
+
+    const generatedAt = new Date().toISOString();
+    const body = renderPrepNote(event, ctx, brief, generatedAt);
+
+    await fs.mkdir(PREP_DIR, { recursive: true });
+    const fileName = `${slugify(event.summary || 'meeting')}-${eventDateKey(event)}.md`;
+    const absPath = path.join(PREP_DIR, fileName);
+    await fs.writeFile(absPath, body, 'utf-8');
+
+    return { path: path.posix.join('knowledge', 'Meetings', 'prep', fileName) };
+}
+
+/**
+ * Find the pre-generated prep note for a calendar event (matched by the
+ * `eventId` stamped in frontmatter) and return its path + "What matters" brief.
+ * Returns null when no prep has been generated yet.
+ */
+export async function readPrepNoteForEvent(eventId: string): Promise<{ path: string; brief: string } | null> {
+    if (!eventId) return null;
+    let files: string[];
+    try {
+        files = (await fs.readdir(PREP_DIR)).filter((f) => f.endsWith('.md'));
+    } catch {
+        return null;
+    }
+    for (const f of files) {
+        let raw: string;
+        try {
+            raw = await fs.readFile(path.join(PREP_DIR, f), 'utf-8');
+        } catch {
+            continue;
+        }
+        const { frontmatter, content } = parseFrontmatter(raw);
+        const fm = (frontmatter ?? {}) as Record<string, unknown>;
+        if (String(fm.eventId ?? '') !== eventId) continue;
+        return {
+            path: path.posix.join('knowledge', 'Meetings', 'prep', f),
+            brief: extractSection(content, 'What matters'),
+        };
+    }
+    return null;
+}
diff --git a/apps/x/packages/core/src/knowledge/meeting_prep_scheduler.ts b/apps/x/packages/core/src/knowledge/meeting_prep_scheduler.ts
new file mode 100644
index 00000000..b9b31ba3
--- /dev/null
+++ b/apps/x/packages/core/src/knowledge/meeting_prep_scheduler.ts
@@ -0,0 +1,158 @@
+import path from "node:path";
+import fs from "node:fs/promises";
+import type { Dirent } from "node:fs";
+import { WorkDir } from "../config/config.js";
+import { generateAndWritePrep } from "./meeting_prep_brief.js";
+
+// Generate prep up to 6h before a meeting. We tick every 5 minutes and scan the
+// synced calendar — a calendar-aware loop fits "N hours before each meeting"
+// better than a fixed cron, and re-reading the calendar each tick means moves
+// and cancellations are picked up automatically.
+const TICK_INTERVAL_MS = 15 * 60_000;
+const PREP_LEAD_MS = 6 * 60 * 60_000;
+// Drop state entries older than 24h so the file doesn't grow forever.
+const STATE_TTL_MS = 24 * 60 * 60 * 1000;
+
+const CALENDAR_SYNC_DIR = path.join(WorkDir, "calendar_sync");
+const STATE_FILE = path.join(WorkDir, "meeting_prep_state.json");
+
+interface PrepState {
+    preppedEventIds: Record<string, { preppedAt: string; startTime: string }>;
+}
+
+interface CalendarEvent {
+    id?: string;
+    summary?: string;
+    status?: string;
+    start?: { dateTime?: string; date?: string };
+    attendees?: Array<{ self?: boolean; responseStatus?: string }>;
+}
+
+async function loadState(): Promise<PrepState> {
+    try {
+        const raw = await fs.readFile(STATE_FILE, "utf-8");
+        const parsed = JSON.parse(raw);
+        if (parsed && typeof parsed === "object" && parsed.preppedEventIds) {
+            return parsed as PrepState;
+        }
+    } catch {
+        // No state file yet, or corrupt — start fresh.
+    }
+    return { preppedEventIds: {} };
+}
+
+async function saveState(state: PrepState): Promise<void> {
+    // Write to a sibling tmp file then rename so a mid-write crash can't leave
+    // the JSON corrupt.
+    const tmp = `${STATE_FILE}.tmp`;
+    await fs.writeFile(tmp, JSON.stringify(state, null, 2), "utf-8");
+    await fs.rename(tmp, STATE_FILE);
+}
+
+function gcState(state: PrepState): PrepState {
+    const cutoff = Date.now() - STATE_TTL_MS;
+    const fresh: PrepState["preppedEventIds"] = {};
+    for (const [id, entry] of Object.entries(state.preppedEventIds)) {
+        const ts = Date.parse(entry.preppedAt);
+        if (Number.isFinite(ts) && ts >= cutoff) fresh[id] = entry;
+    }
+    return { preppedEventIds: fresh };
+}
+
+function isAllDay(event: CalendarEvent): boolean {
+    return !event.start?.dateTime;
+}
+
+function isDeclinedBySelf(event: CalendarEvent): boolean {
+    return event.attendees?.find((a) => a.self)?.responseStatus === "declined";
+}
+
+async function tick(state: PrepState): Promise<{ state: PrepState; dirty: boolean }> {
+    let entries: Dirent[];
+    try {
+        entries = await fs.readdir(CALENDAR_SYNC_DIR, { withFileTypes: true });
+    } catch {
+        return { state, dirty: false };
+    }
+
+    const now = Date.now();
+    let dirty = false;
+
+    for (const entry of entries) {
+        if (!entry.isFile() || !entry.name.endsWith(".json")) continue;
+        if (entry.name.startsWith("sync_state")) continue;
+
+        const eventId = entry.name.replace(/\.json$/, "");
+        if (state.preppedEventIds[eventId]) continue;
+
+        let raw: string;
+        try {
+            raw = await fs.readFile(path.join(CALENDAR_SYNC_DIR, entry.name), "utf-8");
+        } catch {
+            continue;
+        }
+        let event: CalendarEvent;
+        try {
+            event = JSON.parse(raw);
+        } catch {
+            continue;
+        }
+
+        if (event.status === "cancelled") continue;
+        if (isAllDay(event)) continue;
+        if (isDeclinedBySelf(event)) continue;
+        if (!(event.attendees ?? []).some((a) => !a.self)) continue; // nobody else
+
+        const startStr = event.start?.dateTime;
+        if (!startStr) continue;
+        const startMs = Date.parse(startStr);
+        if (!Number.isFinite(startMs)) continue;
+
+        const msUntilStart = startMs - now;
+        if (msUntilStart > PREP_LEAD_MS) continue; // too far out
+        if (msUntilStart <= 0) continue; // already started — too late to pre-generate
+
+        try {
+            const result = await generateAndWritePrep(raw);
+            if (result) {
+                console.log(`[MeetingPrep] generated prep for "${event.summary ?? eventId}" → ${result.path}`);
+            }
+        } catch (err) {
+            console.error(`[MeetingPrep] prep generation failed for ${eventId}:`, err);
+            continue; // leave unmarked so we retry next tick
+        }
+
+        state.preppedEventIds[eventId] = {
+            preppedAt: new Date().toISOString(),
+            startTime: startStr,
+        };
+        dirty = true;
+    }
+
+    return { state, dirty };
+}
+
+export async function init(): Promise<void> {
+    console.log("[MeetingPrep] starting meeting prep scheduler");
+    console.log(`[MeetingPrep] tick every ${TICK_INTERVAL_MS / 60_000}m, lead ${PREP_LEAD_MS / 3_600_000}h`);
+
+    let state = gcState(await loadState());
+
+    while (true) {
+        try {
+            const result = await tick(state);
+            state = result.state;
+            if (result.dirty) {
+                state = gcState(state);
+                try {
+                    await saveState(state);
+                } catch (err) {
+                    console.error("[MeetingPrep] failed to save state:", err);
+                }
+            }
+        } catch (err) {
+            console.error("[MeetingPrep] tick failed:", err);
+        }
+        await new Promise((resolve) => setTimeout(resolve, TICK_INTERVAL_MS));
+    }
+}
diff --git a/apps/x/packages/core/src/knowledge/sync_gmail.ts b/apps/x/packages/core/src/knowledge/sync_gmail.ts
index e4d478e9..215429ce 100644
--- a/apps/x/packages/core/src/knowledge/sync_gmail.ts
+++ b/apps/x/packages/core/src/knowledge/sync_gmail.ts
@@ -4,6 +4,7 @@ import { google, gmail_v1 as gmail } from 'googleapis';
 import { NodeHtmlMarkdown } from 'node-html-markdown'
 import { OAuth2Client } from 'google-auth-library';
 import { WorkDir } from '../config/config.js';
+import { getMaxEmails } from '../config/gmail_sync_config.js';
 import { GoogleClientFactory } from './google-client-factory.js';
 import { serviceLogger, type ServiceRunContext } from '../services/service_logger.js';
 import { limitEventItems } from './limit_event_items.js';
@@ -15,6 +16,10 @@ import { notifyIfEnabled } from '../application/notification/notifier.js';
 const SYNC_DIR = path.join(WorkDir, 'gmail_sync');
 const LEGACY_CACHE_DIR = path.join(SYNC_DIR, 'cache');
 const CACHE_DIR = path.join(WorkDir, 'inbox_lists');
+// Local index of full-text search results. Kept separate from inbox_lists/ so it
+// never leaks non-inbox threads into the inbox view. Grows as you search; we
+// don't prune it (the user wants a durable local index).
+const SEARCH_CACHE_DIR = path.join(WorkDir, 'search_index');
 
 (function migrateLegacyCacheDir() {
     try {
@@ -95,6 +100,35 @@ function deleteCachedSnapshot(threadId: string): void {
     }
 }
 
+// Local search index — same on-disk shape as the inbox cache, separate dir.
+function searchCachePath(threadId: string): string {
+    return path.join(SEARCH_CACHE_DIR, `${encodeURIComponent(threadId)}.json`);
+}
+
+function readSearchSnapshot(threadId: string): SnapshotCacheEntry | null {
+    try {
+        const raw = fs.readFileSync(searchCachePath(threadId), 'utf-8');
+        return JSON.parse(raw) as SnapshotCacheEntry;
+    } catch {
+        return null;
+    }
+}
+
+function writeSearchSnapshot(threadId: string, historyId: string, snapshot: GmailThreadSnapshot): void {
+    try {
+        if (!fs.existsSync(SEARCH_CACHE_DIR)) fs.mkdirSync(SEARCH_CACHE_DIR, { recursive: true });
+        const entry: SnapshotCacheEntry = {
+            historyId,
+            fetchedAt: new Date().toISOString(),
+            parserVersion: SNAPSHOT_PARSER_VERSION,
+            snapshot,
+        };
+        fs.writeFileSync(searchCachePath(threadId), JSON.stringify(entry), 'utf-8');
+    } catch (err) {
+        console.warn(`[Gmail search index] write failed for ${threadId}:`, err);
+    }
+}
+
 async function getGmailClientOrThrow() {
     const auth = await GoogleClientFactory.getClient();
     if (!auth) throw new Error('Gmail is not connected.');
@@ -132,19 +166,19 @@ export async function trashThread(threadId: string): Promise<ThreadActionResult>
     }
 }
 
-export async function markThreadRead(threadId: string): Promise<ThreadActionResult> {
+export async function markThreadRead(threadId: string, read: boolean = true): Promise<ThreadActionResult> {
     try {
         const gmailClient = await getGmailClientOrThrow();
         await gmailClient.users.threads.modify({
             userId: 'me',
             id: threadId,
-            requestBody: { removeLabelIds: ['UNREAD'] },
+            requestBody: read ? { removeLabelIds: ['UNREAD'] } : { addLabelIds: ['UNREAD'] },
         });
-        // Update local cache: clear unread on all messages in the thread.
+        // Mirror the new read state onto every message in the cached thread.
         const cached = readCachedSnapshot(threadId);
         if (cached) {
-            for (const m of cached.snapshot.messages) m.unread = false;
-            cached.snapshot.unread = false;
+            for (const m of cached.snapshot.messages) m.unread = !read;
+            cached.snapshot.unread = !read;
             try {
                 fs.writeFileSync(cachePath(threadId), JSON.stringify(cached), 'utf-8');
             } catch (err) {
@@ -176,6 +210,8 @@ export interface GmailThreadSnapshot {
     importance?: 'important' | 'other';
     draft_response?: string;
     gmail_draft?: string;
+    /** Gmail-side draft id, present on entries from listDraftThreads. */
+    draftId?: string;
     messages: Array<{
         id?: string;
         from?: string;
@@ -192,8 +228,19 @@ export interface GmailThreadSnapshot {
             mimeType?: string;
             sizeBytes?: number;
             savedPath: string;
+            messageId?: string;
+            attachmentId?: string;
         }>;
         messageIdHeader?: string;
+        isDraft?: boolean;
+        /**
+         * The draft's own stored In-Reply-To / References headers. Only set
+         * on draft messages (see buildDraftSnapshot) — the composer reuses
+         * them on send since the Drafts pseudo-thread has no other messages
+         * to rebuild the reply chain from.
+         */
+        inReplyToHeader?: string;
+        referencesHeader?: string;
     }>;
 }
 
@@ -248,6 +295,7 @@ function notifyNewEmails(threads: SyncedThread[]): void {
     const now = Date.now();
     for (const { threadId } of threads) {
         const snapshot = readCachedSnapshot(threadId)?.snapshot;
+        if (snapshot?.importance !== 'important') continue;
         if (snapshot && isEmailTooOldToNotify(snapshotDateMs(snapshot), now)) continue;
         const subject = snapshot?.subject?.trim() || '(no subject)';
         const from = snapshot?.from?.trim();
@@ -346,6 +394,10 @@ interface ExtractedAttachment {
     mimeType?: string;
     sizeBytes?: number;
     savedPath: string;
+    // Gmail identifiers needed to fetch the attachment on demand (e.g. when a
+    // search result's attachment hasn't been downloaded to disk yet).
+    messageId?: string;
+    attachmentId?: string;
 }
 
 /**
@@ -382,6 +434,8 @@ function extractAttachments(msgId: string, payload: gmail.Schema$MessagePart, ht
                     mimeType: part.mimeType ?? undefined,
                     sizeBytes: typeof part.body?.size === 'number' ? part.body.size : undefined,
                     savedPath: `gmail_sync/attachments/${safeName}`,
+                    messageId: msgId,
+                    attachmentId: attId,
                 });
             }
         }
@@ -792,6 +846,45 @@ async function buildAndCacheSnapshot(
     ) {
         return cached.snapshot;
     }
+    const snapshot = await parseThreadSnapshot(threadId, threadData, gmailClient);
+    if (!snapshot) return null;
+
+    try {
+        const userEmail = await getUserEmail(auth);
+        const skipDraft = (snapshot.gmail_draft?.length ?? 0) > 0;
+        const classification = await classifyThread(snapshot, userEmail, { skipDraft });
+        snapshot.importance = classification.importance;
+        if (classification.summary) snapshot.summary = classification.summary;
+        if (classification.draftResponse) {
+            const draftResponse = stripGmailQuotedReplyText(classification.draftResponse);
+            if (draftResponse) snapshot.draft_response = draftResponse;
+        }
+    } catch (err) {
+        console.warn(`[Gmail] classify failed for ${threadId}:`, err);
+    }
+
+    if (threadData.historyId) {
+        writeCachedSnapshot(threadId, threadData.historyId, snapshot);
+    }
+
+    return snapshot;
+}
+
+/**
+ * Parse a threads.get response into a snapshot WITHOUT AI classification or
+ * caching — the shared core of buildAndCacheSnapshot, also used by search (which
+ * doesn't need importance/summary). Returns null when there are no visible
+ * (non-draft) messages.
+ */
+async function parseThreadSnapshot(
+    threadId: string,
+    threadData: gmail.Schema$Thread,
+    gmailClient: gmail.Gmail,
+): Promise<GmailThreadSnapshot | null> {
+    const messages = threadData.messages;
+    if (!messages || messages.length === 0) return null;
+
+    const cached = readCachedSnapshot(threadId);
     const heightCarryover = new Map<string, number>();
     if (cached) {
         for (const m of cached.snapshot.messages) {
@@ -855,7 +948,7 @@ async function buildAndCacheSnapshot(
         .filter(Boolean)
         .join('\n\n');
 
-    const snapshot: GmailThreadSnapshot = {
+    return {
         threadId,
         threadUrl: `https://mail.google.com/mail/u/0/#all/${threadId}`,
         subject: latest.subject || visibleMessages[0]?.subject,
@@ -868,26 +961,6 @@ async function buildAndCacheSnapshot(
         messages: visibleMessages,
         gmail_draft: latestDraftBody || undefined,
     };
-
-    try {
-        const userEmail = await getUserEmail(auth);
-        const skipDraft = latestDraftBody.length > 0;
-        const classification = await classifyThread(snapshot, userEmail, { skipDraft });
-        snapshot.importance = classification.importance;
-        if (classification.summary) snapshot.summary = classification.summary;
-        if (classification.draftResponse) {
-            const draftResponse = stripGmailQuotedReplyText(classification.draftResponse);
-            if (draftResponse) snapshot.draft_response = draftResponse;
-        }
-    } catch (err) {
-        console.warn(`[Gmail] classify failed for ${threadId}:`, err);
-    }
-
-    if (threadData.historyId) {
-        writeCachedSnapshot(threadId, threadData.historyId, snapshot);
-    }
-
-    return snapshot;
 }
 
 async function saveAttachment(gmail: gmail.Gmail, userId: string, msgId: string, part: gmail.Schema$MessagePart, attachmentsDir: string): Promise<string | null> {
@@ -919,6 +992,83 @@ async function saveAttachment(gmail: gmail.Gmail, userId: string, msgId: string,
     return null;
 }
 
+export interface DownloadAttachmentResult {
+    ok: boolean;
+    error?: string;
+}
+
+/**
+ * Ensure an attachment referenced by a snapshot exists on disk, downloading it
+ * on demand when it doesn't. Inbox attachments are saved during sync, but
+ * search results build snapshots without downloading, so opening one of their
+ * attachments needs this. `savedPath` is the workspace-relative path stored on
+ * the attachment; `attachmentId` (when supplied) is tried first, falling back
+ * to re-fetching the message and locating the part by filename — attachment ids
+ * can go stale on a cached snapshot, whereas the file name is stable.
+ */
+export async function downloadAttachment(args: {
+    messageId: string;
+    savedPath: string;
+    attachmentId?: string;
+}): Promise<DownloadAttachmentResult> {
+    try {
+        const { messageId, savedPath, attachmentId } = args;
+        if (!messageId || !savedPath) return { ok: false, error: 'Missing attachment reference.' };
+
+        const absPath = path.join(WorkDir, savedPath);
+        if (fs.existsSync(absPath)) return { ok: true };
+
+        const gmailClient = await getGmailClientOrThrow();
+        const dir = path.dirname(absPath);
+        if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+
+        const fetchData = async (attId: string): Promise<string | null> => {
+            const res = await gmailClient.users.messages.attachments.get({
+                userId: 'me',
+                messageId,
+                id: attId,
+            });
+            return res.data.data ?? null;
+        };
+
+        let data: string | null = null;
+        if (attachmentId) {
+            try {
+                data = await fetchData(attachmentId);
+            } catch (err) {
+                console.warn(`[Gmail] attachment fetch by id failed for ${messageId}, retrying by filename:`, err);
+            }
+        }
+
+        if (!data) {
+            // Re-fetch the message and locate the attachment part whose derived
+            // saved name matches the requested savedPath.
+            const wanted = path.basename(savedPath);
+            const msg = await gmailClient.users.messages.get({ userId: 'me', id: messageId, format: 'full' });
+            let foundAttId: string | undefined;
+            const walk = (part: gmail.Schema$MessagePart): void => {
+                if (foundAttId) return;
+                const fn = part.filename;
+                const attId = part.body?.attachmentId;
+                if (fn && attId && `${messageId}_${cleanFilename(fn)}` === wanted) {
+                    foundAttId = attId;
+                    return;
+                }
+                if (part.parts) for (const sub of part.parts) walk(sub);
+            };
+            if (msg.data.payload) walk(msg.data.payload);
+            if (!foundAttId) return { ok: false, error: 'Attachment not found in message.' };
+            data = await fetchData(foundAttId);
+        }
+
+        if (!data) return { ok: false, error: 'Attachment had no data.' };
+        fs.writeFileSync(absPath, Buffer.from(data, 'base64'));
+        return { ok: true };
+    } catch (err) {
+        return { ok: false, error: err instanceof Error ? err.message : String(err) };
+    }
+}
+
 // --- Sync Logic ---
 
 async function processThread(auth: OAuth2Client, threadId: string, syncDir: string, attachmentsDir: string): Promise<SyncedThread | null> {
@@ -1148,24 +1298,29 @@ async function backfillMissingRecentThreads(
 async function fullSync(auth: OAuth2Client, syncDir: string, attachmentsDir: string, stateFile: string, lookbackDays: number) {
     const gmail = google.gmail({ version: 'v1', auth });
 
-    // If the state file holds a last_sync timestamp (e.g. left over from a
-    // prior Composio sync, or from a previous successful native sync that
-    // we're falling back to after a history.list 404), use that as the
-    // floor — but never reach back further than lookbackDays. This caps the
-    // window at "1 week at most": if last_sync is within the lookback window
-    // we resume from it (a smaller window), otherwise we clamp to lookbackDays
-    // ago. Mail older than the cap that arrived during a long offline gap is
-    // intentionally skipped rather than backfilled.
+    // The onboarding / recovery fetch is bounded by a COUNT of the most recent
+    // threads (maxEmails, configurable — default 500), not by a fixed date
+    // window. So a fresh account pulls its newest `maxEmails` emails even when
+    // they span more than a week.
+    //
+    // When we can resume after a previous successful sync (a last_sync within
+    // the lookback window — e.g. the history.list 404 fallback, or a prior
+    // Composio sync), we still floor the query at last_sync so only genuinely
+    // new mail is re-walked, and the count cap acts purely as a safety bound.
+    // With no resumable last_sync (first connect, or a gap longer than the
+    // lookback window) we drop the date floor entirely and just take the newest
+    // `maxEmails` threads.
+    const maxEmails = getMaxEmails();
     const state = loadState(stateFile);
     const lookbackFloor = new Date();
     lookbackFloor.setDate(lookbackFloor.getDate() - lookbackDays);
-    let pastDate: Date;
-    if (state.last_sync && new Date(state.last_sync) > lookbackFloor) {
-        pastDate = new Date(state.last_sync);
-        console.log(`Performing full sync from last_sync=${state.last_sync}...`);
+    const resumeFrom = state.last_sync && new Date(state.last_sync) > lookbackFloor
+        ? new Date(state.last_sync)
+        : null;
+    if (resumeFrom) {
+        console.log(`Performing full sync from last_sync=${state.last_sync} (max ${maxEmails} threads)...`);
     } else {
-        pastDate = lookbackFloor;
-        console.log(`Performing full sync of last ${lookbackDays} days...`);
+        console.log(`Performing full sync of the newest ${maxEmails} threads...`);
     }
 
     let run: ServiceRunContext | null = null;
@@ -1180,19 +1335,24 @@ async function fullSync(auth: OAuth2Client, syncDir: string, attachmentsDir: str
     };
 
     try {
-        const dateQuery = pastDate.toISOString().split('T')[0].replace(/-/g, '/');
+        const baseQuery = '-in:spam -in:trash';
+        const q = resumeFrom
+            ? `after:${resumeFrom.toISOString().split('T')[0].replace(/-/g, '/')} ${baseQuery}`
+            : baseQuery;
 
         // Get History ID
         const profile = await gmail.users.getProfile({ userId: 'me' });
         const currentHistoryId = profile.data.historyId!;
 
+        // Gmail returns threads newest-first, so paginating until we've collected
+        // maxEmails ids yields the most recent maxEmails threads.
         const threadIds: string[] = [];
         let pageToken: string | undefined;
         do {
             const res = await gmail.users.threads.list({
                 userId: 'me',
-                q: `after:${dateQuery} -in:spam -in:trash`,
-                maxResults: 500,
+                q,
+                maxResults: Math.min(500, maxEmails),
                 pageToken
             });
 
@@ -1205,7 +1365,9 @@ async function fullSync(auth: OAuth2Client, syncDir: string, attachmentsDir: str
                 }
             }
             pageToken = res.data.nextPageToken ?? undefined;
-        } while (pageToken);
+        } while (pageToken && threadIds.length < maxEmails);
+
+        if (threadIds.length > maxEmails) threadIds.length = maxEmails;
 
         if (threadIds.length === 0) {
             saveState(currentHistoryId, stateFile);
@@ -1317,6 +1479,14 @@ async function partialSync(auth: OAuth2Client, startHistoryId: string, syncDir:
                 for (const item of record.messagesAdded) {
                     const labels = item.message?.labelIds ?? [];
                     if (labels.includes('SPAM') || labels.includes('TRASH')) continue;
+                    // Drafts are not incoming mail: every composer autosave
+                    // (ours or another Gmail client's) adds a DRAFT message.
+                    // Processing it would leak unsent draft bodies into
+                    // gmail_sync/ markdown + knowledge events, fire "New
+                    // email" notifications, and re-run the LLM classifier per
+                    // autosave. The Drafts view reads live via gmail:getDrafts
+                    // instead.
+                    if (labels.includes('DRAFT')) continue;
                     if (item.message?.threadId) {
                         threadIds.add(item.message.threadId);
                     }
@@ -1434,10 +1604,10 @@ async function performSync() {
         // partial-sync on subsequent calls.
         const cacheMissing = !fs.existsSync(CACHE_DIR) || fs.readdirSync(CACHE_DIR).length === 0;
         // partialSync replays *every* messageAdded since the stored historyId,
-        // regardless of date — so after a long offline gap a still-valid
-        // historyId would pull the entire gap (e.g. 3 weeks). To honor the
-        // "1 week at most" cap, bypass it when last_sync is older than the
-        // lookback window and run a (date-clamped) fullSync instead.
+        // regardless of date/count — so after a long offline gap a still-valid
+        // historyId would pull the entire gap (e.g. 3 weeks). When last_sync is
+        // older than the lookback window, bypass it and run fullSync instead,
+        // which is count-bounded (the newest maxEmails threads).
         const gapMs = state.last_sync ? Date.now() - new Date(state.last_sync).getTime() : 0;
         const gapTooLarge = gapMs > LOOKBACK_DAYS * 24 * 60 * 60 * 1000;
         if (!state.historyId) {
@@ -1447,7 +1617,7 @@ async function performSync() {
             console.log("History ID present but inbox cache empty — running full sync to backfill snapshots...");
             await fullSync(auth, SYNC_DIR, ATTACHMENTS_DIR, STATE_FILE, LOOKBACK_DAYS);
         } else if (gapTooLarge) {
-            console.log(`Last sync older than ${LOOKBACK_DAYS} days — running full sync clamped to the lookback window instead of partial sync...`);
+            console.log(`Last sync older than ${LOOKBACK_DAYS} days — running count-bounded full sync instead of partial sync...`);
             await fullSync(auth, SYNC_DIR, ATTACHMENTS_DIR, STATE_FILE, LOOKBACK_DAYS);
         } else {
             console.log("History ID found, starting partial sync...");
@@ -1485,6 +1655,19 @@ export interface SendReplyResult {
     error?: string;
 }
 
+export interface SaveDraftOptions extends Omit<SendReplyOptions, 'to'> {
+    /** Recipient may be blank while a draft is still being written. */
+    to?: string;
+    /** Existing Gmail draft to update; omitted on first save (creates a new one). */
+    draftId?: string;
+}
+
+export interface SaveDraftResult {
+    /** The Gmail-side draft id, to be passed back on subsequent saves. */
+    draftId?: string;
+    error?: string;
+}
+
 export interface GmailConnectionStatus {
     connected: boolean;
     hasRequiredScope: boolean;
@@ -1588,6 +1771,88 @@ function sanitizeAttachmentName(name: string): string {
     return (name || 'attachment').replace(/[\r\n"\\]/g, '_').trim() || 'attachment';
 }
 
+// Build the raw (base64url) RFC 2822 message shared by both send and draft-save.
+// Recipient headers are omitted when blank, so an in-progress draft with no
+// `To` yet still produces a valid message. `isEmpty` lets callers reject a
+// whitespace-only body without re-parsing the result.
+function buildRawMimeMessage(opts: SaveDraftOptions, userEmail: string): { raw: string; isEmpty: boolean } {
+    const safeTo = opts.to?.trim() ? requireSafeHeaderValue('To', opts.to) : undefined;
+    const safeCc = opts.cc?.trim() ? requireSafeHeaderValue('Cc', opts.cc) : undefined;
+    const safeBcc = opts.bcc?.trim() ? requireSafeHeaderValue('Bcc', opts.bcc) : undefined;
+    const safeInReplyTo = opts.inReplyTo ? requireSafeHeaderValue('In-Reply-To', opts.inReplyTo) : undefined;
+    const safeReferences = opts.references ? requireSafeHeaderValue('References', opts.references) : undefined;
+    const replyBody = opts.threadId
+        ? sanitizeReplyBodyForGmailReply(opts.bodyHtml, opts.bodyText)
+        : { bodyHtml: opts.bodyHtml.trim(), bodyText: opts.bodyText.trim() };
+    const isEmpty = !replyBody.bodyText.trim();
+
+    const seed = `${Date.now()}_${Math.random().toString(36).slice(2, 10)}`;
+    const altBoundary = `alt_${seed}`;
+    const attachments = (opts.attachments ?? []).filter((a) => a.contentBase64);
+
+    const headers: string[] = [];
+    headers.push(`From: ${requireSafeHeaderValue('From', userEmail)}`);
+    if (safeTo) headers.push(`To: ${safeTo}`);
+    if (safeCc) headers.push(`Cc: ${safeCc}`);
+    if (safeBcc) headers.push(`Bcc: ${safeBcc}`);
+    headers.push(`Subject: ${encodeRfc2047(opts.subject)}`);
+    if (safeInReplyTo) headers.push(`In-Reply-To: ${safeInReplyTo}`);
+    if (safeReferences) headers.push(`References: ${safeReferences}`);
+    headers.push('MIME-Version: 1.0');
+
+    // The text+html body as a self-contained multipart/alternative block.
+    const altParts: string[] = [];
+    altParts.push(`--${altBoundary}`);
+    altParts.push('Content-Type: text/plain; charset="UTF-8"');
+    altParts.push('Content-Transfer-Encoding: base64');
+    altParts.push('');
+    altParts.push(encodeMimeBase64(replyBody.bodyText));
+    altParts.push('');
+    altParts.push(`--${altBoundary}`);
+    altParts.push('Content-Type: text/html; charset="UTF-8"');
+    altParts.push('Content-Transfer-Encoding: base64');
+    altParts.push('');
+    altParts.push(encodeMimeBase64(replyBody.bodyHtml));
+    altParts.push('');
+    altParts.push(`--${altBoundary}--`);
+
+    let body: string;
+    if (attachments.length) {
+        // Wrap the alternative body plus each attachment in a multipart/mixed.
+        const mixedBoundary = `mixed_${seed}`;
+        headers.push(`Content-Type: multipart/mixed; boundary="${mixedBoundary}"`);
+        const mixed: string[] = [];
+        mixed.push(`--${mixedBoundary}`);
+        mixed.push(`Content-Type: multipart/alternative; boundary="${altBoundary}"`);
+        mixed.push('');
+        mixed.push(altParts.join('\r\n'));
+        for (const att of attachments) {
+            const name = sanitizeAttachmentName(att.filename);
+            const mime = sanitizeAttachmentName(att.mimeType) || 'application/octet-stream';
+            mixed.push(`--${mixedBoundary}`);
+            mixed.push(`Content-Type: ${mime}; name="${name}"`);
+            mixed.push('Content-Transfer-Encoding: base64');
+            mixed.push(`Content-Disposition: attachment; filename="${name}"`);
+            mixed.push('');
+            mixed.push(wrapBase64(att.contentBase64));
+            mixed.push('');
+        }
+        mixed.push(`--${mixedBoundary}--`);
+        body = mixed.join('\r\n');
+    } else {
+        headers.push(`Content-Type: multipart/alternative; boundary="${altBoundary}"`);
+        body = altParts.join('\r\n');
+    }
+
+    const message = `${headers.join('\r\n')}\r\n\r\n${body}`;
+    const raw = Buffer.from(message, 'utf8')
+        .toString('base64')
+        .replace(/\+/g, '-')
+        .replace(/\//g, '_')
+        .replace(/=+$/, '');
+    return { raw, isEmpty };
+}
+
 export async function sendThreadReply(opts: SendReplyOptions): Promise<SendReplyResult> {
     try {
         const auth = await GoogleClientFactory.getClient();
@@ -1597,82 +1862,11 @@ export async function sendThreadReply(opts: SendReplyOptions): Promise<SendReply
         const userEmail = await getUserEmail(auth);
         if (!userEmail) return { error: 'Could not determine your Gmail address.' };
 
-        const safeTo = requireSafeHeaderValue('To', opts.to);
-        const safeCc = opts.cc?.trim() ? requireSafeHeaderValue('Cc', opts.cc) : undefined;
-        const safeBcc = opts.bcc?.trim() ? requireSafeHeaderValue('Bcc', opts.bcc) : undefined;
-        const safeInReplyTo = opts.inReplyTo ? requireSafeHeaderValue('In-Reply-To', opts.inReplyTo) : undefined;
-        const safeReferences = opts.references ? requireSafeHeaderValue('References', opts.references) : undefined;
-        const replyBody = opts.threadId
-            ? sanitizeReplyBodyForGmailReply(opts.bodyHtml, opts.bodyText)
-            : { bodyHtml: opts.bodyHtml.trim(), bodyText: opts.bodyText.trim() };
-        if (!replyBody.bodyText.trim()) return { error: 'Draft is empty.' };
+        if (!opts.to?.trim()) return { error: 'Add at least one recipient.' };
+        const built = buildRawMimeMessage(opts, userEmail);
+        if (built.isEmpty) return { error: 'Draft is empty.' };
 
-        const seed = `${Date.now()}_${Math.random().toString(36).slice(2, 10)}`;
-        const altBoundary = `alt_${seed}`;
-        const attachments = (opts.attachments ?? []).filter((a) => a.contentBase64);
-
-        const headers: string[] = [];
-        headers.push(`From: ${requireSafeHeaderValue('From', userEmail)}`);
-        headers.push(`To: ${safeTo}`);
-        if (safeCc) headers.push(`Cc: ${safeCc}`);
-        if (safeBcc) headers.push(`Bcc: ${safeBcc}`);
-        headers.push(`Subject: ${encodeRfc2047(opts.subject)}`);
-        if (safeInReplyTo) headers.push(`In-Reply-To: ${safeInReplyTo}`);
-        if (safeReferences) headers.push(`References: ${safeReferences}`);
-        headers.push('MIME-Version: 1.0');
-
-        // The text+html body as a self-contained multipart/alternative block.
-        const altParts: string[] = [];
-        altParts.push(`--${altBoundary}`);
-        altParts.push('Content-Type: text/plain; charset="UTF-8"');
-        altParts.push('Content-Transfer-Encoding: base64');
-        altParts.push('');
-        altParts.push(encodeMimeBase64(replyBody.bodyText));
-        altParts.push('');
-        altParts.push(`--${altBoundary}`);
-        altParts.push('Content-Type: text/html; charset="UTF-8"');
-        altParts.push('Content-Transfer-Encoding: base64');
-        altParts.push('');
-        altParts.push(encodeMimeBase64(replyBody.bodyHtml));
-        altParts.push('');
-        altParts.push(`--${altBoundary}--`);
-
-        let body: string;
-        if (attachments.length) {
-            // Wrap the alternative body plus each attachment in a multipart/mixed.
-            const mixedBoundary = `mixed_${seed}`;
-            headers.push(`Content-Type: multipart/mixed; boundary="${mixedBoundary}"`);
-            const mixed: string[] = [];
-            mixed.push(`--${mixedBoundary}`);
-            mixed.push(`Content-Type: multipart/alternative; boundary="${altBoundary}"`);
-            mixed.push('');
-            mixed.push(altParts.join('\r\n'));
-            for (const att of attachments) {
-                const name = sanitizeAttachmentName(att.filename);
-                const mime = sanitizeAttachmentName(att.mimeType) || 'application/octet-stream';
-                mixed.push(`--${mixedBoundary}`);
-                mixed.push(`Content-Type: ${mime}; name="${name}"`);
-                mixed.push('Content-Transfer-Encoding: base64');
-                mixed.push(`Content-Disposition: attachment; filename="${name}"`);
-                mixed.push('');
-                mixed.push(wrapBase64(att.contentBase64));
-                mixed.push('');
-            }
-            mixed.push(`--${mixedBoundary}--`);
-            body = mixed.join('\r\n');
-        } else {
-            headers.push(`Content-Type: multipart/alternative; boundary="${altBoundary}"`);
-            body = altParts.join('\r\n');
-        }
-
-        const message = `${headers.join('\r\n')}\r\n\r\n${body}`;
-        const raw = Buffer.from(message, 'utf8')
-            .toString('base64')
-            .replace(/\+/g, '-')
-            .replace(/\//g, '_')
-            .replace(/=+$/, '');
-
-        const requestBody: gmail.Schema$Message = { raw };
+        const requestBody: gmail.Schema$Message = { raw: built.raw };
         if (opts.threadId) requestBody.threadId = opts.threadId;
 
         const res = await gmailClient.users.messages.send({
@@ -1706,6 +1900,294 @@ export async function sendThreadReply(opts: SendReplyOptions): Promise<SendReply
     }
 }
 
+/**
+ * Save the composer's contents as a Gmail draft. Drafts created here live in the
+ * user's real Gmail account, so they show up in the Drafts folder of every Gmail
+ * client and sync back down via the normal history sync (the `gmail_draft` field).
+ *
+ * Passing `draftId` updates that existing draft in place. If it's omitted but a
+ * draft already exists for `threadId` (e.g. a reply opened in a new session),
+ * that draft is reused instead of creating a duplicate. A stale `draftId`
+ * (deleted/sent elsewhere) falls back to creating a fresh draft.
+ */
+export async function saveThreadDraft(opts: SaveDraftOptions): Promise<SaveDraftResult> {
+    try {
+        const auth = await GoogleClientFactory.getClient();
+        if (!auth) return { error: 'Gmail is not connected.' };
+
+        const gmailClient = google.gmail({ version: 'v1', auth });
+        const userEmail = await getUserEmail(auth);
+        if (!userEmail) return { error: 'Could not determine your Gmail address.' };
+
+        const built = buildRawMimeMessage(opts, userEmail);
+        if (built.isEmpty) return { error: 'Draft is empty.' };
+
+        const message: gmail.Schema$Message = { raw: built.raw };
+        if (opts.threadId) message.threadId = opts.threadId;
+
+        // Resolve which draft to update: explicit id wins; otherwise reuse an
+        // existing draft on the same thread so replies don't pile up duplicates.
+        let draftId = opts.draftId;
+        if (!draftId && opts.threadId) {
+            try {
+                const drafts = await gmailClient.users.drafts.list({ userId: 'me' });
+                const existing = (drafts.data.drafts || []).find(
+                    (d) => d.message?.threadId === opts.threadId && d.id
+                );
+                if (existing?.id) draftId = existing.id;
+            } catch {
+                // Listing failed — fall through and create a new draft.
+            }
+        }
+
+        let res;
+        if (draftId) {
+            try {
+                res = await gmailClient.users.drafts.update({
+                    userId: 'me',
+                    id: draftId,
+                    requestBody: { message },
+                });
+            } catch (err) {
+                const code = (err as { code?: number })?.code
+                    ?? (err as { response?: { status?: number } })?.response?.status;
+                // Recreate only when the draft is actually gone (deleted or
+                // already sent). A transient failure (timeout, 5xx) must NOT
+                // fall back to create — the original draft still exists, so
+                // that would silently pile up duplicates in Gmail.
+                if (code !== 404 && code !== 410) throw err;
+                res = await gmailClient.users.drafts.create({ userId: 'me', requestBody: { message } });
+            }
+        } else {
+            res = await gmailClient.users.drafts.create({ userId: 'me', requestBody: { message } });
+        }
+
+        // Mirror the draft body onto the thread's cached snapshot so reopening
+        // the reply composer shows the autosaved text. Surgical, like
+        // markThreadRead — draft messages are filtered out of the history sync
+        // (see partialSync), so no sync pass will refresh this, and waking the
+        // whole sync loop per autosave (md/event writes + LLM reclassification)
+        // is exactly what we're avoiding.
+        if (opts.threadId) {
+            const cached = readCachedSnapshot(opts.threadId);
+            if (cached) {
+                cached.snapshot.gmail_draft = opts.bodyText?.trim() || undefined;
+                try {
+                    fs.writeFileSync(cachePath(opts.threadId), JSON.stringify(cached), 'utf-8');
+                } catch (err) {
+                    console.warn(`[Gmail cache] draft write failed for ${opts.threadId}:`, err);
+                }
+            }
+        }
+
+        return { draftId: res.data.id || undefined };
+    } catch (err) {
+        return { error: err instanceof Error ? err.message : String(err) };
+    }
+}
+
+/** Delete a Gmail draft by id. A missing draft is treated as success. */
+export async function deleteThreadDraft(draftId: string): Promise<{ ok: boolean; error?: string }> {
+    try {
+        const auth = await GoogleClientFactory.getClient();
+        if (!auth) return { ok: false, error: 'Gmail is not connected.' };
+
+        const gmailClient = google.gmail({ version: 'v1', auth });
+        await gmailClient.users.drafts.delete({ userId: 'me', id: draftId });
+        triggerSync();
+        return { ok: true };
+    } catch (err) {
+        const code = (err as { code?: number; response?: { status?: number } })?.code
+            ?? (err as { response?: { status?: number } })?.response?.status;
+        // Already gone (sent/deleted) — nothing to do.
+        if (code === 404 || code === 410) return { ok: true };
+        return { ok: false, error: err instanceof Error ? err.message : String(err) };
+    }
+}
+
+// In-memory cache of built draft snapshots, keyed by draftId and validated by
+// the draft's underlying message id. Gmail assigns a fresh message id whenever a
+// draft is updated (locally via saveThreadDraft or in another client), so an
+// unchanged message id means the parsed snapshot can be reused — we skip the
+// per-draft drafts.get + body parse, mirroring listInboxPage's mtime cache.
+interface DraftCacheEntry {
+    messageId: string;
+    snapshot: GmailThreadSnapshot;
+}
+const draftListCache = new Map<string, DraftCacheEntry>();
+
+// Fetch one draft and parse it into a lightweight snapshot for the Drafts view.
+async function buildDraftSnapshot(
+    gmailClient: gmail.Gmail,
+    draftId: string,
+): Promise<GmailThreadSnapshot | null> {
+    const full = await gmailClient.users.drafts.get({ userId: 'me', id: draftId, format: 'full' });
+    const msg = full.data.message;
+    if (!msg) return null;
+
+    const headers = msg.payload?.headers || [];
+    const parts = msg.payload ? extractBodyParts(msg.payload) : { text: '', html: '' };
+    const rawBody = msg.payload ? normalizeBody(getBody(msg.payload)) : '';
+    const body = stripGmailQuotedReplyText(rawBody);
+    const subject = headerValue(headers, 'Subject') || '';
+    const from = headerValue(headers, 'From') || '';
+    const to = headerValue(headers, 'To') || '';
+    const cc = headerValue(headers, 'Cc') || '';
+    const date = headerValue(headers, 'Date') || '';
+    const threadId = msg.threadId || draftId;
+    const messageIdHeader =
+        headerValue(headers, 'Message-ID') || headerValue(headers, 'Message-Id') || undefined;
+    // The reply chain the draft already carries. The composer must reuse these
+    // on send — this pseudo-thread has no other messages to rebuild them from,
+    // and deriving them from the draft itself would self-reference a
+    // Message-ID that never gets delivered (breaking recipients' threading).
+    const inReplyToHeader = headerValue(headers, 'In-Reply-To') || undefined;
+    const referencesHeader = headerValue(headers, 'References') || undefined;
+
+    return {
+        threadId,
+        threadUrl: `https://mail.google.com/mail/u/0/#drafts?compose=${draftId}`,
+        subject,
+        from,
+        to,
+        date,
+        latest_email: body,
+        gmail_draft: body || undefined,
+        draftId,
+        unread: false,
+        messages: [{
+            id: msg.id || undefined,
+            from,
+            to,
+            cc: cc || undefined,
+            date,
+            subject,
+            body,
+            bodyHtml: parts.html || undefined,
+            messageIdHeader,
+            isDraft: true,
+            inReplyToHeader,
+            referencesHeader,
+        }],
+    };
+}
+
+/**
+ * List the account's Gmail drafts (reply drafts and standalone new-message
+ * drafts) as lightweight thread snapshots for the Drafts view. Drafts aren't
+ * part of the INBOX snapshot cache, so we read them from the Gmail API — but a
+ * cheap drafts.list (ids only) lets us reuse already-parsed snapshots for
+ * unchanged drafts and only drafts.get the new/edited ones. No AI
+ * classification; recipients/subject/body come straight off the draft message.
+ */
+export async function listDraftThreads(): Promise<{ threads: GmailThreadSnapshot[]; error?: string }> {
+    try {
+        const auth = await GoogleClientFactory.getClient();
+        if (!auth) {
+            draftListCache.clear();
+            return { threads: [], error: 'Gmail is not connected.' };
+        }
+
+        const gmailClient = google.gmail({ version: 'v1', auth });
+        const list = await gmailClient.users.drafts.list({ userId: 'me', maxResults: 50 });
+        const drafts = list.data.drafts || [];
+
+        const seen = new Set<string>();
+        const built = await Promise.all(drafts.map(async (d) => {
+            if (!d.id) return null;
+            seen.add(d.id);
+            const messageId = d.message?.id || '';
+            const cached = draftListCache.get(d.id);
+            // Reuse the cached snapshot when the draft's message id is unchanged.
+            if (cached && messageId && cached.messageId === messageId) {
+                return cached.snapshot;
+            }
+            try {
+                const snapshot = await buildDraftSnapshot(gmailClient, d.id);
+                if (snapshot) draftListCache.set(d.id, { messageId, snapshot });
+                return snapshot;
+            } catch (err) {
+                console.warn('[Gmail] draft fetch failed:', err);
+                // Fall back to a stale cached copy if we have one.
+                return cached?.snapshot ?? null;
+            }
+        }));
+
+        // Evict cache entries for drafts that no longer exist (sent/deleted).
+        for (const key of draftListCache.keys()) {
+            if (!seen.has(key)) draftListCache.delete(key);
+        }
+
+        const threads = built.filter((s): s is GmailThreadSnapshot => s !== null);
+        // Newest first.
+        threads.sort((a, b) => {
+            const da = a.date ? Date.parse(a.date) : 0;
+            const db = b.date ? Date.parse(b.date) : 0;
+            return (Number.isFinite(db) ? db : 0) - (Number.isFinite(da) ? da : 0);
+        });
+        return { threads };
+    } catch (err) {
+        return { threads: [], error: err instanceof Error ? err.message : String(err) };
+    }
+}
+
+export interface SearchResult {
+    threads: GmailThreadSnapshot[];
+    error?: string;
+}
+
+/**
+ * Full-text search across the ENTIRE Gmail mailbox (not just locally-synced
+ * mail) using Gmail's `q` query. Each matching thread is parsed into a snapshot
+ * and written to the local search index so repeat searches — and opening a
+ * result — are instant. Reuses the inbox cache when a thread is already synced
+ * there. No AI classification.
+ */
+export async function searchThreads(query: string, opts: { limit?: number } = {}): Promise<SearchResult> {
+    const q = query.trim();
+    if (!q) return { threads: [] };
+    try {
+        const auth = await GoogleClientFactory.getClient();
+        if (!auth) return { threads: [], error: 'Gmail is not connected.' };
+
+        const gmailClient = google.gmail({ version: 'v1', auth });
+        // Generous cap so the index isn't artificially small (Gmail allows 500).
+        const limit = Math.max(1, Math.min(200, opts.limit ?? 100));
+        const list = await gmailClient.users.threads.list({ userId: 'me', q, maxResults: limit });
+        const ids = (list.data.threads || [])
+            .map((t) => t.id)
+            .filter((id): id is string => Boolean(id));
+
+        const built = await Promise.all(ids.map(async (threadId) => {
+            // Prefer the inbox snapshot (kept fresh by sync), then the search index.
+            const inboxCached = readCachedSnapshot(threadId);
+            if (inboxCached?.snapshot) return inboxCached.snapshot;
+            const indexed = readSearchSnapshot(threadId);
+            if (indexed?.snapshot) return indexed.snapshot;
+            try {
+                const threadData = await gmailClient.users.threads.get({ userId: 'me', id: threadId, format: 'full' });
+                const snapshot = await parseThreadSnapshot(threadId, threadData.data, gmailClient);
+                if (snapshot) writeSearchSnapshot(threadId, threadData.data.historyId || '', snapshot);
+                return snapshot;
+            } catch (err) {
+                console.warn(`[Gmail search] fetch failed for ${threadId}:`, err);
+                return null;
+            }
+        }));
+
+        const threads = built.filter((s): s is GmailThreadSnapshot => s !== null);
+        // Newest first.
+        threads.sort((a, b) => {
+            const da = a.date ? Date.parse(a.date) : 0;
+            const db = b.date ? Date.parse(b.date) : 0;
+            return (Number.isFinite(db) ? db : 0) - (Number.isFinite(da) ? da : 0);
+        });
+        return { threads };
+    } catch (err) {
+        return { threads: [], error: err instanceof Error ? err.message : String(err) };
+    }
+}
+
 export async function init() {
     console.log("Starting Gmail Sync (TS)...");
     console.log(`Will sync every ${SYNC_INTERVAL_MS / 1000} seconds.`);
diff --git a/apps/x/packages/core/src/knowledge/tag_notes.ts b/apps/x/packages/core/src/knowledge/tag_notes.ts
index 7cc7b426..70d451f4 100644
--- a/apps/x/packages/core/src/knowledge/tag_notes.ts
+++ b/apps/x/packages/core/src/knowledge/tag_notes.ts
@@ -1,10 +1,9 @@
 import fs from 'fs';
 import path from 'path';
 import { WorkDir } from '../config/config.js';
-import { createRun, createMessage } from '../runs/runs.js';
+import { runHeadlessAgent, toolInputPaths } from '../agents/headless-app.js';
 import { getKgModel } from '../models/defaults.js';
-import { bus } from '../runs/bus.js';
-import { getErrorDetails, waitForRunCompletion } from '../agents/utils.js';
+import { getErrorDetails } from '../agents/utils.js';
 import { serviceLogger } from '../services/service_logger.js';
 import { limitEventItems } from './limit_event_items.js';
 import {
@@ -83,13 +82,6 @@ function getUntaggedNotes(state: NoteTaggingState): string[] {
 async function tagNoteBatch(
     files: { path: string; content: string }[]
 ): Promise<{ runId: string; filesEdited: Set<string> }> {
-    const run = await createRun({
-        agentId: NOTE_TAGGING_AGENT,
-        model: await getKgModel(),
-        useCase: 'knowledge_sync',
-        subUseCase: 'tag_notes',
-    });
-
     let message = `Tag the following ${files.length} knowledge notes by prepending YAML frontmatter with appropriate tags.\n\n`;
     message += `**Important:** Use workspace-relative paths with file-editText (e.g. "knowledge/People/Sarah Chen.md", NOT absolute paths).\n\n`;
 
@@ -105,33 +97,16 @@ async function tagNoteBatch(
         message += `\n\n---\n\n`;
     }
 
-    const filesEdited = new Set<string>();
-
-    const unsubscribe = await bus.subscribe(run.id, async (event) => {
-        if (event.type !== 'tool-invocation') {
-            return;
-        }
-        if (event.toolName !== 'file-editText') {
-            return;
-        }
-        try {
-            const parsed = JSON.parse(event.input) as { path?: string };
-            if (typeof parsed.path === 'string') {
-                filesEdited.add(parsed.path);
-            }
-        } catch {
-            // ignore parse errors
-        }
+    const { turnId, state } = await runHeadlessAgent({
+        agentId: NOTE_TAGGING_AGENT,
+        message,
+        model: await getKgModel(),
+        throwOnError: true,
     });
 
-    await createMessage(run.id, message);
-    try {
-        await waitForRunCompletion(run.id, { throwOnError: true });
-    } finally {
-        unsubscribe();
-    }
-
-    return { runId: run.id, filesEdited };
+    // Edited paths come from the durable turn state instead of streaming
+    // bus subscriptions.
+    return { runId: turnId, filesEdited: toolInputPaths(state, ['file-editText']) };
 }
 
 /**
diff --git a/apps/x/packages/core/src/migrations/runs/__fixtures__/background-task.jsonl b/apps/x/packages/core/src/migrations/runs/__fixtures__/background-task.jsonl
new file mode 100644
index 00000000..781f41c5
--- /dev/null
+++ b/apps/x/packages/core/src/migrations/runs/__fixtures__/background-task.jsonl
@@ -0,0 +1,15 @@
+{"type":"start","runId":"2026-07-02T15-55-29Z-0017565-000","agentName":"background-task-agent","model":"google/gemini-3.1-flash-lite","provider":"rowboat","permissionMode":"manual","useCase":"background_task_agent","subUseCase":"manual","subflow":[],"ts":"2026-07-02T15:55:29.568Z"}
+{"runId":"2026-07-02T15-55-29Z-0017565-000","type":"message","messageId":"2026-07-02T15-55-29Z-0017565-001","message":{"role":"user","content":"Run the background task at `bg-tasks/mohali-weather-brief/`.\n\n**Time:** Thursday, July 2, 2026 at 9:25:29 PM GMT+5:30 (Asia/Calcutta)\n\n**Instructions:**\nGet and show the latest weather in Mohali in degree celsius\n\nYour task folder is `bg-tasks/mohali-weather-brief/`. The user-visible artifact is `bg-tasks/mohali-weather-brief/index.md` — read it with `file-readText` and update it with `file-editText` per the OUTPUT / ACTION mode rule. Do not touch `bg-tasks/mohali-weather-brief/task.yaml` (the runtime owns it).\n\n**Trigger:** Manual run (user-triggered — either the Run button in the Background Task detail view or the `run-background-task-agent` tool).","userMessageContext":{"currentDateTime":"Thursday, July 2, 2026 at 9:25 PM GMT+5:30"}},"subflow":[]}
+{"runId":"2026-07-02T15-55-29Z-0017565-000","messageId":"2026-07-02T15-55-31Z-0017565-000","type":"message","message":{"role":"assistant","content":[{"type":"tool-call","toolCallId":"oFDM4XYN","toolName":"file-readText","arguments":{"query":"redacted"},"providerOptions":{"openrouter":{"reasoning_details":[{"type":"reasoning.encrypted","data":"EjQKMgEMOdbHK4P4fV56Kb79TR4GLeN0KXeYhT+YPCqiTE4fmExcz7koIh6pfWrr8i4wlW2X","id":"oFDM4XYN","format":"google-gemini-v1","index":0}]}}},{"type":"reasoning","text":"[REDACTED]"}],"providerOptions":{"openrouter":{"usage":{"promptTokens":12311,"promptTokensDetails":{"cachedTokens":0},"completionTokens":30,"completionTokensDetails":{"reasoningTokens":0},"cost":0,"totalTokens":12341,"costDetails":{"upstreamInferenceCost":0.00312275}},"provider":"Google AI Studio","reasoning_details":[{"type":"reasoning.encrypted","data":"EjQKMgEMOdbHK4P4fV56Kb79TR4GLeN0KXeYhT+YPCqiTE4fmExcz7koIh6pfWrr8i4wlW2X","id":"oFDM4XYN","format":"google-gemini-v1","index":0}]}}},"subflow":[]}
+{"runId":"2026-07-02T15-55-29Z-0017565-000","type":"tool-invocation","toolCallId":"oFDM4XYN","toolName":"file-readText","input":"{\"query\": \"redacted\"}","subflow":[]}
+{"runId":"2026-07-02T15-55-29Z-0017565-000","type":"tool-result","toolCallId":"oFDM4XYN","toolName":"file-readText","result":{"ok":true,"note":"redacted for fixture"},"subflow":[]}
+{"runId":"2026-07-02T15-55-29Z-0017565-000","messageId":"2026-07-02T15-55-31Z-0017565-001","type":"message","message":{"role":"tool","content":"redacted for fixture","toolCallId":"oFDM4XYN","toolName":"file-readText"},"subflow":[]}
+{"runId":"2026-07-02T15-55-29Z-0017565-000","messageId":"2026-07-02T15-55-33Z-0017565-000","type":"message","message":{"role":"assistant","content":[{"type":"tool-call","toolCallId":"OAs24vk5","toolName":"web-search","arguments":{"query":"redacted"},"providerOptions":{"openrouter":{"reasoning_details":[{"type":"reasoning.encrypted","data":"EjQKMgEMOdbHs6o9nrkXG1745HqUQkXR2/g4bvozLYGNP63eCEFEIDPzSKvW+CBAyOuSl46C","id":"OAs24vk5","format":"google-gemini-v1","index":0}]}}},{"type":"reasoning","text":"[REDACTED]"}],"providerOptions":{"openrouter":{"usage":{"promptTokens":12609,"promptTokensDetails":{"cachedTokens":8079},"completionTokens":21,"completionTokensDetails":{"reasoningTokens":0},"cost":0,"totalTokens":12630,"costDetails":{"upstreamInferenceCost":0.001365975}},"provider":"Google AI Studio","reasoning_details":[{"type":"reasoning.encrypted","data":"EjQKMgEMOdbHs6o9nrkXG1745HqUQkXR2/g4bvozLYGNP63eCEFEIDPzSKvW+CBAyOuSl46C","id":"OAs24vk5","format":"google-gemini-v1","index":0}]}}},"subflow":[]}
+{"runId":"2026-07-02T15-55-29Z-0017565-000","type":"tool-invocation","toolCallId":"OAs24vk5","toolName":"web-search","input":"{\"query\": \"redacted\"}","subflow":[]}
+{"runId":"2026-07-02T15-55-29Z-0017565-000","type":"tool-result","toolCallId":"OAs24vk5","toolName":"web-search","result":{"ok":true,"note":"redacted for fixture"},"subflow":[]}
+{"runId":"2026-07-02T15-55-29Z-0017565-000","messageId":"2026-07-02T15-55-34Z-0017565-000","type":"message","message":{"role":"tool","content":"redacted for fixture","toolCallId":"OAs24vk5","toolName":"web-search"},"subflow":[]}
+{"runId":"2026-07-02T15-55-29Z-0017565-000","messageId":"2026-07-02T15-55-36Z-0017565-000","type":"message","message":{"role":"assistant","content":[{"type":"tool-call","toolCallId":"xcoaRes7","toolName":"file-editText","arguments":{"query":"redacted"},"providerOptions":{"openrouter":{"reasoning_details":[{"type":"reasoning.encrypted","data":"EjQKMgEMOdbH+d29EP8/ZWH5EL3vSL+Nb9k5tsCVzMyINtH7vfhAvqeB7hBGY1L60w2BRWn4","id":"xcoaRes7","format":"google-gemini-v1","index":0}]}}},{"type":"reasoning","text":"[REDACTED]"}],"providerOptions":{"openrouter":{"usage":{"promptTokens":17340,"promptTokensDetails":{"cachedTokens":12157},"completionTokens":75,"completionTokensDetails":{"reasoningTokens":0},"cost":0,"totalTokens":17415,"costDetails":{"upstreamInferenceCost":0.001712175}},"provider":"Google AI Studio","reasoning_details":[{"type":"reasoning.encrypted","data":"EjQKMgEMOdbH+d29EP8/ZWH5EL3vSL+Nb9k5tsCVzMyINtH7vfhAvqeB7hBGY1L60w2BRWn4","id":"xcoaRes7","format":"google-gemini-v1","index":0}]}}},"subflow":[]}
+{"runId":"2026-07-02T15-55-29Z-0017565-000","type":"tool-invocation","toolCallId":"xcoaRes7","toolName":"file-editText","input":"{\"query\": \"redacted\"}","subflow":[]}
+{"runId":"2026-07-02T15-55-29Z-0017565-000","type":"tool-result","toolCallId":"xcoaRes7","toolName":"file-editText","result":{"ok":true,"note":"redacted for fixture"},"subflow":[]}
+{"runId":"2026-07-02T15-55-29Z-0017565-000","messageId":"2026-07-02T15-55-36Z-0017565-001","type":"message","message":{"role":"tool","content":"redacted for fixture","toolCallId":"xcoaRes7","toolName":"file-editText"},"subflow":[]}
+{"runId":"2026-07-02T15-55-29Z-0017565-000","messageId":"2026-07-02T15-55-37Z-0017565-000","type":"message","message":{"role":"assistant","content":[{"type":"text","text":"Updated — Mohali: 30.5°C · Clear Sky (as of 9:00 PM IST)."}],"providerOptions":{"openrouter":{"usage":{"promptTokens":17487,"promptTokensDetails":{"cachedTokens":12151},"completionTokens":26,"completionTokensDetails":{"reasoningTokens":0},"cost":0,"totalTokens":17513,"costDetails":{"upstreamInferenceCost":0.001676775}},"provider":"Google AI Studio","reasoning_details":[{"type":"reasoning.text","signature":"EjQKMgEMOdbHosBKKoAUZMNdqBPqUrsYCf2gYO8SL1TPjujCq2Zfl+Iia3fy5vIqcd8yY7TI","format":"google-gemini-v1","index":0}]}}},"subflow":[]}
diff --git a/apps/x/packages/core/src/migrations/runs/__fixtures__/copilot-brew-deny.jsonl b/apps/x/packages/core/src/migrations/runs/__fixtures__/copilot-brew-deny.jsonl
new file mode 100644
index 00000000..fe9ccad3
--- /dev/null
+++ b/apps/x/packages/core/src/migrations/runs/__fixtures__/copilot-brew-deny.jsonl
@@ -0,0 +1,7 @@
+{"type":"start","runId":"2026-07-02T15-29-15Z-0011690-000","agentName":"copilot","model":"anthropic/claude-opus-4.7","provider":"rowboat","permissionMode":"manual","useCase":"copilot_chat","subflow":[],"ts":"2026-07-02T15:29:15.130Z"}
+{"runId":"2026-07-02T15-29-15Z-0011690-000","type":"message","messageId":"2026-07-02T15-29-15Z-0011690-001","message":{"role":"user","content":"run the following command:\nbrew install foobar","userMessageContext":{"currentDateTime":"Thursday, July 2, 2026 at 8:59 PM GMT+5:30","middlePane":{"kind":"empty"}}},"subflow":[]}
+{"runId":"2026-07-02T15-29-15Z-0011690-000","messageId":"2026-07-02T15-29-17Z-0011690-002","type":"message","message":{"role":"assistant","content":[{"type":"tool-call","toolCallId":"toolu_bdrk_01Vq7Vjphw18SzBskW1F38QP","toolName":"executeCommand","arguments":{"query":"redacted"},"providerOptions":{"openrouter":{"reasoning_details":[]}}},{"type":"text","text":"I'll run that for you."}],"providerOptions":{"openrouter":{"usage":{"promptTokens":24249,"promptTokensDetails":{"cachedTokens":0},"completionTokens":79,"completionTokensDetails":{"reasoningTokens":0},"cost":0,"totalTokens":24328,"costDetails":{"upstreamInferenceCost":0.12322}},"provider":"Amazon Bedrock"}}},"subflow":[]}
+{"runId":"2026-07-02T15-29-15Z-0011690-000","type":"tool-permission-request","toolCall":{"type":"tool-call","toolCallId":"toolu_bdrk_01Vq7Vjphw18SzBskW1F38QP","toolName":"executeCommand","arguments":{"query":"redacted"},"providerOptions":{"openrouter":{"reasoning_details":[]}}},"permission":{"kind":"command","commandNames":["brew"]},"subflow":[]}
+{"subflow":[],"toolCallId":"toolu_bdrk_01Vq7Vjphw18SzBskW1F38QP","response":"deny","runId":"2026-07-02T15-29-15Z-0011690-000","type":"tool-permission-response"}
+{"runId":"2026-07-02T15-29-15Z-0011690-000","messageId":"2026-07-02T15-29-19Z-0011690-002","type":"message","message":{"role":"tool","content":"redacted for fixture","toolCallId":"toolu_bdrk_01Vq7Vjphw18SzBskW1F38QP","toolName":"executeCommand"},"subflow":[]}
+{"runId":"2026-07-02T15-29-15Z-0011690-000","messageId":"2026-07-02T15-29-24Z-0011690-000","type":"message","message":{"role":"assistant","content":[{"type":"text","text":"The command was denied by the approval prompt, so `brew install foobar` didn't run. If you'd like to try again, approve the prompt when it appears — or let me know if you want me to try a different package name (Homebrew doesn't have an official `foobar` formula, so it would likely fail with \"No available formula\" anyway)."}],"providerOptions":{"openrouter":{"usage":{"promptTokens":24357,"promptTokensDetails":{"cachedTokens":0},"completionTokens":104,"completionTokensDetails":{"reasoningTokens":0},"cost":0,"totalTokens":24461,"costDetails":{"upstreamInferenceCost":0.124385}},"provider":"Amazon Bedrock"}}},"subflow":[]}
diff --git a/apps/x/packages/core/src/migrations/runs/__fixtures__/copilot-multi-turn.jsonl b/apps/x/packages/core/src/migrations/runs/__fixtures__/copilot-multi-turn.jsonl
new file mode 100644
index 00000000..e2b79ede
--- /dev/null
+++ b/apps/x/packages/core/src/migrations/runs/__fixtures__/copilot-multi-turn.jsonl
@@ -0,0 +1,16 @@
+{"type":"start","runId":"2026-07-02T15-27-08Z-0011690-000","agentName":"copilot","model":"anthropic/claude-opus-4.7","provider":"rowboat","permissionMode":"auto","useCase":"copilot_chat","subflow":[],"ts":"2026-07-02T15:27:08.939Z"}
+{"runId":"2026-07-02T15-27-08Z-0011690-000","type":"message","messageId":"2026-07-02T15-27-09Z-0011690-000","message":{"role":"user","content":"yo","userMessageContext":{"currentDateTime":"Thursday, July 2, 2026 at 8:57 PM GMT+5:30","middlePane":{"kind":"empty"}}},"subflow":[]}
+{"runId":"2026-07-02T15-27-08Z-0011690-000","messageId":"2026-07-02T15-27-11Z-0011690-002","type":"message","message":{"role":"assistant","content":[{"type":"text","text":"Yo! What's up?"}],"providerOptions":{"openrouter":{"usage":{"promptTokens":24239,"promptTokensDetails":{"cachedTokens":0},"completionTokens":12,"completionTokensDetails":{"reasoningTokens":0},"cost":0,"totalTokens":24251,"costDetails":{"upstreamInferenceCost":0.121495}},"provider":"Amazon Bedrock"}}},"subflow":[]}
+{"runId":"2026-07-02T15-27-08Z-0011690-000","type":"message","messageId":"2026-07-02T15-27-25Z-0011690-000","message":{"role":"user","content":"whats the weather in Mohali?","userMessageContext":{"currentDateTime":"Thursday, July 2, 2026 at 8:57 PM GMT+5:30","middlePane":{"kind":"empty"}}},"subflow":[]}
+{"runId":"2026-07-02T15-27-08Z-0011690-000","messageId":"2026-07-02T15-27-30Z-0011690-000","type":"message","message":{"role":"assistant","content":[{"type":"tool-call","toolCallId":"toolu_bdrk_013dC9KmbiBbMH7L2a8wJ3HG","toolName":"web-search","arguments":{"query":"redacted"},"providerOptions":{"openrouter":{"reasoning_details":[]}}},{"type":"text","text":"Quick answer coming up — but \"what's the weather\" is exactly the kind of thing that decays fast. Want me to set up a background task that keeps a fresh Mohali forecast in a note (say, refreshed every morning)? Say the word.\n\nFor right now:"}],"providerOptions":{"openrouter":{"usage":{"promptTokens":24325,"promptTokensDetails":{"cachedTokens":0},"completionTokens":176,"completionTokensDetails":{"reasoningTokens":0},"cost":0,"totalTokens":24501,"costDetails":{"upstreamInferenceCost":0.126025}},"provider":"Amazon Bedrock"}}},"subflow":[]}
+{"runId":"2026-07-02T15-27-08Z-0011690-000","type":"tool-invocation","toolCallId":"toolu_bdrk_013dC9KmbiBbMH7L2a8wJ3HG","toolName":"web-search","input":"{\"query\": \"redacted\"}","subflow":[]}
+{"runId":"2026-07-02T15-27-08Z-0011690-000","type":"tool-result","toolCallId":"toolu_bdrk_013dC9KmbiBbMH7L2a8wJ3HG","toolName":"web-search","result":{"ok":true,"note":"redacted for fixture"},"subflow":[]}
+{"runId":"2026-07-02T15-27-08Z-0011690-000","messageId":"2026-07-02T15-27-31Z-0011690-000","type":"message","message":{"role":"tool","content":"redacted for fixture","toolCallId":"toolu_bdrk_013dC9KmbiBbMH7L2a8wJ3HG","toolName":"web-search"},"subflow":[]}
+{"runId":"2026-07-02T15-27-08Z-0011690-000","messageId":"2026-07-02T15-27-40Z-0011690-000","type":"message","message":{"role":"assistant","content":[{"type":"text","text":"### Mohali right now (Thu, Jul 2, ~9 PM IST)\n- **~30°C (87°F)**, feels like **~37°C (99°F)** — humid\n- Clear sky, humidity **76%**, light ESE wind ~3 km/h\n- **Today's range:** 27°C → 33°C, 0% rain\n- **Sunset:** 7:29 PM (already down)\n\n### Next few days\n- **Fri Jul 3:** hot & overcast, up to ~34°C\n- **Sat–Wed:** monsoon kicks in — thunderstorms most days, highs ~32–34°C\n\nBasically: sticky tonight, storms rolling in over the weekend."}],"providerOptions":{"openrouter":{"usage":{"promptTokens":31150,"promptTokensDetails":{"cachedTokens":0},"completionTokens":231,"completionTokensDetails":{"reasoningTokens":0},"cost":0,"totalTokens":31381,"costDetails":{"upstreamInferenceCost":0.161525}},"provider":"Amazon Bedrock"}}},"subflow":[]}
+{"runId":"2026-07-02T15-27-08Z-0011690-000","type":"message","messageId":"2026-07-02T15-27-45Z-0011690-000","message":{"role":"user","content":"list my recent downloads","userMessageContext":{"currentDateTime":"Thursday, July 2, 2026 at 8:57 PM GMT+5:30","middlePane":{"kind":"empty"}}},"subflow":[]}
+{"runId":"2026-07-02T15-27-08Z-0011690-000","messageId":"2026-07-02T15-28-31Z-0011690-000","type":"message","message":{"role":"assistant","content":[{"type":"tool-call","toolCallId":"toolu_bdrk_01HJvA2Yi1eMWmtr5v5KaNe4","toolName":"file-list","arguments":{"query":"redacted"},"providerOptions":{"openrouter":{"reasoning_details":[]}}}],"providerOptions":{"openrouter":{"usage":{"promptTokens":31451,"promptTokensDetails":{"cachedTokens":0},"completionTokens":92,"completionTokensDetails":{"reasoningTokens":0},"cost":0,"totalTokens":31543,"costDetails":{"upstreamInferenceCost":0.159555}},"provider":"Amazon Bedrock"}}},"subflow":[]}
+{"runId":"2026-07-02T15-27-08Z-0011690-000","type":"tool-permission-auto-decision","toolCallId":"toolu_bdrk_01HJvA2Yi1eMWmtr5v5KaNe4","toolCall":{"type":"tool-call","toolCallId":"toolu_bdrk_01HJvA2Yi1eMWmtr5v5KaNe4","toolName":"file-list","arguments":{"query":"redacted"},"providerOptions":{"openrouter":{"reasoning_details":[]}}},"permission":{"kind":"file","operation":"list","paths":["/Users/testuser/Downloads"],"pathPrefix":"/Users/testuser/Downloads"},"decision":"allow","reason":"The user explicitly requested to list files in their Downloads directory, and the tool call is scoped to that directory.","subflow":[]}
+{"runId":"2026-07-02T15-27-08Z-0011690-000","type":"tool-invocation","toolCallId":"toolu_bdrk_01HJvA2Yi1eMWmtr5v5KaNe4","toolName":"file-list","input":"{\"query\": \"redacted\"}","subflow":[]}
+{"runId":"2026-07-02T15-27-08Z-0011690-000","type":"tool-result","toolCallId":"toolu_bdrk_01HJvA2Yi1eMWmtr5v5KaNe4","toolName":"file-list","result":{"ok":true,"note":"redacted for fixture"},"subflow":[]}
+{"runId":"2026-07-02T15-27-08Z-0011690-000","messageId":"2026-07-02T15-28-33Z-0011690-000","type":"message","message":{"role":"tool","content":"redacted for fixture","toolCallId":"toolu_bdrk_01HJvA2Yi1eMWmtr5v5KaNe4","toolName":"file-list"},"subflow":[]}
+{"runId":"2026-07-02T15-27-08Z-0011690-000","messageId":"2026-07-02T15-28-57Z-0011690-000","type":"message","message":{"role":"assistant","content":[{"type":"text","text":"Your Downloads folder is *massive* — hundreds of files going back to 2024. Here are the **10 most recent** (all from the past few days, June 2026):\n\n### Most recent downloads\n1. `Punjab-main---Punjab-main.pdf` — 36 MB, Jul 1 (~10 PM)\n2. `Punjab-main-Punjab-main-page-9.pdf` — 339 KB, Jul 1\n3. `89227HC00FLG.pdf` — 46 KB, Jun 29\n4. `26070100012297ICIC_ChallanReceipt.pdf` — 422 KB, Jun 27\n5. `AnnexureD.pdf` — 81 KB, Jun 26\n6. `18997H8016V0.pdf` — 46 KB, Jun 24\n7. `53377H801DNU.pdf` — 46 KB, Jun 24\n8. `76687H8019D2.pdf` — 46 KB, Jun 24\n9. `25327H800NXB.pdf` — 46 KB, Jun 24\n10. `49137H8010X2.pdf` — 46 KB, Jun 24\n\n```filepath\n~/Downloads\n```\n\nHeads up — your Downloads folder is a graveyard: multiple `(1)`, `(2)`, `(3)` duplicates, ~30 old Rowboat .dmg builds, ISOs, obsolete installers. Rough estimate: several GB of easy wins. Say the word and I'll draft a cleanup plan (dedupe, archive old builds, sweep installers)."}],"providerOptions":{"openrouter":{"usage":{"promptTokens":146280,"promptTokensDetails":{"cachedTokens":0},"completionTokens":518,"completionTokensDetails":{"reasoningTokens":0},"cost":0,"totalTokens":146798,"costDetails":{"upstreamInferenceCost":0.74435}},"provider":"Amazon Bedrock"}}},"subflow":[]}
diff --git a/apps/x/packages/core/src/migrations/runs/__fixtures__/knowledge-single-turn.jsonl b/apps/x/packages/core/src/migrations/runs/__fixtures__/knowledge-single-turn.jsonl
new file mode 100644
index 00000000..bf1109b2
--- /dev/null
+++ b/apps/x/packages/core/src/migrations/runs/__fixtures__/knowledge-single-turn.jsonl
@@ -0,0 +1,3 @@
+{"type":"start","runId":"2026-07-02T15-26-22Z-0011690-000","agentName":"note_creation","model":"google/gemini-3.1-flash-lite","provider":"rowboat","permissionMode":"manual","useCase":"knowledge_sync","subUseCase":"build_graph","subflow":[],"ts":"2026-07-02T15:26:22.103Z"}
+{"runId":"2026-07-02T15-26-22Z-0011690-000","type":"message","messageId":"2026-07-02T15-26-22Z-0011690-001","message":{"role":"user","content":"Process the following 1 source files and create/update obsidian notes.\n\n**Instructions:**\n- Use the KNOWLEDGE BASE INDEX below to resolve entities - DO NOT grep/search for existing notes\n- Extract entities and relationships\n\n**KNOWLEDGE BASE INDEX:**\n- [[Acme Corp]]\n- [[Sample Project]]\n\n**Source file: sample-note.md**\nMeeting with Acme Corp about the Sample Project. Follow up next week.\n","userMessageContext":{"currentDateTime":"Thursday, July 2, 2026 at 8:56 PM GMT+5:30"}},"subflow":[]}
+{"runId":"2026-07-02T15-26-22Z-0011690-000","messageId":"2026-07-02T15-26-24Z-0011690-000","type":"message","message":{"role":"assistant","content":[{"type":"text","text":"Created/updated 1 note: [[Acme Corp]] with a reference to [[Sample Project]]."}],"providerOptions":{"openrouter":{"usage":{"promptTokens":19366,"promptTokensDetails":{"cachedTokens":0},"completionTokens":84,"completionTokensDetails":{"reasoningTokens":0},"cost":0,"totalTokens":19450,"costDetails":{"upstreamInferenceCost":0.0049675}},"provider":"Google AI Studio","reasoning_details":[{"type":"reasoning.text","signature":"EjQKMgEMOdbHC3J8//5gZWhEIrTstK75K+2cLu//G8KXeokib7MUOAXX6oLYt9RyB+jnT6JE","format":"google-gemini-v1","index":0}]}}},"subflow":[]}
diff --git a/apps/x/packages/core/src/migrations/runs/convert.test.ts b/apps/x/packages/core/src/migrations/runs/convert.test.ts
new file mode 100644
index 00000000..0f6e889f
--- /dev/null
+++ b/apps/x/packages/core/src/migrations/runs/convert.test.ts
@@ -0,0 +1,140 @@
+import { describe, it, expect } from "vitest";
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { z } from "zod";
+import { RunEvent } from "@x/shared/dist/runs.js";
+import { reduceTurn, turnTranscript } from "@x/shared/dist/turns.js";
+import { reduceSession } from "@x/shared/dist/sessions.js";
+import { convertRun } from "./convert.js";
+
+const fixturesDir = path.join(
+    path.dirname(fileURLToPath(import.meta.url)),
+    "__fixtures__",
+);
+
+type RunEventT = z.infer<typeof RunEvent>;
+
+function loadFixture(name: string): { log: RunEventT[]; runId: string } {
+    const raw = fs.readFileSync(path.join(fixturesDir, name), "utf-8");
+    const log = raw
+        .split("\n")
+        .filter((line) => line.trim().length > 0)
+        .map((line) => RunEvent.parse(JSON.parse(line)));
+    const start = log[0];
+    if (start.type !== "start") throw new Error("fixture missing start event");
+    return { log, runId: start.runId };
+}
+
+describe("convertRun", () => {
+    it("non-copilot run -> a single standalone turn whose id is the runId", () => {
+        const { log, runId } = loadFixture("knowledge-single-turn.jsonl");
+        const result = convertRun(log, runId);
+
+        expect(result.isSession).toBe(false);
+        expect(result.session).toBeUndefined();
+        expect(result.turns).toHaveLength(1);
+        expect(result.turns[0].turnId).toBe(runId);
+
+        const state = reduceTurn(result.turns[0].events);
+        expect(state.terminal?.type).toBe("turn_completed");
+        expect(state.definition.sessionId).toBeNull();
+        // Standalone turn has inline (empty) context.
+        expect(Array.isArray(state.definition.context)).toBe(true);
+    });
+
+    it("background-task run -> standalone turn, reasoning parts preserved", () => {
+        const { log, runId } = loadFixture("background-task.jsonl");
+        const result = convertRun(log, runId);
+
+        expect(result.isSession).toBe(false);
+        expect(result.turns[0].turnId).toBe(runId);
+
+        const state = reduceTurn(result.turns[0].events);
+        // The bg-task run interleaves tool-call + reasoning parts; they survive
+        // verbatim on the completed model messages.
+        const hasReasoning = state.modelCalls.some(
+            (c) =>
+                Array.isArray(c.response?.content) &&
+                c.response.content.some((p) => p.type === "reasoning"),
+        );
+        expect(hasReasoning).toBe(true);
+        // Every tool call resolved with a terminal result.
+        expect(state.toolCalls.every((tc) => tc.result)).toBe(true);
+    });
+
+    it("copilot run -> session + one turn per user message, chained by previousTurnId", () => {
+        const { log, runId } = loadFixture("copilot-multi-turn.jsonl");
+        const result = convertRun(log, runId);
+
+        expect(result.isSession).toBe(true);
+        expect(result.session?.sessionId).toBe(runId);
+        // Fixture has 3 user messages.
+        expect(result.turns).toHaveLength(3);
+
+        // Session reduces and lists the turns in order.
+        const sessionState = reduceSession(result.session!.events);
+        expect(sessionState.turns.map((t) => t.turnId)).toEqual(
+            result.turns.map((t) => t.turnId),
+        );
+        expect(sessionState.turns.map((t) => t.sessionSeq)).toEqual([1, 2, 3]);
+
+        // First turn has inline context; later turns reference their predecessor.
+        const states = result.turns.map((t) => reduceTurn(t.events));
+        expect(Array.isArray(states[0].definition.context)).toBe(true);
+        expect(states[1].definition.context).toEqual({
+            previousTurnId: result.turns[0].turnId,
+        });
+        expect(states[2].definition.context).toEqual({
+            previousTurnId: result.turns[1].turnId,
+        });
+        // Every turn is completed and its session id points back to the session.
+        for (const s of states) {
+            expect(s.terminal?.type).toBe("turn_completed");
+            expect(s.definition.sessionId).toBe(runId);
+        }
+    });
+
+    it("copilot deny run -> runtime tool result flagged as error", () => {
+        const { log, runId } = loadFixture("copilot-brew-deny.jsonl");
+        const result = convertRun(log, runId);
+
+        expect(result.isSession).toBe(true);
+        const state = reduceTurn(result.turns[0].events);
+
+        const denied = state.toolCalls.find(
+            (tc) => tc.result?.source === "runtime",
+        );
+        expect(denied).toBeDefined();
+        expect(denied?.result?.result.isError).toBe(true);
+        // A denied call is resolved but never invoked.
+        expect(denied?.permission?.resolved?.decision).toBe("deny");
+        expect(denied?.invocation).toBeUndefined();
+    });
+
+    it("turnTranscript reproduces the original conversation slice", () => {
+        const { log, runId } = loadFixture("copilot-multi-turn.jsonl");
+        const result = convertRun(log, runId);
+
+        // Reconstruct expected per-turn user/assistant text from the raw log.
+        const userTexts: string[] = [];
+        for (const e of log) {
+            if (e.type === "message" && e.message.role === "user") {
+                const c = e.message.content;
+                userTexts.push(typeof c === "string" ? c : JSON.stringify(c));
+            }
+        }
+
+        result.turns.forEach((turn, i) => {
+            const transcript = turnTranscript(reduceTurn(turn.events));
+            // The first message of each turn's transcript is its user input.
+            expect(transcript[0].role).toBe("user");
+            const c = transcript[0].content;
+            expect(typeof c === "string" ? c : JSON.stringify(c)).toBe(
+                userTexts[i],
+            );
+            // The last contributed message is an assistant response.
+            expect(transcript[transcript.length - 1].role).toBe("assistant");
+        });
+    });
+});
diff --git a/apps/x/packages/core/src/migrations/runs/convert.ts b/apps/x/packages/core/src/migrations/runs/convert.ts
new file mode 100644
index 00000000..5e1906c2
--- /dev/null
+++ b/apps/x/packages/core/src/migrations/runs/convert.ts
@@ -0,0 +1,539 @@
+import { z } from "zod";
+import {
+    RunEvent,
+    StartEvent,
+    type UseCase,
+} from "@x/shared/dist/runs.js";
+import type {
+    AssistantMessage,
+    UserMessage,
+} from "@x/shared/dist/message.js";
+import {
+    assistantRef,
+    reduceTurn,
+    toolResultRef,
+    TurnEvent,
+    type ModelDescriptor,
+} from "@x/shared/dist/turns.js";
+import { reduceSession, SessionEvent } from "@x/shared/dist/sessions.js";
+
+// One-time conversion of a legacy `run.jsonl` log into the new event-sourced
+// turn/session runtime. Pure and I/O-free so it is exhaustively testable
+// against real fixtures; the runner (migrate.ts) owns the filesystem side.
+//
+// Mapping (decided in planning):
+//   - A run is one whole conversation. Turn boundaries are user messages.
+//   - copilot_chat runs  -> one session + one turn per user message.
+//   - every other run    -> a single standalone turn (sessionId: null) whose
+//                           turnId is the ORIGINAL runId, so the live-note /
+//                           background-task history views (which store that id
+//                           and already fetch turn-first via sessions:getTurn)
+//                           resolve it with no code change.
+//   - code_session runs are skipped by the runner; nothing to migrate there.
+//
+// The synthesized turn log is validated against reduceTurn before it is
+// returned; anything the reducer would reject throws and the runner quarantines
+// the run instead of writing a corrupt turn.
+
+type RunEventT = z.infer<typeof RunEvent>;
+type StartT = z.infer<typeof StartEvent>;
+type TurnEventT = z.infer<typeof TurnEvent>;
+type SessionEventT = z.infer<typeof SessionEvent>;
+type UserMessageT = z.infer<typeof UserMessage>;
+type AssistantMessageT = z.infer<typeof AssistantMessage>;
+type ModelDescriptorT = z.infer<typeof ModelDescriptor>;
+
+export interface ConvertedTurn {
+    turnId: string;
+    events: TurnEventT[];
+}
+
+export interface ConvertedSession {
+    sessionId: string;
+    events: SessionEventT[];
+}
+
+export interface ConvertResult {
+    session?: ConvertedSession;
+    turns: ConvertedTurn[];
+    /** True for copilot_chat runs (session + turns); false for standalone. */
+    isSession: boolean;
+}
+
+export class RunConversionError extends Error {
+    constructor(message: string) {
+        super(message);
+        this.name = "RunConversionError";
+    }
+}
+
+// A tool-call part lifted off an assistant message, with everything the run
+// recorded about how it resolved.
+interface ToolCallPlan {
+    toolCallId: string;
+    toolName: string;
+    input: unknown;
+    // Permission provenance from the legacy run, if any.
+    autoDecision?: { decision: "allow" | "deny"; reason: string; request: unknown };
+    manualRequest?: { request: unknown };
+    manualResponse?: { decision: "allow" | "deny" };
+    // Execution outcome from the legacy run, if any.
+    result?: { output: unknown; isError: boolean };
+    // Tool-role message content for this call (denial text fallback).
+    toolMessage?: string;
+}
+
+interface ModelCallPlan {
+    message: AssistantMessageT;
+    toolCalls: ToolCallPlan[];
+}
+
+interface TurnPlan {
+    input: UserMessageT;
+    ts: string;
+    modelCalls: ModelCallPlan[];
+}
+
+function isToolCallResultObject(value: unknown): value is { success?: boolean } {
+    return typeof value === "object" && value !== null;
+}
+
+function inferIsError(result: unknown): boolean {
+    if (isToolCallResultObject(result)) {
+        if (result.success === false) return true;
+        if ("error" in result && (result as { error?: unknown }).error) return true;
+    }
+    return false;
+}
+
+function modelDescriptor(start: StartT): ModelDescriptorT {
+    // The new ModelDescriptor keeps provider as the name and model as the full
+    // id (no "/" split) — same convention the live agent resolver writes.
+    return { provider: start.provider, model: start.model };
+}
+
+function titleFrom(input: UserMessageT): string | undefined {
+    const content = input.content;
+    let text: string | undefined;
+    if (typeof content === "string") {
+        text = content;
+    } else if (Array.isArray(content)) {
+        const firstText = content.find(
+            (p): p is { type: "text"; text: string } => p.type === "text",
+        );
+        text = firstText?.text;
+    }
+    if (!text) return undefined;
+    const trimmed = text.trim().replace(/\s+/g, " ");
+    if (!trimmed) return undefined;
+    return trimmed.length > 80 ? `${trimmed.slice(0, 77)}...` : trimmed;
+}
+
+// Group the run log into turns keyed off user-message boundaries, folding the
+// interleaved tool / permission events onto the tool-call parts they belong to.
+function planTurns(log: RunEventT[], start: StartT): TurnPlan[] {
+    const turns: TurnPlan[] = [];
+    let current: TurnPlan | undefined;
+    // Per-turn lookups keyed by toolCallId, resolved when we emit each call.
+    let byId: Map<string, ToolCallPlan> = new Map();
+
+    const ensureToolPlan = (toolCallId: string): ToolCallPlan | undefined =>
+        byId.get(toolCallId);
+
+    for (const event of log) {
+        switch (event.type) {
+            case "message": {
+                const msg = event.message;
+                if (msg.role === "user") {
+                    current = {
+                        input: msg,
+                        ts: event.ts ?? start.ts ?? new Date(0).toISOString(),
+                        modelCalls: [],
+                    };
+                    byId = new Map();
+                    turns.push(current);
+                } else if (msg.role === "assistant") {
+                    if (!current) break;
+                    const toolCalls: ToolCallPlan[] = [];
+                    const parts = Array.isArray(msg.content) ? msg.content : [];
+                    for (const part of parts) {
+                        if (part.type !== "tool-call") continue;
+                        const plan: ToolCallPlan = {
+                            toolCallId: part.toolCallId,
+                            toolName: part.toolName,
+                            input: part.arguments,
+                        };
+                        toolCalls.push(plan);
+                        byId.set(part.toolCallId, plan);
+                    }
+                    current.modelCalls.push({ message: msg, toolCalls });
+                } else if (msg.role === "tool") {
+                    const plan = current && ensureToolPlan(msg.toolCallId);
+                    if (plan) plan.toolMessage = msg.content;
+                }
+                break;
+            }
+            case "tool-result": {
+                if (!current || !event.toolCallId) break;
+                const plan = ensureToolPlan(event.toolCallId);
+                if (plan) {
+                    plan.result = {
+                        output: event.result ?? null,
+                        isError: inferIsError(event.result),
+                    };
+                }
+                break;
+            }
+            case "tool-permission-auto-decision": {
+                if (!current) break;
+                const plan = ensureToolPlan(event.toolCallId);
+                if (plan) {
+                    plan.autoDecision = {
+                        decision: event.decision,
+                        reason: event.reason,
+                        request: event.permission ?? event.toolCall,
+                    };
+                }
+                break;
+            }
+            case "tool-permission-request": {
+                if (!current) break;
+                const plan = ensureToolPlan(event.toolCall.toolCallId);
+                if (plan) {
+                    plan.manualRequest = {
+                        request: event.permission ?? event.toolCall,
+                    };
+                }
+                break;
+            }
+            case "tool-permission-response": {
+                if (!current) break;
+                const plan = ensureToolPlan(event.toolCallId);
+                if (plan) {
+                    plan.manualResponse = {
+                        decision: event.response === "approve" ? "allow" : "deny",
+                    };
+                }
+                break;
+            }
+            default:
+                // start, tool-invocation (input taken from the assistant part),
+                // llm-stream-event, run-processing-*, spawn-subflow, ask-human-*,
+                // code-* and error events do not contribute to the transcript.
+                break;
+        }
+    }
+
+    return turns;
+}
+
+// Resolve a tool call's permission story + terminal result into the ordered
+// list of new turn events. Throws (-> quarantine) if the run left the call
+// dangling (no result and no denial), which the reducer cannot represent.
+function toolEvents(
+    turnId: string,
+    ts: string,
+    plan: ToolCallPlan,
+): TurnEventT[] {
+    const events: TurnEventT[] = [];
+    const hasPermission =
+        plan.autoDecision || plan.manualRequest || plan.manualResponse;
+
+    let decision: "allow" | "deny" | undefined;
+    if (hasPermission) {
+        events.push({
+            type: "tool_permission_required",
+            turnId,
+            ts,
+            toolCallId: plan.toolCallId,
+            toolName: plan.toolName,
+            request: (plan.autoDecision?.request ??
+                plan.manualRequest?.request ??
+                {}) as unknown,
+        } as TurnEventT);
+        if (plan.autoDecision) {
+            events.push({
+                type: "tool_permission_classified",
+                turnId,
+                ts,
+                toolCallId: plan.toolCallId,
+                decision: plan.autoDecision.decision,
+                reason: plan.autoDecision.reason,
+            });
+        }
+        // A human response is the effective decision; otherwise the classifier's.
+        if (plan.manualResponse) {
+            decision = plan.manualResponse.decision;
+            events.push({
+                type: "tool_permission_resolved",
+                turnId,
+                ts,
+                toolCallId: plan.toolCallId,
+                decision,
+                source: "human",
+            });
+        } else if (plan.autoDecision) {
+            decision = plan.autoDecision.decision;
+            events.push({
+                type: "tool_permission_resolved",
+                turnId,
+                ts,
+                toolCallId: plan.toolCallId,
+                decision,
+                source: "classifier",
+                reason: plan.autoDecision.reason,
+            });
+        } else {
+            // Only a manual request, never answered — the run ended waiting.
+            throw new RunConversionError(
+                `tool call ${plan.toolCallId} has an unresolved permission request`,
+            );
+        }
+    }
+
+    if (decision === "deny") {
+        const denial =
+            plan.toolMessage ?? "Unable to execute this tool: Permission was denied";
+        events.push({
+            type: "tool_result",
+            turnId,
+            ts,
+            toolCallId: plan.toolCallId,
+            toolName: plan.toolName,
+            source: "runtime",
+            result: { output: denial, isError: true },
+        });
+        return events;
+    }
+
+    // Allowed (explicitly or by absence of a permission gate): the run must have
+    // recorded a terminal result, else the call is dangling and unrepresentable.
+    if (!plan.result) {
+        if (plan.toolMessage !== undefined) {
+            // Fall back to the tool-role message when the raw result event is
+            // missing (older logs).
+            events.push(
+                invocationEvent(turnId, ts, plan),
+                {
+                    type: "tool_result",
+                    turnId,
+                    ts,
+                    toolCallId: plan.toolCallId,
+                    toolName: plan.toolName,
+                    source: "sync",
+                    result: { output: plan.toolMessage, isError: false },
+                },
+            );
+            return events;
+        }
+        throw new RunConversionError(
+            `tool call ${plan.toolCallId} has no terminal result`,
+        );
+    }
+
+    events.push(invocationEvent(turnId, ts, plan), {
+        type: "tool_result",
+        turnId,
+        ts,
+        toolCallId: plan.toolCallId,
+        toolName: plan.toolName,
+        source: "sync",
+        result: {
+            output: (plan.result.output ?? null) as unknown,
+            isError: plan.result.isError,
+        },
+    } as TurnEventT);
+    return events;
+}
+
+function invocationEvent(
+    turnId: string,
+    ts: string,
+    plan: ToolCallPlan,
+): TurnEventT {
+    return {
+        type: "tool_invocation_requested",
+        turnId,
+        ts,
+        toolCallId: plan.toolCallId,
+        toolId: plan.toolName,
+        toolName: plan.toolName,
+        execution: "sync",
+        input: (plan.input ?? null) as unknown,
+    } as TurnEventT;
+}
+
+// Build one reduceTurn-legal turn log from a planned turn.
+function buildTurn(
+    turnId: string,
+    sessionId: string | null,
+    previousTurnId: string | null,
+    start: StartT,
+    plan: TurnPlan,
+): ConvertedTurn {
+    const ts = plan.ts;
+    const model = modelDescriptor(start);
+    const events: TurnEventT[] = [];
+
+    events.push({
+        type: "turn_created",
+        schemaVersion: 1,
+        turnId,
+        ts,
+        sessionId,
+        agent: {
+            requested: { agentId: start.agentName },
+            resolved: {
+                agentId: start.agentName,
+                systemPrompt: "",
+                model,
+                tools: [],
+            },
+        },
+        context: previousTurnId ? { previousTurnId } : [],
+        input: plan.input,
+        config: {
+            autoPermission: start.permissionMode === "auto",
+            humanAvailable: true,
+            maxModelCalls: Math.max(20, plan.modelCalls.length + 5),
+        },
+    });
+
+    if (plan.modelCalls.length === 0) {
+        throw new RunConversionError("turn has no assistant response");
+    }
+    const last = plan.modelCalls[plan.modelCalls.length - 1];
+    if (last.toolCalls.length > 0) {
+        // The final response still has open tool calls (interrupted run); the
+        // turn cannot be completed cleanly.
+        throw new RunConversionError("final model call has unresolved tool calls");
+    }
+
+    plan.modelCalls.forEach((call, index) => {
+        // Request references: only what is NEW since the previous model call.
+        let contextRef: { previousTurnId: string } | undefined;
+        let messages: string[];
+        if (index === 0) {
+            if (previousTurnId) {
+                contextRef = { previousTurnId };
+                messages = ["input"];
+            } else {
+                messages = ["input"];
+            }
+        } else {
+            const prev = plan.modelCalls[index - 1];
+            messages = [
+                assistantRef(index - 1),
+                ...prev.toolCalls.map((tc) => toolResultRef(tc.toolCallId)),
+            ];
+        }
+        events.push({
+            type: "model_call_requested",
+            turnId,
+            ts,
+            modelCallIndex: index,
+            request: {
+                ...(contextRef ? { contextRef } : {}),
+                messages,
+                parameters: {},
+            },
+        });
+        events.push({
+            type: "model_call_completed",
+            turnId,
+            ts,
+            modelCallIndex: index,
+            message: call.message,
+            finishReason: call.toolCalls.length > 0 ? "tool-calls" : "stop",
+            usage: {},
+        });
+        for (const tc of call.toolCalls) {
+            events.push(...toolEvents(turnId, ts, tc));
+        }
+    });
+
+    events.push({
+        type: "turn_completed",
+        turnId,
+        ts,
+        output: last.message,
+        finishReason: "stop",
+        usage: {},
+    });
+
+    // The definition of a well-formed migration: the reducer accepts it.
+    reduceTurn(events);
+    return { turnId, events };
+}
+
+// A copilot run's session turns get fresh ids derived from each initiating user
+// message id (unique, sortable, date-prefixed — satisfies the repo id regex).
+function turnIdFor(runId: string, index: number): string {
+    return `${runId}-t${String(index).padStart(3, "0")}`;
+}
+
+/**
+ * Convert one legacy run log into the new runtime shape. `runId` is the run's
+ * id (== the log's start.runId); pass it explicitly so the caller controls id
+ * preservation. Throws RunConversionError / TurnCorruptionError on anything the
+ * new reducers would reject.
+ */
+export function convertRun(log: RunEventT[], runId: string): ConvertResult {
+    const first = log[0];
+    if (!first || first.type !== "start") {
+        throw new RunConversionError("run log does not begin with a start event");
+    }
+    const start = first as StartT;
+    const useCase: z.infer<typeof UseCase> | undefined = start.useCase;
+
+    const plans = planTurns(log, start);
+    if (plans.length === 0) {
+        throw new RunConversionError("run has no user messages");
+    }
+
+    if (useCase === "copilot_chat") {
+        // Session id reuses the original runId; turns get derived ids.
+        const sessionId = runId;
+        const turns: ConvertedTurn[] = [];
+        const sessionEvents: SessionEventT[] = [];
+        const title = titleFrom(plans[0].input);
+        sessionEvents.push({
+            type: "session_created",
+            schemaVersion: 1,
+            sessionId,
+            ts: plans[0].ts,
+            ...(title ? { title } : {}),
+        });
+        let previousTurnId: string | null = null;
+        plans.forEach((plan, i) => {
+            const turnId = turnIdFor(runId, i);
+            const turn = buildTurn(turnId, sessionId, previousTurnId, start, plan);
+            turns.push(turn);
+            sessionEvents.push({
+                type: "turn_appended",
+                sessionId,
+                ts: plan.ts,
+                turnId,
+                sessionSeq: i + 1,
+                agentId: start.agentName,
+                model: modelDescriptor(start),
+            });
+            previousTurnId = turnId;
+        });
+        reduceSession(sessionEvents);
+        return {
+            session: { sessionId, events: sessionEvents },
+            turns,
+            isSession: true,
+        };
+    }
+
+    // Non-copilot: a single standalone turn whose id IS the runId.
+    if (plans.length > 1) {
+        throw new RunConversionError(
+            `non-copilot run has ${plans.length} user messages; expected a single turn`,
+        );
+    }
+    const turn = buildTurn(runId, null, null, start, plans[0]);
+    return { turns: [turn], isSession: false };
+}
diff --git a/apps/x/packages/core/src/migrations/runs/migrate.test.ts b/apps/x/packages/core/src/migrations/runs/migrate.test.ts
new file mode 100644
index 00000000..c28440ac
--- /dev/null
+++ b/apps/x/packages/core/src/migrations/runs/migrate.test.ts
@@ -0,0 +1,191 @@
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { reduceTurn } from "@x/shared/dist/turns.js";
+import { reduceSession } from "@x/shared/dist/sessions.js";
+import { FSTurnRepo } from "../../turns/fs-repo.js";
+import { FSSessionRepo } from "../../sessions/fs-repo.js";
+import { migrateRuns } from "./migrate.js";
+
+const fixturesDir = path.join(
+    path.dirname(fileURLToPath(import.meta.url)),
+    "__fixtures__",
+);
+
+let tmp: string;
+let runsDir: string;
+let turnsRootDir: string;
+let sessionsRootDir: string;
+let archiveDir: string;
+let logFile: string;
+
+function deps() {
+    return {
+        runsDir,
+        turnsRootDir,
+        sessionsRootDir,
+        archiveDir,
+        logFile,
+        now: () => "2026-07-02T00:00:00.000Z",
+        logger: () => undefined,
+    };
+}
+
+function copyFixture(name: string, targetName?: string): string {
+    const dest = path.join(runsDir, targetName ?? name);
+    fs.copyFileSync(path.join(fixturesDir, name), dest);
+    return dest;
+}
+
+// Turn/session files nest under YYYY/MM/DD; find one by id anywhere in a tree.
+function findFile(root: string, id: string): string | undefined {
+    const want = `${id}.jsonl`;
+    const walk = (dir: string): string | undefined => {
+        let entries: fs.Dirent[];
+        try {
+            entries = fs.readdirSync(dir, { withFileTypes: true });
+        } catch {
+            return undefined;
+        }
+        for (const entry of entries) {
+            const full = path.join(dir, entry.name);
+            if (entry.isDirectory()) {
+                const hit = walk(full);
+                if (hit) return hit;
+            } else if (entry.name === want) {
+                return full;
+            }
+        }
+        return undefined;
+    };
+    return walk(root);
+}
+
+beforeEach(() => {
+    tmp = fs.mkdtempSync(path.join(os.tmpdir(), "runs-migration-"));
+    runsDir = path.join(tmp, "runs");
+    turnsRootDir = path.join(tmp, "storage", "turns");
+    sessionsRootDir = path.join(tmp, "storage", "sessions");
+    archiveDir = path.join(tmp, "runs-archive");
+    logFile = path.join(tmp, "config", "runs-migration.json");
+    fs.mkdirSync(runsDir, { recursive: true });
+});
+
+afterEach(() => {
+    fs.rmSync(tmp, { recursive: true, force: true });
+});
+
+describe("migrateRuns", () => {
+    it("migrates a non-copilot run to a standalone turn keyed by the runId, and archives the source", () => {
+        copyFixture("knowledge-single-turn.jsonl");
+        const runId = "2026-07-02T15-26-22Z-0011690-000";
+
+        const summary = migrateRuns(deps());
+
+        expect(summary.scanned).toBe(1);
+        expect(summary.migratedTurns).toBe(1);
+        expect(summary.migratedSessions).toBe(0);
+        expect(summary.failed).toHaveLength(0);
+        // Turn file exists at the runId; no session written.
+        expect(findFile(turnsRootDir, runId)).toBeDefined();
+        expect(fs.existsSync(sessionsRootDir)).toBe(false);
+        // Source archived out of the scan dir.
+        expect(fs.existsSync(path.join(runsDir, "knowledge-single-turn.jsonl"))).toBe(
+            false,
+        );
+        expect(
+            fs.existsSync(path.join(archiveDir, "knowledge-single-turn.jsonl")),
+        ).toBe(true);
+    });
+
+    it("migrates a copilot run to a session + turns", () => {
+        copyFixture("copilot-multi-turn.jsonl");
+        const runId = "2026-07-02T15-27-08Z-0011690-000";
+
+        const summary = migrateRuns(deps());
+
+        expect(summary.migratedSessions).toBe(1);
+        expect(summary.migratedTurns).toBe(3);
+        expect(findFile(sessionsRootDir, runId)).toBeDefined();
+        expect(findFile(turnsRootDir, `${runId}-t000`)).toBeDefined();
+        expect(findFile(turnsRootDir, `${runId}-t002`)).toBeDefined();
+    });
+
+    it("writes files the real FS repos can read back and reduce", async () => {
+        copyFixture("copilot-multi-turn.jsonl");
+        const runId = "2026-07-02T15-27-08Z-0011690-000";
+        migrateRuns(deps());
+
+        const turnRepo = new FSTurnRepo({ turnsRootDir });
+        const sessionRepo = new FSSessionRepo({ sessionsRootDir });
+
+        // The app's actual read path: repo.read (strict trailing-newline + id
+        // checks) then reduce.
+        const sessionEvents = await sessionRepo.read(runId);
+        const sessionState = reduceSession(sessionEvents);
+        expect(sessionState.turns).toHaveLength(3);
+
+        const turnEvents = await turnRepo.read(`${runId}-t000`);
+        const turnState = reduceTurn(turnEvents);
+        expect(turnState.terminal?.type).toBe("turn_completed");
+    });
+
+    it("skips code_session runs and leaves them in place", () => {
+        // Rewrite a fixture's useCase to code_session.
+        const raw = fs
+            .readFileSync(path.join(fixturesDir, "knowledge-single-turn.jsonl"), "utf-8")
+            .split("\n")
+            .filter((l) => l.trim());
+        const start = JSON.parse(raw[0]);
+        start.useCase = "code_session";
+        raw[0] = JSON.stringify(start);
+        fs.writeFileSync(path.join(runsDir, "code.jsonl"), raw.join("\n") + "\n");
+
+        const summary = migrateRuns(deps());
+
+        expect(summary.skipped).toBe(1);
+        expect(summary.migratedTurns).toBe(0);
+        // Left in place, not archived.
+        expect(fs.existsSync(path.join(runsDir, "code.jsonl"))).toBe(true);
+        expect(fs.existsSync(path.join(archiveDir, "code.jsonl"))).toBe(false);
+    });
+
+    it("leaves a malformed run in place and records the failure", () => {
+        fs.writeFileSync(path.join(runsDir, "broken.jsonl"), "not json\n");
+
+        const summary = migrateRuns(deps());
+
+        expect(summary.failed).toHaveLength(1);
+        expect(summary.failed[0].file).toBe("broken.jsonl");
+        expect(fs.existsSync(path.join(runsDir, "broken.jsonl"))).toBe(true);
+    });
+
+    it("is idempotent — a second pass finds nothing left to migrate", () => {
+        copyFixture("background-task.jsonl");
+
+        const first = migrateRuns(deps());
+        expect(first.migratedTurns).toBe(1);
+
+        const second = migrateRuns(deps());
+        expect(second.scanned).toBe(0);
+        expect(second.migratedTurns).toBe(0);
+    });
+
+    it("writes a migration log with counts", () => {
+        copyFixture("copilot-brew-deny.jsonl");
+        migrateRuns(deps());
+
+        expect(fs.existsSync(logFile)).toBe(true);
+        const parsed = JSON.parse(fs.readFileSync(logFile, "utf-8"));
+        expect(parsed.ranAt).toBe("2026-07-02T00:00:00.000Z");
+        expect(parsed.migratedSessions).toBe(1);
+    });
+
+    it("does nothing gracefully when the runs dir is absent", () => {
+        fs.rmSync(runsDir, { recursive: true, force: true });
+        const summary = migrateRuns(deps());
+        expect(summary.scanned).toBe(0);
+    });
+});
diff --git a/apps/x/packages/core/src/migrations/runs/migrate.ts b/apps/x/packages/core/src/migrations/runs/migrate.ts
new file mode 100644
index 00000000..4fbe5dcc
--- /dev/null
+++ b/apps/x/packages/core/src/migrations/runs/migrate.ts
@@ -0,0 +1,165 @@
+import fs from "node:fs";
+import path from "node:path";
+import { z } from "zod";
+import { WorkDir } from "../../config/config.js";
+import { RunEvent } from "@x/shared/dist/runs.js";
+import { TurnEvent } from "@x/shared/dist/turns.js";
+import { SessionEvent } from "@x/shared/dist/sessions.js";
+import { convertRun } from "./convert.js";
+
+// One-time migration that ports legacy `runs/<runId>.jsonl` logs into the new
+// turn/session runtime at startup. Runs before the session index is built.
+//
+// Design (see convert.ts for the mapping):
+//   - Successfully migrated runs are MOVED to `runs-archive/`. That move is the
+//     idempotency guard — migrated files leave the scan directory, so a re-run
+//     never re-processes them and no separate marker is needed.
+//   - Any run that fails to convert is LEFT in `runs/` (still served by the
+//     `runs:fetch` fallback the history views keep) and retried next launch.
+//   - code_session runs are skipped and left in place — Code mode still uses
+//     the old runtime, so those files must stay.
+// Every step is defensive; a bad run (or the whole pass) never blocks boot.
+
+const ID_PATTERN = /^(\d{4})-(\d{2})-(\d{2})T[A-Za-z0-9-]+$/;
+
+export interface MigrateRunsDeps {
+    runsDir?: string;
+    turnsRootDir?: string;
+    sessionsRootDir?: string;
+    archiveDir?: string;
+    logFile?: string;
+    now?: () => string;
+    logger?: (message: string) => void;
+}
+
+export interface MigrationSummary {
+    scanned: number;
+    migratedSessions: number;
+    migratedTurns: number;
+    skipped: number;
+    failed: Array<{ file: string; error: string }>;
+}
+
+function idPath(rootDir: string, id: string): string {
+    const match = ID_PATTERN.exec(id);
+    if (!match) throw new Error(`invalid id: ${id}`);
+    const [, year, month, day] = match;
+    return path.join(rootDir, year, month, day, `${id}.jsonl`);
+}
+
+// Mirrors the FS repos' serialization: revalidate each event, one JSON object
+// per line, trailing newline. Overwrites any existing target so a re-run after
+// a mid-migration crash converges cleanly (historical ids never collide with
+// live turns, whose ids are minted from the current clock).
+function writeJsonl<T>(
+    rootDir: string,
+    id: string,
+    events: T[],
+    schema: z.ZodType<T>,
+): void {
+    const file = idPath(rootDir, id);
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    const payload =
+        events.map((event) => JSON.stringify(schema.parse(event))).join("\n") +
+        "\n";
+    fs.writeFileSync(file, payload);
+}
+
+export function migrateRuns(deps: MigrateRunsDeps = {}): MigrationSummary {
+    const runsDir = deps.runsDir ?? path.join(WorkDir, "runs");
+    const turnsRootDir =
+        deps.turnsRootDir ?? path.join(WorkDir, "storage", "turns");
+    const sessionsRootDir =
+        deps.sessionsRootDir ?? path.join(WorkDir, "storage", "sessions");
+    const archiveDir = deps.archiveDir ?? path.join(WorkDir, "runs-archive");
+    const logFile =
+        deps.logFile ?? path.join(WorkDir, "config", "runs-migration.json");
+    const log =
+        deps.logger ?? ((message: string) => console.log(`[runs-migration] ${message}`));
+
+    const summary: MigrationSummary = {
+        scanned: 0,
+        migratedSessions: 0,
+        migratedTurns: 0,
+        skipped: 0,
+        failed: [],
+    };
+
+    let files: string[];
+    try {
+        files = fs
+            .readdirSync(runsDir)
+            .filter((name) => name.endsWith(".jsonl"))
+            .sort();
+    } catch {
+        // No runs directory — nothing to migrate.
+        return summary;
+    }
+
+    for (const file of files) {
+        summary.scanned++;
+        const source = path.join(runsDir, file);
+        try {
+            const raw = fs.readFileSync(source, "utf-8");
+            const logEvents = raw
+                .split("\n")
+                .filter((line) => line.trim().length > 0)
+                .map((line) => RunEvent.parse(JSON.parse(line)));
+
+            const start = logEvents[0];
+            if (!start || start.type !== "start") {
+                throw new Error("run log does not begin with a start event");
+            }
+            if (start.useCase === "code_session") {
+                // Code mode still uses the old runtime; leave the file in place.
+                summary.skipped++;
+                continue;
+            }
+
+            const result = convertRun(logEvents, start.runId);
+            for (const turn of result.turns) {
+                writeJsonl(turnsRootDir, turn.turnId, turn.events, TurnEvent);
+            }
+            if (result.session) {
+                writeJsonl(
+                    sessionsRootDir,
+                    result.session.sessionId,
+                    result.session.events,
+                    SessionEvent,
+                );
+            }
+
+            // Success — archive the original out of the scan directory.
+            fs.mkdirSync(archiveDir, { recursive: true });
+            fs.renameSync(source, path.join(archiveDir, file));
+
+            if (result.isSession) summary.migratedSessions++;
+            summary.migratedTurns += result.turns.length;
+        } catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            summary.failed.push({ file, error: message });
+            log(`failed to migrate ${file}: ${message}`);
+        }
+    }
+
+    try {
+        fs.mkdirSync(path.dirname(logFile), { recursive: true });
+        fs.writeFileSync(
+            logFile,
+            JSON.stringify(
+                { ranAt: deps.now?.() ?? new Date().toISOString(), ...summary },
+                null,
+                2,
+            ),
+        );
+    } catch {
+        // Observability only; never fatal.
+    }
+
+    log(
+        `scanned ${summary.scanned}, sessions ${summary.migratedSessions}, ` +
+            `turns ${summary.migratedTurns}, skipped ${summary.skipped}, ` +
+            `failed ${summary.failed.length}`,
+    );
+    return summary;
+}
diff --git a/apps/x/packages/core/src/models/default-model-resolver.ts b/apps/x/packages/core/src/models/default-model-resolver.ts
new file mode 100644
index 00000000..dff99247
--- /dev/null
+++ b/apps/x/packages/core/src/models/default-model-resolver.ts
@@ -0,0 +1,11 @@
+import { getDefaultModelAndProvider } from "./defaults.js";
+
+export interface IDefaultModelResolver {
+    resolve(): Promise<{ model: string; provider: string }>;
+}
+
+export class DefaultModelResolver implements IDefaultModelResolver {
+    resolve(): Promise<{ model: string; provider: string }> {
+        return getDefaultModelAndProvider();
+    }
+}
diff --git a/apps/x/packages/core/src/pre_built/runner.ts b/apps/x/packages/core/src/pre_built/runner.ts
index 0596372f..19414cc3 100644
--- a/apps/x/packages/core/src/pre_built/runner.ts
+++ b/apps/x/packages/core/src/pre_built/runner.ts
@@ -1,9 +1,8 @@
 import fs from 'fs';
 import path from 'path';
 import { WorkDir } from '../config/config.js';
-import { createRun, createMessage } from '../runs/runs.js';
+import { runHeadlessAgent } from '../agents/headless-app.js';
 import { getKgModel } from '../models/defaults.js';
-import { waitForRunCompletion } from '../agents/utils.js';
 import {
     loadConfig,
     loadState,
@@ -38,15 +37,6 @@ async function runAgent(agentName: string): Promise<void> {
     }
 
     try {
-        // Create a run for the agent
-        // The agent file is expected to be in the agents directory with the same name
-        const run = await createRun({
-            agentId: agentName,
-            model: await getKgModel(),
-            useCase: 'knowledge_sync',
-            subUseCase: 'pre_built',
-        });
-
         // Build trigger message with user context
         const message = `Run your scheduled task.
 
@@ -59,10 +49,14 @@ async function runAgent(agentName: string): Promise<void> {
 
 Process new items and use the user context above to identify yourself when drafting responses.`;
 
-        await createMessage(run.id, message);
-
-        // Wait for completion
-        await waitForRunCompletion(run.id);
+        // The agent file is expected to be in the agents directory with
+        // the same name. Waits for the turn to settle (errors tolerated,
+        // matching the old no-throwOnError wait).
+        await runHeadlessAgent({
+            agentId: agentName,
+            message,
+            model: await getKgModel(),
+        });
 
         // Update last run time
         setLastRunTime(agentName, new Date());
diff --git a/apps/x/packages/core/src/sessions/api.ts b/apps/x/packages/core/src/sessions/api.ts
new file mode 100644
index 00000000..7f787b49
--- /dev/null
+++ b/apps/x/packages/core/src/sessions/api.ts
@@ -0,0 +1,79 @@
+import type { z } from "zod";
+import type { UserMessage } from "@x/shared/dist/message.js";
+import type {
+    SessionIndexEntry,
+    SessionState,
+} from "@x/shared/dist/sessions.js";
+import type {
+    JsonValue,
+    RequestedAgent,
+    ToolResultData,
+} from "@x/shared/dist/turns.js";
+import type { Turn } from "../turns/api.js";
+
+// Per-message configuration; it lands on the turn (sessions store none).
+export interface SendMessageConfig {
+    agent: z.infer<typeof RequestedAgent>;
+    autoPermission?: boolean;
+    maxModelCalls?: number;
+}
+
+export interface ISessions {
+    // Startup scan: builds the in-memory index from session files (reading
+    // each session's latest turn for status). Must run before listSessions.
+    initialize(): Promise<void>;
+
+    createSession(input?: { title?: string }): Promise<string>;
+    listSessions(): SessionIndexEntry[];
+    getSession(sessionId: string): Promise<SessionState>;
+    getTurn(turnId: string): Promise<Turn>;
+
+    // Rejects with TurnNotSettledError while the latest turn is non-terminal.
+    // Returns as soon as the turn is created, referenced, and advancing;
+    // progress flows through the bus.
+    sendMessage(
+        sessionId: string,
+        input: z.infer<typeof UserMessage>,
+        config: SendMessageConfig,
+    ): Promise<{ turnId: string }>;
+
+    // External inputs, one advanceTurn each. These settle with that
+    // invocation's outcome; turn-runtime input rejections pass through.
+    respondToPermission(
+        turnId: string,
+        toolCallId: string,
+        decision: "allow" | "deny",
+        metadata?: JsonValue,
+    ): Promise<void>;
+    // The dedicated ask-human endpoint; sendMessage never routes here.
+    respondToAskHuman(
+        turnId: string,
+        toolCallId: string,
+        answer: string,
+    ): Promise<void>;
+    deliverAsyncToolResult(
+        turnId: string,
+        toolCallId: string,
+        result: z.infer<typeof ToolResultData>,
+    ): Promise<void>;
+
+    stopTurn(turnId: string, reason?: string): Promise<void>;
+    // Recovery entry for turns left idle by a crash; runs in the background.
+    resumeTurn(sessionId: string): Promise<void>;
+
+    setTitle(sessionId: string, title: string): Promise<void>;
+    deleteSession(sessionId: string): Promise<void>;
+}
+
+export class TurnNotSettledError extends Error {
+    constructor(
+        readonly sessionId: string,
+        readonly turnId: string,
+        readonly turnStatus: string,
+    ) {
+        super(
+            `session ${sessionId} has a non-terminal turn ${turnId} (${turnStatus})`,
+        );
+        this.name = "TurnNotSettledError";
+    }
+}
diff --git a/apps/x/packages/core/src/sessions/bus.ts b/apps/x/packages/core/src/sessions/bus.ts
new file mode 100644
index 00000000..02fe25a6
--- /dev/null
+++ b/apps/x/packages/core/src/sessions/bus.ts
@@ -0,0 +1,28 @@
+import type { SessionBusEvent } from "@x/shared/dist/sessions.js";
+
+// Ephemeral fan-out toward the renderer (bridged over IPC in the app layer).
+// Publishing is fire-and-forget; nothing durable depends on delivery.
+export interface ISessionBus {
+    publish(event: SessionBusEvent): void;
+}
+
+// Default in-process fan-out; the app layer subscribes and forwards over IPC.
+// Listener errors are swallowed: observers must never affect sessions.
+export class EmitterSessionBus implements ISessionBus {
+    private listeners = new Set<(event: SessionBusEvent) => void>();
+
+    publish(event: SessionBusEvent): void {
+        for (const listener of this.listeners) {
+            try {
+                listener(event);
+            } catch {
+                // observational only
+            }
+        }
+    }
+
+    subscribe(listener: (event: SessionBusEvent) => void): () => void {
+        this.listeners.add(listener);
+        return () => this.listeners.delete(listener);
+    }
+}
diff --git a/apps/x/packages/core/src/sessions/fs-repo.test.ts b/apps/x/packages/core/src/sessions/fs-repo.test.ts
new file mode 100644
index 00000000..dc85993d
--- /dev/null
+++ b/apps/x/packages/core/src/sessions/fs-repo.test.ts
@@ -0,0 +1,108 @@
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import type { z } from "zod";
+import {
+    SessionCorruptionError,
+    type SessionCreated,
+    type SessionEvent,
+} from "@x/shared/dist/sessions.js";
+import { FSSessionRepo } from "./fs-repo.js";
+
+const S1 = "2026-07-02T09-00-00Z-0000001-000";
+const S2 = "2026-07-03T09-00-00Z-0000002-000";
+
+function created(sessionId = S1): z.infer<typeof SessionCreated> {
+    return {
+        type: "session_created",
+        schemaVersion: 1,
+        sessionId,
+        ts: "2026-07-02T09:00:00Z",
+        title: "T",
+    };
+}
+
+function appended(sessionId = S1): z.infer<typeof SessionEvent> {
+    return {
+        type: "turn_appended",
+        sessionId,
+        ts: "2026-07-02T09:01:00Z",
+        turnId: "turn-1",
+        sessionSeq: 1,
+        agentId: "copilot",
+        model: { provider: "fake", model: "m" },
+    };
+}
+
+describe("FSSessionRepo", () => {
+    let root: string;
+    let repo: FSSessionRepo;
+
+    beforeEach(async () => {
+        root = await fs.mkdtemp(path.join(os.tmpdir(), "session-repo-"));
+        repo = new FSSessionRepo({ sessionsRootDir: root });
+    });
+
+    afterEach(async () => {
+        await fs.rm(root, { recursive: true, force: true });
+    });
+
+    it("creates date-partitioned files and round-trips events", async () => {
+        await repo.create(created());
+        await repo.append(S1, [appended()]);
+        const file = path.join(root, "2026", "07", "02", `${S1}.jsonl`);
+        await fs.access(file);
+        const events = await repo.read(S1);
+        expect(events.map((e) => e.type)).toEqual([
+            "session_created",
+            "turn_appended",
+        ]);
+    });
+
+    it("rejects malformed and path-like session ids", async () => {
+        for (const bad of ["../evil", "a/b", "nope", ""]) {
+            await expect(repo.read(bad)).rejects.toThrowError(/invalid session id/);
+        }
+    });
+
+    it("create fails if the session exists; append fails if it doesn't", async () => {
+        await repo.create(created());
+        await expect(repo.create(created())).rejects.toThrowError();
+        await expect(repo.append(S2, [appended(S2)])).rejects.toThrowError(
+            /session not found/,
+        );
+    });
+
+    it("read rejects corrupt files whole", async () => {
+        const file = path.join(root, "2026", "07", "02", `${S1}.jsonl`);
+        await fs.mkdir(path.dirname(file), { recursive: true });
+        await fs.writeFile(file, `${JSON.stringify(created())}\nnot json\n`);
+        await expect(repo.read(S1)).rejects.toThrowError(SessionCorruptionError);
+        await fs.writeFile(file, `${JSON.stringify(created())}\n{"torn`);
+        await expect(repo.read(S1)).rejects.toThrowError(
+            /does not end with a complete line/,
+        );
+    });
+
+    it("lists session ids across date partitions", async () => {
+        await repo.create(created(S1));
+        await repo.create(created(S2));
+        expect(await repo.listSessionIds()).toEqual([S1, S2]);
+    });
+
+    it("listing an empty root returns no ids", async () => {
+        const empty = new FSSessionRepo({
+            sessionsRootDir: path.join(root, "missing"),
+        });
+        expect(await empty.listSessionIds()).toEqual([]);
+    });
+
+    it("delete removes the file only; deleting a missing session throws", async () => {
+        await repo.create(created(S1));
+        await repo.create(created(S2));
+        await repo.delete(S1);
+        expect(await repo.listSessionIds()).toEqual([S2]);
+        await expect(repo.delete(S1)).rejects.toThrowError(/session not found/);
+    });
+});
diff --git a/apps/x/packages/core/src/sessions/fs-repo.ts b/apps/x/packages/core/src/sessions/fs-repo.ts
new file mode 100644
index 00000000..63eccecd
--- /dev/null
+++ b/apps/x/packages/core/src/sessions/fs-repo.ts
@@ -0,0 +1,149 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { z } from "zod";
+import {
+    SessionCorruptionError,
+    SessionCreated,
+    SessionEvent,
+} from "@x/shared/dist/sessions.js";
+import { KeyedMutex } from "../turns/keyed-mutex.js";
+import type { ISessionRepo } from "./repo.js";
+
+// Session IDs come from the same generator as turn IDs.
+const SESSION_ID_PATTERN = /^(\d{4})-(\d{2})-(\d{2})T[A-Za-z0-9-]+$/;
+
+export class FSSessionRepo implements ISessionRepo {
+    private readonly rootDir: string;
+    private readonly mutex = new KeyedMutex();
+
+    constructor({ sessionsRootDir }: { sessionsRootDir: string }) {
+        this.rootDir = sessionsRootDir;
+    }
+
+    private filePath(sessionId: string): string {
+        const match = SESSION_ID_PATTERN.exec(sessionId);
+        if (!match) {
+            throw new Error(`invalid session id: ${sessionId}`);
+        }
+        const [, year, month, day] = match;
+        return path.join(this.rootDir, year, month, day, `${sessionId}.jsonl`);
+    }
+
+    private serialize(
+        sessionId: string,
+        events: Array<z.infer<typeof SessionEvent>>,
+    ): string {
+        let payload = "";
+        for (const event of events) {
+            const parsed = SessionEvent.parse(event);
+            if (parsed.sessionId !== sessionId) {
+                throw new Error(
+                    `event sessionId ${parsed.sessionId} does not match ${sessionId}`,
+                );
+            }
+            payload += `${JSON.stringify(parsed)}\n`;
+        }
+        return payload;
+    }
+
+    async create(event: z.infer<typeof SessionCreated>): Promise<void> {
+        const parsed = SessionCreated.parse(event);
+        const file = this.filePath(parsed.sessionId);
+        await fs.mkdir(path.dirname(file), { recursive: true });
+        await fs.writeFile(file, this.serialize(parsed.sessionId, [parsed]), {
+            flag: "wx",
+        });
+    }
+
+    async read(sessionId: string): Promise<Array<z.infer<typeof SessionEvent>>> {
+        const file = this.filePath(sessionId);
+        let raw: string;
+        try {
+            raw = await fs.readFile(file, "utf8");
+        } catch (error) {
+            if ((error as NodeJS.ErrnoException).code === "ENOENT") {
+                throw new Error(`session not found: ${sessionId}`);
+            }
+            throw error;
+        }
+        if (raw.length === 0) {
+            throw new SessionCorruptionError(`session file is empty: ${sessionId}`);
+        }
+        const lines = raw.split("\n");
+        const trailing = lines.pop();
+        if (trailing !== "") {
+            throw new SessionCorruptionError(
+                `session file does not end with a complete line: ${sessionId}`,
+            );
+        }
+        const events: Array<z.infer<typeof SessionEvent>> = [];
+        for (const [index, line] of lines.entries()) {
+            let parsed: z.infer<typeof SessionEvent>;
+            try {
+                parsed = SessionEvent.parse(JSON.parse(line));
+            } catch (error) {
+                throw new SessionCorruptionError(
+                    `malformed session event at ${sessionId}:${index + 1}: ${String(
+                        error instanceof Error ? error.message : error,
+                    )}`,
+                );
+            }
+            if (parsed.sessionId !== sessionId) {
+                throw new SessionCorruptionError(
+                    `event sessionId ${parsed.sessionId} does not match file ${sessionId}`,
+                );
+            }
+            events.push(parsed);
+        }
+        return events;
+    }
+
+    async append(
+        sessionId: string,
+        events: Array<z.infer<typeof SessionEvent>>,
+    ): Promise<void> {
+        if (events.length === 0) {
+            return;
+        }
+        const payload = this.serialize(sessionId, events);
+        const file = this.filePath(sessionId);
+        try {
+            await fs.access(file);
+        } catch {
+            throw new Error(`session not found: ${sessionId}`);
+        }
+        await fs.appendFile(file, payload);
+    }
+
+    async withLock<T>(sessionId: string, fn: () => Promise<T>): Promise<T> {
+        return this.mutex.run(sessionId, fn);
+    }
+
+    async listSessionIds(): Promise<string[]> {
+        let names: string[];
+        try {
+            names = (await fs.readdir(this.rootDir, { recursive: true })) as string[];
+        } catch (error) {
+            if ((error as NodeJS.ErrnoException).code === "ENOENT") {
+                return [];
+            }
+            throw error;
+        }
+        return names
+            .filter((name) => name.endsWith(".jsonl"))
+            .map((name) => path.basename(name, ".jsonl"))
+            .sort();
+    }
+
+    async delete(sessionId: string): Promise<void> {
+        const file = this.filePath(sessionId);
+        try {
+            await fs.unlink(file);
+        } catch (error) {
+            if ((error as NodeJS.ErrnoException).code === "ENOENT") {
+                throw new Error(`session not found: ${sessionId}`);
+            }
+            throw error;
+        }
+    }
+}
diff --git a/apps/x/packages/core/src/sessions/headless.ts b/apps/x/packages/core/src/sessions/headless.ts
new file mode 100644
index 00000000..071d7fd4
--- /dev/null
+++ b/apps/x/packages/core/src/sessions/headless.ts
@@ -0,0 +1,41 @@
+import type { z } from "zod";
+import type { UserMessage } from "@x/shared/dist/message.js";
+import type {
+    ConversationMessage,
+    RequestedAgent,
+} from "@x/shared/dist/turns.js";
+import type { ITurnRuntime, TurnOutcome } from "../turns/api.js";
+
+// Standalone turns for non-session callers (background tasks, live notes,
+// knowledge pipelines, scheduled agents): sessionId null, automatic
+// permissions, no human. Never appears in the session index; callers keep
+// the turnId if they need history.
+export async function runHeadlessTurn(
+    turnRuntime: ITurnRuntime,
+    input: {
+        agent: z.infer<typeof RequestedAgent>;
+        context?: Array<z.infer<typeof ConversationMessage>>;
+        input: z.infer<typeof UserMessage>;
+        maxModelCalls?: number;
+        signal?: AbortSignal;
+    },
+): Promise<{ turnId: string; outcome: TurnOutcome }> {
+    const turnId = await turnRuntime.createTurn({
+        agent: input.agent,
+        sessionId: null,
+        context: input.context ?? [],
+        input: input.input,
+        config: {
+            autoPermission: true,
+            humanAvailable: false,
+            ...(input.maxModelCalls === undefined
+                ? {}
+                : { maxModelCalls: input.maxModelCalls }),
+        },
+    });
+    const execution = turnRuntime.advanceTurn(turnId, undefined, {
+        signal: input.signal,
+    });
+    const outcome = await execution.outcome;
+    return { turnId, outcome };
+}
diff --git a/apps/x/packages/core/src/sessions/in-memory-session-repo.ts b/apps/x/packages/core/src/sessions/in-memory-session-repo.ts
new file mode 100644
index 00000000..35c54765
--- /dev/null
+++ b/apps/x/packages/core/src/sessions/in-memory-session-repo.ts
@@ -0,0 +1,83 @@
+import { z } from "zod";
+import {
+    SessionCorruptionError,
+    SessionCreated,
+    SessionEvent,
+} from "@x/shared/dist/sessions.js";
+import { KeyedMutex } from "../turns/keyed-mutex.js";
+import type { ISessionRepo } from "./repo.js";
+
+// Test fake mirroring FSSessionRepo semantics without touching disk.
+export class InMemorySessionRepo implements ISessionRepo {
+    private files = new Map<string, Array<z.infer<typeof SessionEvent>>>();
+    private corrupt = new Set<string>();
+    private mutex = new KeyedMutex();
+
+    async create(event: z.infer<typeof SessionCreated>): Promise<void> {
+        const parsed = SessionCreated.parse(event);
+        if (this.files.has(parsed.sessionId) || this.corrupt.has(parsed.sessionId)) {
+            throw new Error(`session already exists: ${parsed.sessionId}`);
+        }
+        this.files.set(parsed.sessionId, [structuredClone(parsed)]);
+    }
+
+    async read(sessionId: string): Promise<Array<z.infer<typeof SessionEvent>>> {
+        if (this.corrupt.has(sessionId)) {
+            throw new SessionCorruptionError(`session file is corrupt: ${sessionId}`);
+        }
+        const events = this.files.get(sessionId);
+        if (!events) {
+            throw new Error(`session not found: ${sessionId}`);
+        }
+        return structuredClone(events);
+    }
+
+    async append(
+        sessionId: string,
+        events: Array<z.infer<typeof SessionEvent>>,
+    ): Promise<void> {
+        const file = this.files.get(sessionId);
+        if (!file) {
+            throw new Error(`session not found: ${sessionId}`);
+        }
+        for (const event of events) {
+            const parsed = SessionEvent.parse(event);
+            if (parsed.sessionId !== sessionId) {
+                throw new Error(
+                    `event sessionId ${parsed.sessionId} does not match ${sessionId}`,
+                );
+            }
+            file.push(structuredClone(parsed));
+        }
+    }
+
+    async withLock<T>(sessionId: string, fn: () => Promise<T>): Promise<T> {
+        return this.mutex.run(sessionId, fn);
+    }
+
+    async listSessionIds(): Promise<string[]> {
+        return [...this.files.keys(), ...this.corrupt].sort();
+    }
+
+    async delete(sessionId: string): Promise<void> {
+        const existed = this.files.delete(sessionId) || this.corrupt.delete(sessionId);
+        if (!existed) {
+            throw new Error(`session not found: ${sessionId}`);
+        }
+    }
+
+    // Test helpers
+    seed(events: Array<z.infer<typeof SessionEvent>>): void {
+        if (events.length === 0) {
+            throw new Error("cannot seed an empty log");
+        }
+        this.files.set(
+            events[0].sessionId,
+            events.map((e) => structuredClone(SessionEvent.parse(e))),
+        );
+    }
+
+    seedCorrupt(sessionId: string): void {
+        this.corrupt.add(sessionId);
+    }
+}
diff --git a/apps/x/packages/core/src/sessions/index.ts b/apps/x/packages/core/src/sessions/index.ts
new file mode 100644
index 00000000..df906d01
--- /dev/null
+++ b/apps/x/packages/core/src/sessions/index.ts
@@ -0,0 +1,8 @@
+export * from "./api.js";
+export * from "./bus.js";
+export * from "./fs-repo.js";
+export * from "./headless.js";
+export * from "./in-memory-session-repo.js";
+export * from "./repo.js";
+export * from "./session-index.js";
+export * from "./sessions.js";
diff --git a/apps/x/packages/core/src/sessions/repo.ts b/apps/x/packages/core/src/sessions/repo.ts
new file mode 100644
index 00000000..eb10f4e1
--- /dev/null
+++ b/apps/x/packages/core/src/sessions/repo.ts
@@ -0,0 +1,20 @@
+import type { z } from "zod";
+import type { SessionCreated, SessionEvent } from "@x/shared/dist/sessions.js";
+
+export interface ISessionRepo {
+    // Fails if the session already exists.
+    create(event: z.infer<typeof SessionCreated>): Promise<void>;
+    // Validates every line strictly; corrupt files are rejected whole.
+    read(sessionId: string): Promise<Array<z.infer<typeof SessionEvent>>>;
+    // Validates events before writing.
+    append(
+        sessionId: string,
+        events: Array<z.infer<typeof SessionEvent>>,
+    ): Promise<void>;
+    // In-process per-session exclusion.
+    withLock<T>(sessionId: string, fn: () => Promise<T>): Promise<T>;
+    // Enumerates all session ids for the startup scan.
+    listSessionIds(): Promise<string[]>;
+    // Removes the session file only; referenced turn files stay as orphans.
+    delete(sessionId: string): Promise<void>;
+}
diff --git a/apps/x/packages/core/src/sessions/session-index.ts b/apps/x/packages/core/src/sessions/session-index.ts
new file mode 100644
index 00000000..f09dcbf6
--- /dev/null
+++ b/apps/x/packages/core/src/sessions/session-index.ts
@@ -0,0 +1,25 @@
+import type { SessionIndexEntry } from "@x/shared/dist/sessions.js";
+
+// In-memory projection over session files. Never a source of truth: rebuilt
+// by the startup scan, maintained write-through by the sessions service.
+export class SessionIndex {
+    private entries = new Map<string, SessionIndexEntry>();
+
+    list(): SessionIndexEntry[] {
+        return [...this.entries.values()].sort((a, b) =>
+            b.updatedAt.localeCompare(a.updatedAt),
+        );
+    }
+
+    get(sessionId: string): SessionIndexEntry | undefined {
+        return this.entries.get(sessionId);
+    }
+
+    upsert(entry: SessionIndexEntry): void {
+        this.entries.set(entry.sessionId, entry);
+    }
+
+    remove(sessionId: string): boolean {
+        return this.entries.delete(sessionId);
+    }
+}
diff --git a/apps/x/packages/core/src/sessions/sessions.test.ts b/apps/x/packages/core/src/sessions/sessions.test.ts
new file mode 100644
index 00000000..d4efdaa1
--- /dev/null
+++ b/apps/x/packages/core/src/sessions/sessions.test.ts
@@ -0,0 +1,844 @@
+import { describe, expect, it } from "vitest";
+import type { z } from "zod";
+import type { SessionBusEvent, SessionEvent } from "@x/shared/dist/sessions.js";
+import type {
+    ResolvedAgent,
+    TurnEvent,
+    TurnStreamEvent,
+} from "@x/shared/dist/turns.js";
+import type {
+    CreateTurnInput,
+    ITurnRuntime,
+    Turn,
+    TurnExecution,
+    TurnExternalInput,
+    TurnOutcome,
+} from "../turns/api.js";
+import { TurnInputError } from "../turns/api.js";
+import { HotStream } from "../turns/stream.js";
+import { TurnNotSettledError } from "./api.js";
+import { runHeadlessTurn } from "./headless.js";
+import { InMemorySessionRepo } from "./in-memory-session-repo.js";
+import type { ISessionRepo } from "./repo.js";
+import { SessionsImpl } from "./sessions.js";
+
+type TEvent = z.infer<typeof TurnEvent>;
+
+const TS = "2026-07-02T10:00:00Z";
+const FIXTURE_MODEL = { provider: "openai", model: "gpt-fixture" };
+const FIXTURE_AGENT: z.infer<typeof ResolvedAgent> = {
+    agentId: "copilot",
+    systemPrompt: "SYS",
+    model: FIXTURE_MODEL,
+    tools: [],
+};
+
+function user(text: string) {
+    return { role: "user" as const, content: text };
+}
+
+function assistantText(text: string) {
+    return { role: "assistant" as const, content: text };
+}
+
+function completedOutcome(): TurnOutcome {
+    return {
+        status: "completed",
+        output: assistantText("ok"),
+        finishReason: "stop",
+        usage: {},
+    };
+}
+
+function createdEvent(turnId: string, input: CreateTurnInput): TEvent {
+    return {
+        type: "turn_created",
+        schemaVersion: 1,
+        turnId,
+        ts: TS,
+        sessionId: input.sessionId ?? null,
+        agent: { requested: input.agent, resolved: FIXTURE_AGENT },
+        context: input.context,
+        input: input.input,
+        config: {
+            autoPermission: input.config.autoPermission ?? false,
+            humanAvailable: input.config.humanAvailable,
+            maxModelCalls: input.config.maxModelCalls ?? 20,
+        },
+    };
+}
+
+// Minimal valid event logs reducing to each turn status.
+function turnLog(
+    turnId: string,
+    sessionId: string,
+    status: "idle" | "completed" | "failed" | "cancelled" | "suspended",
+): TEvent[] {
+    const created: TEvent = createdEvent(turnId, {
+        agent: { agentId: "copilot" },
+        sessionId,
+        context: [],
+        input: user("hi"),
+        config: { humanAvailable: true },
+    });
+    const requested: TEvent = {
+        type: "model_call_requested",
+        turnId,
+        ts: TS,
+        modelCallIndex: 0,
+        request: { messages: ['input'], parameters: {} },
+    };
+    switch (status) {
+        case "idle":
+            return [created];
+        case "completed":
+            return [
+                created,
+                requested,
+                {
+                    type: "model_call_completed",
+                    turnId,
+                    ts: TS,
+                    modelCallIndex: 0,
+                    message: assistantText("ok"),
+                    finishReason: "stop",
+                    usage: {},
+                },
+                {
+                    type: "turn_completed",
+                    turnId,
+                    ts: TS,
+                    output: assistantText("ok"),
+                    finishReason: "stop",
+                    usage: {},
+                },
+            ];
+        case "failed":
+            return [
+                created,
+                requested,
+                { type: "model_call_failed", turnId, ts: TS, modelCallIndex: 0, error: "boom" },
+                { type: "turn_failed", turnId, ts: TS, error: "boom", usage: {} },
+            ];
+        case "cancelled":
+            return [
+                created,
+                { type: "turn_cancelled", turnId, ts: TS, usage: {} },
+            ];
+        case "suspended":
+            return [
+                created,
+                requested,
+                {
+                    type: "model_call_completed",
+                    turnId,
+                    ts: TS,
+                    modelCallIndex: 0,
+                    message: {
+                        role: "assistant",
+                        content: [
+                            {
+                                type: "tool-call",
+                                toolCallId: "B",
+                                toolName: "fetch",
+                                arguments: {},
+                            },
+                        ],
+                    },
+                    finishReason: "tool-calls",
+                    usage: {},
+                },
+                {
+                    type: "tool_invocation_requested",
+                    turnId,
+                    ts: TS,
+                    toolCallId: "B",
+                    toolId: "tool.fetch",
+                    toolName: "fetch",
+                    execution: "async",
+                    input: {},
+                },
+                {
+                    type: "turn_suspended",
+                    turnId,
+                    ts: TS,
+                    pendingPermissions: [],
+                    pendingAsyncTools: [
+                        { toolCallId: "B", toolId: "tool.fetch", toolName: "fetch", input: {} },
+                    ],
+                    usage: {},
+                },
+            ];
+    }
+}
+
+type AdvanceScript = (call: {
+    turnId: string;
+    input?: TurnExternalInput;
+    signal?: AbortSignal;
+}) =>
+    | { events?: TurnStreamEvent[]; outcome: TurnOutcome }
+    | { error: unknown }
+    | { untilAbort: true };
+
+class FakeTurnRuntime implements ITurnRuntime {
+    createTurnInputs: CreateTurnInput[] = [];
+    advanceCalls: Array<{ turnId: string; input?: TurnExternalInput }> = [];
+    logs = new Map<string, TEvent[]>();
+    createError?: Error;
+    script?: AdvanceScript;
+    // When set, session turns get an inherited agent snapshot (like the real
+    // runtime does for identical predecessors).
+    inheritSnapshots = false;
+    private n = 0;
+
+    async createTurn(input: CreateTurnInput): Promise<string> {
+        if (this.createError) {
+            throw this.createError;
+        }
+        this.createTurnInputs.push(input);
+        this.n += 1;
+        const turnId = `2026-07-02T10-00-00Z-${String(this.n).padStart(7, "0")}-000`;
+        const created = createdEvent(turnId, input);
+        if (
+            this.inheritSnapshots &&
+            created.type === "turn_created" &&
+            !Array.isArray(input.context)
+        ) {
+            created.agent = {
+                ...created.agent,
+                resolved: {
+                    agentId: FIXTURE_AGENT.agentId,
+                    model: FIXTURE_MODEL,
+                    inheritedFrom: input.context.previousTurnId,
+                },
+            };
+        }
+        this.logs.set(turnId, [created]);
+        return turnId;
+    }
+
+    advanceTurn(
+        turnId: string,
+        input?: TurnExternalInput,
+        options?: { signal?: AbortSignal },
+    ): TurnExecution {
+        this.advanceCalls.push({ turnId, input });
+        const stream = new HotStream<TurnStreamEvent, TurnOutcome>();
+        const result = this.script?.({ turnId, input, signal: options?.signal }) ?? {
+            outcome: completedOutcome(),
+        };
+        if ("error" in result) {
+            stream.fail(result.error);
+        } else if ("untilAbort" in result) {
+            const signal = options?.signal;
+            if (!signal) {
+                throw new Error("untilAbort script requires a signal");
+            }
+            const finish = () => stream.end({ status: "cancelled", usage: {} });
+            if (signal.aborted) {
+                finish();
+            } else {
+                signal.addEventListener("abort", finish, { once: true });
+            }
+        } else {
+            for (const event of result.events ?? []) {
+                stream.push(event);
+            }
+            stream.end(result.outcome);
+        }
+        return { events: stream.events, outcome: stream.outcome };
+    }
+
+    async getTurn(turnId: string): Promise<Turn> {
+        const log = this.logs.get(turnId);
+        if (!log) {
+            throw new Error(`turn not found: ${turnId}`);
+        }
+        return { turnId, events: structuredClone(log) };
+    }
+
+    setLog(turnId: string, events: TEvent[]): void {
+        this.logs.set(turnId, events);
+    }
+}
+
+class RecordingBus {
+    events: SessionBusEvent[] = [];
+    publish(event: SessionBusEvent): void {
+        this.events.push(event);
+    }
+}
+
+class FakeIdGen {
+    private n = 0;
+    async next(): Promise<string> {
+        this.n += 1;
+        return `2026-07-02T09-00-00Z-${String(this.n).padStart(7, "0")}-000`;
+    }
+}
+
+class FakeClock {
+    now(): string {
+        return TS;
+    }
+}
+
+// Wrapper to simulate a crash between turn-file creation and session append.
+class FlakySessionRepo implements ISessionRepo {
+    failNextAppend = false;
+    constructor(private readonly inner: InMemorySessionRepo) {}
+    create(event: Parameters<InMemorySessionRepo["create"]>[0]) {
+        return this.inner.create(event);
+    }
+    read(sessionId: string) {
+        return this.inner.read(sessionId);
+    }
+    async append(
+        sessionId: string,
+        events: Array<z.infer<typeof SessionEvent>>,
+    ): Promise<void> {
+        if (this.failNextAppend) {
+            this.failNextAppend = false;
+            throw new Error("disk full");
+        }
+        return this.inner.append(sessionId, events);
+    }
+    withLock<T>(sessionId: string, fn: () => Promise<T>): Promise<T> {
+        return this.inner.withLock(sessionId, fn);
+    }
+    listSessionIds() {
+        return this.inner.listSessionIds();
+    }
+    delete(sessionId: string) {
+        return this.inner.delete(sessionId);
+    }
+}
+
+function makeSessions(opts: { repo?: ISessionRepo; fake?: FakeTurnRuntime } = {}) {
+    const repo = opts.repo ?? new InMemorySessionRepo();
+    const fake = opts.fake ?? new FakeTurnRuntime();
+    const bus = new RecordingBus();
+    const sessions = new SessionsImpl({
+        sessionRepo: repo,
+        turnRuntime: fake,
+        idGenerator: new FakeIdGen(),
+        clock: new FakeClock(),
+        sessionBus: bus,
+    });
+    return { sessions, repo, fake, bus };
+}
+
+const flush = () => new Promise<void>((resolve) => setTimeout(resolve, 0));
+
+describe("createSession and listing", () => {
+    it("persists session_created and publishes an index entry with status none", async () => {
+        const { sessions, repo, bus } = makeSessions();
+        const sessionId = await sessions.createSession({ title: "My chat" });
+        const events = await (repo as InMemorySessionRepo).read(sessionId);
+        expect(events).toEqual([
+            expect.objectContaining({
+                type: "session_created",
+                schemaVersion: 1,
+                sessionId,
+                title: "My chat",
+            }),
+        ]);
+        expect(sessions.listSessions()).toEqual([
+            expect.objectContaining({
+                sessionId,
+                title: "My chat",
+                turnCount: 0,
+                latestTurnStatus: "none",
+            }),
+        ]);
+        expect(bus.events).toEqual([
+            expect.objectContaining({ kind: "index-changed", sessionId }),
+        ]);
+    });
+});
+
+describe("sendMessage (13.3)", () => {
+    it("first message: inline empty context, config on the turn, denormalized ref, default title", async () => {
+        const { sessions, repo, fake } = makeSessions();
+        const sessionId = await sessions.createSession();
+        const { turnId } = await sessions.sendMessage(sessionId, user("Fix the bug in parser"), {
+            agent: { agentId: "copilot", overrides: { model: { provider: "x", model: "y" } } },
+            autoPermission: true,
+            maxModelCalls: 5,
+        });
+
+        expect(fake.createTurnInputs[0]).toEqual({
+            agent: { agentId: "copilot", overrides: { model: { provider: "x", model: "y" } } },
+            sessionId,
+            context: [],
+            input: user("Fix the bug in parser"),
+            config: { humanAvailable: true, autoPermission: true, maxModelCalls: 5 },
+        });
+
+        const events = await (repo as InMemorySessionRepo).read(sessionId);
+        expect(events[1]).toEqual(
+            expect.objectContaining({
+                type: "turn_appended",
+                turnId,
+                sessionSeq: 1,
+                agentId: "copilot",
+                model: FIXTURE_MODEL, // resolved, not requested override input
+            }),
+        );
+        expect(events[2]).toEqual(
+            expect.objectContaining({
+                type: "title_changed",
+                title: "Fix the bug in parser",
+            }),
+        );
+        expect(fake.advanceCalls).toEqual([{ turnId, input: undefined }]);
+    });
+
+    it("subsequent messages reference the latest turn and skip the title", async () => {
+        const { sessions, repo, fake } = makeSessions();
+        const sessionId = await sessions.createSession();
+        const first = await sessions.sendMessage(sessionId, user("one"), {
+            agent: { agentId: "copilot" },
+        });
+        fake.setLog(first.turnId, turnLog(first.turnId, sessionId, "completed"));
+
+        const second = await sessions.sendMessage(sessionId, user("two"), {
+            agent: { agentId: "copilot" },
+        });
+        expect(fake.createTurnInputs[1].context).toEqual({
+            previousTurnId: first.turnId,
+        });
+        const events = await (repo as InMemorySessionRepo).read(sessionId);
+        const appends = events.filter((e) => e.type === "turn_appended");
+        expect(appends.map((e) => (e.type === "turn_appended" ? e.sessionSeq : 0))).toEqual([1, 2]);
+        expect(appends[1]).toEqual(
+            expect.objectContaining({ turnId: second.turnId }),
+        );
+        expect(events.filter((e) => e.type === "title_changed")).toHaveLength(1);
+    });
+
+    it("rejects while the latest turn is idle or suspended; allows all terminal statuses", async () => {
+        const { sessions, fake } = makeSessions();
+        const sessionId = await sessions.createSession();
+        const { turnId } = await sessions.sendMessage(sessionId, user("one"), {
+            agent: { agentId: "copilot" },
+        });
+
+        for (const status of ["idle", "suspended"] as const) {
+            fake.setLog(turnId, turnLog(turnId, sessionId, status));
+            const attempt = sessions.sendMessage(sessionId, user("nope"), {
+                agent: { agentId: "copilot" },
+            });
+            await expect(attempt).rejects.toThrowError(TurnNotSettledError);
+            await expect(attempt).rejects.toMatchObject({
+                sessionId,
+                turnId,
+                turnStatus: status,
+            });
+        }
+
+        let latest = turnId;
+        for (const status of ["completed", "failed", "cancelled"] as const) {
+            fake.setLog(latest, turnLog(latest, sessionId, status));
+            const result = await sessions.sendMessage(sessionId, user(`after ${status}`), {
+                agent: { agentId: "copilot" },
+            });
+            latest = result.turnId;
+        }
+    });
+
+    it("denormalizes the model correctly for inherited agent snapshots", async () => {
+        const { sessions, repo, fake } = makeSessions();
+        fake.inheritSnapshots = true;
+        const sessionId = await sessions.createSession();
+        const first = await sessions.sendMessage(sessionId, user("one"), {
+            agent: { agentId: "copilot" },
+        });
+        fake.setLog(first.turnId, turnLog(first.turnId, sessionId, "completed"));
+
+        const second = await sessions.sendMessage(sessionId, user("two"), {
+            agent: { agentId: "copilot" },
+        });
+        // The second turn's created event carries an inherited snapshot; the
+        // session still denormalizes the concrete model onto turn_appended,
+        // and status derivation reduces the inherited log fine.
+        const created = fake.logs.get(second.turnId)?.[0];
+        expect(
+            created?.type === "turn_created" && "inheritedFrom" in created.agent.resolved,
+        ).toBe(true);
+        const events = await (repo as InMemorySessionRepo).read(sessionId);
+        const appended = events.filter((e) => e.type === "turn_appended");
+        expect(appended[1]).toMatchObject({ model: FIXTURE_MODEL });
+        expect(sessions.listSessions()[0].lastModel).toEqual(FIXTURE_MODEL);
+    });
+
+    it("serializes concurrent sends: exactly one wins", async () => {
+        const { sessions, repo } = makeSessions();
+        const sessionId = await sessions.createSession();
+        const results = await Promise.allSettled([
+            sessions.sendMessage(sessionId, user("a"), { agent: { agentId: "copilot" } }),
+            sessions.sendMessage(sessionId, user("b"), { agent: { agentId: "copilot" } }),
+        ]);
+        expect(results.filter((r) => r.status === "fulfilled")).toHaveLength(1);
+        const rejected = results.find((r) => r.status === "rejected");
+        expect((rejected as PromiseRejectedResult).reason).toBeInstanceOf(
+            TurnNotSettledError,
+        );
+        const events = await (repo as InMemorySessionRepo).read(sessionId);
+        expect(events.filter((e) => e.type === "turn_appended")).toHaveLength(1);
+    });
+});
+
+describe("write ordering and crash simulation (13.4)", () => {
+    it("a failed session append leaves a benign orphan turn and no advance; retry works", async () => {
+        const inner = new InMemorySessionRepo();
+        const flaky = new FlakySessionRepo(inner);
+        const { sessions, fake } = makeSessions({ repo: flaky });
+        const sessionId = await sessions.createSession();
+
+        flaky.failNextAppend = true;
+        await expect(
+            sessions.sendMessage(sessionId, user("one"), { agent: { agentId: "copilot" } }),
+        ).rejects.toThrowError("disk full");
+
+        // Turn file exists (orphan), session unchanged, nothing advanced.
+        expect(fake.logs.size).toBe(1);
+        expect(fake.advanceCalls).toHaveLength(0);
+        expect(await inner.read(sessionId)).toHaveLength(1);
+
+        // Retry produces a fresh turn at sessionSeq 1.
+        const { turnId } = await sessions.sendMessage(sessionId, user("one again"), {
+            agent: { agentId: "copilot" },
+        });
+        const events = await inner.read(sessionId);
+        expect(events.filter((e) => e.type === "turn_appended")).toEqual([
+            expect.objectContaining({ turnId, sessionSeq: 1 }),
+        ]);
+    });
+
+    it("a failed createTurn leaves the session untouched", async () => {
+        const { sessions, repo, fake } = makeSessions();
+        const sessionId = await sessions.createSession();
+        fake.createError = new Error("agent resolution failed");
+        await expect(
+            sessions.sendMessage(sessionId, user("one"), { agent: { agentId: "ghost" } }),
+        ).rejects.toThrowError("agent resolution failed");
+        expect(await (repo as InMemorySessionRepo).read(sessionId)).toHaveLength(1);
+        expect(fake.advanceCalls).toHaveLength(0);
+    });
+});
+
+describe("external input routing (13.5)", () => {
+    async function setupSuspended() {
+        const fixture = makeSessions();
+        const sessionId = await fixture.sessions.createSession();
+        const { turnId } = await fixture.sessions.sendMessage(sessionId, user("go"), {
+            agent: { agentId: "copilot" },
+        });
+        fixture.fake.setLog(turnId, turnLog(turnId, sessionId, "suspended"));
+        fixture.fake.advanceCalls.length = 0;
+        return { ...fixture, sessionId, turnId };
+    }
+
+    it("respondToPermission advances with a permission_decision input", async () => {
+        const { sessions, fake, turnId } = await setupSuspended();
+        await sessions.respondToPermission(turnId, "tc1", "allow", { scope: "once" });
+        expect(fake.advanceCalls).toEqual([
+            {
+                turnId,
+                input: {
+                    type: "permission_decision",
+                    toolCallId: "tc1",
+                    decision: "allow",
+                    metadata: { scope: "once" },
+                },
+            },
+        ]);
+    });
+
+    it("respondToAskHuman is a dedicated async_tool_result wrapper", async () => {
+        const { sessions, fake, turnId } = await setupSuspended();
+        await sessions.respondToAskHuman(turnId, "B", "the answer is 42");
+        expect(fake.advanceCalls).toEqual([
+            {
+                turnId,
+                input: {
+                    type: "async_tool_result",
+                    toolCallId: "B",
+                    result: { output: "the answer is 42", isError: false },
+                },
+            },
+        ]);
+    });
+
+    it("deliverAsyncToolResult passes the result through verbatim", async () => {
+        const { sessions, fake, turnId } = await setupSuspended();
+        await sessions.deliverAsyncToolResult(turnId, "B", {
+            output: { rows: 3 },
+            isError: false,
+        });
+        expect(fake.advanceCalls[0].input).toEqual({
+            type: "async_tool_result",
+            toolCallId: "B",
+            result: { output: { rows: 3 }, isError: false },
+        });
+    });
+
+    it("turn-runtime input rejections pass through", async () => {
+        const { sessions, fake, turnId } = await setupSuspended();
+        fake.script = () => ({ error: new TurnInputError("no pending async tool call X") });
+        await expect(
+            sessions.deliverAsyncToolResult(turnId, "X", { output: "x", isError: false }),
+        ).rejects.toThrowError(TurnInputError);
+    });
+});
+
+describe("stopTurn and resumeTurn", () => {
+    it("aborts an actively running advance instead of issuing a cancel input", async () => {
+        const { sessions, fake } = makeSessions();
+        fake.script = () => ({ untilAbort: true });
+        const sessionId = await sessions.createSession();
+        const { turnId } = await sessions.sendMessage(sessionId, user("go"), {
+            agent: { agentId: "copilot" },
+        });
+        expect(fake.advanceCalls).toHaveLength(1);
+        await sessions.stopTurn(turnId);
+        // No second advance: the running invocation's signal was aborted.
+        expect(fake.advanceCalls).toHaveLength(1);
+    });
+
+    it("cancels an at-rest turn through a cancel input", async () => {
+        const { sessions, fake } = makeSessions();
+        const sessionId = await sessions.createSession();
+        const { turnId } = await sessions.sendMessage(sessionId, user("go"), {
+            agent: { agentId: "copilot" },
+        });
+        await flush();
+        fake.setLog(turnId, turnLog(turnId, sessionId, "suspended"));
+        fake.advanceCalls.length = 0;
+        await sessions.stopTurn(turnId, "user stop");
+        expect(fake.advanceCalls).toEqual([
+            { turnId, input: { type: "cancel", reason: "user stop" } },
+        ]);
+    });
+
+    it("resumeTurn re-enters the latest turn with no input", async () => {
+        const { sessions, fake } = makeSessions();
+        const sessionId = await sessions.createSession();
+        const { turnId } = await sessions.sendMessage(sessionId, user("go"), {
+            agent: { agentId: "copilot" },
+        });
+        await flush();
+        fake.advanceCalls.length = 0;
+        await sessions.resumeTurn(sessionId);
+        expect(fake.advanceCalls).toEqual([{ turnId, input: undefined }]);
+    });
+
+    it("resumeTurn on a session with no turns throws", async () => {
+        const { sessions } = makeSessions();
+        const sessionId = await sessions.createSession();
+        await expect(sessions.resumeTurn(sessionId)).rejects.toThrowError(
+            /no turns to resume/,
+        );
+    });
+});
+
+describe("event forwarding and index maintenance (13.6, 13.7)", () => {
+    it("forwards stream events to the bus tagged with sessionId in order", async () => {
+        const { sessions, fake, bus } = makeSessions();
+        const streamed: TurnStreamEvent[] = [
+            { type: "text_delta", turnId: "x", modelCallIndex: 0, delta: "he" },
+            { type: "text_delta", turnId: "x", modelCallIndex: 0, delta: "y" },
+        ];
+        fake.script = () => ({ events: streamed, outcome: completedOutcome() });
+        const sessionId = await sessions.createSession();
+        const { turnId } = await sessions.sendMessage(sessionId, user("go"), {
+            agent: { agentId: "copilot" },
+        });
+        await flush();
+        const turnEvents = bus.events.filter((e) => e.kind === "turn-event");
+        expect(turnEvents).toEqual(
+            streamed.map((event) => ({
+                kind: "turn-event",
+                sessionId,
+                turnId,
+                event,
+            })),
+        );
+    });
+
+    it("outcome settlement updates the index entry's latest turn status", async () => {
+        const { sessions, fake, bus } = makeSessions();
+        fake.script = () => ({
+            outcome: {
+                status: "suspended",
+                pendingPermissions: [],
+                pendingAsyncTools: [
+                    { toolCallId: "B", toolId: "tool.fetch", toolName: "fetch", input: {} },
+                ],
+                usage: {},
+            },
+        });
+        const sessionId = await sessions.createSession();
+        await sessions.sendMessage(sessionId, user("go"), {
+            agent: { agentId: "copilot" },
+        });
+        await flush();
+        expect(sessions.listSessions()[0].latestTurnStatus).toBe("suspended");
+        const last = bus.events[bus.events.length - 1];
+        expect(last).toMatchObject({
+            kind: "index-changed",
+            entry: { latestTurnStatus: "suspended" },
+        });
+    });
+
+    it("setTitle appends and updates the index preserving status", async () => {
+        const { sessions, repo } = makeSessions();
+        const sessionId = await sessions.createSession();
+        await sessions.sendMessage(sessionId, user("go"), {
+            agent: { agentId: "copilot" },
+        });
+        await flush();
+        await sessions.setTitle(sessionId, "Renamed");
+        const events = await (repo as InMemorySessionRepo).read(sessionId);
+        expect(events[events.length - 1]).toMatchObject({
+            type: "title_changed",
+            title: "Renamed",
+        });
+        expect(sessions.listSessions()[0]).toMatchObject({
+            title: "Renamed",
+            latestTurnStatus: "completed",
+        });
+    });
+
+    it("deleteSession removes the file and entry; turn files stay; late settles don't resurrect", async () => {
+        const { sessions, repo, fake, bus } = makeSessions();
+        fake.script = () => ({ untilAbort: true });
+        const sessionId = await sessions.createSession();
+        const { turnId } = await sessions.sendMessage(sessionId, user("go"), {
+            agent: { agentId: "copilot" },
+        });
+
+        await sessions.deleteSession(sessionId);
+        await expect(
+            (repo as InMemorySessionRepo).read(sessionId),
+        ).rejects.toThrowError(/session not found/);
+        expect(sessions.listSessions()).toEqual([]);
+        expect(bus.events[bus.events.length - 1]).toEqual({
+            kind: "index-changed",
+            sessionId,
+            entry: null,
+        });
+        // Turn file untouched (orphaned, inert).
+        expect(fake.logs.has(turnId)).toBe(true);
+
+        // The still-running advance settles after deletion: no resurrection.
+        await sessions.stopTurn(turnId);
+        await flush();
+        expect(sessions.listSessions()).toEqual([]);
+    });
+});
+
+describe("startup scan (13.6)", () => {
+    it("builds the index from session files and each latest turn; corrupt files yield errored entries", async () => {
+        const repo = new InMemorySessionRepo();
+        const fake = new FakeTurnRuntime();
+        const s1 = "2026-07-02T09-00-00Z-0000001-000";
+        const s2 = "2026-07-02T09-00-00Z-0000002-000";
+        const s3 = "2026-07-02T09-00-00Z-0000003-000";
+        repo.seed([
+            { type: "session_created", schemaVersion: 1, sessionId: s1, ts: TS, title: "Done one" },
+            {
+                type: "turn_appended",
+                sessionId: s1,
+                ts: TS,
+                turnId: "t1",
+                sessionSeq: 1,
+                agentId: "copilot",
+                model: FIXTURE_MODEL,
+            },
+        ]);
+        fake.setLog("t1", turnLog("t1", s1, "completed"));
+        repo.seed([
+            { type: "session_created", schemaVersion: 1, sessionId: s2, ts: TS },
+            {
+                type: "turn_appended",
+                sessionId: s2,
+                ts: TS,
+                turnId: "t2",
+                sessionSeq: 1,
+                agentId: "researcher",
+                model: { provider: "anthropic", model: "claude-x" },
+            },
+        ]);
+        fake.setLog("t2", turnLog("t2", s2, "suspended"));
+        repo.seedCorrupt(s3);
+
+        const { sessions } = makeSessions({ repo, fake });
+        await sessions.initialize();
+
+        const entries = sessions.listSessions();
+        expect(entries).toHaveLength(3);
+        const byId = new Map(entries.map((e) => [e.sessionId, e]));
+        expect(byId.get(s1)).toMatchObject({
+            title: "Done one",
+            turnCount: 1,
+            lastAgentId: "copilot",
+            lastModel: FIXTURE_MODEL,
+            latestTurnStatus: "completed",
+        });
+        expect(byId.get(s2)).toMatchObject({
+            lastAgentId: "researcher",
+            latestTurnStatus: "suspended",
+        });
+        expect(byId.get(s3)).toMatchObject({
+            latestTurnStatus: "none",
+            error: expect.stringMatching(/corrupt/),
+        });
+    });
+
+    it("a rebuilt index matches write-through state for the same history", async () => {
+        const repo = new InMemorySessionRepo();
+        const fake = new FakeTurnRuntime();
+        const live = makeSessions({ repo, fake });
+        const sessionId = await live.sessions.createSession();
+        const { turnId } = await live.sessions.sendMessage(sessionId, user("hello world"), {
+            agent: { agentId: "copilot" },
+        });
+        await flush();
+        fake.setLog(turnId, turnLog(turnId, sessionId, "completed"));
+
+        const rebuilt = makeSessions({ repo, fake });
+        await rebuilt.sessions.initialize();
+        expect(rebuilt.sessions.listSessions()).toEqual([
+            expect.objectContaining({
+                sessionId,
+                title: "hello world",
+                turnCount: 1,
+                latestTurnId: turnId,
+                latestTurnStatus: "completed",
+            }),
+        ]);
+    });
+});
+
+describe("headless standalone turns (13.8)", () => {
+    it("runs a standalone turn with sessionId null, auto permission, no human", async () => {
+        const fake = new FakeTurnRuntime();
+        const { turnId, outcome } = await runHeadlessTurn(fake, {
+            agent: { agentId: "background-task-agent" },
+            input: user("summarize"),
+            maxModelCalls: 3,
+        });
+        expect(fake.createTurnInputs[0]).toEqual({
+            agent: { agentId: "background-task-agent" },
+            sessionId: null,
+            context: [],
+            input: user("summarize"),
+            config: { autoPermission: true, humanAvailable: false, maxModelCalls: 3 },
+        });
+        expect(outcome.status).toBe("completed");
+        expect(fake.advanceCalls).toEqual([{ turnId, input: undefined }]);
+    });
+});
diff --git a/apps/x/packages/core/src/sessions/sessions.ts b/apps/x/packages/core/src/sessions/sessions.ts
new file mode 100644
index 00000000..ad9d8c98
--- /dev/null
+++ b/apps/x/packages/core/src/sessions/sessions.ts
@@ -0,0 +1,418 @@
+import type { z } from "zod";
+import type { UserMessage } from "@x/shared/dist/message.js";
+import {
+    SessionCreated,
+    type SessionEvent,
+    type SessionIndexEntry,
+    type SessionLatestTurnStatus,
+    type SessionState,
+    reduceSession,
+    sessionIndexEntry,
+} from "@x/shared/dist/sessions.js";
+import {
+    type JsonValue,
+    type ModelDescriptor,
+    type ToolResultData,
+    deriveTurnStatus,
+    reduceTurn,
+} from "@x/shared/dist/turns.js";
+import type { IMonotonicallyIncreasingIdGenerator } from "../application/lib/id-gen.js";
+import type {
+    ITurnRuntime,
+    Turn,
+    TurnExecution,
+    TurnExternalInput,
+    TurnOutcome,
+} from "../turns/api.js";
+import type { IClock } from "../turns/clock.js";
+import {
+    type ISessions,
+    type SendMessageConfig,
+    TurnNotSettledError,
+} from "./api.js";
+import type { ISessionBus } from "./bus.js";
+import type { ISessionRepo } from "./repo.js";
+import { SessionIndex } from "./session-index.js";
+
+export interface SessionsDependencies {
+    sessionRepo: ISessionRepo;
+    turnRuntime: ITurnRuntime;
+    idGenerator: IMonotonicallyIncreasingIdGenerator;
+    clock: IClock;
+    sessionBus: ISessionBus;
+}
+
+// The session layer per session-design.md: owns conversations as ordered
+// chains of turn references, enforces one active turn per session, assembles
+// context as a reference to the previous turn, and maintains the in-memory
+// index write-through. It never reads or writes turn-file contents beyond
+// what ITurnRuntime exposes.
+export class SessionsImpl implements ISessions {
+    private readonly sessionRepo: ISessionRepo;
+    private readonly turnRuntime: ITurnRuntime;
+    private readonly idGenerator: IMonotonicallyIncreasingIdGenerator;
+    private readonly clock: IClock;
+    private readonly sessionBus: ISessionBus;
+
+    private readonly index = new SessionIndex();
+    // Ephemeral: executions this process started, for stopTurn's abort path.
+    private readonly active = new Map<
+        string,
+        { sessionId: string | null; controller: AbortController; execution: TurnExecution }
+    >();
+
+    constructor({
+        sessionRepo,
+        turnRuntime,
+        idGenerator,
+        clock,
+        sessionBus,
+    }: SessionsDependencies) {
+        this.sessionRepo = sessionRepo;
+        this.turnRuntime = turnRuntime;
+        this.idGenerator = idGenerator;
+        this.clock = clock;
+        this.sessionBus = sessionBus;
+    }
+
+    // §8.2: scan session files, read each session's latest turn for status.
+    // Corrupt files yield errored entries; the scan never aborts.
+    async initialize(): Promise<void> {
+        for (const sessionId of await this.sessionRepo.listSessionIds()) {
+            this.index.upsert(await this.scanSession(sessionId));
+        }
+    }
+
+    private async scanSession(sessionId: string): Promise<SessionIndexEntry> {
+        try {
+            const state = reduceSession(await this.sessionRepo.read(sessionId));
+            const status = await this.latestTurnStatus(state);
+            return sessionIndexEntry(state, status);
+        } catch (error) {
+            return {
+                sessionId,
+                createdAt: "",
+                updatedAt: "",
+                turnCount: 0,
+                latestTurnStatus: "none",
+                error: errorMessage(error),
+            };
+        }
+    }
+
+    private async latestTurnStatus(
+        state: SessionState,
+    ): Promise<SessionLatestTurnStatus> {
+        if (!state.latestTurnId) {
+            return "none";
+        }
+        const turn = await this.turnRuntime.getTurn(state.latestTurnId);
+        return deriveTurnStatus(reduceTurn(turn.events));
+    }
+
+    async createSession(input?: { title?: string }): Promise<string> {
+        const sessionId = await this.idGenerator.next();
+        const event = SessionCreated.parse({
+            type: "session_created",
+            schemaVersion: 1,
+            sessionId,
+            ts: this.clock.now(),
+            ...(input?.title === undefined ? {} : { title: input.title }),
+        });
+        await this.sessionRepo.create(event);
+        this.publishEntry(sessionIndexEntry(reduceSession([event]), "none"));
+        return sessionId;
+    }
+
+    listSessions(): SessionIndexEntry[] {
+        return this.index.list();
+    }
+
+    async getSession(sessionId: string): Promise<SessionState> {
+        return reduceSession(await this.sessionRepo.read(sessionId));
+    }
+
+    async getTurn(turnId: string): Promise<Turn> {
+        return this.turnRuntime.getTurn(turnId);
+    }
+
+    // §9.1. Write order per §7: turn file first, then turn_appended, then the
+    // first advance — so an orphan turn (crash between the writes) is benign
+    // and an executing turn is always referenced.
+    async sendMessage(
+        sessionId: string,
+        input: z.infer<typeof UserMessage>,
+        config: SendMessageConfig,
+    ): Promise<{ turnId: string }> {
+        return this.sessionRepo.withLock(sessionId, async () => {
+            const events = await this.sessionRepo.read(sessionId);
+            const state = reduceSession(events);
+
+            if (state.latestTurnId) {
+                const status = await this.latestTurnStatus(state);
+                if (
+                    status !== "completed" &&
+                    status !== "failed" &&
+                    status !== "cancelled"
+                ) {
+                    throw new TurnNotSettledError(
+                        sessionId,
+                        state.latestTurnId,
+                        status,
+                    );
+                }
+            }
+
+            const turnId = await this.turnRuntime.createTurn({
+                agent: config.agent,
+                sessionId,
+                context: state.latestTurnId
+                    ? { previousTurnId: state.latestTurnId }
+                    : [],
+                input,
+                config: {
+                    humanAvailable: true,
+                    ...(config.autoPermission === undefined
+                        ? {}
+                        : { autoPermission: config.autoPermission }),
+                    ...(config.maxModelCalls === undefined
+                        ? {}
+                        : { maxModelCalls: config.maxModelCalls }),
+                },
+            });
+
+            const batch: Array<z.infer<typeof SessionEvent>> = [
+                {
+                    type: "turn_appended",
+                    sessionId,
+                    ts: this.clock.now(),
+                    turnId,
+                    sessionSeq: state.turns.length + 1,
+                    agentId: config.agent.agentId,
+                    model: await this.resolvedModelOf(turnId),
+                },
+            ];
+            if (!state.title) {
+                batch.push({
+                    type: "title_changed",
+                    sessionId,
+                    ts: this.clock.now(),
+                    title: defaultTitle(input),
+                });
+            }
+            await this.sessionRepo.append(sessionId, batch);
+
+            this.publishEntry(
+                sessionIndexEntry(reduceSession([...events, ...batch]), "idle"),
+            );
+            this.startTrackedAdvance(sessionId, turnId);
+            return { turnId };
+        });
+    }
+
+    async respondToPermission(
+        turnId: string,
+        toolCallId: string,
+        decision: "allow" | "deny",
+        metadata?: JsonValue,
+    ): Promise<void> {
+        await this.advanceWithInput(turnId, {
+            type: "permission_decision",
+            toolCallId,
+            decision,
+            ...(metadata === undefined ? {} : { metadata }),
+        });
+    }
+
+    async respondToAskHuman(
+        turnId: string,
+        toolCallId: string,
+        answer: string,
+    ): Promise<void> {
+        await this.advanceWithInput(turnId, {
+            type: "async_tool_result",
+            toolCallId,
+            result: { output: answer, isError: false },
+        });
+    }
+
+    async deliverAsyncToolResult(
+        turnId: string,
+        toolCallId: string,
+        result: z.infer<typeof ToolResultData>,
+    ): Promise<void> {
+        await this.advanceWithInput(turnId, {
+            type: "async_tool_result",
+            toolCallId,
+            result,
+        });
+    }
+
+    async stopTurn(turnId: string, reason?: string): Promise<void> {
+        const running = this.active.get(turnId);
+        if (running) {
+            running.controller.abort();
+            await running.execution.outcome.catch(() => undefined);
+            return;
+        }
+        await this.advanceWithInput(turnId, {
+            type: "cancel",
+            ...(reason === undefined ? {} : { reason }),
+        });
+    }
+
+    // Recovery entry for idle (crash-interrupted) turns. Deliberately not run
+    // at startup: recovery re-issues interrupted model calls, so resumption
+    // must be an explicit action. Runs in the background.
+    async resumeTurn(sessionId: string): Promise<void> {
+        const state = reduceSession(await this.sessionRepo.read(sessionId));
+        if (!state.latestTurnId) {
+            throw new Error(`session ${sessionId} has no turns to resume`);
+        }
+        this.startTrackedAdvance(sessionId, state.latestTurnId);
+    }
+
+    async setTitle(sessionId: string, title: string): Promise<void> {
+        await this.sessionRepo.withLock(sessionId, async () => {
+            const events = await this.sessionRepo.read(sessionId);
+            const batch: Array<z.infer<typeof SessionEvent>> = [
+                { type: "title_changed", sessionId, ts: this.clock.now(), title },
+            ];
+            await this.sessionRepo.append(sessionId, batch);
+            const state = reduceSession([...events, ...batch]);
+            const existing = this.index.get(sessionId);
+            this.publishEntry(
+                sessionIndexEntry(state, existing?.latestTurnStatus ?? "none"),
+            );
+        });
+    }
+
+    // §9.4: removes the session file and index entry only. Referenced turn
+    // files stay behind as inert orphans.
+    async deleteSession(sessionId: string): Promise<void> {
+        await this.sessionRepo.withLock(sessionId, async () => {
+            await this.sessionRepo.delete(sessionId);
+            this.index.remove(sessionId);
+            this.sessionBus.publish({ kind: "index-changed", sessionId, entry: null });
+        });
+    }
+
+    // ------------------------------------------------------------------
+    // Internals
+    // ------------------------------------------------------------------
+
+    private async resolvedModelOf(
+        turnId: string,
+    ): Promise<z.infer<typeof ModelDescriptor>> {
+        const turn = await this.turnRuntime.getTurn(turnId);
+        const created = turn.events[0];
+        if (created.type !== "turn_created") {
+            throw new Error(`turn ${turnId} has no turn_created event`);
+        }
+        return created.agent.resolved.model;
+    }
+
+    private async sessionIdOf(turnId: string): Promise<string | null> {
+        const turn = await this.turnRuntime.getTurn(turnId);
+        const created = turn.events[0];
+        if (created.type !== "turn_created") {
+            throw new Error(`turn ${turnId} has no turn_created event`);
+        }
+        return created.sessionId;
+    }
+
+    private async advanceWithInput(
+        turnId: string,
+        input: TurnExternalInput,
+    ): Promise<void> {
+        const sessionId = await this.sessionIdOf(turnId);
+        const execution = this.startTrackedAdvance(sessionId, turnId, input);
+        await execution.outcome;
+    }
+
+    // Every advance this layer initiates: forward its stream to the bus
+    // tagged with sessionId, keep the abort controller for stopTurn, and
+    // update the index entry when the outcome settles.
+    private startTrackedAdvance(
+        sessionId: string | null,
+        turnId: string,
+        input?: TurnExternalInput,
+    ): TurnExecution {
+        const controller = new AbortController();
+        const execution = this.turnRuntime.advanceTurn(turnId, input, {
+            signal: controller.signal,
+        });
+        this.active.set(turnId, { sessionId, controller, execution });
+
+        void (async () => {
+            try {
+                for await (const event of execution.events) {
+                    if (sessionId !== null) {
+                        this.sessionBus.publish({
+                            kind: "turn-event",
+                            sessionId,
+                            turnId,
+                            event,
+                        });
+                    }
+                }
+            } catch {
+                // Infrastructure failures surface through the outcome.
+            }
+        })();
+
+        void execution.outcome
+            .then((outcome) => this.onSettled(sessionId, turnId, outcome))
+            .catch(() => undefined)
+            .finally(() => this.active.delete(turnId));
+
+        return execution;
+    }
+
+    private onSettled(
+        sessionId: string | null,
+        turnId: string,
+        outcome: TurnOutcome,
+    ): void {
+        if (sessionId === null) {
+            return;
+        }
+        const entry = this.index.get(sessionId);
+        // The session may have been deleted, or a newer turn appended.
+        if (!entry || entry.latestTurnId !== turnId) {
+            return;
+        }
+        this.publishEntry({
+            ...entry,
+            latestTurnStatus: outcome.status,
+            updatedAt: this.clock.now(),
+        });
+    }
+
+    private publishEntry(entry: SessionIndexEntry): void {
+        this.index.upsert(entry);
+        this.sessionBus.publish({
+            kind: "index-changed",
+            sessionId: entry.sessionId,
+            entry,
+        });
+    }
+}
+
+function errorMessage(error: unknown): string {
+    return error instanceof Error ? error.message : String(error);
+}
+
+function defaultTitle(input: z.infer<typeof UserMessage>): string {
+    const text =
+        typeof input.content === "string"
+            ? input.content
+            : input.content
+                  .map((part) => (part.type === "text" ? part.text : ""))
+                  .join(" ");
+    const collapsed = text.trim().replace(/\s+/g, " ");
+    if (collapsed.length === 0) {
+        return "New session";
+    }
+    return collapsed.length > 80 ? `${collapsed.slice(0, 79)}…` : collapsed;
+}
diff --git a/apps/x/packages/core/src/turns/agent-resolver.ts b/apps/x/packages/core/src/turns/agent-resolver.ts
new file mode 100644
index 00000000..5ea1760d
--- /dev/null
+++ b/apps/x/packages/core/src/turns/agent-resolver.ts
@@ -0,0 +1,14 @@
+import type { z } from "zod";
+import type { RequestedAgent, ResolvedAgent } from "@x/shared/dist/turns.js";
+
+// Absorbs agent assembly: built-in/dynamic agent selection, user-defined
+// agent loading, system-prompt augmentation, model precedence
+// (override > agent > application default), tool attachment and filtering.
+// The result is the immutable execution snapshot persisted in turn_created;
+// the resolved system prompt is final byte-for-byte. Resolution failure
+// rejects createTurn without creating a turn file.
+export interface IAgentResolver {
+    resolve(
+        agent: z.infer<typeof RequestedAgent>,
+    ): Promise<z.infer<typeof ResolvedAgent>>;
+}
diff --git a/apps/x/packages/core/src/turns/api.ts b/apps/x/packages/core/src/turns/api.ts
new file mode 100644
index 00000000..55a60e2c
--- /dev/null
+++ b/apps/x/packages/core/src/turns/api.ts
@@ -0,0 +1,112 @@
+import type { z } from "zod";
+import type { AssistantMessage, UserMessage } from "@x/shared/dist/message.js";
+import type {
+    JsonValue,
+    RequestedAgent,
+    ToolResultData,
+    TurnContext,
+    TurnEvent,
+    TurnStreamEvent,
+    TurnSuspended,
+    TurnUsage,
+} from "@x/shared/dist/turns.js";
+
+export interface CreateTurnInput {
+    agent: z.infer<typeof RequestedAgent>;
+    sessionId?: string | null;
+    context: z.infer<typeof TurnContext>;
+    input: z.infer<typeof UserMessage>;
+    config: {
+        autoPermission?: boolean;
+        humanAvailable: boolean;
+        maxModelCalls?: number;
+    };
+}
+
+// Exactly one external input per advanceTurn invocation.
+export type TurnExternalInput =
+    | {
+          type: "permission_decision";
+          toolCallId: string;
+          decision: "allow" | "deny";
+          metadata?: JsonValue;
+      }
+    | {
+          type: "async_tool_progress";
+          toolCallId: string;
+          progress: JsonValue;
+      }
+    | {
+          type: "async_tool_result";
+          toolCallId: string;
+          result: z.infer<typeof ToolResultData>;
+      }
+    | {
+          type: "cancel";
+          reason?: string;
+      };
+
+export type TurnOutcome =
+    | {
+          status: "completed";
+          output: z.infer<typeof AssistantMessage>;
+          finishReason: string;
+          usage: z.infer<typeof TurnUsage>;
+      }
+    | {
+          status: "suspended";
+          pendingPermissions: z.infer<typeof TurnSuspended>["pendingPermissions"];
+          pendingAsyncTools: z.infer<typeof TurnSuspended>["pendingAsyncTools"];
+          usage: z.infer<typeof TurnUsage>;
+      }
+    | {
+          status: "failed";
+          error: string;
+          // Mirrors turn_failed.code (e.g. MODEL_CALL_LIMIT_ERROR_CODE).
+          code?: string;
+          usage: z.infer<typeof TurnUsage>;
+      }
+    | {
+          status: "cancelled";
+          reason?: string;
+          usage: z.infer<typeof TurnUsage>;
+      };
+
+export interface TurnExecution {
+    events: AsyncIterable<TurnStreamEvent>;
+    outcome: Promise<TurnOutcome>;
+}
+
+export interface Turn {
+    turnId: string;
+    events: Array<z.infer<typeof TurnEvent>>;
+}
+
+export interface ITurnRuntime {
+    createTurn(input: CreateTurnInput): Promise<string>;
+    advanceTurn(
+        turnId: string,
+        input?: TurnExternalInput,
+        options?: { signal?: AbortSignal },
+    ): TurnExecution;
+    getTurn(turnId: string): Promise<Turn>;
+}
+
+// An external input that does not match the turn's current durable pending
+// state. Rejects the execution; nothing is appended.
+export class TurnInputError extends Error {
+    constructor(message: string) {
+        super(message);
+        this.name = "TurnInputError";
+    }
+}
+
+// A live runtime dependency is missing or incompatible with the persisted
+// snapshot. Rejects the execution; the turn is left unchanged so the caller
+// can fix its environment and retry.
+export class TurnDependencyError extends Error {
+    constructor(message: string) {
+        super(message);
+        this.name = "TurnDependencyError";
+    }
+}
diff --git a/apps/x/packages/core/src/turns/bridges/index.ts b/apps/x/packages/core/src/turns/bridges/index.ts
new file mode 100644
index 00000000..5927554c
--- /dev/null
+++ b/apps/x/packages/core/src/turns/bridges/index.ts
@@ -0,0 +1,5 @@
+export * from "./real-agent-resolver.js";
+export * from "./real-model-registry.js";
+export * from "./real-permission-checker.js";
+export * from "./real-permission-classifier.js";
+export * from "./real-tool-registry.js";
diff --git a/apps/x/packages/core/src/turns/bridges/real-agent-resolver.test.ts b/apps/x/packages/core/src/turns/bridges/real-agent-resolver.test.ts
new file mode 100644
index 00000000..974d7502
--- /dev/null
+++ b/apps/x/packages/core/src/turns/bridges/real-agent-resolver.test.ts
@@ -0,0 +1,199 @@
+import { describe, expect, it } from "vitest";
+import { z } from "zod";
+import type { Agent } from "@x/shared/dist/agent.js";
+import { composeSystemInstructions } from "../../agents/runtime.js";
+import type { BuiltinTools } from "../../application/lib/builtin-tools.js";
+import { RealAgentResolver } from "./real-agent-resolver.js";
+
+const DEFAULTS = async () => ({ model: "gpt-default", provider: "openai" });
+
+function makeAgent(
+    overrides: Partial<z.infer<typeof Agent>> = {},
+): z.infer<typeof Agent> {
+    return {
+        name: "copilot",
+        instructions: "You are Copilot.",
+        tools: {},
+        ...overrides,
+    };
+}
+
+// A minimal fake builtin catalog (the real one is heavy and irrelevant here).
+const fakeBuiltins = {
+    "file-list": {
+        description: "List files",
+        inputSchema: z.object({ path: z.string() }),
+        execute: async () => null,
+    },
+    "web-search": {
+        description: "Search the web",
+        inputSchema: z.object({ query: z.string() }),
+        execute: async () => null,
+        isAvailable: async () => false,
+    },
+} as unknown as typeof BuiltinTools;
+
+function makeResolver(agent: z.infer<typeof Agent>, deps: Partial<ConstructorParameters<typeof RealAgentResolver>[0]> = {}) {
+    return new RealAgentResolver({
+        load: async () => agent,
+        builtins: fakeBuiltins,
+        defaultModel: DEFAULTS,
+        loadNotes: () => null,
+        loadWorkDir: () => null,
+        ...deps,
+    });
+}
+
+describe("RealAgentResolver", () => {
+    it("applies model precedence: override > agent config > app default", async () => {
+        const withNothing = makeResolver(makeAgent());
+        expect((await withNothing.resolve({ agentId: "copilot" })).model).toEqual({
+            provider: "openai",
+            model: "gpt-default",
+        });
+
+        const withAgentModel = makeResolver(
+            makeAgent({ provider: "anthropic", model: "claude-x" }),
+        );
+        expect(
+            (await withAgentModel.resolve({ agentId: "copilot" })).model,
+        ).toEqual({ provider: "anthropic", model: "claude-x" });
+
+        expect(
+            (
+                await withAgentModel.resolve({
+                    agentId: "copilot",
+                    overrides: { model: { provider: "google", model: "gemini-x" } },
+                })
+            ).model,
+        ).toEqual({ provider: "google", model: "gemini-x" });
+    });
+
+    it("maps builtins to descriptors with JSON schemas, filtering unavailable ones", async () => {
+        const resolver = makeResolver(
+            makeAgent({
+                tools: {
+                    "file-list": { type: "builtin", name: "file-list" },
+                    "web-search": { type: "builtin", name: "web-search" }, // unavailable
+                    ghost: { type: "builtin", name: "ghost" }, // not in catalog
+                },
+            }),
+        );
+        const resolved = await resolver.resolve({ agentId: "copilot" });
+        expect(resolved.tools).toHaveLength(1);
+        expect(resolved.tools[0]).toMatchObject({
+            toolId: "builtin:file-list",
+            name: "file-list",
+            description: "List files",
+            execution: "sync",
+            requiresHuman: false,
+        });
+        expect(resolved.tools[0].inputSchema).toMatchObject({
+            type: "object",
+            properties: { path: { type: "string" } },
+        });
+    });
+
+    it("passes MCP schemas through and skips agent-as-tool attachments", async () => {
+        const resolver = makeResolver(
+            makeAgent({
+                tools: {
+                    lookup: {
+                        type: "mcp",
+                        name: "lookup",
+                        description: "Look things up",
+                        inputSchema: { type: "object", properties: { q: { type: "string" } } },
+                        mcpServerName: "kb",
+                    },
+                    subflow: { type: "agent", name: "researcher" },
+                },
+            }),
+        );
+        const resolved = await resolver.resolve({ agentId: "copilot" });
+        expect(resolved.tools).toHaveLength(1);
+        expect(resolved.tools[0]).toMatchObject({
+            toolId: "mcp:kb:lookup",
+            name: "lookup",
+            description: "Look things up",
+            execution: "sync",
+        });
+    });
+
+    it("maps ask-human to an async human-dependent descriptor", async () => {
+        const resolver = makeResolver(
+            makeAgent({
+                tools: { "ask-human": { type: "builtin", name: "ask-human" } },
+            }),
+        );
+        const resolved = await resolver.resolve({ agentId: "copilot" });
+        expect(resolved.tools[0]).toMatchObject({
+            toolId: "builtin:ask-human",
+            execution: "async",
+            requiresHuman: true,
+        });
+    });
+
+    it("composes the system prompt byte-identically to the shared composer", async () => {
+        const resolver = makeResolver(makeAgent(), {
+            loadNotes: () => "# Agent Notes\nremember X",
+            loadWorkDir: (id) => (id === "sess-1" ? "/Users/me/work" : null),
+        });
+        const resolved = await resolver.resolve({
+            agentId: "copilot",
+            overrides: {
+                composition: {
+                    workDirId: "sess-1",
+                    searchEnabled: true,
+                    codeMode: "claude",
+                },
+            },
+        });
+        expect(resolved.systemPrompt).toBe(
+            composeSystemInstructions({
+                instructions: "You are Copilot.",
+                agentNotesContext: "# Agent Notes\nremember X",
+                userWorkDir: "/Users/me/work",
+                voiceInput: false,
+                voiceOutput: null,
+                searchEnabled: true,
+                codeMode: "claude",
+                codeCwd: null,
+            }),
+        );
+    });
+
+    it("is prompt-stable: identical composition yields identical bytes; unknown keys are ignored", async () => {
+        const resolver = makeResolver(makeAgent());
+        const a = await resolver.resolve({ agentId: "copilot" });
+        const b = await resolver.resolve({
+            agentId: "copilot",
+            overrides: { composition: { someUnknownKey: 42 } },
+        });
+        expect(b.systemPrompt).toBe(a.systemPrompt);
+    });
+
+    it("does not load notes/work-dir for non-copilot agents", async () => {
+        let notesLoaded = 0;
+        const resolver = makeResolver(makeAgent({ name: "background-task-agent" }), {
+            loadNotes: () => {
+                notesLoaded += 1;
+                return "notes";
+            },
+        });
+        await resolver.resolve({ agentId: "background-task-agent" });
+        expect(notesLoaded).toBe(0);
+    });
+
+    it("rejects when the agent cannot be loaded, creating nothing", async () => {
+        const resolver = new RealAgentResolver({
+            load: async () => {
+                throw new Error("no such agent");
+            },
+            builtins: fakeBuiltins,
+            defaultModel: DEFAULTS,
+        });
+        await expect(resolver.resolve({ agentId: "ghost" })).rejects.toThrowError(
+            "no such agent",
+        );
+    });
+});
diff --git a/apps/x/packages/core/src/turns/bridges/real-agent-resolver.ts b/apps/x/packages/core/src/turns/bridges/real-agent-resolver.ts
new file mode 100644
index 00000000..8f2ce1b0
--- /dev/null
+++ b/apps/x/packages/core/src/turns/bridges/real-agent-resolver.ts
@@ -0,0 +1,202 @@
+import { z } from "zod";
+import type { Agent } from "@x/shared/dist/agent.js";
+import {
+    type JsonValue,
+    RequestedAgent,
+    ResolvedAgent,
+    type ToolDescriptor,
+} from "@x/shared/dist/turns.js";
+import {
+    composeSystemInstructions,
+    loadAgent,
+    loadAgentNotesContext,
+    loadUserWorkDir,
+} from "../../agents/runtime.js";
+import { BuiltinTools } from "../../application/lib/builtin-tools.js";
+import { getDefaultModelAndProvider } from "../../models/defaults.js";
+import type { IAgentResolver } from "../agent-resolver.js";
+
+export const ASK_HUMAN_TOOL = "ask-human";
+
+const ASK_HUMAN_DESCRIPTOR: z.infer<typeof ToolDescriptor> = {
+    toolId: `builtin:${ASK_HUMAN_TOOL}`,
+    name: ASK_HUMAN_TOOL,
+    description:
+        "Ask a human before proceeding. Optionally pass `options` (an array of short button labels) when a small set of choices would help the human answer quickly.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            question: {
+                type: "string",
+                description: "The question to ask the human",
+            },
+            options: {
+                type: "array",
+                items: { type: "string" },
+                description: "Optional short button labels the human can pick from",
+            },
+        },
+        required: ["question"],
+        additionalProperties: false,
+    },
+    execution: "async",
+    requiresHuman: true,
+};
+
+// Recognized keys of the opaque RequestedAgent.overrides.composition value.
+// Unknown keys are ignored. Prompt-affecting inputs should be session-sticky:
+// every key here alters system-prompt bytes and therefore busts provider
+// prefix caching when it changes between turns.
+const CompositionOverrides = z.object({
+    workDirId: z.string().nullable().optional(),
+    voiceInput: z.boolean().optional(),
+    voiceOutput: z.enum(["summary", "full"]).nullable().optional(),
+    searchEnabled: z.boolean().optional(),
+    codeMode: z.enum(["claude", "codex"]).nullable().optional(),
+    codeCwd: z.string().nullable().optional(),
+    videoMode: z.boolean().optional(),
+    coachMode: z.boolean().optional(),
+});
+
+export interface RealAgentResolverDeps {
+    load?: typeof loadAgent;
+    builtins?: typeof BuiltinTools;
+    defaultModel?: () => Promise<{ model: string; provider: string }>;
+    loadNotes?: () => string | null;
+    loadWorkDir?: (workDirId: string) => string | null;
+}
+
+// Bridges the existing agent system (loadAgent + dynamic builders, the
+// BuiltinTools catalog, MCP attachments) to the immutable ResolvedAgent
+// snapshot. The composed system prompt is byte-identical to the old
+// runtime's streamAgent assembly for the same inputs.
+export class RealAgentResolver implements IAgentResolver {
+    private readonly load: typeof loadAgent;
+    private readonly builtins: typeof BuiltinTools;
+    private readonly defaultModel: () => Promise<{ model: string; provider: string }>;
+    private readonly loadNotes: () => string | null;
+    private readonly loadWorkDir: (workDirId: string) => string | null;
+
+    constructor(deps: RealAgentResolverDeps = {}) {
+        this.load = deps.load ?? loadAgent;
+        this.builtins = deps.builtins ?? BuiltinTools;
+        this.defaultModel = deps.defaultModel ?? getDefaultModelAndProvider;
+        this.loadNotes = deps.loadNotes ?? loadAgentNotesContext;
+        this.loadWorkDir = deps.loadWorkDir ?? loadUserWorkDir;
+    }
+
+    async resolve(
+        requested: z.infer<typeof RequestedAgent>,
+    ): Promise<z.infer<typeof ResolvedAgent>> {
+        const agent = await this.load(requested.agentId);
+        if (!agent) {
+            throw new Error(`agent not found: ${requested.agentId}`);
+        }
+
+        // Model precedence: createTurn override > agent config > app default.
+        let model = requested.overrides?.model;
+        if (!model) {
+            const fallback = await this.defaultModel();
+            model = {
+                provider: agent.provider ?? fallback.provider,
+                model: agent.model ?? fallback.model,
+            };
+        }
+
+        const parsed = CompositionOverrides.safeParse(
+            requested.overrides?.composition ?? {},
+        );
+        const composition = parsed.success ? parsed.data : {};
+        // Agent notes and work-dir context are copilot-scoped, matching the
+        // old runtime's behavior.
+        const copilotContext =
+            requested.agentId === "copilot" || requested.agentId === "rowboatx";
+        const systemPrompt = composeSystemInstructions({
+            instructions: agent.instructions,
+            agentNotesContext: copilotContext ? this.loadNotes() : null,
+            userWorkDir:
+                copilotContext && composition.workDirId
+                    ? this.loadWorkDir(composition.workDirId)
+                    : null,
+            voiceInput: composition.voiceInput ?? false,
+            voiceOutput: composition.voiceOutput ?? null,
+            searchEnabled: composition.searchEnabled ?? false,
+            codeMode: composition.codeMode ?? null,
+            codeCwd: composition.codeCwd ?? null,
+            videoMode: composition.videoMode ?? false,
+            coachMode: composition.coachMode ?? false,
+        });
+
+        const tools = await this.resolveTools(agent);
+        return ResolvedAgent.parse({
+            agentId: requested.agentId,
+            systemPrompt,
+            model,
+            tools,
+        });
+    }
+
+    private async resolveTools(
+        agent: z.infer<typeof Agent>,
+    ): Promise<Array<z.infer<typeof ToolDescriptor>>> {
+        const tools: Array<z.infer<typeof ToolDescriptor>> = [];
+        for (const [name, attachment] of Object.entries(agent.tools ?? {})) {
+            if (attachment.type === "agent") {
+                continue; // agent-as-tool is not supported in v1
+            }
+            if (attachment.type === "mcp") {
+                tools.push({
+                    toolId: `mcp:${attachment.mcpServerName}:${attachment.name}`,
+                    name,
+                    description: attachment.description,
+                    inputSchema:
+                        toJsonValue(attachment.inputSchema) ??
+                        { type: "object", properties: {} },
+                    execution: "sync",
+                    requiresHuman: false,
+                });
+                continue;
+            }
+            if (name === ASK_HUMAN_TOOL) {
+                tools.push(ASK_HUMAN_DESCRIPTOR);
+                continue;
+            }
+            const builtin = this.builtins[attachment.name];
+            if (!builtin) {
+                continue;
+            }
+            if (builtin.isAvailable && !(await builtin.isAvailable())) {
+                continue;
+            }
+            tools.push({
+                toolId: `builtin:${attachment.name}`,
+                name,
+                description: builtin.description,
+                inputSchema: toJsonSchema(builtin.inputSchema),
+                execution: "sync",
+                requiresHuman: false,
+            });
+        }
+        return tools;
+    }
+}
+
+function toJsonSchema(schema: unknown): JsonValue {
+    try {
+        return toJsonValue(z.toJSONSchema(schema as z.ZodType)) ?? {
+            type: "object",
+            properties: {},
+        };
+    } catch {
+        // An exotic zod schema must not break the whole turn.
+        return { type: "object", properties: {} };
+    }
+}
+
+function toJsonValue(value: unknown): JsonValue | undefined {
+    try {
+        return JSON.parse(JSON.stringify(value)) as JsonValue;
+    } catch {
+        return undefined;
+    }
+}
diff --git a/apps/x/packages/core/src/turns/bridges/real-model-registry.test.ts b/apps/x/packages/core/src/turns/bridges/real-model-registry.test.ts
new file mode 100644
index 00000000..ea0fe990
--- /dev/null
+++ b/apps/x/packages/core/src/turns/bridges/real-model-registry.test.ts
@@ -0,0 +1,214 @@
+import { describe, expect, it } from "vitest";
+import type { LanguageModel } from "ai";
+import type { LlmStreamEvent, ModelStreamRequest } from "../model-registry.js";
+import { RealModelRegistry, type StreamTextInvoker } from "./real-model-registry.js";
+
+type InvokerOptions = Parameters<StreamTextInvoker>[0];
+
+function makeRegistry(parts: Array<Record<string, unknown>>, capture: InvokerOptions[]) {
+    const fakeModel = { modelId: "gpt-test" } as unknown as LanguageModel;
+    return new RealModelRegistry({
+        resolveProvider: async () => ({ flavor: "openai" }),
+        createProviderImpl: (() => ({
+            languageModel: () => fakeModel,
+        })) as never,
+        invoke: (options) => {
+            capture.push(options);
+            return {
+                fullStream: (async function* () {
+                    yield* parts;
+                })(),
+            };
+        },
+    });
+}
+
+function request(overrides: Partial<ModelStreamRequest> = {}): ModelStreamRequest {
+    return {
+        systemPrompt: "SYS",
+        messages: [{ role: "user", content: "hello" }] as ModelStreamRequest["messages"],
+        tools: [
+            {
+                toolId: "builtin:echo",
+                name: "echo",
+                description: "Echo",
+                inputSchema: { type: "object", properties: {} },
+                execution: "sync",
+                requiresHuman: false,
+            },
+        ],
+        parameters: {},
+        signal: new AbortController().signal,
+        ...overrides,
+    };
+}
+
+async function collect(registry: RealModelRegistry, req: ModelStreamRequest) {
+    const model = await registry.resolve({ provider: "openai", model: "gpt-test" });
+    const events: LlmStreamEvent[] = [];
+    for await (const event of model.stream(req)) {
+        events.push(event);
+    }
+    return events;
+}
+
+describe("RealModelRegistry", () => {
+    it("normalizes one streamText step into deltas, step events, and a completed message", async () => {
+        const capture: InvokerOptions[] = [];
+        const registry = makeRegistry(
+            [
+                { type: "start" },
+                { type: "text-start" },
+                { type: "text-delta", text: "Hel" },
+                { type: "text-delta", text: "lo" },
+                { type: "text-end" },
+                { type: "tool-call", toolCallId: "tc1", toolName: "echo", input: { x: 1 } },
+                {
+                    type: "finish-step",
+                    finishReason: "tool-calls",
+                    usage: { inputTokens: 7, outputTokens: 3, totalTokens: 10 },
+                    providerMetadata: { openai: { cached: true } },
+                },
+            ],
+            capture,
+        );
+        const events = await collect(registry, request());
+
+        expect(events.map((e) => e.type)).toEqual([
+            "step_event", // text_start
+            "text_delta",
+            "text_delta",
+            "step_event", // text_end
+            "step_event", // tool_call
+            "step_event", // finish_step
+            "completed",
+        ]);
+        expect(events[3]).toEqual({
+            type: "step_event",
+            event: { type: "text_end", text: "Hello" },
+        });
+        const completed = events[events.length - 1];
+        expect(completed).toMatchObject({
+            type: "completed",
+            finishReason: "tool-calls",
+            usage: { inputTokens: 7, outputTokens: 3, totalTokens: 10 },
+            providerMetadata: { openai: { cached: true } },
+            message: {
+                role: "assistant",
+                content: [
+                    { type: "text", text: "Hello" },
+                    {
+                        type: "tool-call",
+                        toolCallId: "tc1",
+                        toolName: "echo",
+                        arguments: { x: 1 },
+                    },
+                ],
+            },
+        });
+
+        // The invoker received the system prompt, the pre-encoded messages
+        // verbatim (encoding is the composer's job), and the wrapped tools.
+        expect(capture[0].system).toBe("SYS");
+        expect(capture[0].messages).toEqual([{ role: "user", content: "hello" }]);
+        expect(Object.keys(capture[0].tools)).toEqual(["echo"]);
+    });
+
+    it("accumulates reasoning separately and emits reasoning deltas", async () => {
+        const registry = makeRegistry(
+            [
+                { type: "reasoning-start" },
+                { type: "reasoning-delta", text: "thinking…" },
+                { type: "reasoning-end" },
+                { type: "text-start" },
+                { type: "text-delta", text: "done" },
+                { type: "text-end" },
+                { type: "finish-step", finishReason: "stop", usage: {} },
+            ],
+            [],
+        );
+        const events = await collect(registry, request());
+        expect(events.filter((e) => e.type === "reasoning_delta")).toHaveLength(1);
+        const completed = events[events.length - 1];
+        expect(
+            completed.type === "completed" ? completed.message.content : undefined,
+        ).toEqual([
+            { type: "reasoning", text: "thinking…" },
+            { type: "text", text: "done" },
+        ]);
+    });
+
+    it("throws on provider error parts (a model failure, not a completion)", async () => {
+        const registry = makeRegistry(
+            [{ type: "error", error: new Error("rate limited") }],
+            [],
+        );
+        const model = await registry.resolve({ provider: "openai", model: "gpt-test" });
+        await expect(
+            (async () => {
+                for await (const event of model.stream(request())) {
+                    void event;
+                }
+            })(),
+        ).rejects.toThrowError("rate limited");
+    });
+
+    it("encodeMessages produces the LLM-facing wire form (context woven, tool results enveloped)", async () => {
+        const registry = makeRegistry([], []);
+        const model = await registry.resolve({ provider: "openai", model: "gpt-test" });
+        const encoded = model.encodeMessages([
+            {
+                role: "user",
+                content: "list my downloads",
+                userMessageContext: {
+                    currentDateTime: "2026-07-02T10:30:00Z",
+                    middlePane: { kind: "empty" },
+                },
+            },
+            { role: "tool", content: "[…files…]", toolCallId: "tc1", toolName: "file-list" },
+        ]) as Array<{ role: string; content: unknown }>;
+
+        // The user message is the woven wire text, not the internal structure.
+        expect(encoded[0].role).toBe("user");
+        const userText = String(encoded[0].content);
+        expect(userText).toContain("2026-07-02T10:30:00Z");
+        expect(userText).toContain("list my downloads");
+        expect(userText).not.toContain("userMessageContext");
+
+        // Tool output rides the AI SDK tool-result envelope.
+        expect(encoded[1]).toMatchObject({
+            role: "tool",
+            content: [
+                {
+                    type: "tool-result",
+                    toolCallId: "tc1",
+                    output: { type: "text", value: "[…files…]" },
+                },
+            ],
+        });
+    });
+
+    it("stops promptly when the signal aborts mid-stream", async () => {
+        const controller = new AbortController();
+        const registry = makeRegistry(
+            [
+                { type: "text-delta", text: "a" },
+                { type: "text-delta", text: "b" },
+            ],
+            [],
+        );
+        const model = await registry.resolve({ provider: "openai", model: "gpt-test" });
+        const seen: string[] = [];
+        await expect(
+            (async () => {
+                for await (const event of model.stream(
+                    request({ signal: controller.signal }),
+                )) {
+                    seen.push(event.type);
+                    controller.abort();
+                }
+            })(),
+        ).rejects.toThrowError();
+        expect(seen).toEqual(["text_delta"]);
+    });
+});
diff --git a/apps/x/packages/core/src/turns/bridges/real-model-registry.ts b/apps/x/packages/core/src/turns/bridges/real-model-registry.ts
new file mode 100644
index 00000000..f79ef32d
--- /dev/null
+++ b/apps/x/packages/core/src/turns/bridges/real-model-registry.ts
@@ -0,0 +1,261 @@
+import {
+    jsonSchema,
+    stepCountIs,
+    streamText,
+    tool,
+    type LanguageModel,
+    type ModelMessage,
+    type ToolSet,
+} from "ai";
+import type { z } from "zod";
+import type { LlmProvider } from "@x/shared/dist/models.js";
+import type { AssistantContentPart } from "@x/shared/dist/message.js";
+import type { JsonValue, ModelDescriptor, TurnUsage } from "@x/shared/dist/turns.js";
+import { convertFromMessages } from "../../agents/runtime.js";
+import { resolveProviderConfig } from "../../models/defaults.js";
+import { createProvider } from "../../models/models.js";
+import type {
+    IModelRegistry,
+    LlmStreamEvent,
+    ModelStreamRequest,
+    ResolvedModel,
+} from "../model-registry.js";
+
+// Injectable seam over streamText so normalization is testable without a
+// provider. The bridge always requests exactly one step.
+export type StreamTextInvoker = (options: {
+    model: LanguageModel;
+    system: string;
+    messages: ModelMessage[];
+    tools: ToolSet;
+    abortSignal: AbortSignal;
+}) => { fullStream: AsyncIterable<unknown> };
+
+const defaultInvoker: StreamTextInvoker = (options) =>
+    streamText({ ...options, stopWhen: stepCountIs(1) });
+
+export interface RealModelRegistryDeps {
+    resolveProvider?: (name: string) => Promise<z.infer<typeof LlmProvider>>;
+    createProviderImpl?: typeof createProvider;
+    invoke?: StreamTextInvoker;
+}
+
+// Bridges models.json provider configs to live AI SDK models and normalizes
+// one streamText step into LlmStreamEvents. Tools are declared without
+// execute: the turn loop harvests tool calls and runs them itself.
+export class RealModelRegistry implements IModelRegistry {
+    private readonly resolveProvider: (
+        name: string,
+    ) => Promise<z.infer<typeof LlmProvider>>;
+    private readonly createProviderImpl: typeof createProvider;
+    private readonly invoke: StreamTextInvoker;
+
+    constructor(deps: RealModelRegistryDeps = {}) {
+        this.resolveProvider = deps.resolveProvider ?? resolveProviderConfig;
+        this.createProviderImpl = deps.createProviderImpl ?? createProvider;
+        this.invoke = deps.invoke ?? defaultInvoker;
+    }
+
+    async resolve(
+        descriptor: z.infer<typeof ModelDescriptor>,
+    ): Promise<ResolvedModel> {
+        const providerConfig = await this.resolveProvider(descriptor.provider);
+        const provider = this.createProviderImpl(providerConfig);
+        const model = provider.languageModel(descriptor.model);
+        return {
+            descriptor,
+            // The structural -> wire conversion the app uses today: weaves
+            // userMessageContext into the user text, renders attachments,
+            // wraps tool output as tool-result parts. Deterministic and
+            // per-message, so composed requests are byte-stable.
+            encodeMessages: (messages) =>
+                convertFromMessages(messages) as unknown as JsonValue[],
+            stream: (request) => this.run(model, request),
+        };
+    }
+
+    private async *run(
+        model: LanguageModel,
+        request: ModelStreamRequest,
+    ): AsyncGenerator<LlmStreamEvent, void, void> {
+        const tools: ToolSet = {};
+        for (const descriptor of request.tools) {
+            tools[descriptor.name] = tool({
+                ...(descriptor.description
+                    ? { description: descriptor.description }
+                    : {}),
+                inputSchema: jsonSchema(
+                    (descriptor.inputSchema ?? {
+                        type: "object",
+                        properties: {},
+                    }) as Parameters<typeof jsonSchema>[0],
+                ),
+            });
+        }
+
+        const result = this.invoke({
+            model,
+            system: request.systemPrompt,
+            messages: request.messages as ModelMessage[],
+            tools,
+            abortSignal: request.signal,
+        });
+
+        const parts: Array<z.infer<typeof AssistantContentPart>> = [];
+        let textBuffer = "";
+        let reasoningBuffer = "";
+        let finishReason = "unknown";
+        let usage: z.infer<typeof TurnUsage> = {};
+        let providerMetadata: JsonValue | undefined;
+
+        for await (const raw of result.fullStream) {
+            request.signal.throwIfAborted();
+            const event = raw as {
+                type: string;
+                text?: string;
+                toolCallId?: string;
+                toolName?: string;
+                input?: unknown;
+                finishReason?: string;
+                usage?: Record<string, number | undefined>;
+                providerMetadata?: unknown;
+                error?: unknown;
+            };
+            switch (event.type) {
+                case "text-start":
+                    textBuffer = "";
+                    yield { type: "step_event", event: { type: "text_start" } };
+                    break;
+                case "text-delta": {
+                    const delta = event.text ?? "";
+                    textBuffer += delta;
+                    const last = parts[parts.length - 1];
+                    if (last?.type === "text") {
+                        last.text += delta;
+                    } else {
+                        parts.push({ type: "text", text: delta });
+                    }
+                    yield { type: "text_delta", delta };
+                    break;
+                }
+                case "text-end":
+                    yield {
+                        type: "step_event",
+                        event: { type: "text_end", text: textBuffer },
+                    };
+                    break;
+                case "reasoning-start":
+                    reasoningBuffer = "";
+                    yield { type: "step_event", event: { type: "reasoning_start" } };
+                    break;
+                case "reasoning-delta": {
+                    const delta = event.text ?? "";
+                    reasoningBuffer += delta;
+                    const last = parts[parts.length - 1];
+                    if (last?.type === "reasoning") {
+                        last.text += delta;
+                    } else {
+                        parts.push({ type: "reasoning", text: delta });
+                    }
+                    yield { type: "reasoning_delta", delta };
+                    break;
+                }
+                case "reasoning-end":
+                    yield {
+                        type: "step_event",
+                        event: { type: "reasoning_end", text: reasoningBuffer },
+                    };
+                    break;
+                case "tool-call": {
+                    const toolCall = {
+                        type: "tool-call" as const,
+                        toolCallId: String(event.toolCallId),
+                        toolName: String(event.toolName),
+                        arguments: event.input,
+                    };
+                    parts.push(toolCall);
+                    yield { type: "step_event", event: { type: "tool_call", toolCall } };
+                    break;
+                }
+                case "finish-step": {
+                    finishReason = event.finishReason ?? "unknown";
+                    usage = mapUsage(event.usage);
+                    providerMetadata = toJsonValue(event.providerMetadata);
+                    yield {
+                        type: "step_event",
+                        event: {
+                            type: "finish_step",
+                            finishReason,
+                            usage,
+                            ...(providerMetadata === undefined
+                                ? {}
+                                : { providerMetadata }),
+                        },
+                    };
+                    break;
+                }
+                case "error":
+                    throw event.error instanceof Error
+                        ? event.error
+                        : new Error(formatStreamError(event.error));
+                default:
+                    break;
+            }
+        }
+
+        yield {
+            type: "completed",
+            message: {
+                role: "assistant",
+                content: parts.length > 0 ? parts : "",
+            },
+            finishReason,
+            usage,
+            ...(providerMetadata === undefined ? {} : { providerMetadata }),
+        };
+    }
+}
+
+function mapUsage(
+    usage: Record<string, number | undefined> | undefined,
+): z.infer<typeof TurnUsage> {
+    const mapped: z.infer<typeof TurnUsage> = {};
+    if (!usage) {
+        return mapped;
+    }
+    for (const key of [
+        "inputTokens",
+        "outputTokens",
+        "totalTokens",
+        "reasoningTokens",
+        "cachedInputTokens",
+    ] as const) {
+        const value = usage[key];
+        if (typeof value === "number" && Number.isFinite(value)) {
+            mapped[key] = value;
+        }
+    }
+    return mapped;
+}
+
+function toJsonValue(value: unknown): JsonValue | undefined {
+    if (value === undefined || value === null) {
+        return undefined;
+    }
+    try {
+        return JSON.parse(JSON.stringify(value)) as JsonValue;
+    } catch {
+        return undefined;
+    }
+}
+
+function formatStreamError(error: unknown): string {
+    if (typeof error === "string") {
+        return error;
+    }
+    try {
+        return JSON.stringify(error);
+    } catch {
+        return String(error);
+    }
+}
diff --git a/apps/x/packages/core/src/turns/bridges/real-permission-checker.test.ts b/apps/x/packages/core/src/turns/bridges/real-permission-checker.test.ts
new file mode 100644
index 00000000..2967b6ae
--- /dev/null
+++ b/apps/x/packages/core/src/turns/bridges/real-permission-checker.test.ts
@@ -0,0 +1,72 @@
+import { describe, expect, it } from "vitest";
+import type { getToolPermissionMetadata } from "../../agents/runtime.js";
+import { RealPermissionChecker } from "./real-permission-checker.js";
+
+type MetadataFn = typeof getToolPermissionMetadata;
+type MetadataCall = {
+    toolCall: Parameters<MetadataFn>[0];
+    attachment: Parameters<MetadataFn>[1];
+};
+
+function makeChecker(result: Awaited<ReturnType<MetadataFn>> | Error) {
+    const calls: MetadataCall[] = [];
+    const checker = new RealPermissionChecker({
+        getMetadata: (async (toolCall, attachment) => {
+            calls.push({ toolCall, attachment });
+            if (result instanceof Error) {
+                throw result;
+            }
+            return result;
+        }) as MetadataFn,
+    });
+    return { checker, calls };
+}
+
+const input = {
+    turnId: "turn-1",
+    toolCallId: "tc-1",
+    toolId: "builtin:executeCommand",
+    toolName: "executeCommand",
+    input: { command: "rm -rf /" },
+};
+
+describe("RealPermissionChecker", () => {
+    it("gates builtins through getToolPermissionMetadata with empty session grants", async () => {
+        const metadata = { kind: "command" as const, commandNames: ["rm"] };
+        const { checker, calls } = makeChecker(metadata);
+        const result = await checker.check(input);
+        expect(result).toEqual({ required: true, request: metadata });
+        expect(calls[0].toolCall).toMatchObject({
+            type: "tool-call",
+            toolCallId: "tc-1",
+            toolName: "executeCommand",
+            arguments: { command: "rm -rf /" },
+        });
+        expect(calls[0].attachment).toEqual({
+            type: "builtin",
+            name: "executeCommand",
+        });
+    });
+
+    it("returns not-required when metadata is null", async () => {
+        const { checker } = makeChecker(null);
+        expect(await checker.check(input)).toEqual({ required: false });
+    });
+
+    it("never gates non-builtin tools", async () => {
+        const { checker, calls } = makeChecker(new Error("must not be called"));
+        expect(
+            await checker.check({
+                ...input,
+                toolId: "mcp:kb:search",
+                toolName: "search",
+            }),
+        ).toEqual({ required: false });
+        expect(calls).toHaveLength(0);
+    });
+
+    it("propagates metadata errors so the loop fails closed", async () => {
+        const { checker } = makeChecker(new Error("policy exploded"));
+        await expect(checker.check(input)).rejects.toThrowError("policy exploded");
+    });
+});
diff --git a/apps/x/packages/core/src/turns/bridges/real-permission-checker.ts b/apps/x/packages/core/src/turns/bridges/real-permission-checker.ts
new file mode 100644
index 00000000..50fec935
--- /dev/null
+++ b/apps/x/packages/core/src/turns/bridges/real-permission-checker.ts
@@ -0,0 +1,49 @@
+import type { JsonValue } from "@x/shared/dist/turns.js";
+import { getToolPermissionMetadata } from "../../agents/runtime.js";
+import type {
+    IPermissionChecker,
+    PermissionCheckAllowed,
+    PermissionCheckInput,
+    PermissionCheckRequired,
+} from "../permission.js";
+
+export interface RealPermissionCheckerDeps {
+    getMetadata?: typeof getToolPermissionMetadata;
+}
+
+// Bridges the existing deterministic permission rules: only builtins are
+// gated (executeCommand via the command allowlist, file tools via workspace
+// boundaries and file-access grants). Session-scoped grants are deferred, so
+// the session grant inputs are always empty. A thrown metadata error
+// propagates: the turn loop fails closed on checker errors.
+export class RealPermissionChecker implements IPermissionChecker {
+    private readonly getMetadata: typeof getToolPermissionMetadata;
+
+    constructor(deps: RealPermissionCheckerDeps = {}) {
+        this.getMetadata = deps.getMetadata ?? getToolPermissionMetadata;
+    }
+
+    async check(
+        input: PermissionCheckInput,
+    ): Promise<PermissionCheckAllowed | PermissionCheckRequired> {
+        if (!input.toolId.startsWith("builtin:")) {
+            return { required: false };
+        }
+        const name = input.toolId.slice("builtin:".length);
+        const metadata = await this.getMetadata(
+            {
+                type: "tool-call",
+                toolCallId: input.toolCallId,
+                toolName: input.toolName,
+                arguments: input.input,
+            },
+            { type: "builtin", name },
+            new Set<string>(), // session-scoped command grants: deferred
+            [], // session-scoped file grants: deferred
+        );
+        if (!metadata) {
+            return { required: false };
+        }
+        return { required: true, request: metadata as JsonValue };
+    }
+}
diff --git a/apps/x/packages/core/src/turns/bridges/real-permission-classifier.test.ts b/apps/x/packages/core/src/turns/bridges/real-permission-classifier.test.ts
new file mode 100644
index 00000000..23312fca
--- /dev/null
+++ b/apps/x/packages/core/src/turns/bridges/real-permission-classifier.test.ts
@@ -0,0 +1,98 @@
+import { describe, expect, it } from "vitest";
+import type { classifyToolPermissions } from "../../security/auto-permission-classifier.js";
+import { RealPermissionClassifier } from "./real-permission-classifier.js";
+
+type ClassifierFn = typeof classifyToolPermissions;
+type ClassifierInput = Parameters<ClassifierFn>[0];
+
+function makeClassifier(
+    decisions: Awaited<ReturnType<ClassifierFn>> | Error,
+) {
+    const calls: ClassifierInput[] = [];
+    const classifier = new RealPermissionClassifier({
+        classifier: (async (input) => {
+            calls.push(input);
+            if (decisions instanceof Error) {
+                throw decisions;
+            }
+            return decisions;
+        }) as ClassifierFn,
+    });
+    return { classifier, calls };
+}
+
+const batch = {
+    turnId: "turn-1",
+    messages: [
+        { role: "user" as const, content: "list my downloads" },
+        { role: "assistant" as const, content: "sure" },
+    ],
+    requests: [
+        {
+            toolCallId: "tc-1",
+            toolName: "file-list",
+            input: { path: "/Users/me/Downloads" },
+            request: {
+                kind: "file",
+                operation: "list",
+                paths: ["/Users/me/Downloads"],
+                pathPrefix: "/Users/me/Downloads",
+            },
+        },
+    ],
+};
+
+describe("RealPermissionClassifier", () => {
+    it("adapts the batch into classifyToolPermissions candidates with conversation context", async () => {
+        const { classifier, calls } = makeClassifier([
+            { toolCallId: "tc-1", decision: "allow", reason: "user asked for it" },
+        ]);
+        const decisions = await classifier.classify(batch);
+
+        expect(decisions).toEqual([
+            { toolCallId: "tc-1", decision: "allow", reason: "user asked for it" },
+        ]);
+        expect(calls[0].runId).toBe("turn-1");
+        expect(calls[0].useCase).toBe("copilot_chat");
+        expect(calls[0].messages).toHaveLength(2);
+        expect(calls[0].candidates[0]).toMatchObject({
+            toolCall: {
+                type: "tool-call",
+                toolCallId: "tc-1",
+                toolName: "file-list",
+            },
+            permission: { kind: "file", operation: "list" },
+        });
+    });
+
+    it("returns an empty result for an empty batch without calling the LLM", async () => {
+        const { classifier, calls } = makeClassifier(new Error("must not be called"));
+        expect(
+            await classifier.classify({ ...batch, requests: [] }),
+        ).toEqual([]);
+        expect(calls).toHaveLength(0);
+    });
+
+    it("omitted decisions surface as missing entries (loop treats them as defer)", async () => {
+        const { classifier } = makeClassifier([]);
+        const decisions = await classifier.classify(batch);
+        expect(decisions).toEqual([]);
+    });
+
+    it("propagates classifier failures (loop normalizes to defer)", async () => {
+        const { classifier } = makeClassifier(new Error("llm unavailable"));
+        await expect(classifier.classify(batch)).rejects.toThrowError(
+            "llm unavailable",
+        );
+    });
+
+    it("rejects malformed permission metadata via schema parsing", async () => {
+        const { classifier } = makeClassifier([]);
+        await expect(
+            classifier.classify({
+                ...batch,
+                requests: [{ ...batch.requests[0], request: { kind: "nonsense" } }],
+            }),
+        ).rejects.toThrowError();
+    });
+});
diff --git a/apps/x/packages/core/src/turns/bridges/real-permission-classifier.ts b/apps/x/packages/core/src/turns/bridges/real-permission-classifier.ts
new file mode 100644
index 00000000..1d5732d6
--- /dev/null
+++ b/apps/x/packages/core/src/turns/bridges/real-permission-classifier.ts
@@ -0,0 +1,57 @@
+import { ToolPermissionMetadata } from "@x/shared/dist/runs.js";
+import { convertFromMessages } from "../../agents/runtime.js";
+import type { UseCase } from "../../analytics/use_case.js";
+import { classifyToolPermissions } from "../../security/auto-permission-classifier.js";
+import type {
+    IPermissionClassifier,
+    PermissionClassification,
+    PermissionClassificationBatch,
+} from "../permission.js";
+
+export interface RealPermissionClassifierDeps {
+    classifier?: typeof classifyToolPermissions;
+    useCase?: UseCase;
+}
+
+// Bridges the existing LLM auto-permission classifier. The underlying
+// classifier only ever answers allow/deny; omitted decisions surface as
+// missing entries, which the turn loop records as classification failures
+// and treats as defer. A parse/LLM failure throws, which the loop likewise
+// normalizes to defer for the whole batch.
+export class RealPermissionClassifier implements IPermissionClassifier {
+    private readonly classifier: typeof classifyToolPermissions;
+    private readonly useCase: UseCase;
+
+    constructor(deps: RealPermissionClassifierDeps = {}) {
+        this.classifier = deps.classifier ?? classifyToolPermissions;
+        this.useCase = deps.useCase ?? "copilot_chat";
+    }
+
+    async classify(
+        batch: PermissionClassificationBatch,
+    ): Promise<PermissionClassification[]> {
+        if (batch.requests.length === 0) {
+            return [];
+        }
+        const decisions = await this.classifier({
+            runId: batch.turnId,
+            agentName: null,
+            messages: convertFromMessages(batch.messages),
+            candidates: batch.requests.map((request) => ({
+                toolCall: {
+                    type: "tool-call",
+                    toolCallId: request.toolCallId,
+                    toolName: request.toolName,
+                    arguments: request.input,
+                },
+                permission: ToolPermissionMetadata.parse(request.request),
+            })),
+            useCase: this.useCase,
+        });
+        return decisions.map((decision) => ({
+            toolCallId: decision.toolCallId,
+            decision: decision.decision,
+            reason: decision.reason,
+        }));
+    }
+}
diff --git a/apps/x/packages/core/src/turns/bridges/real-tool-registry.test.ts b/apps/x/packages/core/src/turns/bridges/real-tool-registry.test.ts
new file mode 100644
index 00000000..4fb6113e
--- /dev/null
+++ b/apps/x/packages/core/src/turns/bridges/real-tool-registry.test.ts
@@ -0,0 +1,198 @@
+import { describe, expect, it } from "vitest";
+import type { z } from "zod";
+import type { ToolDescriptor } from "@x/shared/dist/turns.js";
+import type { execTool } from "../../application/lib/exec-tool.js";
+import type { BuiltinTools } from "../../application/lib/builtin-tools.js";
+import type { IAbortRegistry } from "../../runs/abort-registry.js";
+import { TurnDependencyError } from "../api.js";
+import type { SyncRuntimeTool, ToolExecutionContext } from "../tool-registry.js";
+import { RealToolRegistry } from "./real-tool-registry.js";
+
+type ExecCall = {
+    attachment: Parameters<typeof execTool>[0];
+    input: Record<string, unknown>;
+    ctx: NonNullable<Parameters<typeof execTool>[2]>;
+};
+
+class FakeAbortRegistry implements IAbortRegistry {
+    calls: string[] = [];
+    createForRun(runId: string): AbortSignal {
+        this.calls.push(`create:${runId}`);
+        return new AbortController().signal;
+    }
+    registerProcess(): void {}
+    unregisterProcess(): void {}
+    abort(runId: string): void {
+        this.calls.push(`abort:${runId}`);
+    }
+    forceAbort(): void {}
+    isAborted(): boolean {
+        return false;
+    }
+    cleanup(runId: string): void {
+        this.calls.push(`cleanup:${runId}`);
+    }
+}
+
+const fakeBuiltins = {
+    echo: { description: "Echo", inputSchema: {}, execute: async () => null },
+} as unknown as typeof BuiltinTools;
+
+function descriptor(
+    overrides: Partial<z.infer<typeof ToolDescriptor>> = {},
+): z.infer<typeof ToolDescriptor> {
+    return {
+        toolId: "builtin:echo",
+        name: "echo",
+        description: "Echo",
+        inputSchema: {},
+        execution: "sync",
+        requiresHuman: false,
+        ...overrides,
+    };
+}
+
+function makeCtx(overrides: Partial<ToolExecutionContext> = {}): ToolExecutionContext & {
+    progress: unknown[];
+} {
+    const progress: unknown[] = [];
+    return {
+        turnId: "turn-1",
+        toolCallId: "tc-1",
+        signal: new AbortController().signal,
+        reportProgress: async (p) => {
+            progress.push(p);
+        },
+        progress,
+        ...overrides,
+    };
+}
+
+function makeRegistry(execImpl: (call: ExecCall) => Promise<unknown>) {
+    const calls: ExecCall[] = [];
+    const abortRegistry = new FakeAbortRegistry();
+    const registry = new RealToolRegistry({
+        execToolImpl: (async (attachment, input, ctx) => {
+            const call = { attachment, input, ctx: ctx! };
+            calls.push(call);
+            return execImpl(call);
+        }) as typeof execTool,
+        abortRegistry,
+        builtins: fakeBuiltins,
+    });
+    return { registry, calls, abortRegistry };
+}
+
+describe("RealToolRegistry", () => {
+    it("executes builtins through execTool with a turn-scoped ToolContext", async () => {
+        const { registry, calls, abortRegistry } = makeRegistry(async () => ({ ok: 1 }));
+        const tool = (await registry.resolve(descriptor())) as SyncRuntimeTool;
+        const ctx = makeCtx();
+        const result = await tool.execute({ text: "hi" }, ctx);
+
+        expect(result).toEqual({ output: { ok: 1 }, isError: false });
+        expect(calls[0].attachment).toEqual({ type: "builtin", name: "echo" });
+        expect(calls[0].input).toEqual({ text: "hi" });
+        expect(calls[0].ctx).toMatchObject({ runId: "turn-1", toolCallId: "tc-1" });
+        // Abort registry bracketed per call.
+        expect(abortRegistry.calls).toEqual(["create:turn-1", "cleanup:turn-1"]);
+    });
+
+    it("normalizes undefined results to null and serializes objects", async () => {
+        const { registry } = makeRegistry(async () => undefined);
+        const tool = (await registry.resolve(descriptor())) as SyncRuntimeTool;
+        expect(await tool.execute({}, makeCtx())).toEqual({
+            output: null,
+            isError: false,
+        });
+    });
+
+    it("forwards tool-output-stream publishes as progress", async () => {
+        const { registry } = makeRegistry(async ({ ctx }) => {
+            await ctx.publish({
+                runId: "turn-1",
+                type: "tool-output-stream",
+                toolCallId: "tc-1",
+                toolName: "echo",
+                output: "chunk-1",
+                subflow: [],
+            });
+            return "done";
+        });
+        const tool = (await registry.resolve(descriptor())) as SyncRuntimeTool;
+        const ctx = makeCtx();
+        await tool.execute({}, ctx);
+        expect(ctx.progress).toEqual([{ kind: "tool-output", chunk: "chunk-1" }]);
+    });
+
+    it("wires the abort signal to the registry's force-kill path", async () => {
+        const controller = new AbortController();
+        const { registry, abortRegistry } = makeRegistry(async () => {
+            controller.abort();
+            return "late";
+        });
+        const tool = (await registry.resolve(descriptor())) as SyncRuntimeTool;
+        await tool.execute({}, makeCtx({ signal: controller.signal }));
+        expect(abortRegistry.calls).toEqual([
+            "create:turn-1",
+            "abort:turn-1",
+            "cleanup:turn-1",
+        ]);
+    });
+
+    it("lets tool errors propagate (the loop converts them to error results) and still cleans up", async () => {
+        const { registry, abortRegistry } = makeRegistry(async () => {
+            throw new Error("tool exploded");
+        });
+        const tool = (await registry.resolve(descriptor())) as SyncRuntimeTool;
+        await expect(tool.execute({}, makeCtx())).rejects.toThrowError("tool exploded");
+        expect(abortRegistry.calls).toEqual(["create:turn-1", "cleanup:turn-1"]);
+    });
+
+    it("resolves mcp descriptors into mcp attachments (server:tool split on first colon)", async () => {
+        const { registry, calls } = makeRegistry(async () => "mcp result");
+        const tool = (await registry.resolve(
+            descriptor({
+                toolId: "mcp:kb:search:advanced",
+                name: "search:advanced",
+                description: "Search KB",
+                inputSchema: { type: "object" },
+            }),
+        )) as SyncRuntimeTool;
+        await tool.execute({ q: "x" }, makeCtx());
+        expect(calls[0].attachment).toEqual({
+            type: "mcp",
+            name: "search:advanced",
+            mcpServerName: "kb",
+            description: "Search KB",
+            inputSchema: { type: "object" },
+        });
+    });
+
+    it("resolves ask-human as an async tool with no executor", async () => {
+        const { registry } = makeRegistry(async () => null);
+        const tool = await registry.resolve(
+            descriptor({
+                toolId: "builtin:ask-human",
+                name: "ask-human",
+                execution: "async",
+                requiresHuman: true,
+            }),
+        );
+        expect("execute" in tool).toBe(false);
+        expect(tool.descriptor.execution).toBe("async");
+    });
+
+    it("rejects unknown builtins and malformed toolIds as dependency errors", async () => {
+        const { registry } = makeRegistry(async () => null);
+        await expect(
+            registry.resolve(descriptor({ toolId: "builtin:ghost", name: "ghost" })),
+        ).rejects.toThrowError(TurnDependencyError);
+        await expect(
+            registry.resolve(descriptor({ toolId: "mcp:onlyserver" })),
+        ).rejects.toThrowError(TurnDependencyError);
+        await expect(
+            registry.resolve(descriptor({ toolId: "weird:scheme" })),
+        ).rejects.toThrowError(TurnDependencyError);
+    });
+});
diff --git a/apps/x/packages/core/src/turns/bridges/real-tool-registry.ts b/apps/x/packages/core/src/turns/bridges/real-tool-registry.ts
new file mode 100644
index 00000000..697978ab
--- /dev/null
+++ b/apps/x/packages/core/src/turns/bridges/real-tool-registry.ts
@@ -0,0 +1,141 @@
+import type { z } from "zod";
+import type { ToolAttachment } from "@x/shared/dist/agent.js";
+import type { JsonValue, ToolDescriptor } from "@x/shared/dist/turns.js";
+import { execTool } from "../../application/lib/exec-tool.js";
+import { BuiltinTools } from "../../application/lib/builtin-tools.js";
+import {
+    type IAbortRegistry,
+    InMemoryAbortRegistry,
+} from "../../runs/abort-registry.js";
+import { TurnDependencyError } from "../api.js";
+import type {
+    IToolRegistry,
+    RuntimeTool,
+    SyncRuntimeTool,
+    ToolExecutionContext,
+} from "../tool-registry.js";
+import { ASK_HUMAN_TOOL } from "./real-agent-resolver.js";
+
+export interface RealToolRegistryDeps {
+    execToolImpl?: typeof execTool;
+    abortRegistry?: IAbortRegistry;
+    builtins?: typeof BuiltinTools;
+}
+
+// Bridges persisted tool descriptors to the existing dispatch: builtins via
+// the BuiltinTools catalog, MCP tools via execTool's MCP path. toolId encodes
+// the attachment: "builtin:<name>" or "mcp:<server>:<tool>". ask-human is the
+// async human-dependent tool with no in-process executor.
+export class RealToolRegistry implements IToolRegistry {
+    private readonly execToolImpl: typeof execTool;
+    private readonly abortRegistry: IAbortRegistry;
+    private readonly builtins: typeof BuiltinTools;
+
+    constructor(deps: RealToolRegistryDeps = {}) {
+        this.execToolImpl = deps.execToolImpl ?? execTool;
+        this.abortRegistry = deps.abortRegistry ?? new InMemoryAbortRegistry();
+        this.builtins = deps.builtins ?? BuiltinTools;
+    }
+
+    async resolve(
+        descriptor: z.infer<typeof ToolDescriptor>,
+    ): Promise<RuntimeTool> {
+        if (descriptor.toolId === `builtin:${ASK_HUMAN_TOOL}`) {
+            return {
+                descriptor: descriptor as { execution: "async" } & z.infer<
+                    typeof ToolDescriptor
+                >,
+            };
+        }
+        if (descriptor.toolId.startsWith("builtin:")) {
+            const name = descriptor.toolId.slice("builtin:".length);
+            const builtin = this.builtins[name];
+            if (!builtin?.execute) {
+                throw new TurnDependencyError(
+                    `no live builtin tool for ${descriptor.toolId}`,
+                );
+            }
+            return this.syncTool(descriptor, { type: "builtin", name });
+        }
+        if (descriptor.toolId.startsWith("mcp:")) {
+            const rest = descriptor.toolId.slice("mcp:".length);
+            const separator = rest.indexOf(":");
+            if (separator <= 0 || separator === rest.length - 1) {
+                throw new TurnDependencyError(
+                    `malformed mcp toolId: ${descriptor.toolId}`,
+                );
+            }
+            return this.syncTool(descriptor, {
+                type: "mcp",
+                name: rest.slice(separator + 1),
+                mcpServerName: rest.slice(0, separator),
+                description: descriptor.description,
+                inputSchema: descriptor.inputSchema,
+            });
+        }
+        throw new TurnDependencyError(
+            `unrecognized toolId scheme: ${descriptor.toolId}`,
+        );
+    }
+
+    private syncTool(
+        descriptor: z.infer<typeof ToolDescriptor>,
+        attachment: z.infer<typeof ToolAttachment>,
+    ): SyncRuntimeTool {
+        return {
+            descriptor: descriptor as { execution: "sync" } & z.infer<
+                typeof ToolDescriptor
+            >,
+            execute: async (input, ctx: ToolExecutionContext) => {
+                // AbortSignal is the primary kill path; the abort registry is
+                // the secondary force-kill for spawned child processes,
+                // bracketed per call and keyed by turn.
+                this.abortRegistry.createForRun(ctx.turnId);
+                const onAbort = () => this.abortRegistry.abort(ctx.turnId);
+                ctx.signal.addEventListener("abort", onAbort, { once: true });
+                try {
+                    const value = await this.execToolImpl(
+                        attachment,
+                        asArgs(input),
+                        {
+                            runId: ctx.turnId,
+                            toolCallId: ctx.toolCallId,
+                            signal: ctx.signal,
+                            abortRegistry: this.abortRegistry,
+                            publish: async (event) => {
+                                if (event.type === "tool-output-stream") {
+                                    await ctx.reportProgress({
+                                        kind: "tool-output",
+                                        chunk: event.output,
+                                    });
+                                }
+                            },
+                        },
+                    );
+                    return {
+                        output: toJsonValue(value === undefined ? null : value),
+                        isError: false,
+                    };
+                } finally {
+                    ctx.signal.removeEventListener("abort", onAbort);
+                    this.abortRegistry.cleanup(ctx.turnId);
+                }
+            },
+        };
+    }
+}
+
+function asArgs(input: unknown): Record<string, unknown> {
+    return input && typeof input === "object"
+        ? (input as Record<string, unknown>)
+        : {};
+}
+
+function toJsonValue(value: unknown): JsonValue {
+    try {
+        const parsed: unknown = JSON.parse(JSON.stringify(value));
+        return parsed === undefined ? null : (parsed as JsonValue);
+    } catch {
+        return String(value);
+    }
+}
diff --git a/apps/x/packages/core/src/turns/bridges/real-usage-reporter.ts b/apps/x/packages/core/src/turns/bridges/real-usage-reporter.ts
new file mode 100644
index 00000000..99d004e5
--- /dev/null
+++ b/apps/x/packages/core/src/turns/bridges/real-usage-reporter.ts
@@ -0,0 +1,22 @@
+import { captureLlmUsage } from "../../analytics/usage.js";
+import { getCurrentUseCase } from "../../analytics/use_case.js";
+import type { IUsageReporter, ModelUsageReport } from "../usage-reporter.js";
+
+// Reports each completed model call as the same `llm_usage` PostHog event
+// the old run loop emitted. The use case comes from the AsyncLocalStorage
+// context the caller established (headless runners wrap startHeadlessAgent
+// in withUseCase); UI-driven session turns have no context and default to
+// copilot_chat — matching the old createRun default.
+export class RealUsageReporter implements IUsageReporter {
+    reportModelUsage(report: ModelUsageReport): void {
+        const context = getCurrentUseCase();
+        captureLlmUsage({
+            useCase: context?.useCase ?? "copilot_chat",
+            ...(context?.subUseCase ? { subUseCase: context.subUseCase } : {}),
+            agentName: report.agentId,
+            model: report.model.model,
+            provider: report.model.provider,
+            usage: report.usage,
+        });
+    }
+}
diff --git a/apps/x/packages/core/src/turns/bus.ts b/apps/x/packages/core/src/turns/bus.ts
new file mode 100644
index 00000000..2a6b0fe4
--- /dev/null
+++ b/apps/x/packages/core/src/turns/bus.ts
@@ -0,0 +1,39 @@
+// Ephemeral process-lifecycle events (turn-runtime-design.md §17). Never
+// persisted, never replayed; if the process crashes the information
+// disappears, which accurately reflects that no execution is known active.
+export interface TurnProcessingStart {
+    type: "turn-processing-start";
+    turnId: string;
+}
+
+export interface TurnProcessingEnd {
+    type: "turn-processing-end";
+    turnId: string;
+}
+
+export type TurnLifecycleEvent = TurnProcessingStart | TurnProcessingEnd;
+
+export interface ITurnLifecycleBus {
+    publish(event: TurnLifecycleEvent): void;
+}
+
+// Default in-process fan-out. Observers must never affect turn semantics, so
+// listener errors are swallowed.
+export class EmitterTurnLifecycleBus implements ITurnLifecycleBus {
+    private listeners = new Set<(event: TurnLifecycleEvent) => void>();
+
+    publish(event: TurnLifecycleEvent): void {
+        for (const listener of this.listeners) {
+            try {
+                listener(event);
+            } catch {
+                // observational only
+            }
+        }
+    }
+
+    subscribe(listener: (event: TurnLifecycleEvent) => void): () => void {
+        this.listeners.add(listener);
+        return () => this.listeners.delete(listener);
+    }
+}
diff --git a/apps/x/packages/core/src/turns/clock.ts b/apps/x/packages/core/src/turns/clock.ts
new file mode 100644
index 00000000..a88a3122
--- /dev/null
+++ b/apps/x/packages/core/src/turns/clock.ts
@@ -0,0 +1,11 @@
+// Deterministic timestamp seam. No IClock existed in the codebase before the
+// turn runtime; production uses SystemClock, tests inject fixed clocks.
+export interface IClock {
+    now(): string; // ISO-8601 timestamp
+}
+
+export class SystemClock implements IClock {
+    now(): string {
+        return new Date().toISOString();
+    }
+}
diff --git a/apps/x/packages/core/src/turns/compose-model-request.ts b/apps/x/packages/core/src/turns/compose-model-request.ts
new file mode 100644
index 00000000..9811e9c0
--- /dev/null
+++ b/apps/x/packages/core/src/turns/compose-model-request.ts
@@ -0,0 +1,68 @@
+import type { z } from "zod";
+import {
+    type ConversationMessage,
+    type JsonValue,
+    type ResolvedAgent,
+    type ToolDescriptor,
+    type TurnState,
+    requestMessagesFor,
+} from "@x/shared/dist/turns.js";
+import type { IContextResolver } from "./context-resolver.js";
+
+// The exact provider payload for one model call, rebuilt deterministically
+// from durable state (turn-runtime-design.md §8.3):
+//   - systemPrompt and tools come from the resolved agent snapshot (their
+//     single canonical copy in turn_created),
+//   - messages are the cross-turn prefix plus every request's reference list
+//     resolved against the turn's own events, encoded to wire form.
+// This is the SAME code path the loop sends through, so the debug view and
+// the transmitted bytes cannot diverge.
+export interface ComposedModelRequest {
+    systemPrompt: string;
+    messages: JsonValue[];
+    tools: Array<z.infer<typeof ToolDescriptor>>;
+    parameters: Record<string, JsonValue>;
+}
+
+export function composeModelRequest(
+    state: TurnState,
+    modelCallIndex: number,
+    // The materialized cross-turn prefix (contextResolver output). Ignored
+    // for inline-context turns, whose context rides the {context} ref.
+    resolvedPrefix: Array<z.infer<typeof ConversationMessage>>,
+    // The materialized agent snapshot (contextResolver.resolveAgent output —
+    // inherited snapshots must be resolved before composing).
+    agent: z.infer<typeof ResolvedAgent>,
+    encode: (messages: Array<z.infer<typeof ConversationMessage>>) => JsonValue[],
+): ComposedModelRequest {
+    const call = state.modelCalls[modelCallIndex];
+    if (!call) {
+        throw new Error(`no model call at index ${modelCallIndex}`);
+    }
+    const prefix = Array.isArray(state.definition.context) ? [] : resolvedPrefix;
+    const structural = [...prefix];
+    for (let index = 0; index <= modelCallIndex; index++) {
+        structural.push(...requestMessagesFor(state, index));
+    }
+    return {
+        systemPrompt: agent.systemPrompt,
+        messages: encode(structural),
+        tools: agent.tools,
+        parameters: call.request.parameters,
+    };
+}
+
+// Debug/materialization convenience: compose from durable state alone,
+// resolving the cross-turn prefix through the context resolver.
+export async function materializeModelRequest(
+    state: TurnState,
+    modelCallIndex: number,
+    contextResolver: IContextResolver,
+    encode: (messages: Array<z.infer<typeof ConversationMessage>>) => JsonValue[],
+): Promise<ComposedModelRequest> {
+    const prefix = await contextResolver.resolve(state.definition.context);
+    const agent = await contextResolver.resolveAgent(
+        state.definition.agent.resolved,
+    );
+    return composeModelRequest(state, modelCallIndex, prefix, agent, encode);
+}
diff --git a/apps/x/packages/core/src/turns/context-resolver.test.ts b/apps/x/packages/core/src/turns/context-resolver.test.ts
new file mode 100644
index 00000000..35621178
--- /dev/null
+++ b/apps/x/packages/core/src/turns/context-resolver.test.ts
@@ -0,0 +1,330 @@
+import { describe, expect, it } from "vitest";
+import type { z } from "zod";
+import {
+    MODEL_CALL_LIMIT_ERROR_CODE,
+    type TurnContext,
+    TurnCorruptionError,
+    type TurnEvent,
+} from "@x/shared/dist/turns.js";
+import { TurnRepoContextResolver } from "./context-resolver.js";
+import { InMemoryTurnRepo } from "./in-memory-turn-repo.js";
+
+type TEvent = z.infer<typeof TurnEvent>;
+
+function user(text: string) {
+    return { role: "user" as const, content: text };
+}
+
+function assistant(text: string) {
+    return { role: "assistant" as const, content: text };
+}
+
+// A minimal completed turn: input → one model call → text response.
+function completedTurnLog(
+    turnId: string,
+    context: z.infer<typeof TurnContext>,
+    inputText: string,
+    responseText: string,
+): TEvent[] {
+    const ts = "2026-07-02T10:00:00Z";
+    return [
+        {
+            type: "turn_created",
+            schemaVersion: 1,
+            turnId,
+            ts,
+            sessionId: "sess-1",
+            agent: {
+                requested: { agentId: "copilot" },
+                resolved: {
+                    agentId: "copilot",
+                    systemPrompt: "SYS",
+                    model: { provider: "fake", model: "m" },
+                    tools: [],
+                },
+            },
+            context,
+            input: user(inputText),
+            config: {
+                autoPermission: false,
+                humanAvailable: true,
+                maxModelCalls: 20,
+            },
+        },
+        {
+            type: "model_call_requested",
+            turnId,
+            ts,
+            modelCallIndex: 0,
+            request: {
+                ...(Array.isArray(context) ? {} : { contextRef: context }),
+                messages:
+                    Array.isArray(context) && context.length > 0
+                        ? ["context", "input"]
+                        : ["input"],
+                parameters: {},
+            },
+        },
+        {
+            type: "model_call_completed",
+            turnId,
+            ts,
+            modelCallIndex: 0,
+            message: assistant(responseText),
+            finishReason: "stop",
+            usage: {},
+        },
+        {
+            type: "turn_completed",
+            turnId,
+            ts,
+            output: assistant(responseText),
+            finishReason: "stop",
+            usage: {},
+        },
+    ];
+}
+
+// A turn that failed at the model-call limit after one tool round trip; its
+// transcript is structurally complete including the synthetic closure.
+function limitFailedTurnLog(turnId: string): TEvent[] {
+    const ts = "2026-07-02T10:00:00Z";
+    const echo = {
+        toolId: "tool.echo",
+        name: "echo",
+        description: "Echo",
+        inputSchema: {},
+        execution: "sync" as const,
+        requiresHuman: false,
+    };
+    const call = {
+        role: "assistant" as const,
+        content: [
+            {
+                type: "tool-call" as const,
+                toolCallId: "tc1",
+                toolName: "echo",
+                arguments: {},
+            },
+        ],
+    };
+    return [
+        {
+            type: "turn_created",
+            schemaVersion: 1,
+            turnId,
+            ts,
+            sessionId: "sess-1",
+            agent: {
+                requested: { agentId: "copilot" },
+                resolved: {
+                    agentId: "copilot",
+                    systemPrompt: "SYS",
+                    model: { provider: "fake", model: "m" },
+                    tools: [echo],
+                },
+            },
+            context: [],
+            input: user("do it"),
+            config: {
+                autoPermission: false,
+                humanAvailable: true,
+                maxModelCalls: 1,
+            },
+        },
+        {
+            type: "model_call_requested",
+            turnId,
+            ts,
+            modelCallIndex: 0,
+            request: {
+                messages: ["input"],
+                parameters: {},
+            },
+        },
+        {
+            type: "model_call_completed",
+            turnId,
+            ts,
+            modelCallIndex: 0,
+            message: call,
+            finishReason: "tool-calls",
+            usage: {},
+        },
+        {
+            type: "tool_invocation_requested",
+            turnId,
+            ts,
+            toolCallId: "tc1",
+            toolId: "tool.echo",
+            toolName: "echo",
+            execution: "sync",
+            input: {},
+        },
+        {
+            type: "tool_result",
+            turnId,
+            ts,
+            toolCallId: "tc1",
+            toolName: "echo",
+            source: "sync",
+            result: { output: "echoed", isError: false },
+        },
+        {
+            type: "turn_failed",
+            turnId,
+            ts,
+            error: "Model call limit of 1 reached before the turn completed.",
+            code: MODEL_CALL_LIMIT_ERROR_CODE,
+            usage: {},
+        },
+    ];
+}
+
+const T1 = "2026-07-02T10-00-00Z-0000001-000";
+const T2 = "2026-07-02T10-00-00Z-0000002-000";
+const T3 = "2026-07-02T10-00-00Z-0000003-000";
+
+describe("TurnRepoContextResolver", () => {
+    it("passes inline context through unchanged", async () => {
+        const repo = new InMemoryTurnRepo();
+        const resolver = new TurnRepoContextResolver({ turnRepo: repo });
+        const inline = [user("a"), assistant("b")];
+        expect(await resolver.resolve(inline)).toEqual(inline);
+    });
+
+    it("resolves a single reference to the referenced turn's transcript", async () => {
+        const repo = new InMemoryTurnRepo();
+        repo.seed(completedTurnLog(T1, [], "first question", "first answer"));
+        const resolver = new TurnRepoContextResolver({ turnRepo: repo });
+        expect(await resolver.resolve({ previousTurnId: T1 })).toEqual([
+            user("first question"),
+            assistant("first answer"),
+        ]);
+    });
+
+    it("resolves a chain of references down to the inline base", async () => {
+        const repo = new InMemoryTurnRepo();
+        repo.seed(completedTurnLog(T1, [user("preamble")], "q1", "a1"));
+        repo.seed(completedTurnLog(T2, { previousTurnId: T1 }, "q2", "a2"));
+        repo.seed(completedTurnLog(T3, { previousTurnId: T2 }, "q3", "a3"));
+        const resolver = new TurnRepoContextResolver({ turnRepo: repo });
+        expect(await resolver.resolve({ previousTurnId: T3 })).toEqual([
+            user("preamble"),
+            user("q1"),
+            assistant("a1"),
+            user("q2"),
+            assistant("a2"),
+            user("q3"),
+            assistant("a3"),
+        ]);
+    });
+
+    it("includes failed turns' transcripts with synthetic closures", async () => {
+        const repo = new InMemoryTurnRepo();
+        repo.seed(limitFailedTurnLog(T1));
+        const resolver = new TurnRepoContextResolver({ turnRepo: repo });
+        const resolved = await resolver.resolve({ previousTurnId: T1 });
+        expect(resolved.map((m) => m.role)).toEqual(["user", "assistant", "tool"]);
+        expect(resolved[2]).toMatchObject({
+            role: "tool",
+            toolCallId: "tc1",
+            content: "echoed",
+        });
+    });
+
+    it("rejects references to missing turns as infrastructure errors", async () => {
+        const repo = new InMemoryTurnRepo();
+        const resolver = new TurnRepoContextResolver({ turnRepo: repo });
+        await expect(
+            resolver.resolve({ previousTurnId: T1 }),
+        ).rejects.toThrowError(/turn not found/);
+    });
+
+    it("resolveAgent materializes inherited snapshots through the chain", async () => {
+        const repo = new InMemoryTurnRepo();
+        repo.seed(completedTurnLog(T1, [], "q1", "a1")); // concrete base
+        const inheritedLog = completedTurnLog(T2, { previousTurnId: T1 }, "q2", "a2").map(
+            (event) =>
+                event.type === "turn_created"
+                    ? {
+                          ...event,
+                          agent: {
+                              ...event.agent,
+                              resolved: {
+                                  agentId: "copilot",
+                                  model: { provider: "fake", model: "m" },
+                                  inheritedFrom: T1,
+                              },
+                          },
+                      }
+                    : event,
+        );
+        repo.seed(inheritedLog);
+        const resolver = new TurnRepoContextResolver({ turnRepo: repo });
+
+        const concrete = await resolver.resolveAgent({
+            agentId: "copilot",
+            systemPrompt: "SYS",
+            model: { provider: "fake", model: "m" },
+            tools: [],
+        });
+        expect(concrete.systemPrompt).toBe("SYS"); // passthrough
+
+        const materialized = await resolver.resolveAgent({
+            agentId: "copilot",
+            model: { provider: "fake", model: "m2" },
+            inheritedFrom: T2, // hops T2 -> T1
+        });
+        expect(materialized.systemPrompt).toBe("SYS");
+        expect(materialized.tools).toEqual([]);
+        // The inherited record's own model wins over the chain base's model.
+        expect(materialized.model).toEqual({ provider: "fake", model: "m2" });
+    });
+
+    it("resolveAgent rejects cyclic inheritance as corruption", async () => {
+        const repo = new InMemoryTurnRepo();
+        const cyclic = completedTurnLog(T1, [], "q1", "a1").map((event) =>
+            event.type === "turn_created"
+                ? {
+                      ...event,
+                      context: { previousTurnId: T1 },
+                      agent: {
+                          ...event.agent,
+                          resolved: {
+                              agentId: "copilot",
+                              model: { provider: "fake", model: "m" },
+                              inheritedFrom: T1,
+                          },
+                      },
+                  }
+                : event,
+        );
+        // Fix the request contextRef to match the now-ref context.
+        const fixed = cyclic.map((event) =>
+            event.type === "model_call_requested"
+                ? { ...event, request: { ...event.request, contextRef: { previousTurnId: T1 } } }
+                : event,
+        );
+        repo.seed(fixed);
+        const resolver = new TurnRepoContextResolver({ turnRepo: repo });
+        await expect(
+            resolver.resolveAgent({
+                agentId: "copilot",
+                model: { provider: "fake", model: "m" },
+                inheritedFrom: T1,
+            }),
+        ).rejects.toThrowError(TurnCorruptionError);
+    });
+
+    it("rejects cyclic reference chains as corruption", async () => {
+        const repo = new InMemoryTurnRepo();
+        // Two turns referencing each other (only constructable by corruption).
+        repo.seed(completedTurnLog(T1, { previousTurnId: T2 }, "q1", "a1"));
+        repo.seed(completedTurnLog(T2, { previousTurnId: T1 }, "q2", "a2"));
+        const resolver = new TurnRepoContextResolver({ turnRepo: repo });
+        await expect(
+            resolver.resolve({ previousTurnId: T1 }),
+        ).rejects.toThrowError(TurnCorruptionError);
+    });
+});
diff --git a/apps/x/packages/core/src/turns/context-resolver.ts b/apps/x/packages/core/src/turns/context-resolver.ts
new file mode 100644
index 00000000..3785cc26
--- /dev/null
+++ b/apps/x/packages/core/src/turns/context-resolver.ts
@@ -0,0 +1,88 @@
+import type { z } from "zod";
+import {
+    type ConversationMessage,
+    type ResolvedAgent,
+    type ResolvedAgentSnapshot,
+    type TurnContext,
+    TurnCorruptionError,
+    isInheritedSnapshot,
+    reduceTurn,
+    turnTranscript,
+} from "@x/shared/dist/turns.js";
+import type { ITurnRepo } from "./repo.js";
+
+// Materializes a turn's context (turn-runtime-design.md §6.6). Inline
+// contexts pass through; references resolve to the referenced turn's full
+// transcript by walking the chain down to its inline base. Resolution always
+// reads durable state, so normal execution and crash recovery share one
+// path. A missing or corrupt referenced turn is an infrastructure error.
+export interface IContextResolver {
+    resolve(
+        context: z.infer<typeof TurnContext>,
+    ): Promise<Array<z.infer<typeof ConversationMessage>>>;
+    // Materializes an inherited agent snapshot by walking inheritedFrom to
+    // the nearest concrete snapshot (same discipline as context references:
+    // deterministic, from durable state, cycle-checked).
+    resolveAgent(
+        resolved: z.infer<typeof ResolvedAgentSnapshot>,
+    ): Promise<z.infer<typeof ResolvedAgent>>;
+}
+
+export class TurnRepoContextResolver implements IContextResolver {
+    private readonly turnRepo: ITurnRepo;
+
+    constructor({ turnRepo }: { turnRepo: ITurnRepo }) {
+        this.turnRepo = turnRepo;
+    }
+
+    async resolve(
+        context: z.infer<typeof TurnContext>,
+    ): Promise<Array<z.infer<typeof ConversationMessage>>> {
+        // Walk the reference chain back to the inline base, then concatenate
+        // transcripts oldest-first. Iterative to bound stack depth; a visited
+        // set catches cyclic (corrupt) chains.
+        const segments: Array<Array<z.infer<typeof ConversationMessage>>> = [];
+        const visited = new Set<string>();
+        let current = context;
+        while (!Array.isArray(current)) {
+            const turnId = current.previousTurnId;
+            if (visited.has(turnId)) {
+                throw new TurnCorruptionError(
+                    `cyclic context reference chain at turn ${turnId}`,
+                );
+            }
+            visited.add(turnId);
+            const events = await this.turnRepo.read(turnId);
+            const state = reduceTurn(events);
+            segments.push(turnTranscript(state));
+            current = state.definition.context;
+        }
+        segments.push(current);
+        segments.reverse();
+        return segments.flat();
+    }
+
+    async resolveAgent(
+        resolved: z.infer<typeof ResolvedAgentSnapshot>,
+    ): Promise<z.infer<typeof ResolvedAgent>> {
+        if (!isInheritedSnapshot(resolved)) {
+            return resolved;
+        }
+        const visited = new Set<string>();
+        let current: z.infer<typeof ResolvedAgentSnapshot> = resolved;
+        while (isInheritedSnapshot(current)) {
+            const turnId = current.inheritedFrom;
+            if (visited.has(turnId)) {
+                throw new TurnCorruptionError(
+                    `cyclic agent snapshot inheritance at turn ${turnId}`,
+                );
+            }
+            visited.add(turnId);
+            const events = await this.turnRepo.read(turnId);
+            current = reduceTurn(events).definition.agent.resolved;
+        }
+        // Only the heavy fields inherit; the turn's own concrete identity
+        // (agentId, model — a mid-session model switch) always wins.
+        return { ...current, agentId: resolved.agentId, model: resolved.model };
+    }
+}
diff --git a/apps/x/packages/core/src/turns/fs-repo.test.ts b/apps/x/packages/core/src/turns/fs-repo.test.ts
new file mode 100644
index 00000000..583ea330
--- /dev/null
+++ b/apps/x/packages/core/src/turns/fs-repo.test.ts
@@ -0,0 +1,203 @@
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import type { z } from "zod";
+import {
+    TurnCorruptionError,
+    TurnCreated,
+    TurnEvent,
+} from "@x/shared/dist/turns.js";
+import { FSTurnRepo } from "./fs-repo.js";
+
+const TURN_ID = "2026-07-02T10-00-00Z-0000001-000";
+
+function created(turnId = TURN_ID): z.infer<typeof TurnCreated> {
+    return {
+        type: "turn_created",
+        schemaVersion: 1,
+        turnId,
+        ts: "2026-07-02T10:00:00Z",
+        sessionId: null,
+        agent: {
+            requested: { agentId: "copilot" },
+            resolved: {
+                agentId: "copilot",
+                systemPrompt: "SYS",
+                model: { provider: "fake", model: "m" },
+                tools: [],
+            },
+        },
+        context: [],
+        input: { role: "user", content: "hello" },
+        config: { autoPermission: false, humanAvailable: true, maxModelCalls: 20 },
+    };
+}
+
+function requested(turnId = TURN_ID): z.infer<typeof TurnEvent> {
+    return {
+        type: "model_call_requested",
+        turnId,
+        ts: "2026-07-02T10:00:01Z",
+        modelCallIndex: 0,
+        request: {
+            messages: ["input"],
+            parameters: {},
+        },
+    };
+}
+
+function failed(turnId = TURN_ID): z.infer<typeof TurnEvent> {
+    return {
+        type: "model_call_failed",
+        turnId,
+        ts: "2026-07-02T10:00:02Z",
+        modelCallIndex: 0,
+        error: "boom",
+    };
+}
+
+describe("FSTurnRepo", () => {
+    let root: string;
+    let repo: FSTurnRepo;
+
+    beforeEach(async () => {
+        root = await fs.mkdtemp(path.join(os.tmpdir(), "turn-repo-"));
+        repo = new FSTurnRepo({ turnsRootDir: root });
+    });
+
+    afterEach(async () => {
+        await fs.rm(root, { recursive: true, force: true });
+    });
+
+    it("writes to a deterministic date-partitioned path", async () => {
+        await repo.create(created());
+        const file = path.join(root, "2026", "07", "02", `${TURN_ID}.jsonl`);
+        const raw = await fs.readFile(file, "utf8");
+        expect(raw.endsWith("\n")).toBe(true);
+        expect(JSON.parse(raw.trim()).type).toBe("turn_created");
+    });
+
+    it("rejects malformed and path-like turn ids", async () => {
+        for (const bad of [
+            "../../../etc/passwd",
+            "2026-07-02T10/evil",
+            "2026-07-02T10-00-00Z-0000001-000.jsonl",
+            "not-a-turn-id",
+            "",
+        ]) {
+            await expect(repo.read(bad)).rejects.toThrowError(/invalid turn id/);
+        }
+    });
+
+    it("create fails if the turn already exists", async () => {
+        await repo.create(created());
+        await expect(repo.create(created())).rejects.toThrowError();
+    });
+
+    it("appends preserve order and read validates every line", async () => {
+        await repo.create(created());
+        await repo.append(TURN_ID, [requested()]);
+        await repo.append(TURN_ID, [failed()]);
+        const events = await repo.read(TURN_ID);
+        expect(events.map((e) => e.type)).toEqual([
+            "turn_created",
+            "model_call_requested",
+            "model_call_failed",
+        ]);
+    });
+
+    it("append validates events and turn id match before writing", async () => {
+        await repo.create(created());
+        await expect(
+            repo.append(TURN_ID, [requested("2026-07-02T10-00-00Z-0000002-000")]),
+        ).rejects.toThrowError(/does not match/);
+        await expect(
+            repo.append(TURN_ID, [{ type: "wat" } as unknown as z.infer<typeof TurnEvent>]),
+        ).rejects.toThrowError();
+        // Nothing was written by the failed appends.
+        expect((await repo.read(TURN_ID)).length).toBe(1);
+    });
+
+    it("append never creates a missing turn file", async () => {
+        await expect(repo.append(TURN_ID, [requested()])).rejects.toThrowError(
+            /turn not found/,
+        );
+    });
+
+    it("reading a missing turn reports not found", async () => {
+        await expect(repo.read(TURN_ID)).rejects.toThrowError(/turn not found/);
+    });
+
+    async function writeRaw(content: string): Promise<void> {
+        const file = path.join(root, "2026", "07", "02", `${TURN_ID}.jsonl`);
+        await fs.mkdir(path.dirname(file), { recursive: true });
+        await fs.writeFile(file, content);
+    }
+
+    it("rejects an empty file as corrupt", async () => {
+        await writeRaw("");
+        await expect(repo.read(TURN_ID)).rejects.toThrowError(TurnCorruptionError);
+    });
+
+    it("rejects malformed first, middle, and final lines", async () => {
+        const good = JSON.stringify(created());
+        const req = JSON.stringify(requested());
+        for (const content of [
+            `not json\n${req}\n`,
+            `${good}\nnot json\n${req}\n`,
+            `${good}\n{"type":"wat"}\n`,
+        ]) {
+            await writeRaw(content);
+            await expect(repo.read(TURN_ID)).rejects.toThrowError(
+                TurnCorruptionError,
+            );
+        }
+    });
+
+    it("rejects a torn final line (no trailing newline)", async () => {
+        const good = JSON.stringify(created());
+        const torn = JSON.stringify(requested()).slice(0, 20);
+        await writeRaw(`${good}\n${torn}`);
+        await expect(repo.read(TURN_ID)).rejects.toThrowError(
+            /does not end with a complete line/,
+        );
+    });
+
+    it("rejects unsupported schema versions on read", async () => {
+        const v2 = { ...created(), schemaVersion: 2 };
+        await writeRaw(`${JSON.stringify(v2)}\n`);
+        await expect(repo.read(TURN_ID)).rejects.toThrowError(TurnCorruptionError);
+    });
+
+    it("rejects events whose turnId does not match the file", async () => {
+        const other = created("2026-07-02T10-00-00Z-0000002-000");
+        await writeRaw(`${JSON.stringify(other)}\n`);
+        await expect(repo.read(TURN_ID)).rejects.toThrowError(/does not match file/);
+    });
+
+    it("withLock serializes work per turn", async () => {
+        const order: string[] = [];
+        await Promise.all([
+            repo.withLock(TURN_ID, async () => {
+                order.push("a-start");
+                await new Promise((r) => setTimeout(r, 20));
+                order.push("a-end");
+            }),
+            repo.withLock(TURN_ID, async () => {
+                order.push("b-start");
+                order.push("b-end");
+            }),
+        ]);
+        expect(order).toEqual(["a-start", "a-end", "b-start", "b-end"]);
+    });
+
+    it("withLock releases after failures", async () => {
+        await expect(
+            repo.withLock(TURN_ID, async () => {
+                throw new Error("first fails");
+            }),
+        ).rejects.toThrowError("first fails");
+        await expect(repo.withLock(TURN_ID, async () => "ok")).resolves.toBe("ok");
+    });
+});
diff --git a/apps/x/packages/core/src/turns/fs-repo.ts b/apps/x/packages/core/src/turns/fs-repo.ts
new file mode 100644
index 00000000..57d19ca8
--- /dev/null
+++ b/apps/x/packages/core/src/turns/fs-repo.ts
@@ -0,0 +1,128 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { z } from "zod";
+import {
+    TurnCorruptionError,
+    TurnCreated,
+    TurnEvent,
+} from "@x/shared/dist/turns.js";
+import { KeyedMutex } from "./keyed-mutex.js";
+import type { ITurnRepo } from "./repo.js";
+
+// Turn IDs come from IMonotonicallyIncreasingIdGenerator and look like
+// 2025-11-11T04-36-29Z-0001234-000. The repo validates the format before
+// deriving a path and rejects anything path-like.
+const TURN_ID_PATTERN = /^(\d{4})-(\d{2})-(\d{2})T[A-Za-z0-9-]+$/;
+
+export class FSTurnRepo implements ITurnRepo {
+    private readonly rootDir: string;
+    private readonly mutex = new KeyedMutex();
+
+    constructor({ turnsRootDir }: { turnsRootDir: string }) {
+        this.rootDir = turnsRootDir;
+    }
+
+    private filePath(turnId: string): string {
+        const match = TURN_ID_PATTERN.exec(turnId);
+        if (!match) {
+            throw new Error(`invalid turn id: ${turnId}`);
+        }
+        const [, year, month, day] = match;
+        return path.join(this.rootDir, year, month, day, `${turnId}.jsonl`);
+    }
+
+    private serialize(
+        turnId: string,
+        events: Array<z.infer<typeof TurnEvent>>,
+    ): string {
+        let payload = "";
+        for (const event of events) {
+            const parsed = TurnEvent.parse(event);
+            if (parsed.turnId !== turnId) {
+                throw new Error(
+                    `event turnId ${parsed.turnId} does not match ${turnId}`,
+                );
+            }
+            payload += `${JSON.stringify(parsed)}\n`;
+        }
+        return payload;
+    }
+
+    async create(event: z.infer<typeof TurnCreated>): Promise<void> {
+        const parsed = TurnCreated.parse(event);
+        const file = this.filePath(parsed.turnId);
+        await fs.mkdir(path.dirname(file), { recursive: true });
+        // "wx" fails if the file already exists.
+        await fs.writeFile(file, this.serialize(parsed.turnId, [parsed]), {
+            flag: "wx",
+        });
+    }
+
+    async read(turnId: string): Promise<Array<z.infer<typeof TurnEvent>>> {
+        const file = this.filePath(turnId);
+        let raw: string;
+        try {
+            raw = await fs.readFile(file, "utf8");
+        } catch (error) {
+            if ((error as NodeJS.ErrnoException).code === "ENOENT") {
+                throw new Error(`turn not found: ${turnId}`);
+            }
+            throw error;
+        }
+        if (raw.length === 0) {
+            throw new TurnCorruptionError(`turn file is empty: ${turnId}`);
+        }
+        const lines = raw.split("\n");
+        // A well-formed file ends with a newline, leaving one trailing empty
+        // segment. Anything else (including a torn final line) is corrupt.
+        const trailing = lines.pop();
+        if (trailing !== "") {
+            throw new TurnCorruptionError(
+                `turn file does not end with a complete line: ${turnId}`,
+            );
+        }
+        const events: Array<z.infer<typeof TurnEvent>> = [];
+        for (const [index, line] of lines.entries()) {
+            let parsed: z.infer<typeof TurnEvent>;
+            try {
+                parsed = TurnEvent.parse(JSON.parse(line));
+            } catch (error) {
+                throw new TurnCorruptionError(
+                    `malformed turn event at ${turnId}:${index + 1}: ${String(
+                        error instanceof Error ? error.message : error,
+                    )}`,
+                );
+            }
+            if (parsed.turnId !== turnId) {
+                throw new TurnCorruptionError(
+                    `event turnId ${parsed.turnId} does not match file ${turnId}`,
+                );
+            }
+            events.push(parsed);
+        }
+        return events;
+    }
+
+    async append(
+        turnId: string,
+        events: Array<z.infer<typeof TurnEvent>>,
+    ): Promise<void> {
+        if (events.length === 0) {
+            return;
+        }
+        const payload = this.serialize(turnId, events);
+        const file = this.filePath(turnId);
+        // Appends must never create a file: a turn exists only via create().
+        // All writers hold the per-turn lock, so check-then-append is safe.
+        try {
+            await fs.access(file);
+        } catch {
+            throw new Error(`turn not found: ${turnId}`);
+        }
+        await fs.appendFile(file, payload);
+    }
+
+    async withLock<T>(turnId: string, fn: () => Promise<T>): Promise<T> {
+        return this.mutex.run(turnId, fn);
+    }
+}
diff --git a/apps/x/packages/core/src/turns/in-memory-turn-repo.ts b/apps/x/packages/core/src/turns/in-memory-turn-repo.ts
new file mode 100644
index 00000000..3dfd176d
--- /dev/null
+++ b/apps/x/packages/core/src/turns/in-memory-turn-repo.ts
@@ -0,0 +1,62 @@
+import { z } from "zod";
+import { TurnCreated, TurnEvent } from "@x/shared/dist/turns.js";
+import { KeyedMutex } from "./keyed-mutex.js";
+import type { ITurnRepo } from "./repo.js";
+
+// Test fake mirroring FSTurnRepo semantics (create-if-absent, validate on
+// write and read boundaries, per-turn locking) without touching disk.
+export class InMemoryTurnRepo implements ITurnRepo {
+    private files = new Map<string, Array<z.infer<typeof TurnEvent>>>();
+    private mutex = new KeyedMutex();
+
+    async create(event: z.infer<typeof TurnCreated>): Promise<void> {
+        const parsed = TurnCreated.parse(event);
+        if (this.files.has(parsed.turnId)) {
+            throw new Error(`turn already exists: ${parsed.turnId}`);
+        }
+        this.files.set(parsed.turnId, [structuredClone(parsed)]);
+    }
+
+    async read(turnId: string): Promise<Array<z.infer<typeof TurnEvent>>> {
+        const events = this.files.get(turnId);
+        if (!events) {
+            throw new Error(`turn not found: ${turnId}`);
+        }
+        return structuredClone(events);
+    }
+
+    async append(
+        turnId: string,
+        events: Array<z.infer<typeof TurnEvent>>,
+    ): Promise<void> {
+        const file = this.files.get(turnId);
+        if (!file) {
+            throw new Error(`turn not found: ${turnId}`);
+        }
+        for (const event of events) {
+            const parsed = TurnEvent.parse(event);
+            if (parsed.turnId !== turnId) {
+                throw new Error(
+                    `event turnId ${parsed.turnId} does not match ${turnId}`,
+                );
+            }
+            file.push(structuredClone(parsed));
+        }
+    }
+
+    async withLock<T>(turnId: string, fn: () => Promise<T>): Promise<T> {
+        return this.mutex.run(turnId, fn);
+    }
+
+    // Test helper: seed a raw event log (validated) for recovery scenarios.
+    seed(events: Array<z.infer<typeof TurnEvent>>): void {
+        if (events.length === 0) {
+            throw new Error("cannot seed an empty log");
+        }
+        const turnId = events[0].turnId;
+        this.files.set(
+            turnId,
+            events.map((e) => structuredClone(TurnEvent.parse(e))),
+        );
+    }
+}
diff --git a/apps/x/packages/core/src/turns/index.ts b/apps/x/packages/core/src/turns/index.ts
new file mode 100644
index 00000000..77153361
--- /dev/null
+++ b/apps/x/packages/core/src/turns/index.ts
@@ -0,0 +1,16 @@
+export * from "./api.js";
+export * from "./agent-resolver.js";
+export * from "./bus.js";
+export * from "./clock.js";
+export * from "./compose-model-request.js";
+export * from "./context-resolver.js";
+export * from "./fs-repo.js";
+export * from "./in-memory-turn-repo.js";
+export * from "./keyed-mutex.js";
+export * from "./model-registry.js";
+export * from "./permission.js";
+export * from "./repo.js";
+export * from "./runtime.js";
+export * from "./stream.js";
+export * from "./tool-registry.js";
+export * from "./usage-reporter.js";
diff --git a/apps/x/packages/core/src/turns/inspect-cli.ts b/apps/x/packages/core/src/turns/inspect-cli.ts
new file mode 100644
index 00000000..b662e407
--- /dev/null
+++ b/apps/x/packages/core/src/turns/inspect-cli.ts
@@ -0,0 +1,193 @@
+// Runtime storage inspector. Works on turns AND sessions (auto-detected):
+//
+//   npm run inspect -- <turnId | sessionId | path/to/*.jsonl> [modelCallIndex] [--full] [--turns]
+//
+// Turn mode prints, per model call, the EXACT provider payload the loop sent
+// — rebuilt from the durable file by the same composer the loop transmits
+// through (compose-model-request.ts). This is where the woven wire-form
+// messages (user-message context, attachments, tool-result envelopes) are
+// visible; the file itself stores only structural facts and references.
+//
+// Session mode prints the session overview (title, turns, statuses, sizes);
+// pass --turns to cascade full turn inspection for every turn.
+//
+// --full prints untruncated system prompts and message contents.
+import fs from "node:fs";
+import path from "node:path";
+import {
+    deriveTurnStatus,
+    reduceTurn,
+    type JsonValue,
+    type TurnEvent,
+    type TurnState,
+} from "@x/shared/dist/turns.js";
+import { reduceSession } from "@x/shared/dist/sessions.js";
+import type { z } from "zod";
+import { convertFromMessages } from "../agents/runtime.js";
+import { WorkDir } from "../config/config.js";
+import { FSSessionRepo } from "../sessions/fs-repo.js";
+import { composeModelRequest } from "./compose-model-request.js";
+import { TurnRepoContextResolver } from "./context-resolver.js";
+import { FSTurnRepo } from "./fs-repo.js";
+
+const turnRepo = new FSTurnRepo({
+    turnsRootDir: path.join(WorkDir, "storage", "turns"),
+});
+const sessionRepo = new FSSessionRepo({
+    sessionsRootDir: path.join(WorkDir, "storage", "sessions"),
+});
+const resolver = new TurnRepoContextResolver({ turnRepo });
+const encode = (messages: Parameters<typeof convertFromMessages>[0]) =>
+    convertFromMessages(messages) as unknown as JsonValue[];
+
+function usage(): never {
+    console.error(
+        "usage: inspect <turnId | sessionId | path/to/*.jsonl> [modelCallIndex] [--full] [--turns]",
+    );
+    process.exit(1);
+}
+
+function clip(text: string, full: boolean, limit = 400): string {
+    if (full || text.length <= limit) return text;
+    return `${text.slice(0, limit)}… [${text.length} chars total; pass --full]`;
+}
+
+function inputPreview(state: TurnState): string {
+    const content = state.definition.input.content;
+    const text =
+        typeof content === "string"
+            ? content
+            : content
+                  .map((part) => (part.type === "text" ? part.text : `<${part.type}>`))
+                  .join(" ");
+    return text.replace(/\s+/g, " ").slice(0, 60);
+}
+
+async function inspectTurn(
+    turnId: string,
+    events: Array<z.infer<typeof TurnEvent>>,
+    onlyIndex: number | undefined,
+    full: boolean,
+): Promise<void> {
+    const state = reduceTurn(events);
+    const prefix = await resolver.resolve(state.definition.context);
+    const agent = await resolver.resolveAgent(state.definition.agent.resolved);
+
+    const inherited =
+        "inheritedFrom" in state.definition.agent.resolved
+            ? `  (snapshot inherited from ${state.definition.agent.resolved.inheritedFrom})`
+            : "";
+    console.log(`turn ${turnId}  status ${deriveTurnStatus(state)}`);
+    console.log(
+        `agent ${agent.agentId}  model ${agent.model.provider}/${agent.model.model}  calls ${state.modelCalls.length}${inherited}`,
+    );
+
+    for (const call of state.modelCalls) {
+        if (onlyIndex !== undefined && call.index !== onlyIndex) continue;
+        const composed = composeModelRequest(state, call.index, prefix, agent, encode);
+        console.log(`\n━━ model call ${call.index} ━━ (as sent to the provider)`);
+        console.log(
+            `system (${composed.systemPrompt.length} chars): ${clip(composed.systemPrompt, full)}`,
+        );
+        console.log(
+            `tools (${composed.tools.length}): ${composed.tools.map((t) => t.name).join(", ")}`,
+        );
+        console.log(`messages (${composed.messages.length}):`);
+        for (const message of composed.messages) {
+            const m = message as { role?: string; content?: unknown };
+            const content =
+                typeof m.content === "string" ? m.content : JSON.stringify(m.content);
+            console.log(`  [${m.role}] ${clip(content, full)}`);
+        }
+        if (call.error !== undefined) {
+            console.log(`  → failed: ${call.error}`);
+        } else if (call.response !== undefined) {
+            const response =
+                typeof call.response.content === "string"
+                    ? call.response.content
+                    : JSON.stringify(call.response.content);
+            console.log(`  → response (${call.finishReason}): ${clip(response, full)}`);
+        }
+    }
+}
+
+async function inspectSession(
+    sessionId: string,
+    full: boolean,
+    cascade: boolean,
+): Promise<void> {
+    const state = reduceSession(await sessionRepo.read(sessionId));
+    console.log(`session ${sessionId}`);
+    console.log(
+        `title "${state.title ?? ""}"  turns ${state.turns.length}  created ${state.createdAt}  updated ${state.updatedAt}`,
+    );
+    for (const ref of state.turns) {
+        try {
+            const events = await turnRepo.read(ref.turnId);
+            const turnState = reduceTurn(events);
+            const bytes = JSON.stringify(events).length;
+            console.log(
+                `  ${String(ref.sessionSeq).padStart(3)}. ${ref.turnId}  ${deriveTurnStatus(turnState).padEnd(9)} ${turnState.modelCalls.length} calls  ~${Math.round(bytes / 1024)}KB  "${inputPreview(turnState)}"`,
+            );
+        } catch (error) {
+            console.log(
+                `  ${String(ref.sessionSeq).padStart(3)}. ${ref.turnId}  UNREADABLE: ${error instanceof Error ? error.message : error}`,
+            );
+        }
+    }
+    if (cascade) {
+        for (const ref of state.turns) {
+            console.log(`\n════════ turn ${ref.sessionSeq} ════════`);
+            try {
+                await inspectTurn(ref.turnId, await turnRepo.read(ref.turnId), undefined, full);
+            } catch (error) {
+                console.log(`unreadable: ${error instanceof Error ? error.message : error}`);
+            }
+        }
+    } else {
+        console.log(`\n(inspect a turn: npm run inspect -- <turnId>; whole session: --turns)`);
+    }
+}
+
+async function main(): Promise<void> {
+    const flags = new Set(process.argv.slice(2).filter((a) => a.startsWith("--")));
+    const args = process.argv.slice(2).filter((a) => !a.startsWith("--"));
+    const full = flags.has("--full");
+    const cascade = flags.has("--turns");
+    const target = args[0];
+    if (!target) usage();
+    const onlyIndex = args[1] !== undefined ? Number(args[1]) : undefined;
+
+    const id = target.endsWith(".jsonl") ? path.basename(target, ".jsonl") : target;
+
+    // Direct file path: session files live under storage/sessions.
+    if (target.endsWith(".jsonl") && fs.existsSync(target)) {
+        if (path.resolve(target).includes(`${path.sep}sessions${path.sep}`)) {
+            await inspectSession(id, full, cascade);
+            return;
+        }
+        const events = fs
+            .readFileSync(target, "utf8")
+            .trim()
+            .split("\n")
+            .map((line) => JSON.parse(line) as z.infer<typeof TurnEvent>);
+        await inspectTurn(id, events, onlyIndex, full);
+        return;
+    }
+
+    // Bare id: try turn first, then session.
+    try {
+        const events = await turnRepo.read(id);
+        await inspectTurn(id, events, onlyIndex, full);
+    } catch (error) {
+        if (!(error instanceof Error) || !/turn not found/.test(error.message)) {
+            throw error;
+        }
+        await inspectSession(id, full, cascade);
+    }
+}
+
+main().catch((error: unknown) => {
+    console.error(error instanceof Error ? error.message : error);
+    process.exit(1);
+});
diff --git a/apps/x/packages/core/src/turns/keyed-mutex.ts b/apps/x/packages/core/src/turns/keyed-mutex.ts
new file mode 100644
index 00000000..e39c2404
--- /dev/null
+++ b/apps/x/packages/core/src/turns/keyed-mutex.ts
@@ -0,0 +1,21 @@
+// In-process per-key exclusion. Cross-process coordination is explicitly out
+// of scope for the turn runtime (single Electron main process).
+export class KeyedMutex {
+    private tails = new Map<string, Promise<unknown>>();
+
+    async run<T>(key: string, fn: () => Promise<T>): Promise<T> {
+        const prev = this.tails.get(key) ?? Promise.resolve();
+        const next = prev.then(
+            () => fn(),
+            () => fn(),
+        );
+        this.tails.set(key, next);
+        try {
+            return await next;
+        } finally {
+            if (this.tails.get(key) === next) {
+                this.tails.delete(key);
+            }
+        }
+    }
+}
diff --git a/apps/x/packages/core/src/turns/model-registry.ts b/apps/x/packages/core/src/turns/model-registry.ts
new file mode 100644
index 00000000..d4c83a76
--- /dev/null
+++ b/apps/x/packages/core/src/turns/model-registry.ts
@@ -0,0 +1,54 @@
+import type { z } from "zod";
+import type { AssistantMessage } from "@x/shared/dist/message.js";
+import type {
+    ConversationMessage,
+    DurableLlmStepStreamEvent,
+    JsonValue,
+    ModelDescriptor,
+    ToolDescriptor,
+    TurnUsage,
+} from "@x/shared/dist/turns.js";
+
+// One stream() call performs exactly one model step; the turn loop drives
+// multi-step behavior. The stream yields normalized events and must end with
+// exactly one "completed" event, or throw (a throw is a model failure; an
+// abort-triggered throw is cancellation).
+export type LlmStreamEvent =
+    | { type: "text_delta"; delta: string }
+    | { type: "reasoning_delta"; delta: string }
+    | { type: "step_event"; event: z.infer<typeof DurableLlmStepStreamEvent> }
+    | {
+          type: "completed";
+          message: z.infer<typeof AssistantMessage>;
+          finishReason: string;
+          usage: z.infer<typeof TurnUsage>;
+          providerMetadata?: JsonValue;
+      };
+
+export interface ModelStreamRequest {
+    systemPrompt: string;
+    // Provider wire-form messages: the output of encodeMessages. The loop
+    // builds these through the shared request composer, so what is sent is
+    // exactly what composeModelRequest reproduces from the durable log.
+    messages: JsonValue[];
+    tools: Array<z.infer<typeof ToolDescriptor>>;
+    parameters: Record<string, JsonValue>;
+    signal: AbortSignal;
+}
+
+export interface ResolvedModel {
+    descriptor: z.infer<typeof ModelDescriptor>;
+    // Deterministic per-message structural -> wire conversion (e.g. weaving
+    // userMessageContext into the user text, tool-result enveloping).
+    encodeMessages(
+        messages: Array<z.infer<typeof ConversationMessage>>,
+    ): JsonValue[];
+    stream(request: ModelStreamRequest): AsyncIterable<LlmStreamEvent>;
+}
+
+// Resolves the persisted model descriptor to a live model during advanceTurn.
+// A rejection is an infrastructure error: the execution is rejected and the
+// turn is left unchanged.
+export interface IModelRegistry {
+    resolve(descriptor: z.infer<typeof ModelDescriptor>): Promise<ResolvedModel>;
+}
diff --git a/apps/x/packages/core/src/turns/permission.ts b/apps/x/packages/core/src/turns/permission.ts
new file mode 100644
index 00000000..c6cc9022
--- /dev/null
+++ b/apps/x/packages/core/src/turns/permission.ts
@@ -0,0 +1,61 @@
+import type { z } from "zod";
+import type { ConversationMessage, JsonValue } from "@x/shared/dist/turns.js";
+
+export interface PermissionCheckInput {
+    turnId: string;
+    toolCallId: string;
+    toolId: string;
+    toolName: string;
+    input: unknown;
+}
+
+export interface PermissionCheckAllowed {
+    required: false;
+}
+
+export interface PermissionCheckRequired {
+    required: true;
+    // Presentation payload persisted on tool_permission_required and shown to
+    // the human/classifier.
+    request: JsonValue;
+}
+
+// Tool-specific policy (command analysis, filesystem boundaries, allowlists)
+// lives behind this seam, outside the loop. A thrown error fails closed: the
+// call is recorded as permission-required and never executes automatically.
+export interface IPermissionChecker {
+    check(
+        input: PermissionCheckInput,
+    ): Promise<PermissionCheckAllowed | PermissionCheckRequired>;
+}
+
+export interface PermissionClassificationInput {
+    toolCallId: string;
+    toolName: string;
+    input: unknown;
+    request: JsonValue;
+}
+
+export interface PermissionClassification {
+    toolCallId: string;
+    decision: "allow" | "deny" | "defer";
+    reason: string;
+}
+
+export interface PermissionClassificationBatch {
+    turnId: string;
+    // Conversation context for the classifier: the turn's resolved context
+    // plus current-turn settled messages.
+    messages: Array<z.infer<typeof ConversationMessage>>;
+    requests: PermissionClassificationInput[];
+}
+
+// Handles all permission-required calls from one model response in one batch
+// when automatic permission is enabled. Internal model calls are opaque to
+// the turn loop. Failures and omitted decisions normalize to defer.
+export interface IPermissionClassifier {
+    classify(
+        batch: PermissionClassificationBatch,
+        signal: AbortSignal,
+    ): Promise<PermissionClassification[]>;
+}
diff --git a/apps/x/packages/core/src/turns/repo.ts b/apps/x/packages/core/src/turns/repo.ts
new file mode 100644
index 00000000..6824f529
--- /dev/null
+++ b/apps/x/packages/core/src/turns/repo.ts
@@ -0,0 +1,15 @@
+import type { z } from "zod";
+import type { TurnCreated, TurnEvent } from "@x/shared/dist/turns.js";
+
+// Loop-facing repository contract. Listing, deletion, session lookup, and
+// presentation metadata are deliberately not part of it.
+export interface ITurnRepo {
+    // Fails if the turn already exists.
+    create(event: z.infer<typeof TurnCreated>): Promise<void>;
+    // Validates every line strictly; corrupt files are rejected whole.
+    read(turnId: string): Promise<Array<z.infer<typeof TurnEvent>>>;
+    // Validates events before writing.
+    append(turnId: string, events: Array<z.infer<typeof TurnEvent>>): Promise<void>;
+    // In-process per-turn exclusion.
+    withLock<T>(turnId: string, fn: () => Promise<T>): Promise<T>;
+}
diff --git a/apps/x/packages/core/src/turns/runtime.test.ts b/apps/x/packages/core/src/turns/runtime.test.ts
new file mode 100644
index 00000000..335250e4
--- /dev/null
+++ b/apps/x/packages/core/src/turns/runtime.test.ts
@@ -0,0 +1,1759 @@
+import { describe, expect, it } from "vitest";
+import type { z } from "zod";
+import {
+    MODEL_CALL_LIMIT_ERROR_CODE,
+    type JsonValue,
+    type ResolvedAgent,
+    type ToolDescriptor,
+    type TurnEvent,
+    type TurnStreamEvent,
+    reduceTurn,
+} from "@x/shared/dist/turns.js";
+import type { IAgentResolver } from "./agent-resolver.js";
+import type { TurnExecution, TurnOutcome } from "./api.js";
+import { TurnDependencyError, TurnInputError } from "./api.js";
+import type { TurnLifecycleEvent } from "./bus.js";
+import { TurnRepoContextResolver } from "./context-resolver.js";
+import { InMemoryTurnRepo } from "./in-memory-turn-repo.js";
+import type {
+    IModelRegistry,
+    LlmStreamEvent,
+    ModelStreamRequest,
+    ResolvedModel,
+} from "./model-registry.js";
+import type {
+    IPermissionChecker,
+    IPermissionClassifier,
+    PermissionCheckInput,
+    PermissionClassification,
+    PermissionClassificationBatch,
+    PermissionClassificationInput,
+} from "./permission.js";
+import { composeModelRequest } from "./compose-model-request.js";
+import { TurnRuntime } from "./runtime.js";
+import type {
+    IToolRegistry,
+    RuntimeTool,
+    SyncRuntimeTool,
+    ToolExecutionContext,
+} from "./tool-registry.js";
+
+// ---------------------------------------------------------------------------
+// Fixtures
+// ---------------------------------------------------------------------------
+
+const TS = "2026-07-02T10:00:00Z";
+
+const echoDescriptor: z.infer<typeof ToolDescriptor> = {
+    toolId: "tool.echo",
+    name: "echo",
+    description: "Echo tool",
+    inputSchema: {},
+    execution: "sync",
+    requiresHuman: false,
+};
+
+const fetchDescriptor: z.infer<typeof ToolDescriptor> = {
+    toolId: "tool.fetch",
+    name: "fetch",
+    description: "Async fetch tool",
+    inputSchema: {},
+    execution: "async",
+    requiresHuman: false,
+};
+
+const askHumanDescriptor: z.infer<typeof ToolDescriptor> = {
+    toolId: "tool.ask-human",
+    name: "ask-human",
+    description: "Ask the human",
+    inputSchema: {},
+    execution: "async",
+    requiresHuman: true,
+};
+
+const defaultAgent: z.infer<typeof ResolvedAgent> = {
+    agentId: "copilot",
+    systemPrompt: "SYS",
+    model: { provider: "fake", model: "m" },
+    tools: [echoDescriptor, fetchDescriptor, askHumanDescriptor],
+};
+
+function user(text: string) {
+    return { role: "user" as const, content: text };
+}
+
+function assistantText(text: string) {
+    return { role: "assistant" as const, content: text };
+}
+
+function toolCallPart(id: string, name: string, args: JsonValue = {}) {
+    return {
+        type: "tool-call" as const,
+        toolCallId: id,
+        toolName: name,
+        arguments: args,
+    };
+}
+
+function assistantCalls(...parts: Array<ReturnType<typeof toolCallPart>>) {
+    return { role: "assistant" as const, content: parts };
+}
+
+function completedResp(
+    message: Extract<LlmStreamEvent, { type: "completed" }>["message"],
+): LlmStreamEvent {
+    return {
+        type: "completed",
+        message,
+        finishReason: "stop",
+        usage: { inputTokens: 10, outputTokens: 5, totalTokens: 15 },
+    };
+}
+
+type ScriptedCall = (
+    request: ModelStreamRequest,
+) => AsyncGenerator<LlmStreamEvent, void, void>;
+
+function respond(...events: LlmStreamEvent[]): ScriptedCall {
+    return async function* () {
+        yield* events;
+    };
+}
+
+function failCall(error: string): ScriptedCall {
+    // eslint-disable-next-line require-yield
+    return async function* () {
+        throw new Error(error);
+    };
+}
+
+function hangUntilAbort(onStarted?: () => void): ScriptedCall {
+    // eslint-disable-next-line require-yield
+    return async function* (request) {
+        onStarted?.();
+        await new Promise<void>((resolve) => {
+            if (request.signal.aborted) {
+                resolve();
+            } else {
+                request.signal.addEventListener("abort", () => resolve(), {
+                    once: true,
+                });
+            }
+        });
+        throw new Error("aborted");
+    };
+}
+
+class FakeModelRegistry implements IModelRegistry {
+    requests: ModelStreamRequest[] = [];
+    resolved: Array<ResolvedModel["descriptor"]> = [];
+    private next = 0;
+
+    constructor(private readonly calls: ScriptedCall[]) {}
+
+    async resolve(
+        descriptor: ResolvedModel["descriptor"],
+    ): Promise<ResolvedModel> {
+        this.resolved.push(descriptor);
+        return {
+            descriptor,
+            // Identity encoding: tests assert on structural messages directly.
+            encodeMessages: (messages) => messages as unknown as JsonValue[],
+            stream: (request) => {
+                this.requests.push(request);
+                const call = this.calls[this.next++];
+                if (!call) {
+                    throw new Error("no scripted model call remaining");
+                }
+                return call(request);
+            },
+        };
+    }
+}
+
+function syncTool(
+    descriptor: z.infer<typeof ToolDescriptor>,
+    execute: SyncRuntimeTool["execute"],
+): SyncRuntimeTool {
+    return {
+        descriptor: descriptor as SyncRuntimeTool["descriptor"],
+        execute,
+    };
+}
+
+const defaultTools: RuntimeTool[] = [
+    syncTool(echoDescriptor, async (input) => ({
+        output: { echoed: (input ?? null) as JsonValue },
+        isError: false,
+    })),
+    { descriptor: fetchDescriptor as { execution: "async" } & typeof fetchDescriptor },
+    { descriptor: askHumanDescriptor as { execution: "async" } & typeof askHumanDescriptor },
+];
+
+class FakeToolRegistry implements IToolRegistry {
+    constructor(private readonly tools: RuntimeTool[]) {}
+
+    async resolve(
+        descriptor: z.infer<typeof ToolDescriptor>,
+    ): Promise<RuntimeTool> {
+        const tool = this.tools.find(
+            (t) => t.descriptor.toolId === descriptor.toolId,
+        );
+        if (!tool) {
+            throw new TurnDependencyError(`no live tool for ${descriptor.toolId}`);
+        }
+        return tool;
+    }
+}
+
+type CheckerRule = "allow" | { request: JsonValue } | "throw";
+
+class FakePermissionChecker implements IPermissionChecker {
+    calls: PermissionCheckInput[] = [];
+
+    constructor(private readonly rules: Record<string, CheckerRule> = {}) {}
+
+    async check(input: PermissionCheckInput) {
+        this.calls.push(input);
+        const rule = this.rules[input.toolName] ?? "allow";
+        if (rule === "allow") {
+            return { required: false as const };
+        }
+        if (rule === "throw") {
+            throw new Error("checker exploded");
+        }
+        return { required: true as const, request: rule.request };
+    }
+}
+
+class FakePermissionClassifier implements IPermissionClassifier {
+    batches: PermissionClassificationInput[][] = [];
+    contexts: Array<{ turnId: string; messageCount: number }> = [];
+
+    constructor(
+        private readonly impl?: (
+            requests: PermissionClassificationInput[],
+        ) => PermissionClassification[],
+        private readonly throws?: string,
+    ) {}
+
+    async classify(
+        batch: PermissionClassificationBatch,
+    ): Promise<PermissionClassification[]> {
+        this.batches.push(batch.requests);
+        this.contexts.push({
+            turnId: batch.turnId,
+            messageCount: batch.messages.length,
+        });
+        if (this.throws) {
+            throw new Error(this.throws);
+        }
+        if (!this.impl) {
+            throw new Error("classifier must not be called in this test");
+        }
+        return this.impl(batch.requests);
+    }
+}
+
+class FakeAgentResolver implements IAgentResolver {
+    constructor(
+        private readonly agent: z.infer<typeof ResolvedAgent>,
+        private readonly error?: string,
+    ) {}
+
+    async resolve() {
+        if (this.error) {
+            throw new Error(this.error);
+        }
+        return this.agent;
+    }
+}
+
+class FakeBus {
+    events: TurnLifecycleEvent[] = [];
+    publish(event: TurnLifecycleEvent): void {
+        this.events.push(event);
+    }
+}
+
+class FakeIdGen {
+    private n: number;
+    constructor(start = 0) {
+        this.n = start;
+    }
+    async next(): Promise<string> {
+        this.n += 1;
+        return `2026-07-02T10-00-00Z-${String(this.n).padStart(7, "0")}-000`;
+    }
+}
+
+class FakeClock {
+    now(): string {
+        return TS;
+    }
+}
+
+function makeRuntime(opts: {
+    models?: ScriptedCall[];
+    tools?: RuntimeTool[];
+    checker?: FakePermissionChecker;
+    classifier?: FakePermissionClassifier;
+    agent?: z.infer<typeof ResolvedAgent>;
+    agentError?: string;
+    repo?: InMemoryTurnRepo;
+    idStart?: number;
+} = {}) {
+    const repo = opts.repo ?? new InMemoryTurnRepo();
+    const models = new FakeModelRegistry(opts.models ?? []);
+    const checker = opts.checker ?? new FakePermissionChecker();
+    const classifier = opts.classifier ?? new FakePermissionClassifier();
+    const bus = new FakeBus();
+    const usage = new FakeUsageReporter();
+    const runtime = new TurnRuntime({
+        turnRepo: repo,
+        idGenerator: new FakeIdGen(opts.idStart ?? 0),
+        clock: new FakeClock(),
+        agentResolver: new FakeAgentResolver(opts.agent ?? defaultAgent, opts.agentError),
+        modelRegistry: models,
+        toolRegistry: new FakeToolRegistry(opts.tools ?? defaultTools),
+        contextResolver: new TurnRepoContextResolver({ turnRepo: repo }),
+        permissionChecker: checker,
+        permissionClassifier: classifier,
+        lifecycleBus: bus,
+        usageReporter: usage,
+    });
+    return { runtime, repo, models, checker, classifier, bus, usage };
+}
+
+async function newTurn(
+    runtime: TurnRuntime,
+    overrides: Partial<Parameters<TurnRuntime["createTurn"]>[0]> = {},
+): Promise<string> {
+    return runtime.createTurn({
+        agent: { agentId: "copilot" },
+        context: [],
+        input: user("hello"),
+        config: { humanAvailable: true },
+        ...overrides,
+    });
+}
+
+async function settle(execution: TurnExecution): Promise<{
+    outcome?: TurnOutcome;
+    error?: unknown;
+    events: TurnStreamEvent[];
+}> {
+    const events: TurnStreamEvent[] = [];
+    const consumer = (async () => {
+        try {
+            for await (const event of execution.events) {
+                events.push(event);
+            }
+        } catch {
+            // Infrastructure failures also reject the outcome; tests assert there.
+        }
+    })();
+    let outcome: TurnOutcome | undefined;
+    let error: unknown;
+    try {
+        outcome = await execution.outcome;
+    } catch (err) {
+        error = err;
+    }
+    await consumer;
+    return { outcome, error, events };
+}
+
+async function advanceAndSettle(
+    runtime: TurnRuntime,
+    turnId: string,
+    input?: Parameters<TurnRuntime["advanceTurn"]>[1],
+    options?: Parameters<TurnRuntime["advanceTurn"]>[2],
+) {
+    return settle(runtime.advanceTurn(turnId, input, options));
+}
+
+class FakeUsageReporter {
+    reports: Array<{
+        agentId: string;
+        model: { provider: string; model: string };
+        usage: Record<string, number | undefined>;
+    }> = [];
+    reportModelUsage(report: {
+        agentId: string;
+        model: { provider: string; model: string };
+        usage: Record<string, number | undefined>;
+    }): void {
+        this.reports.push(report);
+    }
+}
+
+function typesOf(events: Array<{ type: string }>): string[] {
+    return events.map((e) => e.type);
+}
+
+// The fake model's identity encoding passes structural messages through.
+function sentMessages(request: ModelStreamRequest) {
+    return request.messages as Array<{
+        role: string;
+        content?: unknown;
+        toolCallId?: string;
+    }>;
+}
+
+async function persisted(
+    repo: InMemoryTurnRepo,
+    turnId: string,
+): Promise<Array<z.infer<typeof TurnEvent>>> {
+    return repo.read(turnId);
+}
+
+// ---------------------------------------------------------------------------
+// §26.1 Plain model response
+// ---------------------------------------------------------------------------
+
+describe("plain model response (26.1)", () => {
+    it("runs one model step to completion with exact persisted request", async () => {
+        const { runtime, repo, models, bus, usage } = makeRuntime({
+            models: [
+                respond(
+                    { type: "text_delta", delta: "do" },
+                    { type: "step_event", event: { type: "text_end", text: "done" } },
+                    { type: "text_delta", delta: "ne" },
+                    completedResp(assistantText("done")),
+                ),
+            ],
+        });
+        const turnId = await newTurn(runtime);
+        const { outcome, events } = await advanceAndSettle(runtime, turnId);
+
+        expect(outcome).toMatchObject({
+            status: "completed",
+            output: assistantText("done"),
+            finishReason: "stop",
+        });
+
+        const log = await persisted(repo, turnId);
+        expect(typesOf(log)).toEqual([
+            "turn_created",
+            "model_call_requested",
+            "model_step_event",
+            "model_call_completed",
+            "turn_completed",
+        ]);
+        const request = log[1];
+        expect(request).toMatchObject({
+            modelCallIndex: 0,
+            request: { messages: ["input"] },
+        });
+        // The model received the composed payload: resolved system prompt,
+        // snapshot tools, encoded messages.
+        expect(models.requests[0].systemPrompt).toBe("SYS");
+        expect(sentMessages(models.requests[0])).toEqual([user("hello")]);
+        // One usage report per completed model call, after the durable append.
+        expect(usage.reports).toEqual([
+            {
+                agentId: "copilot",
+                model: defaultAgent.model,
+                usage: { inputTokens: 10, outputTokens: 5, totalTokens: 15 },
+            },
+        ]);
+        // Deltas are streamed but never persisted.
+        expect(events.filter((e) => e.type === "text_delta")).toHaveLength(2);
+        expect(typesOf(log)).not.toContain("text_delta");
+        // Terminal event duplicates output and aggregate usage.
+        const terminal = log[log.length - 1];
+        expect(terminal).toMatchObject({
+            type: "turn_completed",
+            output: assistantText("done"),
+            usage: { inputTokens: 10, outputTokens: 5, totalTokens: 15 },
+        });
+        // Lifecycle bus events are emitted but not persisted.
+        expect(bus.events.map((e) => e.type)).toEqual([
+            "turn-processing-start",
+            "turn-processing-end",
+        ]);
+    });
+
+    it("streams durable events only after persistence, matching the file", async () => {
+        const { runtime, repo } = makeRuntime({
+            models: [respond(completedResp(assistantText("done")))],
+        });
+        const turnId = await newTurn(runtime);
+        const { events } = await advanceAndSettle(runtime, turnId);
+        const durable = events.filter(
+            (e) => e.type !== "text_delta" && e.type !== "reasoning_delta",
+        );
+        const log = await persisted(repo, turnId);
+        expect(durable).toEqual(log.slice(1));
+    });
+
+    it("outcome resolves without consuming the event stream", async () => {
+        const { runtime } = makeRuntime({
+            models: [respond(completedResp(assistantText("done")))],
+        });
+        const turnId = await newTurn(runtime);
+        const execution = runtime.advanceTurn(turnId);
+        const outcome = await execution.outcome;
+        expect(outcome.status).toBe("completed");
+    });
+});
+
+// ---------------------------------------------------------------------------
+// §26.2 Mixed sync and async tools
+// ---------------------------------------------------------------------------
+
+describe("mixed sync and async tools (26.2)", () => {
+    it("executes sync tools, suspends on async, and preserves source order in the next request", async () => {
+        const batch = assistantCalls(
+            toolCallPart("A", "echo", { i: 1 }),
+            toolCallPart("B", "fetch", { i: 2 }),
+            toolCallPart("C", "echo", { i: 3 }),
+            toolCallPart("D", "fetch", { i: 4 }),
+        );
+        const { runtime, repo, models } = makeRuntime({
+            models: [
+                respond(completedResp(batch)),
+                respond(completedResp(assistantText("done"))),
+            ],
+        });
+        const turnId = await newTurn(runtime);
+
+        const first = await advanceAndSettle(runtime, turnId);
+        expect(first.outcome).toMatchObject({
+            status: "suspended",
+            pendingAsyncTools: [
+                expect.objectContaining({ toolCallId: "B" }),
+                expect.objectContaining({ toolCallId: "D" }),
+            ],
+        });
+
+        // Async results arrive in reverse order.
+        const second = await advanceAndSettle(runtime, turnId, {
+            type: "async_tool_result",
+            toolCallId: "D",
+            result: { output: "d-result", isError: false },
+        });
+        expect(second.outcome?.status).toBe("suspended");
+
+        const third = await advanceAndSettle(runtime, turnId, {
+            type: "async_tool_result",
+            toolCallId: "B",
+            result: { output: "b-result", isError: false },
+        });
+        expect(third.outcome?.status).toBe("completed");
+
+        // The next model request carries results in original source order
+        // even though physical completion order was A, C, D, B.
+        const log = await persisted(repo, turnId);
+        const secondRequest = log.find(
+            (e) => e.type === "model_call_requested" && e.modelCallIndex === 1,
+        );
+        expect(secondRequest).toBeDefined();
+        expect(
+            secondRequest?.type === "model_call_requested"
+                ? secondRequest.request.messages
+                : [],
+        ).toEqual([
+            "assistant:0",
+            "toolResult:A",
+            "toolResult:B",
+            "toolResult:C",
+            "toolResult:D",
+        ]);
+        // The live model call saw the results in source order.
+        expect(
+            sentMessages(models.requests[1])
+                .filter((m) => m.role === "tool")
+                .map((m) => m.toolCallId),
+        ).toEqual(["A", "B", "C", "D"]);
+        // Byte-for-byte property: the durable file plus the shared composer
+        // reproduces exactly what the model received.
+        const state = reduceTurn(log);
+        for (const index of [0, 1]) {
+            const composed = composeModelRequest(state, index, [], defaultAgent, (m) => m as never);
+            expect(composed.messages).toEqual(models.requests[index].messages);
+            expect(composed.systemPrompt).toBe(models.requests[index].systemPrompt);
+            expect(composed.tools).toEqual(models.requests[index].tools);
+        }
+        // Size guard: request events stay reference-sized — the transcript
+        // duplication this design removes must not creep back.
+        for (const event of log) {
+            if (event.type === "model_call_requested") {
+                expect(JSON.stringify(event).length).toBeLessThan(2048);
+            }
+        }
+    });
+
+    it("rejects async results for calls that are not pending", async () => {
+        const { runtime } = makeRuntime({
+            models: [respond(completedResp(assistantText("done")))],
+        });
+        const turnId = await newTurn(runtime);
+        await advanceAndSettle(runtime, turnId);
+        const { error } = await advanceAndSettle(runtime, turnId, {
+            type: "async_tool_result",
+            toolCallId: "ghost",
+            result: { output: "x", isError: false },
+        });
+        expect(error).toBeInstanceOf(TurnInputError);
+    });
+});
+
+// ---------------------------------------------------------------------------
+// §26.3 Partial human permission decisions
+// ---------------------------------------------------------------------------
+
+describe("partial human permission decisions (26.3)", () => {
+    async function setup() {
+        const batch = assistantCalls(
+            toolCallPart("P1", "echo"),
+            toolCallPart("P2", "echo"),
+            toolCallPart("F1", "fetch"),
+        );
+        const fixture = makeRuntime({
+            models: [
+                respond(completedResp(batch)),
+                respond(completedResp(assistantText("done"))),
+            ],
+            checker: new FakePermissionChecker({
+                echo: { request: { kind: "command" } },
+            }),
+        });
+        const turnId = await newTurn(fixture.runtime);
+        const first = await advanceAndSettle(fixture.runtime, turnId);
+        return { ...fixture, turnId, first };
+    }
+
+    it("records all required permissions and exposes allowed async tools in one suspension", async () => {
+        const { first } = await setup();
+        expect(first.outcome).toMatchObject({
+            status: "suspended",
+            pendingPermissions: [
+                expect.objectContaining({ toolCallId: "P1" }),
+                expect.objectContaining({ toolCallId: "P2" }),
+            ],
+            pendingAsyncTools: [expect.objectContaining({ toolCallId: "F1" })],
+        });
+    });
+
+    it("one approval advances only its tool; denial yields an error result; no model call until all settle", async () => {
+        const { runtime, repo, turnId } = await setup();
+
+        const afterAllow = await advanceAndSettle(runtime, turnId, {
+            type: "permission_decision",
+            toolCallId: "P1",
+            decision: "allow",
+        });
+        expect(afterAllow.outcome).toMatchObject({
+            status: "suspended",
+            pendingPermissions: [expect.objectContaining({ toolCallId: "P2" })],
+        });
+        let log = await persisted(repo, turnId);
+        expect(
+            log.some(
+                (e) => e.type === "tool_result" && e.toolCallId === "P1" && e.source === "sync",
+            ),
+        ).toBe(true);
+
+        // Async result may arrive while a permission is still unresolved.
+        const afterAsync = await advanceAndSettle(runtime, turnId, {
+            type: "async_tool_result",
+            toolCallId: "F1",
+            result: { output: "fetched", isError: false },
+        });
+        expect(afterAsync.outcome?.status).toBe("suspended");
+
+        const afterDeny = await advanceAndSettle(runtime, turnId, {
+            type: "permission_decision",
+            toolCallId: "P2",
+            decision: "deny",
+        });
+        expect(afterDeny.outcome?.status).toBe("completed");
+
+        log = await persisted(repo, turnId);
+        const denial = log.find(
+            (e) => e.type === "tool_result" && e.toolCallId === "P2",
+        );
+        expect(denial).toMatchObject({
+            source: "runtime",
+            result: { isError: true },
+        });
+        // Exactly two model calls: the batch, then the follow-up.
+        expect(log.filter((e) => e.type === "model_call_requested")).toHaveLength(2);
+    });
+
+    it("rejects decisions for permissions that are not pending", async () => {
+        const { runtime, turnId } = await setup();
+        await advanceAndSettle(runtime, turnId, {
+            type: "permission_decision",
+            toolCallId: "P1",
+            decision: "allow",
+        });
+        const { error } = await advanceAndSettle(runtime, turnId, {
+            type: "permission_decision",
+            toolCallId: "P1",
+            decision: "deny",
+        });
+        expect(error).toBeInstanceOf(TurnInputError);
+    });
+});
+
+// ---------------------------------------------------------------------------
+// §26.4 Automatic permission classification
+// ---------------------------------------------------------------------------
+
+describe("automatic permission classification (26.4)", () => {
+    const batch = assistantCalls(
+        toolCallPart("CA", "echo"),
+        toolCallPart("CD", "echo"),
+        toolCallPart("CF", "echo"),
+    );
+    const checkerRules = { echo: { request: { kind: "command" as const } } };
+    const classifierImpl = (requests: PermissionClassificationInput[]) =>
+        requests.map((r): PermissionClassification => {
+            const decision =
+                r.toolCallId === "CA" ? "allow" : r.toolCallId === "CD" ? "deny" : "defer";
+            return { toolCallId: r.toolCallId, decision, reason: `because ${decision}` };
+        });
+
+    it("handles allow, deny, and defer in one batch with a human available", async () => {
+        const { runtime, repo, classifier } = makeRuntime({
+            models: [respond(completedResp(batch))],
+            checker: new FakePermissionChecker(checkerRules),
+            classifier: new FakePermissionClassifier(classifierImpl),
+        });
+        const turnId = await newTurn(runtime, {
+            config: { humanAvailable: true, autoPermission: true },
+        });
+        const { outcome } = await advanceAndSettle(runtime, turnId);
+
+        // Deferred call asks the human.
+        expect(outcome).toMatchObject({
+            status: "suspended",
+            pendingPermissions: [expect.objectContaining({ toolCallId: "CF" })],
+        });
+        expect(classifier.batches).toHaveLength(1);
+        expect(classifier.batches[0].map((r) => r.toolCallId)).toEqual([
+            "CA",
+            "CD",
+            "CF",
+        ]);
+        // Conversation context reaches the classifier: input + batch response.
+        expect(classifier.contexts[0]).toEqual({
+            turnId,
+            messageCount: 2,
+        });
+
+        const log = await persisted(repo, turnId);
+        // Classifier provenance and effective decisions are distinct records.
+        expect(
+            log.filter((e) => e.type === "tool_permission_classified"),
+        ).toHaveLength(3);
+        const resolved = log.filter((e) => e.type === "tool_permission_resolved");
+        expect(resolved).toEqual([
+            expect.objectContaining({ toolCallId: "CA", decision: "allow", source: "classifier" }),
+            expect.objectContaining({ toolCallId: "CD", decision: "deny", source: "classifier" }),
+        ]);
+        // Allow executed; deny got an error result without invocation.
+        expect(
+            log.some((e) => e.type === "tool_result" && e.toolCallId === "CA" && e.source === "sync"),
+        ).toBe(true);
+        expect(
+            log.some(
+                (e) => e.type === "tool_invocation_requested" && e.toolCallId === "CD",
+            ),
+        ).toBe(false);
+    });
+
+    it("denies deferred calls when no human is available", async () => {
+        const { runtime, repo } = makeRuntime({
+            models: [
+                respond(completedResp(batch)),
+                respond(completedResp(assistantText("done"))),
+            ],
+            checker: new FakePermissionChecker(checkerRules),
+            classifier: new FakePermissionClassifier(classifierImpl),
+        });
+        const turnId = await newTurn(runtime, {
+            config: { humanAvailable: false, autoPermission: true },
+        });
+        const { outcome } = await advanceAndSettle(runtime, turnId);
+        expect(outcome?.status).toBe("completed");
+        const log = await persisted(repo, turnId);
+        expect(
+            log.find(
+                (e) => e.type === "tool_permission_resolved" && e.toolCallId === "CF",
+            ),
+        ).toMatchObject({ decision: "deny", source: "human_unavailable" });
+    });
+
+    it("classifier failure records the failure and defers to the human", async () => {
+        const { runtime, repo } = makeRuntime({
+            models: [respond(completedResp(batch))],
+            checker: new FakePermissionChecker(checkerRules),
+            classifier: new FakePermissionClassifier(undefined, "classifier exploded"),
+        });
+        const turnId = await newTurn(runtime, {
+            config: { humanAvailable: true, autoPermission: true },
+        });
+        const { outcome } = await advanceAndSettle(runtime, turnId);
+        expect(outcome).toMatchObject({ status: "suspended" });
+        expect(
+            outcome?.status === "suspended"
+                ? outcome.pendingPermissions.map((p) => p.toolCallId)
+                : [],
+        ).toEqual(["CA", "CD", "CF"]);
+        const log = await persisted(repo, turnId);
+        expect(
+            log.find((e) => e.type === "tool_permission_classification_failed"),
+        ).toMatchObject({ toolCallIds: ["CA", "CD", "CF"] });
+        // A later advance does not re-classify failed calls.
+        const again = await advanceAndSettle(runtime, turnId);
+        expect(again.outcome?.status).toBe("suspended");
+    });
+
+    it("missing decisions are recorded as per-call classification failures", async () => {
+        const { runtime, repo } = makeRuntime({
+            models: [respond(completedResp(batch))],
+            checker: new FakePermissionChecker(checkerRules),
+            classifier: new FakePermissionClassifier((requests) =>
+                requests
+                    .filter((r) => r.toolCallId !== "CF")
+                    .map((r) => ({
+                        toolCallId: r.toolCallId,
+                        decision: "allow",
+                        reason: "ok",
+                    })),
+            ),
+        });
+        const turnId = await newTurn(runtime, {
+            config: { humanAvailable: true, autoPermission: true },
+        });
+        const { outcome } = await advanceAndSettle(runtime, turnId);
+        expect(outcome).toMatchObject({
+            status: "suspended",
+            pendingPermissions: [expect.objectContaining({ toolCallId: "CF" })],
+        });
+        const log = await persisted(repo, turnId);
+        expect(
+            log.find((e) => e.type === "tool_permission_classification_failed"),
+        ).toMatchObject({ toolCallIds: ["CF"] });
+    });
+
+    it("manual mode never calls the classifier", async () => {
+        const classifier = new FakePermissionClassifier(); // throws if called
+        const { runtime } = makeRuntime({
+            models: [respond(completedResp(batch))],
+            checker: new FakePermissionChecker(checkerRules),
+            classifier,
+        });
+        const turnId = await newTurn(runtime, {
+            config: { humanAvailable: true, autoPermission: false },
+        });
+        const { outcome } = await advanceAndSettle(runtime, turnId);
+        expect(outcome?.status).toBe("suspended");
+        expect(classifier.batches).toHaveLength(0);
+    });
+
+    it("checker failure fails closed: recorded, routed to human, never auto-executed", async () => {
+        const { runtime, repo, classifier } = makeRuntime({
+            models: [respond(completedResp(assistantCalls(toolCallPart("X", "echo"))))],
+            checker: new FakePermissionChecker({ echo: "throw" }),
+            classifier: new FakePermissionClassifier(() => [
+                { toolCallId: "X", decision: "allow", reason: "should not matter" },
+            ]),
+        });
+        const turnId = await newTurn(runtime, {
+            config: { humanAvailable: true, autoPermission: true },
+        });
+        const { outcome } = await advanceAndSettle(runtime, turnId);
+        expect(outcome).toMatchObject({
+            status: "suspended",
+            pendingPermissions: [expect.objectContaining({ toolCallId: "X" })],
+        });
+        // The classifier is bypassed for checker-error calls.
+        expect(classifier.batches).toHaveLength(0);
+        const log = await persisted(repo, turnId);
+        expect(
+            log.find((e) => e.type === "tool_permission_required"),
+        ).toMatchObject({ checkerError: "checker exploded" });
+        expect(log.some((e) => e.type === "tool_invocation_requested")).toBe(false);
+    });
+
+    it("checker failure with no human denies without executing", async () => {
+        const { runtime, repo } = makeRuntime({
+            models: [
+                respond(completedResp(assistantCalls(toolCallPart("X", "echo")))),
+                respond(completedResp(assistantText("done"))),
+            ],
+            checker: new FakePermissionChecker({ echo: "throw" }),
+        });
+        const turnId = await newTurn(runtime, {
+            config: { humanAvailable: false, autoPermission: false },
+        });
+        const { outcome } = await advanceAndSettle(runtime, turnId);
+        expect(outcome?.status).toBe("completed");
+        const log = await persisted(repo, turnId);
+        expect(
+            log.find((e) => e.type === "tool_permission_resolved"),
+        ).toMatchObject({ decision: "deny", source: "human_unavailable" });
+        expect(log.some((e) => e.type === "tool_invocation_requested")).toBe(false);
+    });
+});
+
+// ---------------------------------------------------------------------------
+// Human-dependent tools
+// ---------------------------------------------------------------------------
+
+describe("human-dependent tools", () => {
+    it("ask-human suspends as a pending async tool when a human is available", async () => {
+        const { runtime } = makeRuntime({
+            models: [
+                respond(completedResp(assistantCalls(toolCallPart("H", "ask-human")))),
+                respond(completedResp(assistantText("done"))),
+            ],
+        });
+        const turnId = await newTurn(runtime);
+        const first = await advanceAndSettle(runtime, turnId);
+        expect(first.outcome).toMatchObject({
+            status: "suspended",
+            pendingAsyncTools: [expect.objectContaining({ toolCallId: "H" })],
+        });
+        const second = await advanceAndSettle(runtime, turnId, {
+            type: "async_tool_result",
+            toolCallId: "H",
+            result: { output: "42", isError: false },
+        });
+        expect(second.outcome?.status).toBe("completed");
+    });
+
+    it("requiresHuman tools get an immediate error result when no human is available", async () => {
+        const { runtime, repo } = makeRuntime({
+            models: [
+                respond(completedResp(assistantCalls(toolCallPart("H", "ask-human")))),
+                respond(completedResp(assistantText("done"))),
+            ],
+        });
+        const turnId = await newTurn(runtime, {
+            config: { humanAvailable: false },
+        });
+        const { outcome } = await advanceAndSettle(runtime, turnId);
+        expect(outcome?.status).toBe("completed");
+        const log = await persisted(repo, turnId);
+        expect(
+            log.some((e) => e.type === "tool_invocation_requested" && e.toolCallId === "H"),
+        ).toBe(true);
+        expect(log.find((e) => e.type === "tool_result" && e.toolCallId === "H")).toMatchObject({
+            source: "runtime",
+            result: { isError: true },
+        });
+    });
+});
+
+// ---------------------------------------------------------------------------
+// §26.5 Cancellation
+// ---------------------------------------------------------------------------
+
+describe("cancellation (26.5)", () => {
+    it("cancels a suspended turn via the cancel input", async () => {
+        const { runtime, repo } = makeRuntime({
+            models: [
+                respond(completedResp(assistantCalls(toolCallPart("B", "fetch")))),
+            ],
+        });
+        const turnId = await newTurn(runtime);
+        await advanceAndSettle(runtime, turnId);
+
+        const { outcome } = await advanceAndSettle(runtime, turnId, {
+            type: "cancel",
+            reason: "user stop",
+        });
+        expect(outcome).toMatchObject({ status: "cancelled", reason: "user stop" });
+
+        const log = await persisted(repo, turnId);
+        expect(log.find((e) => e.type === "tool_result" && e.toolCallId === "B")).toMatchObject({
+            source: "runtime",
+            result: { isError: true },
+        });
+        expect(log[log.length - 1]).toMatchObject({
+            type: "turn_cancelled",
+            reason: "user stop",
+        });
+
+        // Late external inputs are rejected.
+        const late = await advanceAndSettle(runtime, turnId, {
+            type: "async_tool_result",
+            toolCallId: "B",
+            result: { output: "late", isError: false },
+        });
+        expect(late.error).toBeInstanceOf(TurnInputError);
+    });
+
+    it("cancels during a model call via the abort signal", async () => {
+        const controller = new AbortController();
+        let abortNow: (() => void) | undefined;
+        const started = new Promise<void>((resolve) => {
+            abortNow = () => resolve();
+        });
+        const { runtime, repo } = makeRuntime({
+            models: [hangUntilAbort(() => abortNow?.())],
+        });
+        const turnId = await newTurn(runtime);
+        const execution = runtime.advanceTurn(turnId, undefined, {
+            signal: controller.signal,
+        });
+        await started;
+        controller.abort();
+        const { outcome } = await settle(execution);
+        expect(outcome?.status).toBe("cancelled");
+        const log = await persisted(repo, turnId);
+        expect(typesOf(log)).toEqual([
+            "turn_created",
+            "model_call_requested",
+            "model_call_failed",
+            "turn_cancelled",
+        ]);
+    });
+
+    it("cancels during a sync tool with a synthetic result", async () => {
+        const controller = new AbortController();
+        const tools: RuntimeTool[] = [
+            syncTool(echoDescriptor, async (_input, ctx: ToolExecutionContext) => {
+                controller.abort();
+                if (!ctx.signal.aborted) {
+                    await new Promise<void>((resolve) => {
+                        ctx.signal.addEventListener("abort", () => resolve(), {
+                            once: true,
+                        });
+                    });
+                }
+                throw new Error("aborted mid-tool");
+            }),
+            { descriptor: fetchDescriptor as { execution: "async" } & typeof fetchDescriptor },
+            { descriptor: askHumanDescriptor as { execution: "async" } & typeof askHumanDescriptor },
+        ];
+        const { runtime, repo } = makeRuntime({
+            models: [respond(completedResp(assistantCalls(toolCallPart("S", "echo"))))],
+            tools,
+        });
+        const turnId = await newTurn(runtime);
+        const { outcome } = await advanceAndSettle(runtime, turnId, undefined, {
+            signal: controller.signal,
+        });
+        expect(outcome?.status).toBe("cancelled");
+        const log = await persisted(repo, turnId);
+        expect(log.find((e) => e.type === "tool_result" && e.toolCallId === "S")).toMatchObject({
+            source: "runtime",
+            result: { isError: true },
+        });
+        expect(log[log.length - 1].type).toBe("turn_cancelled");
+    });
+});
+
+// ---------------------------------------------------------------------------
+// §26.6 Failures
+// ---------------------------------------------------------------------------
+
+describe("failures (26.6)", () => {
+    it("provider failure appends model and turn failures", async () => {
+        const { runtime, repo } = makeRuntime({ models: [failCall("boom")] });
+        const turnId = await newTurn(runtime);
+        const { outcome } = await advanceAndSettle(runtime, turnId);
+        expect(outcome).toMatchObject({ status: "failed", error: "boom" });
+        const log = await persisted(repo, turnId);
+        expect(typesOf(log)).toEqual([
+            "turn_created",
+            "model_call_requested",
+            "model_call_failed",
+            "turn_failed",
+        ]);
+    });
+
+    it("a sync tool throw becomes an error result and the turn continues", async () => {
+        const tools: RuntimeTool[] = [
+            syncTool(echoDescriptor, async () => {
+                throw new Error("tool exploded");
+            }),
+            { descriptor: fetchDescriptor as { execution: "async" } & typeof fetchDescriptor },
+            { descriptor: askHumanDescriptor as { execution: "async" } & typeof askHumanDescriptor },
+        ];
+        const { runtime, repo } = makeRuntime({
+            models: [
+                respond(completedResp(assistantCalls(toolCallPart("T", "echo")))),
+                respond(completedResp(assistantText("recovered"))),
+            ],
+            tools,
+        });
+        const turnId = await newTurn(runtime);
+        const { outcome } = await advanceAndSettle(runtime, turnId);
+        expect(outcome).toMatchObject({
+            status: "completed",
+            output: assistantText("recovered"),
+        });
+        const log = await persisted(repo, turnId);
+        expect(log.find((e) => e.type === "tool_result")).toMatchObject({
+            source: "sync",
+            result: { output: "tool exploded", isError: true },
+        });
+    });
+
+    it("an async failure result becomes an error tool result and the turn continues", async () => {
+        const { runtime } = makeRuntime({
+            models: [
+                respond(completedResp(assistantCalls(toolCallPart("B", "fetch")))),
+                respond(completedResp(assistantText("done"))),
+            ],
+        });
+        const turnId = await newTurn(runtime);
+        await advanceAndSettle(runtime, turnId);
+        const { outcome } = await advanceAndSettle(runtime, turnId, {
+            type: "async_tool_result",
+            toolCallId: "B",
+            result: { output: "network unreachable", isError: true },
+        });
+        expect(outcome?.status).toBe("completed");
+    });
+
+    it("unknown tools become runtime error results, not turn failures", async () => {
+        const { runtime, repo } = makeRuntime({
+            models: [
+                respond(completedResp(assistantCalls(toolCallPart("U", "no-such-tool")))),
+                respond(completedResp(assistantText("done"))),
+            ],
+        });
+        const turnId = await newTurn(runtime);
+        const { outcome } = await advanceAndSettle(runtime, turnId);
+        expect(outcome?.status).toBe("completed");
+        const log = await persisted(repo, turnId);
+        expect(log.find((e) => e.type === "tool_result" && e.toolCallId === "U")).toMatchObject({
+            source: "runtime",
+            result: { isError: true },
+        });
+    });
+
+    it("repository errors reject stream and outcome without a false turn_failed", async () => {
+        const { runtime } = makeRuntime();
+        const execution = runtime.advanceTurn("2026-07-02T10-00-00Z-9999999-000");
+        await expect(execution.outcome).rejects.toThrowError(/turn not found/);
+        await expect(
+            (async () => {
+                for await (const event of execution.events) {
+                    void event; // drain
+                }
+            })(),
+        ).rejects.toThrowError(/turn not found/);
+    });
+
+    it("missing live tools reject the execution and leave the turn unchanged", async () => {
+        const { runtime, repo } = makeRuntime({
+            models: [respond(completedResp(assistantText("done")))],
+            tools: [], // registry knows nothing
+        });
+        const turnId = await newTurn(runtime);
+        const { error } = await advanceAndSettle(runtime, turnId);
+        expect(error).toBeInstanceOf(TurnDependencyError);
+        expect((await persisted(repo, turnId)).length).toBe(1); // only turn_created
+    });
+
+    it("agent resolution failure rejects createTurn without creating a file", async () => {
+        const { runtime, repo } = makeRuntime({ agentError: "no such agent" });
+        await expect(newTurn(runtime)).rejects.toThrowError("no such agent");
+        await expect(
+            repo.read("2026-07-02T10-00-00Z-0000001-000"),
+        ).rejects.toThrowError(/turn not found/);
+    });
+});
+
+// ---------------------------------------------------------------------------
+// §26.7 Crash recovery
+// ---------------------------------------------------------------------------
+
+describe("crash recovery (26.7)", () => {
+    const SEED_ID = "2026-07-02T10-00-00Z-0000001-000";
+
+    function seedCreated(config?: {
+        autoPermission: boolean;
+        humanAvailable: boolean;
+        maxModelCalls: number;
+    }): z.infer<typeof TurnEvent> {
+        return {
+            type: "turn_created",
+            schemaVersion: 1,
+            turnId: SEED_ID,
+            ts: TS,
+            sessionId: null,
+            agent: { requested: { agentId: "copilot" }, resolved: defaultAgent },
+            context: [],
+            input: user("hello"),
+            config: config ?? {
+                autoPermission: false,
+                humanAvailable: true,
+                maxModelCalls: 20,
+            },
+        };
+    }
+
+    function seedRequested(
+        index: number,
+        refs: string[] = ["input"],
+    ): z.infer<typeof TurnEvent> {
+        return {
+            type: "model_call_requested",
+            turnId: SEED_ID,
+            ts: TS,
+            modelCallIndex: index,
+            request: {
+                messages: refs,
+                parameters: {},
+            },
+        };
+    }
+
+    function seedCompleted(index: number, message: Parameters<typeof completedResp>[0]): z.infer<typeof TurnEvent> {
+        return {
+            type: "model_call_completed",
+            turnId: SEED_ID,
+            ts: TS,
+            modelCallIndex: index,
+            message,
+            finishReason: "stop",
+            usage: {},
+        };
+    }
+
+    it("created-only log initiates the first model call", async () => {
+        const repo = new InMemoryTurnRepo();
+        repo.seed([seedCreated()]);
+        const { runtime } = makeRuntime({
+            repo,
+            models: [respond(completedResp(assistantText("done")))],
+        });
+        const { outcome } = await advanceAndSettle(runtime, SEED_ID);
+        expect(outcome?.status).toBe("completed");
+    });
+
+    it("an unmatched model request is closed as interrupted and re-issued", async () => {
+        const repo = new InMemoryTurnRepo();
+        repo.seed([seedCreated(), seedRequested(0)]);
+        const { runtime, models } = makeRuntime({
+            repo,
+            models: [respond(completedResp(assistantText("done")))],
+        });
+        const { outcome } = await advanceAndSettle(runtime, SEED_ID);
+        expect(outcome?.status).toBe("completed");
+        const log = await persisted(repo, SEED_ID);
+        expect(typesOf(log)).toEqual([
+            "turn_created",
+            "model_call_requested",
+            "model_call_failed",
+            "model_call_requested",
+            "model_call_completed",
+            "turn_completed",
+        ]);
+        expect(log[2]).toMatchObject({ error: expect.stringMatching(/interrupted/) });
+        expect(models.requests).toHaveLength(1); // only the re-issued call hit the provider
+    });
+
+    it("the re-issued call counts against the model-call budget", async () => {
+        const repo = new InMemoryTurnRepo();
+        repo.seed([
+            seedCreated({
+                autoPermission: false,
+                humanAvailable: true,
+                maxModelCalls: 1,
+            }),
+            seedRequested(0),
+        ]);
+        const { runtime } = makeRuntime({ repo });
+        const { outcome } = await advanceAndSettle(runtime, SEED_ID);
+        expect(outcome).toMatchObject({
+            status: "failed",
+            code: MODEL_CALL_LIMIT_ERROR_CODE,
+        });
+    });
+
+    it("an unmatched sync invocation gets an indeterminate result and the turn continues", async () => {
+        const repo = new InMemoryTurnRepo();
+        const batch = assistantCalls(toolCallPart("S", "echo"));
+        repo.seed([
+            seedCreated(),
+            seedRequested(0),
+            seedCompleted(0, batch),
+            {
+                type: "tool_invocation_requested",
+                turnId: SEED_ID,
+                ts: TS,
+                toolCallId: "S",
+                toolId: "tool.echo",
+                toolName: "echo",
+                execution: "sync",
+                input: {},
+            },
+        ]);
+        const { runtime } = makeRuntime({
+            repo,
+            models: [respond(completedResp(assistantText("done")))],
+        });
+        const { outcome } = await advanceAndSettle(runtime, SEED_ID);
+        expect(outcome?.status).toBe("completed");
+        const log = await persisted(repo, SEED_ID);
+        expect(log.find((e) => e.type === "tool_result" && e.toolCallId === "S")).toMatchObject({
+            source: "runtime",
+            result: {
+                output: expect.stringMatching(/interrupted; its outcome is unknown/),
+                isError: true,
+            },
+        });
+        // No turn_failed anywhere: the turn completed.
+        expect(typesOf(log)).not.toContain("turn_failed");
+    });
+
+    it("an unmatched async invocation remains suspended, appending the missing snapshot", async () => {
+        const repo = new InMemoryTurnRepo();
+        const batch = assistantCalls(toolCallPart("B", "fetch"));
+        repo.seed([
+            seedCreated(),
+            seedRequested(0),
+            seedCompleted(0, batch),
+            {
+                type: "tool_invocation_requested",
+                turnId: SEED_ID,
+                ts: TS,
+                toolCallId: "B",
+                toolId: "tool.fetch",
+                toolName: "fetch",
+                execution: "async",
+                input: {},
+            },
+        ]);
+        const { runtime } = makeRuntime({ repo });
+        const { outcome } = await advanceAndSettle(runtime, SEED_ID);
+        expect(outcome).toMatchObject({
+            status: "suspended",
+            pendingAsyncTools: [expect.objectContaining({ toolCallId: "B" })],
+        });
+        const log = await persisted(repo, SEED_ID);
+        expect(log[log.length - 1].type).toBe("turn_suspended");
+    });
+
+    it("re-advancing an already-suspended turn appends no duplicate snapshot", async () => {
+        const { runtime, repo } = makeRuntime({
+            models: [respond(completedResp(assistantCalls(toolCallPart("B", "fetch"))))],
+        });
+        const turnId = await newTurn(runtime);
+        await advanceAndSettle(runtime, turnId);
+        const before = (await persisted(repo, turnId)).length;
+        const { outcome } = await advanceAndSettle(runtime, turnId);
+        expect(outcome?.status).toBe("suspended");
+        expect((await persisted(repo, turnId)).length).toBe(before);
+    });
+
+    it("a completed tool batch proceeds to the next model call", async () => {
+        const repo = new InMemoryTurnRepo();
+        const batch = assistantCalls(toolCallPart("S", "echo"));
+        repo.seed([
+            seedCreated(),
+            seedRequested(0),
+            seedCompleted(0, batch),
+            {
+                type: "tool_invocation_requested",
+                turnId: SEED_ID,
+                ts: TS,
+                toolCallId: "S",
+                toolId: "tool.echo",
+                toolName: "echo",
+                execution: "sync",
+                input: {},
+            },
+            {
+                type: "tool_result",
+                turnId: SEED_ID,
+                ts: TS,
+                toolCallId: "S",
+                toolName: "echo",
+                source: "sync",
+                result: { output: "ok", isError: false },
+            },
+        ]);
+        const { runtime, models } = makeRuntime({
+            repo,
+            models: [respond(completedResp(assistantText("done")))],
+        });
+        const { outcome } = await advanceAndSettle(runtime, SEED_ID);
+        expect(outcome?.status).toBe("completed");
+        expect(
+            sentMessages(models.requests[0]).filter((m) => m.role === "tool"),
+        ).toHaveLength(1);
+    });
+
+    it("a permission resolved allow before invocation safely invokes the tool", async () => {
+        const repo = new InMemoryTurnRepo();
+        const batch = assistantCalls(toolCallPart("P", "echo"));
+        repo.seed([
+            seedCreated(),
+            seedRequested(0),
+            seedCompleted(0, batch),
+            {
+                type: "tool_permission_required",
+                turnId: SEED_ID,
+                ts: TS,
+                toolCallId: "P",
+                toolName: "echo",
+                request: {},
+            },
+            {
+                type: "tool_permission_resolved",
+                turnId: SEED_ID,
+                ts: TS,
+                toolCallId: "P",
+                decision: "allow",
+                source: "human",
+            },
+        ]);
+        const { runtime, repo: r } = makeRuntime({
+            repo,
+            models: [respond(completedResp(assistantText("done")))],
+        });
+        const { outcome } = await advanceAndSettle(runtime, SEED_ID);
+        expect(outcome?.status).toBe("completed");
+        const log = await persisted(r, SEED_ID);
+        expect(log.some((e) => e.type === "tool_invocation_requested" && e.toolCallId === "P")).toBe(true);
+        expect(log.find((e) => e.type === "tool_result" && e.toolCallId === "P")).toMatchObject({
+            source: "sync",
+            result: { isError: false },
+        });
+    });
+
+    it("a terminal turn returns its outcome and performs no writes", async () => {
+        const { runtime, repo } = makeRuntime({
+            models: [respond(completedResp(assistantText("done")))],
+        });
+        const turnId = await newTurn(runtime);
+        await advanceAndSettle(runtime, turnId);
+        const before = (await persisted(repo, turnId)).length;
+
+        const again = await advanceAndSettle(runtime, turnId);
+        expect(again.outcome).toMatchObject({
+            status: "completed",
+            output: assistantText("done"),
+        });
+        expect((await persisted(repo, turnId)).length).toBe(before);
+
+        const withInput = await advanceAndSettle(runtime, turnId, {
+            type: "cancel",
+        });
+        expect(withInput.error).toBeInstanceOf(TurnInputError);
+    });
+});
+
+// ---------------------------------------------------------------------------
+// §26.8 Historical and live reconstruction
+// ---------------------------------------------------------------------------
+
+describe("agent snapshot inheritance", () => {
+    it("inherits system prompt + tools from an identical context predecessor", async () => {
+        const { runtime, repo, models } = makeRuntime({
+            models: [
+                respond(completedResp(assistantText("first"))),
+                respond(completedResp(assistantText("second"))),
+            ],
+        });
+        const first = await newTurn(runtime, { sessionId: "S" });
+        await advanceAndSettle(runtime, first);
+
+        const second = await runtime.createTurn({
+            agent: { agentId: "copilot" },
+            sessionId: "S",
+            context: { previousTurnId: first },
+            input: user("again"),
+            config: { humanAvailable: true },
+        });
+        const created = (await persisted(repo, second))[0];
+        expect(created.type === "turn_created" ? created.agent.resolved : null).toEqual({
+            agentId: "copilot",
+            model: defaultAgent.model,
+            inheritedFrom: first,
+        });
+
+        // The inherited turn still sends the full materialized snapshot.
+        const { outcome } = await advanceAndSettle(runtime, second);
+        expect(outcome?.status).toBe("completed");
+        expect(models.requests[1].systemPrompt).toBe("SYS");
+        expect(models.requests[1].tools).toEqual(defaultAgent.tools);
+    });
+
+    it("a model switch still inherits the prompt and tools (model stays concrete)", async () => {
+        const repo = new InMemoryTurnRepo();
+        const a = makeRuntime({
+            repo,
+            models: [respond(completedResp(assistantText("first")))],
+        });
+        const first = await newTurn(a.runtime, { sessionId: "S" });
+        await advanceAndSettle(a.runtime, first);
+
+        const switched = {
+            ...defaultAgent,
+            model: { provider: "anthropic", model: "claude-x" },
+        };
+        const b = makeRuntime({
+            repo,
+            agent: switched,
+            idStart: 200,
+            models: [respond(completedResp(assistantText("second")))],
+        });
+        const second = await b.runtime.createTurn({
+            agent: { agentId: "copilot" },
+            sessionId: "S",
+            context: { previousTurnId: first },
+            input: user("again"),
+            config: { humanAvailable: true },
+        });
+        const created = (await persisted(repo, second))[0];
+        expect(created.type === "turn_created" ? created.agent.resolved : null).toEqual({
+            agentId: "copilot",
+            model: { provider: "anthropic", model: "claude-x" },
+            inheritedFrom: first,
+        });
+        const { outcome } = await advanceAndSettle(b.runtime, second);
+        expect(outcome?.status).toBe("completed");
+        // The switched model was resolved; prompt/tools came through the chain.
+        expect(b.models.resolved[0]).toEqual({ provider: "anthropic", model: "claude-x" });
+        expect(b.models.requests[0].systemPrompt).toBe("SYS");
+        expect(b.models.requests[0].tools).toEqual(defaultAgent.tools);
+    });
+
+    it("a tools difference forces a full snapshot", async () => {
+        const repo = new InMemoryTurnRepo();
+        const a = makeRuntime({
+            repo,
+            models: [respond(completedResp(assistantText("first")))],
+        });
+        const first = await newTurn(a.runtime, { sessionId: "S" });
+        await advanceAndSettle(a.runtime, first);
+
+        const fewerTools = { ...defaultAgent, tools: [echoDescriptor] };
+        const b = makeRuntime({ repo, agent: fewerTools, idStart: 300 });
+        const second = await b.runtime.createTurn({
+            agent: { agentId: "copilot" },
+            sessionId: "S",
+            context: { previousTurnId: first },
+            input: user("again"),
+            config: { humanAvailable: true },
+        });
+        const created = (await persisted(repo, second))[0];
+        expect(
+            created.type === "turn_created" && "tools" in created.agent.resolved
+                ? created.agent.resolved.tools
+                : null,
+        ).toEqual([echoDescriptor]);
+    });
+
+    it("inheritance chains across turns and materializes through multiple hops", async () => {
+        const { runtime, repo, models } = makeRuntime({
+            models: [
+                respond(completedResp(assistantText("one"))),
+                respond(completedResp(assistantText("two"))),
+                respond(completedResp(assistantText("three"))),
+            ],
+        });
+        const t1 = await newTurn(runtime, { sessionId: "S" });
+        await advanceAndSettle(runtime, t1);
+        const t2 = await runtime.createTurn({
+            agent: { agentId: "copilot" },
+            sessionId: "S",
+            context: { previousTurnId: t1 },
+            input: user("two"),
+            config: { humanAvailable: true },
+        });
+        await advanceAndSettle(runtime, t2);
+        const t3 = await runtime.createTurn({
+            agent: { agentId: "copilot" },
+            sessionId: "S",
+            context: { previousTurnId: t2 },
+            input: user("three"),
+            config: { humanAvailable: true },
+        });
+        const created3 = (await persisted(repo, t3))[0];
+        // t3 inherits from t2, which itself inherits from t1 (the concrete base).
+        expect(
+            created3.type === "turn_created" && "inheritedFrom" in created3.agent.resolved
+                ? created3.agent.resolved.inheritedFrom
+                : null,
+        ).toBe(t2);
+        const { outcome } = await advanceAndSettle(runtime, t3);
+        expect(outcome?.status).toBe("completed");
+        expect(models.requests[2].systemPrompt).toBe("SYS");
+        expect(models.requests[2].tools).toEqual(defaultAgent.tools);
+    });
+
+    it("standalone (inline-context) turns always persist a full snapshot", async () => {
+        const { runtime, repo } = makeRuntime();
+        const turnId = await newTurn(runtime);
+        const created = (await persisted(repo, turnId))[0];
+        expect(
+            created.type === "turn_created" && "systemPrompt" in created.agent.resolved,
+        ).toBe(true);
+    });
+
+    it("falls back to a full snapshot when the predecessor is unreadable", async () => {
+        const { runtime, repo } = makeRuntime();
+        const turnId = await runtime.createTurn({
+            agent: { agentId: "copilot" },
+            sessionId: "S",
+            context: { previousTurnId: "2026-07-02T09-00-00Z-0000404-000" },
+            input: user("orphan ref"),
+            config: { humanAvailable: true },
+        });
+        const created = (await persisted(repo, turnId))[0];
+        expect(
+            created.type === "turn_created" && "systemPrompt" in created.agent.resolved,
+        ).toBe(true);
+    });
+
+    it("persists a full snapshot when the resolved agent differs", async () => {
+        const repo = new InMemoryTurnRepo();
+        const a = makeRuntime({
+            repo,
+            models: [respond(completedResp(assistantText("first")))],
+        });
+        const first = await newTurn(a.runtime, { sessionId: "S" });
+        await advanceAndSettle(a.runtime, first);
+
+        const changedAgent = { ...defaultAgent, systemPrompt: "SYS v2" };
+        const b = makeRuntime({ repo, agent: changedAgent, idStart: 100 });
+        const second = await b.runtime.createTurn({
+            agent: { agentId: "copilot" },
+            sessionId: "S",
+            context: { previousTurnId: first },
+            input: user("again"),
+            config: { humanAvailable: true },
+        });
+        const created = (await persisted(repo, second))[0];
+        expect(
+            created.type === "turn_created" && "systemPrompt" in created.agent.resolved
+                ? created.agent.resolved.systemPrompt
+                : null,
+        ).toBe("SYS v2");
+    });
+});
+
+describe("historical and live reconstruction (26.8)", () => {
+    it("getTurn is read-only and matches live durable events", async () => {
+        const { runtime, repo } = makeRuntime({
+            models: [
+                respond(
+                    { type: "text_delta", delta: "d" },
+                    completedResp(assistantText("done")),
+                ),
+            ],
+        });
+        const turnId = await newTurn(runtime);
+        const { events } = await advanceAndSettle(runtime, turnId);
+
+        const before = (await persisted(repo, turnId)).length;
+        const turn = await runtime.getTurn(turnId);
+        expect((await persisted(repo, turnId)).length).toBe(before);
+
+        const durable = events.filter(
+            (e) => e.type !== "text_delta" && e.type !== "reasoning_delta",
+        );
+        expect(turn.events.slice(1)).toEqual(durable);
+        // Ephemeral deltas are absent after reload.
+        expect(turn.events.some((e) => (e.type as string) === "text_delta")).toBe(false);
+    });
+});
+
+// ---------------------------------------------------------------------------
+// §26.9 Model-call limit
+// ---------------------------------------------------------------------------
+
+describe("model-call limit (26.9)", () => {
+    it("a tool-free response on the final allowed call completes normally", async () => {
+        const { runtime } = makeRuntime({
+            models: [
+                respond(completedResp(assistantCalls(toolCallPart("S", "echo")))),
+                respond(completedResp(assistantText("done"))),
+            ],
+        });
+        const turnId = await newTurn(runtime, {
+            config: { humanAvailable: true, maxModelCalls: 2 },
+        });
+        const { outcome } = await advanceAndSettle(runtime, turnId);
+        expect(outcome?.status).toBe("completed");
+    });
+
+    it("tool calls on the final call are fully processed, then the turn fails with the limit code", async () => {
+        const { runtime, repo, models } = makeRuntime({
+            models: [respond(completedResp(assistantCalls(toolCallPart("S", "echo"))))],
+        });
+        const turnId = await newTurn(runtime, {
+            config: { humanAvailable: true, maxModelCalls: 1 },
+        });
+        const { outcome } = await advanceAndSettle(runtime, turnId);
+        expect(outcome).toMatchObject({
+            status: "failed",
+            code: MODEL_CALL_LIMIT_ERROR_CODE,
+        });
+        const log = await persisted(repo, turnId);
+        // The batch was fully processed before failing…
+        expect(log.find((e) => e.type === "tool_result" && e.toolCallId === "S")).toMatchObject({
+            result: { isError: false },
+        });
+        // …and no further model call was made.
+        expect(models.requests).toHaveLength(1);
+        expect(log[log.length - 1]).toMatchObject({
+            type: "turn_failed",
+            code: MODEL_CALL_LIMIT_ERROR_CODE,
+        });
+    });
+});
+
+// ---------------------------------------------------------------------------
+// Tool progress
+// ---------------------------------------------------------------------------
+
+describe("tool progress", () => {
+    it("sync progress persists before the callback resolves; async progress arrives as input", async () => {
+        const tools: RuntimeTool[] = [
+            syncTool(echoDescriptor, async (_input, ctx) => {
+                await ctx.reportProgress({ pct: 50 });
+                return { output: "done", isError: false };
+            }),
+            { descriptor: fetchDescriptor as { execution: "async" } & typeof fetchDescriptor },
+            { descriptor: askHumanDescriptor as { execution: "async" } & typeof askHumanDescriptor },
+        ];
+        const { runtime, repo } = makeRuntime({
+            models: [
+                respond(
+                    completedResp(
+                        assistantCalls(toolCallPart("S", "echo"), toolCallPart("B", "fetch")),
+                    ),
+                ),
+                respond(completedResp(assistantText("done"))),
+            ],
+            tools,
+        });
+        const turnId = await newTurn(runtime);
+        await advanceAndSettle(runtime, turnId);
+
+        await advanceAndSettle(runtime, turnId, {
+            type: "async_tool_progress",
+            toolCallId: "B",
+            progress: { pct: 10 },
+        });
+        const { outcome } = await advanceAndSettle(runtime, turnId, {
+            type: "async_tool_result",
+            toolCallId: "B",
+            result: { output: "fetched", isError: false },
+        });
+        expect(outcome?.status).toBe("completed");
+
+        const log = await persisted(repo, turnId);
+        const progress = log.filter((e) => e.type === "tool_progress");
+        expect(progress).toEqual([
+            expect.objectContaining({ toolCallId: "S", source: "sync" }),
+            expect.objectContaining({ toolCallId: "B", source: "async" }),
+        ]);
+    });
+});
diff --git a/apps/x/packages/core/src/turns/runtime.ts b/apps/x/packages/core/src/turns/runtime.ts
new file mode 100644
index 00000000..da2362a4
--- /dev/null
+++ b/apps/x/packages/core/src/turns/runtime.ts
@@ -0,0 +1,1216 @@
+import type { z } from "zod";
+import {
+    DEFAULT_MAX_MODEL_CALLS,
+    MODEL_CALL_LIMIT_ERROR_CODE,
+    type ConversationMessage,
+    type JsonValue,
+    type ModelCallFailed,
+    type ModelRequest,
+    type ResolvedAgent,
+    type ResolvedAgentSnapshot,
+    assistantRef,
+    toolResultRef,
+    type ToolCallState,
+    type ToolDescriptor,
+    type ToolInvocationRequested,
+    type ToolPermissionRequired,
+    type ToolPermissionResolved,
+    type ToolResult,
+    ToolResultData,
+    TurnCreated,
+    type TurnEvent,
+    type TurnState,
+    type TurnStreamEvent,
+    type TurnSuspended,
+    outstandingAsyncTools,
+    outstandingPermissions,
+    reduceTurn,
+} from "@x/shared/dist/turns.js";
+import type { IMonotonicallyIncreasingIdGenerator } from "../application/lib/id-gen.js";
+import type { IAgentResolver } from "./agent-resolver.js";
+import {
+    type CreateTurnInput,
+    type ITurnRuntime,
+    type Turn,
+    TurnDependencyError,
+    type TurnExecution,
+    type TurnExternalInput,
+    TurnInputError,
+    type TurnOutcome,
+} from "./api.js";
+import type { ITurnLifecycleBus } from "./bus.js";
+import type { IClock } from "./clock.js";
+import { composeModelRequest } from "./compose-model-request.js";
+import type { IUsageReporter } from "./usage-reporter.js";
+import type { IContextResolver } from "./context-resolver.js";
+import type {
+    IModelRegistry,
+    LlmStreamEvent,
+    ResolvedModel,
+} from "./model-registry.js";
+import type { IPermissionChecker, IPermissionClassifier } from "./permission.js";
+import type { ITurnRepo } from "./repo.js";
+import { HotStream } from "./stream.js";
+import type { IToolRegistry, RuntimeTool, SyncRuntimeTool } from "./tool-registry.js";
+
+type TEvent = z.infer<typeof TurnEvent>;
+
+const INTERRUPTED_TOOL_MESSAGE =
+    "Tool execution was interrupted; its outcome is unknown and it was not retried.";
+
+export interface TurnRuntimeDependencies {
+    turnRepo: ITurnRepo;
+    idGenerator: IMonotonicallyIncreasingIdGenerator;
+    clock: IClock;
+    agentResolver: IAgentResolver;
+    modelRegistry: IModelRegistry;
+    toolRegistry: IToolRegistry;
+    contextResolver: IContextResolver;
+    permissionChecker: IPermissionChecker;
+    permissionClassifier: IPermissionClassifier;
+    lifecycleBus: ITurnLifecycleBus;
+    usageReporter: IUsageReporter;
+}
+
+// Immutable dependency container: holds no mutable per-turn state. All active
+// turn state is reconstructed from the repository inside each invocation.
+export class TurnRuntime implements ITurnRuntime {
+    private readonly turnRepo: ITurnRepo;
+    private readonly idGenerator: IMonotonicallyIncreasingIdGenerator;
+    private readonly clock: IClock;
+    private readonly agentResolver: IAgentResolver;
+    private readonly modelRegistry: IModelRegistry;
+    private readonly toolRegistry: IToolRegistry;
+    private readonly contextResolver: IContextResolver;
+    private readonly permissionChecker: IPermissionChecker;
+    private readonly permissionClassifier: IPermissionClassifier;
+    private readonly lifecycleBus: ITurnLifecycleBus;
+    private readonly usageReporter: IUsageReporter;
+
+    constructor({
+        turnRepo,
+        idGenerator,
+        clock,
+        agentResolver,
+        modelRegistry,
+        toolRegistry,
+        contextResolver,
+        permissionChecker,
+        permissionClassifier,
+        lifecycleBus,
+        usageReporter,
+    }: TurnRuntimeDependencies) {
+        this.turnRepo = turnRepo;
+        this.idGenerator = idGenerator;
+        this.clock = clock;
+        this.agentResolver = agentResolver;
+        this.modelRegistry = modelRegistry;
+        this.toolRegistry = toolRegistry;
+        this.contextResolver = contextResolver;
+        this.permissionChecker = permissionChecker;
+        this.permissionClassifier = permissionClassifier;
+        this.lifecycleBus = lifecycleBus;
+        this.usageReporter = usageReporter;
+    }
+
+    async createTurn(input: CreateTurnInput): Promise<string> {
+        const resolved = await this.agentResolver.resolve(input.agent);
+        const turnId = await this.idGenerator.next();
+        // Inherit the heavy snapshot fields (system prompt + tools) when they
+        // are byte-identical to the context predecessor's materialized
+        // snapshot — the same reference mechanism as context and requests.
+        // The model stays concrete for the session index and so a model
+        // switch never blocks inheritance.
+        let snapshot: z.infer<typeof ResolvedAgentSnapshot> = resolved;
+        if (!Array.isArray(input.context)) {
+            try {
+                const previousEvents = await this.turnRepo.read(
+                    input.context.previousTurnId,
+                );
+                const previous = await this.contextResolver.resolveAgent(
+                    reduceTurn(previousEvents).definition.agent.resolved,
+                );
+                if (
+                    previous.systemPrompt === resolved.systemPrompt &&
+                    JSON.stringify(previous.tools) === JSON.stringify(resolved.tools)
+                ) {
+                    snapshot = {
+                        agentId: resolved.agentId,
+                        model: resolved.model,
+                        inheritedFrom: input.context.previousTurnId,
+                    };
+                }
+            } catch {
+                // Unreadable predecessor: persist the full snapshot; context
+                // resolution surfaces the real problem at advance time.
+            }
+        }
+        const event = TurnCreated.parse({
+            type: "turn_created",
+            schemaVersion: 1,
+            turnId,
+            ts: this.clock.now(),
+            sessionId: input.sessionId ?? null,
+            agent: { requested: input.agent, resolved: snapshot },
+            context: input.context,
+            input: input.input,
+            config: {
+                autoPermission: input.config.autoPermission ?? false,
+                humanAvailable: input.config.humanAvailable,
+                maxModelCalls: input.config.maxModelCalls ?? DEFAULT_MAX_MODEL_CALLS,
+            },
+        });
+        await this.turnRepo.create(event);
+        return turnId;
+    }
+
+    async getTurn(turnId: string): Promise<Turn> {
+        const events = await this.turnRepo.read(turnId);
+        return { turnId, events };
+    }
+
+    advanceTurn(
+        turnId: string,
+        input?: TurnExternalInput,
+        options?: { signal?: AbortSignal },
+    ): TurnExecution {
+        const stream = new HotStream<TurnStreamEvent, TurnOutcome>();
+        void this.turnRepo
+            .withLock(turnId, () =>
+                this.advanceLocked(turnId, input, options?.signal, stream),
+            )
+            .then(
+                (outcome) => stream.end(outcome),
+                (error: unknown) => stream.fail(error),
+            );
+        return { events: stream.events, outcome: stream.outcome };
+    }
+
+    private async advanceLocked(
+        turnId: string,
+        input: TurnExternalInput | undefined,
+        externalSignal: AbortSignal | undefined,
+        stream: HotStream<TurnStreamEvent, TurnOutcome>,
+    ): Promise<TurnOutcome> {
+        this.lifecycleBus.publish({ type: "turn-processing-start", turnId });
+        try {
+            return await this.advance(turnId, input, externalSignal, stream);
+        } finally {
+            this.lifecycleBus.publish({ type: "turn-processing-end", turnId });
+        }
+    }
+
+    // §18 steps 4–7: read, reduce, short-circuit terminal turns, materialize
+    // context, and validate live dependencies — all before any mutation.
+    // Failures here are infrastructure errors: the execution rejects and the
+    // turn is left unchanged.
+    private async advance(
+        turnId: string,
+        input: TurnExternalInput | undefined,
+        externalSignal: AbortSignal | undefined,
+        stream: HotStream<TurnStreamEvent, TurnOutcome>,
+    ): Promise<TurnOutcome> {
+        const events = await this.turnRepo.read(turnId);
+        const state = reduceTurn(events);
+
+        if (state.terminal) {
+            if (input) {
+                throw new TurnInputError(`turn ${turnId} is terminal; input rejected`);
+            }
+            return outcomeFromTerminal(state);
+        }
+
+        const definition = state.definition;
+        const resolvedContext = await this.contextResolver.resolve(
+            definition.context,
+        );
+        const resolvedAgent = await this.contextResolver.resolveAgent(
+            definition.agent.resolved,
+        );
+        const model = await this.modelRegistry.resolve(resolvedAgent.model);
+        const toolsByName = new Map<string, RuntimeTool>();
+        for (const descriptor of resolvedAgent.tools) {
+            const tool = await this.toolRegistry.resolve(descriptor);
+            if (
+                tool.descriptor.toolId !== descriptor.toolId ||
+                tool.descriptor.execution !== descriptor.execution
+            ) {
+                throw new TurnDependencyError(
+                    `resolved tool ${descriptor.toolId} does not match its persisted descriptor`,
+                );
+            }
+            toolsByName.set(descriptor.name, tool);
+        }
+
+        const controller = new AbortController();
+        const forwardAbort = () => controller.abort();
+        if (externalSignal) {
+            if (externalSignal.aborted) {
+                controller.abort();
+            } else {
+                externalSignal.addEventListener("abort", forwardAbort, {
+                    once: true,
+                });
+            }
+        }
+
+        const run = new TurnAdvance({
+            turnId,
+            events,
+            state,
+            stream,
+            resolvedContext,
+            resolvedAgent,
+            model,
+            usageReporter: this.usageReporter,
+            toolsByName,
+            signal: controller.signal,
+            turnRepo: this.turnRepo,
+            clock: this.clock,
+            permissionChecker: this.permissionChecker,
+            permissionClassifier: this.permissionClassifier,
+        });
+        try {
+            return await run.run(input);
+        } finally {
+            if (externalSignal) {
+                externalSignal.removeEventListener("abort", forwardAbort);
+            }
+        }
+    }
+}
+
+// One advanceTurn invocation. Owns the per-invocation context and implements
+// the §18 main loop as one method per phase. All state it acts on is derived
+// from the durable log via the shared reducer after every append.
+class TurnAdvance {
+    private readonly turnId: string;
+    private readonly events: TEvent[];
+    private state: TurnState;
+    private readonly stream: HotStream<TurnStreamEvent, TurnOutcome>;
+    private readonly resolvedContext: Array<z.infer<typeof ConversationMessage>>;
+    private readonly resolvedAgent: z.infer<typeof ResolvedAgent>;
+    private readonly model: ResolvedModel;
+    private readonly usageReporter: IUsageReporter;
+    private readonly toolsByName: Map<string, RuntimeTool>;
+    private readonly signal: AbortSignal;
+    private readonly turnRepo: ITurnRepo;
+    private readonly clock: IClock;
+    private readonly permissionChecker: IPermissionChecker;
+    private readonly permissionClassifier: IPermissionClassifier;
+
+    // Checker "allowed" outcomes are deliberately not durable: after a crash
+    // the checker is simply re-consulted.
+    private readonly checkerAllowed = new Set<string>();
+    private appended = false;
+    private cancelReason: string | undefined;
+
+    constructor(init: {
+        turnId: string;
+        events: TEvent[];
+        state: TurnState;
+        stream: HotStream<TurnStreamEvent, TurnOutcome>;
+        resolvedContext: Array<z.infer<typeof ConversationMessage>>;
+        resolvedAgent: z.infer<typeof ResolvedAgent>;
+        model: ResolvedModel;
+        usageReporter: IUsageReporter;
+        toolsByName: Map<string, RuntimeTool>;
+        signal: AbortSignal;
+        turnRepo: ITurnRepo;
+        clock: IClock;
+        permissionChecker: IPermissionChecker;
+        permissionClassifier: IPermissionClassifier;
+    }) {
+        this.turnId = init.turnId;
+        this.events = init.events;
+        this.state = init.state;
+        this.stream = init.stream;
+        this.resolvedContext = init.resolvedContext;
+        this.resolvedAgent = init.resolvedAgent;
+        this.model = init.model;
+        this.usageReporter = init.usageReporter;
+        this.toolsByName = init.toolsByName;
+        this.signal = init.signal;
+        this.turnRepo = init.turnRepo;
+        this.clock = init.clock;
+        this.permissionChecker = init.permissionChecker;
+        this.permissionClassifier = init.permissionClassifier;
+    }
+
+    private get definition(): TurnState["definition"] {
+        return this.state.definition;
+    }
+
+    private now(): string {
+        return this.clock.now();
+    }
+
+    // Durable barrier: persist, re-reduce (the reducer doubles as a runtime
+    // assertion that the appended history is legal), then stream.
+    private async append(...batch: TEvent[]): Promise<void> {
+        await this.turnRepo.append(this.turnId, batch);
+        this.events.push(...batch);
+        this.state = reduceTurn(this.events);
+        this.appended = true;
+        for (const event of batch) {
+            this.stream.push(event);
+        }
+    }
+
+    // §18 step 8: repeatedly advance deterministic work. Each phase either
+    // appends durable facts and lets the loop continue, or produces the
+    // invocation's outcome.
+    async run(input: TurnExternalInput | undefined): Promise<TurnOutcome> {
+        if (input) {
+            const cancelled = await this.applyInput(input);
+            if (cancelled) {
+                return cancelled;
+            }
+        }
+        for (;;) {
+            if (this.signal.aborted) {
+                return this.cancel();
+            }
+            if (await this.closeInterruptedModelCall()) {
+                continue;
+            }
+            if (await this.closeInterruptedSyncTools()) {
+                continue;
+            }
+            await this.evaluatePermissions();
+            if (this.signal.aborted) {
+                return this.cancel();
+            }
+            await this.classifyBatch();
+            if (this.signal.aborted) {
+                return this.cancel();
+            }
+            await this.denyUnresolvedWithoutHuman();
+            await this.executeAllowedTools();
+            if (this.signal.aborted) {
+                return this.cancel();
+            }
+            const suspended = await this.suspendIfPending();
+            if (suspended) {
+                return suspended;
+            }
+            const completed = await this.completeIfFinished();
+            if (completed) {
+                return completed;
+            }
+            const exhausted = await this.failIfExhausted();
+            if (exhausted) {
+                return exhausted;
+            }
+            const settled = await this.runModelStep();
+            if (settled) {
+                return settled;
+            }
+        }
+    }
+
+    // §11.2: exactly one input, validated against durable pending state.
+    // Returns an outcome only for cancel inputs.
+    private async applyInput(
+        input: TurnExternalInput,
+    ): Promise<TurnOutcome | undefined> {
+        switch (input.type) {
+            case "cancel":
+                this.cancelReason = input.reason;
+                return this.cancel();
+            case "permission_decision": {
+                const tc = this.state.toolCalls.find(
+                    (t) => t.toolCallId === input.toolCallId,
+                );
+                if (!tc?.permission || tc.permission.resolved || tc.result) {
+                    throw new TurnInputError(
+                        `no pending permission for tool call ${input.toolCallId}`,
+                    );
+                }
+                await this.append({
+                    type: "tool_permission_resolved",
+                    turnId: this.turnId,
+                    ts: this.now(),
+                    toolCallId: input.toolCallId,
+                    decision: input.decision,
+                    source: "human",
+                    ...(input.metadata === undefined
+                        ? {}
+                        : { metadata: input.metadata }),
+                });
+                if (input.decision === "deny") {
+                    await this.append(
+                        runtimeResultEvent(this.turnId, this.now(), tc, {
+                            output: "Permission denied by user.",
+                            isError: true,
+                        }),
+                    );
+                }
+                return undefined;
+            }
+            case "async_tool_progress": {
+                const tc = this.requirePendingAsync(input.toolCallId);
+                await this.append({
+                    type: "tool_progress",
+                    turnId: this.turnId,
+                    ts: this.now(),
+                    toolCallId: tc.toolCallId,
+                    source: "async",
+                    progress: input.progress,
+                });
+                return undefined;
+            }
+            case "async_tool_result": {
+                const tc = this.requirePendingAsync(input.toolCallId);
+                await this.append({
+                    type: "tool_result",
+                    turnId: this.turnId,
+                    ts: this.now(),
+                    toolCallId: tc.toolCallId,
+                    toolName: tc.toolName,
+                    source: "async",
+                    result: input.result,
+                });
+                return undefined;
+            }
+        }
+    }
+
+    private requirePendingAsync(toolCallId: string): ToolCallState {
+        const tc = this.state.toolCalls.find((t) => t.toolCallId === toolCallId);
+        if (!tc?.invocation || tc.execution !== "async" || tc.result) {
+            throw new TurnInputError(`no pending async tool call ${toolCallId}`);
+        }
+        return tc;
+    }
+
+    // §23: a model call interrupted by a crash is closed as failed and later
+    // re-issued by the normal model step (counting against the budget).
+    private async closeInterruptedModelCall(): Promise<boolean> {
+        const open = this.state.modelCalls.find(
+            (c) => c.response === undefined && c.error === undefined,
+        );
+        if (!open) {
+            return false;
+        }
+        await this.append(
+            modelCallFailedEvent(
+                this.turnId,
+                this.now(),
+                open.index,
+                "model call was interrupted before a response was recorded",
+            ),
+        );
+        return true;
+    }
+
+    // §23: a sync invocation interrupted by a crash gets an indeterminate
+    // error result; the turn continues (tool problems are conversational).
+    private async closeInterruptedSyncTools(): Promise<boolean> {
+        const interrupted = this.state.toolCalls.filter(
+            (tc) => tc.invocation && tc.execution === "sync" && !tc.result,
+        );
+        if (interrupted.length === 0) {
+            return false;
+        }
+        for (const tc of interrupted) {
+            await this.append(
+                runtimeResultEvent(this.turnId, this.now(), tc, {
+                    output: INTERRUPTED_TOOL_MESSAGE,
+                    isError: true,
+                }),
+            );
+        }
+        return true;
+    }
+
+    // §9/§10: for freshly extracted tool calls — unknown tools and
+    // human-dependent tools settle immediately; everything else is checked.
+    // A checker throw fails closed (recorded, never auto-executed).
+    private async evaluatePermissions(): Promise<void> {
+        const fresh = this.state.toolCalls.filter(
+            (tc) =>
+                !tc.result &&
+                !tc.invocation &&
+                !tc.permission &&
+                !this.checkerAllowed.has(tc.toolCallId),
+        );
+        for (const tc of fresh) {
+            if (this.signal.aborted) {
+                return;
+            }
+            const tool = this.toolsByName.get(tc.toolName);
+            if (!tool) {
+                await this.append(
+                    runtimeResultEvent(this.turnId, this.now(), tc, {
+                        output: `Unknown tool: ${tc.toolName}`,
+                        isError: true,
+                    }),
+                );
+                continue;
+            }
+            if (
+                tool.descriptor.requiresHuman &&
+                !this.definition.config.humanAvailable
+            ) {
+                await this.append(
+                    invocationEvent(this.turnId, this.now(), tc, tool.descriptor),
+                );
+                await this.append(
+                    runtimeResultEvent(this.turnId, this.now(), tc, {
+                        output: "Human input is unavailable for this turn.",
+                        isError: true,
+                    }),
+                );
+                continue;
+            }
+            try {
+                const check = await this.permissionChecker.check({
+                    turnId: this.turnId,
+                    toolCallId: tc.toolCallId,
+                    toolId: tool.descriptor.toolId,
+                    toolName: tc.toolName,
+                    input: tc.input,
+                });
+                if (!check.required) {
+                    this.checkerAllowed.add(tc.toolCallId);
+                } else {
+                    await this.append(
+                        permissionRequiredEvent(
+                            this.turnId,
+                            this.now(),
+                            tc,
+                            check.request,
+                        ),
+                    );
+                }
+            } catch (error) {
+                await this.append(
+                    permissionRequiredEvent(
+                        this.turnId,
+                        this.now(),
+                        tc,
+                        {},
+                        errorMessage(error),
+                    ),
+                );
+            }
+        }
+    }
+
+    // Conversation context for the classifier: resolved context, the turn
+    // input, and completed assistant responses (the current batch's tool
+    // results are not yet terminal, so tool messages are omitted).
+    private conversationSoFar(): Array<z.infer<typeof ConversationMessage>> {
+        const messages: Array<z.infer<typeof ConversationMessage>> = [
+            this.state.definition.input,
+        ];
+        for (const call of this.state.modelCalls) {
+            if (call.response !== undefined) {
+                messages.push(call.response);
+            }
+        }
+        return [...this.resolvedContext, ...messages];
+    }
+
+    // §9.3: one classifier batch per model response in auto mode.
+    // Checker-error calls and previously failed classifications skip the
+    // classifier and go straight to the human/deny fallback.
+    private async classifyBatch(): Promise<void> {
+        if (!this.definition.config.autoPermission) {
+            return;
+        }
+        const candidates = this.state.toolCalls.filter(
+            (tc) =>
+                tc.permission &&
+                !tc.permission.resolved &&
+                !tc.permission.classification &&
+                !tc.permission.classificationFailed &&
+                tc.permission.required.checkerError === undefined &&
+                !tc.result,
+        );
+        if (candidates.length === 0) {
+            return;
+        }
+        let decisions;
+        try {
+            decisions = await this.permissionClassifier.classify(
+                {
+                    turnId: this.turnId,
+                    messages: this.conversationSoFar(),
+                    requests: candidates.map((tc) => ({
+                        toolCallId: tc.toolCallId,
+                        toolName: tc.toolName,
+                        input: tc.input,
+                        request: (tc.permission as NonNullable<ToolCallState["permission"]>)
+                            .required.request,
+                    })),
+                },
+                this.signal,
+            );
+        } catch (error) {
+            if (this.signal.aborted) {
+                return;
+            }
+            await this.append({
+                type: "tool_permission_classification_failed",
+                turnId: this.turnId,
+                ts: this.now(),
+                toolCallIds: candidates.map((c) => c.toolCallId),
+                error: errorMessage(error),
+            });
+            return;
+        }
+        for (const tc of candidates) {
+            const decision = decisions.find((d) => d.toolCallId === tc.toolCallId);
+            if (!decision) {
+                await this.append({
+                    type: "tool_permission_classification_failed",
+                    turnId: this.turnId,
+                    ts: this.now(),
+                    toolCallIds: [tc.toolCallId],
+                    error: "classifier returned no decision",
+                });
+                continue;
+            }
+            await this.append({
+                type: "tool_permission_classified",
+                turnId: this.turnId,
+                ts: this.now(),
+                toolCallId: tc.toolCallId,
+                decision: decision.decision,
+                reason: decision.reason,
+            });
+            if (decision.decision === "allow") {
+                await this.append(
+                    resolvedEvent(
+                        this.turnId,
+                        this.now(),
+                        tc.toolCallId,
+                        "allow",
+                        "classifier",
+                        decision.reason,
+                    ),
+                );
+            } else if (decision.decision === "deny") {
+                await this.append(
+                    resolvedEvent(
+                        this.turnId,
+                        this.now(),
+                        tc.toolCallId,
+                        "deny",
+                        "classifier",
+                        decision.reason,
+                    ),
+                );
+                await this.append(
+                    runtimeResultEvent(this.turnId, this.now(), tc, {
+                        output: `Permission denied: ${decision.reason}`,
+                        isError: true,
+                    }),
+                );
+            }
+            // "defer" falls through to the human/deny fallback.
+        }
+    }
+
+    // §9.3 matrix, humanAvailable = false: deny whatever remains unresolved.
+    private async denyUnresolvedWithoutHuman(): Promise<void> {
+        if (this.definition.config.humanAvailable) {
+            return;
+        }
+        const unresolved = this.state.toolCalls.filter(
+            (tc) => tc.permission && !tc.permission.resolved && !tc.result,
+        );
+        for (const tc of unresolved) {
+            await this.append(
+                resolvedEvent(
+                    this.turnId,
+                    this.now(),
+                    tc.toolCallId,
+                    "deny",
+                    "human_unavailable",
+                ),
+            );
+            await this.append(
+                runtimeResultEvent(this.turnId, this.now(), tc, {
+                    output: "Permission denied: no human is available for this turn.",
+                    isError: true,
+                }),
+            );
+        }
+    }
+
+    // §10.5: execute allowed sync tools sequentially and expose allowed async
+    // tools, in source order. Tool failures are conversational, not terminal.
+    private async executeAllowedTools(): Promise<void> {
+        const executable = this.state.toolCalls.filter(
+            (tc) =>
+                !tc.result &&
+                !tc.invocation &&
+                (this.checkerAllowed.has(tc.toolCallId) ||
+                    tc.permission?.resolved?.decision === "allow"),
+        );
+        for (const tc of executable) {
+            if (this.signal.aborted) {
+                return;
+            }
+            const tool = this.toolsByName.get(tc.toolName);
+            if (!tool) {
+                await this.append(
+                    runtimeResultEvent(this.turnId, this.now(), tc, {
+                        output: `Unknown tool: ${tc.toolName}`,
+                        isError: true,
+                    }),
+                );
+                continue;
+            }
+            await this.append(
+                invocationEvent(this.turnId, this.now(), tc, tool.descriptor),
+            );
+            if (tool.descriptor.execution === "async") {
+                continue; // exposed; the result arrives through advanceTurn
+            }
+            const syncTool = tool as SyncRuntimeTool;
+            try {
+                const result = await syncTool.execute(tc.input, {
+                    turnId: this.turnId,
+                    toolCallId: tc.toolCallId,
+                    signal: this.signal,
+                    reportProgress: async (progress) => {
+                        await this.append({
+                            type: "tool_progress",
+                            turnId: this.turnId,
+                            ts: this.now(),
+                            toolCallId: tc.toolCallId,
+                            source: "sync",
+                            progress,
+                        });
+                    },
+                });
+                await this.append({
+                    type: "tool_result",
+                    turnId: this.turnId,
+                    ts: this.now(),
+                    toolCallId: tc.toolCallId,
+                    toolName: tc.toolName,
+                    source: "sync",
+                    result: ToolResultData.parse(result),
+                });
+            } catch (error) {
+                if (this.signal.aborted) {
+                    await this.append(
+                        runtimeResultEvent(this.turnId, this.now(), tc, {
+                            output: "Tool execution was cancelled.",
+                            isError: true,
+                        }),
+                    );
+                    return;
+                }
+                await this.append({
+                    type: "tool_result",
+                    turnId: this.turnId,
+                    ts: this.now(),
+                    toolCallId: tc.toolCallId,
+                    toolName: tc.toolName,
+                    source: "sync",
+                    result: { output: errorMessage(error), isError: true },
+                });
+            }
+        }
+    }
+
+    // §11.1: settle suspended while external work remains. A no-input
+    // re-advance of an already-snapshotted suspension appends nothing.
+    private async suspendIfPending(): Promise<TurnOutcome | undefined> {
+        const pendingPerms = outstandingPermissions(this.state);
+        const pendingAsync = outstandingAsyncTools(this.state);
+        if (pendingPerms.length + pendingAsync.length === 0) {
+            return undefined;
+        }
+        const last = this.events[this.events.length - 1];
+        if (this.appended || last.type !== "turn_suspended") {
+            await this.append({
+                type: "turn_suspended",
+                turnId: this.turnId,
+                ts: this.now(),
+                pendingPermissions: permissionsSnapshot(pendingPerms),
+                pendingAsyncTools: asyncSnapshot(pendingAsync),
+                usage: this.state.usage,
+            });
+        }
+        return {
+            status: "suspended",
+            pendingPermissions: permissionsSnapshot(pendingPerms),
+            pendingAsyncTools: asyncSnapshot(pendingAsync),
+            usage: this.state.usage,
+        };
+    }
+
+    // §8.5: a completed response without tool calls completes the turn.
+    private async completeIfFinished(): Promise<TurnOutcome | undefined> {
+        const lastCall = this.state.modelCalls[this.state.modelCalls.length - 1];
+        if (
+            lastCall?.response === undefined ||
+            this.state.toolCalls.some((tc) => tc.modelCallIndex === lastCall.index)
+        ) {
+            return undefined;
+        }
+        const output = lastCall.response;
+        const finishReason = lastCall.finishReason ?? "unknown";
+        await this.append({
+            type: "turn_completed",
+            turnId: this.turnId,
+            ts: this.now(),
+            output,
+            finishReason,
+            usage: this.state.usage,
+        });
+        return { status: "completed", output, finishReason, usage: this.state.usage };
+    }
+
+    // §20: limit exhaustion is a distinguishable outcome; the transcript is
+    // structurally complete, so sessions can offer continuation.
+    private async failIfExhausted(): Promise<TurnOutcome | undefined> {
+        if (this.state.modelCalls.length < this.definition.config.maxModelCalls) {
+            return undefined;
+        }
+        const error = `Model call limit of ${this.definition.config.maxModelCalls} reached before the turn completed.`;
+        await this.append({
+            type: "turn_failed",
+            turnId: this.turnId,
+            ts: this.now(),
+            error,
+            code: MODEL_CALL_LIMIT_ERROR_CODE,
+            usage: this.state.usage,
+        });
+        return {
+            status: "failed",
+            error,
+            code: MODEL_CALL_LIMIT_ERROR_CODE,
+            usage: this.state.usage,
+        };
+    }
+
+    // §8.3/§18h–l: one model step. The durable request barrier precedes the
+    // provider call; step events persist before the next provider read;
+    // deltas bypass storage. The request records only REFERENCES to what is
+    // new since the previous call; the payload actually sent is built by the
+    // shared composer over the durable state, so file + composer reproduce
+    // the wire bytes exactly. Returns an outcome only on failure/cancel.
+    private async runModelStep(): Promise<TurnOutcome | undefined> {
+        const index = this.state.modelCalls.length;
+        const context = this.definition.context;
+        const isRef = !Array.isArray(context);
+        let refs: string[];
+        if (index === 0) {
+            refs =
+                !isRef && context.length > 0
+                    ? ["context", "input"]
+                    : ["input"];
+        } else {
+            const previous = this.state.modelCalls[index - 1];
+            refs =
+                previous.response !== undefined
+                    ? [
+                          assistantRef(previous.index),
+                          ...this.state.toolCalls
+                              .filter((tc) => tc.modelCallIndex === previous.index)
+                              .sort((a, b) => a.order - b.order)
+                              .map((tc) => toolResultRef(tc.toolCallId)),
+                      ]
+                    : []; // re-issue after an interrupted call adds nothing new
+        }
+        const request: z.infer<typeof ModelRequest> = {
+            ...(isRef && index === 0 ? { contextRef: context } : {}),
+            messages: refs,
+            parameters: {},
+        };
+        await this.append({
+            type: "model_call_requested",
+            turnId: this.turnId,
+            ts: this.now(),
+            modelCallIndex: index,
+            request,
+        });
+
+        const composed = composeModelRequest(
+            this.state,
+            index,
+            this.resolvedContext,
+            this.resolvedAgent,
+            (messages) => this.model.encodeMessages(messages),
+        );
+
+        let completion: Extract<LlmStreamEvent, { type: "completed" }> | null =
+            null;
+        try {
+            for await (const event of this.model.stream({
+                systemPrompt: composed.systemPrompt,
+                messages: composed.messages,
+                tools: composed.tools,
+                parameters: composed.parameters,
+                signal: this.signal,
+            })) {
+                switch (event.type) {
+                    case "text_delta":
+                        this.stream.push({
+                            type: "text_delta",
+                            turnId: this.turnId,
+                            modelCallIndex: index,
+                            delta: event.delta,
+                        });
+                        break;
+                    case "reasoning_delta":
+                        this.stream.push({
+                            type: "reasoning_delta",
+                            turnId: this.turnId,
+                            modelCallIndex: index,
+                            delta: event.delta,
+                        });
+                        break;
+                    case "step_event":
+                        await this.append({
+                            type: "model_step_event",
+                            turnId: this.turnId,
+                            ts: this.now(),
+                            modelCallIndex: index,
+                            event: event.event,
+                        });
+                        break;
+                    case "completed":
+                        completion = event;
+                        break;
+                }
+            }
+            if (!completion) {
+                throw new Error("model stream ended without a completed response");
+            }
+        } catch (error) {
+            if (this.signal.aborted) {
+                await this.append(
+                    modelCallFailedEvent(
+                        this.turnId,
+                        this.now(),
+                        index,
+                        "model call was cancelled",
+                    ),
+                );
+                return this.cancel();
+            }
+            const message = errorMessage(error);
+            await this.append(
+                modelCallFailedEvent(this.turnId, this.now(), index, message),
+            );
+            await this.append({
+                type: "turn_failed",
+                turnId: this.turnId,
+                ts: this.now(),
+                error: message,
+                usage: this.state.usage,
+            });
+            return { status: "failed", error: message, usage: this.state.usage };
+        }
+
+        await this.append({
+            type: "model_call_completed",
+            turnId: this.turnId,
+            ts: this.now(),
+            modelCallIndex: index,
+            message: completion.message,
+            finishReason: completion.finishReason,
+            usage: completion.usage,
+            ...(completion.providerMetadata === undefined
+                ? {}
+                : { providerMetadata: completion.providerMetadata }),
+        });
+        // Analytics after the durable barrier; a reporter failure must never
+        // affect the turn.
+        try {
+            this.usageReporter.reportModelUsage({
+                agentId: this.resolvedAgent.agentId,
+                model: this.resolvedAgent.model,
+                usage: completion.usage,
+            });
+        } catch {
+            // best effort
+        }
+        return undefined;
+    }
+
+    // §22: close any open model call, give synthetic results to unresolved
+    // calls, and append the terminal cancellation.
+    private async cancel(): Promise<TurnOutcome> {
+        const open = this.state.modelCalls.find(
+            (c) => c.response === undefined && c.error === undefined,
+        );
+        if (open) {
+            await this.append(
+                modelCallFailedEvent(
+                    this.turnId,
+                    this.now(),
+                    open.index,
+                    "model call was cancelled",
+                ),
+            );
+        }
+        for (const tc of this.state.toolCalls.filter((t) => !t.result)) {
+            await this.append(
+                runtimeResultEvent(this.turnId, this.now(), tc, {
+                    output: "Tool call was cancelled before completion.",
+                    isError: true,
+                }),
+            );
+        }
+        await this.append({
+            type: "turn_cancelled",
+            turnId: this.turnId,
+            ts: this.now(),
+            ...(this.cancelReason === undefined
+                ? {}
+                : { reason: this.cancelReason }),
+            usage: this.state.usage,
+        });
+        return {
+            status: "cancelled",
+            ...(this.cancelReason === undefined ? {} : { reason: this.cancelReason }),
+            usage: this.state.usage,
+        };
+    }
+}
+
+function errorMessage(error: unknown): string {
+    return error instanceof Error ? error.message : String(error);
+}
+
+function outcomeFromTerminal(state: TurnState): TurnOutcome {
+    const terminal = state.terminal;
+    if (!terminal) {
+        throw new Error("turn is not terminal");
+    }
+    switch (terminal.type) {
+        case "turn_completed":
+            return {
+                status: "completed",
+                output: terminal.output,
+                finishReason: terminal.finishReason,
+                usage: terminal.usage,
+            };
+        case "turn_failed":
+            return {
+                status: "failed",
+                error: terminal.error,
+                ...(terminal.code === undefined ? {} : { code: terminal.code }),
+                usage: terminal.usage,
+            };
+        case "turn_cancelled":
+            return {
+                status: "cancelled",
+                ...(terminal.reason === undefined ? {} : { reason: terminal.reason }),
+                usage: terminal.usage,
+            };
+    }
+}
+
+function permissionsSnapshot(
+    calls: ToolCallState[],
+): z.infer<typeof TurnSuspended>["pendingPermissions"] {
+    return calls.map((tc) => ({
+        toolCallId: tc.toolCallId,
+        toolName: tc.toolName,
+        request: (tc.permission as NonNullable<ToolCallState["permission"]>)
+            .required.request,
+    }));
+}
+
+function asyncSnapshot(
+    calls: ToolCallState[],
+): z.infer<typeof TurnSuspended>["pendingAsyncTools"] {
+    return calls.map((tc) => ({
+        toolCallId: tc.toolCallId,
+        toolId: (tc.invocation as z.infer<typeof ToolInvocationRequested>).toolId,
+        toolName: tc.toolName,
+        input: (tc.invocation as z.infer<typeof ToolInvocationRequested>).input,
+    }));
+}
+
+function modelCallFailedEvent(
+    turnId: string,
+    ts: string,
+    modelCallIndex: number,
+    error: string,
+): z.infer<typeof ModelCallFailed> {
+    return { type: "model_call_failed", turnId, ts, modelCallIndex, error };
+}
+
+function runtimeResultEvent(
+    turnId: string,
+    ts: string,
+    tc: ToolCallState,
+    result: { output: JsonValue; isError: boolean },
+): z.infer<typeof ToolResult> {
+    return {
+        type: "tool_result",
+        turnId,
+        ts,
+        toolCallId: tc.toolCallId,
+        toolName: tc.toolName,
+        source: "runtime",
+        result,
+    };
+}
+
+function permissionRequiredEvent(
+    turnId: string,
+    ts: string,
+    tc: ToolCallState,
+    request: JsonValue,
+    checkerError?: string,
+): z.infer<typeof ToolPermissionRequired> {
+    return {
+        type: "tool_permission_required",
+        turnId,
+        ts,
+        toolCallId: tc.toolCallId,
+        toolName: tc.toolName,
+        request,
+        ...(checkerError === undefined ? {} : { checkerError }),
+    };
+}
+
+function resolvedEvent(
+    turnId: string,
+    ts: string,
+    toolCallId: string,
+    decision: "allow" | "deny",
+    source: z.infer<typeof ToolPermissionResolved>["source"],
+    reason?: string,
+): z.infer<typeof ToolPermissionResolved> {
+    return {
+        type: "tool_permission_resolved",
+        turnId,
+        ts,
+        toolCallId,
+        decision,
+        source,
+        ...(reason === undefined ? {} : { reason }),
+    };
+}
+
+function invocationEvent(
+    turnId: string,
+    ts: string,
+    tc: ToolCallState,
+    descriptor: z.infer<typeof ToolDescriptor>,
+): z.infer<typeof ToolInvocationRequested> {
+    return {
+        type: "tool_invocation_requested",
+        turnId,
+        ts,
+        toolCallId: tc.toolCallId,
+        toolId: descriptor.toolId,
+        toolName: tc.toolName,
+        execution: descriptor.execution,
+        input: (tc.input ?? null) as JsonValue,
+    };
+}
diff --git a/apps/x/packages/core/src/turns/stream.test.ts b/apps/x/packages/core/src/turns/stream.test.ts
new file mode 100644
index 00000000..f2b35614
--- /dev/null
+++ b/apps/x/packages/core/src/turns/stream.test.ts
@@ -0,0 +1,89 @@
+import { describe, expect, it } from "vitest";
+import { HotStream } from "./stream.js";
+
+async function collect<T>(iterable: AsyncIterable<T>): Promise<T[]> {
+    const out: T[] = [];
+    for await (const item of iterable) {
+        out.push(item);
+    }
+    return out;
+}
+
+describe("HotStream", () => {
+    it("buffers events pushed before a consumer attaches", async () => {
+        const stream = new HotStream<number, string>();
+        stream.push(1);
+        stream.push(2);
+        stream.end("done");
+        expect(await collect(stream.events)).toEqual([1, 2]);
+        expect(await stream.outcome).toBe("done");
+    });
+
+    it("outcome resolves without draining events", async () => {
+        const stream = new HotStream<number, string>();
+        stream.push(1);
+        stream.push(2);
+        stream.end("done");
+        expect(await stream.outcome).toBe("done");
+    });
+
+    it("delivers events in order across await boundaries", async () => {
+        const stream = new HotStream<number, string>();
+        const consumer = collect(stream.events);
+        stream.push(1);
+        await Promise.resolve();
+        stream.push(2);
+        stream.push(3);
+        stream.end("done");
+        expect(await consumer).toEqual([1, 2, 3]);
+    });
+
+    it("closing the consumer drops future events without affecting outcome", async () => {
+        const stream = new HotStream<number, string>();
+        stream.push(1);
+        stream.push(2);
+        for await (const event of stream.events) {
+            expect(event).toBe(1);
+            break; // closes the iterator
+        }
+        stream.push(3); // dropped
+        stream.end("done");
+        expect(await collect(stream.events)).toEqual([]);
+        expect(await stream.outcome).toBe("done");
+    });
+
+    it("failure drains queued events, then throws, and rejects outcome with the same error", async () => {
+        const stream = new HotStream<number, string>();
+        const boom = new Error("boom");
+        stream.push(1);
+        stream.fail(boom);
+        const seen: number[] = [];
+        await expect(
+            (async () => {
+                for await (const event of stream.events) {
+                    seen.push(event);
+                }
+            })(),
+        ).rejects.toBe(boom);
+        expect(seen).toEqual([1]);
+        await expect(stream.outcome).rejects.toBe(boom);
+    });
+
+    it("ignores pushes and settlement after completion", async () => {
+        const stream = new HotStream<number, string>();
+        stream.end("first");
+        stream.push(9);
+        stream.end("second");
+        stream.fail(new Error("late"));
+        expect(await stream.outcome).toBe("first");
+        expect(await collect(stream.events)).toEqual([]);
+    });
+
+    it("a waiting consumer wakes on end", async () => {
+        const stream = new HotStream<number, string>();
+        const consumer = collect(stream.events);
+        await Promise.resolve();
+        stream.end("done");
+        expect(await consumer).toEqual([]);
+    });
+});
diff --git a/apps/x/packages/core/src/turns/stream.ts b/apps/x/packages/core/src/turns/stream.ts
new file mode 100644
index 00000000..9092b454
--- /dev/null
+++ b/apps/x/packages/core/src/turns/stream.ts
@@ -0,0 +1,94 @@
+// Hot execution stream (turn-runtime-design.md §16). Execution starts
+// independently of event consumption; events buffer in an unbounded in-memory
+// queue until the single assumed consumer attaches. If the consumer closes,
+// subsequent events are dropped; closing never cancels execution. On
+// infrastructure failure, iteration drains already-queued events and then
+// throws, and the outcome rejects with the same error.
+export class HotStream<TEvent, TOutcome> {
+    private queue: TEvent[] = [];
+    private waiters: Array<() => void> = [];
+    private done = false;
+    private failure: { error: unknown } | null = null;
+    private consumerClosed = false;
+
+    readonly outcome: Promise<TOutcome>;
+    private resolveOutcome!: (outcome: TOutcome) => void;
+    private rejectOutcome!: (error: unknown) => void;
+
+    constructor() {
+        this.outcome = new Promise<TOutcome>((resolve, reject) => {
+            this.resolveOutcome = resolve;
+            this.rejectOutcome = reject;
+        });
+        // The outcome may legitimately never be awaited (fire-and-forget
+        // callers); don't surface unhandled rejections for it.
+        this.outcome.catch(() => undefined);
+    }
+
+    push(event: TEvent): void {
+        if (this.done || this.consumerClosed) {
+            return;
+        }
+        this.queue.push(event);
+        this.wake();
+    }
+
+    end(outcome: TOutcome): void {
+        if (this.done) {
+            return;
+        }
+        this.done = true;
+        this.resolveOutcome(outcome);
+        this.wake();
+    }
+
+    fail(error: unknown): void {
+        if (this.done) {
+            return;
+        }
+        this.done = true;
+        this.failure = { error };
+        this.rejectOutcome(error);
+        this.wake();
+    }
+
+    private wake(): void {
+        const waiters = this.waiters;
+        this.waiters = [];
+        for (const waiter of waiters) {
+            waiter();
+        }
+    }
+
+    get events(): AsyncIterable<TEvent> {
+        return {
+            [Symbol.asyncIterator]: (): AsyncIterator<TEvent> => ({
+                next: async (): Promise<IteratorResult<TEvent>> => {
+                    for (;;) {
+                        if (this.consumerClosed) {
+                            return { value: undefined, done: true };
+                        }
+                        const event = this.queue.shift();
+                        if (event !== undefined) {
+                            return { value: event, done: false };
+                        }
+                        if (this.done) {
+                            if (this.failure) {
+                                throw this.failure.error;
+                            }
+                            return { value: undefined, done: true };
+                        }
+                        await new Promise<void>((resolve) =>
+                            this.waiters.push(resolve),
+                        );
+                    }
+                },
+                return: async (): Promise<IteratorResult<TEvent>> => {
+                    this.consumerClosed = true;
+                    this.queue.length = 0;
+                    return { value: undefined, done: true };
+                },
+            }),
+        };
+    }
+}
diff --git a/apps/x/packages/core/src/turns/tool-registry.ts b/apps/x/packages/core/src/turns/tool-registry.ts
new file mode 100644
index 00000000..3d9c09b7
--- /dev/null
+++ b/apps/x/packages/core/src/turns/tool-registry.ts
@@ -0,0 +1,37 @@
+import type { z } from "zod";
+import type {
+    JsonValue,
+    ToolDescriptor,
+    ToolResultData,
+} from "@x/shared/dist/turns.js";
+
+export interface ToolExecutionContext {
+    turnId: string;
+    toolCallId: string;
+    signal: AbortSignal;
+    // The loop appends a durable tool_progress event before resolving.
+    reportProgress(progress: JsonValue): Promise<void>;
+}
+
+export interface SyncRuntimeTool {
+    descriptor: z.infer<typeof ToolDescriptor> & { execution: "sync" };
+    execute(
+        input: unknown,
+        context: ToolExecutionContext,
+    ): Promise<z.infer<typeof ToolResultData>>;
+}
+
+// An async tool has no in-process executor. Its invocation is exposed
+// externally and its progress/result arrives later through advanceTurn.
+export interface AsyncRuntimeTool {
+    descriptor: z.infer<typeof ToolDescriptor> & { execution: "async" };
+}
+
+export type RuntimeTool = SyncRuntimeTool | AsyncRuntimeTool;
+
+// Resolves persisted tool descriptors to live implementations during
+// advanceTurn. A rejection or a descriptor mismatch is an infrastructure
+// error: the execution is rejected and the turn is left unchanged.
+export interface IToolRegistry {
+    resolve(descriptor: z.infer<typeof ToolDescriptor>): Promise<RuntimeTool>;
+}
diff --git a/apps/x/packages/core/src/turns/usage-reporter.ts b/apps/x/packages/core/src/turns/usage-reporter.ts
new file mode 100644
index 00000000..90bbd284
--- /dev/null
+++ b/apps/x/packages/core/src/turns/usage-reporter.ts
@@ -0,0 +1,19 @@
+import type { z } from "zod";
+import type { ModelDescriptor, TurnUsage } from "@x/shared/dist/turns.js";
+
+// Analytics seam for the turn loop: invoked once per completed model call,
+// after the durable model_call_completed append. Implementations must never
+// throw into the loop and must not block it (fire-and-forget).
+export interface ModelUsageReport {
+    agentId: string;
+    model: z.infer<typeof ModelDescriptor>;
+    usage: z.infer<typeof TurnUsage>;
+}
+
+export interface IUsageReporter {
+    reportModelUsage(report: ModelUsageReport): void;
+}
+
+export class NoopUsageReporter implements IUsageReporter {
+    reportModelUsage(): void {}
+}
diff --git a/apps/x/packages/core/src/voice/voice.ts b/apps/x/packages/core/src/voice/voice.ts
index 1cfba03b..775918ed 100644
--- a/apps/x/packages/core/src/voice/voice.ts
+++ b/apps/x/packages/core/src/voice/voice.ts
@@ -32,46 +32,57 @@ export async function getVoiceConfig(): Promise<VoiceConfig> {
     };
 }
 
-export async function synthesizeSpeech(text: string): Promise<{ audioBase64: string; mimeType: string }> {
+async function resolveTtsEndpoint(streaming: boolean): Promise<{ url: string; headers: Record<string, string> }> {
     const config = await getVoiceConfig();
     const signedIn = await isSignedIn();
 
-    let url: string;
-    let headers: Record<string, string>;
-
     if (signedIn) {
-        const voiceId = config.elevenlabs?.voiceId || 'UgBBYS2sOqTuMpoF3BR0';
+        const voiceId = config.elevenlabs?.voiceId || 's3TPKV1kjDlVtZbl4Ksh';
         const accessToken = await getAccessToken();
-        url = `${API_URL}/v1/voice/text-to-speech/${voiceId}`;
-        headers = {
-            'Authorization': `Bearer ${accessToken}`,
-            'Content-Type': 'application/json',
+        // The proxy has no dedicated /stream route — the same endpoint is
+        // used and the body is consumed progressively; if the proxy buffers,
+        // streaming degrades to today's full-body latency, never worse.
+        return {
+            url: `${API_URL}/v1/voice/text-to-speech/${voiceId}`,
+            headers: {
+                'Authorization': `Bearer ${accessToken}`,
+                'Content-Type': 'application/json',
+            },
         };
-        console.log('[voice] synthesizing speech via Rowboat proxy, text length:', text.length, 'voiceId:', voiceId);
-    } else {
-        if (!config.elevenlabs) {
-            throw new Error(`ElevenLabs not configured. Create ${path.join(WorkDir, 'config', 'elevenlabs.json')} with { "apiKey": "<your-key>" }`);
-        }
-        const voiceId = config.elevenlabs.voiceId || 'UgBBYS2sOqTuMpoF3BR0';
-        url = `https://api.elevenlabs.io/v1/text-to-speech/${voiceId}`;
-        headers = {
+    }
+
+    if (!config.elevenlabs) {
+        throw new Error(`ElevenLabs not configured. Create ${path.join(WorkDir, 'config', 'elevenlabs.json')} with { "apiKey": "<your-key>" }`);
+    }
+    const voiceId = config.elevenlabs.voiceId || 's3TPKV1kjDlVtZbl4Ksh';
+    return {
+        url: `https://api.elevenlabs.io/v1/text-to-speech/${voiceId}${streaming ? '/stream' : ''}`,
+        headers: {
             'xi-api-key': config.elevenlabs.apiKey,
             'Content-Type': 'application/json',
-        };
-        console.log('[voice] synthesizing speech via ElevenLabs, text length:', text.length, 'voiceId:', voiceId);
-    }
+        },
+    };
+}
+
+function ttsRequestBody(text: string): string {
+    return JSON.stringify({
+        text,
+        model_id: 'eleven_flash_v2_5',
+        voice_settings: {
+            stability: 0.5,
+            similarity_boost: 0.75,
+        },
+    });
+}
+
+export async function synthesizeSpeech(text: string): Promise<{ audioBase64: string; mimeType: string }> {
+    const { url, headers } = await resolveTtsEndpoint(false);
+    console.log('[voice] synthesizing speech, text length:', text.length);
 
     const response = await fetch(url, {
         method: 'POST',
         headers,
-        body: JSON.stringify({
-            text,
-            model_id: 'eleven_flash_v2_5',
-            voice_settings: {
-                stability: 0.5,
-                similarity_boost: 0.75,
-            },
-        }),
+        body: ttsRequestBody(text),
     });
 
     if (!response.ok) {
@@ -85,3 +96,42 @@ export async function synthesizeSpeech(text: string): Promise<{ audioBase64: str
     console.log('[voice] synthesized audio, base64 length:', audioBase64.length);
     return { audioBase64, mimeType: 'audio/mpeg' };
 }
+
+/**
+ * Streaming synthesis: invokes `onChunk` with MP3 bytes as they arrive so
+ * playback can start on the first chunk. Resolves when the stream ends;
+ * rejects on HTTP/stream errors. Abort via the provided signal.
+ */
+export async function synthesizeSpeechStream(
+    text: string,
+    onChunk: (chunk: Buffer) => void,
+    signal?: AbortSignal,
+): Promise<void> {
+    const { url, headers } = await resolveTtsEndpoint(true);
+    console.log('[voice] streaming speech synthesis, text length:', text.length);
+
+    const response = await fetch(url, {
+        method: 'POST',
+        headers,
+        body: ttsRequestBody(text),
+        signal: signal ?? null,
+    });
+
+    if (!response.ok) {
+        const errText = await response.text().catch(() => 'Unknown error');
+        console.error('[voice] TTS stream API error:', response.status, errText);
+        throw new Error(`TTS API error ${response.status}: ${errText}`);
+    }
+    if (!response.body) {
+        throw new Error('TTS API returned no body');
+    }
+
+    const reader = response.body.getReader();
+    for (;;) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        if (value && value.byteLength > 0) {
+            onChunk(Buffer.from(value));
+        }
+    }
+}
diff --git a/apps/x/packages/shared/package.json b/apps/x/packages/shared/package.json
index 0bab918a..31f99cdd 100644
--- a/apps/x/packages/shared/package.json
+++ b/apps/x/packages/shared/package.json
@@ -1,14 +1,19 @@
 {
-    "name": "@x/shared",
-    "private": true,
-    "type": "module",
-    "main": "./dist/index.js",
-    "types": "./dist/index.d.ts",
-    "scripts": {
-      "build": "rm -rf dist && tsc",
-      "dev": "tsc -w"
-    },
-    "dependencies": {
-      "zod": "^4.2.1"
-    }
-}
\ No newline at end of file
+  "name": "@x/shared",
+  "private": true,
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "scripts": {
+    "build": "rm -rf dist && tsc -p tsconfig.build.json",
+    "dev": "tsc -w",
+    "test": "vitest run",
+    "test:watch": "vitest"
+  },
+  "dependencies": {
+    "zod": "^4.2.1"
+  },
+  "devDependencies": {
+    "vitest": "catalog:"
+  }
+}
diff --git a/apps/x/packages/shared/src/blocks.ts b/apps/x/packages/shared/src/blocks.ts
index 69b331c4..7f456bab 100644
--- a/apps/x/packages/shared/src/blocks.ts
+++ b/apps/x/packages/shared/src/blocks.ts
@@ -107,6 +107,10 @@ export const GmailAttachmentSchema = z.object({
   mimeType: z.string().optional(),
   sizeBytes: z.number().int().nonnegative().optional(),
   savedPath: z.string(),
+  // Gmail identifiers used to fetch the attachment on demand when it hasn't
+  // been downloaded to disk yet (e.g. attachments on search results).
+  messageId: z.string().optional(),
+  attachmentId: z.string().optional(),
 });
 
 export type GmailAttachment = z.infer<typeof GmailAttachmentSchema>;
@@ -124,6 +128,14 @@ export const GmailThreadMessageSchema = z.object({
   bodyHeight: z.number().int().positive().optional(),
   attachments: z.array(GmailAttachmentSchema).optional(),
   messageIdHeader: z.string().optional(),
+  // Set on the unsent draft message within a thread (used by the Drafts view).
+  isDraft: z.boolean().optional(),
+  // The draft's own stored In-Reply-To / References headers. Only set on
+  // draft messages: a Drafts-view pseudo-thread contains just the draft, so
+  // the composer can't rebuild the reply chain from thread messages and must
+  // reuse what the draft already carries.
+  inReplyToHeader: z.string().optional(),
+  referencesHeader: z.string().optional(),
 });
 
 export type GmailThreadMessage = z.infer<typeof GmailThreadMessageSchema>;
@@ -134,6 +146,9 @@ export const GmailThreadSchema = EmailBlockSchema.extend({
   unread: z.boolean().optional(),
   importance: z.enum(['important', 'other']).optional(),
   gmail_draft: z.string().optional(),
+  // Gmail-side draft id, present on entries returned by the Drafts list so the
+  // composer can update/delete that exact draft.
+  draftId: z.string().optional(),
   messages: z.array(GmailThreadMessageSchema),
 });
 
diff --git a/apps/x/packages/shared/src/browser-control.ts b/apps/x/packages/shared/src/browser-control.ts
index e4eb112d..1383e9e2 100644
--- a/apps/x/packages/shared/src/browser-control.ts
+++ b/apps/x/packages/shared/src/browser-control.ts
@@ -14,6 +14,15 @@ export const BrowserStateSchema = z.object({
   tabs: z.array(BrowserTabStateSchema),
 });
 
+// HTTP basic/proxy auth challenge raised by a page in the embedded browser.
+// Defined once here so main, preload, and renderer share one shape.
+export const HttpAuthRequestSchema = z.object({
+  requestId: z.string(),
+  host: z.string(),
+  isProxy: z.boolean(),
+  realm: z.string().optional(),
+});
+
 export const BrowserPageElementSchema = z.object({
   index: z.number().int().positive(),
   tagName: z.string(),
@@ -134,6 +143,7 @@ export const BrowserControlResultSchema = z.object({
 
 export type BrowserTabState = z.infer<typeof BrowserTabStateSchema>;
 export type BrowserState = z.infer<typeof BrowserStateSchema>;
+export type HttpAuthRequest = z.infer<typeof HttpAuthRequestSchema>;
 export type BrowserPageElement = z.infer<typeof BrowserPageElementSchema>;
 export type BrowserPageSnapshot = z.infer<typeof BrowserPageSnapshotSchema>;
 export type BrowserControlAction = z.infer<typeof BrowserControlActionSchema>;
diff --git a/apps/x/packages/shared/src/channels.ts b/apps/x/packages/shared/src/channels.ts
new file mode 100644
index 00000000..d6e4fa33
--- /dev/null
+++ b/apps/x/packages/shared/src/channels.ts
@@ -0,0 +1,54 @@
+import { z } from "zod";
+
+// ---------------------------------------------------------------------------
+// Mobile messaging channels (WhatsApp / Telegram bridges).
+//
+// Each channel links the user's OWN account/bot to the local app: WhatsApp
+// connects as a linked device (QR pairing), Telegram long-polls the user's
+// own bot token. There is no central relay — the desktop app must be running.
+// ---------------------------------------------------------------------------
+
+export const WhatsAppChannelConfig = z.object({
+    enabled: z.boolean(),
+    // Extra sender phone numbers (digits only, no '+') allowed to drive the
+    // bridge. The linked account itself (self-chat) is always allowed.
+    allowFrom: z.array(z.string()),
+});
+
+export const TelegramChannelConfig = z.object({
+    enabled: z.boolean(),
+    botToken: z.string(),
+    // Telegram chat ids (numeric strings) allowed to drive the bridge.
+    // Unknown senders are told their chat id so it can be added here.
+    allowFrom: z.array(z.string()),
+});
+
+export const ChannelsConfig = z.object({
+    whatsapp: WhatsAppChannelConfig,
+    telegram: TelegramChannelConfig,
+});
+
+export const DEFAULT_CHANNELS_CONFIG: z.infer<typeof ChannelsConfig> = {
+    whatsapp: { enabled: false, allowFrom: [] },
+    telegram: { enabled: false, botToken: "", allowFrom: [] },
+};
+
+export const WhatsAppChannelStatus = z.object({
+    state: z.enum(["disabled", "starting", "qr", "connected", "error"]),
+    // PNG data URL of the pairing QR (present while state === "qr").
+    qrDataUrl: z.string().optional(),
+    // Linked account phone number (digits) once connected.
+    self: z.string().optional(),
+    error: z.string().optional(),
+});
+
+export const TelegramChannelStatus = z.object({
+    state: z.enum(["disabled", "starting", "polling", "error"]),
+    botUsername: z.string().optional(),
+    error: z.string().optional(),
+});
+
+export const ChannelsStatus = z.object({
+    whatsapp: WhatsAppChannelStatus,
+    telegram: TelegramChannelStatus,
+});
diff --git a/apps/x/packages/shared/src/code-mode.ts b/apps/x/packages/shared/src/code-mode.ts
index a3bd46a7..8a85f62f 100644
--- a/apps/x/packages/shared/src/code-mode.ts
+++ b/apps/x/packages/shared/src/code-mode.ts
@@ -53,6 +53,11 @@ export const CodeRunEvent = z.discriminatedUnion("type", [
             priority: z.string().optional(),
         })),
     }),
+    z.object({
+        type: z.literal("usage"),
+        used: z.number().nonnegative(),
+        size: z.number().positive(),
+    }),
     z.object({
         type: z.literal("permission"),
         ask: PermissionAsk,
diff --git a/apps/x/packages/shared/src/index.ts b/apps/x/packages/shared/src/index.ts
index 52f76e92..aaf107e3 100644
--- a/apps/x/packages/shared/src/index.ts
+++ b/apps/x/packages/shared/src/index.ts
@@ -19,5 +19,6 @@ export * as browserControl from './browser-control.js';
 export * as billing from './billing.js';
 export * as notificationSettings from './notification-settings.js';
 export * as codeSessions from './code-sessions.js';
+export * as channels from './channels.js';
 export * as rowboatApp from './rowboat-app.js';
 export { PrefixLogger };
diff --git a/apps/x/packages/shared/src/ipc.ts b/apps/x/packages/shared/src/ipc.ts
index 2e3e3210..ea4ab0e5 100644
--- a/apps/x/packages/shared/src/ipc.ts
+++ b/apps/x/packages/shared/src/ipc.ts
@@ -13,16 +13,19 @@ import {
     BackgroundTaskSummarySchema,
     TriggersSchema,
 } from './background-task.js';
-import { UserMessageContent } from './message.js';
+import { UserMessage, UserMessageContent } from './message.js';
+import { RequestedAgent, type TurnEvent } from './turns.js';
+import type { SessionBusEvent, SessionIndexEntry, SessionState } from './sessions.js';
 import { RowboatApiConfig } from './rowboat-account.js';
 import { ZListToolkitsResponse } from './composio.js';
 import { AppSummarySchema } from './rowboat-app.js';
-import { BrowserStateSchema } from './browser-control.js';
+import { BrowserStateSchema, HttpAuthRequestSchema } from './browser-control.js';
 import { BillingInfoSchema } from './billing.js';
 import { EmailBlockSchema, GmailThreadSchema } from './blocks.js';
 import { PermissionDecision, ApprovalPolicy, CodingAgent } from './code-mode.js';
 import { NotificationSettingsSchema } from './notification-settings.js';
 import { CodeProject, CodeSession, CodeSessionMode, CodeSessionStatus, GitRepoInfo, GitStatusFile, CodeAgentModelOptions } from './code-sessions.js';
+import { ChannelsConfig, ChannelsStatus } from './channels.js';
 
 // ============================================================================
 // Runtime Validation Schemas (Single Source of Truth)
@@ -206,6 +209,56 @@ const ipcSchemas = {
       error: z.string().optional(),
     }),
   },
+  'gmail:saveDraft': {
+    req: z.object({
+      // Existing Gmail draft to update; omitted on first save (creates a new one).
+      draftId: z.string().min(1).optional(),
+      threadId: z.string().min(1).optional(),
+      // Recipients may be blank for a draft (unlike a send).
+      to: z.string().optional(),
+      cc: z.string().optional(),
+      bcc: z.string().optional(),
+      subject: z.string(),
+      bodyHtml: z.string(),
+      bodyText: z.string(),
+      inReplyTo: z.string().optional(),
+      references: z.string().optional(),
+      attachments: z
+        .array(
+          z.object({
+            filename: z.string(),
+            mimeType: z.string(),
+            contentBase64: z.string(),
+          }),
+        )
+        .optional(),
+    }),
+    res: z.object({
+      draftId: z.string().optional(),
+      error: z.string().optional(),
+    }),
+  },
+  'gmail:deleteDraft': {
+    req: z.object({ draftId: z.string().min(1) }),
+    res: z.object({ ok: z.boolean(), error: z.string().optional() }),
+  },
+  'gmail:getDrafts': {
+    req: z.object({}),
+    res: z.object({
+      threads: z.array(GmailThreadSchema),
+      error: z.string().optional(),
+    }),
+  },
+  'gmail:search': {
+    req: z.object({
+      query: z.string(),
+      limit: z.number().int().positive().optional(),
+    }),
+    res: z.object({
+      threads: z.array(GmailThreadSchema),
+      error: z.string().optional(),
+    }),
+  },
   'gmail:getConnectionStatus': {
     req: z.object({}),
     res: z.object({
@@ -236,7 +289,15 @@ const ipcSchemas = {
     res: z.object({ ok: z.boolean(), error: z.string().optional() }),
   },
   'gmail:markThreadRead': {
-    req: z.object({ threadId: z.string().min(1) }),
+    req: z.object({ threadId: z.string().min(1), read: z.boolean().optional() }),
+    res: z.object({ ok: z.boolean(), error: z.string().optional() }),
+  },
+  'gmail:downloadAttachment': {
+    req: z.object({
+      messageId: z.string().min(1),
+      savedPath: z.string().min(1),
+      attachmentId: z.string().optional(),
+    }),
     res: z.object({ ok: z.boolean(), error: z.string().optional() }),
   },
   'gmail:saveMessageHeight': {
@@ -376,6 +437,90 @@ const ipcSchemas = {
     req: z.null(),
     res: z.null(),
   },
+  // ── New runtime: sessions + turns (session-design.md) ────────────────────
+  // Turn-mutating calls return quickly; the renderer follows progress through
+  // the sessions:events feed and the shared reduceTurn reducer.
+  'sessions:create': {
+    req: z.object({ title: z.string().optional() }),
+    res: z.object({ sessionId: z.string() }),
+  },
+  'sessions:list': {
+    req: z.object({}),
+    res: z.object({ sessions: z.array(z.custom<SessionIndexEntry>()) }),
+  },
+  'sessions:get': {
+    req: z.object({ sessionId: z.string() }),
+    res: z.custom<SessionState>(),
+  },
+  'sessions:getTurn': {
+    // Events are strictly validated at the repository read; typed via
+    // z.custom to avoid re-validating potentially large logs per IPC hop.
+    req: z.object({ turnId: z.string() }),
+    res: z.custom<{ turnId: string; events: Array<z.infer<typeof TurnEvent>> }>(),
+  },
+  'sessions:sendMessage': {
+    req: z.object({
+      sessionId: z.string(),
+      input: UserMessage,
+      config: z.object({
+        agent: RequestedAgent,
+        autoPermission: z.boolean().optional(),
+        maxModelCalls: z.number().int().positive().optional(),
+      }),
+    }),
+    res: z.object({ turnId: z.string() }),
+  },
+  'sessions:respondToPermission': {
+    req: z.object({
+      turnId: z.string(),
+      toolCallId: z.string(),
+      decision: z.enum(['allow', 'deny']),
+      metadata: z.json().optional(),
+    }),
+    res: z.object({ success: z.literal(true) }),
+  },
+  'sessions:respondToAskHuman': {
+    req: z.object({
+      turnId: z.string(),
+      toolCallId: z.string(),
+      answer: z.string(),
+    }),
+    res: z.object({ success: z.literal(true) }),
+  },
+  'sessions:stopTurn': {
+    req: z.object({
+      turnId: z.string(),
+      reason: z.string().optional(),
+    }),
+    res: z.object({ success: z.literal(true) }),
+  },
+  'sessions:resumeTurn': {
+    req: z.object({ sessionId: z.string() }),
+    res: z.object({ success: z.literal(true) }),
+  },
+  'sessions:setTitle': {
+    req: z.object({ sessionId: z.string(), title: z.string() }),
+    res: z.object({ success: z.literal(true) }),
+  },
+  'sessions:downloadLog': {
+    // Concatenates the session's turn logs into one JSONL for debugging.
+    req: z.object({ sessionId: z.string() }),
+    res: z.object({
+      success: z.boolean(),
+      error: z.string().optional(),
+    }),
+  },
+  'sessions:delete': {
+    req: z.object({ sessionId: z.string() }),
+    res: z.object({ success: z.literal(true) }),
+  },
+  'sessions:events': {
+    // Typed via z.custom so the renderer's `on` handler is typed without
+    // runtime validation (the broadcast path bypasses preload validation,
+    // like runs:events).
+    req: z.custom<SessionBusEvent>(),
+    res: z.null(),
+  },
   'services:events': {
     req: ServiceEvent,
     res: z.null(),
@@ -506,6 +651,12 @@ const ipcSchemas = {
     }),
     res: z.null(),
   },
+  // Bring the main app window to the foreground (e.g. the assistant navigated
+  // the UI during a call while the user was in another app).
+  'app:focusMainWindow': {
+    req: z.null(),
+    res: z.object({}),
+  },
   'app:takeMeetingNotes': {
     req: z.object({
       // Pass the raw calendar event JSON through; renderer adapts to its existing flow.
@@ -807,6 +958,28 @@ const ipcSchemas = {
       success: z.literal(true),
     }),
   },
+  // ── Mobile channels (WhatsApp / Telegram bridge) ─────────────
+  'channels:getConfig': {
+    req: z.null(),
+    res: ChannelsConfig,
+  },
+  'channels:setConfig': {
+    req: ChannelsConfig,
+    res: z.object({ success: z.literal(true) }),
+  },
+  'channels:getStatus': {
+    req: z.null(),
+    res: ChannelsStatus,
+  },
+  'channels:whatsappLogout': {
+    req: z.null(),
+    res: z.object({ success: z.literal(true) }),
+  },
+  // Push: main → renderer status updates (QR rotation, connect/disconnect).
+  'channels:status': {
+    req: ChannelsStatus,
+    res: z.null(),
+  },
   'slack:getConfig': {
     req: z.null(),
     res: z.object({
@@ -1276,6 +1449,34 @@ const ipcSchemas = {
       mimeType: z.string(),
     }),
   },
+  // Streaming TTS: main starts the synthesis and pushes audio chunks over
+  // 'voice:tts-chunk' as they arrive, so playback can begin on the first
+  // chunk instead of after the full body (~0.5-1s earlier first-audio).
+  'voice:synthesizeStreamStart': {
+    req: z.object({
+      requestId: z.string(),
+      text: z.string(),
+    }),
+    res: z.object({
+      ok: z.boolean(),
+      error: z.string().optional(),
+    }),
+  },
+  'voice:synthesizeStreamCancel': {
+    req: z.object({ requestId: z.string() }),
+    res: z.object({}),
+  },
+  // Push channel: main → renderer with streaming TTS audio. `done: true`
+  // (possibly with a final chunk) ends the stream; `error` aborts it.
+  'voice:tts-chunk': {
+    req: z.object({
+      requestId: z.string(),
+      chunkBase64: z.string().optional(),
+      done: z.boolean(),
+      error: z.string().optional(),
+    }),
+    res: z.null(),
+  },
   // Ensures the OS-level microphone permission is settled before capturing.
   // On first-ever use (macOS) the permission is 'not-determined'; resolving
   // the native prompt up front prevents the in-flight getUserMedia from
@@ -1286,6 +1487,79 @@ const ipcSchemas = {
       granted: z.boolean(),
     }),
   },
+  // Same as ensureMicAccess but for the camera — settles the macOS TCC
+  // permission before video mode calls getUserMedia({ video: true }).
+  'voice:ensureCameraAccess': {
+    req: z.null(),
+    res: z.object({
+      granted: z.boolean(),
+    }),
+  },
+  // Video-mode popout: show/hide the small always-on-top window (user +
+  // mascot tiles) that floats over everything for the duration of a screen
+  // share, Meet-style.
+  'video:setPopout': {
+    req: z.object({ show: z.boolean() }),
+    res: z.object({}),
+  },
+  // Main-window renderer pushes the current call state; the main process
+  // caches it and relays to the popout window (replayed on popout load).
+  'video:popoutState': {
+    req: z.object({
+      ttsState: z.enum(['idle', 'synthesizing', 'speaking']),
+      status: z.enum(['listening', 'thinking', 'speaking']).nullable(),
+      cameraOn: z.boolean(),
+      screenSharing: z.boolean(),
+      // Live transcript of the in-progress utterance.
+      interimText: z.string().nullable(),
+    }),
+    res: z.object({}),
+  },
+  // Popout window → fetch the latest cached call state on mount. The
+  // did-finish-load replay can race the React listener registration, and the
+  // popout must never guess (a wrong camera-on default flashes the user's
+  // video before the first state push corrects it).
+  'video:getPopoutState': {
+    req: z.null(),
+    res: z.object({
+      state: z
+        .object({
+          ttsState: z.enum(['idle', 'synthesizing', 'speaking']),
+          status: z.enum(['listening', 'thinking', 'speaking']).nullable(),
+          cameraOn: z.boolean(),
+          screenSharing: z.boolean(),
+          interimText: z.string().nullable(),
+        })
+        .nullable(),
+    }),
+  },
+  // Popout control bar → main process → relayed to the app window, which
+  // executes the action on the live call. 'expand' additionally focuses the
+  // main app window (handled in the main process).
+  'video:popoutAction': {
+    req: z.object({
+      action: z.enum(['toggle-camera', 'toggle-share', 'stop-speaking', 'end-call', 'expand']),
+    }),
+    res: z.object({}),
+  },
+  // Push channel: main → popout window with the latest call state.
+  'video:popout-state': {
+    req: z.object({
+      ttsState: z.enum(['idle', 'synthesizing', 'speaking']),
+      status: z.enum(['listening', 'thinking', 'speaking']).nullable(),
+      cameraOn: z.boolean(),
+      screenSharing: z.boolean(),
+      interimText: z.string().nullable(),
+    }),
+    res: z.null(),
+  },
+  // Push channel: main → app window with a popout control-bar action.
+  'video:popout-action': {
+    req: z.object({
+      action: z.enum(['toggle-camera', 'toggle-share', 'stop-speaking', 'end-call', 'expand']),
+    }),
+    res: z.null(),
+  },
   'meeting:checkScreenPermission': {
     req: z.null(),
     res: z.object({
@@ -1306,6 +1580,47 @@ const ipcSchemas = {
       notes: z.string(),
     }),
   },
+  // Resolve a meeting's attendees against the knowledge base — returns each
+  // attendee's existing person note (or null). Deterministic, no LLM; powers
+  // the ambient "Next up" prep card.
+  'meeting-prep:resolve': {
+    req: z.object({
+      attendees: z.array(z.object({
+        email: z.string().optional(),
+        displayName: z.string().optional(),
+        self: z.boolean().optional(),
+      })),
+      // When provided, the response includes any pre-generated prep note for
+      // this calendar event (matched by the eventId stamped in frontmatter).
+      eventId: z.string().optional(),
+    }),
+    res: z.object({
+      attendees: z.array(z.object({
+        label: z.string(),
+        email: z.string().optional(),
+        displayName: z.string().optional(),
+        note: z.object({
+          path: z.string(),
+          name: z.string(),
+          role: z.string().optional(),
+          organization: z.string().optional(),
+          markdown: z.string(),
+        }).nullable(),
+      })),
+      organizations: z.array(z.object({
+        path: z.string(),
+        name: z.string(),
+        markdown: z.string(),
+      })),
+      // The pre-generated prep note (brief + path), if one exists for eventId.
+      prepNote: z.object({
+        path: z.string(),
+        brief: z.string(),
+      }).nullable(),
+      matchedCount: z.number().int().nonnegative(),
+      unmatchedCount: z.number().int().nonnegative(),
+    }),
+  },
   // Inline task schedule classification
   'export:note': {
     req: z.object({
@@ -1598,6 +1913,30 @@ const ipcSchemas = {
     req: BrowserStateSchema,
     res: z.null(),
   },
+  // HTTP basic/proxy auth challenge from a page in the embedded browser
+  // (main → renderer push). The renderer shows a credential prompt and
+  // answers via browser:httpAuthResponse.
+  'browser:httpAuthRequest': {
+    req: HttpAuthRequestSchema,
+    res: z.null(),
+  },
+  // Main → renderer: a pending auth challenge was resolved without the
+  // renderer answering (timed out, or its tab/window was destroyed), so the
+  // renderer must drop the corresponding dialog from its queue.
+  'browser:httpAuthResolved': {
+    req: z.object({ requestId: z.string() }),
+    res: z.null(),
+  },
+  // Renderer → main. Omit username to cancel the challenge; provide it (even
+  // empty, for token-style auth) to submit credentials.
+  'browser:httpAuthResponse': {
+    req: z.object({
+      requestId: z.string(),
+      username: z.string().optional(),
+      password: z.string().optional(),
+    }),
+    res: z.object({ ok: z.boolean() }),
+  },
   // Billing channels
   'billing:getInfo': {
     req: z.null(),
diff --git a/apps/x/packages/shared/src/message.ts b/apps/x/packages/shared/src/message.ts
index cdf5d983..92645395 100644
--- a/apps/x/packages/shared/src/message.ts
+++ b/apps/x/packages/shared/src/message.ts
@@ -44,8 +44,20 @@ export const UserAttachmentPart = z.object({
     lineNumber: z.number().int().min(1).optional(),  // 1-indexed line in source file (for editor-context references)
 });
 
-// Any single part of a user message (text or attachment)
-export const UserContentPart = z.union([UserTextPart, UserAttachmentPart]);
+// An inline image within a content array (e.g. a live webcam frame from
+// video mode). Unlike attachments, image parts carry their data inline as
+// base64 and are sent to the model as real multimodal image parts rather
+// than a file-path reference.
+export const UserImagePart = z.object({
+    type: z.literal("image"),
+    data: z.string(),                    // base64-encoded image bytes (no data: prefix)
+    mediaType: z.string(),               // MIME type ("image/jpeg")
+    source: z.enum(["camera", "screen"]).optional(),
+    capturedAt: z.string().optional(),   // ISO timestamp of capture
+});
+
+// Any single part of a user message (text, attachment, or inline image)
+export const UserContentPart = z.union([UserTextPart, UserAttachmentPart, UserImagePart]);
 
 // Named type for user message content — used everywhere instead of repeating the union
 export const UserMessageContent = z.union([z.string(), z.array(UserContentPart)]);
diff --git a/apps/x/packages/shared/src/sessions.test.ts b/apps/x/packages/shared/src/sessions.test.ts
new file mode 100644
index 00000000..2676a2b7
--- /dev/null
+++ b/apps/x/packages/shared/src/sessions.test.ts
@@ -0,0 +1,201 @@
+import { describe, expect, it } from "vitest";
+import { z } from "zod";
+import {
+    SessionCorruptionError,
+    SessionCreated,
+    SessionEvent,
+    SessionTurnAppended,
+    reduceSession,
+    sessionIndexEntry,
+} from "./sessions.js";
+
+type SEvent = z.infer<typeof SessionEvent>;
+
+const SESSION_ID = "2026-07-02T09-00-00Z-0000042-000";
+const MODEL = { provider: "openai", model: "gpt-test" };
+
+function sessionCreated(
+    overrides: Partial<z.infer<typeof SessionCreated>> = {},
+): z.infer<typeof SessionCreated> {
+    return {
+        type: "session_created",
+        schemaVersion: 1,
+        sessionId: SESSION_ID,
+        ts: "2026-07-02T09:00:00Z",
+        ...overrides,
+    };
+}
+
+function turnAppended(
+    sessionSeq: number,
+    turnId: string,
+    overrides: Partial<z.infer<typeof SessionTurnAppended>> = {},
+): z.infer<typeof SessionTurnAppended> {
+    return {
+        type: "turn_appended",
+        sessionId: SESSION_ID,
+        ts: `2026-07-02T09:0${sessionSeq}:00Z`,
+        turnId,
+        sessionSeq,
+        agentId: "copilot",
+        model: MODEL,
+        ...overrides,
+    };
+}
+
+function titleChanged(title: string, ts = "2026-07-02T09:05:00Z") {
+    return {
+        type: "title_changed" as const,
+        sessionId: SESSION_ID,
+        ts,
+        title,
+    };
+}
+
+function expectCorruption(events: SEvent[], match: string | RegExp): void {
+    expect(() => reduceSession(events)).toThrowError(SessionCorruptionError);
+    expect(() => reduceSession(events)).toThrowError(match);
+}
+
+describe("schemas", () => {
+    it("session events round-trip through the SessionEvent schema", () => {
+        const events: SEvent[] = [
+            sessionCreated({ title: "Hello" }),
+            turnAppended(1, "turn-1"),
+            titleChanged("Renamed"),
+        ];
+        for (const event of events) {
+            expect(SessionEvent.parse(event)).toEqual(event);
+        }
+    });
+
+    it("rejects non-positive sessionSeq at the schema level", () => {
+        expect(() => SessionEvent.parse(turnAppended(0, "turn-0"))).toThrowError();
+    });
+});
+
+describe("reduceSession", () => {
+    it("reduces a created-only log", () => {
+        const state = reduceSession([sessionCreated()]);
+        expect(state.definition.sessionId).toBe(SESSION_ID);
+        expect(state.turns).toEqual([]);
+        expect(state.latestTurnId).toBeUndefined();
+        expect(state.title).toBeUndefined();
+        expect(state.createdAt).toBe("2026-07-02T09:00:00Z");
+        expect(state.updatedAt).toBe("2026-07-02T09:00:00Z");
+    });
+
+    it("folds turns in order with denormalized metadata", () => {
+        const state = reduceSession([
+            sessionCreated(),
+            turnAppended(1, "turn-1"),
+            turnAppended(2, "turn-2", { agentId: "researcher", model: { provider: "anthropic", model: "claude-x" } }),
+        ]);
+        expect(state.turns).toHaveLength(2);
+        expect(state.turns[0]).toMatchObject({ turnId: "turn-1", sessionSeq: 1, agentId: "copilot" });
+        expect(state.turns[1]).toMatchObject({
+            turnId: "turn-2",
+            sessionSeq: 2,
+            agentId: "researcher",
+            model: { provider: "anthropic", model: "claude-x" },
+        });
+        expect(state.latestTurnId).toBe("turn-2");
+        expect(state.updatedAt).toBe("2026-07-02T09:02:00Z");
+    });
+
+    it("folds titles: creation default then last change wins", () => {
+        const withDefault = reduceSession([sessionCreated({ title: "First message…" })]);
+        expect(withDefault.title).toBe("First message…");
+
+        const renamed = reduceSession([
+            sessionCreated({ title: "First message…" }),
+            titleChanged("Better title"),
+            titleChanged("Best title", "2026-07-02T09:06:00Z"),
+        ]);
+        expect(renamed.title).toBe("Best title");
+        expect(renamed.updatedAt).toBe("2026-07-02T09:06:00Z");
+    });
+
+    it("rejects an empty log", () => {
+        expectCorruption([], /empty/);
+    });
+
+    it("rejects a log not starting with session_created", () => {
+        expectCorruption([turnAppended(1, "turn-1")], /first event must be session_created/);
+    });
+
+    it("rejects duplicate session_created", () => {
+        expectCorruption([sessionCreated(), sessionCreated()], /duplicate session_created/);
+    });
+
+    it("rejects mismatched session ids", () => {
+        expectCorruption(
+            [sessionCreated(), { ...turnAppended(1, "turn-1"), sessionId: "other" }],
+            /does not match session/,
+        );
+    });
+
+    it("rejects unsupported schema versions", () => {
+        const bad = { ...sessionCreated(), schemaVersion: 2 } as unknown as SEvent;
+        expectCorruption([bad], /unsupported session schema version/);
+    });
+
+    it("rejects unknown event types", () => {
+        const bad = { type: "wat", sessionId: SESSION_ID, ts: "t" } as unknown as SEvent;
+        expectCorruption([sessionCreated(), bad], /unknown session event type/);
+    });
+
+    it("rejects a first turn not at sessionSeq 1", () => {
+        expectCorruption([sessionCreated(), turnAppended(2, "turn-2")], /out of order; expected 1/);
+    });
+
+    it("rejects gapped sessionSeq", () => {
+        expectCorruption(
+            [sessionCreated(), turnAppended(1, "turn-1"), turnAppended(3, "turn-3")],
+            /out of order; expected 2/,
+        );
+    });
+
+    it("rejects duplicate sessionSeq", () => {
+        expectCorruption(
+            [sessionCreated(), turnAppended(1, "turn-1"), turnAppended(1, "turn-1b")],
+            /out of order; expected 2/,
+        );
+    });
+
+    it("rejects duplicate turn ids", () => {
+        expectCorruption(
+            [sessionCreated(), turnAppended(1, "turn-1"), turnAppended(2, "turn-1")],
+            /duplicate turnId/,
+        );
+    });
+});
+
+describe("sessionIndexEntry", () => {
+    it("projects an entry with last-turn metadata and the provided status", () => {
+        const state = reduceSession([
+            sessionCreated({ title: "T" }),
+            turnAppended(1, "turn-1"),
+            turnAppended(2, "turn-2", { agentId: "researcher" }),
+        ]);
+        expect(sessionIndexEntry(state, "suspended")).toEqual({
+            sessionId: SESSION_ID,
+            title: "T",
+            createdAt: "2026-07-02T09:00:00Z",
+            updatedAt: "2026-07-02T09:02:00Z",
+            turnCount: 2,
+            lastAgentId: "researcher",
+            lastModel: MODEL,
+            latestTurnId: "turn-2",
+            latestTurnStatus: "suspended",
+        });
+    });
+
+    it("projects an empty session with status none", () => {
+        const state = reduceSession([sessionCreated()]);
+        const entry = sessionIndexEntry(state, "none");
+        expect(entry.turnCount).toBe(0);
+        expect(entry.lastAgentId).toBeUndefined();
+        expect(entry.latestTurnStatus).toBe("none");
+    });
+});
diff --git a/apps/x/packages/shared/src/sessions.ts b/apps/x/packages/shared/src/sessions.ts
new file mode 100644
index 00000000..1a52d38f
--- /dev/null
+++ b/apps/x/packages/shared/src/sessions.ts
@@ -0,0 +1,206 @@
+import { z } from "zod";
+import {
+    ModelDescriptor,
+    type TurnStatus,
+    type TurnStreamEvent,
+} from "./turns.js";
+
+// Durable session contract for the session layer (see
+// packages/core/docs/session-design.md). A session is an append-only chain
+// of turn references plus presentation metadata; conversation content lives
+// exclusively in turn files. Pure module shared by core and renderer.
+
+// ---------------------------------------------------------------------------
+// Durable events
+// ---------------------------------------------------------------------------
+
+export const SessionCreated = z.object({
+    type: z.literal("session_created"),
+    schemaVersion: z.literal(1),
+    sessionId: z.string(),
+    ts: z.string(),
+    title: z.string().optional(),
+});
+
+// agentId/model are denormalized from the turn so the session index can fold
+// without opening turn files; the turn file stays authoritative.
+export const SessionTurnAppended = z.object({
+    type: z.literal("turn_appended"),
+    sessionId: z.string(),
+    ts: z.string(),
+    turnId: z.string(),
+    sessionSeq: z.number().int().positive(),
+    agentId: z.string(),
+    model: ModelDescriptor,
+});
+
+export const SessionTitleChanged = z.object({
+    type: z.literal("title_changed"),
+    sessionId: z.string(),
+    ts: z.string(),
+    title: z.string(),
+});
+
+export const SessionEvent = z.discriminatedUnion("type", [
+    SessionCreated,
+    SessionTurnAppended,
+    SessionTitleChanged,
+]);
+
+// ---------------------------------------------------------------------------
+// Derived session state
+// ---------------------------------------------------------------------------
+
+export class SessionCorruptionError extends Error {
+    constructor(message: string) {
+        super(message);
+        this.name = "SessionCorruptionError";
+    }
+}
+
+export interface SessionTurnRef {
+    turnId: string;
+    sessionSeq: number;
+    agentId: string;
+    model: z.infer<typeof ModelDescriptor>;
+    ts: string;
+}
+
+export interface SessionState {
+    definition: z.infer<typeof SessionCreated>;
+    title?: string;
+    turns: SessionTurnRef[];
+    latestTurnId?: string;
+    createdAt: string;
+    updatedAt: string;
+}
+
+function fail(message: string): never {
+    throw new SessionCorruptionError(message);
+}
+
+export function reduceSession(
+    events: Array<z.infer<typeof SessionEvent>>,
+): SessionState {
+    if (events.length === 0) {
+        fail("session log is empty");
+    }
+    const [first, ...rest] = events;
+    if (first.type !== "session_created") {
+        fail(`first event must be session_created, got ${first.type}`);
+    }
+    if (first.schemaVersion !== 1) {
+        fail(`unsupported session schema version: ${String(first.schemaVersion)}`);
+    }
+
+    const state: SessionState = {
+        definition: first,
+        title: first.title,
+        turns: [],
+        createdAt: first.ts,
+        updatedAt: first.ts,
+    };
+
+    for (const event of rest) {
+        if (event.sessionId !== first.sessionId) {
+            fail(
+                `event sessionId ${event.sessionId} does not match session ${first.sessionId}`,
+            );
+        }
+        switch (event.type) {
+            case "session_created":
+                fail("duplicate session_created event");
+                break;
+            case "turn_appended": {
+                const expectedSeq = state.turns.length + 1;
+                if (event.sessionSeq !== expectedSeq) {
+                    fail(
+                        `sessionSeq ${event.sessionSeq} out of order; expected ${expectedSeq}`,
+                    );
+                }
+                if (state.turns.some((t) => t.turnId === event.turnId)) {
+                    fail(`duplicate turnId in session: ${event.turnId}`);
+                }
+                state.turns.push({
+                    turnId: event.turnId,
+                    sessionSeq: event.sessionSeq,
+                    agentId: event.agentId,
+                    model: event.model,
+                    ts: event.ts,
+                });
+                state.latestTurnId = event.turnId;
+                break;
+            }
+            case "title_changed":
+                state.title = event.title;
+                break;
+            default: {
+                const unknown: never = event;
+                fail(
+                    `unknown session event type: ${(unknown as { type: string }).type}`,
+                );
+            }
+        }
+        state.updatedAt = event.ts;
+    }
+
+    return state;
+}
+
+// ---------------------------------------------------------------------------
+// Session index (in-memory projection; never a source of truth)
+// ---------------------------------------------------------------------------
+
+// "none" = the session has no turns yet. The remaining values are the latest
+// turn's derived status (deriveTurnStatus in turns.ts).
+export type SessionLatestTurnStatus = "none" | TurnStatus;
+
+export interface SessionIndexEntry {
+    sessionId: string;
+    title?: string;
+    createdAt: string;
+    updatedAt: string;
+    turnCount: number;
+    lastAgentId?: string;
+    lastModel?: z.infer<typeof ModelDescriptor>;
+    latestTurnId?: string;
+    latestTurnStatus: SessionLatestTurnStatus;
+    // Set when the session (or its latest turn) failed to load/validate; the
+    // entry is surfaced in an errored state instead of aborting the startup
+    // scan.
+    error?: string;
+}
+
+// What the renderer's single feed consumer receives over IPC: live turn
+// stream events (durable events + ephemeral deltas) and index updates.
+// entry: null signals deletion.
+export type SessionBusEvent =
+    | {
+          kind: "turn-event";
+          sessionId: string;
+          turnId: string;
+          event: TurnStreamEvent;
+      }
+    | {
+          kind: "index-changed";
+          sessionId: string;
+          entry: SessionIndexEntry | null;
+      };
+
+export function sessionIndexEntry(
+    state: SessionState,
+    latestTurnStatus: SessionLatestTurnStatus,
+): SessionIndexEntry {
+    const lastTurn = state.turns[state.turns.length - 1];
+    return {
+        sessionId: state.definition.sessionId,
+        title: state.title,
+        createdAt: state.createdAt,
+        updatedAt: state.updatedAt,
+        turnCount: state.turns.length,
+        lastAgentId: lastTurn?.agentId,
+        lastModel: lastTurn?.model,
+        latestTurnId: state.latestTurnId,
+        latestTurnStatus,
+    };
+}
diff --git a/apps/x/packages/shared/src/turns.test.ts b/apps/x/packages/shared/src/turns.test.ts
new file mode 100644
index 00000000..84a5a9c7
--- /dev/null
+++ b/apps/x/packages/shared/src/turns.test.ts
@@ -0,0 +1,1421 @@
+import { describe, expect, it } from "vitest";
+import { z } from "zod";
+import {
+    type JsonValue,
+    ModelCallCompleted,
+    ModelCallFailed,
+    ModelCallRequested,
+    ModelStepEvent,
+    MODEL_CALL_LIMIT_ERROR_CODE,
+    ToolDescriptor,
+    ToolInvocationRequested,
+    ToolPermissionClassificationFailed,
+    ToolPermissionClassified,
+    ToolPermissionRequired,
+    ToolPermissionResolved,
+    ToolProgress,
+    ToolResult,
+    TurnCancelled,
+    TurnCompleted,
+    TurnCorruptionError,
+    TurnCreated,
+    TurnEvent,
+    TurnFailed,
+    TurnSuspended,
+    deriveTurnStatus,
+    outstandingAsyncTools,
+    outstandingPermissions,
+    reduceTurn,
+    turnTranscript,
+} from "./turns.js";
+
+type TEvent = z.infer<typeof TurnEvent>;
+
+const TURN_ID = "2026-07-02T10-00-00Z-0000001-000";
+const PREV_TURN_ID = "2026-07-02T09-00-00Z-0000001-000";
+const TS = "2026-07-02T10:00:00Z";
+
+const echoTool: z.infer<typeof ToolDescriptor> = {
+    toolId: "tool.echo",
+    name: "echo",
+    description: "Echo tool",
+    inputSchema: {},
+    execution: "sync",
+    requiresHuman: false,
+};
+
+const fetchTool: z.infer<typeof ToolDescriptor> = {
+    toolId: "tool.fetch",
+    name: "fetch",
+    description: "Async fetch tool",
+    inputSchema: {},
+    execution: "async",
+    requiresHuman: false,
+};
+
+function user(text: string) {
+    return { role: "user" as const, content: text };
+}
+
+function assistantText(text: string) {
+    return { role: "assistant" as const, content: text };
+}
+
+function toolCallPart(id: string, name: string, args: JsonValue = {}) {
+    return {
+        type: "tool-call" as const,
+        toolCallId: id,
+        toolName: name,
+        arguments: args,
+    };
+}
+
+function assistantCalls(...parts: Array<ReturnType<typeof toolCallPart>>) {
+    return { role: "assistant" as const, content: parts };
+}
+
+function toolMsg(id: string, name: string, content = "ok") {
+    return { role: "tool" as const, content, toolCallId: id, toolName: name };
+}
+
+function created(
+    overrides: Partial<z.infer<typeof TurnCreated>> = {},
+): z.infer<typeof TurnCreated> {
+    return {
+        type: "turn_created",
+        schemaVersion: 1,
+        turnId: TURN_ID,
+        ts: TS,
+        sessionId: null,
+        agent: {
+            requested: { agentId: "copilot" },
+            resolved: {
+                agentId: "copilot",
+                systemPrompt: "SYS",
+                model: { provider: "openai", model: "gpt-test" },
+                tools: [echoTool, fetchTool],
+            },
+        },
+        context: [],
+        input: user("hello"),
+        config: {
+            autoPermission: false,
+            humanAvailable: true,
+            maxModelCalls: 20,
+        },
+        ...overrides,
+    };
+}
+
+function requested(
+    index: number,
+    messages: z.infer<typeof ModelCallRequested>["request"]["messages"],
+    requestOverrides: Partial<z.infer<typeof ModelCallRequested>["request"]> = {},
+): z.infer<typeof ModelCallRequested> {
+    return {
+        type: "model_call_requested",
+        turnId: TURN_ID,
+        ts: TS,
+        modelCallIndex: index,
+        request: {
+            messages,
+            parameters: {},
+            ...requestOverrides,
+        },
+    };
+}
+
+function completed(
+    index: number,
+    message: z.infer<typeof ModelCallCompleted>["message"],
+    usage: z.infer<typeof ModelCallCompleted>["usage"] = {
+        inputTokens: 10,
+        outputTokens: 5,
+        totalTokens: 15,
+    },
+): z.infer<typeof ModelCallCompleted> {
+    return {
+        type: "model_call_completed",
+        turnId: TURN_ID,
+        ts: TS,
+        modelCallIndex: index,
+        message,
+        finishReason: "stop",
+        usage,
+    };
+}
+
+function callFailed(
+    index: number,
+    error = "provider exploded",
+): z.infer<typeof ModelCallFailed> {
+    return {
+        type: "model_call_failed",
+        turnId: TURN_ID,
+        ts: TS,
+        modelCallIndex: index,
+        error,
+    };
+}
+
+function stepEvent(
+    index: number,
+    event: z.infer<typeof ModelStepEvent>["event"] = {
+        type: "text_end",
+        text: "chunk",
+    },
+): z.infer<typeof ModelStepEvent> {
+    return {
+        type: "model_step_event",
+        turnId: TURN_ID,
+        ts: TS,
+        modelCallIndex: index,
+        event,
+    };
+}
+
+function permRequired(
+    id: string,
+    name: string,
+    checkerError?: string,
+): z.infer<typeof ToolPermissionRequired> {
+    return {
+        type: "tool_permission_required",
+        turnId: TURN_ID,
+        ts: TS,
+        toolCallId: id,
+        toolName: name,
+        request: { tool: name },
+        ...(checkerError === undefined ? {} : { checkerError }),
+    };
+}
+
+function permClassified(
+    id: string,
+    decision: z.infer<typeof ToolPermissionClassified>["decision"],
+): z.infer<typeof ToolPermissionClassified> {
+    return {
+        type: "tool_permission_classified",
+        turnId: TURN_ID,
+        ts: TS,
+        toolCallId: id,
+        decision,
+        reason: "because",
+    };
+}
+
+function permClassificationFailed(
+    ids: string[],
+): z.infer<typeof ToolPermissionClassificationFailed> {
+    return {
+        type: "tool_permission_classification_failed",
+        turnId: TURN_ID,
+        ts: TS,
+        toolCallIds: ids,
+        error: "classifier timed out",
+    };
+}
+
+function permResolved(
+    id: string,
+    decision: z.infer<typeof ToolPermissionResolved>["decision"],
+    source: z.infer<typeof ToolPermissionResolved>["source"] = "human",
+): z.infer<typeof ToolPermissionResolved> {
+    return {
+        type: "tool_permission_resolved",
+        turnId: TURN_ID,
+        ts: TS,
+        toolCallId: id,
+        decision,
+        source,
+    };
+}
+
+function invocation(
+    id: string,
+    tool: z.infer<typeof ToolDescriptor> = echoTool,
+    overrides: Partial<z.infer<typeof ToolInvocationRequested>> = {},
+): z.infer<typeof ToolInvocationRequested> {
+    return {
+        type: "tool_invocation_requested",
+        turnId: TURN_ID,
+        ts: TS,
+        toolCallId: id,
+        toolId: tool.toolId,
+        toolName: tool.name,
+        execution: tool.execution,
+        input: {},
+        ...overrides,
+    };
+}
+
+function progress(
+    id: string,
+    source: z.infer<typeof ToolProgress>["source"] = "sync",
+): z.infer<typeof ToolProgress> {
+    return {
+        type: "tool_progress",
+        turnId: TURN_ID,
+        ts: TS,
+        toolCallId: id,
+        source,
+        progress: { pct: 50 },
+    };
+}
+
+function result(
+    id: string,
+    name: string,
+    source: z.infer<typeof ToolResult>["source"] = "sync",
+    output: JsonValue = "ok",
+    isError = false,
+): z.infer<typeof ToolResult> {
+    return {
+        type: "tool_result",
+        turnId: TURN_ID,
+        ts: TS,
+        toolCallId: id,
+        toolName: name,
+        source,
+        result: { output, isError },
+    };
+}
+
+function suspendedEv(
+    perms: Array<{ id: string; name: string }>,
+    asyncs: Array<{ id: string; tool: z.infer<typeof ToolDescriptor> }>,
+): z.infer<typeof TurnSuspended> {
+    return {
+        type: "turn_suspended",
+        turnId: TURN_ID,
+        ts: TS,
+        pendingPermissions: perms.map((p) => ({
+            toolCallId: p.id,
+            toolName: p.name,
+            request: { tool: p.name },
+        })),
+        pendingAsyncTools: asyncs.map((a) => ({
+            toolCallId: a.id,
+            toolId: a.tool.toolId,
+            toolName: a.tool.name,
+            input: {},
+        })),
+        usage: {},
+    };
+}
+
+function turnCompletedEv(
+    output: z.infer<typeof TurnCompleted>["output"] = assistantText("done"),
+): z.infer<typeof TurnCompleted> {
+    return {
+        type: "turn_completed",
+        turnId: TURN_ID,
+        ts: TS,
+        output,
+        finishReason: "stop",
+        usage: {},
+    };
+}
+
+function turnFailedEv(
+    error = "it broke",
+    code?: string,
+): z.infer<typeof TurnFailed> {
+    return {
+        type: "turn_failed",
+        turnId: TURN_ID,
+        ts: TS,
+        error,
+        ...(code === undefined ? {} : { code }),
+        usage: {},
+    };
+}
+
+function turnCancelledEv(reason?: string): z.infer<typeof TurnCancelled> {
+    return {
+        type: "turn_cancelled",
+        turnId: TURN_ID,
+        ts: TS,
+        ...(reason === undefined ? {} : { reason }),
+        usage: {},
+    };
+}
+
+// A complete happy-path sequence with one sync tool round trip.
+function syncToolSequence(): TEvent[] {
+    const call0 = assistantCalls(toolCallPart("tc1", "echo"));
+    return [
+        created(),
+        requested(0, ["input"]),
+        completed(0, call0),
+        permRequired("tc1", "echo"),
+        permResolved("tc1", "allow"),
+        invocation("tc1"),
+        result("tc1", "echo"),
+        requested(1, ["assistant:0", "toolResult:tc1"]),
+        completed(1, assistantText("done")),
+        turnCompletedEv(),
+    ];
+}
+
+function expectCorruption(events: TEvent[], match: string | RegExp): void {
+    expect(() => reduceTurn(events)).toThrowError(TurnCorruptionError);
+    expect(() => reduceTurn(events)).toThrowError(match);
+}
+
+describe("schemas", () => {
+    it("every builder output round-trips through the TurnEvent schema", () => {
+        for (const event of syncToolSequence()) {
+            expect(TurnEvent.parse(event)).toEqual(event);
+        }
+    });
+
+    it("rejects system-role messages in inline context", () => {
+        const bad = created({
+            context: [
+                { role: "system", content: "sneaky" },
+            ] as unknown as z.infer<typeof TurnCreated>["context"],
+        });
+        expect(() => TurnCreated.parse(bad)).toThrowError();
+    });
+});
+
+describe("plain completion", () => {
+    it("reduces a created-only log to an idle empty state", () => {
+        const state = reduceTurn([created()]);
+        expect(state.definition.turnId).toBe(TURN_ID);
+        expect(state.modelCalls).toEqual([]);
+        expect(state.toolCalls).toEqual([]);
+        expect(state.terminal).toBeUndefined();
+        expect(deriveTurnStatus(state)).toBe("idle");
+    });
+
+    it("reduces a plain model response to a completed turn", () => {
+        const state = reduceTurn([
+            created(),
+            requested(0, ["input"]),
+            stepEvent(0),
+            completed(0, assistantText("done")),
+            turnCompletedEv(),
+        ]);
+        expect(state.modelCalls).toHaveLength(1);
+        expect(state.modelCalls[0].response).toEqual(assistantText("done"));
+        expect(state.modelCalls[0].finishReason).toBe("stop");
+        expect(state.modelCalls[0].stepEvents).toHaveLength(1);
+        expect(state.terminal?.type).toBe("turn_completed");
+        expect(deriveTurnStatus(state)).toBe("completed");
+    });
+
+    it("aggregates usage across model calls", () => {
+        const state = reduceTurn(syncToolSequence());
+        expect(state.usage).toEqual({
+            inputTokens: 20,
+            outputTokens: 10,
+            totalTokens: 30,
+        });
+    });
+
+    it("leaves usage fields undefined when never reported", () => {
+        const state = reduceTurn([
+            created(),
+            requested(0, ["input"]),
+            completed(0, assistantText("a"), { inputTokens: 5 }),
+        ]);
+        expect(state.usage).toEqual({ inputTokens: 5 });
+        expect(state.usage.cachedInputTokens).toBeUndefined();
+    });
+});
+
+describe("tool execution", () => {
+    it("extracts tool calls with order, batch index, and descriptor identity", () => {
+        const call0 = assistantCalls(
+            toolCallPart("tc1", "echo", { text: "a" }),
+            toolCallPart("a1", "fetch", { url: "u" }),
+        );
+        const state = reduceTurn([
+            created(),
+            requested(0, ["input"]),
+            completed(0, call0),
+        ]);
+        expect(state.toolCalls).toHaveLength(2);
+        expect(state.toolCalls[0]).toMatchObject({
+            toolCallId: "tc1",
+            toolName: "echo",
+            toolId: "tool.echo",
+            execution: "sync",
+            modelCallIndex: 0,
+            order: 0,
+            input: { text: "a" },
+        });
+        expect(state.toolCalls[1]).toMatchObject({
+            toolCallId: "a1",
+            execution: "async",
+            order: 1,
+        });
+    });
+
+    it("leaves identity undefined for tools missing from the agent snapshot", () => {
+        const state = reduceTurn([
+            created(),
+            requested(0, ["input"]),
+            completed(0, assistantCalls(toolCallPart("x1", "unknown-tool"))),
+            result("x1", "unknown-tool", "runtime", "No such tool", true),
+        ]);
+        expect(state.toolCalls[0].toolId).toBeUndefined();
+        expect(state.toolCalls[0].execution).toBeUndefined();
+        expect(state.toolCalls[0].result?.result.isError).toBe(true);
+    });
+
+    it("reduces a full sync tool round trip", () => {
+        const state = reduceTurn(syncToolSequence());
+        const tc = state.toolCalls[0];
+        expect(tc.permission?.required).toBeDefined();
+        expect(tc.permission?.resolved?.decision).toBe("allow");
+        expect(tc.invocation).toBeDefined();
+        expect(tc.result?.source).toBe("sync");
+        expect(state.terminal?.type).toBe("turn_completed");
+    });
+
+    it("records classifier provenance separately from the effective decision", () => {
+        const call0 = assistantCalls(toolCallPart("tc1", "echo"));
+        const state = reduceTurn([
+            created({ config: { autoPermission: true, humanAvailable: true, maxModelCalls: 20 } }),
+            requested(0, ["input"]),
+            completed(0, call0),
+            permRequired("tc1", "echo"),
+            permClassified("tc1", "allow"),
+            permResolved("tc1", "allow", "classifier"),
+            invocation("tc1"),
+            result("tc1", "echo"),
+        ]);
+        const permission = state.toolCalls[0].permission;
+        expect(permission?.classification?.decision).toBe("allow");
+        expect(permission?.resolved?.source).toBe("classifier");
+    });
+
+    it("accepts classification failure as audit and continues to human resolution", () => {
+        const call0 = assistantCalls(toolCallPart("tc1", "echo"));
+        const state = reduceTurn([
+            created(),
+            requested(0, ["input"]),
+            completed(0, call0),
+            permRequired("tc1", "echo"),
+            permClassificationFailed(["tc1"]),
+            permResolved("tc1", "deny", "human"),
+            result("tc1", "echo", "runtime", "Permission denied", true),
+        ]);
+        expect(state.toolCalls[0].permission?.classificationFailed).toBe(true);
+        expect(state.toolCalls[0].result?.result.isError).toBe(true);
+    });
+
+    it("accumulates tool progress", () => {
+        const call0 = assistantCalls(toolCallPart("tc1", "echo"));
+        const state = reduceTurn([
+            created(),
+            requested(0, ["input"]),
+            completed(0, call0),
+            invocation("tc1"),
+            progress("tc1"),
+            progress("tc1"),
+            result("tc1", "echo"),
+        ]);
+        expect(state.toolCalls[0].progress).toHaveLength(2);
+    });
+
+    it("accepts denial results without invocation (runtime source)", () => {
+        const call0 = assistantCalls(toolCallPart("tc1", "echo"));
+        const state = reduceTurn([
+            created(),
+            requested(0, ["input"]),
+            completed(0, call0),
+            permRequired("tc1", "echo"),
+            permResolved("tc1", "deny"),
+            result("tc1", "echo", "runtime", "Permission denied", true),
+        ]);
+        expect(state.toolCalls[0].invocation).toBeUndefined();
+        expect(state.toolCalls[0].result?.source).toBe("runtime");
+    });
+});
+
+describe("context references", () => {
+    it("accepts a referenced context with matching contextRef on requests", () => {
+        const state = reduceTurn([
+            created({ context: { previousTurnId: PREV_TURN_ID } }),
+            requested(0, ["input"], {
+                contextRef: { previousTurnId: PREV_TURN_ID },
+            }),
+            completed(0, assistantText("done")),
+            turnCompletedEv(),
+        ]);
+        expect(deriveTurnStatus(state)).toBe("completed");
+    });
+
+    it("rejects a request missing the contextRef when context is a reference", () => {
+        expectCorruption(
+            [
+                created({ context: { previousTurnId: PREV_TURN_ID } }),
+                requested(0, ["input"]),
+            ],
+            /contextRef inconsistent/,
+        );
+    });
+
+    it("rejects a request whose contextRef targets the wrong turn", () => {
+        expectCorruption(
+            [
+                created({ context: { previousTurnId: PREV_TURN_ID } }),
+                requested(0, ["input"], {
+                    contextRef: { previousTurnId: "some-other-turn" },
+                }),
+            ],
+            /contextRef inconsistent/,
+        );
+    });
+
+    it("rejects a contextRef when the turn context is inline", () => {
+        expectCorruption(
+            [
+                created(),
+                requested(0, ["input"], {
+                    contextRef: { previousTurnId: PREV_TURN_ID },
+                }),
+            ],
+            /contextRef but turn context is inline/,
+        );
+    });
+
+    it("requires a {context} ref before {input} when inline context is nonempty", () => {
+        const context = [
+            user("earlier"),
+            assistantCalls(toolCallPart("old1", "echo")),
+            toolMsg("old1", "echo"),
+        ];
+        const state = reduceTurn([
+            created({ context }),
+            requested(0, ["context", "input"]),
+            completed(0, assistantText("done")),
+            turnCompletedEv(),
+        ]);
+        expect(deriveTurnStatus(state)).toBe("completed");
+        expectCorruption(
+            [created({ context }), requested(0, ["input"])],
+            /references do not match/,
+        );
+    });
+
+    it("rejects a contextRef on a non-initial model call", () => {
+        expectCorruption(
+            [
+                created({ context: { previousTurnId: PREV_TURN_ID } }),
+                requested(0, ["input"], {
+                    contextRef: { previousTurnId: PREV_TURN_ID },
+                }),
+                completed(0, assistantCalls(toolCallPart("tc1", "echo"))),
+                invocation("tc1"),
+                result("tc1", "echo"),
+                requested(
+                    1,
+                    [
+                        "assistant:0",
+                        "toolResult:tc1",
+                    ],
+                    { contextRef: { previousTurnId: PREV_TURN_ID } },
+                ),
+            ],
+            /contextRef on a non-initial model call/,
+        );
+    });
+});
+
+describe("inherited agent snapshots", () => {
+    const inherited = {
+        agentId: "copilot",
+        model: { provider: "openai", model: "gpt-test" },
+        inheritedFrom: PREV_TURN_ID,
+    };
+
+    it("accepts inheritance referencing the context predecessor; identity arrives via invocation", () => {
+        const call0 = assistantCalls(toolCallPart("tc1", "echo"));
+        const state = reduceTurn([
+            created({
+                context: { previousTurnId: PREV_TURN_ID },
+                agent: { requested: { agentId: "copilot" }, resolved: inherited },
+            }),
+            requested(0, ["input"], { contextRef: { previousTurnId: PREV_TURN_ID } }),
+            completed(0, call0),
+        ]);
+        // No descriptor lookup without the concrete snapshot…
+        expect(state.toolCalls[0].toolId).toBeUndefined();
+        expect(state.toolCalls[0].execution).toBeUndefined();
+
+        // …until tool_invocation_requested supplies identity.
+        const withInvocation = reduceTurn([
+            created({
+                context: { previousTurnId: PREV_TURN_ID },
+                agent: { requested: { agentId: "copilot" }, resolved: inherited },
+            }),
+            requested(0, ["input"], { contextRef: { previousTurnId: PREV_TURN_ID } }),
+            completed(0, call0),
+            invocation("tc1"),
+            result("tc1", "echo"),
+        ]);
+        expect(withInvocation.toolCalls[0].toolId).toBe("tool.echo");
+        expect(withInvocation.toolCalls[0].execution).toBe("sync");
+    });
+
+    it("rejects an inherited snapshot on an inline-context turn", () => {
+        expectCorruption(
+            [
+                created({
+                    context: [],
+                    agent: { requested: { agentId: "copilot" }, resolved: inherited },
+                }),
+            ],
+            /inherited agent snapshot must reference the turn's context predecessor/,
+        );
+    });
+
+    it("rejects an inherited snapshot pointing at a different turn than the context", () => {
+        expectCorruption(
+            [
+                created({
+                    context: { previousTurnId: "some-other-turn" },
+                    agent: { requested: { agentId: "copilot" }, resolved: inherited },
+                }),
+            ],
+            /inherited agent snapshot must reference the turn's context predecessor/,
+        );
+    });
+});
+
+describe("suspension", () => {
+    it("accepts a snapshot matching pending permissions and async tools", () => {
+        const call0 = assistantCalls(
+            toolCallPart("tc1", "echo"),
+            toolCallPart("a1", "fetch"),
+        );
+        const state = reduceTurn([
+            created(),
+            requested(0, ["input"]),
+            completed(0, call0),
+            permRequired("tc1", "echo"),
+            invocation("a1", fetchTool),
+            suspendedEv([{ id: "tc1", name: "echo" }], [{ id: "a1", tool: fetchTool }]),
+        ]);
+        expect(state.suspension?.pendingPermissions).toHaveLength(1);
+        expect(state.suspension?.pendingAsyncTools).toHaveLength(1);
+        expect(deriveTurnStatus(state)).toBe("suspended");
+    });
+
+    it("replaces the snapshot as inputs arrive, one at a time", () => {
+        const call0 = assistantCalls(
+            toolCallPart("tc1", "echo"),
+            toolCallPart("a1", "fetch"),
+        );
+        const state = reduceTurn([
+            created(),
+            requested(0, ["input"]),
+            completed(0, call0),
+            permRequired("tc1", "echo"),
+            invocation("a1", fetchTool),
+            suspendedEv([{ id: "tc1", name: "echo" }], [{ id: "a1", tool: fetchTool }]),
+            result("a1", "fetch", "async", { data: 1 }),
+            suspendedEv([{ id: "tc1", name: "echo" }], []),
+        ]);
+        expect(state.suspension?.pendingAsyncTools).toHaveLength(0);
+        expect(outstandingPermissions(state)).toHaveLength(1);
+        expect(outstandingAsyncTools(state)).toHaveLength(0);
+    });
+
+    it("supports async results arriving in any order before the next model call", () => {
+        const call0 = assistantCalls(
+            toolCallPart("a1", "fetch"),
+            toolCallPart("a2", "fetch"),
+        );
+        const state = reduceTurn([
+            created(),
+            requested(0, ["input"]),
+            completed(0, call0),
+            invocation("a1", fetchTool),
+            invocation("a2", fetchTool),
+            suspendedEv([], [{ id: "a1", tool: fetchTool }, { id: "a2", tool: fetchTool }]),
+            result("a2", "fetch", "async", "second"),
+            suspendedEv([], [{ id: "a1", tool: fetchTool }]),
+            result("a1", "fetch", "async", "first"),
+            requested(1, [
+                "assistant:0",
+                "toolResult:a1",
+                "toolResult:a2",
+            ]),
+            completed(1, assistantText("done")),
+            turnCompletedEv(),
+        ]);
+        expect(deriveTurnStatus(state)).toBe("completed");
+    });
+
+    it("rejects a snapshot claiming already-resolved work", () => {
+        const call0 = assistantCalls(toolCallPart("tc1", "echo"));
+        expectCorruption(
+            [
+                created(),
+                requested(0, ["input"]),
+                completed(0, call0),
+                permRequired("tc1", "echo"),
+                permResolved("tc1", "allow"),
+                invocation("tc1"),
+                result("tc1", "echo"),
+                suspendedEv([{ id: "tc1", name: "echo" }], []),
+            ],
+            /suspension without pending external work/,
+        );
+    });
+
+    it("rejects a snapshot omitting pending work", () => {
+        const call0 = assistantCalls(
+            toolCallPart("tc1", "echo"),
+            toolCallPart("a1", "fetch"),
+        );
+        expectCorruption(
+            [
+                created(),
+                requested(0, ["input"]),
+                completed(0, call0),
+                permRequired("tc1", "echo"),
+                invocation("a1", fetchTool),
+                suspendedEv([{ id: "tc1", name: "echo" }], []),
+            ],
+            /suspension snapshot inconsistent/,
+        );
+    });
+
+    it("rejects suspension while a model call is unsettled", () => {
+        expectCorruption(
+            [
+                created(),
+                requested(0, ["input"]),
+                suspendedEv([{ id: "tc1", name: "echo" }], []),
+            ],
+            /suspension while a model call is unsettled/,
+        );
+    });
+});
+
+describe("recovery-shaped histories", () => {
+    it("accepts an interrupted model call closed and re-issued (§23 fix)", () => {
+        const state = reduceTurn([
+            created(),
+            requested(0, ["input"]),
+            callFailed(0, "interrupted by process restart"),
+            requested(1, []),
+            completed(1, assistantText("done")),
+            turnCompletedEv(),
+        ]);
+        expect(state.modelCalls[0].error).toMatch(/interrupted/);
+        expect(state.modelCalls[1].response).toEqual(assistantText("done"));
+        expect(deriveTurnStatus(state)).toBe("completed");
+    });
+
+    it("re-issued model calls count against maxModelCalls", () => {
+        expectCorruption(
+            [
+                created({
+                    config: { autoPermission: false, humanAvailable: true, maxModelCalls: 1 },
+                }),
+                requested(0, ["input"]),
+                callFailed(0, "interrupted"),
+                requested(1, []),
+            ],
+            /exceeds maxModelCalls/,
+        );
+    });
+
+    it("accepts an interrupted sync tool closed with an indeterminate runtime result, turn continuing (§23 fix)", () => {
+        const call0 = assistantCalls(toolCallPart("tc1", "echo"));
+        const state = reduceTurn([
+            created(),
+            requested(0, ["input"]),
+            completed(0, call0),
+            invocation("tc1"),
+            result(
+                "tc1",
+                "echo",
+                "runtime",
+                "Tool execution was interrupted; its outcome is unknown and it was not retried.",
+                true,
+            ),
+            requested(1, ["assistant:0", "toolResult:tc1"]),
+            completed(1, assistantText("done")),
+            turnCompletedEv(),
+        ]);
+        expect(state.toolCalls[0].result?.source).toBe("runtime");
+        expect(state.terminal?.type).toBe("turn_completed");
+    });
+
+    it("accepts cancellation with synthetic runtime results for unresolved calls", () => {
+        const call0 = assistantCalls(toolCallPart("a1", "fetch"));
+        const state = reduceTurn([
+            created(),
+            requested(0, ["input"]),
+            completed(0, call0),
+            invocation("a1", fetchTool),
+            suspendedEv([], [{ id: "a1", tool: fetchTool }]),
+            result("a1", "fetch", "runtime", "Cancelled", true),
+            turnCancelledEv("user stop"),
+        ]);
+        expect(state.terminal?.type).toBe("turn_cancelled");
+        expect(deriveTurnStatus(state)).toBe("cancelled");
+    });
+
+    it("accepts a live model failure closing the turn", () => {
+        const state = reduceTurn([
+            created(),
+            requested(0, ["input"]),
+            callFailed(0),
+            turnFailedEv("provider exploded"),
+        ]);
+        expect(deriveTurnStatus(state)).toBe("failed");
+    });
+
+    it("accepts model-call-limit exhaustion with a machine-readable code", () => {
+        const call0 = assistantCalls(toolCallPart("tc1", "echo"));
+        const state = reduceTurn([
+            created({
+                config: { autoPermission: false, humanAvailable: true, maxModelCalls: 1 },
+            }),
+            requested(0, ["input"]),
+            completed(0, call0),
+            invocation("tc1"),
+            result("tc1", "echo"),
+            turnFailedEv("model call limit reached", MODEL_CALL_LIMIT_ERROR_CODE),
+        ]);
+        expect(state.terminal?.type).toBe("turn_failed");
+        expect(
+            state.terminal?.type === "turn_failed" ? state.terminal.code : undefined,
+        ).toBe(MODEL_CALL_LIMIT_ERROR_CODE);
+    });
+});
+
+describe("invariants", () => {
+    it("rejects an empty log", () => {
+        expectCorruption([], /empty/);
+    });
+
+    it("rejects a log not starting with turn_created", () => {
+        expectCorruption([requested(0, ["input"])], /first event must be turn_created/);
+    });
+
+    it("rejects duplicate turn_created", () => {
+        expectCorruption([created(), created()], /duplicate turn_created/);
+    });
+
+    it("rejects mismatched turn ids", () => {
+        expectCorruption(
+            [created(), { ...requested(0, ["input"]), turnId: "other" }],
+            /does not match turn/,
+        );
+    });
+
+    it("rejects unsupported schema versions", () => {
+        const bad = {
+            ...created(),
+            schemaVersion: 2,
+        } as unknown as TEvent;
+        expectCorruption([bad], /unsupported turn schema version/);
+    });
+
+    it("rejects unknown event types", () => {
+        const bad = {
+            type: "wat",
+            turnId: TURN_ID,
+            ts: TS,
+        } as unknown as TEvent;
+        expectCorruption([created(), bad], /unknown turn event type/);
+    });
+
+    it("rejects out-of-order model call indices", () => {
+        expectCorruption(
+            [created(), requested(1, [])],
+            /out of order/,
+        );
+    });
+
+    it("rejects a reused model call index", () => {
+        expectCorruption(
+            [
+                created(),
+                requested(0, ["input"]),
+                completed(0, assistantText("a")),
+                requested(0, ["input"]),
+            ],
+            /out of order/,
+        );
+    });
+
+    it("rejects concurrent unresolved model requests", () => {
+        expectCorruption(
+            [created(), requested(0, ["input"]), requested(1, [])],
+            /concurrent unresolved model call requests/,
+        );
+    });
+
+    it("rejects completion without a matching request", () => {
+        expectCorruption(
+            [created(), completed(0, assistantText("a"))],
+            /without matching request/,
+        );
+    });
+
+    it("rejects failure without a matching request", () => {
+        expectCorruption([created(), callFailed(0)], /without matching request/);
+    });
+
+    it("rejects duplicate model call completion", () => {
+        expectCorruption(
+            [
+                created(),
+                requested(0, ["input"]),
+                completed(0, assistantText("a")),
+                completed(0, assistantText("b")),
+            ],
+            /duplicate settlement/,
+        );
+    });
+
+    it("rejects completion after failure of the same call", () => {
+        expectCorruption(
+            [
+                created(),
+                requested(0, ["input"]),
+                callFailed(0),
+                completed(0, assistantText("a")),
+            ],
+            /duplicate settlement/,
+        );
+    });
+
+    it("rejects the next model call while tool calls are unresolved", () => {
+        const call0 = assistantCalls(toolCallPart("tc1", "echo"));
+        expectCorruption(
+            [
+                created(),
+                requested(0, ["input"]),
+                completed(0, call0),
+                requested(1, ["assistant:0"]),
+            ],
+            /while tool calls are unresolved/,
+        );
+    });
+
+    it("rejects a model call past the budget", () => {
+        const call0 = assistantCalls(toolCallPart("tc1", "echo"));
+        expectCorruption(
+            [
+                created({
+                    config: { autoPermission: false, humanAvailable: true, maxModelCalls: 1 },
+                }),
+                requested(0, ["input"]),
+                completed(0, call0),
+                invocation("tc1"),
+                result("tc1", "echo"),
+                requested(1, ["assistant:0", "toolResult:tc1"]),
+            ],
+            /exceeds maxModelCalls/,
+        );
+    });
+
+    it("rejects duplicate tool call ids within one response", () => {
+        expectCorruption(
+            [
+                created(),
+                requested(0, ["input"]),
+                completed(
+                    0,
+                    assistantCalls(toolCallPart("tc1", "echo"), toolCallPart("tc1", "echo")),
+                ),
+            ],
+            /duplicate tool call id/,
+        );
+    });
+
+    it("rejects duplicate tool call ids across responses", () => {
+        const call0 = assistantCalls(toolCallPart("tc1", "echo"));
+        expectCorruption(
+            [
+                created(),
+                requested(0, ["input"]),
+                completed(0, call0),
+                invocation("tc1"),
+                result("tc1", "echo"),
+                requested(1, ["assistant:0", "toolResult:tc1"]),
+                completed(1, assistantCalls(toolCallPart("tc1", "echo"))),
+            ],
+            /duplicate tool call id/,
+        );
+    });
+
+    it("rejects request references whose tool-result order differs from the batch", () => {
+        const call0 = assistantCalls(
+            toolCallPart("tc1", "echo"),
+            toolCallPart("tc2", "echo"),
+        );
+        expectCorruption(
+            [
+                created(),
+                requested(0, ["input"]),
+                completed(0, call0),
+                invocation("tc1"),
+                result("tc1", "echo"),
+                invocation("tc2"),
+                result("tc2", "echo"),
+                requested(1, [
+                    "assistant:0",
+                    "toolResult:tc2",
+                    "toolResult:tc1",
+                ]),
+            ],
+            /references do not match/,
+        );
+    });
+
+    it("rejects permission records targeting unknown tool calls", () => {
+        expectCorruption(
+            [created(), requested(0, ["input"]), completed(0, assistantText("a")), permRequired("ghost", "echo")],
+            /unknown tool call/,
+        );
+    });
+
+    it("rejects duplicate permission requirements", () => {
+        const call0 = assistantCalls(toolCallPart("tc1", "echo"));
+        expectCorruption(
+            [
+                created(),
+                requested(0, ["input"]),
+                completed(0, call0),
+                permRequired("tc1", "echo"),
+                permRequired("tc1", "echo"),
+            ],
+            /duplicate permission requirement/,
+        );
+    });
+
+    it("rejects classification without a requirement", () => {
+        const call0 = assistantCalls(toolCallPart("tc1", "echo"));
+        expectCorruption(
+            [
+                created(),
+                requested(0, ["input"]),
+                completed(0, call0),
+                permClassified("tc1", "allow"),
+            ],
+            /classification without permission requirement/,
+        );
+    });
+
+    it("rejects resolution without a requirement", () => {
+        const call0 = assistantCalls(toolCallPart("tc1", "echo"));
+        expectCorruption(
+            [
+                created(),
+                requested(0, ["input"]),
+                completed(0, call0),
+                permResolved("tc1", "allow"),
+            ],
+            /resolution without requirement/,
+        );
+    });
+
+    it("rejects conflicting effective permission decisions", () => {
+        const call0 = assistantCalls(toolCallPart("tc1", "echo"));
+        expectCorruption(
+            [
+                created(),
+                requested(0, ["input"]),
+                completed(0, call0),
+                permRequired("tc1", "echo"),
+                permResolved("tc1", "allow"),
+                permResolved("tc1", "deny"),
+            ],
+            /conflicting permission decisions/,
+        );
+    });
+
+    it("rejects invocation while permission is pending", () => {
+        const call0 = assistantCalls(toolCallPart("tc1", "echo"));
+        expectCorruption(
+            [
+                created(),
+                requested(0, ["input"]),
+                completed(0, call0),
+                permRequired("tc1", "echo"),
+                invocation("tc1"),
+            ],
+            /invocation without permission allowance/,
+        );
+    });
+
+    it("rejects invocation of a denied tool call", () => {
+        const call0 = assistantCalls(toolCallPart("tc1", "echo"));
+        expectCorruption(
+            [
+                created(),
+                requested(0, ["input"]),
+                completed(0, call0),
+                permRequired("tc1", "echo"),
+                permResolved("tc1", "deny"),
+                invocation("tc1"),
+            ],
+            /invocation without permission allowance/,
+        );
+    });
+
+    it("rejects duplicate invocations", () => {
+        const call0 = assistantCalls(toolCallPart("tc1", "echo"));
+        expectCorruption(
+            [
+                created(),
+                requested(0, ["input"]),
+                completed(0, call0),
+                invocation("tc1"),
+                invocation("tc1"),
+            ],
+            /duplicate tool invocation/,
+        );
+    });
+
+    it("rejects invocations whose execution mode contradicts the snapshot", () => {
+        const call0 = assistantCalls(toolCallPart("tc1", "echo"));
+        expectCorruption(
+            [
+                created(),
+                requested(0, ["input"]),
+                completed(0, call0),
+                invocation("tc1", echoTool, { execution: "async" }),
+            ],
+            /execution mismatch/,
+        );
+    });
+
+    it("rejects progress without invocation", () => {
+        const call0 = assistantCalls(toolCallPart("tc1", "echo"));
+        expectCorruption(
+            [created(), requested(0, ["input"]), completed(0, call0), progress("tc1")],
+            /progress without invocation/,
+        );
+    });
+
+    it("rejects progress after a terminal tool result", () => {
+        const call0 = assistantCalls(toolCallPart("tc1", "echo"));
+        expectCorruption(
+            [
+                created(),
+                requested(0, ["input"]),
+                completed(0, call0),
+                invocation("tc1"),
+                result("tc1", "echo"),
+                progress("tc1"),
+            ],
+            /progress after terminal result/,
+        );
+    });
+
+    it("rejects duplicate tool results", () => {
+        const call0 = assistantCalls(toolCallPart("tc1", "echo"));
+        expectCorruption(
+            [
+                created(),
+                requested(0, ["input"]),
+                completed(0, call0),
+                invocation("tc1"),
+                result("tc1", "echo"),
+                result("tc1", "echo"),
+            ],
+            /duplicate tool result/,
+        );
+    });
+
+    it("rejects sync-sourced results without invocation", () => {
+        const call0 = assistantCalls(toolCallPart("tc1", "echo"));
+        expectCorruption(
+            [created(), requested(0, ["input"]), completed(0, call0), result("tc1", "echo", "sync")],
+            /sync tool result without invocation/,
+        );
+    });
+
+    it("rejects async results for sync tools", () => {
+        const call0 = assistantCalls(toolCallPart("tc1", "echo"));
+        expectCorruption(
+            [
+                created(),
+                requested(0, ["input"]),
+                completed(0, call0),
+                invocation("tc1"),
+                result("tc1", "echo", "async"),
+            ],
+            /result source mismatch/,
+        );
+    });
+
+    it("rejects step events without a matching open call", () => {
+        expectCorruption([created(), stepEvent(0)], /without matching model call request/);
+        expectCorruption(
+            [
+                created(),
+                requested(0, ["input"]),
+                completed(0, assistantText("a")),
+                stepEvent(0),
+            ],
+            /after model call 0 settled/,
+        );
+    });
+
+    it("rejects completion while tool calls remain unresolved", () => {
+        const call0 = assistantCalls(toolCallPart("tc1", "echo"));
+        expectCorruption(
+            [created(), requested(0, ["input"]), completed(0, call0), turnCompletedEv()],
+            /completion while tool calls lack terminal results/,
+        );
+    });
+
+    it("rejects completion when the final response has tool calls", () => {
+        const call0 = assistantCalls(toolCallPart("tc1", "echo"));
+        expectCorruption(
+            [
+                created(),
+                requested(0, ["input"]),
+                completed(0, call0),
+                invocation("tc1"),
+                result("tc1", "echo"),
+                turnCompletedEv(),
+            ],
+            /final response has tool calls/,
+        );
+    });
+
+    it("rejects completion without any completed model response", () => {
+        expectCorruption([created(), turnCompletedEv()], /without a completed model response/);
+    });
+
+    it("rejects terminal failure while tool calls remain unresolved", () => {
+        const call0 = assistantCalls(toolCallPart("tc1", "echo"));
+        expectCorruption(
+            [created(), requested(0, ["input"]), completed(0, call0), turnFailedEv()],
+            /failure while tool calls lack terminal results/,
+        );
+    });
+
+    it("rejects terminal events while a model call is unsettled", () => {
+        expectCorruption(
+            [created(), requested(0, ["input"]), turnCancelledEv()],
+            /cancellation while a model call is unsettled/,
+        );
+    });
+
+    it("rejects any event after a terminal event", () => {
+        const base = [
+            created(),
+            requested(0, ["input"]),
+            completed(0, assistantText("a")),
+        ];
+        for (const terminal of [turnCompletedEv(), turnFailedEv(), turnCancelledEv()]) {
+            expectCorruption(
+                [...base, terminal, stepEvent(0)],
+                /event after terminal turn event/,
+            );
+        }
+    });
+
+    it("rejects multiple terminal events", () => {
+        expectCorruption(
+            [
+                created(),
+                requested(0, ["input"]),
+                completed(0, assistantText("a")),
+                turnCompletedEv(),
+                turnFailedEv(),
+            ],
+            /event after terminal turn event/,
+        );
+    });
+});
+
+describe("derivations", () => {
+    it("derives suspended for pending permissions and idle otherwise", () => {
+        const call0 = assistantCalls(toolCallPart("tc1", "echo"));
+        const pending = reduceTurn([
+            created(),
+            requested(0, ["input"]),
+            completed(0, call0),
+            permRequired("tc1", "echo"),
+            suspendedEv([{ id: "tc1", name: "echo" }], []),
+        ]);
+        expect(deriveTurnStatus(pending)).toBe("suspended");
+
+        const idle = reduceTurn([created(), requested(0, ["input"]), completed(0, call0)]);
+        expect(deriveTurnStatus(idle)).toBe("idle");
+    });
+
+    it("builds the turn transcript in source order with serialized results", () => {
+        const call0 = assistantCalls(
+            toolCallPart("tc1", "echo"),
+            toolCallPart("tc2", "echo"),
+        );
+        const state = reduceTurn([
+            created(),
+            requested(0, ["input"]),
+            completed(0, call0),
+            invocation("tc1"),
+            invocation("tc2"),
+            result("tc2", "echo", "sync", { n: 2 }),
+            result("tc1", "echo", "sync", "plain text"),
+            requested(1, [
+                "assistant:0",
+                "toolResult:tc1",
+                "toolResult:tc2",
+            ]),
+            completed(1, assistantText("done")),
+            turnCompletedEv(),
+        ]);
+        expect(turnTranscript(state)).toEqual([
+            user("hello"),
+            call0,
+            { role: "tool", content: "plain text", toolCallId: "tc1", toolName: "echo" },
+            { role: "tool", content: '{"n":2}', toolCallId: "tc2", toolName: "echo" },
+            assistantText("done"),
+        ]);
+    });
+
+    it("omits failed model calls from the transcript", () => {
+        const state = reduceTurn([
+            created(),
+            requested(0, ["input"]),
+            callFailed(0, "interrupted"),
+            requested(1, []),
+            completed(1, assistantText("done")),
+            turnCompletedEv(),
+        ]);
+        expect(turnTranscript(state)).toEqual([user("hello"), assistantText("done")]);
+    });
+
+    it("transcript excludes the context prefix", () => {
+        const state = reduceTurn([
+            created({ context: { previousTurnId: PREV_TURN_ID } }),
+            requested(0, ["input"], {
+                contextRef: { previousTurnId: PREV_TURN_ID },
+            }),
+            completed(0, assistantText("done")),
+            turnCompletedEv(),
+        ]);
+        expect(turnTranscript(state)[0]).toEqual(user("hello"));
+        expect(turnTranscript(state)).toHaveLength(2);
+    });
+
+    it("transcript throws on unresolved tool calls", () => {
+        const call0 = assistantCalls(toolCallPart("tc1", "echo"));
+        const state = reduceTurn([
+            created(),
+            requested(0, ["input"]),
+            completed(0, call0),
+        ]);
+        expect(() => turnTranscript(state)).toThrowError(/unresolved/);
+    });
+});
diff --git a/apps/x/packages/shared/src/turns.ts b/apps/x/packages/shared/src/turns.ts
new file mode 100644
index 00000000..df9a65f4
--- /dev/null
+++ b/apps/x/packages/shared/src/turns.ts
@@ -0,0 +1,1111 @@
+import { z } from "zod";
+import {
+    AssistantMessage,
+    ToolCallPart,
+    ToolMessage,
+    UserMessage,
+} from "./message.js";
+
+// Durable turn contract for the turn runtime (see
+// packages/core/docs/turn-runtime-design.md). This module is the
+// cross-boundary source of truth shared by core and renderer: event schemas,
+// the pure reducer, and pure derivations over the reduced state. It must
+// stay free of I/O and node-only imports so the renderer can consume it
+// directly.
+
+export type JsonValue = z.infer<ReturnType<typeof z.json>>;
+
+export const DEFAULT_MAX_MODEL_CALLS = 20;
+export const MODEL_CALL_LIMIT_ERROR_CODE = "model-call-limit";
+
+// ---------------------------------------------------------------------------
+// Agent snapshot
+// ---------------------------------------------------------------------------
+
+export const ModelDescriptor = z.object({
+    provider: z.string(),
+    model: z.string(),
+});
+
+export const RequestedAgent = z.object({
+    agentId: z.string(),
+    overrides: z
+        .object({
+            model: ModelDescriptor.optional(),
+            // Opaque composition hints interpreted by the agent resolver
+            // (e.g. work-dir id, voice/search/code modes). Persisted verbatim
+            // for audit. The resolver decides which keys affect the system
+            // prompt; keeping prompt-affecting inputs session-sticky is what
+            // preserves provider prefix caching across turns.
+            composition: z.json().optional(),
+        })
+        .optional(),
+});
+
+export const ToolDescriptor = z.object({
+    toolId: z.string(),
+    name: z.string(),
+    description: z.string(),
+    inputSchema: z.json(),
+    execution: z.enum(["sync", "async"]),
+    requiresHuman: z.boolean(),
+});
+
+export const ResolvedAgent = z.object({
+    agentId: z.string(),
+    systemPrompt: z.string(),
+    model: ModelDescriptor,
+    tools: z.array(ToolDescriptor),
+});
+
+// Session turns whose system prompt and tool set are byte-identical to the
+// previous turn's materialized snapshot inherit it by reference instead of
+// re-persisting ~tens of KB per turn (same mechanism as context references).
+// The model stays concrete: it is tiny, the session index denormalizes it,
+// and a mid-session model switch must not block inheritance. Written only
+// when equality holds at creation; materialization walks inheritedFrom to
+// the nearest concrete snapshot.
+export const InheritedAgentSnapshot = z.object({
+    agentId: z.string(),
+    model: ModelDescriptor,
+    inheritedFrom: z.string(),
+});
+
+export const ResolvedAgentSnapshot = z.union([
+    ResolvedAgent,
+    InheritedAgentSnapshot,
+]);
+
+export function isInheritedSnapshot(
+    resolved: z.infer<typeof ResolvedAgentSnapshot>,
+): resolved is z.infer<typeof InheritedAgentSnapshot> {
+    return "inheritedFrom" in resolved;
+}
+
+// ---------------------------------------------------------------------------
+// Context
+// ---------------------------------------------------------------------------
+
+// Context excludes system-role messages: the resolved agent owns the single
+// authoritative system prompt.
+export const ConversationMessage = z.discriminatedUnion("role", [
+    UserMessage,
+    AssistantMessage,
+    ToolMessage,
+]);
+
+// A reference points at the immediately preceding turn; its materialized
+// value is that turn's transcript (context + input + produced messages).
+// Inline arrays are used by standalone turns and by callers that assemble
+// context themselves. Resolution is a runtime concern; the reducer treats
+// context as opaque.
+export const TurnContextRef = z.object({
+    previousTurnId: z.string(),
+});
+
+export const TurnContext = z.union([
+    TurnContextRef,
+    z.array(ConversationMessage),
+]);
+
+// ---------------------------------------------------------------------------
+// Usage
+// ---------------------------------------------------------------------------
+
+export const TurnUsage = z.object({
+    inputTokens: z.number().optional(),
+    outputTokens: z.number().optional(),
+    totalTokens: z.number().optional(),
+    reasoningTokens: z.number().optional(),
+    cachedInputTokens: z.number().optional(),
+});
+
+// ---------------------------------------------------------------------------
+// Durable events
+// ---------------------------------------------------------------------------
+
+export const TurnCreated = z.object({
+    type: z.literal("turn_created"),
+    schemaVersion: z.literal(1),
+    turnId: z.string(),
+    ts: z.string(),
+    sessionId: z.string().nullable(),
+    agent: z.object({
+        requested: RequestedAgent,
+        resolved: ResolvedAgentSnapshot,
+    }),
+    context: TurnContext,
+    input: UserMessage,
+    config: z.object({
+        autoPermission: z.boolean(),
+        humanAvailable: z.boolean(),
+        maxModelCalls: z.number().int().positive(),
+    }),
+});
+
+// A model request is a list of REFERENCES into the turn's own events; every
+// referenced byte exists exactly once in the file. The request records only
+// what is NEW since the previous model call:
+//   call 0:  [{context}?, {input}]      (context only when inline and nonempty;
+//                                        cross-turn prefixes ride contextRef)
+//   call N:  [{assistant: N-1}, ...that batch's toolResults in source order]
+//   re-issue after an interrupted call: []
+// The system prompt and tool set are NOT repeated here — they are byte-
+// identical to turn_created.agent.resolved by construction. The exact
+// provider payload is rebuilt deterministically by the request composer
+// (core), which is the same code path the loop sends through.
+// Compact string refs so raw JSONL reads naturally:
+//   "context" | "input" | "assistant:<modelCallIndex>" | "toolResult:<toolCallId>"
+export const ModelRequestMessageRef = z
+    .string()
+    .regex(/^(context|input|assistant:\d+|toolResult:.+)$/);
+
+export type ParsedRequestRef =
+    | { kind: "context" }
+    | { kind: "input" }
+    | { kind: "assistant"; modelCallIndex: number }
+    | { kind: "toolResult"; toolCallId: string };
+
+export const assistantRef = (modelCallIndex: number): string =>
+    `assistant:${modelCallIndex}`;
+export const toolResultRef = (toolCallId: string): string =>
+    `toolResult:${toolCallId}`;
+
+export function parseRequestRef(ref: string): ParsedRequestRef {
+    if (ref === "context" || ref === "input") {
+        return { kind: ref };
+    }
+    if (ref.startsWith("assistant:")) {
+        const modelCallIndex = Number(ref.slice("assistant:".length));
+        if (!Number.isInteger(modelCallIndex) || modelCallIndex < 0) {
+            throw new Error(`malformed request ref: ${ref}`);
+        }
+        return { kind: "assistant", modelCallIndex };
+    }
+    if (ref.startsWith("toolResult:")) {
+        return { kind: "toolResult", toolCallId: ref.slice("toolResult:".length) };
+    }
+    throw new Error(`malformed request ref: ${ref}`);
+}
+
+export const ModelRequest = z.object({
+    contextRef: TurnContextRef.optional(),
+    messages: z.array(ModelRequestMessageRef),
+    parameters: z.record(z.string(), z.json()),
+});
+
+export const ModelCallRequested = z.object({
+    type: z.literal("model_call_requested"),
+    turnId: z.string(),
+    ts: z.string(),
+    modelCallIndex: z.number().int().nonnegative(),
+    request: ModelRequest,
+});
+
+// Normalized provider step events kept for debugging. Raw text/reasoning
+// deltas are stream-only and never appear here.
+export const DurableLlmStepStreamEvent = z.discriminatedUnion("type", [
+    z.object({ type: z.literal("text_start") }),
+    z.object({ type: z.literal("text_end"), text: z.string() }),
+    z.object({ type: z.literal("reasoning_start") }),
+    z.object({ type: z.literal("reasoning_end"), text: z.string() }),
+    z.object({ type: z.literal("tool_call"), toolCall: ToolCallPart }),
+    z.object({
+        type: z.literal("finish_step"),
+        finishReason: z.string(),
+        usage: TurnUsage.optional(),
+        providerMetadata: z.json().optional(),
+    }),
+    z.object({ type: z.literal("provider_error"), error: z.string() }),
+]);
+
+export const ModelStepEvent = z.object({
+    type: z.literal("model_step_event"),
+    turnId: z.string(),
+    ts: z.string(),
+    modelCallIndex: z.number().int().nonnegative(),
+    event: DurableLlmStepStreamEvent,
+});
+
+export const ModelCallCompleted = z.object({
+    type: z.literal("model_call_completed"),
+    turnId: z.string(),
+    ts: z.string(),
+    modelCallIndex: z.number().int().nonnegative(),
+    message: AssistantMessage,
+    finishReason: z.string(),
+    usage: TurnUsage,
+    providerMetadata: z.json().optional(),
+});
+
+export const ModelCallFailed = z.object({
+    type: z.literal("model_call_failed"),
+    turnId: z.string(),
+    ts: z.string(),
+    modelCallIndex: z.number().int().nonnegative(),
+    error: z.string(),
+});
+
+export const ToolPermissionRequired = z.object({
+    type: z.literal("tool_permission_required"),
+    turnId: z.string(),
+    ts: z.string(),
+    toolCallId: z.string(),
+    toolName: z.string(),
+    request: z.json(),
+    checkerError: z.string().optional(),
+});
+
+export const ToolPermissionClassified = z.object({
+    type: z.literal("tool_permission_classified"),
+    turnId: z.string(),
+    ts: z.string(),
+    toolCallId: z.string(),
+    decision: z.enum(["allow", "deny", "defer"]),
+    reason: z.string(),
+});
+
+export const ToolPermissionClassificationFailed = z.object({
+    type: z.literal("tool_permission_classification_failed"),
+    turnId: z.string(),
+    ts: z.string(),
+    toolCallIds: z.array(z.string()),
+    error: z.string(),
+});
+
+// The only effective execution decision; classifier records are provenance.
+export const ToolPermissionResolved = z.object({
+    type: z.literal("tool_permission_resolved"),
+    turnId: z.string(),
+    ts: z.string(),
+    toolCallId: z.string(),
+    decision: z.enum(["allow", "deny"]),
+    source: z.enum(["classifier", "human", "human_unavailable"]),
+    reason: z.string().optional(),
+    metadata: z.json().optional(),
+});
+
+export const ToolInvocationRequested = z.object({
+    type: z.literal("tool_invocation_requested"),
+    turnId: z.string(),
+    ts: z.string(),
+    toolCallId: z.string(),
+    toolId: z.string(),
+    toolName: z.string(),
+    execution: z.enum(["sync", "async"]),
+    input: z.json(),
+});
+
+export const ToolProgress = z.object({
+    type: z.literal("tool_progress"),
+    turnId: z.string(),
+    ts: z.string(),
+    toolCallId: z.string(),
+    source: z.enum(["sync", "async"]),
+    progress: z.json(),
+});
+
+export const ToolResultData = z.object({
+    output: z.json(),
+    isError: z.boolean(),
+    metadata: z.json().optional(),
+});
+
+// `runtime` results cover permission denial, unknown tools, unusable calls,
+// human unavailability, cancellation, and interrupted sync execution. A
+// result may exist without an invocation when execution was rejected before
+// dispatch.
+export const ToolResult = z.object({
+    type: z.literal("tool_result"),
+    turnId: z.string(),
+    ts: z.string(),
+    toolCallId: z.string(),
+    toolName: z.string(),
+    source: z.enum(["sync", "async", "runtime"]),
+    result: ToolResultData,
+});
+
+export const TurnSuspended = z.object({
+    type: z.literal("turn_suspended"),
+    turnId: z.string(),
+    ts: z.string(),
+    pendingPermissions: z.array(
+        z.object({
+            toolCallId: z.string(),
+            toolName: z.string(),
+            request: z.json(),
+        }),
+    ),
+    pendingAsyncTools: z.array(
+        z.object({
+            toolCallId: z.string(),
+            toolId: z.string(),
+            toolName: z.string(),
+            input: z.json(),
+        }),
+    ),
+    usage: TurnUsage,
+});
+
+export const TurnCompleted = z.object({
+    type: z.literal("turn_completed"),
+    turnId: z.string(),
+    ts: z.string(),
+    output: AssistantMessage,
+    finishReason: z.string(),
+    usage: TurnUsage,
+});
+
+export const TurnFailed = z.object({
+    type: z.literal("turn_failed"),
+    turnId: z.string(),
+    ts: z.string(),
+    error: z.string(),
+    // Machine-readable discriminator for failures callers must tell apart;
+    // MODEL_CALL_LIMIT_ERROR_CODE is defined by the spec.
+    code: z.string().optional(),
+    usage: TurnUsage,
+});
+
+export const TurnCancelled = z.object({
+    type: z.literal("turn_cancelled"),
+    turnId: z.string(),
+    ts: z.string(),
+    reason: z.string().optional(),
+    usage: TurnUsage,
+});
+
+export const TurnEvent = z.discriminatedUnion("type", [
+    TurnCreated,
+    ModelCallRequested,
+    ModelStepEvent,
+    ModelCallCompleted,
+    ModelCallFailed,
+    ToolPermissionRequired,
+    ToolPermissionClassified,
+    ToolPermissionClassificationFailed,
+    ToolPermissionResolved,
+    ToolInvocationRequested,
+    ToolProgress,
+    ToolResult,
+    TurnSuspended,
+    TurnCompleted,
+    TurnFailed,
+    TurnCancelled,
+]);
+
+// ---------------------------------------------------------------------------
+// Ephemeral stream-only deltas (never persisted)
+// ---------------------------------------------------------------------------
+
+export type TextDelta = {
+    type: "text_delta";
+    turnId: string;
+    modelCallIndex: number;
+    delta: string;
+};
+
+export type ReasoningDelta = {
+    type: "reasoning_delta";
+    turnId: string;
+    modelCallIndex: number;
+    delta: string;
+};
+
+export type TurnStreamEvent =
+    | z.infer<typeof TurnEvent>
+    | TextDelta
+    | ReasoningDelta;
+
+// ---------------------------------------------------------------------------
+// Derived turn state
+// ---------------------------------------------------------------------------
+
+export class TurnCorruptionError extends Error {
+    constructor(message: string) {
+        super(message);
+        this.name = "TurnCorruptionError";
+    }
+}
+
+export interface ModelCallState {
+    index: number;
+    request: z.infer<typeof ModelRequest>;
+    stepEvents: Array<z.infer<typeof DurableLlmStepStreamEvent>>;
+    response?: z.infer<typeof AssistantMessage>;
+    finishReason?: string;
+    usage?: z.infer<typeof TurnUsage>;
+    providerMetadata?: JsonValue;
+    error?: string;
+}
+
+export interface ToolCallState {
+    modelCallIndex: number;
+    order: number;
+    toolCallId: string;
+    toolName: string;
+    input: unknown;
+    toolId?: string;
+    execution?: "sync" | "async";
+    permission?: {
+        required: z.infer<typeof ToolPermissionRequired>;
+        classification?: z.infer<typeof ToolPermissionClassified>;
+        // Set when a tool_permission_classification_failed event named this
+        // call; such calls are treated as defer and never re-classified.
+        classificationFailed?: boolean;
+        resolved?: z.infer<typeof ToolPermissionResolved>;
+    };
+    invocation?: z.infer<typeof ToolInvocationRequested>;
+    progress: Array<z.infer<typeof ToolProgress>>;
+    result?: z.infer<typeof ToolResult>;
+}
+
+export interface TurnState {
+    definition: z.infer<typeof TurnCreated>;
+    modelCalls: ModelCallState[];
+    toolCalls: ToolCallState[];
+    suspension?: z.infer<typeof TurnSuspended>;
+    terminal?:
+        | z.infer<typeof TurnCompleted>
+        | z.infer<typeof TurnFailed>
+        | z.infer<typeof TurnCancelled>;
+    usage: z.infer<typeof TurnUsage>;
+}
+
+function fail(message: string): never {
+    throw new TurnCorruptionError(message);
+}
+
+function isContextRef(
+    context: z.infer<typeof TurnContext>,
+): context is z.infer<typeof TurnContextRef> {
+    return !Array.isArray(context);
+}
+
+function findToolCall(state: TurnState, toolCallId: string): ToolCallState {
+    const toolCall = state.toolCalls.find(
+        (tc) => tc.toolCallId === toolCallId,
+    );
+    if (!toolCall) {
+        fail(`event targets unknown tool call: ${toolCallId}`);
+    }
+    return toolCall;
+}
+
+function openModelCall(state: TurnState): ModelCallState | undefined {
+    const last = state.modelCalls[state.modelCalls.length - 1];
+    if (last && last.response === undefined && last.error === undefined) {
+        return last;
+    }
+    return undefined;
+}
+
+function batchToolCalls(state: TurnState, modelCallIndex: number): ToolCallState[] {
+    return state.toolCalls
+        .filter((tc) => tc.modelCallIndex === modelCallIndex)
+        .sort((a, b) => a.order - b.order);
+}
+
+function addUsage(
+    total: z.infer<typeof TurnUsage>,
+    usage: z.infer<typeof TurnUsage>,
+): void {
+    const keys = [
+        "inputTokens",
+        "outputTokens",
+        "totalTokens",
+        "reasoningTokens",
+        "cachedInputTokens",
+    ] as const;
+    for (const key of keys) {
+        const value = usage[key];
+        if (value !== undefined) {
+            total[key] = (total[key] ?? 0) + value;
+        }
+    }
+}
+
+function applyModelCallRequested(
+    state: TurnState,
+    event: z.infer<typeof ModelCallRequested>,
+): void {
+    const expectedIndex = state.modelCalls.length;
+    if (event.modelCallIndex !== expectedIndex) {
+        fail(
+            `model call index ${event.modelCallIndex} out of order; expected ${expectedIndex}`,
+        );
+    }
+    if (expectedIndex >= state.definition.config.maxModelCalls) {
+        fail(
+            `model call index ${event.modelCallIndex} exceeds maxModelCalls ${state.definition.config.maxModelCalls}`,
+        );
+    }
+    if (openModelCall(state)) {
+        fail("concurrent unresolved model call requests");
+    }
+    const unresolved = state.toolCalls.filter((tc) => !tc.result);
+    if (unresolved.length > 0) {
+        fail(
+            `model call requested while tool calls are unresolved: ${unresolved
+                .map((tc) => tc.toolCallId)
+                .join(", ")}`,
+        );
+    }
+
+    const context = state.definition.context;
+    let expectedRefs: string[];
+    if (event.modelCallIndex === 0) {
+        if (isContextRef(context)) {
+            if (event.request.contextRef?.previousTurnId !== context.previousTurnId) {
+                fail("model request contextRef inconsistent with turn context");
+            }
+            expectedRefs = ["input"];
+        } else {
+            if (event.request.contextRef !== undefined) {
+                fail("model request has contextRef but turn context is inline");
+            }
+            expectedRefs = context.length > 0 ? ["context", "input"] : ["input"];
+        }
+    } else {
+        if (event.request.contextRef !== undefined) {
+            fail("model request has contextRef on a non-initial model call");
+        }
+        const previous = state.modelCalls[event.modelCallIndex - 1];
+        expectedRefs =
+            previous.response !== undefined
+                ? [
+                      assistantRef(previous.index),
+                      ...batchToolCalls(state, previous.index).map((tc) =>
+                          toolResultRef(tc.toolCallId),
+                      ),
+                  ]
+                : []; // re-issue after an interrupted call adds nothing new
+    }
+    if (JSON.stringify(event.request.messages) !== JSON.stringify(expectedRefs)) {
+        fail(
+            `model request references do not match the transcript: expected ${JSON.stringify(
+                expectedRefs,
+            )}, got ${JSON.stringify(event.request.messages)}`,
+        );
+    }
+
+    state.modelCalls.push({
+        index: event.modelCallIndex,
+        request: event.request,
+        stepEvents: [],
+    });
+}
+
+function applyModelStepEvent(
+    state: TurnState,
+    event: z.infer<typeof ModelStepEvent>,
+): void {
+    const call = state.modelCalls[event.modelCallIndex];
+    if (!call) {
+        fail(`step event without matching model call request: ${event.modelCallIndex}`);
+    }
+    if (call.response !== undefined || call.error !== undefined) {
+        fail(`step event after model call ${event.modelCallIndex} settled`);
+    }
+    call.stepEvents.push(event.event);
+}
+
+function applyModelCallCompleted(
+    state: TurnState,
+    event: z.infer<typeof ModelCallCompleted>,
+): void {
+    const call = state.modelCalls[event.modelCallIndex];
+    if (!call) {
+        fail(`model call completion without matching request: ${event.modelCallIndex}`);
+    }
+    if (call.response !== undefined || call.error !== undefined) {
+        fail(`duplicate settlement for model call ${event.modelCallIndex}`);
+    }
+    call.response = event.message;
+    call.finishReason = event.finishReason;
+    call.usage = event.usage;
+    call.providerMetadata = event.providerMetadata;
+    addUsage(state.usage, event.usage);
+
+    const parts = Array.isArray(event.message.content)
+        ? event.message.content
+        : [];
+    let order = 0;
+    for (const part of parts) {
+        if (part.type !== "tool-call") {
+            continue;
+        }
+        if (state.toolCalls.some((tc) => tc.toolCallId === part.toolCallId)) {
+            fail(`duplicate tool call id: ${part.toolCallId}`);
+        }
+        const resolved = state.definition.agent.resolved;
+        // Inherited snapshots resolve outside the reducer; identity fields
+        // then arrive via tool_invocation_requested events.
+        const descriptor = isInheritedSnapshot(resolved)
+            ? undefined
+            : resolved.tools.find((tool) => tool.name === part.toolName);
+        state.toolCalls.push({
+            modelCallIndex: event.modelCallIndex,
+            order: order++,
+            toolCallId: part.toolCallId,
+            toolName: part.toolName,
+            input: part.arguments,
+            toolId: descriptor?.toolId,
+            execution: descriptor?.execution,
+            progress: [],
+        });
+    }
+}
+
+function applyModelCallFailed(
+    state: TurnState,
+    event: z.infer<typeof ModelCallFailed>,
+): void {
+    const call = state.modelCalls[event.modelCallIndex];
+    if (!call) {
+        fail(`model call failure without matching request: ${event.modelCallIndex}`);
+    }
+    if (call.response !== undefined || call.error !== undefined) {
+        fail(`duplicate settlement for model call ${event.modelCallIndex}`);
+    }
+    call.error = event.error;
+}
+
+function applyToolPermissionRequired(
+    state: TurnState,
+    event: z.infer<typeof ToolPermissionRequired>,
+): void {
+    const toolCall = findToolCall(state, event.toolCallId);
+    if (toolCall.result) {
+        fail(`permission requirement after tool result: ${event.toolCallId}`);
+    }
+    if (toolCall.invocation) {
+        fail(`permission requirement after invocation: ${event.toolCallId}`);
+    }
+    if (toolCall.permission) {
+        fail(`duplicate permission requirement: ${event.toolCallId}`);
+    }
+    toolCall.permission = { required: event };
+}
+
+function applyToolPermissionClassified(
+    state: TurnState,
+    event: z.infer<typeof ToolPermissionClassified>,
+): void {
+    const toolCall = findToolCall(state, event.toolCallId);
+    if (!toolCall.permission) {
+        fail(`classification without permission requirement: ${event.toolCallId}`);
+    }
+    if (toolCall.permission.resolved) {
+        fail(`classification after permission resolution: ${event.toolCallId}`);
+    }
+    if (toolCall.permission.classification) {
+        fail(`duplicate permission classification: ${event.toolCallId}`);
+    }
+    toolCall.permission.classification = event;
+}
+
+function applyToolPermissionClassificationFailed(
+    state: TurnState,
+    event: z.infer<typeof ToolPermissionClassificationFailed>,
+): void {
+    for (const toolCallId of event.toolCallIds) {
+        const toolCall = findToolCall(state, toolCallId);
+        if (!toolCall.permission) {
+            fail(`classification failure without permission requirement: ${toolCallId}`);
+        }
+        if (toolCall.permission.resolved) {
+            fail(`classification failure after permission resolution: ${toolCallId}`);
+        }
+        toolCall.permission.classificationFailed = true;
+    }
+}
+
+function applyToolPermissionResolved(
+    state: TurnState,
+    event: z.infer<typeof ToolPermissionResolved>,
+): void {
+    const toolCall = findToolCall(state, event.toolCallId);
+    if (!toolCall.permission) {
+        fail(`permission resolution without requirement: ${event.toolCallId}`);
+    }
+    if (toolCall.permission.resolved) {
+        fail(`conflicting permission decisions: ${event.toolCallId}`);
+    }
+    if (toolCall.result) {
+        fail(`permission resolution after tool result: ${event.toolCallId}`);
+    }
+    toolCall.permission.resolved = event;
+}
+
+function applyToolInvocationRequested(
+    state: TurnState,
+    event: z.infer<typeof ToolInvocationRequested>,
+): void {
+    const toolCall = findToolCall(state, event.toolCallId);
+    if (toolCall.invocation) {
+        fail(`duplicate tool invocation: ${event.toolCallId}`);
+    }
+    if (toolCall.result) {
+        fail(`tool invocation after result: ${event.toolCallId}`);
+    }
+    if (toolCall.toolName !== event.toolName) {
+        fail(`tool invocation name mismatch: ${event.toolCallId}`);
+    }
+    if (toolCall.permission && toolCall.permission.resolved?.decision !== "allow") {
+        fail(`tool invocation without permission allowance: ${event.toolCallId}`);
+    }
+    if (toolCall.execution !== undefined && toolCall.execution !== event.execution) {
+        fail(`tool invocation execution mismatch: ${event.toolCallId}`);
+    }
+    if (toolCall.toolId !== undefined && toolCall.toolId !== event.toolId) {
+        fail(`tool invocation toolId mismatch: ${event.toolCallId}`);
+    }
+    toolCall.execution = event.execution;
+    toolCall.toolId = event.toolId;
+    toolCall.invocation = event;
+}
+
+function applyToolProgress(
+    state: TurnState,
+    event: z.infer<typeof ToolProgress>,
+): void {
+    const toolCall = findToolCall(state, event.toolCallId);
+    if (!toolCall.invocation) {
+        fail(`tool progress without invocation: ${event.toolCallId}`);
+    }
+    if (toolCall.result) {
+        fail(`tool progress after terminal result: ${event.toolCallId}`);
+    }
+    if (event.source !== toolCall.execution) {
+        fail(`tool progress source mismatch: ${event.toolCallId}`);
+    }
+    toolCall.progress.push(event);
+}
+
+function applyToolResult(
+    state: TurnState,
+    event: z.infer<typeof ToolResult>,
+): void {
+    const toolCall = findToolCall(state, event.toolCallId);
+    if (toolCall.result) {
+        fail(`duplicate tool result: ${event.toolCallId}`);
+    }
+    if (toolCall.toolName !== event.toolName) {
+        fail(`tool result name mismatch: ${event.toolCallId}`);
+    }
+    if (event.source !== "runtime") {
+        if (!toolCall.invocation) {
+            fail(`${event.source} tool result without invocation: ${event.toolCallId}`);
+        }
+        if (event.source !== toolCall.execution) {
+            fail(`tool result source mismatch: ${event.toolCallId}`);
+        }
+    }
+    toolCall.result = event;
+}
+
+function sortedIds(ids: string[]): string {
+    return [...ids].sort().join(",");
+}
+
+function applyTurnSuspended(
+    state: TurnState,
+    event: z.infer<typeof TurnSuspended>,
+): void {
+    if (openModelCall(state)) {
+        fail("suspension while a model call is unsettled");
+    }
+    const expectedPermissions = outstandingPermissions(state).map(
+        (tc) => tc.toolCallId,
+    );
+    const expectedAsync = outstandingAsyncTools(state).map((tc) => tc.toolCallId);
+    if (expectedPermissions.length + expectedAsync.length === 0) {
+        fail("suspension without pending external work");
+    }
+    const claimedPermissions = event.pendingPermissions.map((p) => p.toolCallId);
+    const claimedAsync = event.pendingAsyncTools.map((p) => p.toolCallId);
+    if (
+        sortedIds(claimedPermissions) !== sortedIds(expectedPermissions) ||
+        sortedIds(claimedAsync) !== sortedIds(expectedAsync)
+    ) {
+        fail("suspension snapshot inconsistent with pending state");
+    }
+    state.suspension = event;
+}
+
+function assertTerminalPreconditions(state: TurnState, kind: string): void {
+    if (openModelCall(state)) {
+        fail(`${kind} while a model call is unsettled`);
+    }
+    const unresolved = state.toolCalls.filter((tc) => !tc.result);
+    if (unresolved.length > 0) {
+        fail(
+            `${kind} while tool calls lack terminal results: ${unresolved
+                .map((tc) => tc.toolCallId)
+                .join(", ")}`,
+        );
+    }
+}
+
+function applyTurnCompleted(
+    state: TurnState,
+    event: z.infer<typeof TurnCompleted>,
+): void {
+    assertTerminalPreconditions(state, "completion");
+    const last = state.modelCalls[state.modelCalls.length - 1];
+    if (!last || last.response === undefined) {
+        fail("completion without a completed model response");
+    }
+    if (batchToolCalls(state, last.index).length > 0) {
+        fail("completion while the final response has tool calls");
+    }
+    state.terminal = event;
+}
+
+export function reduceTurn(
+    events: Array<z.infer<typeof TurnEvent>>,
+): TurnState {
+    if (events.length === 0) {
+        fail("turn log is empty");
+    }
+    const [first, ...rest] = events;
+    if (first.type !== "turn_created") {
+        fail(`first event must be turn_created, got ${first.type}`);
+    }
+    if (first.schemaVersion !== 1) {
+        fail(`unsupported turn schema version: ${String(first.schemaVersion)}`);
+    }
+
+    if (isInheritedSnapshot(first.agent.resolved)) {
+        const context = first.context;
+        if (
+            Array.isArray(context) ||
+            context.previousTurnId !== first.agent.resolved.inheritedFrom
+        ) {
+            fail(
+                "inherited agent snapshot must reference the turn's context predecessor",
+            );
+        }
+    }
+
+    const state: TurnState = {
+        definition: first,
+        modelCalls: [],
+        toolCalls: [],
+        usage: {},
+    };
+
+    for (const event of rest) {
+        if (event.turnId !== first.turnId) {
+            fail(
+                `event turnId ${event.turnId} does not match turn ${first.turnId}`,
+            );
+        }
+        if (state.terminal) {
+            fail(`event after terminal turn event: ${event.type}`);
+        }
+        switch (event.type) {
+            case "turn_created":
+                fail("duplicate turn_created event");
+                break;
+            case "model_call_requested":
+                applyModelCallRequested(state, event);
+                break;
+            case "model_step_event":
+                applyModelStepEvent(state, event);
+                break;
+            case "model_call_completed":
+                applyModelCallCompleted(state, event);
+                break;
+            case "model_call_failed":
+                applyModelCallFailed(state, event);
+                break;
+            case "tool_permission_required":
+                applyToolPermissionRequired(state, event);
+                break;
+            case "tool_permission_classified":
+                applyToolPermissionClassified(state, event);
+                break;
+            case "tool_permission_classification_failed":
+                applyToolPermissionClassificationFailed(state, event);
+                break;
+            case "tool_permission_resolved":
+                applyToolPermissionResolved(state, event);
+                break;
+            case "tool_invocation_requested":
+                applyToolInvocationRequested(state, event);
+                break;
+            case "tool_progress":
+                applyToolProgress(state, event);
+                break;
+            case "tool_result":
+                applyToolResult(state, event);
+                break;
+            case "turn_suspended":
+                applyTurnSuspended(state, event);
+                break;
+            case "turn_completed":
+                applyTurnCompleted(state, event);
+                break;
+            case "turn_failed":
+                assertTerminalPreconditions(state, "failure");
+                state.terminal = event;
+                break;
+            case "turn_cancelled":
+                assertTerminalPreconditions(state, "cancellation");
+                state.terminal = event;
+                break;
+            default: {
+                const unknown: never = event;
+                fail(`unknown turn event type: ${(unknown as { type: string }).type}`);
+            }
+        }
+    }
+
+    return state;
+}
+
+// ---------------------------------------------------------------------------
+// Pure derivations over TurnState
+// ---------------------------------------------------------------------------
+
+export function outstandingPermissions(state: TurnState): ToolCallState[] {
+    return state.toolCalls.filter(
+        (tc) => tc.permission && !tc.permission.resolved && !tc.result,
+    );
+}
+
+export function outstandingAsyncTools(state: TurnState): ToolCallState[] {
+    return state.toolCalls.filter(
+        (tc) => tc.invocation && tc.execution === "async" && !tc.result,
+    );
+}
+
+export type TurnStatus =
+    | "completed"
+    | "failed"
+    | "cancelled"
+    | "suspended"
+    | "idle";
+
+// No durable running status exists by design: an "idle" turn is simply
+// non-terminal with no outstanding external work. Whether it is actively
+// being advanced right now is ephemeral bus state.
+export function deriveTurnStatus(state: TurnState): TurnStatus {
+    if (state.terminal) {
+        switch (state.terminal.type) {
+            case "turn_completed":
+                return "completed";
+            case "turn_failed":
+                return "failed";
+            case "turn_cancelled":
+                return "cancelled";
+        }
+    }
+    if (
+        outstandingPermissions(state).length > 0 ||
+        outstandingAsyncTools(state).length > 0
+    ) {
+        return "suspended";
+    }
+    return "idle";
+}
+
+function toolResultContent(result: z.infer<typeof ToolResult>): string {
+    const output = result.result.output;
+    return typeof output === "string" ? output : JSON.stringify(output);
+}
+
+// The canonical model-facing tool message for a resolved tool call.
+export function toolResultMessage(
+    toolCall: ToolCallState,
+): z.infer<typeof ConversationMessage> {
+    if (!toolCall.result) {
+        throw new Error(
+            `tool call ${toolCall.toolCallId} has no terminal result`,
+        );
+    }
+    return {
+        role: "tool",
+        content: toolResultContent(toolCall.result),
+        toolCallId: toolCall.toolCallId,
+        toolName: toolCall.toolName,
+    };
+}
+
+// Resolves one model call's request references to structural messages (the
+// NEW portion that call added relative to the previous one). Concatenating
+// calls 0..N yields the full current-turn conversation for call N; the
+// request composer (core) prepends the resolved cross-turn prefix and
+// encodes to the provider wire form.
+export function requestMessagesFor(
+    state: TurnState,
+    modelCallIndex: number,
+): Array<z.infer<typeof ConversationMessage>> {
+    const call = state.modelCalls[modelCallIndex];
+    if (!call) {
+        throw new Error(`no model call at index ${modelCallIndex}`);
+    }
+    return call.request.messages.flatMap((raw) => {
+        const ref = parseRequestRef(raw);
+        switch (ref.kind) {
+            case "context": {
+                const context = state.definition.context;
+                if (!Array.isArray(context)) {
+                    throw new Error("context ref on a turn without inline context");
+                }
+                return context;
+            }
+            case "input":
+                return [state.definition.input];
+            case "assistant": {
+                const response = state.modelCalls[ref.modelCallIndex]?.response;
+                if (response === undefined) {
+                    throw new Error(
+                        `assistant ref to unsettled model call ${ref.modelCallIndex}`,
+                    );
+                }
+                return [response];
+            }
+            case "toolResult": {
+                const toolCall = state.toolCalls.find(
+                    (tc) => tc.toolCallId === ref.toolCallId,
+                );
+                if (!toolCall) {
+                    throw new Error(`toolResult ref to unknown call ${ref.toolCallId}`);
+                }
+                return [toolResultMessage(toolCall)];
+            }
+        }
+    });
+}
+
+// The messages this turn contributed to the conversation: its input plus, per
+// completed model call, the assistant response and its tool results in source
+// order. Failed model calls contribute nothing. The turn's context prefix is
+// NOT included; materializing the full conversation is the context resolver's
+// job (core). Requires every tool call to have a terminal result, which holds
+// for all terminal turns.
+export function turnTranscript(
+    state: TurnState,
+): Array<z.infer<typeof ConversationMessage>> {
+    const messages: Array<z.infer<typeof ConversationMessage>> = [
+        state.definition.input,
+    ];
+    for (const call of state.modelCalls) {
+        if (call.response === undefined) {
+            continue;
+        }
+        messages.push(call.response);
+        for (const toolCall of batchToolCalls(state, call.index)) {
+            if (!toolCall.result) {
+                throw new Error(
+                    `turnTranscript requires terminal tool results; ${toolCall.toolCallId} is unresolved`,
+                );
+            }
+            messages.push(toolResultMessage(toolCall));
+        }
+    }
+    return messages;
+}
diff --git a/apps/x/packages/shared/tsconfig.build.json b/apps/x/packages/shared/tsconfig.build.json
new file mode 100644
index 00000000..4838eeca
--- /dev/null
+++ b/apps/x/packages/shared/tsconfig.build.json
@@ -0,0 +1,7 @@
+{
+    "extends": "./tsconfig.json",
+    "exclude": [
+        "src/**/*.test.ts",
+        "src/**/*.spec.ts"
+    ]
+}
diff --git a/apps/x/packages/shared/vitest.config.ts b/apps/x/packages/shared/vitest.config.ts
new file mode 100644
index 00000000..4064b801
--- /dev/null
+++ b/apps/x/packages/shared/vitest.config.ts
@@ -0,0 +1,11 @@
+import { defineConfig } from "vitest/config";
+
+export default defineConfig({
+    test: {
+        environment: "node",
+        include: ["src/**/*.test.ts", "src/**/*.spec.ts"],
+        globals: false,
+        clearMocks: true,
+        restoreMocks: true,
+    },
+});
diff --git a/apps/x/patches/@agentclientprotocol__codex-acp@0.0.44.patch b/apps/x/patches/@agentclientprotocol__codex-acp@0.0.44.patch
new file mode 100644
index 00000000..79ab1623
--- /dev/null
+++ b/apps/x/patches/@agentclientprotocol__codex-acp@0.0.44.patch
@@ -0,0 +1,57 @@
+diff --git a/dist/index.js b/dist/index.js
+--- a/dist/index.js
++++ b/dist/index.js
+@@ -17678,15 +17678,22 @@
+       case "dynamicToolCall":
+         return await createDynamicToolCallUpdate(event.item);
++      case "contextCompaction":
++        return {
++          sessionUpdate: "tool_call",
++          toolCallId: event.item.id,
++          kind: "other",
++          title: "Compacting context",
++          status: "in_progress"
++        };
+       case "collabAgentToolCall":
+       case "userMessage":
+       case "hookPrompt":
+       case "agentMessage":
+       case "reasoning":
+       case "webSearch":
+       case "imageView":
+       case "imageGeneration":
+       case "enteredReviewMode":
+       case "exitedReviewMode":
+-      case "contextCompaction":
+       case "plan":
+         return null;
+@@ -17713,23 +17720,28 @@
+         return this.completeCommandExecutionEvent(event.item);
+       case "reasoning":
+         const summary = event.item.summary[0];
+         if (!summary) return null;
+         return {
+           sessionUpdate: "agent_thought_chunk",
+           content: {
+             type: "text",
+             text: summary
+           }
+         };
++      case "contextCompaction":
++        return {
++          sessionUpdate: "tool_call_update",
++          toolCallId: event.item.id,
++          status: "completed"
++        };
+       case "collabAgentToolCall":
+       case "userMessage":
+       case "hookPrompt":
+       case "agentMessage":
+       case "webSearch":
+       case "imageView":
+       case "imageGeneration":
+       case "enteredReviewMode":
+       case "exitedReviewMode":
+-      case "contextCompaction":
+       case "plan":
+         return null;
diff --git a/apps/x/pnpm-lock.yaml b/apps/x/pnpm-lock.yaml
index dc18481a..d3c69af4 100644
--- a/apps/x/pnpm-lock.yaml
+++ b/apps/x/pnpm-lock.yaml
@@ -11,6 +11,9 @@ catalogs:
       version: 4.1.7
 
 patchedDependencies:
+  '@agentclientprotocol/codex-acp@0.0.44':
+    hash: 0079b1ab3870451b47fe5ea5ecaca697e17139cff50fd2ee9c296b172aba525e
+    path: patches/@agentclientprotocol__codex-acp@0.0.44.patch
   '@openai/codex@0.128.0':
     hash: 9edd926108a95aaa788aa93870fd6b16d70eeccdf5740b503af5d34cc9f25e86
     path: patches/@openai__codex@0.128.0.patch
@@ -57,7 +60,7 @@ importers:
         version: 0.39.0(@anthropic-ai/sdk@0.100.1(zod@4.2.1))(@modelcontextprotocol/sdk@1.25.1(hono@4.11.3)(zod@4.2.1))
       '@agentclientprotocol/codex-acp':
         specifier: ^0.0.44
-        version: 0.0.44(zod@4.2.1)
+        version: 0.0.44(patch_hash=0079b1ab3870451b47fe5ea5ecaca697e17139cff50fd2ee9c296b172aba525e)(zod@4.2.1)
       '@x/core':
         specifier: workspace:*
         version: link:../../packages/core
@@ -335,7 +338,7 @@ importers:
         version: 3.3.0(react-dom@19.2.3(react@19.2.3))(react@19.2.3)
       recharts:
         specifier: ^3.8.0
-        version: 3.8.1(@types/react@19.2.7)(react-dom@19.2.3(react@19.2.3))(react-is@16.13.1)(react@19.2.3)(redux@5.0.1)
+        version: 3.8.1(@types/react@19.2.7)(react-dom@19.2.3(react@19.2.3))(react-is@17.0.2)(react@19.2.3)(redux@5.0.1)
       remark-breaks:
         specifier: ^4.0.0
         version: 4.0.0
@@ -370,6 +373,15 @@ importers:
       '@eslint/js':
         specifier: ^9.39.1
         version: 9.39.2
+      '@testing-library/dom':
+        specifier: ^10.4.1
+        version: 10.4.1
+      '@testing-library/jest-dom':
+        specifier: ^6.9.1
+        version: 6.9.1
+      '@testing-library/react':
+        specifier: ^16.3.2
+        version: 16.3.2(@testing-library/dom@10.4.1)(@types/react-dom@19.2.3(@types/react@19.2.7))(@types/react@19.2.7)(react-dom@19.2.3(react@19.2.3))(react@19.2.3)
       '@types/node':
         specifier: ^24.10.1
         version: 24.10.4
@@ -394,6 +406,9 @@ importers:
       globals:
         specifier: ^16.5.0
         version: 16.5.0
+      jsdom:
+        specifier: ^29.1.1
+        version: 29.1.1
       tw-animate-css:
         specifier: ^1.4.0
         version: 1.4.0
@@ -406,6 +421,9 @@ importers:
       vite:
         specifier: ^7.2.4
         version: 7.3.0(@types/node@24.10.4)(jiti@2.6.1)(lightningcss@1.30.2)(terser@5.46.0)(yaml@2.8.2)
+      vitest:
+        specifier: 'catalog:'
+        version: 4.1.7(@opentelemetry/api@1.9.0)(@types/node@24.10.4)(jsdom@29.1.1)(vite@7.3.0(@types/node@24.10.4)(jiti@2.6.1)(lightningcss@1.30.2)(terser@5.46.0)(yaml@2.8.2))
 
   packages/core:
     dependencies:
@@ -414,7 +432,7 @@ importers:
         version: 0.39.0(@anthropic-ai/sdk@0.100.1(zod@4.2.1))(@modelcontextprotocol/sdk@1.25.1(hono@4.11.3)(zod@4.2.1))
       '@agentclientprotocol/codex-acp':
         specifier: ^0.0.44
-        version: 0.0.44(zod@4.2.1)
+        version: 0.0.44(patch_hash=0079b1ab3870451b47fe5ea5ecaca697e17139cff50fd2ee9c296b172aba525e)(zod@4.2.1)
       '@agentclientprotocol/sdk':
         specifier: ^0.22.1
         version: 0.22.1(zod@4.2.1)
@@ -435,7 +453,7 @@ importers:
         version: 2.0.1
       '@composio/core':
         specifier: ^0.6.0
-        version: 0.6.2(zod@4.2.1)
+        version: 0.6.2(ws@8.21.0)(zod@4.2.1)
       '@google-cloud/local-auth':
         specifier: ^3.0.1
         version: 3.0.1(encoding@0.1.13)
@@ -460,6 +478,9 @@ importers:
       awilix:
         specifier: ^12.0.5
         version: 12.0.5
+      baileys:
+        specifier: 7.0.0-rc13
+        version: 7.0.0-rc13(sharp@0.35.3(@types/node@25.0.3))
       chokidar:
         specifier: ^4.0.3
         version: 4.0.3
@@ -505,6 +526,9 @@ importers:
       posthog-node:
         specifier: ^4.18.0
         version: 4.18.0
+      qrcode:
+        specifier: ^1.5.4
+        version: 1.5.4
       react:
         specifier: ^19.2.3
         version: 19.2.3
@@ -533,18 +557,28 @@ importers:
       '@types/pdf-parse':
         specifier: ^1.1.5
         version: 1.1.5
+      '@types/qrcode':
+        specifier: ^1.5.6
+        version: 1.5.6
       vitest:
         specifier: 'catalog:'
-        version: 4.1.7(@opentelemetry/api@1.9.0)(@types/node@25.0.3)(vite@7.3.0(@types/node@25.0.3)(jiti@2.6.1)(lightningcss@1.30.2)(terser@5.46.0)(yaml@2.8.2))
+        version: 4.1.7(@opentelemetry/api@1.9.0)(@types/node@25.0.3)(jsdom@29.1.1)(vite@7.3.0(@types/node@25.0.3)(jiti@2.6.1)(lightningcss@1.30.2)(terser@5.46.0)(yaml@2.8.2))
 
   packages/shared:
     dependencies:
       zod:
         specifier: ^4.2.1
         version: 4.2.1
+    devDependencies:
+      vitest:
+        specifier: 'catalog:'
+        version: 4.1.7(@opentelemetry/api@1.9.0)(@types/node@25.0.3)(jsdom@29.1.1)(vite@7.3.0(@types/node@25.0.3)(jiti@2.6.1)(lightningcss@1.30.2)(terser@5.46.0)(yaml@2.8.2))
 
 packages:
 
+  '@adobe/css-tools@4.5.0':
+    resolution: {integrity: sha512-6OzddxPio9UiWTCemp4N8cYLV2ZN1ncRnV1cVGtve7dhPOtRkleRyx32GQCYSwDYgaHU3USMm84tNsvKzRCa1Q==}
+
   '@agentclientprotocol/claude-agent-acp@0.39.0':
     resolution: {integrity: sha512-+tCm5v32L0R3zE4qjZQowfO1L/zqvQ5FapmsMSIf4gawXfTf26CG5hgz99wARdo0zn20/1eP80gzx7PbZlSX9A==}
     hasBin: true
@@ -675,6 +709,21 @@ packages:
       zod:
         optional: true
 
+  '@asamuzakjp/css-color@5.1.11':
+    resolution: {integrity: sha512-KVw6qIiCTUQhByfTd78h2yD1/00waTmm9uy/R7Ck/ctUyAPj+AEDLkQIdJW0T8+qGgj3j5bpNKK7Q3G+LedJWg==}
+    engines: {node: ^20.19.0 || ^22.12.0 || >=24.0.0}
+
+  '@asamuzakjp/dom-selector@7.1.1':
+    resolution: {integrity: sha512-67RZDnYRc8H/8MLDgQCDE//zoqVFwajkepHZgmXrbwybzXOEwOWGPYGmALYl9J2DOLfFPPs6kKCqmbzV895hTQ==}
+    engines: {node: ^20.19.0 || ^22.12.0 || >=24.0.0}
+
+  '@asamuzakjp/generational-cache@1.0.1':
+    resolution: {integrity: sha512-wajfB8KqzMCN2KGNFdLkReeHncd0AslUSrvHVvvYWuU8ghncRJoA50kT3zP9MVL0+9g4/67H+cdvBskj9THPzg==}
+    engines: {node: ^20.19.0 || ^22.12.0 || >=24.0.0}
+
+  '@asamuzakjp/nwsapi@2.3.9':
+    resolution: {integrity: sha512-n8GuYSrI9bF7FFZ/SjhwevlHc8xaVlb/7HmHelnc/PZXBD2ZR49NnN9sMMuDdEGPeeRQ5d0hqlSlEpgCX3Wl0Q==}
+
   '@aws-crypto/crc32@5.2.0':
     resolution: {integrity: sha512-nLbCWqQNgUiwwtFsen1AdzAtvuLRsQS8rYgMuxCrdKf9kOssamGLuPwyTY9wyYblNr9+1XM8v6zoDTPPSIeANg==}
     engines: {node: '>=16.0.0'}
@@ -931,9 +980,26 @@ packages:
     resolution: {integrity: sha512-qQ5m48eI/MFLQ5PxQj4PFaprjyCTLI37ElWMmNs0K8Lk3dVeOdNpB3ks8jc7yM5CDmVC73eMVk/trk3fgmrUpA==}
     engines: {node: '>=6.9.0'}
 
+  '@borewit/text-codec@0.2.2':
+    resolution: {integrity: sha512-DDaRehssg1aNrH4+2hnj1B7vnUGEjU6OIlyRdkMd0aUdIUvKXrJfXsy8LVtXAy7DRvYVluWbMspsRhz2lcW0mQ==}
+
   '@braintree/sanitize-url@7.1.1':
     resolution: {integrity: sha512-i1L7noDNxtFyL5DmZafWy1wRVhGehQmzZaz1HiN5e7iylJMSZR7ekOV7NsIqa5qBldlLrsKv4HbgFUVlQrz8Mw==}
 
+  '@bramus/specificity@2.4.2':
+    resolution: {integrity: sha512-ctxtJ/eA+t+6q2++vj5j7FYX3nRu311q1wfYH3xjlLOsczhlhxAg2FWNUXhpGvAw3BWo1xBcvOV6/YLc2r5FJw==}
+    hasBin: true
+
+  '@cacheable/memory@2.2.0':
+    resolution: {integrity: sha512-CTLKqLItRCEixEAewD3/j9DB3/o96gpTPD4eJ1v+DGOlxZRZncRQkGYqqnAGCscYd6RNeXfGeiuCphsPtqyIfQ==}
+
+  '@cacheable/node-cache@1.7.6':
+    resolution: {integrity: sha512-6Omk2SgNnjtxB5f/E6bTIWIt5xhdpx39fGNRQgU9lojvRxU68v+qY+SXXLsp3ZGukqoPjsK21wZ6XABFr/Ge3A==}
+    engines: {node: '>=18'}
+
+  '@cacheable/utils@2.5.0':
+    resolution: {integrity: sha512-buipgOVDkkPXNR5+xBpDw7Zk2n1EvU7qBJCNUcL7rhQ//kfpOXPAvQ511Os0vpLYJ1pZnvudNytkQt2hst3wqA==}
+
   '@chevrotain/cst-dts-gen@12.0.0':
     resolution: {integrity: sha512-fSL4KXjTl7cDgf0B5Rip9Q05BOrYvkJV/RrBTE/bKDN096E4hN/ySpcBK5B24T76dlQ2i32Zc3PAE27jFnFrKg==}
 
@@ -1055,6 +1121,42 @@ packages:
     peerDependencies:
       zod: '>=3.25.76 <5'
 
+  '@csstools/color-helpers@6.1.0':
+    resolution: {integrity: sha512-064IFJdjTfUqnjpCVpMOdbr8FLQBhinbZj6yRv2An2E41O/pLEXqfFRWqGq/SxlE5PEUYTlvWsG2r8MswAVvkg==}
+    engines: {node: '>=20.19.0'}
+
+  '@csstools/css-calc@3.2.1':
+    resolution: {integrity: sha512-DtdHlgXh5ZkA43cwBcAm+huzgJiwx3ZTWVjBs94kwz2xKqSimDA3lBgCjphYgwgVUMWatSM0pDd8TILB1yrVVg==}
+    engines: {node: '>=20.19.0'}
+    peerDependencies:
+      '@csstools/css-parser-algorithms': ^4.0.0
+      '@csstools/css-tokenizer': ^4.0.0
+
+  '@csstools/css-color-parser@4.1.9':
+    resolution: {integrity: sha512-paQcIaOO53Rk5+YrBaBjm/SgrV4INImjo2BT1DtQRYr+XeTRbeAYlS+jxXp9drqvKmtFnWRJKIalDLhZZDu42A==}
+    engines: {node: '>=20.19.0'}
+    peerDependencies:
+      '@csstools/css-parser-algorithms': ^4.0.0
+      '@csstools/css-tokenizer': ^4.0.0
+
+  '@csstools/css-parser-algorithms@4.0.0':
+    resolution: {integrity: sha512-+B87qS7fIG3L5h3qwJ/IFbjoVoOe/bpOdh9hAjXbvx0o8ImEmUsGXN0inFOnk2ChCFgqkkGFQ+TpM5rbhkKe4w==}
+    engines: {node: '>=20.19.0'}
+    peerDependencies:
+      '@csstools/css-tokenizer': ^4.0.0
+
+  '@csstools/css-syntax-patches-for-csstree@1.1.6':
+    resolution: {integrity: sha512-TcJCWFbXLPpJYq6z7bfOyjWYJDiDg2/I4gyUC9pqPNqHFRIey0EB0q0L5cSnQDfWJg8Jd6VadakxdIez/3zkqQ==}
+    peerDependencies:
+      css-tree: ^3.2.1
+    peerDependenciesMeta:
+      css-tree:
+        optional: true
+
+  '@csstools/css-tokenizer@4.0.0':
+    resolution: {integrity: sha512-QxULHAm7cNu72w97JUNCBFODFaXpbDg+dP8b/oWFAZ2MTRppA3U00Y2L1HqaS4J6yBqxwa/Y3nMBaxVKbB/NsA==}
+    engines: {node: '>=20.19.0'}
+
   '@eigenpal/docx-editor-agents@1.0.3':
     resolution: {integrity: sha512-Bk/J9/PBnMCOxb6w4cHQiCTuN/1C4FtZM9evC9EXXcLP13yFMdqoEqsYs+Lh3HyaRRAaCZTrkfgOZyTqqyjtwQ==}
     peerDependencies:
@@ -1091,6 +1193,7 @@ packages:
 
   '@eigenpal/docx-editor-react@1.0.3':
     resolution: {integrity: sha512-KupDVHo6KC4KUs48bM1pMYFFbDJqkW8XyIhgsnLx+BWk2yOPU4bx2HfWB6H+JEVROA1h1AmhTAyE39gk75wg5w==}
+    deprecated: deprecated
     peerDependencies:
       prosemirror-commands: ^1.5.2
       prosemirror-dropcursor: ^1.8.2
@@ -1241,6 +1344,9 @@ packages:
     engines: {node: '>=14.14'}
     hasBin: true
 
+  '@emnapi/runtime@1.11.2':
+    resolution: {integrity: sha512-kyOl3X0DuTiT1h2ft8r2fYO8JYtU9a9Xis/zBSiGArNaagCOWx90N1k2wxp18czFDH+OgcWGb5ZP/XMt3dcyPA==}
+
   '@esbuild/aix-ppc64@0.24.2':
     resolution: {integrity: sha512-thpVCb/rhxE/BnMLQ7GReQLLN8q9qbHmI55F4489/ByVg2aQaQ6kbcLb6FHkocZzQhxc4gx0sCk0tJkKBFzDhA==}
     engines: {node: '>=18'}
@@ -1585,6 +1691,15 @@ packages:
     resolution: {integrity: sha512-43/qtrDUokr7LJqoF2c3+RInu/t4zfrpYdoSDfYyhg52rwLV6TnOvdG4fXm7IkSB3wErkcmJS9iEhjVtOSEjjA==}
     engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
 
+  '@exodus/bytes@1.15.1':
+    resolution: {integrity: sha512-S6mL0yNB/Abt9Ei4tq8gDhcczc4S3+vQ4ra7vxnAf+YHC02srtqxKKZghx2Dq6p0e66THKwR6r8N6P95wEty7Q==}
+    engines: {node: ^20.19.0 || ^22.12.0 || >=24.0.0}
+    peerDependencies:
+      '@noble/hashes': ^1.8.0 || ^2.0.0
+    peerDependenciesMeta:
+      '@noble/hashes':
+        optional: true
+
   '@floating-ui/core@1.7.3':
     resolution: {integrity: sha512-sGnvb5dmrJaKEZ+LDIpguvdX3bDlEllmv4/ClQ9awcmCZrlx5jQyyMWFM5kBI+EyNOCDDiKk8il0zeuX3Zlg/w==}
 
@@ -1611,12 +1726,18 @@ packages:
     resolution: {integrity: sha512-A+po2d/dVoY7cYajycYI43ZbYMXukuopIsqCjh5QzsBCipDtdofHntljDlpccMjIfTy6UOkg+5KPriwYch2bXA==}
     engines: {node: '>=14.0.0'}
 
+  '@hapi/boom@9.1.4':
+    resolution: {integrity: sha512-Ls1oH8jaN1vNsqcaHVYJrKmgMcKsC1wcp8bujvXrHaAqD2iDYq3HoOwsxwo09Cuda5R5nC0o0IxlrlTuvPuzSw==}
+
   '@hapi/formula@3.0.2':
     resolution: {integrity: sha512-hY5YPNXzw1He7s0iqkRQi+uMGh383CGdyyIGYtB+W5N3KHPXoqychklvHhKCC9M3Xtv0OCs/IHw+r4dcHtBYWw==}
 
   '@hapi/hoek@11.0.7':
     resolution: {integrity: sha512-HV5undWkKzcB4RZUusqOpcgxOaq6VOAH7zhhIr2g3G8NF/MlFO75SjOr2NfuSx0Mh40+1FqCkagKLJRykUWoFQ==}
 
+  '@hapi/hoek@9.3.0':
+    resolution: {integrity: sha512-/c6rf4UJlmHlC9b5BaNvzAcFv7HZ2QHaV0D4/HNlBdvFnvQq8RI4kYdhyPCl7Xj+oWvTWQ8ujhqS53LIgAe6KQ==}
+
   '@hapi/pinpoint@2.0.1':
     resolution: {integrity: sha512-EKQmr16tM8s16vTT3cA5L0kZZcTMU5DUOZTuvpnY738m+jyP3JIUj+Mm1xc1rsLkGBQ/gVnfKYPwOmPg1tUR4Q==}
 
@@ -1655,6 +1776,152 @@ packages:
   '@iconify/utils@3.1.0':
     resolution: {integrity: sha512-Zlzem1ZXhI1iHeeERabLNzBHdOa4VhQbqAcOQaMKuTuyZCpwKbC2R4Dd0Zo3g9EAc+Y4fiarO8HIHRAth7+skw==}
 
+  '@img/colour@1.1.0':
+    resolution: {integrity: sha512-Td76q7j57o/tLVdgS746cYARfSyxk8iEfRxewL9h4OMzYhbW4TAcppl0mT4eyqXddh6L/jwoM75mo7ixa/pCeQ==}
+    engines: {node: '>=18'}
+
+  '@img/sharp-darwin-arm64@0.35.3':
+    resolution: {integrity: sha512-RMnFX7YQsMoh7lWfcM4NEHHymBX/rLuKNPVM84XE9ONPcaSCDgE7CHIHpSgPcO2xcRthgBy1HfNO319mwhIAkg==}
+    engines: {node: '>=20.9.0'}
+    cpu: [arm64]
+    os: [darwin]
+
+  '@img/sharp-darwin-x64@0.35.3':
+    resolution: {integrity: sha512-Xo+5uFBtLN0BKqieTxiFzFPQAUlBbbH5iBKyRX/z1JrbnYsHTfKJnUfL8+p2TPXr1pXqao4eeL4Rl144uDpK9w==}
+    engines: {node: '>=20.9.0'}
+    cpu: [x64]
+    os: [darwin]
+
+  '@img/sharp-freebsd-wasm32@0.35.3':
+    resolution: {integrity: sha512-lUxcqWIj2wMQ9BrwNjngcr1gWUr5xgaGThBRqPPalIC2n67Cqj1uPh8NnA/ZhAg8hUbKl+kVHKwgUIwe6ZYPrg==}
+    engines: {node: '>=20.9.0'}
+    os: [freebsd]
+
+  '@img/sharp-libvips-darwin-arm64@1.3.2':
+    resolution: {integrity: sha512-9J6ypZFpQBj4YnePGoq/S38w6nz+vqg5WZLrLGY4YuSemdMq47GMLBPO42MzwdGwpg/agZ7xzZcFHa48xlywfg==}
+    cpu: [arm64]
+    os: [darwin]
+
+  '@img/sharp-libvips-darwin-x64@1.3.2':
+    resolution: {integrity: sha512-m2pW1n6cns9VaubNwsZ+c3CRYjxNQWgJ5gPlnL1nbBcpkBvFm6SCFN5o0psFHI8w9n11NKhFkeEDns98tiqbEw==}
+    cpu: [x64]
+    os: [darwin]
+
+  '@img/sharp-libvips-linux-arm64@1.3.2':
+    resolution: {integrity: sha512-dqVSFynCox4C/J8kT16V7SIFAns0IjgLwkvYT7p8LQVmJ5OS5b6tI9IGflxTeuBS//zXeFIUbwt5dwxyZ17cnA==}
+    cpu: [arm64]
+    os: [linux]
+
+  '@img/sharp-libvips-linux-arm@1.3.2':
+    resolution: {integrity: sha512-1eMLzy92I4J6rmi4mAT8yC3HxOtniyGELlzGbNMLLeqe052ahFQ0h6LFq+lh5DsDIdYViIDst08abvSbcEdLXQ==}
+    cpu: [arm]
+    os: [linux]
+
+  '@img/sharp-libvips-linux-ppc64@1.3.2':
+    resolution: {integrity: sha512-3z0NHDxD6n5I9gc05U1eW1AyRm+Gznzq3naMrthPNqE6oYykcogW0l/jfpJdjYnuNl8R7yI9pNbE1XiUeyq0Aw==}
+    cpu: [ppc64]
+    os: [linux]
+
+  '@img/sharp-libvips-linux-riscv64@1.3.2':
+    resolution: {integrity: sha512-bsb4rI+NldGOsXuej2r8OdSS8+zXDVaCWxyWrcv6kneTOlgAHtZABRzBBCwdsPiD90J4myNJuHpg6kA20ImW/w==}
+    cpu: [riscv64]
+    os: [linux]
+
+  '@img/sharp-libvips-linux-s390x@1.3.2':
+    resolution: {integrity: sha512-/ABshyj8gCpyIrNXnHn4LorDJ0HHm1VhXPBlxZ8zAtfVPAaSafXPGn+sUSIRiwaSBy0mmFjSjiXI5mkcwdChKQ==}
+    cpu: [s390x]
+    os: [linux]
+
+  '@img/sharp-libvips-linux-x64@1.3.2':
+    resolution: {integrity: sha512-ITPEtgffGJ0S6G9dRyw/366tJQqFRcHWPHhC+Stpg3Z8AEMrDrTr2lhdz4f/Y/HMbRh//7Z5mBzEpVdi62Oc3w==}
+    cpu: [x64]
+    os: [linux]
+
+  '@img/sharp-libvips-linuxmusl-arm64@1.3.2':
+    resolution: {integrity: sha512-zE9EdiUzUmg5mDT5a1rk5fYJ6GWPloTwWBYDS14naqHsL+EaMpDj1AWnpLgh3u0YCORv2Tt50wrcrpYqkP97Kw==}
+    cpu: [arm64]
+    os: [linux]
+
+  '@img/sharp-libvips-linuxmusl-x64@1.3.2':
+    resolution: {integrity: sha512-m0lrLiUt+lBYnCFr8qV/65yMR4E/c7/wf78I5eKTdkEakFAlZ9QlzEM3QIhhAwVeUhLAHLcCq7a7Vszq/oFNZQ==}
+    cpu: [x64]
+    os: [linux]
+
+  '@img/sharp-linux-arm64@0.35.3':
+    resolution: {integrity: sha512-QgKDspHPnrU+GQ55XPhGwyhC8acLVOOSyAvo1oVfFmrIXLkDNmGWzAfDZ4xK8oSA1qBQrALcHX0G5UZni/SuFQ==}
+    engines: {node: '>=20.9.0'}
+    cpu: [arm64]
+    os: [linux]
+
+  '@img/sharp-linux-arm@0.35.3':
+    resolution: {integrity: sha512-affVWCTLooy8TSxbDx2qkzuDeaWLNVBA+P//FNBirHsXpP2fuBhk5AuboYUnrDnzoXes8GFjpTx0SBFOCRg+FA==}
+    engines: {node: '>=20.9.0'}
+    cpu: [arm]
+    os: [linux]
+
+  '@img/sharp-linux-ppc64@0.35.3':
+    resolution: {integrity: sha512-sMd8rDxmpLOwv/7N44klFjOD5DUO7FLdjiXDI0hoxYaf7Ar262dQIEkosE98bps+5HPLtp/EvNqeqQtOycP/IA==}
+    engines: {node: '>=20.9.0'}
+    cpu: [ppc64]
+    os: [linux]
+
+  '@img/sharp-linux-riscv64@0.35.3':
+    resolution: {integrity: sha512-0Eob78yjlYPfL5vMNWAW55l3R9Y6BQS/gOfe0ZcP9mEz9ohhKSt4im1hayiknXgf8AWrFqMvJcKIdmLmEe7yeQ==}
+    engines: {node: '>=20.9.0'}
+    cpu: [riscv64]
+    os: [linux]
+
+  '@img/sharp-linux-s390x@0.35.3':
+    resolution: {integrity: sha512-KgAxQ0DxpNOq1rG2t5cgTgShJFGSuU7XO45cqC+1NVOuZnP6tlgZRuSYOfNupGkHID0o3cJOsw4DVeJpMovcGw==}
+    engines: {node: '>=20.9.0'}
+    cpu: [s390x]
+    os: [linux]
+
+  '@img/sharp-linux-x64@0.35.3':
+    resolution: {integrity: sha512-8pqvxubL2PGdhlPy6GLqzDYMUjyRmKAwKHYKixpdJYBUK7PJ0C029XdsnpFIdgRZG68fZiGdHVWcKPvtiPB4cA==}
+    engines: {node: '>=20.9.0'}
+    cpu: [x64]
+    os: [linux]
+
+  '@img/sharp-linuxmusl-arm64@0.35.3':
+    resolution: {integrity: sha512-Vz0iQjzzcSX3HCbfwFfCSG/9SCIqyO0mH2sXyiHaAYfBk0cRsCWXRyQYX0ovCK/PAQBbTzQ0dsPQHh5MAFL59w==}
+    engines: {node: '>=20.9.0'}
+    cpu: [arm64]
+    os: [linux]
+
+  '@img/sharp-linuxmusl-x64@0.35.3':
+    resolution: {integrity: sha512-6O1NPKcDVj9QEdg7Hx549EX8U0rp6yXQERqru6yRN7fGBn32UvIRJUlWnk+8xDCiG76hXVBbX82NZ/ZKr0euIg==}
+    engines: {node: '>=20.9.0'}
+    cpu: [x64]
+    os: [linux]
+
+  '@img/sharp-wasm32@0.35.3':
+    resolution: {integrity: sha512-cZ0XkcYGpHZkqW6iCkqTcmUC0CD9DhD5d/qeZlZkfRBn6GnHniZXLUo5+9xw8Iv76YE6LQFN9YNBlKREcCG76w==}
+    engines: {node: '>=20.9.0'}
+
+  '@img/sharp-webcontainers-wasm32@0.35.3':
+    resolution: {integrity: sha512-2rnq7bX3NzeR2T4YWgz8qiG4h3TSdMe+vN1iQXpJleSJ3SM5zQ8Fy2SyyXAWlbxpEZ2Y+Z4u1BePgJEYbSy80Q==}
+    engines: {node: '>=20.9.0'}
+    cpu: [wasm32]
+
+  '@img/sharp-win32-arm64@0.35.3':
+    resolution: {integrity: sha512-4bPwFdMbeC4JQ8L8LOyWp6nsHcboP5fxkp6iPOXz2Vg49R42TuMs2whkJ5OAP4/Ul035qOzy0AecOF9VOscn4w==}
+    engines: {node: '>=20.9.0'}
+    cpu: [arm64]
+    os: [win32]
+
+  '@img/sharp-win32-ia32@0.35.3':
+    resolution: {integrity: sha512-r53mXsBN6lFUDiST764SvgwUdHAqM4rPAiDzAmf4fLoB6X/rkfyTrLCg6+g17wJJiCmB3JYgHuUldCWUIRFSXw==}
+    engines: {node: ^20.9.0}
+    cpu: [ia32]
+    os: [win32]
+
+  '@img/sharp-win32-x64@0.35.3':
+    resolution: {integrity: sha512-D4y1vNeZrIIJCN+uHaWVtH86B+aCrdMYYjicy9pXHvbGZeGYLLSd3wdVuC37FxVXlU1ARsk84eKWfWMXGYEqvA==}
+    engines: {node: '>=20.9.0'}
+    cpu: [x64]
+    os: [win32]
+
   '@inquirer/checkbox@3.0.1':
     resolution: {integrity: sha512-0hm2nrToWUdD6/UHnel/UKGdk1//ke5zGUpHIvk5ZWmaKezlGxZkOJXNSWsdxO/rEqTkbB3lNC2J6nBElV2aAQ==}
     engines: {node: '>=18'}
@@ -1746,6 +2013,15 @@ packages:
   '@jridgewell/trace-mapping@0.3.31':
     resolution: {integrity: sha512-zzNR+SdQSDJzc8joaeP8QQoCQr8NuYx2dIIytl1QeBEZHJ9uW6hebsrYgbz8hJwUQao3TWCMtmfV8Nu1twOLAw==}
 
+  '@keyv/bigmap@1.3.1':
+    resolution: {integrity: sha512-WbzE9sdmQtKy8vrNPa9BRnwZh5UF4s1KTmSK0KUVLo3eff5BlQNNWDnFOouNpKfPKDnms9xynJjsMYjMaT/aFQ==}
+    engines: {node: '>= 18'}
+    peerDependencies:
+      keyv: ^5.6.0
+
+  '@keyv/serialize@1.1.1':
+    resolution: {integrity: sha512-dXn3FZhPv0US+7dtJsIi2R+c7qWYiReoEh5zUntWCf4oSpMNib8FDhSoed6m3QyZdx5hK7iLFkYk3rNxwt8vTA==}
+
   '@lezer/common@1.5.2':
     resolution: {integrity: sha512-sxQE460fPZyU3sdc8lafxiPwJHBzZRy/udNFynGQky1SePYBdhkBl1kOagA9uT3pxR8K09bOrmTUqA9wb/PjSQ==}
 
@@ -2142,6 +2418,9 @@ packages:
     resolution: {integrity: sha512-R5R9tb2AXs2IRLNKLBJDynhkfmx7mX0vi8NkhZb3gUkPWHn6HXk5J8iQ/dql0U3ApfWym4kXXmBDRGO+oeOfjg==}
     engines: {node: '>=14'}
 
+  '@pinojs/redact@0.4.0':
+    resolution: {integrity: sha512-k2ENnmBugE/rzQfEcdWHcCY+/FM3VLzH9cYEsbdsoqrvzAKRhUZeRNhAZvB8OitQJ1TBed3yqWtdjzS6wJKBwg==}
+
   '@pkgjs/parseargs@0.11.0':
     resolution: {integrity: sha512-+1VkjdD0QBLPodGrJUeqarH8VAIvQODIbwh9XpP5Syisf7YoQgsJKPNFoqqLQlu+VQ/tVSshMR6loPMn8U+dPg==}
     engines: {node: '>=14'}
@@ -2161,12 +2440,21 @@ packages:
   '@protobufjs/codegen@2.0.4':
     resolution: {integrity: sha512-YyFaikqM5sH0ziFZCN3xDC7zeGaB/d0IUb9CATugHWbd1FRFwWwt4ld4OYMPWu5a3Xe01mGAULCdqhMlPl29Jg==}
 
+  '@protobufjs/codegen@2.0.5':
+    resolution: {integrity: sha512-zgXFLzW3Ap33e6d0Wlj4MGIm6Ce8O89n/apUaGNB/jx+hw+ruWEp7EwGUshdLKVRCxZW12fp9r40E1mQrf/34g==}
+
   '@protobufjs/eventemitter@1.1.0':
     resolution: {integrity: sha512-j9ednRT81vYJ9OfVuXG6ERSTdEL1xVsNgqpkxMsbIabzSo3goCjDIveeGv5d03om39ML71RdmrGNjG5SReBP/Q==}
 
+  '@protobufjs/eventemitter@1.1.1':
+    resolution: {integrity: sha512-vW1GmwMZNnL+gMRaovlh9yZX74kc+TTU3FObkkurpMaRtBfLP3ldjS9KQWlwZgraRE0+dheEEoAxdzcJQ8eXZg==}
+
   '@protobufjs/fetch@1.1.0':
     resolution: {integrity: sha512-lljVXpqXebpsijW71PZaCYeIcE5on1w5DlQy5WH6GLbFryLUrBD4932W/E2BSpfRJWseIL4v/KPgBFxDOIdKpQ==}
 
+  '@protobufjs/fetch@1.1.1':
+    resolution: {integrity: sha512-GpptLrs57adMSuHi3VNj0mAF8dwh36LMaYF6XyJ6JMWlVsc+t42tm1HSEDmOs3A8fC9yyeisgLhsTVQokOZ0zw==}
+
   '@protobufjs/float@1.0.2':
     resolution: {integrity: sha512-Ddb+kVXlXst9d+R9PfTIxh1EdNkgoRe5tOX6t01f1lYWOvJnSPDBlG241QLzcyPdoNTsblLUdujGSE4RzrTZGQ==}
 
@@ -2182,6 +2470,9 @@ packages:
   '@protobufjs/utf8@1.1.0':
     resolution: {integrity: sha512-Vvn3zZrhQZkkBE8LSuW3em98c0FwgO4nxzv6OdSxPKJIEKY2bGbHn+mhGIPerzI4twdxaP8/0+06HBpwf345Lw==}
 
+  '@protobufjs/utf8@1.1.1':
+    resolution: {integrity: sha512-oOAWABowe8EAbMyWKM0tYDKi8Yaox52D+HWZhAIJqQXbqe0xI/GV7FhLWqlEKreMkfDjshR5FKgi3mnle0h6Eg==}
+
   '@radix-ui/number@1.1.1':
     resolution: {integrity: sha512-MkKCwxlXTgz6CFoJx3pCwn07GKp36+aZyu/u2Ln2VrA5DcdyCZkASEDBTd8x5whTQQL5CiYf4prXKLcgQdv29g==}
 
@@ -3481,6 +3772,29 @@ packages:
     peerDependencies:
       vite: ^5.2.0 || ^6 || ^7
 
+  '@testing-library/dom@10.4.1':
+    resolution: {integrity: sha512-o4PXJQidqJl82ckFaXUeoAW+XysPLauYI43Abki5hABd853iMhitooc6znOnczgbTYmEP6U6/y1ZyKAIsvMKGg==}
+    engines: {node: '>=18'}
+
+  '@testing-library/jest-dom@6.9.1':
+    resolution: {integrity: sha512-zIcONa+hVtVSSep9UT3jZ5rizo2BsxgyDYU7WFD5eICBE7no3881HGeb/QkGfsJs6JTkY1aQhT7rIPC7e+0nnA==}
+    engines: {node: '>=14', npm: '>=6', yarn: '>=1'}
+
+  '@testing-library/react@16.3.2':
+    resolution: {integrity: sha512-XU5/SytQM+ykqMnAnvB2umaJNIOsLF3PVv//1Ew4CTcpz0/BRyy/af40qqrt7SjKpDdT1saBMc42CUok5gaw+g==}
+    engines: {node: '>=18'}
+    peerDependencies:
+      '@testing-library/dom': ^10.0.0
+      '@types/react': ^18.0.0 || ^19.0.0
+      '@types/react-dom': ^18.0.0 || ^19.0.0
+      react: ^18.0.0 || ^19.0.0
+      react-dom: ^18.0.0 || ^19.0.0
+    peerDependenciesMeta:
+      '@types/react':
+        optional: true
+      '@types/react-dom':
+        optional: true
+
   '@tiptap/core@3.22.4':
     resolution: {integrity: sha512-vGIGm/HpqLg8EAAQXQ+koV+/S828OEpzocfWcPOwo1u2QUVf9dQG47Yy6JJ8zFFaJwfv4dBcOXli+7BrJwsxDQ==}
     peerDependencies:
@@ -3656,6 +3970,13 @@ packages:
   '@tiptap/starter-kit@3.22.4':
     resolution: {integrity: sha512-qWjw+vfdin1rzMRpRU4cC5tLTwMJtUpXeQukv+6mOqqvhptuwuZBjUHImVEJaSPoHXS7+1ut+nTnrLyWyEuE5Q==}
 
+  '@tokenizer/inflate@0.4.1':
+    resolution: {integrity: sha512-2mAv+8pkG6GIZiF1kNg1jAjh27IDxEPKwdGul3snfztFerfPGI1LjDezZp3i7BElXompqEtPmoPx6c2wgtWsOA==}
+    engines: {node: '>=18'}
+
+  '@tokenizer/token@0.3.0':
+    resolution: {integrity: sha512-OvjF+z51L3ov0OyAU0duzsYuvO01PH7x4t6DJx+guahgTnBHkhJdG7soQeTSFLWN3efnHyibZ4Z8l2EuWwJN3A==}
+
   '@tokenlens/core@1.3.0':
     resolution: {integrity: sha512-d8YNHNC+q10bVpi95fELJwJyPVf1HfvBEI18eFQxRSZTdByXrP+f/ZtlhSzkx0Jl0aEmYVeBA5tPeeYRioLViQ==}
 
@@ -3675,6 +3996,9 @@ packages:
   '@types/appdmg@0.5.5':
     resolution: {integrity: sha512-G+n6DgZTZFOteITE30LnWj+HRVIGr7wMlAiLWOO02uJFWVEitaPU9JVXm9wJokkgshBawb2O1OykdcsmkkZfgg==}
 
+  '@types/aria-query@5.0.4':
+    resolution: {integrity: sha512-rfT93uj5s0PRL7EzccGMs3brplhcrghnDoV26NqKhCAS1hVo+WdNsPvE/yb6ilfr5hi2MEk6d5EWJTKdxg8jVw==}
+
   '@types/babel__core@7.20.5':
     resolution: {integrity: sha512-qoQprZvz5wQFJwMDqeseRXWv3rqMvhgpbXFfVyWhbx9X47POIA6i/+dXefEmZKoAgOaTdaIgNSMqMIU61yRyzA==}
 
@@ -3888,6 +4212,9 @@ packages:
   '@types/pdf-parse@1.1.5':
     resolution: {integrity: sha512-kBfrSXsloMnUJOKi25s3+hRmkycHfLK6A09eRGqF/N8BkQoPUmaCr+q8Cli5FnfohEz/rsv82zAiPz/LXtOGhA==}
 
+  '@types/qrcode@1.5.6':
+    resolution: {integrity: sha512-te7NQcV2BOvdj2b1hCAHzAoMNuj65kNBMz0KBaxM6c3VGBOhU0dURQKOtH8CFNI/dsKkwlv32p26qYQTWoB5bw==}
+
   '@types/qs@6.14.0':
     resolution: {integrity: sha512-eOunJqu0K1923aExK6y8p6fsihYEn/BYuQ4g0CxAAgFc4b/ZLN4CrsRZ55srTdqoiLzU2B2evC+apEIxprEzkQ==}
 
@@ -4223,6 +4550,10 @@ packages:
     resolution: {integrity: sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==}
     engines: {node: '>=8'}
 
+  ansi-styles@5.2.0:
+    resolution: {integrity: sha512-Cxwpt2SfTzTtXcfOlzGEee8O+c+MmUgGrNiBcXnuWxuFJHe6a5Hz7qwhwe5OgaSYI0IJvkLqWX1ASG+cJOkEiA==}
+    engines: {node: '>=10'}
+
   ansi-styles@6.2.3:
     resolution: {integrity: sha512-4Dj6M28JB+oAH8kFkTLUo+a2jwOFkuqb3yucU0CANcRRUbxS0cP0nZYCGjcc3BNXwRIsUVmDGgzawme7zvJHvg==}
     engines: {node: '>=12'}
@@ -4243,6 +4574,13 @@ packages:
     resolution: {integrity: sha512-ik3ZgC9dY/lYVVM++OISsaYDeg1tb0VtP5uL3ouh1koGOaUMDPpbFIei4JkFimWUFPn90sbMNMXQAIVOlnYKJA==}
     engines: {node: '>=10'}
 
+  aria-query@5.3.0:
+    resolution: {integrity: sha512-b0P0sZPKtyu8HkeRAfCq0IfURZK+SuwMjY1UXGBU27wpAiTwQAIlq56IbIO+ytk/JjS1fMR14ee5WBBfKi5J6A==}
+
+  aria-query@5.3.2:
+    resolution: {integrity: sha512-COROpnaoap1E2F000S62r6A60uHZnmlvomhfyT2DlTcrY1OrBKn2UhH7qn5wTC9zMvD0AY7csdPSNwKP+7WiQw==}
+    engines: {node: '>= 0.4'}
+
   arrify@2.0.1:
     resolution: {integrity: sha512-3duEwti880xqi4eAMN8AyR4a0ByT90zoYdLlevfrvU43vb0YZwZVfxOgxWrLXXXpyugL0hNZc9G6BiB5B3nUug==}
     engines: {node: '>=8'}
@@ -4254,6 +4592,9 @@ packages:
   async-lock@1.4.1:
     resolution: {integrity: sha512-Az2ZTpuytrtqENulXwO3GGv1Bztugx6TT37NIo7imr/Qo0gsYiGtSdBa2B6fsXhTpVZDNfu1Qn3pk531e3q+nQ==}
 
+  async-mutex@0.5.0:
+    resolution: {integrity: sha512-1A94B18jkJ3DYq284ohPxoXbfTA5HsQ7/Mf4DEhcyLx3Bz27Rh59iScbB6EPiP+B+joue6YCxcMXSbFC1tZKwA==}
+
   async@1.5.2:
     resolution: {integrity: sha512-nSVgobk4rv61R9PUSDtYt7mPVB2olxNR5RWJcAsH676/ef11bUZwvu7+RGYrYauVdDPcO519v68wRhXQtxsV9w==}
 
@@ -4264,6 +4605,10 @@ packages:
     resolution: {integrity: sha512-+q/t7Ekv1EDY2l6Gda6LLiX14rU9TV20Wa3ofeQmwPFZbOMo9DXrLbOjFaaclkXKWidIaopwAObQDqwWtGUjqg==}
     engines: {node: '>= 4.0.0'}
 
+  atomic-sleep@1.0.0:
+    resolution: {integrity: sha512-kNOjDqAh7px0XWNI+4QbzoiR/nTkHAWNud2uvnJquD1/x5a7EQZMJT0AczqK0Qn67oY/TTQ1LbUKajZpp3I9tQ==}
+    engines: {node: '>=8.0.0'}
+
   author-regex@1.0.0:
     resolution: {integrity: sha512-KbWgR8wOYRAPekEmMXrYYdc7BRyhn2Ftk7KWfMUnQ43hFdojWEFRxhhRUm3/OFEdPa1r0KAvTTg9YQK57xTe0g==}
     engines: {node: '>=0.8'}
@@ -4285,6 +4630,22 @@ packages:
   bail@2.0.2:
     resolution: {integrity: sha512-0xO6mYd7JB2YesxDKplafRpsiOzPt9V02ddPCLbY1xYGPOX24NTyN50qnUxgCPcSoYMhKpAuBTjQoRZCAkUDRw==}
 
+  baileys@7.0.0-rc13:
+    resolution: {integrity: sha512-v8k74K8B5R7WNYGa26MyJAYEu3Wc4BSuK01QaK8lr30lhE8Nga31nWNu8KN0NDDt+Fsvkq4SQFFI8Q13ghjKmA==}
+    engines: {node: '>=20.0.0'}
+    peerDependencies:
+      audio-decode: ^2.1.3
+      jimp: ^1.6.1
+      link-preview-js: ^3.0.0
+      sharp: '*'
+    peerDependenciesMeta:
+      audio-decode:
+        optional: true
+      jimp:
+        optional: true
+      link-preview-js:
+        optional: true
+
   balanced-match@1.0.2:
     resolution: {integrity: sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw==}
 
@@ -4402,6 +4763,9 @@ packages:
     resolution: {integrity: sha512-v+p6ongsrp0yTGbJXjgxPow2+DL93DASP4kXCDKb8/bwRtt9OEF3whggkkDkGNzgcWy2XaF4a8nZglC7uElscg==}
     engines: {node: '>=8'}
 
+  cacheable@2.5.0:
+    resolution: {integrity: sha512-60cyAOytib/OzBw1JNSoSV/boK1AtHryDIjvVBk7XbN4ugfkM3+Sry7fEjNgPMGgOjuaZPAp8ruZ0Cxafwyq9g==}
+
   call-bind-apply-helpers@1.0.2:
     resolution: {integrity: sha512-Sp1ablJ0ivDkSzjcaJdxEunN5/XvksFJ2sMBFfq6x0ryhQV/2b/KwFe21cMpmHtPOSij8K99/wSfoEuTObmuMQ==}
     engines: {node: '>= 0.4'}
@@ -4421,6 +4785,10 @@ packages:
   camel-case@4.1.2:
     resolution: {integrity: sha512-gxGWBrTT1JuMx6R+o5PTXMmUnhnVzLQ9SNutD4YqKtI6ap897t3tKECYla6gCWEkplXnlNybEkZg9GEGxKFCgw==}
 
+  camelcase@5.3.1:
+    resolution: {integrity: sha512-L28STB170nwWS63UjtlEOE3dldQApaJXZkOI1uMFfzf3rRuPegHaHesyee+YxQ+W6SvRDQV6UrdOdRiR153wJg==}
+    engines: {node: '>=6'}
+
   camelize@1.0.1:
     resolution: {integrity: sha512-dU+Tx2fsypxTgtLoE36npi3UqcjSSMNYfkqgmoEhtZrraP5VWq0K7FkWVTYa8eMPtnU/G2txVsfdCJTn9uzpuQ==}
 
@@ -4512,6 +4880,9 @@ packages:
     resolution: {integrity: sha512-ouuZd4/dm2Sw5Gmqy6bGyNNNe1qt9RpmxveLSO7KcgsTnU7RXfsw+/bukWGo1abgBiMAic068rclZsO4IWmmxQ==}
     engines: {node: '>= 12'}
 
+  cliui@6.0.0:
+    resolution: {integrity: sha512-t6wbgtoCXvAzst7QgXxJYqPt0usEfbgQdftEPbLL/cvv6HPE5VgvqCuAIDR0NgU52ds6rFwqrgakNLrHEjCbrQ==}
+
   cliui@7.0.4:
     resolution: {integrity: sha512-OcRE68cOsVMXp1Yvonl/fzkQOyjLSu/8bhPDfQt0e0/Eb283TKP20Fs2MqoPsr9SwA595rRCA+QMzYc9nBP+JQ==}
 
@@ -4620,6 +4991,10 @@ packages:
     resolution: {integrity: sha512-nTjqfcBFEipKdXCv4YDQWCfmcLZKm81ldF0pAopTvyrFGVbcR6P/VAAd5G7N+0tTr8QqiU0tFadD6FK4NtJwOA==}
     engines: {node: '>= 0.6'}
 
+  content-type@2.0.0:
+    resolution: {integrity: sha512-j/O/d7GcZCyNl7/hwZAb606rzqkyvaDctLmckbxLzHvFBzTJHuGEdodATcP3yIRoDrLHkIATJuvzbFlp/ki2cQ==}
+    engines: {node: '>=18'}
+
   convert-source-map@2.0.0:
     resolution: {integrity: sha512-Kvp459HrV2FEJ1CAsi1Ku+MY3kasH19TFykTz2xWmMeq6bk2NU3XXvfJ+Q61m0xktWwt+1HSYf3JZsTms3aRJg==}
 
@@ -4680,13 +5055,23 @@ packages:
   css-select@5.2.2:
     resolution: {integrity: sha512-TizTzUddG/xYLA3NXodFM0fSbNizXjOKhqiQQwvhlspadZokn1KDy0NZFS0wuEubIYAV5/c1/lAr0TaaFXEXzw==}
 
+  css-tree@3.2.1:
+    resolution: {integrity: sha512-X7sjQzceUhu1u7Y/ylrRZFU2FS6LRiFVp6rKLPg23y3x3c3DOKAwuXGDp+PAGjh6CSnCjYeAul8pcT8bAl+lSA==}
+    engines: {node: ^10 || ^12.20.0 || ^14.13.0 || >=15.0.0}
+
   css-what@6.2.2:
     resolution: {integrity: sha512-u/O3vwbptzhMs3L1fQE82ZSLHQQfto5gyZzwteVIEyeaY5Fc7R4dapF/BvRoSYFeqfBk4m0V1Vafq5Pjv25wvA==}
     engines: {node: '>= 6'}
 
+  css.escape@1.5.1:
+    resolution: {integrity: sha512-YUifsXXuknHlUsmlgyY0PKzgPOr7/FjCePfHNt0jxm83wHZi44VDMQ7/fGNkjY3/jV1MC+1CmZbaHzugyeRtpg==}
+
   csstype@3.2.3:
     resolution: {integrity: sha512-z1HGKcYy2xA8AGQfwrn0PAy+PB7X/GSj3UVJW9qKyn43xWa+gl5nXmU4qqLMRzWVLFC8KusUX8T/0kCiOYpAIQ==}
 
+  curve25519-js@0.0.4:
+    resolution: {integrity: sha512-axn2UMEnkhyDUPWOwVKBMVIzSQy2ejH2xRGy1wq81dqRwApXfIzfbE3hIX0ZRFBIihf/KDqK158DLwESu4AK1w==}
+
   cytoscape-cose-bilkent@4.1.0:
     resolution: {integrity: sha512-wgQlVIUJF13Quxiv5e1gstZ08rnZj2XaLHGoFMYXz7SkNfCDOOteKBE6SYRfA9WxxI/iBc3ajfDoc6hb/MRAHQ==}
     peerDependencies:
@@ -4847,6 +5232,10 @@ packages:
     resolution: {integrity: sha512-0R9ikRb668HB7QDxT1vkpuUBtqc53YyAwMwGeUFKRojY/NWKvdZ+9UYtRfGmhqNbRkTSVpMbmyhXipFFv2cb/A==}
     engines: {node: '>= 12'}
 
+  data-urls@7.0.0:
+    resolution: {integrity: sha512-23XHcCF+coGYevirZceTVD7NdJOqVn+49IHyxgszm+JIiHLoB2TkmPtsYkNWT1pvRSGkc35L6NHs0yHkN2SumA==}
+    engines: {node: ^20.19.0 || ^22.12.0 || >=24.0.0}
+
   dayjs@1.11.19:
     resolution: {integrity: sha512-t5EcLVS6QPBNqM2z8fakk/NKel+Xzshgt8FFKAn+qwlD1pzZWxh0nVCrvFK7ZDb6XucZeF9z8C7CBWTRIVApAw==}
 
@@ -4867,9 +5256,16 @@ packages:
       supports-color:
         optional: true
 
+  decamelize@1.2.0:
+    resolution: {integrity: sha512-z2S+W9X73hAUUki+N+9Za2lBlun89zigOyGrsax+KUQ6wKW4ZoWpEYBkGhQjwAjjDCkWxhY0VKEhk8wzY7F5cA==}
+    engines: {node: '>=0.10.0'}
+
   decimal.js-light@2.5.1:
     resolution: {integrity: sha512-qIMFpTMZmny+MMIitAB6D7iVPEorVw6YQRWkvarTkT4tBeSLLiHzcwj6q0MmYSFCiVpiqPJTJEYIrpcPzVEIvg==}
 
+  decimal.js@10.6.0:
+    resolution: {integrity: sha512-YpgQiITW3JXGntzdUmyUR1V812Hn8T1YVXhCu+wO3OpS4eU9l4YdD3qjyiKdV6mvV29zapkMeD390UVEf2lkUg==}
+
   decode-named-character-reference@1.2.0:
     resolution: {integrity: sha512-c6fcElNV6ShtZXmsgNgFFV5tVX2PaV4g+MOAkb8eXHvn6sryJBrZa9r0zV6+dtTyoCKxtDy5tyQ5ZwQuidtd+Q==}
 
@@ -4948,6 +5344,9 @@ packages:
     resolution: {integrity: sha512-DPi0FmjiSU5EvQV0++GFDOJ9ASQUVFh5kD+OzOnYdi7n3Wpm9hWWGfB/O2blfHcMVTL5WkQXSnRiK9makhrcnw==}
     engines: {node: '>=0.3.1'}
 
+  dijkstrajs@1.0.3:
+    resolution: {integrity: sha512-qiSlmBq9+BCdCA/L46dw8Uy93mloxsPSbwnm5yrKn2vMPiy8KyAskTF6zuV/j5BMsmOGZDPs7KjU+mjb670kfA==}
+
   dingbat-to-unicode@1.0.1:
     resolution: {integrity: sha512-98l0sW87ZT58pU4i61wa2OHwxbiYSbuxsCBozaVnYX2iCnr3bLM3fIes1/ej7h1YdOKuKt/MLs706TVnALA65w==}
 
@@ -4958,6 +5357,12 @@ packages:
     resolution: {integrity: sha512-FwgeAKqY2vc9eVm2V2XGg8bq25B0OQjtSDITGi9zNnvu5GbtR4WvGjM5QNld/ALB6ZbsSuHskBPK9SvPpKhsbA==}
     engines: {node: '>=0.10'}
 
+  dom-accessibility-api@0.5.16:
+    resolution: {integrity: sha512-X7BJ2yElsnOJ30pZF4uIIDfBEVgF4XEBxL9Bxhy6dnrm5hkzqmsWHGTiHqRiITNhMyFLyAiWndIJP7Z1NTteDg==}
+
+  dom-accessibility-api@0.6.3:
+    resolution: {integrity: sha512-7ZgogeTnjuHbo+ct10G9Ffp0mif17idi0IyWNVA/wcwcm7NPOD/WEHVP3n7n3MhXqxoIYm8d6MuZohYWIZ4T3w==}
+
   dom-serializer@0.2.2:
     resolution: {integrity: sha512-2/xPb3ORsQ42nHYiSunXkDjPLBaEj/xTwUO4B7XCZQTRk7EBtTOPaygh10YAAh2OI1Qrp6NWfpAhzswj0ydt9g==}
 
@@ -5091,6 +5496,10 @@ packages:
     resolution: {integrity: sha512-aN97NXWF6AWBTahfVOIrB/NShkzi5H7F9r1s9mD3cDj4Ko5f2qhhVoYMibXF7GlLveb/D2ioWay8lxI97Ven3g==}
     engines: {node: '>=0.12'}
 
+  entities@8.0.0:
+    resolution: {integrity: sha512-zwfzJecQ/Uej6tusMqwAqU/6KL2XaB2VZ2Jg54Je6ahNBGNH6Ek6g3jjNCF0fG9EWQKGZNddNjU5F1ZQn/sBnA==}
+    engines: {node: '>=20.19.0'}
+
   env-paths@2.2.1:
     resolution: {integrity: sha512-+h1lkLKhZMTYjog1VEpJNG7NZJWcuc2DDk/qsqSTRRCOXiLjeQ1d1/udrUGhqMxUgAlwKNZ0cf2uqan5GLuS2A==}
     engines: {node: '>=6'}
@@ -5242,6 +5651,9 @@ packages:
   eventemitter3@5.0.1:
     resolution: {integrity: sha512-GWkBvjiSZK87ELrYOSESUYeVIc9mvLLf/nXalMOS5dYrgZq9o5OVkbZAVM06CVxYsCwH9BDZFPlQTlPA1j4ahA==}
 
+  eventemitter3@5.0.4:
+    resolution: {integrity: sha512-mlsTRyGaPBjPedk6Bvw+aqbsXDtoAyAzm5MO7JgU+yVRyMQ5O8bD4Kcci7BS85f93veegeCPkL8R4GLClnjLFw==}
+
   events@3.3.0:
     resolution: {integrity: sha512-mQw+2fkQbALzQ7V0MY0IqdnXNOeTtP4r0lN9z7AAawCXgqea7bDii20AYrIBrFd/Hx0M2Ocz6S111CaFkUcb0Q==}
     engines: {node: '>=0.8.x'}
@@ -5340,6 +5752,10 @@ packages:
     resolution: {integrity: sha512-XXTUwCvisa5oacNGRP9SfNtYBNAMi+RPwBFmblZEF7N7swHYQS6/Zfk7SRwx4D5j3CH211YNRco1DEMNVfZCnQ==}
     engines: {node: '>=16.0.0'}
 
+  file-type@21.3.4:
+    resolution: {integrity: sha512-Ievi/yy8DS3ygGvT47PjSfdFoX+2isQueoYP1cntFW1JLYAuS4GD7NUPGg4zv2iZfV52uDyk5w5Z0TdpRS6Q1g==}
+    engines: {node: '>=20'}
+
   filename-reserved-regex@2.0.0:
     resolution: {integrity: sha512-lc1bnsSr4L4Bdif8Xb/qrtokGbq5zlsms/CYH8PP+WtCkGNF65DPiQY8vG3SakEdRn8Dlnm+gW/qWKKjS5sZzQ==}
     engines: {node: '>=4'}
@@ -5360,6 +5776,10 @@ packages:
     resolution: {integrity: sha512-NWzkk0jSJtTt08+FBFMvXoeZnOJD+jTtsRmBYbAIzJdX6l7dLgR7CTubCM5/eDdPUBvLCeVasP1brfVR/9/EZQ==}
     engines: {node: '>=4'}
 
+  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'}
@@ -5670,6 +6090,10 @@ packages:
     resolution: {integrity: sha512-NqADB8VjPFLM2V0VvHUewwwsw0ZWBaIdgo+ieHtK3hasLz4qeCRjYcqfB6AQrBggRKppKF8L52/VqdVsO47Dlw==}
     engines: {node: '>= 0.4'}
 
+  hashery@1.5.1:
+    resolution: {integrity: sha512-iZyKG96/JwPz1N55vj2Ie2vXbhu440zfUfJvSwEqEbeLluk7NnapfGqa7LH0mOsnDxTF85Mx8/dyR6HfqcbmbQ==}
+    engines: {node: '>=20'}
+
   hasown@2.0.2:
     resolution: {integrity: sha512-0hJU9SCPvmMzIBdZFqNPXWa6dqh7WdH0cII9y+CyS8rG3nL48Bclra9HmKhVVUHyPWNH5Y7xDwAB7bfgSjkUMQ==}
     engines: {node: '>= 0.4'}
@@ -5731,6 +6155,12 @@ packages:
     resolution: {integrity: sha512-PmQi306+M/ct/m5s66Hrg+adPnkD5jiO6IjA7WhWw0gSBSo1EcRegwuI1deZ+wd5pzCGynCcn2DprnE4/yEV4w==}
     engines: {node: '>=16.9.0'}
 
+  hookified@1.15.1:
+    resolution: {integrity: sha512-MvG/clsADq1GPM2KGo2nyfaWVyn9naPiXrqIe4jYjXNZQt238kWyOGrsyc/DmRAQ+Re6yeo6yX/yoNCG5KAEVg==}
+
+  hookified@2.2.0:
+    resolution: {integrity: sha512-p/LgFzRN5FeoD3DLS6bkUapeye6E4SI6yJs6KetENd18S+FBthqYq2amJUWpt5z0EQwwHemidjY5OqJGEKm5uA==}
+
   hosted-git-info@2.8.9:
     resolution: {integrity: sha512-mxIDAb9Lsm6DoOJ7xH+5+X4y1LU/4Hi50L9C5sIswK3JzULS4bwk1FvjdBgvYR4bzT4tuUQiC15FE2f5HbLvYw==}
 
@@ -5740,6 +6170,10 @@ packages:
   hsl-to-rgb-for-reals@1.1.1:
     resolution: {integrity: sha512-LgOWAkrN0rFaQpfdWBQlv/VhkOxb5AsBjk6NQVx4yEzWS923T07X0M1Y0VNko2H52HeSpZrZNNMJ0aFqsdVzQg==}
 
+  html-encoding-sniffer@6.0.0:
+    resolution: {integrity: sha512-CV9TW3Y3f8/wT0BRFc1/KAVQ3TUHiXmaAb6VW9vtiMFf7SLoMd1PdAc4W3KFOFETBJUb90KatHqlsZMWV+R9Gg==}
+    engines: {node: ^20.19.0 || ^22.12.0 || >=24.0.0}
+
   html-entities@2.6.0:
     resolution: {integrity: sha512-kig+rMn/QOVRvr7c86gQ8lWXq+Hkv6CbAH1hLu+RG338StTpE8Z0b44SDVaqVu7HGKf27frdmUYEs9hTUX/cLQ==}
 
@@ -5978,6 +6412,9 @@ packages:
     resolution: {integrity: sha512-+Pgi+vMuUNkJyExiMBt5IlFoMyKnr5zhJ4Uspz58WOhBF5QoIZkFyNHIbBAtHwzVAgk5RtndVNsDRN61/mmDqg==}
     engines: {node: '>=12'}
 
+  is-potential-custom-element-name@1.0.1:
+    resolution: {integrity: sha512-bCYeRA2rVibKZd+s2625gGnGF/t7DSqDs4dP7CrLA1m7jKWz6pps0LpYLJN8Q64HtmPKJ1hrN3nzPNKFEKOUiQ==}
+
   is-promise@4.0.0:
     resolution: {integrity: sha512-hvpoI6korhJMnej285dSg6nu1+e6uxs7zG3BYAm5byqDsgJNWwxzM6z6iZiAgQR4TJ30JmBTOwqZUw3WlyH3AQ==}
 
@@ -6061,6 +6498,15 @@ packages:
     resolution: {integrity: sha512-qQKT4zQxXl8lLwBtHMWwaTcGfFOZviOJet3Oy/xmGk2gZH677CJM9EvtfdSkgWcATZhj/55JZ0rmy3myCT5lsA==}
     hasBin: true
 
+  jsdom@29.1.1:
+    resolution: {integrity: sha512-ECi4Fi2f7BdJtUKTflYRTiaMxIB0O6zfR1fX0GXpUrf6flp8QIYn1UT20YQqdSOfk2dfkCwS8LAFoJDEppNK5Q==}
+    engines: {node: ^20.19.0 || ^22.13.0 || >=24.0.0}
+    peerDependencies:
+      canvas: ^3.0.0
+    peerDependenciesMeta:
+      canvas:
+        optional: true
+
   jsesc@3.1.0:
     resolution: {integrity: sha512-/sM3dO2FOzXjKQhJuo0Q173wf2KOo8t4I8vHy6lF9poUp7bKT0/NHE8fPX23PwfhnykfqnC2xRxOnVw5XuGIaA==}
     engines: {node: '>=6'}
@@ -6132,6 +6578,9 @@ packages:
   keyv@4.5.4:
     resolution: {integrity: sha512-oxVHkHR/EJf2CNXnWxRLW6mg7JyCCUcG0DtEGmL2ctUo1PNTin1PUil+r/+4r5MpVgC/fn1kjsx7mjSujKqIpw==}
 
+  keyv@5.6.0:
+    resolution: {integrity: sha512-CYDD3SOtsHtyXeEORYRx2qBtpDJFjRTGXUtmNEMGyzYOKj1TE3tycdlho7kA1Ufx9OYWZzg52QFBGALTirzDSw==}
+
   khroma@2.1.0:
     resolution: {integrity: sha512-Ls993zuzfayK269Svk9hzpeGUKob/sIgZzyHYdjQoAdQetRKpOLj+k/QQQ/6Qi0Yz65mlROrfd+Ev+1+7dz9Kw==}
 
@@ -6149,6 +6598,9 @@ packages:
     resolution: {integrity: sha512-+bT2uH4E5LGE7h/n3evcS/sQlJXCpIp6ym8OWJ5eV6+67Dsql/LaaT7qJBAt2rzfoa/5QBGBhxDix1dMt2kQKQ==}
     engines: {node: '>= 0.8.0'}
 
+  libsignal@6.0.0:
+    resolution: {integrity: sha512-d/5V3YFtDljbFMufz4ncyUYGYhJl+vzAe+c2EFFBQ6bz1h8Q3IOMEGXYMzlibU60I+e8GagMMpji18iez3P1hA==}
+
   lie@3.3.0:
     resolution: {integrity: sha512-UaiMJzeWRlEujzAuw5LokY1L5ecNQYZKfmyZ9L7wDHb/p5etKaxXhohBcrw0EYby+G/NA52vRSN4N39dxHAIwQ==}
 
@@ -6247,6 +6699,10 @@ packages:
     resolution: {integrity: sha512-NCI2kiDkyR7VeEKm27Kda/iQHyKJe1Bu0FlTbYp3CqJu+9IFe9bLyAjMxf5ZDDbEg+iMPzB5zYyUTSm8wVTKmA==}
     engines: {node: '>=4'}
 
+  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'}
@@ -6299,6 +6755,10 @@ packages:
     resolution: {integrity: sha512-B5Y16Jr9LB9dHVkh6ZevG+vAbOsNOYCX+sXvFWFu7B3Iz5mijW3zdbMyhsh8ANd2mSWBYdJgnqi+mL7/LrOPYg==}
     engines: {node: 20 || >=22}
 
+  lru-cache@11.5.1:
+    resolution: {integrity: sha512-RPimw/7aMdv2oqRrxKwvZXcPfwBrn/JZ2xYcY9Hus/6LaS3VOAKVWKWgNLCFSiOm1ESXinjsDlidVU7JlnCN2A==}
+    engines: {node: 20 || >=22}
+
   lru-cache@5.1.1:
     resolution: {integrity: sha512-KpNARQA3Iwv+jTA0utUVVbrh+Jlrr1Fv0e56GGzAFOXN7dk/FviaDW8LHmK52DlcH4WP2n6gI8vN1aesBFgo9w==}
 
@@ -6320,6 +6780,10 @@ packages:
     resolution: {integrity: sha512-vtEhXh/gNjI9Yg1u4jX/0YVPMvxzHuGgCm6tC5kZyb08yjGWGnqAjGJvcXbqQR2P3MyMEFnRbpcdFS6PBcLqew==}
     engines: {node: '>=12'}
 
+  lz-string@1.5.0:
+    resolution: {integrity: sha512-h5bgJWpxJNswbU7qCrV0tIKQCaS3blPDrqKWx+QxzuzL1zGUzij9XCWLrSLsJPu5t+eWA/ycetzYAO5IOMcWAQ==}
+    hasBin: true
+
   macos-alias@0.2.12:
     resolution: {integrity: sha512-yiLHa7cfJcGRFq4FrR4tMlpNHb4Vy4mWnpajlSSIFM5k4Lv8/7BbbDLzCAVogWNl0LlLhizRp1drXv0hK9h0Yw==}
     os: [darwin]
@@ -6414,6 +6878,9 @@ packages:
   mdast-util-to-string@4.0.0:
     resolution: {integrity: sha512-0H44vDimn51F0YwvxSJSm0eCDOJTRlmN0R1yBh4HLj9wiV1Dn0QoXGbvFAWj2hSItVTlCmBF1hqKlIyUBVFLPg==}
 
+  mdn-data@2.27.1:
+    resolution: {integrity: sha512-9Yubnt3e8A0OKwxYSXyhLymGW4sCufcLG6VdiDdUGVkPhpqLxlvP5vl1983gQjJl3tqbrM731mjaZaP68AgosQ==}
+
   mdurl@2.0.0:
     resolution: {integrity: sha512-Lf+9+2r+Tdp5wXDXC4PcIBjTDtq4UKjCPMQhKIuzpJNW0b96kVqSwW0bT7FhRSfmAiFYgP+SCRvdrDozfh0U5w==}
 
@@ -6424,6 +6891,10 @@ packages:
     resolution: {integrity: sha512-aisnrDP4GNe06UcKFnV5bfMNPBUw4jsLGaWwWfnH3v02GnBuXX2MCVn5RbrWo0j3pczUilYblq7fQ7Nw2t5XKw==}
     engines: {node: '>= 0.8'}
 
+  media-typer@2.0.0:
+    resolution: {integrity: sha512-kOy3OxT2HH39N70UnKgu4NWDZjLOz8W/mfyvniHjRH/DrL3f2pOfvWQ4p60offbbtDAnXWp0v9LfMIqMec269Q==}
+    engines: {node: '>=18'}
+
   mem@4.3.0:
     resolution: {integrity: sha512-qX2bG48pTqYRVmDB37rn/6PT7LcR8T7oAX3bf99u1Tt1nzxYfxkgqDwUwolPlXweM0XzBOBFzSx4kfp7KP1s/w==}
     engines: {node: '>=6'}
@@ -6593,6 +7064,10 @@ packages:
   min-document@2.19.2:
     resolution: {integrity: sha512-8S5I8db/uZN8r9HSLFVWPdJCvYOejMcEC82VIzNUc6Zkklf/d1gg2psfE79/vyhWOj4+J8MtwmoOz3TmvaGu5A==}
 
+  min-indent@1.0.1:
+    resolution: {integrity: sha512-I9jwMn07Sy/IwOj3zVkVik2JTvgpaykDZEigL6Rx6N9LbMywwUSMtxET+7lVoDLLd3O3IXwJwvuuns8UB/HeAg==}
+    engines: {node: '>=4'}
+
   minimatch@10.1.1:
     resolution: {integrity: sha512-enIvLvRAFZYXJzkCYG5RKmPfrFArdLv+R+lbQ53BmIMLIry74bjKzX6iHAm8WYamJkhSSEabrWN5D97XnKObjQ==}
     engines: {node: 20 || >=22}
@@ -6691,6 +7166,10 @@ packages:
   murmur-32@0.2.0:
     resolution: {integrity: sha512-ZkcWZudylwF+ir3Ld1n7gL6bI2mQAzXvSobPwVtu8aYi2sbXeipeSkdcanRLzIofLcM5F53lGaKm2dk7orBi7Q==}
 
+  music-metadata@11.13.0:
+    resolution: {integrity: sha512-uXRaov9dfjSpQufXIU7sMxVZnh+FilCQv2mXn+K5EJ/decP3dTWrgvPYa5r6MtRbieNSCE708Da4J0u1UGfQIw==}
+    engines: {node: '>=18'}
+
   mute-stream@1.0.0:
     resolution: {integrity: sha512-avsJQhyd+680gKXyG/sQc0nXaC6rBkPOfyHYcFb9+hdkqQkR9bdnkJ0AMZhke0oesPqIO+mFFJ+IdBc7mst4IA==}
     engines: {node: ^14.17.0 || ^16.13.0 || >=18.0.0}
@@ -6822,6 +7301,10 @@ packages:
     peerDependencies:
       zod: ^4.0.16
 
+  on-exit-leak-free@2.1.2:
+    resolution: {integrity: sha512-0eJJY6hXLGf1udHwfNftBqH+g73EU4B504nZeKpz1sYRKafAghwxEJunB2O7rDZkL4PGfsMVnTXZ2EjibbqcsA==}
+    engines: {node: '>=14.0.0'}
+
   on-finished@2.4.1:
     resolution: {integrity: sha512-oVlzkg3ENAhCk2zdv7IJwd/QUD4z2RxRwpkcGY8psCVcCYZNq4wYnVWALHM+brtuJjePWiYF/ClmuDr8Ch5+kg==}
     engines: {node: '>= 0.8'}
@@ -6900,6 +7383,10 @@ packages:
     resolution: {integrity: sha512-vvcXsLAJ9Dr5rQOPk7toZQZJApBl2K4J6dANSsEuh6QI41JYcsS/qhTGa9ErIUUgK3WNQoJYvylxvjqmiqEA9Q==}
     engines: {node: '>=4'}
 
+  p-limit@2.3.0:
+    resolution: {integrity: sha512-//88mFWSJx8lxCzwdAABTJL2MyWB12+eIY7MDL2SqLmAkeKU9qxRvWuSyTjm3FUmpBEMuFfckAIqEaVGUDxb6w==}
+    engines: {node: '>=6'}
+
   p-limit@3.1.0:
     resolution: {integrity: sha512-TYOanM3wGwNGsZN2cVTYPArw454xnXj5qmWF1bEoAc4+cU/ol7GVh7odevjp1FNHduHc3KZMcFduxU5Xc6uJRQ==}
     engines: {node: '>=10'}
@@ -6908,6 +7395,10 @@ packages:
     resolution: {integrity: sha512-nQja7m7gSKuewoVRen45CtVfODR3crN3goVQ0DDZ9N3yHxgpkuBhZqsaiotSQRrADUrne346peY7kT3TSACykg==}
     engines: {node: '>=4'}
 
+  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'}
@@ -6920,6 +7411,10 @@ packages:
     resolution: {integrity: sha512-RwFpb72c/BhQLEXIZ5K2e+AhgNVmIejGlTgiB9MzZ0e93GRvqZ7uSi0dvRF7/XIXDeNkra2fNHBxTyPDGySpjQ==}
     engines: {node: '>=8'}
 
+  p-queue@9.3.0:
+    resolution: {integrity: sha512-7NED7xhQ74Ngp4JP/2e0VZHp7vSWfJfqeiR92jPgxsz6m0Se4P03YoTKa9dDXyZ3r6P616gUXttrB6nnHYKang==}
+    engines: {node: '>=20'}
+
   p-retry@4.6.2:
     resolution: {integrity: sha512-312Id396EbJdvRONlngUx0NydfrIQ5lsYu0znKVUzVvArzEIt08V1qhtyESbGVd1FGX7UKtiFp5uwKZdM8wIuQ==}
     engines: {node: '>=8'}
@@ -6928,10 +7423,18 @@ packages:
     resolution: {integrity: sha512-rhIwUycgwwKcP9yTOOFK/AKsAopjjCakVqLHePO3CC6Mir1Z99xT+R63jZxAT5lFZLa2inS5h+ZS2GvR99/FBg==}
     engines: {node: '>=8'}
 
+  p-timeout@7.0.1:
+    resolution: {integrity: sha512-AxTM2wDGORHGEkPCt8yqxOTMgpfbEHqF51f/5fJCmwFC3C/zNcGT63SymH2ttOAaiIws2zVg4+izQCjrakcwHg==}
+    engines: {node: '>=20'}
+
   p-try@1.0.0:
     resolution: {integrity: sha512-U1etNYuMJoIz3ZXSrrySFjsXQTWOx2/jdi86L+2pRvph/qMKL6sbcCYdH23fqsbm8TH2Gn0OybpT4eSFlCVHww==}
     engines: {node: '>=4'}
 
+  p-try@2.2.0:
+    resolution: {integrity: sha512-R4nPAVTAU0B9D35/Gk3uJf/7XYbQcyohSKdvAxIRSNghFl4e71hVoGnBNQz9cWaXxO2I10KTC+3jMdvvoKw6dQ==}
+    engines: {node: '>=6'}
+
   package-json-from-dist@1.0.1:
     resolution: {integrity: sha512-UEZIS3/by4OC8vL3P2dTXRETpebLI2NiI5vIrjaD/5UtrkFX/tNbwjTSRAGC/+7CAo2pIcBaRgWmcBBHcsaCIw==}
 
@@ -6974,6 +7477,9 @@ packages:
   parse5@7.3.0:
     resolution: {integrity: sha512-IInvU7fabl34qmi9gY8XOVxhYyMyuH2xUNpb2q8/Y+7552KlejkRvqvD19nMoUW/uQGGbqNpA6Tufu5FL5BZgw==}
 
+  parse5@8.0.1:
+    resolution: {integrity: sha512-z1e/HMG90obSGeidlli3hj7cbocou0/wa5HacvI3ASx34PecNjNQeaHNo5WIZpWofN9kgkqV1q5YvXe3F0FoPw==}
+
   parseurl@1.3.3:
     resolution: {integrity: sha512-CiyeOxFT/JZyN5m0z9PfXw4SCBJ6Sygz1Dpl0wqjlhDEGGBP1GnsUVEL0p63hoG1fcj3fHynXi9NYO4nWOL+qQ==}
     engines: {node: '>= 0.8'}
@@ -7060,6 +7566,16 @@ packages:
     resolution: {integrity: sha512-uB80kBFb/tfd68bVleG9T5GGsGPjJrLAUpR5PZIrhBnIaRTQRjqdJSsIKkOP6OAIFbj7GOrcudc5pNjZ+geV2g==}
     engines: {node: '>=6'}
 
+  pino-abstract-transport@2.0.0:
+    resolution: {integrity: sha512-F63x5tizV6WCh4R6RHyi2Ml+M70DNRXt/+HANowMflpgGFMAym/VKm6G7ZOQRjqN7XbGxK1Lg9t6ZrtzOaivMw==}
+
+  pino-std-serializers@7.1.0:
+    resolution: {integrity: sha512-BndPH67/JxGExRgiX1dX0w1FvZck5Wa4aal9198SrRhZjH3GxKQUKIBnYJTdj2HDN3UQAS06HlfcSbQj2OHmaw==}
+
+  pino@9.14.0:
+    resolution: {integrity: sha512-8OEwKp5juEvb/MjpIc4hjqfgCNysrS94RIOMXYvpYCdm/jglrKEiAYmiumbmGhCvs+IcInsphYDFwqrjr7398w==}
+    hasBin: true
+
   pizzip@3.2.0:
     resolution: {integrity: sha512-X4NPNICxCfIK8VYhF6wbksn81vTiziyLbvKuORVAmolvnUzl1A1xmz9DAWKxPRq9lZg84pJOOAMq3OE61bD8IQ==}
 
@@ -7074,6 +7590,10 @@ packages:
     resolution: {integrity: sha512-uysumyrvkUX0rX/dEVqt8gC3sTBzd4zoWfLeS29nb53imdaXVvLINYXTI2GNqzaMuvacNx4uJQ8+b3zXR0pkgQ==}
     engines: {node: '>=10.4.0'}
 
+  pngjs@5.0.0:
+    resolution: {integrity: sha512-40QW5YalBNfQo5yRYmiw7Yz6TKKVr3h6970B2YE+3fQpsWcrbj1PzJgxeJ19DRQjhMbKPIuMY8rFaXc8moolVw==}
+    engines: {node: '>=10.13.0'}
+
   points-on-curve@0.2.0:
     resolution: {integrity: sha512-0mYKnYYe9ZcqMCWhUjItv/oHjvgEsfKvnUTg8sAtnHr3GVy7rGkXCb6d5cSyqrWqL4k81b9CPg3urd+T7aop3A==}
 
@@ -7119,6 +7639,10 @@ packages:
     engines: {node: '>=14'}
     hasBin: true
 
+  pretty-format@27.5.1:
+    resolution: {integrity: sha512-Qb1gy5OrP5+zDf2Bvnzdl3jsTf1qXVMazbvCoKhtKqVs4/YK4ozX4gKQJJVyNe+cajNPn0KoC0MC3FUmaHWEmQ==}
+    engines: {node: ^10.13.0 || ^12.13.0 || ^14.15.0 || >=15.0.0}
+
   proc-log@2.0.1:
     resolution: {integrity: sha512-Kcmo2FhfDTXdcbfDH76N7uBYHINxc/8GW7UAVuVP9I+Va3uHSerrnKV6dLooga/gh7GlgzuCCr/eoldnL1muGw==}
     engines: {node: ^12.13.0 || ^14.15.0 || >=16.0.0}
@@ -7126,6 +7650,9 @@ packages:
   process-nextick-args@2.0.1:
     resolution: {integrity: sha512-3ouUOpQhtgrbOa17J7+uxOTpITYWaGP7/AhoR3+A+/1e9skrzelGi/dXzEYyvbxubEF6Wn2ypscTKiKJFFn1ag==}
 
+  process-warning@5.0.0:
+    resolution: {integrity: sha512-a39t9ApHNx2L4+HBnQKqxxHNs1r7KF+Intd8Q/g1bUh6q0WIp9voPXJ/x0j+ZL45KF1pJd9+q2jLIRMfvEshkA==}
+
   process@0.11.10:
     resolution: {integrity: sha512-cdGef/drWFoydD1JsMzuFf8100nZl+GT+yacc2bEced5f9Rjk4z+WtFUTBu9PhOi9j/jfmBPu0mMEY4wIdAF8A==}
     engines: {node: '>= 0.6.0'}
@@ -7195,6 +7722,10 @@ packages:
     resolution: {integrity: sha512-CvexbZtbov6jW2eXAvLukXjXUW1TzFaivC46BpWc/3BpcCysb5Vffu+B3XHMm8lVEuy2Mm4XGex8hBSg1yapPg==}
     engines: {node: '>=12.0.0'}
 
+  protobufjs@7.6.4:
+    resolution: {integrity: sha512-RJJPTTpvFfHcWLkIa2JFWK4XvtSzS0yEWDmunqHXli1h3JlkbcQZXDZdcWxv+JK3Xsl5/UFDPZ0iGm7DAengYw==}
+    engines: {node: '>=12.0.0'}
+
   proxy-addr@2.0.7:
     resolution: {integrity: sha512-llQsMLSUDUPT44jdrU/O37qlnifitDP+ZwrmmZcoSKyLKvtZxpyV0n2/bD/N4tBAAZ/gJEdZU7KMraoK1+XYAg==}
     engines: {node: '>= 0.10'}
@@ -7223,6 +7754,15 @@ packages:
   pusher-js@8.4.0:
     resolution: {integrity: sha512-wp3HqIIUc1GRyu1XrP6m2dgyE9MoCsXVsWNlohj0rjSkLf+a0jLvEyVubdg58oMk7bhjBWnFClgp8jfAa6Ak4Q==}
 
+  qified@0.10.1:
+    resolution: {integrity: sha512-+Owyggi9IxT1ePKGafcI87ubSmxol6smwJ+RAHDQlx9+9cPwFWDiKFFCPuWhr9ignlGpZ9vDQLw67N4dcTVFEA==}
+    engines: {node: '>=20'}
+
+  qrcode@1.5.4:
+    resolution: {integrity: sha512-1ca71Zgiu6ORjHqFBDpnSMTR2ReToX4l1Au1VFLyVeBTFavzQnv5JxMFr3ukHVKpSrSA2MCk0lNJSykjUfz7Zg==}
+    engines: {node: '>=10.13.0'}
+    hasBin: true
+
   qs@6.14.1:
     resolution: {integrity: sha512-4EK3+xJl8Ts67nLYNwqw/dsFVnCf+qR7RgXSK9jEEm9unao3njwMDdmsdvoKBKHzxd7tCYz5e5M+SnMjdtXGQQ==}
     engines: {node: '>=0.6'}
@@ -7236,6 +7776,9 @@ packages:
   queue@6.0.2:
     resolution: {integrity: sha512-iHZWu+q3IdFZFX36ro/lKBkSvfkztY5Y7HMiPlOUjhupPcG2JMfst2KKEpu5XndviX/3UhFbRngUPNKtgvtZiA==}
 
+  quick-format-unescaped@4.0.4:
+    resolution: {integrity: sha512-tYC1Q1hgyRuHgloV/YXs2w15unPVh8qfu/qCTfhTYamaw7fyhumKa2yGpdSo87vY32rIclj+4fWYQXUMs9EHvg==}
+
   quick-lru@5.1.1:
     resolution: {integrity: sha512-WuyALRjWPDGtt/wzJiadO5AXY+8hZ80hVpe6MyivgraREW751X3SbhRvG3eLKOYN+8VEvqLcf3wdnt44Z4S4SA==}
     engines: {node: '>=10'}
@@ -7275,6 +7818,9 @@ packages:
   react-is@16.13.1:
     resolution: {integrity: sha512-24e6ynE2H+OKt4kqsOvNd8kBpV65zoxbA4BVsEOB3ARVWQki/DHzaUoC5KuON/BiccDaCCTZBuOcfZs70kR8bQ==}
 
+  react-is@17.0.2:
+    resolution: {integrity: sha512-w2GsyukL62IJnlaff/nRegPQR94C/XXamvMWmSHRJ4y7Ts/4ocGRmTHvOs8PSE6pB3dWOrD/nueuU5sduBsQ4w==}
+
   react-redux@9.2.0:
     resolution: {integrity: sha512-ROY9fvHhwOD9ySfrF0wmvu//bKCQ6AeZZq1nJNtbDC+kk5DuSuNX/n6YWYF/SYy7bSba4D4FSz8DJeKY/S/r+g==}
     peerDependencies:
@@ -7358,6 +7904,10 @@ packages:
     resolution: {integrity: sha512-GDhwkLfywWL2s6vEjyhri+eXmfH6j1L7JE27WhqLeYzoh/A3DBaYGEj2H/HFZCn/kMfim73FXxEJTw06WtxQwg==}
     engines: {node: '>= 14.18.0'}
 
+  real-require@0.2.0:
+    resolution: {integrity: sha512-57frrGM/OCTLqLOAh0mhVA9VBMHd+9U7Zb2THMGdBUoZVOtGbJzjxsYGDJ3A9AYYCP4hn6y1TVbaOfzWtm5GFg==}
+    engines: {node: '>= 12.13.0'}
+
   recharts@3.8.1:
     resolution: {integrity: sha512-mwzmO1s9sFL0TduUpwndxCUNoXsBw3u3E/0+A+cLcrSfQitSG62L32N69GhqUrrT5qKcAE3pCGVINC6pqkBBQg==}
     engines: {node: '>=18'}
@@ -7370,6 +7920,10 @@ packages:
     resolution: {integrity: sha512-/vxpCXddiX8NGfGO/mTafwjq4aFa/71pvamip0++IQk3zG8cbCj0fifNPrjjF1XMXUne91jL9OoxmdykoEtifQ==}
     engines: {node: '>= 10.13.0'}
 
+  redent@3.0.0:
+    resolution: {integrity: sha512-6tDA8g98We0zd0GvVeMT9arEOnTw9qM03L9cJXaCjrip1OO764RDBLBfrB4cwzNGDj5OA5ioymC9GkizgWJDUg==}
+    engines: {node: '>=8'}
+
   redux-thunk@3.1.0:
     resolution: {integrity: sha512-NW2r5T6ksUKXCabzhL9z+h206HQw/NJkcLm1GPImRQ8IzfXwRGqjVhKJGauHirT0DAuyy6hjdnMZaRoAcy0Klw==}
     peerDependencies:
@@ -7449,6 +8003,9 @@ packages:
     resolution: {integrity: sha512-Xf0nWe6RseziFMu+Ap9biiUbmplq6S9/p+7w7YXP/JBHhrUDDUhwa+vANyubuqfZWTveU//DYVGsDG7RKL/vEw==}
     engines: {node: '>=0.10.0'}
 
+  require-main-filename@2.0.0:
+    resolution: {integrity: sha512-NKN5kMDylKuldxYLSUfrbo5Tuzh4hd+2E8NPPX02mZtn1VuREQToYe/ZdlJy+J3uCpfaiGF05e7B8W0iXbQHmg==}
+
   resedit@2.0.3:
     resolution: {integrity: sha512-oTeemxwoMuxxTYxXUwjkrOPfngTQehlv0/HoYFNkB4uzsP1Un1A9nI8JQKGOFkxpqkC7qkMs0lUsGrvUlbLNUA==}
     engines: {node: '>=14', npm: '>=7'}
@@ -7556,6 +8113,10 @@ packages:
     resolution: {integrity: sha512-x/+Cz4YrimQxQccJf5mKEbIa1NzeCRNI5Ecl/ekmlYaampdNLPalVyIcCZNNH3MvmqBugV5TMYZXv0ljslUlaw==}
     engines: {node: '>= 0.4'}
 
+  safe-stable-stringify@2.5.0:
+    resolution: {integrity: sha512-b3rppTKm9T+PsVCBEOUR46GWI7fdOs00VKZ1+9c1EWDaDMvjQc6tUwuFyIprgGgTcWoVHSKrU8H31ZHA2e0RHA==}
+    engines: {node: '>=10'}
+
   safer-buffer@2.1.2:
     resolution: {integrity: sha512-YZo3K82SD7Riyi0E1EQPojLz7kpepnSQI9IyPbHHg1XXXevb5dJI7tpyN2ADxGcQbHG7vcyRHk0cbwqcQriUtg==}
 
@@ -7563,6 +8124,10 @@ packages:
     resolution: {integrity: sha512-6R3J5M4AcbtLUdZmRv2SygeVaM7IhrLXu9BmnOGmmACak8fiUtOsYNWUS4uK7upbmHIBbLBeFeI//477BKLBzA==}
     engines: {node: '>=11.0.0'}
 
+  saxes@6.0.0:
+    resolution: {integrity: sha512-xAg7SOnEhrm5zI3puOOKyy1OMcMlIJZYNJY7xLBwSze0UjhPLnWfj2GF2EpT0jmzaJKIWKHLsaSSajf35bcYnA==}
+    engines: {node: '>=v12.22.7'}
+
   scheduler@0.25.0-rc-603e6108-20241029:
     resolution: {integrity: sha512-pFwF6H1XrSdYYNLfOcGlM28/j8CGLu8IvdrxqhjWULe2bPcKiKW4CV+OWqR/9fT52mywx65l7ysNkjLKBda7eA==}
 
@@ -7589,6 +8154,11 @@ packages:
     engines: {node: '>=10'}
     hasBin: true
 
+  semver@7.8.5:
+    resolution: {integrity: sha512-Y7/KDsb8LjooZpwaqGyulO6DQlksgCncchHGk+sZIY4SBvUocMBEFH5Ur1fI4dV+Jvl0w6cjvucaIi40puRioA==}
+    engines: {node: '>=10'}
+    hasBin: true
+
   send@1.2.1:
     resolution: {integrity: sha512-1gnZf7DFcoIcajTjTwjwuDjzuz4PPcY2StKPlsGAQ1+YH20IRVrBaXSWmdjowTJ6u8Rc01PoYOGHXfP1mYcZNQ==}
     engines: {node: '>= 18'}
@@ -7607,6 +8177,9 @@ packages:
   server-destroy@1.0.1:
     resolution: {integrity: sha512-rb+9B5YBIEzYcD6x2VKidaa+cqYBJQKnU4oe4E3ANwRRN56yk/ua1YCJT1n21NTS8w6CcOclAKNP3PhdCXKYtQ==}
 
+  set-blocking@2.0.0:
+    resolution: {integrity: sha512-KiKBS8AnWGEyLzofFfmvKwpdPzqiy16LvQfK3yv/fVH7Bj13/wl3JSR1J+rfgRE9q7xUJK4qvgS8raSOeLUehw==}
+
   set-function-length@1.2.2:
     resolution: {integrity: sha512-pgRc4hJ4/sNjWCSS9AmnS40x3bNMDTknHgL5UaMBTMyJnU90EgWh1Rz+MC9eFu4BuN/UwZjKQuY/1v3rM7HMfg==}
     engines: {node: '>= 0.4'}
@@ -7622,6 +8195,15 @@ packages:
     engines: {node: '>= 0.10'}
     hasBin: true
 
+  sharp@0.35.3:
+    resolution: {integrity: sha512-ej0zVHuZGHCiABXcNxeYhpRnPNPAcvbG8RMdBAhDAxLKkCRVSpK3Iyu7qbqw3JMzoj0REeM6f3tJLtVwl0023Q==}
+    engines: {node: '>=20.9.0'}
+    peerDependencies:
+      '@types/node': '*'
+    peerDependenciesMeta:
+      '@types/node':
+        optional: true
+
   shebang-command@1.2.0:
     resolution: {integrity: sha512-EV3L1+UQWGor21OmnvojK36mhg+TyIKDh3iFBKBohr5xeXIhNBcx8oWdgkTEEQ+BEFFYdLRuqMfd5L84N1V5Vg==}
     engines: {node: '>=0.10.0'}
@@ -7700,6 +8282,9 @@ packages:
     resolution: {integrity: sha512-HLpt+uLy/pxB+bum/9DzAgiKS8CX1EvbWxI4zlmgGCExImLdiad2iCwXT5Z4c9c3Eq8rP2318mPW2c+QbtjK8A==}
     engines: {node: '>= 10.0.0', npm: '>= 3.0.0'}
 
+  sonic-boom@4.2.1:
+    resolution: {integrity: sha512-w6AxtubXa2wTXAUsZMMWERrsIRAdrK0Sc+FUytWvYAhBJLyuI4llrMIC1DtlNSdI99EI86KZum2MMq3EAZlF9Q==}
+
   sonner@2.0.7:
     resolution: {integrity: sha512-W6ZN4p58k8aDKA4XPcx2hpIQXBRAgyiWVkYhT7CvK6D3iAu7xjvVyhQHg2/iaKJZ1XVJ4r7XuwGL+WGEK37i9w==}
     peerDependencies:
@@ -7732,6 +8317,10 @@ packages:
   spdx-license-ids@3.0.22:
     resolution: {integrity: sha512-4PRT4nh1EImPbt2jASOKHX7PB7I+e4IWNLvkKFDxNhJlfjbYlleYQh285Z/3mPTHSAK/AvdMmw5BNNuYH8ShgQ==}
 
+  split2@4.2.0:
+    resolution: {integrity: sha512-UcjcJOWknrNkF6PLX83qcHM6KHgVKNkV62Y8a5uYDVv9ydGQVwAHMKqHdJje1VTWpljG0WYpCDhrCdAOYH4TWg==}
+    engines: {node: '>= 10.x'}
+
   sprintf-js@1.0.3:
     resolution: {integrity: sha512-D9cPgkvLlV3t3IzL0D0YLvGA9Ahk4PcvVwUbN0dSGr1aP0Nrt4AEnTUbuGvquEC0mA64Gqt1fzirlRs5ibXx8g==}
 
@@ -7807,6 +8396,10 @@ packages:
     resolution: {integrity: sha512-7FCwGGmx8mD5xQd3RPUvnSpUXHM3BWuzjtpD4TXsfcZ9EL4azvVVUscFYwD9nx8Kh+uCBC00XBtAykoMHwTh8Q==}
     engines: {node: '>=0.10.0'}
 
+  strip-indent@3.0.0:
+    resolution: {integrity: sha512-laJTa3Jb+VQpaC6DseHhF7dXVqHTfJPCRDaEbid/drOhgitgYku/letMUqOXFoWV0zIIUbjpdH2t+tYj4bQMRQ==}
+    engines: {node: '>=8'}
+
   strip-json-comments@3.1.1:
     resolution: {integrity: sha512-6fPc+R4ihwqP6N/aIv2f1gMH8lOVtWQHoqC4yK6oSDVVocumAsfCqjkXnqiYMhmMwS/mEHLp7Vehlt3ql6lEig==}
     engines: {node: '>=8'}
@@ -7818,6 +8411,10 @@ packages:
   strnum@2.1.2:
     resolution: {integrity: sha512-l63NF9y/cLROq/yqKXSLtcMeeyOfnSQlfMSlzFt/K73oIaD8DGaQWd7Z34X9GPiKqP5rbSh84Hl4bOlLcjiSrQ==}
 
+  strtok3@10.3.5:
+    resolution: {integrity: sha512-ki4hZQfh5rX0QDLLkOCj+h+CVNkqmp/CMf8v8kZpkNVK6jGQooMytqzLZYUVYIZcFZ6yDB70EfD8POcFXiF5oA==}
+    engines: {node: '>=18'}
+
   style-mod@4.1.3:
     resolution: {integrity: sha512-i/n8VsZydrugj3Iuzll8+x/00GH2vnYsk1eomD8QiRrSAeW6ItbCQDtfXCeJHd0iwiNagqjQkvpvREEPtW3IoQ==}
 
@@ -7854,6 +8451,9 @@ packages:
     peerDependencies:
       react: ^16.11.0 || ^17.0.0 || ^18.0.0 || ^19.0.0
 
+  symbol-tree@3.2.4:
+    resolution: {integrity: sha512-9QNk5KwDF+Bvz+PyObkmSYjI5ksVUYtjW7AU22r2NKcfLJcXp96hkDWU3+XndOsUb+AQ9QhfzfCT2O+CNWT5Tw==}
+
   tailwind-merge@3.4.0:
     resolution: {integrity: sha512-uSaO4gnW+b3Y2aWoWfFpX62vn2sR3skfhbjsEnaBI81WD1wBLlHZe5sWf0AqjksNdYTbGBEd0UasQMT3SNV15g==}
 
@@ -7894,6 +8494,9 @@ packages:
     engines: {node: '>=10'}
     hasBin: true
 
+  thread-stream@3.2.0:
+    resolution: {integrity: sha512-zLBvqpwr4Esa0kRjcrzGU6zL25lePWaCLMx0RQFrmteozIfeNdaMLpG5U7PeHzvlFkAWaRKA9/KVW4F60iB+qw==}
+
   tiny-each-async@2.0.3:
     resolution: {integrity: sha512-5ROII7nElnAirvFn8g7H7MtpfV1daMcyfTGQwsn/x2VtyV+VPiO5CjReCJtWLvoKTDEDmZocf3cNPraiMnBXLA==}
 
@@ -7923,6 +8526,13 @@ packages:
     peerDependencies:
       '@tiptap/core': ^3.0.1
 
+  tldts-core@7.4.5:
+    resolution: {integrity: sha512-pGrwzZDvPwKe+7NNUqAunb6rqTfynr0VOUhCMdqbu5xlvNiszsAJygRzwvpVycdzejlbpY+SWJOn+s75Og7FEA==}
+
+  tldts@7.4.5:
+    resolution: {integrity: sha512-RfEzKWcq5fHUOFq7J3rl3Oz6ylKGtcHqUznzj4EcXsxLSIjJcvpbXAQtWGeJQ0xKnimR5e0Cn+cn9TssfMzm+g==}
+    hasBin: true
+
   tmp-promise@3.0.3:
     resolution: {integrity: sha512-RwM7MoPojPxsOBYnyd2hy0bxtIlVrihNs9pj5SUvY8Zz1sQcQG2tG1hSr8PDxfgEB8RNKDhqbIlroIarSNDNsQ==}
 
@@ -7953,12 +8563,24 @@ packages:
     resolution: {integrity: sha512-o5sSPKEkg/DIQNmH43V0/uerLrpzVedkUh8tGNvaeXpfpuwjKenlSox/2O/BTlZUtEe+JG7s5YhEz608PlAHRA==}
     engines: {node: '>=0.6'}
 
+  token-types@6.1.2:
+    resolution: {integrity: sha512-dRXchy+C0IgK8WPC6xvCHFRIWYUbqqdEIKPaKo/AcTUNzwLTK6AH7RjdLWsEZcAN/TBdtfUw3PYEgPr5VPr6ww==}
+    engines: {node: '>=14.16'}
+
   tokenlens@1.3.1:
     resolution: {integrity: sha512-7oxmsS5PNCX3z+b+z07hL5vCzlgHKkCGrEQjQmWl5l+v5cUrtL7S1cuST4XThaL1XyjbTX8J5hfP0cjDJRkaLA==}
 
+  tough-cookie@6.0.1:
+    resolution: {integrity: sha512-LktZQb3IeoUWB9lqR5EWTHgW/VTITCXg4D21M+lvybRVdylLrRMnqaIONLVb5mav8vM19m44HIcGq4qASeu2Qw==}
+    engines: {node: '>=16'}
+
   tr46@0.0.3:
     resolution: {integrity: sha512-N3WMsuqV66lT30CrXNbEjx4GEwlow3v6rr4mCcv6prnfwhS01rkgyFdjPNBYd9br7LpXV1+Emh01fHnq2Gdgrw==}
 
+  tr46@6.0.0:
+    resolution: {integrity: sha512-bLVMLPtstlZ4iMQHpFHTR7GAGj2jxi8Dg0s2h2MafAE4uSWF98FC/3MomU51iQAMf8/qDUbKWf5GxuvvVcXEhw==}
+    engines: {node: '>=20'}
+
   tree-kill@1.2.2:
     resolution: {integrity: sha512-L0Orpi8qGpRG//Nd+H90vFB+3iHnue1zSSGmNOOCh1GLJ7rUKVwV2HvijphGQS2UmhUZewS9VgvxYIdgr+fG1A==}
     hasBin: true
@@ -8049,6 +8671,10 @@ packages:
   ufo@1.6.1:
     resolution: {integrity: sha512-9a4/uxlTWJ4+a5i0ooc1rU7C7YOw3wT+UGqdeNNHWnOF9qcMBgLRS+4IYUqbczewFx4mLEig6gawh7X6mFlEkA==}
 
+  uint8array-extras@1.5.0:
+    resolution: {integrity: sha512-rvKSBiC5zqCCiDZ9kAOszZcDvdAHwwIKJG33Ykj43OKcWsnmcBRL09YTU4nOeHZ8Y2a7l1MgTd08SBe9A8Qj6A==}
+    engines: {node: '>=18'}
+
   underscore@1.13.8:
     resolution: {integrity: sha512-DXtD3ZtEQzc7M8m4cXotyHR+FAS18C64asBYY5vqZexfYryNNnDc02W4hKg3rdQuqOYas1jkseX0+nZXjTXnvQ==}
 
@@ -8058,6 +8684,10 @@ packages:
   undici-types@7.16.0:
     resolution: {integrity: sha512-Zz+aZWSj8LE6zoxD+xrjh4VfkIG8Ya6LvYkZqtUQGJPZjYl53ypCaUwWqo7eI0x66KBGeRo+mlBEkMSeSZ38Nw==}
 
+  undici@7.28.0:
+    resolution: {integrity: sha512-cRZYrTDwWznlnRiPjggAGxZXanty6M8RV1ff8Wm4LWXBp7/IG8v5DnOm74DtUBp9OONpK75YlPnIjQqX0dBDtA==}
+    engines: {node: '>=20.18.1'}
+
   unicode-emoji-modifier-base@1.0.0:
     resolution: {integrity: sha512-yLSH4py7oFH3oG/9K+XWrz1pSi3dfUrWEnInbxMfArOfc1+33BlGPQtLsOYwvdMy11AwUBetYuaRxSPqgkq+8g==}
     engines: {node: '>=4'}
@@ -8314,6 +8944,10 @@ packages:
   w3c-keyname@2.2.8:
     resolution: {integrity: sha512-dpojBhNsCNN7T82Tm7k26A6G9ML3NkhDsnw9n/eoxSRlVBB4CEtIQ/KTCLI2Fwf3ataSXRhYFkQi3SlnFwPvPQ==}
 
+  w3c-xmlserializer@5.0.0:
+    resolution: {integrity: sha512-o8qghlI8NZHU1lLPrpi2+Uq7abh4GGPpYANlalzWxyWteJOCsr/P+oPBA49TOLu5FTZO4d3F9MnWJfiMo4BkmA==}
+    engines: {node: '>=18'}
+
   wait-on@9.0.3:
     resolution: {integrity: sha512-13zBnyYvFDW1rBvWiJ6Av3ymAaq8EDQuvxZnPIw3g04UqGi4TyoIJABmfJ6zrvKo9yeFQExNkOk7idQbDJcuKA==}
     engines: {node: '>=20.0.0'}
@@ -8339,6 +8973,10 @@ packages:
   webidl-conversions@3.0.1:
     resolution: {integrity: sha512-2JAn3z8AR6rjK8Sm8orRC0h/bcl/DqL7tRPdGZ4I1CjdF+EaMLmYxBHyXuKL849eucPFhvBoxMsflfOb8kxaeQ==}
 
+  webidl-conversions@8.0.1:
+    resolution: {integrity: sha512-BMhLD/Sw+GbJC21C/UgyaZX41nPt8bUTg+jWyDeg7e7YN4xOM05YPSIXceACnXVtqyEw/LMClUQMtMZ+PGGpqQ==}
+    engines: {node: '>=20'}
+
   webpack-sources@3.3.3:
     resolution: {integrity: sha512-yd1RBzSGanHkitROoPFd6qsrxt+oFhg/129YzheDGqeustzX0vTZJZsSsQjVQC4yzBQ56K55XU8gaNCtIzOnTg==}
     engines: {node: '>=10.13.0'}
@@ -8353,9 +8991,23 @@ packages:
       webpack-cli:
         optional: true
 
+  whatsapp-rust-bridge@0.5.4:
+    resolution: {integrity: sha512-yYO1qSs0Fe7tGtnxOFHomocUD6IZtoAgmA4oDFyGIRZ67D3QZk3w7swA6XXFXNQngiyrg2k7tul6IrM3eUFh7A==}
+
+  whatwg-mimetype@5.0.0:
+    resolution: {integrity: sha512-sXcNcHOC51uPGF0P/D4NVtrkjSU2fNsm9iog4ZvZJsL3rjoDAzXZhkm2MWt1y+PUdggKAYVoMAIYcs78wJ51Cw==}
+    engines: {node: '>=20'}
+
+  whatwg-url@16.0.1:
+    resolution: {integrity: sha512-1to4zXBxmXHV3IiSSEInrreIlu02vUOvrhxJJH5vcxYTBDAx51cqZiKdyTxlecdKNSjj8EcxGBxNf6Vg+945gw==}
+    engines: {node: ^20.19.0 || ^22.12.0 || >=24.0.0}
+
   whatwg-url@5.0.0:
     resolution: {integrity: sha512-saE57nupxk6v3HY35+jzBwYa0rKSy0XR8JSxZPwgLr7ys0IBzhGviA1/TUGJLmSVqs8pb9AnvICXEuOHLprYTw==}
 
+  which-module@2.0.1:
+    resolution: {integrity: sha512-iBdZ57RDvnOR9AGBhML2vFZf7h8vmBjhoaZqODJBFWHVtKkDmKuHai3cx5PgVMrX5YDNp27AofYbAwctSS+vhQ==}
+
   which-typed-array@1.1.20:
     resolution: {integrity: sha512-LYfpUkmqwl0h9A2HL09Mms427Q1RZWuOHsukfVcKRq9q95iQxdw0ix1JQrqbcDR9PH1QDwf5Qo8OZb5lksZ8Xg==}
     engines: {node: '>= 0.4'}
@@ -8374,6 +9026,9 @@ packages:
     engines: {node: '>=8'}
     hasBin: true
 
+  win-guid@0.2.1:
+    resolution: {integrity: sha512-gEIQU4mkgl2OPeoNrWflcJFJ3Ae2BPd4eCsHHA/XikslkIVms/nHhvnvzIZV7VLmBvtFlDOzLt9rrZT+n6D67A==}
+
   wmf@1.0.2:
     resolution: {integrity: sha512-/p9K7bEh0Dj6WbXg4JG0xvLQmIadrner1bi45VMJTfnbVHsc7yIajZyoSoK60/dtVBs12Fm6WkUI5/3WAVsNMw==}
     engines: {node: '>=0.8'}
@@ -8401,6 +9056,18 @@ packages:
   wrappy@1.0.2:
     resolution: {integrity: sha512-l4Sp/DRseor9wL6EvV2+TuQn63dMkPjZ/sp9XkghTEbV9KlPS1xUsZ3u7/IQO4wxtcFB4bgpQPRcR3QCvezPcQ==}
 
+  ws@8.21.0:
+    resolution: {integrity: sha512-Vsp28b7DRcimFQvrqu2Wek3z1iYxDCWqHYB8Qsnk/S4RfaCQzPGPyBNuVjJV3cd6UiKtUtp6sNM77gWvzcCH+g==}
+    engines: {node: '>=10.0.0'}
+    peerDependencies:
+      bufferutil: ^4.0.1
+      utf-8-validate: '>=5.0.2'
+    peerDependenciesMeta:
+      bufferutil:
+        optional: true
+      utf-8-validate:
+        optional: true
+
   wsl-utils@0.3.1:
     resolution: {integrity: sha512-g/eziiSUNBSsdDJtCLB8bdYEUMj4jR7AGeUo96p/3dTafgjHhpF4RiCFPiRILwjQoDXx5MqkBr4fwWtR3Ky4Wg==}
     engines: {node: '>=20'}
@@ -8420,6 +9087,10 @@ packages:
     resolution: {integrity: sha512-7rVi2KMfwfWFl+GpPg6m80IVMWXLRjO+PxTq7V2CDhoGak0wzYzFgUY2m4XJ47OGdXd8eLE8EmwfAmdjw7lC1g==}
     hasBin: true
 
+  xml-name-validator@5.0.0:
+    resolution: {integrity: sha512-EvGK8EJ3DhaHfbRlETOWAS5pO9MZITeauHKJyb8wyajUfQUenkIg2MvLDTZ4T/TgIcm3HU0TFBgWWboAZ30UHg==}
+    engines: {node: '>=18'}
+
   xmlbuilder2@2.1.2:
     resolution: {integrity: sha512-PI710tmtVlQ5VmwzbRTuhmVhKnj9pM8Si+iOZCV2g2SNo3gCrpzR2Ka9wNzZtqfD+mnP+xkrqoNy0sjKZqP4Dg==}
     engines: {node: '>=8.0'}
@@ -8432,10 +9103,16 @@ packages:
     resolution: {integrity: sha512-yMqGBqtXyeN1e3TGYvgNgDVZ3j84W4cwkOXQswghol6APgZWaff9lnbvN7MHYJOiXsvGPXtjTYJEiC9J2wv9Eg==}
     engines: {node: '>=8.0'}
 
+  xmlchars@2.2.0:
+    resolution: {integrity: sha512-JZnDKK8B0RCDw84FNdDAIpZK+JuJw+s7Lz8nksI7SIuU3UXJJslUthsi+uWBUYOwPFwW7W7PRLRfUKpxjtjFCw==}
+
   xtend@4.0.2:
     resolution: {integrity: sha512-LKYU1iAXJXUgAXn9URjiu+MWhyUXHsvfp7mcuYm9dSUKK0/CjtrUwFAxD82/mCWbtLsGjFIad0wIsod4zrTAEQ==}
     engines: {node: '>=0.4'}
 
+  y18n@4.0.3:
+    resolution: {integrity: sha512-JKhqTOwSrqNA1NY5lSztJ1GrBiUodLMmIZuLiDaMRJ+itFd+ABVE8XBjOvIWL+rSqNDC74LCSFmlb/U4UZ4hJQ==}
+
   y18n@5.0.8:
     resolution: {integrity: sha512-0pfFzegeDWJHJIAmTLRP2DwHjdF5s7jo9tuztdQxAhINCdvS+3nGINqPd00AphqJR/0LhANUS6/+7SCb98YOfA==}
     engines: {node: '>=10'}
@@ -8451,6 +9128,10 @@ packages:
     engines: {node: '>= 14.6'}
     hasBin: true
 
+  yargs-parser@18.1.3:
+    resolution: {integrity: sha512-o50j0JeToy/4K6OZcaQmW6lyXXKhq7csREXcDwk2omFPJEwUNOVtJKvmDr9EI1fAJZUyZcRF7kxGBWmRXudrCQ==}
+    engines: {node: '>=6'}
+
   yargs-parser@20.2.9:
     resolution: {integrity: sha512-y11nGElTIV+CT3Zv9t7VKl+Q3hTQoT9a1Qzezhhl6Rp21gJ/IVTW7Z3y9EWXhuUBC2Shnf+DX0antecpAwSP8w==}
     engines: {node: '>=10'}
@@ -8459,6 +9140,10 @@ packages:
     resolution: {integrity: sha512-tVpsJW7DdjecAiFpbIB1e3qxIQsE6NoPc5/eTdrbbIC4h0LVsWhnoa3g+m2HclBIujHzsxZ4VJVA+GUuc2/LBw==}
     engines: {node: '>=12'}
 
+  yargs@15.4.1:
+    resolution: {integrity: sha512-aePbxDmcYW++PaqBsJ+HYUFwCdv4LVvdnhBy78E57PIor8/OVvhMrADFFEDh8DHDFRv/O9i3lPhsENjO7QX0+A==}
+    engines: {node: '>=8'}
+
   yargs@16.2.0:
     resolution: {integrity: sha512-D1mvvtDG0L5ft/jGWkLpG1+m0eQxOfaBvTNELraWj22wSVUMWxZUvYgJYcKh6jGGIkJFhH4IZPQhR4TKpc8mBw==}
     engines: {node: '>=10'}
@@ -8503,6 +9188,8 @@ packages:
 
 snapshots:
 
+  '@adobe/css-tools@4.5.0': {}
+
   '@agentclientprotocol/claude-agent-acp@0.39.0(@anthropic-ai/sdk@0.100.1(zod@4.2.1))(@modelcontextprotocol/sdk@1.25.1(hono@4.11.3)(zod@4.2.1))':
     dependencies:
       '@agentclientprotocol/sdk': 0.22.1(zod@4.2.1)
@@ -8512,7 +9199,7 @@ snapshots:
       - '@anthropic-ai/sdk'
       - '@modelcontextprotocol/sdk'
 
-  '@agentclientprotocol/codex-acp@0.0.44(zod@4.2.1)':
+  '@agentclientprotocol/codex-acp@0.0.44(patch_hash=0079b1ab3870451b47fe5ea5ecaca697e17139cff50fd2ee9c296b172aba525e)(zod@4.2.1)':
     dependencies:
       '@agentclientprotocol/sdk': 0.21.1(zod@4.2.1)
       '@openai/codex': 0.128.0(patch_hash=9edd926108a95aaa788aa93870fd6b16d70eeccdf5740b503af5d34cc9f25e86)
@@ -8637,6 +9324,26 @@ snapshots:
     optionalDependencies:
       zod: 4.2.1
 
+  '@asamuzakjp/css-color@5.1.11':
+    dependencies:
+      '@asamuzakjp/generational-cache': 1.0.1
+      '@csstools/css-calc': 3.2.1(@csstools/css-parser-algorithms@4.0.0(@csstools/css-tokenizer@4.0.0))(@csstools/css-tokenizer@4.0.0)
+      '@csstools/css-color-parser': 4.1.9(@csstools/css-parser-algorithms@4.0.0(@csstools/css-tokenizer@4.0.0))(@csstools/css-tokenizer@4.0.0)
+      '@csstools/css-parser-algorithms': 4.0.0(@csstools/css-tokenizer@4.0.0)
+      '@csstools/css-tokenizer': 4.0.0
+
+  '@asamuzakjp/dom-selector@7.1.1':
+    dependencies:
+      '@asamuzakjp/generational-cache': 1.0.1
+      '@asamuzakjp/nwsapi': 2.3.9
+      bidi-js: 1.0.3
+      css-tree: 3.2.1
+      is-potential-custom-element-name: 1.0.1
+
+  '@asamuzakjp/generational-cache@1.0.1': {}
+
+  '@asamuzakjp/nwsapi@2.3.9': {}
+
   '@aws-crypto/crc32@5.2.0':
     dependencies:
       '@aws-crypto/util': 5.2.0
@@ -9247,8 +9954,32 @@ snapshots:
       '@babel/helper-string-parser': 7.27.1
       '@babel/helper-validator-identifier': 7.28.5
 
+  '@borewit/text-codec@0.2.2': {}
+
   '@braintree/sanitize-url@7.1.1': {}
 
+  '@bramus/specificity@2.4.2':
+    dependencies:
+      css-tree: 3.2.1
+
+  '@cacheable/memory@2.2.0':
+    dependencies:
+      '@cacheable/utils': 2.5.0
+      '@keyv/bigmap': 1.3.1(keyv@5.6.0)
+      hookified: 1.15.1
+      keyv: 5.6.0
+
+  '@cacheable/node-cache@1.7.6':
+    dependencies:
+      cacheable: 2.5.0
+      hookified: 1.15.1
+      keyv: 5.6.0
+
+  '@cacheable/utils@2.5.0':
+    dependencies:
+      hashery: 1.5.1
+      keyv: 5.6.0
+
   '@chevrotain/cst-dts-gen@12.0.0':
     dependencies:
       '@chevrotain/gast': 12.0.0
@@ -9525,13 +10256,13 @@ snapshots:
 
   '@composio/client@0.1.0-alpha.56': {}
 
-  '@composio/core@0.6.2(zod@4.2.1)':
+  '@composio/core@0.6.2(ws@8.21.0)(zod@4.2.1)':
     dependencies:
       '@composio/client': 0.1.0-alpha.56
       '@composio/json-schema-to-zod': 0.1.20(zod@4.2.1)
       '@types/json-schema': 7.0.15
       chalk: 4.1.2
-      openai: 6.17.0(zod@4.2.1)
+      openai: 6.17.0(ws@8.21.0)(zod@4.2.1)
       pusher-js: 8.4.0
       semver: 7.7.3
       zod: 4.2.1
@@ -9543,6 +10274,30 @@ snapshots:
     dependencies:
       zod: 4.2.1
 
+  '@csstools/color-helpers@6.1.0': {}
+
+  '@csstools/css-calc@3.2.1(@csstools/css-parser-algorithms@4.0.0(@csstools/css-tokenizer@4.0.0))(@csstools/css-tokenizer@4.0.0)':
+    dependencies:
+      '@csstools/css-parser-algorithms': 4.0.0(@csstools/css-tokenizer@4.0.0)
+      '@csstools/css-tokenizer': 4.0.0
+
+  '@csstools/css-color-parser@4.1.9(@csstools/css-parser-algorithms@4.0.0(@csstools/css-tokenizer@4.0.0))(@csstools/css-tokenizer@4.0.0)':
+    dependencies:
+      '@csstools/color-helpers': 6.1.0
+      '@csstools/css-calc': 3.2.1(@csstools/css-parser-algorithms@4.0.0(@csstools/css-tokenizer@4.0.0))(@csstools/css-tokenizer@4.0.0)
+      '@csstools/css-parser-algorithms': 4.0.0(@csstools/css-tokenizer@4.0.0)
+      '@csstools/css-tokenizer': 4.0.0
+
+  '@csstools/css-parser-algorithms@4.0.0(@csstools/css-tokenizer@4.0.0)':
+    dependencies:
+      '@csstools/css-tokenizer': 4.0.0
+
+  '@csstools/css-syntax-patches-for-csstree@1.1.6(css-tree@3.2.1)':
+    optionalDependencies:
+      css-tree: 3.2.1
+
+  '@csstools/css-tokenizer@4.0.0': {}
+
   '@eigenpal/docx-editor-agents@1.0.3(ai@5.0.117(zod@4.2.1))(react@19.2.3)':
     dependencies:
       docxtemplater: 3.68.7
@@ -9910,7 +10665,7 @@ snapshots:
       make-fetch-happen: 10.2.1
       nopt: 6.0.0
       proc-log: 2.0.1
-      semver: 7.7.3
+      semver: 7.8.5
       tar: 6.2.1
       which: 2.0.2
     transitivePeerDependencies:
@@ -10004,6 +10759,11 @@ snapshots:
     transitivePeerDependencies:
       - supports-color
 
+  '@emnapi/runtime@1.11.2':
+    dependencies:
+      tslib: 2.8.1
+    optional: true
+
   '@esbuild/aix-ppc64@0.24.2':
     optional: true
 
@@ -10203,6 +10963,8 @@ snapshots:
       '@eslint/core': 0.17.0
       levn: 0.4.1
 
+  '@exodus/bytes@1.15.1': {}
+
   '@floating-ui/core@1.7.3':
     dependencies:
       '@floating-ui/utils': 0.2.10
@@ -10236,10 +10998,16 @@ snapshots:
     dependencies:
       '@hapi/hoek': 11.0.7
 
+  '@hapi/boom@9.1.4':
+    dependencies:
+      '@hapi/hoek': 9.3.0
+
   '@hapi/formula@3.0.2': {}
 
   '@hapi/hoek@11.0.7': {}
 
+  '@hapi/hoek@9.3.0': {}
+
   '@hapi/pinpoint@2.0.1': {}
 
   '@hapi/tlds@1.1.4': {}
@@ -10271,6 +11039,112 @@ snapshots:
       '@iconify/types': 2.0.0
       mlly: 1.8.0
 
+  '@img/colour@1.1.0': {}
+
+  '@img/sharp-darwin-arm64@0.35.3':
+    optionalDependencies:
+      '@img/sharp-libvips-darwin-arm64': 1.3.2
+    optional: true
+
+  '@img/sharp-darwin-x64@0.35.3':
+    optionalDependencies:
+      '@img/sharp-libvips-darwin-x64': 1.3.2
+    optional: true
+
+  '@img/sharp-freebsd-wasm32@0.35.3':
+    dependencies:
+      '@img/sharp-wasm32': 0.35.3
+    optional: true
+
+  '@img/sharp-libvips-darwin-arm64@1.3.2':
+    optional: true
+
+  '@img/sharp-libvips-darwin-x64@1.3.2':
+    optional: true
+
+  '@img/sharp-libvips-linux-arm64@1.3.2':
+    optional: true
+
+  '@img/sharp-libvips-linux-arm@1.3.2':
+    optional: true
+
+  '@img/sharp-libvips-linux-ppc64@1.3.2':
+    optional: true
+
+  '@img/sharp-libvips-linux-riscv64@1.3.2':
+    optional: true
+
+  '@img/sharp-libvips-linux-s390x@1.3.2':
+    optional: true
+
+  '@img/sharp-libvips-linux-x64@1.3.2':
+    optional: true
+
+  '@img/sharp-libvips-linuxmusl-arm64@1.3.2':
+    optional: true
+
+  '@img/sharp-libvips-linuxmusl-x64@1.3.2':
+    optional: true
+
+  '@img/sharp-linux-arm64@0.35.3':
+    optionalDependencies:
+      '@img/sharp-libvips-linux-arm64': 1.3.2
+    optional: true
+
+  '@img/sharp-linux-arm@0.35.3':
+    optionalDependencies:
+      '@img/sharp-libvips-linux-arm': 1.3.2
+    optional: true
+
+  '@img/sharp-linux-ppc64@0.35.3':
+    optionalDependencies:
+      '@img/sharp-libvips-linux-ppc64': 1.3.2
+    optional: true
+
+  '@img/sharp-linux-riscv64@0.35.3':
+    optionalDependencies:
+      '@img/sharp-libvips-linux-riscv64': 1.3.2
+    optional: true
+
+  '@img/sharp-linux-s390x@0.35.3':
+    optionalDependencies:
+      '@img/sharp-libvips-linux-s390x': 1.3.2
+    optional: true
+
+  '@img/sharp-linux-x64@0.35.3':
+    optionalDependencies:
+      '@img/sharp-libvips-linux-x64': 1.3.2
+    optional: true
+
+  '@img/sharp-linuxmusl-arm64@0.35.3':
+    optionalDependencies:
+      '@img/sharp-libvips-linuxmusl-arm64': 1.3.2
+    optional: true
+
+  '@img/sharp-linuxmusl-x64@0.35.3':
+    optionalDependencies:
+      '@img/sharp-libvips-linuxmusl-x64': 1.3.2
+    optional: true
+
+  '@img/sharp-wasm32@0.35.3':
+    dependencies:
+      '@emnapi/runtime': 1.11.2
+    optional: true
+
+  '@img/sharp-webcontainers-wasm32@0.35.3':
+    dependencies:
+      '@img/sharp-wasm32': 0.35.3
+    optional: true
+
+  '@img/sharp-win32-arm64@0.35.3':
+    optional: true
+
+  '@img/sharp-win32-ia32@0.35.3':
+    optional: true
+
+  '@img/sharp-win32-x64@0.35.3':
+    optional: true
+
   '@inquirer/checkbox@3.0.1':
     dependencies:
       '@inquirer/core': 9.2.1
@@ -10410,6 +11284,14 @@ snapshots:
       '@jridgewell/resolve-uri': 3.1.2
       '@jridgewell/sourcemap-codec': 1.5.5
 
+  '@keyv/bigmap@1.3.1(keyv@5.6.0)':
+    dependencies:
+      hashery: 1.5.1
+      hookified: 1.15.1
+      keyv: 5.6.0
+
+  '@keyv/serialize@1.1.1': {}
+
   '@lezer/common@1.5.2': {}
 
   '@lezer/cpp@1.1.6':
@@ -10605,7 +11487,7 @@ snapshots:
   '@npmcli/fs@2.1.2':
     dependencies:
       '@gar/promisify': 1.1.3
-      semver: 7.7.3
+      semver: 7.8.5
 
   '@npmcli/move-file@2.0.1':
     dependencies:
@@ -10836,6 +11718,8 @@ snapshots:
 
   '@opentelemetry/semantic-conventions@1.39.0': {}
 
+  '@pinojs/redact@0.4.0': {}
+
   '@pkgjs/parseargs@0.11.0':
     optional: true
 
@@ -10851,13 +11735,21 @@ snapshots:
 
   '@protobufjs/codegen@2.0.4': {}
 
+  '@protobufjs/codegen@2.0.5': {}
+
   '@protobufjs/eventemitter@1.1.0': {}
 
+  '@protobufjs/eventemitter@1.1.1': {}
+
   '@protobufjs/fetch@1.1.0':
     dependencies:
       '@protobufjs/aspromise': 1.1.2
       '@protobufjs/inquire': 1.1.0
 
+  '@protobufjs/fetch@1.1.1':
+    dependencies:
+      '@protobufjs/aspromise': 1.1.2
+
   '@protobufjs/float@1.0.2': {}
 
   '@protobufjs/inquire@1.1.0': {}
@@ -10868,6 +11760,8 @@ snapshots:
 
   '@protobufjs/utf8@1.1.0': {}
 
+  '@protobufjs/utf8@1.1.1': {}
+
   '@radix-ui/number@1.1.1': {}
 
   '@radix-ui/primitive@1.1.3': {}
@@ -12338,6 +13232,36 @@ snapshots:
       tailwindcss: 4.1.18
       vite: 7.3.0(@types/node@24.10.4)(jiti@2.6.1)(lightningcss@1.30.2)(terser@5.46.0)(yaml@2.8.2)
 
+  '@testing-library/dom@10.4.1':
+    dependencies:
+      '@babel/code-frame': 7.27.1
+      '@babel/runtime': 7.28.6
+      '@types/aria-query': 5.0.4
+      aria-query: 5.3.0
+      dom-accessibility-api: 0.5.16
+      lz-string: 1.5.0
+      picocolors: 1.1.1
+      pretty-format: 27.5.1
+
+  '@testing-library/jest-dom@6.9.1':
+    dependencies:
+      '@adobe/css-tools': 4.5.0
+      aria-query: 5.3.2
+      css.escape: 1.5.1
+      dom-accessibility-api: 0.6.3
+      picocolors: 1.1.1
+      redent: 3.0.0
+
+  '@testing-library/react@16.3.2(@testing-library/dom@10.4.1)(@types/react-dom@19.2.3(@types/react@19.2.7))(@types/react@19.2.7)(react-dom@19.2.3(react@19.2.3))(react@19.2.3)':
+    dependencies:
+      '@babel/runtime': 7.28.6
+      '@testing-library/dom': 10.4.1
+      react: 19.2.3
+      react-dom: 19.2.3(react@19.2.3)
+    optionalDependencies:
+      '@types/react': 19.2.7
+      '@types/react-dom': 19.2.3(@types/react@19.2.7)
+
   '@tiptap/core@3.22.4(@tiptap/pm@3.22.4)':
     dependencies:
       '@tiptap/pm': 3.22.4
@@ -12530,6 +13454,15 @@ snapshots:
       '@tiptap/extensions': 3.22.5(@tiptap/core@3.22.4(@tiptap/pm@3.22.4))(@tiptap/pm@3.22.4)
       '@tiptap/pm': 3.22.4
 
+  '@tokenizer/inflate@0.4.1':
+    dependencies:
+      debug: 4.4.3
+      token-types: 6.1.2
+    transitivePeerDependencies:
+      - supports-color
+
+  '@tokenizer/token@0.3.0': {}
+
   '@tokenlens/core@1.3.0': {}
 
   '@tokenlens/fetch@1.3.0':
@@ -12552,6 +13485,8 @@ snapshots:
       '@types/node': 25.0.3
     optional: true
 
+  '@types/aria-query@5.0.4': {}
+
   '@types/babel__core@7.20.5':
     dependencies:
       '@babel/parser': 7.28.5
@@ -12823,6 +13758,10 @@ snapshots:
     dependencies:
       '@types/node': 25.0.3
 
+  '@types/qrcode@1.5.6':
+    dependencies:
+      '@types/node': 25.0.3
+
   '@types/qs@6.14.0': {}
 
   '@types/range-parser@1.2.7': {}
@@ -12989,6 +13928,14 @@ snapshots:
       chai: 6.2.2
       tinyrainbow: 3.1.0
 
+  '@vitest/mocker@4.1.7(vite@7.3.0(@types/node@24.10.4)(jiti@2.6.1)(lightningcss@1.30.2)(terser@5.46.0)(yaml@2.8.2))':
+    dependencies:
+      '@vitest/spy': 4.1.7
+      estree-walker: 3.0.3
+      magic-string: 0.30.21
+    optionalDependencies:
+      vite: 7.3.0(@types/node@24.10.4)(jiti@2.6.1)(lightningcss@1.30.2)(terser@5.46.0)(yaml@2.8.2)
+
   '@vitest/mocker@4.1.7(vite@7.3.0(@types/node@25.0.3)(jiti@2.6.1)(lightningcss@1.30.2)(terser@5.46.0)(yaml@2.8.2))':
     dependencies:
       '@vitest/spy': 4.1.7
@@ -13225,6 +14172,8 @@ snapshots:
     dependencies:
       color-convert: 2.0.1
 
+  ansi-styles@5.2.0: {}
+
   ansi-styles@6.2.3: {}
 
   appdmg@0.6.6:
@@ -13252,12 +14201,22 @@ snapshots:
     dependencies:
       tslib: 2.8.1
 
+  aria-query@5.3.0:
+    dependencies:
+      dequal: 2.0.3
+
+  aria-query@5.3.2: {}
+
   arrify@2.0.1: {}
 
   assertion-error@2.0.1: {}
 
   async-lock@1.4.1: {}
 
+  async-mutex@0.5.0:
+    dependencies:
+      tslib: 2.8.1
+
   async@1.5.2:
     optional: true
 
@@ -13265,6 +14224,8 @@ snapshots:
 
   at-least-node@1.0.0: {}
 
+  atomic-sleep@1.0.0: {}
+
   author-regex@1.0.0: {}
 
   available-typed-arrays@1.0.7:
@@ -13296,6 +14257,25 @@ snapshots:
 
   bail@2.0.2: {}
 
+  baileys@7.0.0-rc13(sharp@0.35.3(@types/node@25.0.3)):
+    dependencies:
+      '@cacheable/node-cache': 1.7.6
+      '@hapi/boom': 9.1.4
+      async-mutex: 0.5.0
+      libsignal: 6.0.0
+      lru-cache: 11.5.1
+      music-metadata: 11.13.0
+      p-queue: 9.3.0
+      pino: 9.14.0
+      protobufjs: 7.6.4
+      sharp: 0.35.3(@types/node@25.0.3)
+      whatsapp-rust-bridge: 0.5.4
+      ws: 8.21.0
+    transitivePeerDependencies:
+      - bufferutil
+      - supports-color
+      - utf-8-validate
+
   balanced-match@1.0.2: {}
 
   base32-encode@1.2.0:
@@ -13448,6 +14428,14 @@ snapshots:
       normalize-url: 6.1.0
       responselike: 2.0.1
 
+  cacheable@2.5.0:
+    dependencies:
+      '@cacheable/memory': 2.2.0
+      '@cacheable/utils': 2.5.0
+      hookified: 1.15.1
+      keyv: 5.6.0
+      qified: 0.10.1
+
   call-bind-apply-helpers@1.0.2:
     dependencies:
       es-errors: 1.3.0
@@ -13472,6 +14460,8 @@ snapshots:
       pascal-case: 3.1.2
       tslib: 2.8.1
 
+  camelcase@5.3.1: {}
+
   camelize@1.0.1: {}
 
   caniuse-lite@1.0.30001761: {}
@@ -13548,6 +14538,12 @@ snapshots:
 
   cli-width@4.1.0: {}
 
+  cliui@6.0.0:
+    dependencies:
+      string-width: 4.2.3
+      strip-ansi: 6.0.1
+      wrap-ansi: 6.2.0
+
   cliui@7.0.4:
     dependencies:
       string-width: 4.2.3
@@ -13650,6 +14646,8 @@ snapshots:
 
   content-type@1.0.5: {}
 
+  content-type@2.0.0: {}
+
   convert-source-map@2.0.0: {}
 
   cookie-signature@1.2.2: {}
@@ -13709,10 +14707,19 @@ snapshots:
       domutils: 3.2.2
       nth-check: 2.1.1
 
+  css-tree@3.2.1:
+    dependencies:
+      mdn-data: 2.27.1
+      source-map-js: 1.2.1
+
   css-what@6.2.2: {}
 
+  css.escape@1.5.1: {}
+
   csstype@3.2.3: {}
 
+  curve25519-js@0.0.4: {}
+
   cytoscape-cose-bilkent@4.1.0(cytoscape@3.33.1):
     dependencies:
       cose-base: 1.0.3
@@ -13899,6 +14906,13 @@ snapshots:
 
   data-uri-to-buffer@4.0.1: {}
 
+  data-urls@7.0.0:
+    dependencies:
+      whatwg-mimetype: 5.0.0
+      whatwg-url: 16.0.1
+    transitivePeerDependencies:
+      - '@noble/hashes'
+
   dayjs@1.11.19: {}
 
   debug@2.6.9:
@@ -13909,8 +14923,12 @@ snapshots:
     dependencies:
       ms: 2.1.3
 
+  decamelize@1.2.0: {}
+
   decimal.js-light@2.5.1: {}
 
+  decimal.js@10.6.0: {}
+
   decode-named-character-reference@1.2.0:
     dependencies:
       character-entities: 2.0.2
@@ -13978,6 +14996,8 @@ snapshots:
 
   diff@8.0.4: {}
 
+  dijkstrajs@1.0.3: {}
+
   dingbat-to-unicode@1.0.1: {}
 
   dir-compare@4.2.0:
@@ -13989,6 +15009,10 @@ snapshots:
     dependencies:
       '@xmldom/xmldom': 0.9.10
 
+  dom-accessibility-api@0.5.16: {}
+
+  dom-accessibility-api@0.6.3: {}
+
   dom-serializer@0.2.2:
     dependencies:
       domelementtype: 2.3.0
@@ -14180,6 +15204,8 @@ snapshots:
 
   entities@6.0.1: {}
 
+  entities@8.0.0: {}
+
   env-paths@2.2.1: {}
 
   err-code@2.0.3: {}
@@ -14391,6 +15417,8 @@ snapshots:
 
   eventemitter3@5.0.1: {}
 
+  eventemitter3@5.0.4: {}
+
   events@3.3.0: {}
 
   eventsource-parser@3.0.6: {}
@@ -14515,6 +15543,15 @@ snapshots:
     dependencies:
       flat-cache: 4.0.1
 
+  file-type@21.3.4:
+    dependencies:
+      '@tokenizer/inflate': 0.4.1
+      strtok3: 10.3.5
+      token-types: 6.1.2
+      uint8array-extras: 1.5.0
+    transitivePeerDependencies:
+      - supports-color
+
   filename-reserved-regex@2.0.0: {}
 
   filenamify@4.3.0:
@@ -14542,6 +15579,11 @@ snapshots:
     dependencies:
       locate-path: 2.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
@@ -14943,6 +15985,10 @@ snapshots:
     dependencies:
       has-symbols: 1.1.0
 
+  hashery@1.5.1:
+    dependencies:
+      hookified: 1.15.1
+
   hasown@2.0.2:
     dependencies:
       function-bind: 1.1.2
@@ -15079,6 +16125,10 @@ snapshots:
 
   hono@4.11.3: {}
 
+  hookified@1.15.1: {}
+
+  hookified@2.2.0: {}
+
   hosted-git-info@2.8.9: {}
 
   hsl-to-hex@1.0.0:
@@ -15087,6 +16137,12 @@ snapshots:
 
   hsl-to-rgb-for-reals@1.1.1: {}
 
+  html-encoding-sniffer@6.0.0:
+    dependencies:
+      '@exodus/bytes': 1.15.1
+    transitivePeerDependencies:
+      - '@noble/hashes'
+
   html-entities@2.6.0: {}
 
   html-to-docx@1.8.0(encoding@0.1.13):
@@ -15309,6 +16365,8 @@ snapshots:
 
   is-plain-obj@4.1.0: {}
 
+  is-potential-custom-element-name@1.0.1: {}
+
   is-promise@4.0.0: {}
 
   is-property@1.0.2:
@@ -15399,6 +16457,32 @@ snapshots:
     dependencies:
       argparse: 2.0.1
 
+  jsdom@29.1.1:
+    dependencies:
+      '@asamuzakjp/css-color': 5.1.11
+      '@asamuzakjp/dom-selector': 7.1.1
+      '@bramus/specificity': 2.4.2
+      '@csstools/css-syntax-patches-for-csstree': 1.1.6(css-tree@3.2.1)
+      '@exodus/bytes': 1.15.1
+      css-tree: 3.2.1
+      data-urls: 7.0.0
+      decimal.js: 10.6.0
+      html-encoding-sniffer: 6.0.0
+      is-potential-custom-element-name: 1.0.1
+      lru-cache: 11.5.1
+      parse5: 8.0.1
+      saxes: 6.0.0
+      symbol-tree: 3.2.4
+      tough-cookie: 6.0.1
+      undici: 7.28.0
+      w3c-xmlserializer: 5.0.0
+      webidl-conversions: 8.0.1
+      whatwg-mimetype: 5.0.0
+      whatwg-url: 16.0.1
+      xml-name-validator: 5.0.0
+    transitivePeerDependencies:
+      - '@noble/hashes'
+
   jsesc@3.1.0: {}
 
   json-bigint@1.0.0:
@@ -15470,6 +16554,10 @@ snapshots:
     dependencies:
       json-buffer: 3.0.1
 
+  keyv@5.6.0:
+    dependencies:
+      '@keyv/serialize': 1.1.1
+
   khroma@2.1.0: {}
 
   langium@4.2.2:
@@ -15490,6 +16578,11 @@ snapshots:
       prelude-ls: 1.2.1
       type-check: 0.4.0
 
+  libsignal@6.0.0:
+    dependencies:
+      curve25519-js: 0.0.4
+      protobufjs: 7.6.4
+
   lie@3.3.0:
     dependencies:
       immediate: 3.0.6
@@ -15577,6 +16670,10 @@ snapshots:
       p-locate: 2.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
@@ -15626,6 +16723,8 @@ snapshots:
 
   lru-cache@11.2.4: {}
 
+  lru-cache@11.5.1: {}
+
   lru-cache@5.1.1:
     dependencies:
       yallist: 3.1.1
@@ -15642,6 +16741,8 @@ snapshots:
 
   luxon@3.7.2: {}
 
+  lz-string@1.5.0: {}
+
   macos-alias@0.2.12:
     dependencies:
       nan: 2.24.0
@@ -15882,12 +16983,16 @@ snapshots:
     dependencies:
       '@types/mdast': 4.0.4
 
+  mdn-data@2.27.1: {}
+
   mdurl@2.0.0: {}
 
   media-engine@1.0.3: {}
 
   media-typer@1.1.0: {}
 
+  media-typer@2.0.0: {}
+
   mem@4.3.0:
     dependencies:
       map-age-cleaner: 0.1.3
@@ -16184,6 +17289,8 @@ snapshots:
     dependencies:
       dom-walk: 0.1.2
 
+  min-indent@1.0.1: {}
+
   minimatch@10.1.1:
     dependencies:
       '@isaacs/brace-expansion': 5.0.0
@@ -16282,6 +17389,21 @@ snapshots:
       imul: 1.0.1
     optional: true
 
+  music-metadata@11.13.0:
+    dependencies:
+      '@borewit/text-codec': 0.2.2
+      '@tokenizer/token': 0.3.0
+      content-type: 2.0.0
+      debug: 4.4.3
+      file-type: 21.3.4
+      media-typer: 2.0.0
+      strtok3: 10.3.5
+      token-types: 6.1.2
+      uint8array-extras: 1.5.0
+      win-guid: 0.2.1
+    transitivePeerDependencies:
+      - supports-color
+
   mute-stream@1.0.0: {}
 
   nan@2.24.0:
@@ -16396,6 +17518,8 @@ snapshots:
       '@ai-sdk/provider-utils': 3.0.20(zod@4.2.1)
       zod: 4.2.1
 
+  on-exit-leak-free@2.1.2: {}
+
   on-finished@2.4.1:
     dependencies:
       ee-first: 1.1.1
@@ -16430,8 +17554,9 @@ snapshots:
       is-docker: 2.2.1
       is-wsl: 2.2.0
 
-  openai@6.17.0(zod@4.2.1):
+  openai@6.17.0(ws@8.21.0)(zod@4.2.1):
     optionalDependencies:
+      ws: 8.21.0
       zod: 4.2.1
 
   openid-client@6.8.1:
@@ -16478,6 +17603,10 @@ snapshots:
     dependencies:
       p-try: 1.0.0
 
+  p-limit@2.3.0:
+    dependencies:
+      p-try: 2.2.0
+
   p-limit@3.1.0:
     dependencies:
       yocto-queue: 0.1.0
@@ -16486,6 +17615,10 @@ snapshots:
     dependencies:
       p-limit: 1.3.0
 
+  p-locate@4.1.0:
+    dependencies:
+      p-limit: 2.3.0
+
   p-locate@5.0.0:
     dependencies:
       p-limit: 3.1.0
@@ -16499,6 +17632,11 @@ snapshots:
       eventemitter3: 4.0.7
       p-timeout: 3.2.0
 
+  p-queue@9.3.0:
+    dependencies:
+      eventemitter3: 5.0.4
+      p-timeout: 7.0.1
+
   p-retry@4.6.2:
     dependencies:
       '@types/retry': 0.12.0
@@ -16508,8 +17646,12 @@ snapshots:
     dependencies:
       p-finally: 1.0.0
 
+  p-timeout@7.0.1: {}
+
   p-try@1.0.0: {}
 
+  p-try@2.2.0: {}
+
   package-json-from-dist@1.0.1: {}
 
   package-manager-detector@1.6.0: {}
@@ -16555,6 +17697,10 @@ snapshots:
     dependencies:
       entities: 6.0.1
 
+  parse5@8.0.1:
+    dependencies:
+      entities: 8.0.0
+
   parseurl@1.3.3: {}
 
   pascal-case@3.1.2:
@@ -16617,6 +17763,26 @@ snapshots:
 
   pify@4.0.1: {}
 
+  pino-abstract-transport@2.0.0:
+    dependencies:
+      split2: 4.2.0
+
+  pino-std-serializers@7.1.0: {}
+
+  pino@9.14.0:
+    dependencies:
+      '@pinojs/redact': 0.4.0
+      atomic-sleep: 1.0.0
+      on-exit-leak-free: 2.1.2
+      pino-abstract-transport: 2.0.0
+      pino-std-serializers: 7.1.0
+      process-warning: 5.0.0
+      quick-format-unescaped: 4.0.4
+      real-require: 0.2.0
+      safe-stable-stringify: 2.5.0
+      sonic-boom: 4.2.1
+      thread-stream: 3.2.0
+
   pizzip@3.2.0:
     dependencies:
       pako: 2.1.0
@@ -16635,6 +17801,8 @@ snapshots:
       base64-js: 1.5.1
       xmlbuilder: 15.1.1
 
+  pngjs@5.0.0: {}
+
   points-on-curve@0.2.0: {}
 
   points-on-path@0.2.1:
@@ -16686,10 +17854,18 @@ snapshots:
 
   prettier@3.8.0: {}
 
+  pretty-format@27.5.1:
+    dependencies:
+      ansi-regex: 5.0.1
+      ansi-styles: 5.2.0
+      react-is: 17.0.2
+
   proc-log@2.0.1: {}
 
   process-nextick-args@2.0.1: {}
 
+  process-warning@5.0.0: {}
+
   process@0.11.10: {}
 
   progress@2.0.3: {}
@@ -16799,6 +17975,20 @@ snapshots:
       '@types/node': 25.0.3
       long: 5.3.2
 
+  protobufjs@7.6.4:
+    dependencies:
+      '@protobufjs/aspromise': 1.1.2
+      '@protobufjs/base64': 1.1.2
+      '@protobufjs/codegen': 2.0.5
+      '@protobufjs/eventemitter': 1.1.1
+      '@protobufjs/fetch': 1.1.1
+      '@protobufjs/float': 1.0.2
+      '@protobufjs/path': 1.1.2
+      '@protobufjs/pool': 1.1.0
+      '@protobufjs/utf8': 1.1.1
+      '@types/node': 25.0.3
+      long: 5.3.2
+
   proxy-addr@2.0.7:
     dependencies:
       forwarded: 0.2.0
@@ -16823,6 +18013,16 @@ snapshots:
     dependencies:
       tweetnacl: 1.0.3
 
+  qified@0.10.1:
+    dependencies:
+      hookified: 2.2.0
+
+  qrcode@1.5.4:
+    dependencies:
+      dijkstrajs: 1.0.3
+      pngjs: 5.0.0
+      yargs: 15.4.1
+
   qs@6.14.1:
     dependencies:
       side-channel: 1.1.0
@@ -16835,6 +18035,8 @@ snapshots:
     dependencies:
       inherits: 2.0.4
 
+  quick-format-unescaped@4.0.4: {}
+
   quick-lru@5.1.1: {}
 
   radix-ui@1.4.3(@types/react-dom@19.2.3(@types/react@19.2.7))(@types/react@19.2.7)(react-dom@19.2.3(react@19.2.3))(react@19.2.3):
@@ -16926,6 +18128,8 @@ snapshots:
 
   react-is@16.13.1: {}
 
+  react-is@17.0.2: {}
+
   react-redux@9.2.0(@types/react@19.2.7)(react@19.2.3)(redux@5.0.1):
     dependencies:
       '@types/use-sync-external-store': 0.0.6
@@ -17017,7 +18221,9 @@ snapshots:
 
   readdirp@4.1.2: {}
 
-  recharts@3.8.1(@types/react@19.2.7)(react-dom@19.2.3(react@19.2.3))(react-is@16.13.1)(react@19.2.3)(redux@5.0.1):
+  real-require@0.2.0: {}
+
+  recharts@3.8.1(@types/react@19.2.7)(react-dom@19.2.3(react@19.2.3))(react-is@17.0.2)(react@19.2.3)(redux@5.0.1):
     dependencies:
       '@reduxjs/toolkit': 2.11.2(react-redux@9.2.0(@types/react@19.2.7)(react@19.2.3)(redux@5.0.1))(react@19.2.3)
       clsx: 2.1.1
@@ -17027,7 +18233,7 @@ snapshots:
       immer: 10.2.0
       react: 19.2.3
       react-dom: 19.2.3(react@19.2.3)
-      react-is: 16.13.1
+      react-is: 17.0.2
       react-redux: 9.2.0(@types/react@19.2.7)(react@19.2.3)(redux@5.0.1)
       reselect: 5.1.1
       tiny-invariant: 1.3.3
@@ -17041,6 +18247,11 @@ snapshots:
     dependencies:
       resolve: 1.22.11
 
+  redent@3.0.0:
+    dependencies:
+      indent-string: 4.0.0
+      strip-indent: 3.0.0
+
   redux-thunk@3.1.0(redux@5.0.1):
     dependencies:
       redux: 5.0.1
@@ -17155,6 +18366,8 @@ snapshots:
 
   require-from-string@2.0.2: {}
 
+  require-main-filename@2.0.0: {}
+
   resedit@2.0.3:
     dependencies:
       pe-library: 1.0.1
@@ -17289,10 +18502,16 @@ snapshots:
       es-errors: 1.3.0
       is-regex: 1.2.1
 
+  safe-stable-stringify@2.5.0: {}
+
   safer-buffer@2.1.2: {}
 
   sax@1.6.0: {}
 
+  saxes@6.0.0:
+    dependencies:
+      xmlchars: 2.2.0
+
   scheduler@0.25.0-rc-603e6108-20241029: {}
 
   scheduler@0.27.0: {}
@@ -17313,6 +18532,8 @@ snapshots:
 
   semver@7.7.3: {}
 
+  semver@7.8.5: {}
+
   send@1.2.1:
     dependencies:
       debug: 4.4.3
@@ -17349,6 +18570,8 @@ snapshots:
 
   server-destroy@1.0.1: {}
 
+  set-blocking@2.0.0: {}
+
   set-function-length@1.2.2:
     dependencies:
       define-data-property: 1.1.4
@@ -17368,6 +18591,39 @@ snapshots:
       safe-buffer: 5.2.1
       to-buffer: 1.2.2
 
+  sharp@0.35.3(@types/node@25.0.3):
+    dependencies:
+      '@img/colour': 1.1.0
+      detect-libc: 2.1.2
+      semver: 7.8.5
+    optionalDependencies:
+      '@img/sharp-darwin-arm64': 0.35.3
+      '@img/sharp-darwin-x64': 0.35.3
+      '@img/sharp-freebsd-wasm32': 0.35.3
+      '@img/sharp-libvips-darwin-arm64': 1.3.2
+      '@img/sharp-libvips-darwin-x64': 1.3.2
+      '@img/sharp-libvips-linux-arm': 1.3.2
+      '@img/sharp-libvips-linux-arm64': 1.3.2
+      '@img/sharp-libvips-linux-ppc64': 1.3.2
+      '@img/sharp-libvips-linux-riscv64': 1.3.2
+      '@img/sharp-libvips-linux-s390x': 1.3.2
+      '@img/sharp-libvips-linux-x64': 1.3.2
+      '@img/sharp-libvips-linuxmusl-arm64': 1.3.2
+      '@img/sharp-libvips-linuxmusl-x64': 1.3.2
+      '@img/sharp-linux-arm': 0.35.3
+      '@img/sharp-linux-arm64': 0.35.3
+      '@img/sharp-linux-ppc64': 0.35.3
+      '@img/sharp-linux-riscv64': 0.35.3
+      '@img/sharp-linux-s390x': 0.35.3
+      '@img/sharp-linux-x64': 0.35.3
+      '@img/sharp-linuxmusl-arm64': 0.35.3
+      '@img/sharp-linuxmusl-x64': 0.35.3
+      '@img/sharp-webcontainers-wasm32': 0.35.3
+      '@img/sharp-win32-arm64': 0.35.3
+      '@img/sharp-win32-ia32': 0.35.3
+      '@img/sharp-win32-x64': 0.35.3
+      '@types/node': 25.0.3
+
   shebang-command@1.2.0:
     dependencies:
       shebang-regex: 1.0.0
@@ -17463,6 +18719,10 @@ snapshots:
       ip-address: 10.1.0
       smart-buffer: 4.2.0
 
+  sonic-boom@4.2.1:
+    dependencies:
+      atomic-sleep: 1.0.0
+
   sonner@2.0.7(react-dom@19.2.3(react@19.2.3))(react@19.2.3):
     dependencies:
       react: 19.2.3
@@ -17493,6 +18753,8 @@ snapshots:
 
   spdx-license-ids@3.0.22: {}
 
+  split2@4.2.0: {}
+
   sprintf-js@1.0.3: {}
 
   sprintf-js@1.1.3:
@@ -17595,6 +18857,10 @@ snapshots:
 
   strip-eof@1.0.0: {}
 
+  strip-indent@3.0.0:
+    dependencies:
+      min-indent: 1.0.1
+
   strip-json-comments@3.1.1: {}
 
   strip-outer@1.0.1:
@@ -17603,6 +18869,10 @@ snapshots:
 
   strnum@2.1.2: {}
 
+  strtok3@10.3.5:
+    dependencies:
+      '@tokenizer/token': 0.3.0
+
   style-mod@4.1.3: {}
 
   style-to-js@1.1.21:
@@ -17639,6 +18909,8 @@ snapshots:
       react: 19.2.3
       use-sync-external-store: 1.6.0(react@19.2.3)
 
+  symbol-tree@3.2.4: {}
+
   tailwind-merge@3.4.0: {}
 
   tailwindcss@4.1.18: {}
@@ -17678,6 +18950,10 @@ snapshots:
       commander: 2.20.3
       source-map-support: 0.5.21
 
+  thread-stream@3.2.0:
+    dependencies:
+      real-require: 0.2.0
+
   tiny-each-async@2.0.3:
     optional: true
 
@@ -17704,6 +18980,12 @@ snapshots:
       markdown-it-task-lists: 2.1.1
       prosemirror-markdown: 1.13.2
 
+  tldts-core@7.4.5: {}
+
+  tldts@7.4.5:
+    dependencies:
+      tldts-core: 7.4.5
+
   tmp-promise@3.0.3:
     dependencies:
       tmp: 0.2.5
@@ -17736,6 +19018,12 @@ snapshots:
 
   toidentifier@1.0.1: {}
 
+  token-types@6.1.2:
+    dependencies:
+      '@borewit/text-codec': 0.2.2
+      '@tokenizer/token': 0.3.0
+      ieee754: 1.2.1
+
   tokenlens@1.3.1:
     dependencies:
       '@tokenlens/core': 1.3.0
@@ -17743,8 +19031,16 @@ snapshots:
       '@tokenlens/helpers': 1.3.1
       '@tokenlens/models': 1.3.0
 
+  tough-cookie@6.0.1:
+    dependencies:
+      tldts: 7.4.5
+
   tr46@0.0.3: {}
 
+  tr46@6.0.0:
+    dependencies:
+      punycode: 2.3.1
+
   tree-kill@1.2.2: {}
 
   trim-lines@3.0.1: {}
@@ -17817,12 +19113,16 @@ snapshots:
 
   ufo@1.6.1: {}
 
+  uint8array-extras@1.5.0: {}
+
   underscore@1.13.8: {}
 
   undici-types@6.21.0: {}
 
   undici-types@7.16.0: {}
 
+  undici@7.28.0: {}
+
   unicode-emoji-modifier-base@1.0.0: {}
 
   unicode-properties@1.4.1:
@@ -18036,7 +19336,36 @@ snapshots:
       terser: 5.46.0
       yaml: 2.8.2
 
-  vitest@4.1.7(@opentelemetry/api@1.9.0)(@types/node@25.0.3)(vite@7.3.0(@types/node@25.0.3)(jiti@2.6.1)(lightningcss@1.30.2)(terser@5.46.0)(yaml@2.8.2)):
+  vitest@4.1.7(@opentelemetry/api@1.9.0)(@types/node@24.10.4)(jsdom@29.1.1)(vite@7.3.0(@types/node@24.10.4)(jiti@2.6.1)(lightningcss@1.30.2)(terser@5.46.0)(yaml@2.8.2)):
+    dependencies:
+      '@vitest/expect': 4.1.7
+      '@vitest/mocker': 4.1.7(vite@7.3.0(@types/node@24.10.4)(jiti@2.6.1)(lightningcss@1.30.2)(terser@5.46.0)(yaml@2.8.2))
+      '@vitest/pretty-format': 4.1.7
+      '@vitest/runner': 4.1.7
+      '@vitest/snapshot': 4.1.7
+      '@vitest/spy': 4.1.7
+      '@vitest/utils': 4.1.7
+      es-module-lexer: 2.0.0
+      expect-type: 1.3.0
+      magic-string: 0.30.21
+      obug: 2.1.1
+      pathe: 2.0.3
+      picomatch: 4.0.3
+      std-env: 4.1.0
+      tinybench: 2.9.0
+      tinyexec: 1.0.2
+      tinyglobby: 0.2.15
+      tinyrainbow: 3.1.0
+      vite: 7.3.0(@types/node@24.10.4)(jiti@2.6.1)(lightningcss@1.30.2)(terser@5.46.0)(yaml@2.8.2)
+      why-is-node-running: 2.3.0
+    optionalDependencies:
+      '@opentelemetry/api': 1.9.0
+      '@types/node': 24.10.4
+      jsdom: 29.1.1
+    transitivePeerDependencies:
+      - msw
+
+  vitest@4.1.7(@opentelemetry/api@1.9.0)(@types/node@25.0.3)(jsdom@29.1.1)(vite@7.3.0(@types/node@25.0.3)(jiti@2.6.1)(lightningcss@1.30.2)(terser@5.46.0)(yaml@2.8.2)):
     dependencies:
       '@vitest/expect': 4.1.7
       '@vitest/mocker': 4.1.7(vite@7.3.0(@types/node@25.0.3)(jiti@2.6.1)(lightningcss@1.30.2)(terser@5.46.0)(yaml@2.8.2))
@@ -18061,6 +19390,7 @@ snapshots:
     optionalDependencies:
       '@opentelemetry/api': 1.9.0
       '@types/node': 25.0.3
+      jsdom: 29.1.1
     transitivePeerDependencies:
       - msw
 
@@ -18085,6 +19415,10 @@ snapshots:
 
   w3c-keyname@2.2.8: {}
 
+  w3c-xmlserializer@5.0.0:
+    dependencies:
+      xml-name-validator: 5.0.0
+
   wait-on@9.0.3:
     dependencies:
       axios: 1.13.2
@@ -18112,6 +19446,8 @@ snapshots:
 
   webidl-conversions@3.0.1: {}
 
+  webidl-conversions@8.0.1: {}
+
   webpack-sources@3.3.3: {}
 
   webpack@5.104.1(esbuild@0.24.2):
@@ -18146,11 +19482,25 @@ snapshots:
       - esbuild
       - uglify-js
 
+  whatsapp-rust-bridge@0.5.4: {}
+
+  whatwg-mimetype@5.0.0: {}
+
+  whatwg-url@16.0.1:
+    dependencies:
+      '@exodus/bytes': 1.15.1
+      tr46: 6.0.0
+      webidl-conversions: 8.0.1
+    transitivePeerDependencies:
+      - '@noble/hashes'
+
   whatwg-url@5.0.0:
     dependencies:
       tr46: 0.0.3
       webidl-conversions: 3.0.1
 
+  which-module@2.0.1: {}
+
   which-typed-array@1.1.20:
     dependencies:
       available-typed-arrays: 1.0.7
@@ -18174,6 +19524,8 @@ snapshots:
       siginfo: 2.0.0
       stackback: 0.0.2
 
+  win-guid@0.2.1: {}
+
   wmf@1.0.2: {}
 
   word-wrap@1.2.5: {}
@@ -18200,6 +19552,8 @@ snapshots:
 
   wrappy@1.0.2: {}
 
+  ws@8.21.0: {}
+
   wsl-utils@0.3.1:
     dependencies:
       is-wsl: 3.1.1
@@ -18223,6 +19577,8 @@ snapshots:
     dependencies:
       sax: 1.6.0
 
+  xml-name-validator@5.0.0: {}
+
   xmlbuilder2@2.1.2:
     dependencies:
       '@oozcitak/dom': 1.15.5
@@ -18233,8 +19589,12 @@ snapshots:
 
   xmlbuilder@15.1.1: {}
 
+  xmlchars@2.2.0: {}
+
   xtend@4.0.2: {}
 
+  y18n@4.0.3: {}
+
   y18n@5.0.8: {}
 
   yallist@3.1.1: {}
@@ -18243,11 +19603,30 @@ snapshots:
 
   yaml@2.8.2: {}
 
+  yargs-parser@18.1.3:
+    dependencies:
+      camelcase: 5.3.1
+      decamelize: 1.2.0
+
   yargs-parser@20.2.9:
     optional: true
 
   yargs-parser@21.1.1: {}
 
+  yargs@15.4.1:
+    dependencies:
+      cliui: 6.0.0
+      decamelize: 1.2.0
+      find-up: 4.1.0
+      get-caller-file: 2.0.5
+      require-directory: 2.1.1
+      require-main-filename: 2.0.0
+      set-blocking: 2.0.0
+      string-width: 4.2.3
+      which-module: 2.0.1
+      y18n: 4.0.3
+      yargs-parser: 18.1.3
+
   yargs@16.2.0:
     dependencies:
       cliui: 7.0.4
diff --git a/apps/x/pnpm-workspace.yaml b/apps/x/pnpm-workspace.yaml
index 3f3b314a..1be4ffeb 100644
--- a/apps/x/pnpm-workspace.yaml
+++ b/apps/x/pnpm-workspace.yaml
@@ -3,6 +3,7 @@ packages:
   - packages/*
 
 allowBuilds:
+  baileys: set this to true or false
   core-js: true
   electron: true
   electron-winstaller: true
@@ -24,4 +25,5 @@ onlyBuiltDependencies:
   - macos-alias
   - protobufjs
 patchedDependencies:
+  '@agentclientprotocol/codex-acp@0.0.44': patches/@agentclientprotocol__codex-acp@0.0.44.patch
   '@openai/codex@0.128.0': patches/@openai__codex@0.128.0.patch