diff --git a/.ade/.gitignore b/.ade/.gitignore
index 6d2c67a58..19685b6ff 100644
--- a/.ade/.gitignore
+++ b/.ade/.gitignore
@@ -4,7 +4,6 @@ local.secret.yaml
 ade.db
 ade.db-*
 ade.db-wal
-*.bak
 embeddings.db
 mcp.sock
 artifacts/
diff --git a/.ade/cto/identity.yaml b/.ade/cto/identity.yaml
index f87dc6cc5..ad9417718 100644
--- a/.ade/cto/identity.yaml
+++ b/.ade/cto/identity.yaml
@@ -1,14 +1,7 @@
 name: CTO
-version: 2
-persona: >-
-  You are the CTO for this project inside ADE.
-
-  You are the persistent technical lead who owns architecture, execution
-  quality, engineering continuity, and team direction.
-
-  Use ADE's tools and project context to help the team move forward with clear,
-  concrete decisions.
-personality: strategic
+version: 3
+persona: Persistent project CTO with collaborative personality.
+personality: casual
 modelPreferences:
   provider: claude
   model: sonnet
@@ -29,6 +22,7 @@ openclawContextPolicy:
     - token
     - system_prompt
 onboardingState:
-  completedSteps: []
-  dismissedAt: 2026-04-01T23:35:05.209Z
-updatedAt: 2026-04-01T23:35:05.211Z
+  completedSteps:
+    - identity
+  completedAt: 2026-04-02T14:20:19.124Z
+updatedAt: 2026-04-02T14:20:19.127Z
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 0276938ba..f797c3a74 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -5,6 +5,25 @@ All notable changes to ADE will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [Unreleased]
+
+### Added
+
+- **Packed session grid** — resizable tile layout for the Work view with per-session column/row spans, drag-handle resizing on all edges and corners, and a bin-packing algorithm for compact arrangement (`PackedSessionGrid`, `packedSessionGridMath`)
+- **Multi-select agent questions** — `AgentQuestionModal` now supports toggling multiple predefined options per question, with a Markdown/HTML preview pane for selected option descriptions (via `ReactMarkdown` + `rehype-sanitize`)
+- **New Chat quick-create** — faster optimistic session opening from the Work view with immediate tab activation before the backend session is ready
+- **Turn recap** — `chatTranscriptRows` emits a `turn_recap` summary row at the end of each turn, aggregating tool invocation counts and status
+- **Claude tool-use tracking** — per-invocation lifecycle tracking via `toolUseID`; `tool_use_start` and `tool_use_complete` events enable per-tool status indicators in the work log
+- **MCP initialize probe** — Claude runtime pre-checks MCP server availability before starting a session
+
+### Changed
+
+- **Terminal renderer fallback** — simplified from three tiers (WebGL/canvas/DOM) to two (WebGL-first with DOM fallback); added fit recovery with retry on invalid dimensions and `fitRecoveries` health counter
+- **Work log headings** — human-readable labels (e.g. "Read utils.ts", "Run shell", "Write index.ts") replace generic tool identifiers; default visible entries increased from 1 to 4
+- **Model catalog filtering** — `UnifiedModelSelector` accepts `catalogMode: "available-only"` to restrict the picker to models available via configured providers
+- **Git stash actions** — stash pop, drop, and clear now refresh workspace metadata after completion
+- **Composer sizing** — new compact and grid-tile sizing modes in `ChatComposerShell`
+
 ## [1.0.2] - 2026-03-15
 
 ### Added
diff --git a/ai-tools/claude-code.mdx b/ai-tools/claude-code.mdx
index cc64c6927..c01786a2d 100644
--- a/ai-tools/claude-code.mdx
+++ b/ai-tools/claude-code.mdx
@@ -1,6 +1,6 @@
 ---
 title: "Claude Code"
-description: "Use Claude Code as a CLI coding agent inside ADE lanes."
+description: "Use Claude Code as a CLI coding agent inside ADE lanes — launch sessions, connect MCP tools, configure permissions, and track work across agent chat, missions, and CTO delegations."
 icon: "terminal"
 ---
 
@@ -8,45 +8,105 @@ icon: "terminal"
 
 ADE integrates with [Claude Code](https://docs.anthropic.com/en/docs/claude-code), Anthropic's CLI agent for coding tasks. When Claude Code is installed on your machine, ADE can launch it as a managed session inside any lane.
 
+Claude Code is one of ADE's deepest integrations — it serves as both a chat provider (for Agent Chat) and an execution backend (for missions, CTO workers, and automations). ADE manages the Claude Code process lifecycle, injects MCP tools, forwards environment variables, and tracks every session in the History view.
+
+---
+
 ## Requirements
 
-- Claude Code installed (`npm install -g @anthropic-ai/claude-code`)
-- An active Anthropic API key or Claude subscription
+| Requirement | Details |
+|------------|---------|
+| **Claude Code installed** | `npm install -g @anthropic-ai/claude-code` |
+| **Authentication** | An active Anthropic API key or Claude subscription. ADE probes the Claude Code runtime at startup to verify authentication. If auth fails, the AI settings indicator shows amber with instructions. |
+
+ADE auto-detects the Claude Code executable from standard paths and PATH. If detection fails, check **Settings > AI Providers** for the status and diagnostic message.
+
+---
 
-## How ADE uses Claude Code
+## How ADE Uses Claude Code
 
-ADE launches Claude Code as a subprocess inside a lane's worktree. The session inherits the lane's environment variables, working directory, and port assignments.
+ADE launches Claude Code as a subprocess inside a lane's worktree. The session inherits the lane's environment variables, working directory, port assignments, and MCP tool configuration.
 
 Claude Code sessions are used in several places:
 
-- **Agent Chat** -- when you select Claude Code as the executor in a lane chat session
-- **Missions** -- as a worker executor (`claude_cli`) during mission execution phases
-- **CTO workers** -- when the CTO delegates a task to an employee agent using Claude Code
-- **Automations** -- as the execution backend for automation rules
+| Surface | How Claude Code is used |
+|---------|------------------------|
+| **Agent Chat** | Select Claude as the provider in the model selector. ADE starts a Claude Code session with MCP tools bridged in. |
+| **Missions** | Used as a worker executor (`claude_cli`) during mission execution phases. Each worker gets its own Claude Code process. |
+| **CTO Workers** | When the CTO delegates a task to an employee agent, it can use Claude Code as the execution backend. |
+| **Automations** | Automation rules with `agent-session` execution kind can use Claude Code as the underlying agent. |
+
+---
 
 ## Launching Claude Code from ADE
 
 <Steps>
   <Step title="Open a lane">
-    Navigate to the lane where you want to run Claude Code.
+    Navigate to the lane where you want to run Claude Code. The agent will work in this lane's worktree.
   </Step>
   <Step title="Open the Run tab">
     Click the **Run** tab or use the AI tool launcher in Project Home.
   </Step>
   <Step title="Launch Claude Code">
-    Click the **Claude Code** launcher. ADE starts a managed session with the lane's context pack injected as initial context.
+    Click the **Claude Code** launcher. ADE starts a managed session with:
+    - The lane's context pack injected as initial context
+    - MCP tools from ADE's server available to the agent
+    - Environment variables from the lane's overlay applied
+    - The working directory set to the lane's worktree path
   </Step>
 </Steps>
 
-## Permission modes
+---
+
+## MCP Tool Bridging
+
+When ADE launches Claude Code, it bridges ADE's MCP tools into the Claude Code session. This means the Claude Code agent can use ADE-specific tools (file operations, git operations, PR management, lane management) alongside its built-in capabilities.
+
+ADE runs a pre-session **MCP initialize probe** to verify that the MCP server is reachable before starting the Claude Code session. If the probe fails, ADE reports the error in the chat UI instead of starting a broken session.
+
+---
+
+## Permission Modes
 
 ADE supports several permission modes for Claude Code sessions:
 
 | Mode | Behavior |
 |------|----------|
-| `default` | Standard Claude Code permissions |
-| `plan` | Planning only, no file writes |
-| `acceptEdits` | Auto-accept file edits |
-| `bypassPermissions` | Skip all permission prompts |
+| `default` | Standard Claude Code permissions — the agent asks before making changes |
+| `plan` | Planning only — the agent can read files and reason but cannot write or execute |
+| `acceptEdits` | Auto-accept file edits — the agent can write files without asking, but still asks for terminal commands |
+| `bypassPermissions` | Skip all permission prompts — full autonomy. Use with caution. |
+
+Configure the default permission mode in **Settings > AI Providers** or per-mission in the mission creation dialog. For CTO-delegated workers, the CTO sets the permission mode based on the task's risk level.
+
+---
+
+## Connection Status
+
+ADE shows Claude Code's connection status in **Settings > AI Providers**:
+
+| Status | Meaning |
+|--------|---------|
+| **Ready** (green) | Claude Code executable found, authenticated, and runtime probe passed |
+| **Auth failed** (amber) | Claude Code is installed but not authenticated. Run `claude auth login` in a terminal or use `/login` in chat. |
+| **Not found** (gray) | Claude Code CLI not detected. Install it with `npm install -g @anthropic-ai/claude-code`. |
+| **Runtime failed** (red) | Claude Code is installed but the runtime probe failed. Check ADE's developer logs for details. |
+
+---
+
+## Troubleshooting
 
-Configure the default permission mode in **Settings > AI Providers** or per-mission in the mission creation dialog.
+<AccordionGroup>
+  <Accordion title="Claude Code not detected" icon="circle-question">
+    ADE checks standard installation paths and PATH for the Claude Code executable. If installed in a non-standard location, ensure `claude` is available in your PATH. Verify with `which claude` in a terminal.
+  </Accordion>
+  <Accordion title="Authentication errors in chat" icon="lock">
+    Run `claude auth login` in a terminal outside ADE, then restart ADE or click **Refresh** in Settings > AI Providers. ADE caches the runtime probe result for 30 seconds, so the status updates shortly after re-authentication.
+  </Accordion>
+  <Accordion title="MCP tools not available to the agent" icon="plug">
+    Check that the MCP initialize probe passed (visible in the chat session's startup messages). If the probe failed, verify that ADE's MCP server is running — check **Settings > MCP** for server status.
+  </Accordion>
+  <Accordion title="Session hangs or times out" icon="clock">
+    The runtime probe has a 20-second timeout. If your network is slow or the Anthropic API is under load, the probe may fail. Check your internet connection and try again. If sessions consistently hang, check the developer logs for detailed error information.
+  </Accordion>
+</AccordionGroup>
diff --git a/ai-tools/windsurf.mdx b/ai-tools/windsurf.mdx
index 003423105..5d1543229 100644
--- a/ai-tools/windsurf.mdx
+++ b/ai-tools/windsurf.mdx
@@ -1,19 +1,104 @@
 ---
 title: "Windsurf"
-description: "Open your project in Windsurf from ADE and track the session."
+description: "Launch Windsurf from ADE to edit code in a lane's worktree with session tracking and environment inheritance."
 icon: "water"
 ---
 
 ## Overview
 
-ADE can launch [Windsurf](https://codeium.com/windsurf) for your project directly from the Run tab. When launched through ADE, the session is tracked as a managed session in the lane for visibility in the History view.
+ADE can launch [Windsurf](https://codeium.com/windsurf) (by Codeium) as an external editor for any lane. When you open Windsurf through ADE, the session is tracked in the lane's history, the correct worktree directory is opened, and any file changes you make in Windsurf appear in the lane's diff view as soon as they are saved.
+
+This is a one-way integration — ADE launches Windsurf and tracks the session, but does not route AI agent requests through Windsurf or manage Windsurf's internal AI features. You use Windsurf's built-in AI capabilities directly within the Windsurf editor.
+
+---
 
 ## Requirements
 
-- Windsurf installed on your machine
+| Requirement | Details |
+|------------|---------|
+| **Windsurf installed** | The Windsurf desktop app must be installed on your machine |
+| **CLI available** | The `windsurf` command must be available in your PATH. Windsurf typically adds this during installation. Verify with `which windsurf` in a terminal. |
+
+---
 
 ## Launching Windsurf from ADE
 
-Open the **Run** tab or **Project Home** and click the **Windsurf** launcher (if configured). ADE opens the current project (or the selected lane's worktree) in Windsurf as a separate application window.
+<Steps>
+  <Step title="Select a lane">
+    Navigate to the lane you want to work in. Windsurf will open the lane's worktree directory — not the primary checkout.
+  </Step>
+  <Step title="Open the Run tab or Project Home">
+    Click the **Run** tab in the lane's toolbar, or open **Project Home** from the sidebar.
+  </Step>
+  <Step title="Click the Windsurf launcher">
+    If Windsurf is detected or configured, a **Windsurf** button appears alongside other external tool launchers (Cursor, VS Code, Claude Code, etc.). Click it.
+  </Step>
+  <Step title="Windsurf opens">
+    ADE launches Windsurf pointed at the lane's worktree path. The session is registered in ADE's history system.
+  </Step>
+</Steps>
+
+---
+
+## What ADE Tracks
+
+When you launch Windsurf through ADE:
+
+- **Session registration** — the launch is recorded as a managed session in the lane, visible in the History view
+- **File change detection** — ADE watches the lane's worktree for filesystem changes. Edits made in Windsurf appear in the lane's diff view in real time.
+- **Environment inheritance** — Windsurf inherits the lane's environment variable overlays and port assignments
+
+ADE does not monitor Windsurf's internal AI usage, chat history, or token consumption. Those are managed entirely within Windsurf.
+
+---
+
+## Configuring a Custom Launcher
+
+If Windsurf does not appear in the Run tab by default, you can add it as a custom CLI launcher:
+
+<Steps>
+  <Step title="Open Settings">
+    Navigate to **Settings > Project Home > Custom CLI Launchers**.
+  </Step>
+  <Step title="Add a new launcher">
+    Click **Add Launcher** and configure:
+    - **Name:** `Windsurf`
+    - **Command:** `windsurf` (or the full path to the Windsurf executable if it is not in PATH)
+    - **Arguments:** `{worktreePath}` — ADE substitutes the lane's worktree directory at launch time
+  </Step>
+  <Step title="Save and verify">
+    Save the launcher. It now appears in the Run tab for all lanes.
+  </Step>
+</Steps>
+
+---
+
+## Windsurf vs. Cursor vs. Claude Code
+
+ADE supports multiple external AI tools. Here is how Windsurf compares:
+
+| Capability | Windsurf | Cursor | Claude Code |
+|-----------|----------|--------|-------------|
+| **Launch from ADE** | Yes | Yes | Yes |
+| **Session tracking** | Yes | Yes | Yes |
+| **Agent provider in ADE chat** | No | Yes (via ACP) | Yes (via CLI) |
+| **MCP tool bridging** | No | Yes | Yes |
+| **Model routing through ADE** | No | Yes | Yes |
+
+Windsurf is a good choice when you want to use Codeium's AI features directly in the editor while keeping the session tracked in ADE. For deeper integration where ADE manages the AI agent lifecycle, use Cursor (via ACP) or Claude Code (via CLI).
+
+---
+
+## Troubleshooting
 
-Configure custom CLI launchers in **Settings > Project Home > Custom CLI Launchers** if Windsurf does not appear by default.
+<AccordionGroup>
+  <Accordion title="Windsurf launcher does not appear" icon="circle-question">
+    ADE may not detect Windsurf automatically. Add it as a custom CLI launcher in **Settings > Project Home > Custom CLI Launchers** using the `windsurf` command.
+  </Accordion>
+  <Accordion title="Windsurf opens the wrong directory" icon="folder">
+    Verify you selected the correct lane before launching. If Windsurf opens the primary checkout instead of the lane worktree, check that the lane was created as a Worktree Lane (not the primary lane).
+  </Accordion>
+  <Accordion title="File changes not appearing in ADE" icon="file">
+    ADE watches the lane's worktree for filesystem changes. If changes are not appearing, check that you are editing files inside the lane's worktree path (visible in the lane detail header), not in a different directory.
+  </Accordion>
+</AccordionGroup>
diff --git a/apps/desktop/package-lock.json b/apps/desktop/package-lock.json
index 321ed127a..023ff5b51 100644
--- a/apps/desktop/package-lock.json
+++ b/apps/desktop/package-lock.json
@@ -26,6 +26,7 @@
         "@radix-ui/react-tabs": "^1.1.13",
         "@tanstack/react-virtual": "^3.13.21",
         "@xterm/addon-fit": "^0.11.0",
+        "@xterm/addon-webgl": "^0.19.0",
         "@xterm/xterm": "^6.0.0",
         "@xyflow/react": "^12.5.0",
         "ai": "^6.0.141",
@@ -7480,6 +7481,12 @@
       "integrity": "sha512-jYcgT6xtVYhnhgxh3QgYDnnNMYTcf8ElbxxFzX0IZo+vabQqSPAjC3c1wJrKB5E19VwQei89QCiZZP86DCPF7g==",
       "license": "MIT"
     },
+    "node_modules/@xterm/addon-webgl": {
+      "version": "0.19.0",
+      "resolved": "https://registry.npmjs.org/@xterm/addon-webgl/-/addon-webgl-0.19.0.tgz",
+      "integrity": "sha512-b3fMOsyLVuCeNJWxolACEUED0vm7qC0cy4wRvf3oURSzDTYVQiGPhTnhWZwIHdvC48Y+oLhvYXnY4XDXPoJo6A==",
+      "license": "MIT"
+    },
     "node_modules/@xterm/xterm": {
       "version": "6.0.0",
       "resolved": "https://registry.npmjs.org/@xterm/xterm/-/xterm-6.0.0.tgz",
diff --git a/apps/desktop/package.json b/apps/desktop/package.json
index 5e15e5d55..00f60dc05 100644
--- a/apps/desktop/package.json
+++ b/apps/desktop/package.json
@@ -56,6 +56,7 @@
     "@radix-ui/react-tabs": "^1.1.13",
     "@tanstack/react-virtual": "^3.13.21",
     "@xterm/addon-fit": "^0.11.0",
+    "@xterm/addon-webgl": "^0.19.0",
     "@xterm/xterm": "^6.0.0",
     "@xyflow/react": "^12.5.0",
     "ai": "^6.0.141",
diff --git a/apps/desktop/scripts/validate-mac-artifacts.mjs b/apps/desktop/scripts/validate-mac-artifacts.mjs
index f56fa3995..8dc1d5b68 100644
--- a/apps/desktop/scripts/validate-mac-artifacts.mjs
+++ b/apps/desktop/scripts/validate-mac-artifacts.mjs
@@ -226,6 +226,23 @@ async function validatePackagedRuntime(appPath, description) {
   if (!payload?.proxyProbe?.ok) {
     throw new Error("[release:mac] Packaged smoke failed to launch the bundled ADE MCP proxy in probe mode");
   }
+  // Do not rely on probe mode alone here. The regression we fixed still let
+  // the packaged proxy start, but chat MCP failed once Claude/Codex attempted
+  // the first initialize handshake through that launch path.
+  if (!payload?.proxyInitialize?.ok) {
+    throw new Error(
+      `[release:mac] Packaged smoke failed to complete MCP initialize through the bundled ADE proxy: ${
+        String(payload?.proxyInitialize?.error || payload?.proxyInitialize?.stderr || "unknown error")
+      }`
+    );
+  }
+  if (payload?.proxyInitialize?.response?.result?.serverInfo?.name !== "ade-mcp-server") {
+    throw new Error(
+      `[release:mac] Packaged smoke expected ADE MCP initialize to report ade-mcp-server, got ${
+        JSON.stringify(payload?.proxyInitialize?.response ?? null)
+      }`
+    );
+  }
 
   console.log(`[release:mac] Packaged runtime smoke passed for ${description}: ${path.relative(appPath, nodePtyAddon)}`);
 }
diff --git a/apps/desktop/src/main/adeMcpProxy.ts b/apps/desktop/src/main/adeMcpProxy.ts
index 069e2428c..b9d7ae18c 100644
--- a/apps/desktop/src/main/adeMcpProxy.ts
+++ b/apps/desktop/src/main/adeMcpProxy.ts
@@ -45,13 +45,37 @@ function resolveRuntimeRoots(): RuntimeRoots {
   return { projectRoot, workspaceRoot };
 }
 
+function asBoolFlag(value: string | undefined): boolean | null {
+  const trimmed = value?.trim() ?? "";
+  return trimmed === "1" ? true : trimmed === "0" ? false : null;
+}
+
 function resolveProxyIdentityFromEnv(): ProxyIdentity {
+  const computerUseMode = asTrimmed(process.env.ADE_COMPUTER_USE_MODE);
+  const allowLocalFallback = asBoolFlag(process.env.ADE_COMPUTER_USE_ALLOW_LOCAL_FALLBACK);
+  const retainArtifacts = asBoolFlag(process.env.ADE_COMPUTER_USE_RETAIN_ARTIFACTS);
+  const preferredBackend = asTrimmed(process.env.ADE_COMPUTER_USE_PREFERRED_BACKEND);
+  const hasComputerUsePolicy =
+    computerUseMode
+    || typeof allowLocalFallback === "boolean"
+    || typeof retainArtifacts === "boolean"
+    || preferredBackend;
   return {
+    chatSessionId: asTrimmed(process.env.ADE_CHAT_SESSION_ID),
     missionId: asTrimmed(process.env.ADE_MISSION_ID),
     runId: asTrimmed(process.env.ADE_RUN_ID),
     stepId: asTrimmed(process.env.ADE_STEP_ID),
     attemptId: asTrimmed(process.env.ADE_ATTEMPT_ID),
+    ownerId: asTrimmed(process.env.ADE_OWNER_ID),
     role: asTrimmed(process.env.ADE_DEFAULT_ROLE),
+    computerUsePolicy: hasComputerUsePolicy
+      ? {
+          mode: computerUseMode,
+          allowLocalFallback,
+          retainArtifacts,
+          preferredBackend,
+        }
+      : null,
   };
 }
 
diff --git a/apps/desktop/src/main/adeMcpProxyUtils.test.ts b/apps/desktop/src/main/adeMcpProxyUtils.test.ts
index f13444f5d..59fe94f18 100644
--- a/apps/desktop/src/main/adeMcpProxyUtils.test.ts
+++ b/apps/desktop/src/main/adeMcpProxyUtils.test.ts
@@ -12,11 +12,14 @@ import {
 } from "./adeMcpProxyUtils";
 
 const NULL_IDENTITY: ProxyIdentity = {
+  chatSessionId: null,
   missionId: null,
   runId: null,
   stepId: null,
   attemptId: null,
+  ownerId: null,
   role: null,
+  computerUsePolicy: null,
 };
 
 describe("asTrimmed", () => {
@@ -85,6 +88,10 @@ describe("hasProxyIdentity", () => {
     expect(hasProxyIdentity({ ...NULL_IDENTITY, missionId: "m-1" })).toBe(true);
   });
 
+  it("returns true when chatSessionId is set", () => {
+    expect(hasProxyIdentity({ ...NULL_IDENTITY, chatSessionId: "chat-1" })).toBe(true);
+  });
+
   it("returns true when runId is set", () => {
     expect(hasProxyIdentity({ ...NULL_IDENTITY, runId: "r-1" })).toBe(true);
   });
@@ -101,6 +108,22 @@ describe("hasProxyIdentity", () => {
     expect(hasProxyIdentity({ ...NULL_IDENTITY, role: "coder" })).toBe(true);
   });
 
+  it("returns true when ownerId is set", () => {
+    expect(hasProxyIdentity({ ...NULL_IDENTITY, ownerId: "agent-1" })).toBe(true);
+  });
+
+  it("returns true when computerUsePolicy is set", () => {
+    expect(hasProxyIdentity({
+      ...NULL_IDENTITY,
+      computerUsePolicy: {
+        mode: "enabled",
+        allowLocalFallback: null,
+        retainArtifacts: null,
+        preferredBackend: null,
+      },
+    })).toBe(true);
+  });
+
   it("returns true when multiple fields are set", () => {
     expect(hasProxyIdentity({ ...NULL_IDENTITY, missionId: "m-1", role: "coder" })).toBe(true);
   });
@@ -261,11 +284,19 @@ describe("takeNextInboundMessage", () => {
 
 describe("injectIdentityIntoInitializePayload", () => {
   const identity: ProxyIdentity = {
+    chatSessionId: "chat-1",
     missionId: "m-1",
     runId: "r-1",
     stepId: "s-1",
     attemptId: "a-1",
+    ownerId: "agent-1",
     role: "coder",
+    computerUsePolicy: {
+      mode: "enabled",
+      allowLocalFallback: true,
+      retainArtifacts: false,
+      preferredBackend: "vnc",
+    },
   };
 
   it("injects identity into initialize method", () => {
@@ -277,11 +308,19 @@ describe("injectIdentityIntoInitializePayload", () => {
     });
     const result = JSON.parse(injectIdentityIntoInitializePayload(payload, identity));
     expect(result.params.identity).toEqual({
+      chatSessionId: "chat-1",
       missionId: "m-1",
       runId: "r-1",
       stepId: "s-1",
       attemptId: "a-1",
+      ownerId: "agent-1",
       role: "coder",
+      computerUsePolicy: {
+        mode: "enabled",
+        allowLocalFallback: true,
+        retainArtifacts: false,
+        preferredBackend: "vnc",
+      },
     });
   });
 
@@ -303,17 +342,30 @@ describe("injectIdentityIntoInitializePayload", () => {
       id: 1,
       params: {
         identity: {
+          chatSessionId: "existing-chat",
           missionId: "existing-mission",
+          ownerId: "existing-owner",
           role: "existing-role",
+          computerUsePolicy: {
+            mode: "off",
+          },
         },
       },
     });
     const result = JSON.parse(injectIdentityIntoInitializePayload(payload, identity));
+    expect(result.params.identity.chatSessionId).toBe("existing-chat");
     expect(result.params.identity.missionId).toBe("existing-mission");
+    expect(result.params.identity.ownerId).toBe("existing-owner");
     expect(result.params.identity.role).toBe("existing-role");
     expect(result.params.identity.runId).toBe("r-1");
     expect(result.params.identity.stepId).toBe("s-1");
     expect(result.params.identity.attemptId).toBe("a-1");
+    expect(result.params.identity.computerUsePolicy).toEqual({
+      mode: "off",
+      allowLocalFallback: true,
+      retainArtifacts: false,
+      preferredBackend: "vnc",
+    });
   });
 
   it("overwrites existing identity fields that are empty strings", () => {
@@ -323,13 +375,17 @@ describe("injectIdentityIntoInitializePayload", () => {
       id: 1,
       params: {
         identity: {
+          chatSessionId: "   ",
           missionId: "   ",
+          ownerId: "",
           role: "",
         },
       },
     });
     const result = JSON.parse(injectIdentityIntoInitializePayload(payload, identity));
+    expect(result.params.identity.chatSessionId).toBe("chat-1");
     expect(result.params.identity.missionId).toBe("m-1");
+    expect(result.params.identity.ownerId).toBe("agent-1");
     expect(result.params.identity.role).toBe("coder");
   });
 
@@ -360,11 +416,19 @@ describe("injectIdentityIntoInitializePayload", () => {
     });
     const result = JSON.parse(injectIdentityIntoInitializePayload(payload, identity));
     expect(result.params.identity).toEqual({
+      chatSessionId: "chat-1",
       missionId: "m-1",
       runId: "r-1",
       stepId: "s-1",
       attemptId: "a-1",
+      ownerId: "agent-1",
       role: "coder",
+      computerUsePolicy: {
+        mode: "enabled",
+        allowLocalFallback: true,
+        retainArtifacts: false,
+        preferredBackend: "vnc",
+      },
     });
   });
 
@@ -379,6 +443,7 @@ describe("injectIdentityIntoInitializePayload", () => {
     });
     const result = JSON.parse(injectIdentityIntoInitializePayload(payload, identity));
     expect(result.params.capabilities).toEqual({ tools: true });
+    expect(result.params.identity.chatSessionId).toBe("chat-1");
     expect(result.params.identity.missionId).toBe("m-1");
   });
 });
diff --git a/apps/desktop/src/main/adeMcpProxyUtils.ts b/apps/desktop/src/main/adeMcpProxyUtils.ts
index 06f1f8fe8..470ad5e66 100644
--- a/apps/desktop/src/main/adeMcpProxyUtils.ts
+++ b/apps/desktop/src/main/adeMcpProxyUtils.ts
@@ -1,11 +1,19 @@
 import type { Buffer } from "node:buffer";
 
 export type ProxyIdentity = {
+  chatSessionId: string | null;
   missionId: string | null;
   runId: string | null;
   stepId: string | null;
   attemptId: string | null;
+  ownerId: string | null;
   role: string | null;
+  computerUsePolicy: {
+    mode: string | null;
+    allowLocalFallback: boolean | null;
+    retainArtifacts: boolean | null;
+    preferredBackend: string | null;
+  } | null;
 };
 
 export type ParsedInboundMessage = {
@@ -25,7 +33,25 @@ export function isRecord(value: unknown): value is Record<string, unknown> {
 }
 
 export function hasProxyIdentity(identity: ProxyIdentity): boolean {
-  return Boolean(identity.missionId || identity.runId || identity.stepId || identity.attemptId || identity.role);
+  const hasComputerUsePolicy = Boolean(
+    identity.computerUsePolicy
+    && (
+      identity.computerUsePolicy.mode
+      || typeof identity.computerUsePolicy.allowLocalFallback === "boolean"
+      || typeof identity.computerUsePolicy.retainArtifacts === "boolean"
+      || identity.computerUsePolicy.preferredBackend
+    ),
+  );
+  return Boolean(
+    identity.chatSessionId
+    || identity.missionId
+    || identity.runId
+    || identity.stepId
+    || identity.attemptId
+    || identity.ownerId
+    || identity.role
+    || hasComputerUsePolicy,
+  );
 }
 
 export function findHeaderBoundary(buffer: Buffer): { index: number; delimiterLength: number } | null {
@@ -97,7 +123,7 @@ export function injectIdentityIntoInitializePayload(payloadText: string, identit
   const existingIdentity = isRecord(params.identity) ? { ...params.identity } : {};
   const mergedIdentity: Record<string, unknown> = { ...existingIdentity };
 
-  const identityKeys = ["missionId", "runId", "stepId", "attemptId", "role"] as const;
+  const identityKeys = ["chatSessionId", "missionId", "runId", "stepId", "attemptId", "ownerId", "role"] as const;
   for (const key of identityKeys) {
     if (!identity[key]) continue;
     const existing = existingIdentity[key];
@@ -105,6 +131,37 @@ export function injectIdentityIntoInitializePayload(payloadText: string, identit
     mergedIdentity[key] = identity[key];
   }
 
+  const proxyComputerUsePolicy = identity.computerUsePolicy;
+  if (proxyComputerUsePolicy) {
+    const existingComputerUsePolicy = isRecord(existingIdentity.computerUsePolicy)
+      ? { ...existingIdentity.computerUsePolicy }
+      : {};
+    let shouldWriteComputerUsePolicy = false;
+
+    const hasExistingString = (key: string): boolean =>
+      typeof existingComputerUsePolicy[key] === "string" && (existingComputerUsePolicy[key] as string).trim().length > 0;
+    const mergeString = (key: "mode" | "preferredBackend"): void => {
+      if (proxyComputerUsePolicy[key] && !hasExistingString(key)) {
+        existingComputerUsePolicy[key] = proxyComputerUsePolicy[key];
+        shouldWriteComputerUsePolicy = true;
+      }
+    };
+    const mergeBool = (key: "allowLocalFallback" | "retainArtifacts"): void => {
+      if (typeof proxyComputerUsePolicy[key] === "boolean" && typeof existingComputerUsePolicy[key] !== "boolean") {
+        existingComputerUsePolicy[key] = proxyComputerUsePolicy[key];
+        shouldWriteComputerUsePolicy = true;
+      }
+    };
+    mergeString("mode");
+    mergeBool("allowLocalFallback");
+    mergeBool("retainArtifacts");
+    mergeString("preferredBackend");
+
+    if (shouldWriteComputerUsePolicy) {
+      mergedIdentity.computerUsePolicy = existingComputerUsePolicy;
+    }
+  }
+
   return JSON.stringify({
     ...payload,
     params: {
diff --git a/apps/desktop/src/main/main.ts b/apps/desktop/src/main/main.ts
index 4b885bb95..162752d69 100644
--- a/apps/desktop/src/main/main.ts
+++ b/apps/desktop/src/main/main.ts
@@ -679,6 +679,8 @@ app.whenReady().then(async () => {
     let prServiceRef: ReturnType<typeof createPrService> | null = null;
     let prPollingServiceRef: ReturnType<typeof createPrPollingService> | null = null;
     let testServiceRef: ReturnType<typeof createTestService> | null = null;
+    let gitServiceRef: ReturnType<typeof createGitOperationsService> | null = null;
+    let missionBudgetServiceRef: ReturnType<typeof createMissionBudgetService> | null = null;
 
     const lastHeadByLaneId = new Map<string, string>();
 
@@ -759,7 +761,10 @@ app.whenReady().then(async () => {
     });
 
     const sessionService = createSessionService({ db });
-    const reconciledSessions = sessionService.reconcileStaleRunningSessions({ status: "disposed" });
+    const reconciledSessions = sessionService.reconcileStaleRunningSessions({
+      status: "disposed",
+      excludeToolTypes: ["claude-chat", "codex-chat", "ai-chat", "cursor"],
+    });
     if (reconciledSessions > 0) {
       logger.warn("sessions.reconciled_stale_running", { count: reconciledSessions });
     }
@@ -1380,6 +1385,11 @@ app.whenReady().then(async () => {
       getTestService: () => testServiceRef,
       ptyService,
       getAutomationService: () => automationService,
+      getGitService: () => gitServiceRef,
+      conflictService,
+      contextDocService,
+      getWorkerBudgetService: () => workerBudgetService,
+      getMissionBudgetService: () => missionBudgetServiceRef,
       episodicSummaryService,
       laneService,
       sessionService,
@@ -1473,6 +1483,7 @@ app.whenReady().then(async () => {
       }
     });
     testServiceRef = testService;
+    gitServiceRef = gitService;
 
     automationService = createAutomationService({
       db,
@@ -1559,6 +1570,7 @@ app.whenReady().then(async () => {
       aiIntegrationService,
       projectConfigService,
     });
+    missionBudgetServiceRef = missionBudgetService;
     let missionPreflightService: ReturnType<typeof createMissionPreflightService>;
     const deferredProjectStartCancels = new Set<() => void>();
     const scheduleDeferredProjectStart = (
diff --git a/apps/desktop/src/main/packagedRuntimeSmoke.ts b/apps/desktop/src/main/packagedRuntimeSmoke.ts
index 21d1055ed..3717614bb 100644
--- a/apps/desktop/src/main/packagedRuntimeSmoke.ts
+++ b/apps/desktop/src/main/packagedRuntimeSmoke.ts
@@ -1,6 +1,6 @@
 import fs from "node:fs";
 import path from "node:path";
-import { execFile } from "node:child_process";
+import { execFile, spawnSync } from "node:child_process";
 import { createRequire } from "node:module";
 import { promisify } from "node:util";
 import { resolveDesktopAdeMcpLaunch } from "./services/runtime/adeMcpLaunch";
@@ -101,6 +101,64 @@ async function probeClaudeStartup(
   }
 }
 
+function probeMcpInitialize(args: {
+  command: string;
+  cmdArgs: string[];
+  cwd: string;
+  env: NodeJS.ProcessEnv;
+}): {
+  ok: boolean;
+  response: unknown | null;
+  stderr: string | null;
+  error: string | null;
+} {
+  // Keep this as a real MCP initialize round-trip instead of another cheap
+  // "--probe" check. We regressed packaged chats by launching the proxy
+  // successfully but routing chat MCP through the wrong path, which only
+  // showed up once the client attempted the first initialize handshake.
+  const payload = JSON.stringify({
+    jsonrpc: "2.0",
+    id: 1,
+    method: "initialize",
+    params: {
+      protocolVersion: "2025-06-18",
+      clientInfo: {
+        name: "packaged-runtime-smoke",
+        version: "1.0.0",
+      },
+      capabilities: {},
+    },
+  });
+
+  const result = spawnSync(args.command, args.cmdArgs, {
+    cwd: args.cwd,
+    env: args.env,
+    input: `${payload}\n`,
+    encoding: "utf8",
+    timeout: 5_000,
+  });
+
+  const stdout = (result.stdout ?? "").trim();
+  const stderr = (result.stderr ?? "").trim();
+  const error = result.error ? String(result.error.message ?? result.error) : null;
+
+  try {
+    return {
+      ok: result.status === 0,
+      response: stdout ? JSON.parse(stdout) : null,
+      stderr: stderr || null,
+      error,
+    };
+  } catch (parseError) {
+    return {
+      ok: false,
+      response: stdout || null,
+      stderr: stderr || null,
+      error: parseError instanceof Error ? parseError.message : String(parseError),
+    };
+  }
+}
+
 async function main(): Promise<void> {
   const pty = await import("node-pty");
   const claude = await import("@anthropic-ai/claude-agent-sdk");
@@ -135,6 +193,16 @@ async function main(): Promise<void> {
     proxyProbeResult = proxyProbeStdout;
   }
 
+  const proxyInitialize = probeMcpInitialize({
+    command: launch.command,
+    cmdArgs: launch.cmdArgs,
+    cwd,
+    env: {
+      ...process.env,
+      ...launch.env,
+    },
+  });
+
   process.stdout.write(JSON.stringify({
     ok: true,
     nodePty: typeof pty.spawn,
@@ -149,6 +217,7 @@ async function main(): Promise<void> {
     launchEntryPath: launch.entryPath,
     launchSocketPath: launch.socketPath,
     proxyProbe: proxyProbeResult,
+    proxyInitialize,
   }));
 }
 
diff --git a/apps/desktop/src/main/services/ai/authDetector.test.ts b/apps/desktop/src/main/services/ai/authDetector.test.ts
index 26416a9ef..d18ecdc4a 100644
--- a/apps/desktop/src/main/services/ai/authDetector.test.ts
+++ b/apps/desktop/src/main/services/ai/authDetector.test.ts
@@ -260,38 +260,54 @@ describe("authDetector", () => {
   it("finds codex through an npm-global prefix when PATH lookup fails", async () => {
     tempHomeDir = fs.mkdtempSync(path.join(os.tmpdir(), "ade-auth-detector-"));
     const prefixDir = path.join(tempHomeDir, ".npm-global");
+    const preferredCodexPath = path.join(prefixDir, "bin", "codex");
     fs.mkdirSync(path.join(prefixDir, "bin"), { recursive: true });
     fs.writeFileSync(path.join(tempHomeDir, ".npmrc"), "prefix=~/.npm-global\n", "utf8");
-    fs.writeFileSync(path.join(prefixDir, "bin", "codex"), "#!/bin/sh\nexit 0\n", "utf8");
-    fs.chmodSync(path.join(prefixDir, "bin", "codex"), 0o755);
+    fs.writeFileSync(preferredCodexPath, "#!/bin/sh\nexit 0\n", "utf8");
+    fs.chmodSync(preferredCodexPath, 0o755);
     process.env.HOME = tempHomeDir;
     process.env.PATH = "/usr/bin:/bin";
 
-    spawnMock.mockImplementation((command: string, args: string[] = []) => {
-      if (args[0] === "--version") {
-        if (command === "codex") return fakeError();
-        if (command === path.join(prefixDir, "bin", "codex")) return fakeChild({ status: 0, stdout: "0.105.0\n" });
-        return fakeError();
+    const realStatSync = fs.statSync.bind(fs);
+    const statSpy = vi.spyOn(fs, "statSync").mockImplementation(((candidatePath: fs.PathLike, options?: fs.StatOptions) => {
+      const resolved = String(candidatePath);
+      if (resolved.endsWith("/codex") && resolved !== preferredCodexPath) {
+        const error = new Error(`ENOENT: no such file or directory, stat '${resolved}'`) as NodeJS.ErrnoException;
+        error.code = "ENOENT";
+        throw error;
       }
-      if (command === "which") {
+      return realStatSync(candidatePath, options as fs.StatOptions | undefined);
+    }) as typeof fs.statSync);
+
+    try {
+      spawnMock.mockImplementation((command: string, args: string[] = []) => {
+        if (args[0] === "--version") {
+          if (command === "codex") return fakeError();
+          if (command === preferredCodexPath) return fakeChild({ status: 0, stdout: "0.105.0\n" });
+          return fakeError();
+        }
+        if (command === "which") {
+          return fakeChild({ status: 1 });
+        }
+        if ((command === "codex" || command.endsWith("/codex")) && args[0] === "login" && args[1] === "status") {
+          return fakeChild({ status: 0, stdout: "Authenticated as test-user\n" });
+        }
         return fakeChild({ status: 1 });
-      }
-      if ((command === "codex" || command.endsWith("/codex")) && args[0] === "login" && args[1] === "status") {
-        return fakeChild({ status: 0, stdout: "Authenticated as test-user\n" });
-      }
-      return fakeChild({ status: 1 });
-    });
+      });
 
-    const statuses = await detectCliAuthStatuses();
-    const codex = statuses.find((entry) => entry.cli === "codex");
+      const statuses = await detectCliAuthStatuses();
+      const codex = statuses.find((entry) => entry.cli === "codex");
 
-    expect(codex).toEqual({
-      cli: "codex",
-      installed: true,
-      path: path.join(prefixDir, "bin", "codex"),
-      authenticated: true,
-      verified: true,
-    });
+      expect(codex).toEqual({
+        cli: "codex",
+        installed: true,
+        path: preferredCodexPath,
+        authenticated: true,
+        verified: true,
+      });
+    } finally {
+      statSpy.mockRestore();
+    }
   });
 
   it("repairs PATH from the interactive shell during a forced refresh", async () => {
diff --git a/apps/desktop/src/main/services/ai/tools/ctoOperatorTools.ts b/apps/desktop/src/main/services/ai/tools/ctoOperatorTools.ts
index 6cfe1a982..758ec81d5 100644
--- a/apps/desktop/src/main/services/ai/tools/ctoOperatorTools.ts
+++ b/apps/desktop/src/main/services/ai/tools/ctoOperatorTools.ts
@@ -46,7 +46,8 @@ import type { createPrService } from "../../prs/prService";
 import { isNoisyIssueComment, mapPermissionMode } from "../../prs/resolverUtils";
 import type { createProcessService } from "../../processes/processService";
 import type { createSessionService } from "../../sessions/sessionService";
-import { getErrorMessage, nowIso } from "../../shared/utils";
+import type { createCtoStateService } from "../../cto/ctoStateService";
+import { getErrorMessage, nowIso, parseIsoToEpoch } from "../../shared/utils";
 
 export interface CtoOperatorToolDeps {
   currentSessionId: string;
@@ -86,7 +87,55 @@ export interface CtoOperatorToolDeps {
     triggerManually: (args: { id: string; dryRun?: boolean }) => Promise<AutomationRun>;
     listRuns: (args?: AutomationRunListArgs) => AutomationRun[];
   } | null;
+  gitService?: {
+    getSyncStatus: (args: { laneId: string }) => Promise<any>;
+    commit: (args: any) => Promise<any>;
+    push: (args: any) => Promise<any>;
+    pull: (args: { laneId: string }) => Promise<any>;
+    fetch: (args: { laneId: string }) => Promise<any>;
+    listRecentCommits: (args: { laneId: string; limit?: number }) => Promise<any[]>;
+    listBranches: (args: any) => Promise<any[]>;
+    checkoutBranch: (args: any) => Promise<any>;
+    stashPush: (args: any) => Promise<any>;
+    stashPop: (args: any) => Promise<any>;
+    listStashes: (args: { laneId: string }) => Promise<any[]>;
+    getConflictState: (args: { laneId: string }) => Promise<any>;
+    rebaseContinue: (args: { laneId: string }) => Promise<any>;
+    rebaseAbort: (args: { laneId: string }) => Promise<any>;
+    mergeAbort: (args: { laneId: string }) => Promise<any>;
+  } | null;
+  conflictService?: {
+    getLaneStatus: (args: any) => Promise<any>;
+    getRiskMatrix: () => Promise<any[]>;
+    simulateMerge: (args: any) => Promise<any>;
+    runPrediction: (args?: any) => Promise<any>;
+    listProposals: (args: { laneId: string }) => Promise<any[]>;
+    requestProposal: (args: any) => Promise<any>;
+    applyProposal: (args: any) => Promise<any>;
+    undoProposal: (args: any) => Promise<any>;
+  } | null;
+  contextDocService?: {
+    getStatus: () => any;
+    generateDocs: (args: any) => Promise<any>;
+  } | null;
+  steerChat?: (args: { sessionId: string; instruction: string }) => Promise<void>;
+  cancelSteer?: (args: { sessionId: string }) => Promise<void>;
+  handoffChat?: (args: { sessionId: string; targetIdentityKey?: string; reason?: string }) => Promise<any>;
+  listSubagents?: (args: { sessionId: string }) => Promise<any[]>;
+  approveToolUse?: (args: { sessionId: string; toolUseId: string; decision: "accept" | "accept_for_session" | "decline" | "cancel" }) => Promise<void>;
+  computerUseArtifactBrokerService?: {
+    listArtifacts: (args?: any) => any[];
+    updateArtifactReview: (args: any) => any;
+  } | null;
+  workerBudgetService?: {
+    getBudgetSnapshot: (args: { monthKey?: string }) => any;
+    listCostEvents: (args: { agentId: string; monthKey?: string; limit?: number }) => any[];
+  } | null;
+  missionBudgetService?: {
+    getMissionBudgetStatus: (args: { missionId: string }) => Promise<any>;
+  } | null;
   issueTracker?: IssueTracker | null;
+  ctoStateService?: Pick<ReturnType<typeof createCtoStateService>, "getSessionLogs" | "getSubordinateActivityLogs"> | null;
   listChats: (laneId?: string, options?: { includeIdentity?: boolean; includeAutomation?: boolean }) => Promise<AgentChatSessionSummary[]>;
   getChatStatus: (sessionId: string) => Promise<AgentChatSessionSummary | null>;
   getChatTranscript: (args: {
@@ -2066,6 +2115,112 @@ export function createCtoOperatorTools(deps: CtoOperatorToolDeps): Record<string
     },
   });
 
+  tools.getPullRequestDiff = tool({
+    description:
+      "Retrieve the code diff for an ADE-managed pull request. " +
+      "Returns per-file patches from GitHub. Use `files` to limit to specific paths. " +
+      "Output is truncated to `maxChars` (default 80 000) to stay within context budgets.",
+    inputSchema: z.object({
+      prId: z.string().trim().min(1),
+      files: z
+        .array(z.string().trim().min(1))
+        .optional()
+        .describe("Optional list of file paths to include. Omit for full diff."),
+      maxChars: z
+        .number()
+        .int()
+        .min(1000)
+        .max(400_000)
+        .optional()
+        .default(80_000)
+        .describe("Maximum total characters of patch text to return."),
+    }),
+    execute: async ({ prId, files: filterFiles, maxChars }) => {
+      if (!deps.prService) return { success: false, error: "PR service is not available." };
+      try {
+        let prFiles = await deps.prService.getFiles(prId);
+        if (filterFiles && filterFiles.length > 0) {
+          const allowed = new Set(filterFiles);
+          prFiles = prFiles.filter((f) => allowed.has(f.filename));
+        }
+        // Build bounded output
+        let totalChars = 0;
+        let truncated = false;
+        const patches: Array<{
+          filename: string;
+          status: string;
+          additions: number;
+          deletions: number;
+          patch: string | null;
+        }> = [];
+        for (const f of prFiles) {
+          const patchLen = f.patch?.length ?? 0;
+          if (totalChars + patchLen > maxChars && patches.length > 0) {
+            truncated = true;
+            break;
+          }
+          patches.push({
+            filename: f.filename,
+            status: f.status,
+            additions: f.additions,
+            deletions: f.deletions,
+            patch: f.patch,
+          });
+          totalChars += patchLen;
+        }
+        return {
+          success: true,
+          prId,
+          fileCount: prFiles.length,
+          returnedCount: patches.length,
+          truncated,
+          patches,
+        };
+      } catch (error) {
+        return { success: false, error: getErrorMessage(error) };
+      }
+    },
+  });
+
+  tools.approvePullRequest = tool({
+    description: "Submit an APPROVE review on an ADE-managed pull request.",
+    inputSchema: z.object({
+      prId: z.string().trim().min(1),
+      body: z
+        .string()
+        .optional()
+        .default("")
+        .describe("Optional approval comment body."),
+    }),
+    execute: async ({ prId, body }) => {
+      if (!deps.prService) return { success: false, error: "PR service is not available." };
+      try {
+        await deps.prService.submitReview({ prId, event: "APPROVE", body });
+        return { success: true, prId, event: "APPROVE" };
+      } catch (error) {
+        return { success: false, error: getErrorMessage(error) };
+      }
+    },
+  });
+
+  tools.requestPrChanges = tool({
+    description:
+      "Submit a REQUEST_CHANGES review on an ADE-managed pull request with a comment explaining what needs to change.",
+    inputSchema: z.object({
+      prId: z.string().trim().min(1),
+      body: z.string().trim().min(1).describe("Review comment explaining the requested changes."),
+    }),
+    execute: async ({ prId, body }) => {
+      if (!deps.prService) return { success: false, error: "PR service is not available." };
+      try {
+        await deps.prService.submitReview({ prId, event: "REQUEST_CHANGES", body });
+        return { success: true, prId, event: "REQUEST_CHANGES" };
+      } catch (error) {
+        return { success: false, error: getErrorMessage(error) };
+      }
+    },
+  });
+
   // ---------------------------------------------------------------------------
   // Lane Management
   // ---------------------------------------------------------------------------
@@ -2384,5 +2539,865 @@ export function createCtoOperatorTools(deps: CtoOperatorToolDeps): Record<string
     },
   });
 
+  // ---------------------------------------------------------------------------
+  // Git Operations
+  // ---------------------------------------------------------------------------
+
+  const resolveLaneId = (laneId?: string): string => laneId?.trim() || deps.defaultLaneId;
+
+  const gitGuard = async <T>(fn: () => Promise<T>): Promise<{ success: true } & T | { success: false; error: string }> => {
+    if (!deps.gitService) return { success: false, error: "Git service is not available." };
+    try {
+      return { success: true, ...(await fn()) } as { success: true } & T;
+    } catch (error) {
+      return { success: false, error: getErrorMessage(error) };
+    }
+  };
+
+  tools.gitStatus = tool({
+    description: "Get the git sync status for a lane (branch, ahead/behind, dirty state).",
+    inputSchema: z.object({ laneId: z.string().optional() }),
+    execute: ({ laneId }) => gitGuard(() => deps.gitService!.getSyncStatus({ laneId: resolveLaneId(laneId) })),
+  });
+
+  tools.gitCommit = tool({
+    description: "Create a git commit in a lane.",
+    inputSchema: z.object({ laneId: z.string().optional(), message: z.string().min(1), stageAll: z.boolean().optional().default(true) }),
+    execute: ({ laneId, message, stageAll }) => gitGuard(() => deps.gitService!.commit({ laneId: resolveLaneId(laneId), message, stageAll })),
+  });
+
+  tools.gitPush = tool({
+    description: "Push commits to the remote for a lane.",
+    inputSchema: z.object({ laneId: z.string().optional(), force: z.boolean().optional().default(false) }),
+    execute: ({ laneId, force }) => gitGuard(() => deps.gitService!.push({ laneId: resolveLaneId(laneId), force })),
+  });
+
+  tools.gitPull = tool({
+    description: "Pull from the remote for a lane.",
+    inputSchema: z.object({ laneId: z.string().optional() }),
+    execute: ({ laneId }) => gitGuard(() => deps.gitService!.pull({ laneId: resolveLaneId(laneId) })),
+  });
+
+  tools.gitFetch = tool({
+    description: "Fetch remote refs for a lane.",
+    inputSchema: z.object({ laneId: z.string().optional() }),
+    execute: ({ laneId }) => gitGuard(() => deps.gitService!.fetch({ laneId: resolveLaneId(laneId) })),
+  });
+
+  tools.gitListRecentCommits = tool({
+    description: "List recent commits in a lane.",
+    inputSchema: z.object({ laneId: z.string().optional(), limit: z.number().int().positive().max(100).optional().default(20) }),
+    execute: ({ laneId, limit }) => gitGuard(async () => {
+      const commits = await deps.gitService!.listRecentCommits({ laneId: resolveLaneId(laneId), limit });
+      return { count: commits.length, commits };
+    }),
+  });
+
+  tools.gitListBranches = tool({
+    description: "List git branches for a lane.",
+    inputSchema: z.object({ laneId: z.string().optional() }),
+    execute: ({ laneId }) => gitGuard(async () => {
+      const branches = await deps.gitService!.listBranches({ laneId: resolveLaneId(laneId) });
+      return { count: branches.length, branches };
+    }),
+  });
+
+  tools.gitCheckoutBranch = tool({
+    description: "Switch to or create a git branch in a lane.",
+    inputSchema: z.object({ laneId: z.string().optional(), branch: z.string().min(1), create: z.boolean().optional().default(false) }),
+    execute: ({ laneId, branch, create }) => gitGuard(() => deps.gitService!.checkoutBranch({ laneId: resolveLaneId(laneId), branch, create })),
+  });
+
+  tools.gitStashPush = tool({
+    description: "Stash working changes in a lane.",
+    inputSchema: z.object({ laneId: z.string().optional(), message: z.string().optional() }),
+    execute: ({ laneId, message }) => gitGuard(() => deps.gitService!.stashPush({ laneId: resolveLaneId(laneId), ...(message?.trim() ? { message: message.trim() } : {}) })),
+  });
+
+  tools.gitStashPop = tool({
+    description: "Pop the latest stash in a lane.",
+    inputSchema: z.object({ laneId: z.string().optional() }),
+    execute: ({ laneId }) => gitGuard(() => deps.gitService!.stashPop({ laneId: resolveLaneId(laneId) })),
+  });
+
+  tools.gitStashList = tool({
+    description: "List stashes in a lane.",
+    inputSchema: z.object({ laneId: z.string().optional() }),
+    execute: ({ laneId }) => gitGuard(async () => {
+      const stashes = await deps.gitService!.listStashes({ laneId: resolveLaneId(laneId) });
+      return { count: stashes.length, stashes };
+    }),
+  });
+
+  tools.gitGetConflictState = tool({
+    description: "Check if a lane has merge or rebase conflicts in progress.",
+    inputSchema: z.object({ laneId: z.string().optional() }),
+    execute: ({ laneId }) => gitGuard(() => deps.gitService!.getConflictState({ laneId: resolveLaneId(laneId) })),
+  });
+
+  tools.gitRebaseContinue = tool({
+    description: "Continue a rebase after resolving conflicts.",
+    inputSchema: z.object({ laneId: z.string().optional() }),
+    execute: ({ laneId }) => gitGuard(() => deps.gitService!.rebaseContinue({ laneId: resolveLaneId(laneId) })),
+  });
+
+  tools.gitRebaseAbort = tool({
+    description: "Abort an in-progress rebase.",
+    inputSchema: z.object({ laneId: z.string().optional() }),
+    execute: ({ laneId }) => gitGuard(() => deps.gitService!.rebaseAbort({ laneId: resolveLaneId(laneId) })),
+  });
+
+  tools.gitMergeAbort = tool({
+    description: "Abort an in-progress merge.",
+    inputSchema: z.object({ laneId: z.string().optional() }),
+    execute: ({ laneId }) => gitGuard(() => deps.gitService!.mergeAbort({ laneId: resolveLaneId(laneId) })),
+  });
+
+  // ---------------------------------------------------------------------------
+  // Conflict Resolution
+  // ---------------------------------------------------------------------------
+
+  const conflictGuard = async <T>(fn: () => Promise<T>): Promise<{ success: true } & T | { success: false; error: string }> => {
+    if (!deps.conflictService) return { success: false, error: "Conflict service is not available." };
+    try {
+      return { success: true, ...(await fn()) } as { success: true } & T;
+    } catch (error) {
+      return { success: false, error: getErrorMessage(error) };
+    }
+  };
+
+  tools.getConflictStatus = tool({
+    description: "Check merge conflict status for a lane.",
+    inputSchema: z.object({ laneId: z.string().optional() }),
+    execute: ({ laneId }) => conflictGuard(() => deps.conflictService!.getLaneStatus({ laneId: resolveLaneId(laneId) })),
+  });
+
+  tools.getConflictRiskMatrix = tool({
+    description: "Get the conflict risk matrix across all lanes.",
+    inputSchema: z.object({}),
+    execute: () => conflictGuard(async () => {
+      const matrix = await deps.conflictService!.getRiskMatrix();
+      return { count: matrix.length, entries: matrix };
+    }),
+  });
+
+  tools.simulateMerge = tool({
+    description: "Dry-run merge between two lanes to predict conflicts.",
+    inputSchema: z.object({ sourceLaneId: z.string().min(1), targetLaneId: z.string().optional() }),
+    execute: ({ sourceLaneId, targetLaneId }) => conflictGuard(() => deps.conflictService!.simulateMerge({ sourceLaneId, targetLaneId: targetLaneId?.trim() || undefined })),
+  });
+
+  tools.runConflictPrediction = tool({
+    description: "Run batch conflict prediction across all lanes.",
+    inputSchema: z.object({}),
+    execute: () => conflictGuard(() => deps.conflictService!.runPrediction()),
+  });
+
+  tools.listConflictProposals = tool({
+    description: "List AI-generated conflict resolution proposals for a lane.",
+    inputSchema: z.object({ laneId: z.string().min(1) }),
+    execute: ({ laneId }) => conflictGuard(async () => {
+      const proposals = await deps.conflictService!.listProposals({ laneId });
+      return { count: proposals.length, proposals };
+    }),
+  });
+
+  tools.requestConflictProposal = tool({
+    description: "Request an AI-generated resolution for a specific conflict.",
+    inputSchema: z.object({ laneId: z.string().min(1), filePath: z.string().optional() }),
+    execute: ({ laneId, filePath }) => conflictGuard(() => deps.conflictService!.requestProposal({ laneId, filePath: filePath?.trim() || undefined })),
+  });
+
+  tools.applyConflictProposal = tool({
+    description: "Apply an AI-generated conflict resolution proposal.",
+    inputSchema: z.object({ laneId: z.string().min(1), proposalId: z.string().min(1) }),
+    execute: ({ laneId, proposalId }) => conflictGuard(() => deps.conflictService!.applyProposal({ laneId, proposalId })),
+  });
+
+  tools.undoConflictProposal = tool({
+    description: "Undo an applied conflict resolution proposal.",
+    inputSchema: z.object({ laneId: z.string().min(1), proposalId: z.string().min(1) }),
+    execute: ({ laneId, proposalId }) => conflictGuard(() => deps.conflictService!.undoProposal({ laneId, proposalId })),
+  });
+
+  // ---------------------------------------------------------------------------
+  // Context Pack Export
+  // ---------------------------------------------------------------------------
+
+  tools.getContextStatus = tool({
+    description: "Check what ADE context docs exist and whether they are stale.",
+    inputSchema: z.object({}),
+    execute: async () => {
+      if (!deps.contextDocService) return { success: false, error: "Context doc service is not available." };
+      try {
+        return { success: true, ...deps.contextDocService.getStatus() };
+      } catch (error) {
+        return { success: false, error: getErrorMessage(error) };
+      }
+    },
+  });
+
+  tools.generateContextDocs = tool({
+    description: "Generate bounded context packs for bootstrapping workers or exporting project state.",
+    inputSchema: z.object({
+      scope: z.string().optional(),
+      categories: z.array(z.string()).optional(),
+    }),
+    execute: async ({ scope, categories }) => {
+      if (!deps.contextDocService) return { success: false, error: "Context doc service is not available." };
+      try {
+        return { success: true, ...(await deps.contextDocService.generateDocs({ scope, categories })) };
+      } catch (error) {
+        return { success: false, error: getErrorMessage(error) };
+      }
+    },
+  });
+
+  // ---------------------------------------------------------------------------
+  // Agent Chat Steering
+  // ---------------------------------------------------------------------------
+
+  tools.steerChat = tool({
+    description: "Inject a steering instruction into an active chat session.",
+    inputSchema: z.object({
+      sessionId: z.string().min(1),
+      instruction: z.string().min(1),
+    }),
+    execute: async ({ sessionId, instruction }) => {
+      if (!deps.steerChat) return { success: false, error: "Chat steering is not available." };
+      try {
+        await deps.steerChat({ sessionId, instruction });
+        return { success: true, sessionId };
+      } catch (error) {
+        return { success: false, error: getErrorMessage(error) };
+      }
+    },
+  });
+
+  tools.cancelSteer = tool({
+    description: "Cancel a pending steer instruction on a chat session.",
+    inputSchema: z.object({
+      sessionId: z.string().min(1),
+    }),
+    execute: async ({ sessionId }) => {
+      if (!deps.cancelSteer) return { success: false, error: "Chat steering is not available." };
+      try {
+        await deps.cancelSteer({ sessionId });
+        return { success: true, sessionId };
+      } catch (error) {
+        return { success: false, error: getErrorMessage(error) };
+      }
+    },
+  });
+
+  tools.handoffChat = tool({
+    description: "Hand off a chat session to a different agent identity.",
+    inputSchema: z.object({
+      sessionId: z.string().min(1),
+      targetIdentityKey: z.string().optional(),
+      reason: z.string().optional(),
+    }),
+    execute: async ({ sessionId, targetIdentityKey, reason }) => {
+      if (!deps.handoffChat) return { success: false, error: "Chat handoff is not available." };
+      try {
+        return { success: true, ...(await deps.handoffChat({ sessionId, targetIdentityKey, reason })) };
+      } catch (error) {
+        return { success: false, error: getErrorMessage(error) };
+      }
+    },
+  });
+
+  tools.listSubagents = tool({
+    description: "List sub-agents spawned by a chat session.",
+    inputSchema: z.object({
+      sessionId: z.string().min(1),
+    }),
+    execute: async ({ sessionId }) => {
+      if (!deps.listSubagents) return { success: false, error: "Sub-agent listing is not available." };
+      try {
+        const subagents = await deps.listSubagents({ sessionId });
+        return { success: true, count: subagents.length, subagents };
+      } catch (error) {
+        return { success: false, error: getErrorMessage(error) };
+      }
+    },
+  });
+
+  tools.approveToolUse = tool({
+    description: "Approve or deny a pending tool use in a chat session.",
+    inputSchema: z.object({
+      sessionId: z.string().min(1),
+      toolUseId: z.string().min(1),
+      decision: z.enum(["accept", "accept_for_session", "decline", "cancel"]),
+    }),
+    execute: async ({ sessionId, toolUseId, decision }) => {
+      if (!deps.approveToolUse) return { success: false, error: "Tool use approval is not available." };
+      try {
+        await deps.approveToolUse({ sessionId, toolUseId, decision });
+        return { success: true, sessionId, toolUseId, decision };
+      } catch (error) {
+        return { success: false, error: getErrorMessage(error) };
+      }
+    },
+  });
+
+  // ---------------------------------------------------------------------------
+  // Unified Event Feed
+  // ---------------------------------------------------------------------------
+
+  type RecentEvent = {
+    type: string;
+    timestamp: string;
+    summary: string;
+    ids: Record<string, string | null>;
+  };
+
+  tools.getRecentEvents = tool({
+    description:
+      "Surface a unified feed of recent project events: CTO session completions, worker activity, " +
+      "test completions/failures, PR review activity, mission state transitions, and chat session events. " +
+      "Use this to stay aware of what happened while you were idle or to brief the user on recent activity.",
+    inputSchema: z.object({
+      since: z
+        .string()
+        .optional()
+        .describe("ISO 8601 timestamp. Only events after this time are returned. Defaults to 24 hours ago."),
+      limit: z
+        .number()
+        .int()
+        .positive()
+        .max(200)
+        .optional()
+        .default(50)
+        .describe("Maximum number of events to return."),
+    }),
+    execute: async ({ since, limit }) => {
+      const sinceEpoch = since
+        ? parseIsoToEpoch(since)
+        : Date.now() - 24 * 60 * 60 * 1000;
+      const safeLimit = Math.max(1, Math.min(200, limit));
+      const events: RecentEvent[] = [];
+
+      const afterCutoff = (ts: string | null | undefined): boolean => {
+        if (!ts) return false;
+        const epoch = parseIsoToEpoch(ts);
+        return Number.isFinite(epoch) && epoch >= sinceEpoch;
+      };
+
+      // 1. CTO session logs
+      if (deps.ctoStateService) {
+        try {
+          const logs = deps.ctoStateService.getSessionLogs(200);
+          for (const log of logs) {
+            if (!afterCutoff(log.createdAt)) continue;
+            events.push({
+              type: "cto_session",
+              timestamp: log.createdAt,
+              summary: log.summary,
+              ids: { sessionId: log.sessionId, logId: log.id },
+            });
+          }
+        } catch {
+          // CTO state service may not be fully initialized
+        }
+      }
+
+      // 2. Subordinate (worker) activity from CTO state
+      if (deps.ctoStateService) {
+        try {
+          const activities = deps.ctoStateService.getSubordinateActivityLogs(200);
+          for (const activity of activities) {
+            if (!afterCutoff(activity.createdAt)) continue;
+            events.push({
+              type: `worker_${activity.activityType}`,
+              timestamp: activity.createdAt,
+              summary: `[${activity.agentName}] ${activity.summary}`,
+              ids: {
+                agentId: activity.agentId,
+                sessionId: activity.sessionId ?? null,
+                taskKey: activity.taskKey ?? null,
+                issueKey: activity.issueKey ?? null,
+              },
+            });
+          }
+        } catch {
+          // ignore
+        }
+      }
+
+      // 3. Worker runs from heartbeat service
+      if (deps.workerHeartbeatService) {
+        try {
+          const runs = deps.workerHeartbeatService.listRuns({ limit: 100 });
+          for (const run of runs) {
+            const ts = run.finishedAt ?? run.startedAt ?? run.createdAt;
+            if (!afterCutoff(ts)) continue;
+            events.push({
+              type: "worker_run",
+              timestamp: ts,
+              summary: `Worker run ${run.status}${run.taskKey ? ` (task: ${run.taskKey})` : ""}${run.errorMessage ? ` — ${run.errorMessage}` : ""}`,
+              ids: {
+                runId: run.id,
+                agentId: run.agentId,
+                taskKey: run.taskKey ?? null,
+                issueKey: run.issueKey ?? null,
+              },
+            });
+          }
+        } catch {
+          // ignore
+        }
+      }
+
+      // 4. Test runs
+      if (deps.testService) {
+        try {
+          const runs = deps.testService.listRuns({ limit: 100 });
+          for (const run of runs) {
+            const ts = run.endedAt ?? run.startedAt;
+            if (!afterCutoff(ts)) continue;
+            const duration = run.durationMs != null ? ` (${Math.round(run.durationMs / 1000)}s)` : "";
+            events.push({
+              type: "test_run",
+              timestamp: ts,
+              summary: `${run.suiteName}: ${run.status}${duration}`,
+              ids: {
+                runId: run.id,
+                suiteId: run.suiteId,
+                laneId: run.laneId,
+              },
+            });
+          }
+        } catch {
+          // ignore
+        }
+      }
+
+      // 5. Mission state transitions
+      if (deps.missionService) {
+        try {
+          const missions = deps.missionService.list({ limit: 50 });
+          for (const mission of missions) {
+            const ts = mission.completedAt ?? mission.updatedAt;
+            if (!afterCutoff(ts)) continue;
+            events.push({
+              type: "mission_update",
+              timestamp: ts,
+              summary: `Mission "${mission.title}": ${mission.status}${mission.outcomeSummary ? ` — ${mission.outcomeSummary}` : ""}`,
+              ids: {
+                missionId: mission.id,
+                laneId: mission.laneId,
+              },
+            });
+          }
+        } catch {
+          // ignore
+        }
+      }
+
+      // 6. PR review activity (recent events from all tracked PRs)
+      if (deps.prService) {
+        try {
+          const prs = deps.prService.listAll();
+          // Fetch activity for the most recently updated PRs to avoid excessive API calls
+          const recentPrs = prs
+            .filter((pr) => afterCutoff(pr.updatedAt))
+            .slice(0, 5);
+          for (const pr of recentPrs) {
+            try {
+              const activity = await deps.prService.getActivity(pr.id);
+              for (const ev of activity) {
+                if (!afterCutoff(ev.timestamp)) continue;
+                events.push({
+                  type: `pr_${ev.type}`,
+                  timestamp: ev.timestamp,
+                  summary: `PR #${pr.githubPrNumber} "${pr.title}": ${ev.body ?? ev.type}${ev.author ? ` (${ev.author})` : ""}`,
+                  ids: {
+                    prId: pr.id,
+                    prNumber: String(pr.githubPrNumber),
+                    laneId: pr.laneId,
+                  },
+                });
+              }
+            } catch {
+              // individual PR activity fetch may fail
+            }
+          }
+        } catch {
+          // ignore
+        }
+      }
+
+      // 7. Chat session events
+      try {
+        const chats = await deps.listChats(undefined, { includeIdentity: false, includeAutomation: true });
+        for (const chat of chats) {
+          const ts = chat.endedAt ?? chat.lastActivityAt;
+          if (!afterCutoff(ts)) continue;
+          events.push({
+            type: "chat_session",
+            timestamp: ts,
+            summary: `Chat "${chat.title ?? chat.sessionId}": ${chat.status}${chat.summary ? ` — ${chat.summary}` : ""}`,
+            ids: {
+              sessionId: chat.sessionId,
+              laneId: chat.laneId,
+            },
+          });
+        }
+      } catch {
+        // ignore
+      }
+
+      // Sort descending by timestamp and apply limit
+      events.sort((a, b) => parseIsoToEpoch(b.timestamp) - parseIsoToEpoch(a.timestamp));
+      const sliced = events.slice(0, safeLimit);
+
+      return {
+        success: true,
+        count: sliced.length,
+        totalBeforeLimit: events.length,
+        since: since ?? new Date(sinceEpoch).toISOString(),
+        events: sliced,
+      };
+    },
+  });
+
+  // ---------------------------------------------------------------------------
+  // Project Health Dashboard
+  // ---------------------------------------------------------------------------
+
+  tools.getProjectHealthSummary = tool({
+    description:
+      "Aggregate project health into a single snapshot: mission counts by status, worker utilization, test pass rates, PR status distribution, active lanes, and weekly budget burn.",
+    inputSchema: z.object({
+      testRunLimit: z
+        .number()
+        .int()
+        .positive()
+        .max(200)
+        .optional()
+        .default(50),
+    }),
+    execute: async ({ testRunLimit }) => {
+      let missions: {
+        byStatus: Record<string, number>;
+        total: number;
+        activeCount: number;
+        openInterventions: number;
+        weekly: { missions: number; successRate: number; avgDurationMs: number; totalCostUsd: number } | null;
+      } | null = null;
+      if (deps.missionService) {
+        const all = deps.missionService.list({ includeArchived: false, limit: 500 });
+        const byStatus: Record<string, number> = {};
+        let openInterventions = 0;
+        for (const m of all) {
+          byStatus[m.status] = (byStatus[m.status] ?? 0) + 1;
+          openInterventions += m.openInterventions;
+        }
+        const activeCount = all.filter(
+          (m) => m.status === "queued" || m.status === "planning" || m.status === "in_progress" || m.status === "intervention_required",
+        ).length;
+        let weekly: { missions: number; successRate: number; avgDurationMs: number; totalCostUsd: number } | null = null;
+        try {
+          const dashboard = (deps.missionService as any).getDashboard?.();
+          if (dashboard?.weekly) weekly = dashboard.weekly;
+        } catch { /* non-fatal */ }
+        missions = { byStatus, total: all.length, activeCount, openInterventions, weekly };
+      }
+
+      let workers: {
+        total: number;
+        byStatus: Record<string, number>;
+        totalBudgetMonthlyCents: number;
+        totalSpentMonthlyCents: number;
+        budgetUtilizationPct: number;
+      } | null = null;
+      if (deps.workerAgentService) {
+        const agents = deps.workerAgentService.listAgents();
+        const byStatus: Record<string, number> = {};
+        let totalBudget = 0;
+        let totalSpent = 0;
+        for (const a of agents) {
+          byStatus[a.status] = (byStatus[a.status] ?? 0) + 1;
+          totalBudget += (a as any).budgetMonthlyCents ?? 0;
+          totalSpent += (a as any).spentMonthlyCents ?? 0;
+        }
+        workers = {
+          total: agents.length,
+          byStatus,
+          totalBudgetMonthlyCents: totalBudget,
+          totalSpentMonthlyCents: totalSpent,
+          budgetUtilizationPct: totalBudget > 0 ? Math.round((totalSpent / totalBudget) * 10000) / 100 : 0,
+        };
+      }
+
+      let tests: {
+        suiteCount: number;
+        recentRuns: number;
+        byStatus: Record<string, number>;
+        passRate: number;
+      } | null = null;
+      if (deps.testService) {
+        const suites = deps.testService.listSuites();
+        const runs = deps.testService.listRuns({ limit: testRunLimit });
+        const byStatus: Record<string, number> = {};
+        for (const r of runs) {
+          byStatus[r.status] = (byStatus[r.status] ?? 0) + 1;
+        }
+        const terminal = runs.filter((r) => r.status !== "running");
+        const passed = terminal.filter((r) => r.status === "passed").length;
+        tests = {
+          suiteCount: suites.length,
+          recentRuns: runs.length,
+          byStatus,
+          passRate: terminal.length > 0 ? Math.round((passed / terminal.length) * 10000) / 100 : 0,
+        };
+      }
+
+      let prs: {
+        total: number;
+        byState: Record<string, number>;
+        byChecksStatus: Record<string, number>;
+        byReviewStatus: Record<string, number>;
+      } | null = null;
+      if (deps.prService) {
+        const all = (deps.prService as any).listAll?.() ?? [];
+        const byState: Record<string, number> = {};
+        const byChecksStatus: Record<string, number> = {};
+        const byReviewStatus: Record<string, number> = {};
+        for (const pr of all) {
+          byState[pr.state] = (byState[pr.state] ?? 0) + 1;
+          if (pr.checksStatus) byChecksStatus[pr.checksStatus] = (byChecksStatus[pr.checksStatus] ?? 0) + 1;
+          if (pr.reviewStatus) byReviewStatus[pr.reviewStatus] = (byReviewStatus[pr.reviewStatus] ?? 0) + 1;
+        }
+        prs = { total: all.length, byState, byChecksStatus, byReviewStatus };
+      }
+
+      const allLanes = await deps.laneService.list({ includeArchived: false });
+      const activeLanes = allLanes.filter((l) => l.laneType !== "primary");
+      const lanes = {
+        total: allLanes.length,
+        active: activeLanes.length,
+        withMission: activeLanes.filter((l) => (l as any).missionId).length,
+      };
+
+      return {
+        success: true,
+        generatedAt: nowIso(),
+        missions,
+        workers,
+        tests,
+        prs,
+        lanes,
+      };
+    },
+  });
+
+  // ---------------------------------------------------------------------------
+  // Computer Use Artifact Oversight
+  // ---------------------------------------------------------------------------
+
+  tools.listComputerUseArtifacts = tool({
+    description:
+      "List computer-use artifacts (screenshots, videos, browser traces, console logs) across the project.",
+    inputSchema: z.object({
+      kind: z
+        .enum(["screenshot", "video_recording", "browser_trace", "browser_verification", "console_logs"])
+        .optional(),
+      ownerKind: z
+        .enum(["lane", "mission", "orchestrator_run", "orchestrator_step", "orchestrator_attempt", "chat_session", "automation_run", "github_pr", "linear_issue"])
+        .optional(),
+      ownerId: z.string().optional(),
+      limit: z.number().int().min(1).max(200).optional().default(50),
+    }),
+    execute: async ({ kind, ownerKind, ownerId, limit }) => {
+      if (!deps.computerUseArtifactBrokerService) {
+        return { success: false, error: "Computer-use artifact broker is not available." };
+      }
+      try {
+        const artifacts = deps.computerUseArtifactBrokerService.listArtifacts({
+          kind: kind ?? null,
+          ownerKind: ownerKind ?? undefined,
+          ownerId: ownerId ?? undefined,
+          limit,
+        });
+        return {
+          success: true,
+          count: artifacts.length,
+          artifacts: artifacts.map((a: any) => ({
+            id: a.id,
+            kind: a.kind,
+            title: a.title,
+            description: a.description,
+            uri: a.uri,
+            reviewState: a.reviewState,
+            workflowState: a.workflowState,
+            reviewNote: a.reviewNote,
+            createdAt: a.createdAt,
+            owners: (a.links ?? []).map((l: any) => ({ kind: l.ownerKind, id: l.ownerId, relation: l.relation })),
+          })),
+        };
+      } catch (error) {
+        return { success: false, error: getErrorMessage(error) };
+      }
+    },
+  });
+
+  tools.getArtifactPreview = tool({
+    description: "Get full details for a specific computer-use artifact by ID.",
+    inputSchema: z.object({
+      artifactId: z.string().min(1),
+    }),
+    execute: async ({ artifactId }) => {
+      if (!deps.computerUseArtifactBrokerService) {
+        return { success: false, error: "Computer-use artifact broker is not available." };
+      }
+      try {
+        const results = deps.computerUseArtifactBrokerService.listArtifacts({ artifactId });
+        if (results.length === 0) return { success: false, error: `Artifact not found: ${artifactId}` };
+        const a = results[0] as any;
+        return {
+          success: true,
+          artifact: {
+            id: a.id, kind: a.kind, title: a.title, description: a.description,
+            uri: a.uri, mimeType: a.mimeType, reviewState: a.reviewState,
+            workflowState: a.workflowState, reviewNote: a.reviewNote,
+            metadata: a.metadata, createdAt: a.createdAt,
+            links: (a.links ?? []).map((l: any) => ({
+              ownerKind: l.ownerKind, ownerId: l.ownerId, relation: l.relation,
+            })),
+          },
+        };
+      } catch (error) {
+        return { success: false, error: getErrorMessage(error) };
+      }
+    },
+  });
+
+  tools.reviewArtifact = tool({
+    description: "Mark a computer-use artifact as approved, rejected, or needing more evidence.",
+    inputSchema: z.object({
+      artifactId: z.string().min(1),
+      reviewState: z.enum(["pending", "accepted", "needs_more", "dismissed"]),
+      workflowState: z.enum(["evidence_only", "promoted", "published", "dismissed"]).optional(),
+      reviewNote: z.string().max(2000).optional(),
+    }),
+    execute: async ({ artifactId, reviewState, workflowState, reviewNote }) => {
+      if (!deps.computerUseArtifactBrokerService) {
+        return { success: false, error: "Computer-use artifact broker is not available." };
+      }
+      try {
+        const updated = deps.computerUseArtifactBrokerService.updateArtifactReview({
+          artifactId,
+          reviewState,
+          workflowState: workflowState ?? null,
+          reviewNote: reviewNote ?? null,
+        });
+        return {
+          success: true,
+          artifact: { id: updated.id, kind: updated.kind, reviewState: updated.reviewState, workflowState: updated.workflowState, reviewNote: updated.reviewNote },
+        };
+      } catch (error) {
+        return { success: false, error: getErrorMessage(error) };
+      }
+    },
+  });
+
+  // ---------------------------------------------------------------------------
+  // Budget / Cost Visibility
+  // ---------------------------------------------------------------------------
+
+  tools.getProjectBudgetStatus = tool({
+    description: "Get project-wide budget status: total spend, budget remaining, per-worker summaries, and optional per-mission deep dive.",
+    inputSchema: z.object({
+      monthKey: z.string().optional().describe("YYYY-MM format. Defaults to current month."),
+      missionId: z.string().optional().describe("Include detailed budget for this mission."),
+    }),
+    execute: async ({ monthKey, missionId }) => {
+      if (!deps.workerBudgetService) return { success: false, error: "Worker budget service is not available." };
+      try {
+        const snapshot = deps.workerBudgetService.getBudgetSnapshot({ monthKey: monthKey?.trim() || undefined });
+        let missionBudget: any = null;
+        if (missionId?.trim() && deps.missionBudgetService) {
+          try {
+            missionBudget = await deps.missionBudgetService.getMissionBudgetStatus({ missionId: missionId.trim() });
+          } catch { /* non-fatal */ }
+        }
+        return {
+          success: true,
+          monthKey: snapshot.monthKey,
+          computedAt: snapshot.computedAt,
+          company: {
+            budgetMonthlyCents: snapshot.companyBudgetMonthlyCents,
+            spentMonthlyCents: snapshot.companySpentMonthlyCents,
+            remainingCents: snapshot.companyRemainingCents,
+          },
+          workerCount: snapshot.workers.length,
+          workerSummaries: snapshot.workers.map((w: any) => ({
+            agentId: w.agentId, name: w.name, budgetMonthlyCents: w.budgetMonthlyCents,
+            spentMonthlyCents: w.spentMonthlyCents, remainingCents: w.remainingCents, status: w.status,
+          })),
+          ...(missionBudget ? { missionBudget } : {}),
+        };
+      } catch (error) {
+        return { success: false, error: getErrorMessage(error) };
+      }
+    },
+  });
+
+  tools.getWorkerCostBreakdown = tool({
+    description: "Get per-worker monthly spend breakdown with token usage and model detail.",
+    inputSchema: z.object({
+      agentId: z.string().optional(),
+      monthKey: z.string().optional(),
+      limit: z.number().int().positive().optional().default(100),
+    }),
+    execute: async ({ agentId, monthKey, limit }) => {
+      if (!deps.workerBudgetService) return { success: false, error: "Worker budget service is not available." };
+      try {
+        const snapshot = deps.workerBudgetService.getBudgetSnapshot({ monthKey: monthKey?.trim() || undefined });
+        const targetWorkers = agentId?.trim()
+          ? snapshot.workers.filter((w: any) => w.agentId === agentId.trim())
+          : snapshot.workers;
+        if (agentId?.trim() && targetWorkers.length === 0) {
+          return { success: false, error: `Worker not found: ${agentId}` };
+        }
+        const breakdowns = targetWorkers.map((worker: any) => {
+          const events = deps.workerBudgetService!.listCostEvents({
+            agentId: worker.agentId,
+            monthKey: monthKey?.trim() || undefined,
+            limit,
+          });
+          const modelMap = new Map<string, { provider: string; modelId: string; totalCostCents: number; totalInputTokens: number; totalOutputTokens: number; eventCount: number }>();
+          for (const event of events) {
+            const key = `${event.provider}::${event.modelId ?? "unknown"}`;
+            const existing = modelMap.get(key);
+            if (existing) {
+              existing.totalCostCents += event.costCents;
+              existing.totalInputTokens += event.inputTokens ?? 0;
+              existing.totalOutputTokens += event.outputTokens ?? 0;
+              existing.eventCount += 1;
+            } else {
+              modelMap.set(key, {
+                provider: event.provider, modelId: event.modelId ?? "unknown",
+                totalCostCents: event.costCents, totalInputTokens: event.inputTokens ?? 0,
+                totalOutputTokens: event.outputTokens ?? 0, eventCount: 1,
+              });
+            }
+          }
+          return {
+            agentId: worker.agentId, name: worker.name, status: worker.status,
+            budgetMonthlyCents: worker.budgetMonthlyCents, spentMonthlyCents: worker.spentMonthlyCents,
+            remainingCents: worker.remainingCents,
+            modelBreakdown: Array.from(modelMap.values()),
+          };
+        });
+        return { success: true, monthKey: snapshot.monthKey, workerCount: breakdowns.length, breakdowns };
+      } catch (error) {
+        return { success: false, error: getErrorMessage(error) };
+      }
+    },
+  });
+
   return tools;
 }
diff --git a/apps/desktop/src/main/services/chat/agentChatService.test.ts b/apps/desktop/src/main/services/chat/agentChatService.test.ts
index 905f67047..7f038978f 100644
--- a/apps/desktop/src/main/services/chat/agentChatService.test.ts
+++ b/apps/desktop/src/main/services/chat/agentChatService.test.ts
@@ -15,6 +15,7 @@ const mockState = vi.hoisted(() => ({
   codexTurnCounter: 0,
   cursorSessionCounter: 0,
   codexRequestPayloads: [] as Array<Record<string, unknown>>,
+  codexCollaborationModes: [{ mode: "default" }, { mode: "plan" }] as Array<Record<string, unknown> | string>,
   codexLineHandler: null as ((line: string) => void) | null,
   cursorAcquireCalls: [] as Array<Record<string, unknown>>,
   cursorNewSessionCalls: [] as Array<Record<string, unknown>>,
@@ -57,6 +58,10 @@ vi.mock("node:child_process", () => ({
           } else if (payload.method === "turn/start" || payload.method === "review/start") {
             mockState.codexTurnCounter += 1;
             result = { turn: { id: `turn-${mockState.codexTurnCounter}` } };
+          } else if (payload.method === "collaborationMode/list") {
+            result = {
+              collaborationModes: mockState.codexCollaborationModes,
+            };
           } else if (payload.method === "skills/list") {
             result = { skills: [] };
           } else if (payload.method === "account/rateLimits/read") {
@@ -584,6 +589,18 @@ async function waitForEvent<T extends AgentChatEventEnvelope>(
   throw new Error("Timed out waiting for agent chat event.");
 }
 
+function expectResolvedMcpLaunchesToUseStandardProxyFlow(): void {
+  const calls = vi.mocked(resolveAdeMcpServerLaunch).mock.calls;
+  expect(calls.length).toBeGreaterThan(0);
+  for (const [args] of calls) {
+    // Regression guard: packaged chat surfaces must not force the direct
+    // headless MCP path. A previous refactor set preferBundledProxy=false,
+    // which bypassed the working ADE proxy path and broke Claude/Codex chat
+    // MCP initialization before the first turn could start.
+    expect((args as { preferBundledProxy?: boolean }).preferBundledProxy).toBeUndefined();
+  }
+}
+
 // ---------------------------------------------------------------------------
 // Tests
 // ---------------------------------------------------------------------------
@@ -599,6 +616,7 @@ beforeEach(() => {
   mockState.codexTurnCounter = 0;
   mockState.cursorSessionCounter = 0;
   mockState.codexRequestPayloads = [];
+  mockState.codexCollaborationModes = [{ mode: "default" }, { mode: "plan" }];
   mockState.codexLineHandler = null;
   mockState.cursorAcquireCalls = [];
   mockState.cursorNewSessionCalls = [];
@@ -806,6 +824,7 @@ describe("createAgentChatService", () => {
 
     it("pre-approves ADE MCP tools for Claude SDK sessions", async () => {
       vi.mocked(providerResolver.normalizeCliMcpServers).mockImplementation((_provider, servers) => servers ?? {});
+      vi.mocked(resolveAdeMcpServerLaunch).mockClear();
       vi.mocked(unstable_v2_createSession).mockReturnValue({
         send: vi.fn(),
         stream: vi.fn(async function* () {
@@ -832,6 +851,36 @@ describe("createAgentChatService", () => {
       } | undefined;
       expect(opts?.mcpServers).toHaveProperty("ade");
       expect(opts?.allowedTools).toContain("mcp__ade__*");
+      // This explicitly protects the Claude chat surface, which shares the
+      // same MCP launch helper as the other chat providers.
+      expectResolvedMcpLaunchesToUseStandardProxyFlow();
+    });
+
+    it("requests markdown previews for Claude AskUserQuestion by default", async () => {
+      vi.mocked(unstable_v2_createSession).mockReturnValue({
+        send: vi.fn(),
+        stream: vi.fn(async function* () {
+          return;
+        }),
+        close: vi.fn(),
+        sessionId: "sdk-session-ask-user-preview",
+      } as any);
+
+      const { service } = createService();
+      await service.createSession({
+        laneId: "lane-1",
+        provider: "claude",
+        model: "sonnet",
+      });
+
+      await vi.waitFor(() => {
+        expect(unstable_v2_createSession).toHaveBeenCalled();
+      });
+
+      const opts = vi.mocked(unstable_v2_createSession).mock.calls[0]?.[0] as {
+        toolConfig?: { askUserQuestion?: { previewFormat?: string } };
+      } | undefined;
+      expect(opts?.toolConfig?.askUserQuestion?.previewFormat).toBe("markdown");
     });
 
     it("attaches ADE MCP servers through the Claude V2 query controls", async () => {
@@ -1391,6 +1440,10 @@ describe("createAgentChatService", () => {
         expect(vi.mocked(resolveAdeMcpServerLaunch)).toHaveBeenCalled();
       });
 
+      // Codex app-server was the first place this surfaced in production, so
+      // keep a dedicated assertion on the actual Codex chat path too.
+      expectResolvedMcpLaunchesToUseStandardProxyFlow();
+
       const workspaceRoots = vi.mocked(resolveAdeMcpServerLaunch).mock.calls
         .map(([args]) => (args as { workspaceRoot?: string }).workspaceRoot)
         .filter((value): value is string => typeof value === "string");
@@ -1422,6 +1475,7 @@ describe("createAgentChatService", () => {
       vi.mocked(createUniversalToolSet).mockClear();
       vi.mocked(createWorkflowTools).mockClear();
       vi.mocked(buildCodingAgentSystemPrompt).mockClear();
+      vi.mocked(resolveAdeMcpServerLaunch).mockClear();
 
       const selectedLaneRootPath = path.join(tmpRoot, "lane-2");
       fs.mkdirSync(selectedLaneRootPath, { recursive: true });
@@ -1447,6 +1501,12 @@ describe("createAgentChatService", () => {
       expect(vi.mocked(buildCodingAgentSystemPrompt)).toHaveBeenCalledWith(
         expect.objectContaining({ cwd: selectedLaneRoot }),
       );
+      await vi.waitFor(() => {
+        expect(vi.mocked(resolveAdeMcpServerLaunch)).toHaveBeenCalled();
+      });
+      // Unified/API-backed chats also inject ADE MCP through the same launch
+      // resolver, so guard them here as well.
+      expectResolvedMcpLaunchesToUseStandardProxyFlow();
 
       const firstMessages = Array.isArray(streamCalls[0]?.messages)
         ? (streamCalls[0]!.messages as Array<{ role: string; content: unknown }>)
@@ -1663,7 +1723,7 @@ describe("createAgentChatService", () => {
       expect(session.permissionMode).toBe("plan");
     });
 
-    it("does not reuse a foreign-lane identity session and retires it during migration", async () => {
+    it("does not reuse a foreign-lane identity session or auto-close it during migration", async () => {
       const { service, sessionService } = createService();
 
       const legacy = await service.createSession({
@@ -1681,7 +1741,7 @@ describe("createAgentChatService", () => {
 
       expect(canonical.id).not.toBe(legacy.id);
       expect(canonical.laneId).toBe("lane-1");
-      expect(sessionService.get(legacy.id)?.status).toBe("ended");
+      expect(sessionService.get(legacy.id)?.status).not.toBe("ended");
 
       const reused = await service.ensureIdentitySession({
         identityKey: "cto",
@@ -3345,6 +3405,114 @@ describe("createAgentChatService", () => {
       expect(session.interactionMode).toBe("plan");
       expect(session.claudePermissionMode).toBe("default");
     });
+
+    it("sends Codex plan collaboration mode on turn start for plan sessions", async () => {
+      const { service } = createService();
+      const session = await service.createSession({
+        laneId: "lane-1",
+        provider: "codex",
+        model: "gpt-5.4",
+        codexApprovalPolicy: "untrusted",
+        codexSandbox: "read-only",
+        codexConfigSource: "flags",
+      });
+      expect(session.permissionMode).toBe("plan");
+
+      await service.sendMessage({
+        sessionId: session.id,
+        text: "Ask one planning question before coding.",
+      });
+
+      await vi.waitFor(() => {
+        expect(mockState.codexRequestPayloads.some((payload) => payload.method === "collaborationMode/list")).toBe(true);
+        expect(mockState.codexRequestPayloads.some((payload) => payload.method === "turn/start")).toBe(true);
+      });
+      const turnStartRequest = mockState.codexRequestPayloads.find((payload) => payload.method === "turn/start");
+      const params = turnStartRequest?.params as { collaborationMode?: Record<string, unknown> } | undefined;
+      const collaborationMode = params?.collaborationMode as
+        | { mode?: unknown; settings?: { model?: unknown; reasoning_effort?: unknown; developer_instructions?: unknown } }
+        | undefined;
+
+      expect(collaborationMode?.mode).toBe("plan");
+      expect(collaborationMode?.settings?.model).toBe("gpt-5.4");
+      expect(collaborationMode?.settings?.reasoning_effort).toBe("medium");
+      expect(collaborationMode?.settings?.developer_instructions).toBeNull();
+    });
+
+    it("sends Codex default collaboration mode on turn start outside plan mode", async () => {
+      const { service } = createService();
+      const session = await service.createSession({
+        laneId: "lane-1",
+        provider: "codex",
+        model: "gpt-5.4",
+      });
+
+      await service.sendMessage({
+        sessionId: session.id,
+        text: "Inspect the repo.",
+      });
+
+      await vi.waitFor(() => {
+        expect(mockState.codexRequestPayloads.some((payload) => payload.method === "turn/start")).toBe(true);
+      });
+      const turnStartRequest = mockState.codexRequestPayloads.find((payload) => payload.method === "turn/start");
+      const params = turnStartRequest?.params as { collaborationMode?: Record<string, unknown> } | undefined;
+      const collaborationMode = params?.collaborationMode as { mode?: unknown } | undefined;
+
+      expect(collaborationMode?.mode).toBe("default");
+    });
+
+    it("does not auto-upgrade default Codex chats into plan mode", async () => {
+      mockState.codexCollaborationModes = [{ mode: "plan" }];
+      const { service } = createService();
+      const session = await service.createSession({
+        laneId: "lane-1",
+        provider: "codex",
+        model: "gpt-5.4",
+      });
+
+      await service.sendMessage({
+        sessionId: session.id,
+        text: "Inspect the repo.",
+      });
+
+      await vi.waitFor(() => {
+        expect(mockState.codexRequestPayloads.some((payload) => payload.method === "turn/start")).toBe(true);
+      });
+
+      const turnStartRequest = mockState.codexRequestPayloads.find((payload) => payload.method === "turn/start");
+      const params = turnStartRequest?.params as { collaborationMode?: Record<string, unknown> } | undefined;
+      expect(params?.collaborationMode).toBeUndefined();
+    });
+
+    it("falls back to default collaboration mode when plan is not advertised", async () => {
+      mockState.codexCollaborationModes = [{ mode: "default" }];
+      const { service } = createService();
+      const session = await service.createSession({
+        laneId: "lane-1",
+        provider: "codex",
+        model: "gpt-5.4",
+        codexApprovalPolicy: "untrusted",
+        codexSandbox: "read-only",
+        codexConfigSource: "flags",
+      });
+
+      await service.sendMessage({
+        sessionId: session.id,
+        text: "Ask one planning question before coding.",
+      });
+
+      await vi.waitFor(() => {
+        expect(mockState.codexRequestPayloads.some((payload) => payload.method === "collaborationMode/list")).toBe(true);
+        expect(mockState.codexRequestPayloads.some((payload) => payload.method === "turn/start")).toBe(true);
+      });
+
+      const turnStartRequest = mockState.codexRequestPayloads.find((payload) => payload.method === "turn/start");
+      const params = turnStartRequest?.params as { collaborationMode?: Record<string, unknown> } | undefined;
+      const collaborationMode = params?.collaborationMode as { mode?: unknown } | undefined;
+
+      expect(collaborationMode?.mode).toBe("default");
+    });
   });
 
   // --------------------------------------------------------------------------
@@ -3374,6 +3542,227 @@ describe("createAgentChatService", () => {
         service.resumeSession({ sessionId: "unknown-session-id" }),
       ).rejects.toThrow(/not found/i);
     });
+
+    it("preserves Claude V2 session continuity after an idle timeout", async () => {
+      vi.useFakeTimers();
+      try {
+        const events: AgentChatEventEnvelope[] = [];
+        let primaryStreamCall = 0;
+        let primaryClosed = false;
+        const primarySend = vi.fn().mockResolvedValue(undefined);
+        const resumedSend = vi.fn().mockResolvedValue(undefined);
+        const setPermissionMode = vi.fn().mockResolvedValue(undefined);
+
+        const primarySession = {
+          send: primarySend,
+          stream: vi.fn(() => (async function* () {
+            primaryStreamCall += 1;
+            if (primaryStreamCall === 1) {
+              yield {
+                type: "system",
+                subtype: "init",
+                session_id: "sdk-session-1",
+                slash_commands: [],
+              };
+              yield {
+                type: "result",
+                usage: { input_tokens: 1, output_tokens: 1 },
+              };
+              return;
+            }
+
+            yield {
+              type: "assistant",
+              session_id: "sdk-session-1",
+              message: {
+                content: [{ type: "text", text: "Partial answer" }],
+                usage: { input_tokens: 1, output_tokens: 1 },
+              },
+            };
+
+            while (!primaryClosed) {
+              await new Promise((resolve) => setTimeout(resolve, 1_000));
+            }
+
+            throw new Error("aborted by user");
+          })()),
+          close: vi.fn(() => {
+            primaryClosed = true;
+          }),
+          sessionId: "sdk-session-1",
+          setPermissionMode,
+        };
+
+        const resumedSession = {
+          send: resumedSend,
+          stream: vi.fn(() => (async function* () {
+            yield {
+              type: "system",
+              subtype: "init",
+              session_id: "sdk-session-1",
+              slash_commands: [],
+            };
+            yield {
+              type: "assistant",
+              session_id: "sdk-session-1",
+              message: {
+                content: [{ type: "text", text: "You were asking about the new chat buttons." }],
+                usage: { input_tokens: 1, output_tokens: 1 },
+              },
+            };
+            yield {
+              type: "result",
+              usage: { input_tokens: 1, output_tokens: 1 },
+            };
+          })()),
+          close: vi.fn(),
+          sessionId: "sdk-session-1",
+          setPermissionMode,
+        };
+
+        vi.mocked(unstable_v2_createSession).mockReturnValue(primarySession as any);
+        vi.mocked(unstable_v2_resumeSession).mockReturnValue(resumedSession as any);
+
+        const { service } = createService({
+          onEvent: (event: AgentChatEventEnvelope) => events.push(event),
+        });
+
+        const session = await service.createSession({
+          laneId: "lane-1",
+          provider: "claude",
+          model: "sonnet",
+        });
+
+        const firstTurn = service.runSessionTurn({
+          sessionId: session.id,
+          text: "Add the new chat button",
+          timeoutMs: 120_000,
+        });
+        await vi.advanceTimersByTimeAsync(76_000);
+        await firstTurn;
+
+        const persistedAfterTimeout = readPersistedChatState(session.id);
+        expect(persistedAfterTimeout.sdkSessionId).toBe("sdk-session-1");
+        expect(events).toEqual(
+          expect.arrayContaining([
+            expect.objectContaining({
+              event: expect.objectContaining({
+                type: "error",
+                message: expect.stringContaining("chat stayed open so you can retry"),
+              }),
+            }),
+            expect.objectContaining({
+              event: expect.objectContaining({
+                type: "status",
+                turnStatus: "failed",
+              }),
+            }),
+          ]),
+        );
+
+        events.length = 0;
+        const followUp = await service.runSessionTurn({
+          sessionId: session.id,
+          text: "what happened?",
+          timeoutMs: 15_000,
+        });
+
+        expect(unstable_v2_resumeSession).toHaveBeenCalledWith(
+          "sdk-session-1",
+          expect.objectContaining({ model: "sonnet" }),
+        );
+        expect(resumedSend).toHaveBeenCalledTimes(1);
+        expect(followUp.outputText).toContain("new chat buttons");
+      } finally {
+        vi.useRealTimers();
+      }
+    });
+
+    it("does not abort Claude turns solely because they run longer than five minutes", async () => {
+      vi.useFakeTimers();
+      try {
+        const events: AgentChatEventEnvelope[] = [];
+        const send = vi.fn().mockResolvedValue(undefined);
+        const setPermissionMode = vi.fn().mockResolvedValue(undefined);
+        let streamCall = 0;
+
+        const sessionHandle = {
+          send,
+          stream: vi.fn(() => (async function* () {
+            streamCall += 1;
+            if (streamCall === 1) {
+              yield {
+                type: "system",
+                subtype: "init",
+                session_id: "sdk-session-long-running",
+                slash_commands: [],
+              };
+              yield {
+                type: "result",
+                usage: { input_tokens: 1, output_tokens: 1 },
+              };
+              return;
+            }
+
+            for (let index = 0; index < 6; index += 1) {
+              yield {
+                type: "assistant",
+                session_id: "sdk-session-long-running",
+                message: {
+                  content: [{ type: "text", text: `Chunk ${index + 1}. ` }],
+                  usage: { input_tokens: 1, output_tokens: 1 },
+                },
+              };
+              await new Promise((resolve) => setTimeout(resolve, 60_000));
+            }
+
+            yield {
+              type: "assistant",
+              session_id: "sdk-session-long-running",
+              message: {
+                content: [{ type: "text", text: "Finished after a long run." }],
+                usage: { input_tokens: 1, output_tokens: 1 },
+              },
+            };
+            yield {
+              type: "result",
+              usage: { input_tokens: 1, output_tokens: 1 },
+            };
+          })()),
+          close: vi.fn(),
+          sessionId: "sdk-session-long-running",
+          setPermissionMode,
+        };
+
+        vi.mocked(unstable_v2_createSession).mockReturnValue(sessionHandle as any);
+        vi.mocked(unstable_v2_resumeSession).mockReturnValue(sessionHandle as any);
+
+        const { service } = createService({
+          onEvent: (event: AgentChatEventEnvelope) => events.push(event),
+        });
+
+        const session = await service.createSession({
+          laneId: "lane-1",
+          provider: "claude",
+          model: "sonnet",
+        });
+
+        const turn = service.runSessionTurn({
+          sessionId: session.id,
+          text: "Keep working until the implementation is done.",
+          timeoutMs: 500_000,
+        });
+
+        await vi.advanceTimersByTimeAsync(361_000);
+        const result = await turn;
+
+        expect(result.outputText).toContain("Finished after a long run.");
+        expect(events.find((event) => event.event.type === "status" && event.event.turnStatus === "failed")).toBeUndefined();
+        expect(events.find((event) => event.event.type === "status" && event.event.turnStatus === "interrupted")).toBeUndefined();
+      } finally {
+        vi.useRealTimers();
+      }
+    });
   });
 
   // --------------------------------------------------------------------------
@@ -4246,8 +4635,616 @@ describe("createAgentChatService", () => {
     await sendPromise;
   });
 
+  it("emits completed Claude tool_result rows when tool_use_summary arrives", async () => {
+    const events: AgentChatEventEnvelope[] = [];
+    const setPermissionMode = vi.fn().mockResolvedValue(undefined);
+    const send = vi.fn().mockResolvedValue(undefined);
+    let streamCall = 0;
+
+    const stream = vi.fn(() => (async function* () {
+      streamCall += 1;
+      if (streamCall === 1) {
+        yield {
+          type: "system",
+          subtype: "init",
+          session_id: "sdk-session-tool-summary",
+          slash_commands: [],
+        };
+        return;
+      }
+
+      yield {
+        type: "stream_event",
+        event: {
+          type: "content_block_start",
+          index: 0,
+          content_block: {
+            type: "tool_use",
+            id: "tool-use-1",
+            name: "Read",
+            input: { file_path: "apps/desktop/src/renderer/components/chat/AgentChatMessageList.tsx" },
+          },
+        },
+      };
+      yield {
+        type: "tool_use_summary",
+        summary: "Checked the shared chat renderer",
+        preceding_tool_use_ids: ["tool-use-1"],
+      };
+      yield {
+        type: "result",
+        usage: { input_tokens: 1, output_tokens: 1 },
+      };
+    })());
+
+    vi.mocked(unstable_v2_createSession).mockReturnValue({
+      send,
+      stream,
+      close: vi.fn(),
+      sessionId: "sdk-session-tool-summary",
+      setPermissionMode,
+    } as any);
+
+    const { service } = createService({
+      onEvent: (event: AgentChatEventEnvelope) => events.push(event),
+    });
+
+    const session = await service.createSession({
+      laneId: "lane-1",
+      provider: "claude",
+      model: "claude-sonnet-4-6",
+      modelId: "anthropic/claude-sonnet-4-6",
+    });
+
+    await service.runSessionTurn({
+      sessionId: session.id,
+      text: "Inspect the shared chat renderer.",
+    });
+
+    const completedToolResults = events.filter((event) =>
+      event.event.type === "tool_result"
+      && event.event.itemId === "tool-use-1"
+      && event.event.status === "completed"
+    );
+
+    expect(completedToolResults).toHaveLength(1);
+    expect(completedToolResults[0]!.event.type).toBe("tool_result");
+    if (completedToolResults[0]!.event.type !== "tool_result") {
+      throw new Error("Expected tool_result");
+    }
+    expect(completedToolResults[0]!.event.result).toMatchObject({
+      synthetic: true,
+      source: "claude_tool_use_summary",
+      summary: "Checked the shared chat renderer",
+    });
+  });
+
+  it("emits completed Claude tool_result rows for open tools when the turn ends without a tool summary", async () => {
+    const events: AgentChatEventEnvelope[] = [];
+    const setPermissionMode = vi.fn().mockResolvedValue(undefined);
+    const send = vi.fn().mockResolvedValue(undefined);
+    let streamCall = 0;
+
+    const stream = vi.fn(() => (async function* () {
+      streamCall += 1;
+      if (streamCall === 1) {
+        yield {
+          type: "system",
+          subtype: "init",
+          session_id: "sdk-session-tool-fallback",
+          slash_commands: [],
+        };
+        return;
+      }
+
+      yield {
+        type: "stream_event",
+        event: {
+          type: "content_block_start",
+          index: 0,
+          content_block: {
+            type: "tool_use",
+            id: "tool-use-2",
+            name: "Read",
+            input: { file_path: "apps/desktop/src/renderer/components/chat/ChatWorkLogBlock.tsx" },
+          },
+        },
+      };
+      yield {
+        type: "result",
+        usage: { input_tokens: 1, output_tokens: 1 },
+      };
+    })());
+
+    vi.mocked(unstable_v2_createSession).mockReturnValue({
+      send,
+      stream,
+      close: vi.fn(),
+      sessionId: "sdk-session-tool-fallback",
+      setPermissionMode,
+    } as any);
+
+    const { service } = createService({
+      onEvent: (event: AgentChatEventEnvelope) => events.push(event),
+    });
+
+    const session = await service.createSession({
+      laneId: "lane-1",
+      provider: "claude",
+      model: "claude-sonnet-4-6",
+      modelId: "anthropic/claude-sonnet-4-6",
+    });
+
+    await service.runSessionTurn({
+      sessionId: session.id,
+      text: "Inspect the grouped work log renderer.",
+    });
+
+    const completedToolResults = events.filter((event) =>
+      event.event.type === "tool_result"
+      && event.event.itemId === "tool-use-2"
+      && event.event.status === "completed"
+    );
+
+    expect(completedToolResults).toHaveLength(1);
+    expect(completedToolResults[0]!.event.type).toBe("tool_result");
+    if (completedToolResults[0]!.event.type !== "tool_result") {
+      throw new Error("Expected tool_result");
+    }
+    expect(completedToolResults[0]!.event.result).toMatchObject({
+      synthetic: true,
+      source: "claude_turn_finalization",
+      finalTurnStatus: "completed",
+    });
+  });
+
+  it("bridges Claude AskUserQuestion through ADE's question UI", async () => {
+    const events: AgentChatEventEnvelope[] = [];
+    const setPermissionMode = vi.fn().mockResolvedValue(undefined);
+    const send = vi.fn().mockResolvedValue(undefined);
+    let streamCall = 0;
+    let permissionResult: Record<string, unknown> | null = null;
+
+    const askInput = {
+      questions: [
+        {
+          question: "What should we do about the two task list views?",
+          header: "Task views",
+          options: [
+            {
+              label: "Remove the TurnSummaryCard tasks",
+              description: "Keep only the inline task list.",
+              preview: "<div><strong>Inline only</strong><p>Compact stream, no bottom summary card.</p></div>",
+            },
+            {
+              label: "Keep both, improve summary",
+              description: "Keep both task views, but make the summary less intrusive.",
+              preview: "<div><strong>Hybrid</strong><p>Inline progress plus a compact summary card.</p></div>",
+            },
+          ],
+          multiSelect: false,
+        },
+        {
+          question: "Should the inline task list pin while tasks are active?",
+          header: "Inline pinning",
+          options: [
+            { label: "Yes, pin while active" },
+            { label: "No, let it scroll" },
+          ],
+          multiSelect: false,
+        },
+      ],
+    };
+
+    const stream = vi.fn(() => (async function* () {
+      streamCall += 1;
+      if (streamCall === 1) {
+        yield {
+          type: "system",
+          subtype: "init",
+          session_id: "sdk-session-ask-user",
+          slash_commands: [],
+        };
+        return;
+      }
+
+      const sessionOpts = vi.mocked(unstable_v2_createSession).mock.calls.at(-1)?.[0] as any;
+      permissionResult = await sessionOpts.canUseTool("AskUserQuestion", askInput, {
+        signal: new AbortController().signal,
+        toolUseID: "tool-ask-user-1",
+      });
+
+      yield {
+        type: "assistant",
+        message: {
+          content: [{ type: "text", text: "Thanks, I can continue now." }],
+          usage: { input_tokens: 1, output_tokens: 1 },
+        },
+      };
+      yield {
+        type: "result",
+        usage: { input_tokens: 1, output_tokens: 1 },
+      };
+    })());
+
+    vi.mocked(unstable_v2_createSession).mockReturnValue({
+      send,
+      stream,
+      close: vi.fn(),
+      sessionId: "sdk-session-ask-user",
+      setPermissionMode,
+    } as any);
+
+    const { service } = createService({
+      onEvent: (event: AgentChatEventEnvelope) => events.push(event),
+    });
+
+    const session = await service.createSession({
+      laneId: "lane-1",
+      provider: "claude",
+      model: "claude-sonnet-4-6",
+      modelId: "anthropic/claude-sonnet-4-6",
+      permissionMode: "plan",
+    });
+
+    const sendPromise = service.sendMessage({
+      sessionId: session.id,
+      text: "Figure out the task list UX and ask any clarifying questions you need.",
+    });
+
+    const approvalEvent = await waitForEvent(
+      events,
+      (event): event is AgentChatEventEnvelope & {
+        event: Extract<AgentChatEventEnvelope["event"], { type: "approval_request" }>;
+      } =>
+        event.event.type === "approval_request"
+        && typeof (event.event.detail as { request?: { providerMetadata?: { tool?: string } } } | undefined)?.request?.providerMetadata?.tool === "string"
+        && ((event.event.detail as { request?: { providerMetadata?: { tool?: string } } }).request?.providerMetadata?.tool === "AskUserQuestion"),
+    );
+
+    const request = (approvalEvent.event.detail as {
+      request: {
+        kind: string;
+        questions: Array<{
+          id: string;
+          question: string;
+          options?: Array<{ preview?: string; previewFormat?: string }>;
+        }>;
+      };
+    }).request;
+    expect(request.kind).toBe("structured_question");
+    expect(request.questions.map((question) => question.question)).toEqual([
+      "What should we do about the two task list views?",
+      "Should the inline task list pin while tasks are active?",
+    ]);
+    expect(request.questions[0]?.options?.[0]).toMatchObject({
+      preview: "<div><strong>Inline only</strong><p>Compact stream, no bottom summary card.</p></div>",
+      previewFormat: "markdown",
+    });
+
+    await service.respondToInput({
+      sessionId: session.id,
+      itemId: approvalEvent.event.itemId,
+      decision: "accept",
+      answers: {
+        question_1: "Keep both, improve summary",
+        question_2: "Yes, pin while active",
+      },
+    });
+
+    await sendPromise;
+
+    expect(permissionResult).toMatchObject({
+      behavior: "allow",
+      updatedInput: {
+        answers: {
+          "What should we do about the two task list views?": "Keep both, improve summary",
+          "Should the inline task list pin while tasks are active?": "Yes, pin while active",
+        },
+      },
+    });
+  });
+
+  it("keeps standalone ask_user declines explicit without emitting a fake cleanup tool_result", async () => {
+    const events: AgentChatEventEnvelope[] = [];
+    const { service } = createService({
+      onEvent: (event: AgentChatEventEnvelope) => events.push(event),
+    });
+
+    const session = await service.createSession({
+      laneId: "lane-1",
+      provider: "codex",
+      model: "gpt-5.4",
+    });
+
+    const requestPromise = service.requestChatInput({
+      chatSessionId: session.id,
+      title: "Planning question",
+      body: "Which part of the planning UI should we test first?",
+      questions: [{
+        id: "answer",
+        header: "Question 1",
+        question: "Which part of the planning UI should we test first?",
+        options: [
+          { label: "Question flow", value: "question_flow" },
+          { label: "Plan updates", value: "plan_updates" },
+        ],
+        allowsFreeform: true,
+      }],
+    });
+
+    const approvalEvent = await waitForEvent(
+      events,
+      (event): event is AgentChatEventEnvelope & {
+        event: Extract<AgentChatEventEnvelope["event"], { type: "approval_request" }>;
+      } => {
+        const detail = event.event.type === "approval_request"
+          ? (event.event.detail as { request?: { title?: string } } | undefined)
+          : undefined;
+        return event.event.type === "approval_request" && detail?.request?.title === "Planning question";
+      },
+    );
+
+    await service.respondToInput({
+      sessionId: session.id,
+      itemId: approvalEvent.event.itemId,
+      decision: "decline",
+    });
+
+    const result = await requestPromise;
+    expect(result.decision).toBe("decline");
+    expect(events.filter((event) => event.event.type === "tool_result")).toHaveLength(0);
+  });
+
+  it("maps freeform replies to the single pending question when only one answer is needed", async () => {
+    const events: AgentChatEventEnvelope[] = [];
+    const { service } = createService({
+      onEvent: (event: AgentChatEventEnvelope) => events.push(event),
+    });
+
+    const session = await service.createSession({
+      laneId: "lane-1",
+      provider: "codex",
+      model: "gpt-5.4",
+    });
+
+    const requestPromise = service.requestChatInput({
+      chatSessionId: session.id,
+      title: "Single question",
+      body: "Which area should we test first?",
+      questions: [{
+        id: "answer",
+        header: "Question 1",
+        question: "Which area should we test first?",
+        allowsFreeform: true,
+      }],
+    });
+
+    const approvalEvent = await waitForEvent(
+      events,
+      (event): event is AgentChatEventEnvelope & {
+        event: Extract<AgentChatEventEnvelope["event"], { type: "approval_request" }>;
+      } => {
+        const detail = event.event.type === "approval_request"
+          ? (event.event.detail as { request?: { title?: string } } | undefined)
+          : undefined;
+        return event.event.type === "approval_request" && detail?.request?.title === "Single question";
+      },
+    );
+
+    await service.respondToInput({
+      sessionId: session.id,
+      itemId: approvalEvent.event.itemId,
+      decision: "accept",
+      responseText: "Question flow",
+    });
+
+    await expect(requestPromise).resolves.toMatchObject({
+      decision: "accept",
+      answers: { answer: ["Question flow"] },
+      responseText: "Question flow",
+    });
+  });
+
+  it("does not fan a single freeform reply out across multiple structured questions", async () => {
+    const events: AgentChatEventEnvelope[] = [];
+    const { service } = createService({
+      onEvent: (event: AgentChatEventEnvelope) => events.push(event),
+    });
+
+    const session = await service.createSession({
+      laneId: "lane-1",
+      provider: "codex",
+      model: "gpt-5.4",
+    });
+
+    const requestPromise = service.requestChatInput({
+      chatSessionId: session.id,
+      title: "Multiple questions",
+      body: "Tell me which plan we should use and whether to pin tasks.",
+      questions: [
+        {
+          id: "plan_focus",
+          header: "Plan focus",
+          question: "What kind of planning scenario should I use?",
+          allowsFreeform: true,
+        },
+        {
+          id: "task_pinning",
+          header: "Task pinning",
+          question: "Should the inline task list stay pinned?",
+          allowsFreeform: true,
+        },
+      ],
+    });
+
+    const approvalEvent = await waitForEvent(
+      events,
+      (event): event is AgentChatEventEnvelope & {
+        event: Extract<AgentChatEventEnvelope["event"], { type: "approval_request" }>;
+      } => {
+        const detail = event.event.type === "approval_request"
+          ? (event.event.detail as { request?: { title?: string } } | undefined)
+          : undefined;
+        return event.event.type === "approval_request" && detail?.request?.title === "Multiple questions";
+      },
+    );
+
+    await service.respondToInput({
+      sessionId: session.id,
+      itemId: approvalEvent.event.itemId,
+      decision: "accept",
+      responseText: "Start with the UI planning case.",
+    });
+
+    await expect(requestPromise).resolves.toMatchObject({
+      decision: "accept",
+      answers: { response: ["Start with the UI planning case."] },
+      responseText: "Start with the UI planning case.",
+    });
+  });
+
+  it("responds to native Codex requestUserInput declines with empty answers instead of interrupting the turn", async () => {
+    const events: AgentChatEventEnvelope[] = [];
+    const { service } = createService({
+      onEvent: (event: AgentChatEventEnvelope) => events.push(event),
+    });
+
+    const session = await service.createSession({
+      laneId: "lane-1",
+      provider: "codex",
+      model: "gpt-5.4",
+      codexApprovalPolicy: "untrusted",
+      codexSandbox: "read-only",
+      codexConfigSource: "flags",
+    });
+
+    await service.sendMessage({
+      sessionId: session.id,
+      text: "Ask one planning question before coding.",
+    }, { awaitDispatch: true });
+
+    mockState.emitCodexPayload({
+      jsonrpc: "2.0",
+      id: "native-request-1",
+      method: "item/tool/requestUserInput",
+      params: {
+        itemId: "codex-question-1",
+        threadId: "thread-1",
+        turnId: "turn-1",
+        questions: [
+          {
+            id: "plan_focus",
+            header: "Plan focus",
+            question: "What kind of planning scenario should I use?",
+            isOther: true,
+            options: [
+              { label: "UI planning" },
+              { label: "Bug fix planning" },
+            ],
+          },
+        ],
+      },
+    });
+
+    const approvalEvent = await waitForEvent(
+      events,
+      (event): event is AgentChatEventEnvelope & {
+        event: Extract<AgentChatEventEnvelope["event"], { type: "approval_request" }>;
+      } =>
+        event.event.type === "approval_request"
+        && event.event.itemId === "codex-question-1",
+    );
+
+    await service.respondToInput({
+      sessionId: session.id,
+      itemId: approvalEvent.event.itemId,
+      decision: "cancel",
+    });
+
+    expect(
+      mockState.codexRequestPayloads.some((payload) => payload.method === "turn/interrupt"),
+    ).toBe(false);
+    expect(
+      mockState.codexRequestPayloads.find((payload) => payload.id === "native-request-1"),
+    ).toMatchObject({
+      jsonrpc: "2.0",
+      id: "native-request-1",
+      result: {
+        answers: {},
+      },
+    });
+  });
+
+  it("responds to Codex MCP elicitations with action/content payloads", async () => {
+    const events: AgentChatEventEnvelope[] = [];
+    const { service } = createService({
+      onEvent: (event: AgentChatEventEnvelope) => events.push(event),
+    });
+
+    const session = await service.createSession({
+      laneId: "lane-1",
+      provider: "codex",
+      model: "gpt-5.4",
+    });
+
+    await service.sendMessage({
+      sessionId: session.id,
+      text: "Wait for a structured MCP question.",
+    }, { awaitDispatch: true });
+
+    mockState.emitCodexPayload({
+      jsonrpc: "2.0",
+      id: "elicitation-1",
+      method: "mcpServer/elicitation/request",
+      params: {
+        serverName: "ade",
+        message: "Confirm whether we should continue.",
+        turnId: "turn-1",
+        requestedSchema: {
+          type: "object",
+          properties: {
+            confirmed: {
+              type: "boolean",
+              description: "Should ADE continue?",
+            },
+          },
+        },
+      },
+    });
+
+    const approvalEvent = await waitForEvent(
+      events,
+      (event): event is AgentChatEventEnvelope & {
+        event: Extract<AgentChatEventEnvelope["event"], { type: "approval_request" }>;
+      } =>
+        event.event.type === "approval_request"
+        && (
+          (event.event.detail as { request?: { title?: string } } | undefined)?.request?.title === "Question from ade"
+        ),
+    );
+
+    await service.respondToInput({
+      sessionId: session.id,
+      itemId: approvalEvent.event.itemId,
+      decision: "accept",
+      answers: {
+        confirmed: "true",
+      },
+    });
+
+    const elicitationResponse = mockState.codexRequestPayloads.find((payload) => payload.id === "elicitation-1");
+    expect(elicitationResponse?.result).toEqual({
+      action: "accept",
+      content: {
+        confirmed: true,
+      },
+    });
+  });
+
   it("initializes the Cursor runtime before validating the first turn", async () => {
     const events: AgentChatEventEnvelope[] = [];
+    vi.mocked(resolveAdeMcpServerLaunch).mockClear();
 
     const { service } = createService({
       onEvent: (event: AgentChatEventEnvelope) => events.push(event),
@@ -4276,6 +5273,13 @@ describe("createAgentChatService", () => {
     expect(vi.mocked(acquireCursorAcpConnection)).toHaveBeenCalledTimes(1);
     expect(mockState.cursorNewSessionCalls).toHaveLength(1);
     expect(mockState.cursorPromptCalls).toHaveLength(1);
+    await vi.waitFor(() => {
+      expect(vi.mocked(resolveAdeMcpServerLaunch)).toHaveBeenCalled();
+    });
+    // Cursor chat used the same shared MCP launch path, so we keep a separate
+    // assertion to ensure future chat refactors do not regress just one
+    // surface while leaving the others green.
+    expectResolvedMcpLaunchesToUseStandardProxyFlow();
     expect(
       events.some((event) => event.event.type === "error" && event.event.message.includes("No runtime initialized")),
     ).toBe(false);
diff --git a/apps/desktop/src/main/services/chat/agentChatService.ts b/apps/desktop/src/main/services/chat/agentChatService.ts
index bbe2bbe39..c18c3d12d 100644
--- a/apps/desktop/src/main/services/chat/agentChatService.ts
+++ b/apps/desktop/src/main/services/chat/agentChatService.ts
@@ -134,7 +134,7 @@ import { buildCodexAppServerMcpConfigOverrides } from "../ai/codexAppServerConfi
 import { createUniversalToolSet, type PermissionMode } from "../ai/tools/universalTools";
 import { createWorkflowTools } from "../ai/tools/workflowTools";
 import { createLinearTools } from "../ai/tools/linearTools";
-import { createCtoOperatorTools } from "../ai/tools/ctoOperatorTools";
+import { createCtoOperatorTools, type CtoOperatorToolDeps } from "../ai/tools/ctoOperatorTools";
 import { buildCodingAgentSystemPrompt } from "../ai/tools/systemPrompt";
 import { resolveClaudeCliModel } from "../ai/claudeModelUtils";
 import {
@@ -262,6 +262,7 @@ type PendingCodexApproval = {
   kind: "command" | "file_change" | "permissions" | "structured_question" | "plan_approval";
   request?: PendingInputRequest;
   permissions?: Record<string, unknown> | null;
+  questionResponseKind?: "native_request_user_input" | "mcp_elicitation";
 };
 
 type PendingClaudeApproval = {
@@ -296,6 +297,9 @@ type CodexRuntime = {
   sendError: (id: string | number, message: string) => void;
   slashCommands: Array<{ name: string; description: string; argumentHint?: string }>;
   rateLimits: { remaining: number | null; limit: number | null; resetAt: string | null } | null;
+  collaborationModes: Set<string> | null;
+  collaborationModesReady: Promise<void> | null;
+  planModeFallbackNotified: boolean;
 };
 
 type ClaudeRuntime = {
@@ -325,6 +329,12 @@ type ClaudeRuntime = {
   approvalOverrides: Set<string>;
   /** Pending MCP elicitation resolvers keyed by elicitation_id. */
   pendingElicitations: Map<string, () => void>;
+  /** SDK tool_use IDs resolved by canUseTool (e.g. answered AskUserQuestion). */
+  resolvedToolUseIds: Set<string>;
+  /** Suspend the active-turn idle watchdog while ADE is waiting on human input. */
+  pauseIdleWatchdog?: (() => void) | null;
+  /** Resume the active-turn idle watchdog after the blocking wait finishes. */
+  resumeIdleWatchdog?: (() => void) | null;
 };
 
 type PendingUnifiedApproval = {
@@ -757,7 +767,7 @@ type SessionTurnCollector = {
     cacheCreationTokens?: number | null;
   };
   lastError: string | null;
-  timeout: NodeJS.Timeout;
+  timeout: NodeJS.Timeout | null;
 };
 
 type PreparedSendMessage = {
@@ -816,7 +826,8 @@ const MAX_TRANSCRIPT_READ_CHARS = 40_000;
 const AUTO_TITLE_MAX_CHARS = 48;
 const REASONING_ACTIVITY_DETAIL = "Thinking through the answer";
 const WORKING_ACTIVITY_DETAIL = "Preparing response";
-const TURN_TIMEOUT_MS = 300_000; // 5 minutes – overall turn-level timeout
+const DEFAULT_RUN_SESSION_TURN_TIMEOUT_MS = 300_000;
+const DEFAULT_COLLABORATION_MODES_LIST_TIMEOUT_MS = 1_500;
 const CLAUDE_STREAM_IDLE_TIMEOUT_MS = 75_000;
 const AUTO_TITLE_SYSTEM_PROMPT = `You title software development chat sessions.
 Return only the title text.
@@ -1824,6 +1835,147 @@ function resolveSessionCodexConfigSource(
     ?? "flags";
 }
 
+type CodexCollaborationModePayload = {
+  mode: "default" | "plan";
+  settings: {
+    model: string;
+    reasoning_effort: string | null;
+    developer_instructions: null;
+  };
+};
+
+function buildCodexCollaborationMode(
+  session: Pick<
+    AgentChatSession,
+    "provider" | "permissionMode" | "interactionMode" | "model" | "reasoningEffort" | "codexConfigSource"
+  >,
+  supportedModes: Set<string> | null,
+): CodexCollaborationModePayload | null {
+  if (session.provider !== "codex") return null;
+  if (resolveSessionCodexConfigSource(session) === "config-toml") return null;
+  const requestedMode = session.interactionMode === "plan" || session.permissionMode === "plan"
+    ? "plan"
+    : "default";
+  const mode = (() => {
+    if (!supportedModes || supportedModes.size === 0) return requestedMode;
+    if (supportedModes.has(requestedMode)) return requestedMode;
+    if (requestedMode === "plan" && supportedModes.has("default")) return "default";
+    return null;
+  })();
+  if (!mode) return null;
+  return {
+    mode,
+    settings: {
+      model: session.model,
+      reasoning_effort: session.reasoningEffort ?? DEFAULT_REASONING_EFFORT,
+      developer_instructions: null,
+    },
+  };
+}
+
+function resolveRequestedCodexCollaborationMode(
+  session: Pick<
+    AgentChatSession,
+    "provider" | "permissionMode" | "interactionMode" | "codexConfigSource"
+  >,
+): "default" | "plan" | null {
+  if (session.provider !== "codex") return null;
+  if (resolveSessionCodexConfigSource(session) === "config-toml") return null;
+  return session.interactionMode === "plan" || session.permissionMode === "plan"
+    ? "plan"
+    : "default";
+}
+
+function coerceCodexMcpElicitationContent(
+  request: PendingInputRequest | undefined,
+  normalizedAnswers: Record<string, string[]>,
+): Record<string, string | number | boolean | string[]> {
+  const content: Record<string, string | number | boolean | string[]> = {};
+  const providerMetadata = request?.providerMetadata && typeof request.providerMetadata === "object"
+    ? request.providerMetadata as Record<string, unknown>
+    : null;
+  const requestedSchema = providerMetadata?.requestedSchema && typeof providerMetadata.requestedSchema === "object"
+    ? providerMetadata.requestedSchema as Record<string, unknown>
+    : null;
+  const schemaProperties = requestedSchema?.properties && typeof requestedSchema.properties === "object"
+    ? requestedSchema.properties as Record<string, unknown>
+    : null;
+
+  for (const [questionId, values] of Object.entries(normalizedAnswers)) {
+    if (!values.length) continue;
+    const property = schemaProperties?.[questionId] && typeof schemaProperties[questionId] === "object"
+      ? schemaProperties[questionId] as Record<string, unknown>
+      : null;
+    const propertyType = typeof property?.type === "string" ? property.type : null;
+
+    if (propertyType === "array") {
+      content[questionId] = values;
+      continue;
+    }
+
+    const [firstValue] = values;
+    if (!firstValue) continue;
+
+    if (propertyType === "boolean") {
+      const normalized = firstValue.trim().toLowerCase();
+      content[questionId] = normalized === "true" || normalized === "yes";
+      continue;
+    }
+
+    if (propertyType === "number" || propertyType === "integer") {
+      const parsed = Number(firstValue);
+      if (Number.isFinite(parsed)) {
+        content[questionId] = propertyType === "integer" ? Math.trunc(parsed) : parsed;
+        continue;
+      }
+    }
+
+    content[questionId] = firstValue;
+  }
+
+  return content;
+}
+
+function parseCodexCollaborationModes(value: unknown): Set<string> | null {
+  const normalized = new Set<string>();
+  const pushMode = (candidate: unknown): void => {
+    if (typeof candidate === "string") {
+      const trimmed = candidate.trim().toLowerCase();
+      if (trimmed.length) normalized.add(trimmed);
+      return;
+    }
+    if (!candidate || typeof candidate !== "object" || Array.isArray(candidate)) return;
+    const record = candidate as Record<string, unknown>;
+    const nested = [record.mode, record.name, record.kind];
+    for (const entry of nested) {
+      if (typeof entry === "string" && entry.trim().length) {
+        normalized.add(entry.trim().toLowerCase());
+        return;
+      }
+    }
+  };
+
+  if (Array.isArray(value)) {
+    value.forEach(pushMode);
+  } else if (value && typeof value === "object") {
+    const record = value as Record<string, unknown>;
+    const candidates = [
+      record.collaborationModes,
+      record.collaboration_modes,
+      record.modes,
+      record.presets,
+      record.items,
+    ];
+    for (const candidate of candidates) {
+      if (Array.isArray(candidate)) {
+        candidate.forEach(pushMode);
+      }
+    }
+  }
+
+  return normalized.size > 0 ? normalized : null;
+}
+
 function resolveSessionUnifiedPermissionMode(
   session: Pick<AgentChatSession, "unifiedPermissionMode" | "permissionMode">,
   fallback: AgentChatUnifiedPermissionMode,
@@ -2120,6 +2272,11 @@ export function createAgentChatService(args: {
   getTestService?: () => { listSuites: () => any[]; run: (args: any) => Promise<any>; stop: (args: any) => void; listRuns: (args?: any) => any[]; getLogTail: (args: any) => string } | null;
   ptyService?: { create: (args: any) => Promise<{ ptyId: string; sessionId: string }> } | null;
   getAutomationService?: () => { list: () => any[]; triggerManually: (args: any) => Promise<any>; listRuns: (args?: any) => any[] } | null;
+  getGitService?: () => CtoOperatorToolDeps["gitService"];
+  conflictService?: CtoOperatorToolDeps["conflictService"];
+  contextDocService?: CtoOperatorToolDeps["contextDocService"];
+  getWorkerBudgetService?: () => CtoOperatorToolDeps["workerBudgetService"];
+  getMissionBudgetService?: () => CtoOperatorToolDeps["missionBudgetService"];
   computerUseArtifactBrokerService?: ComputerUseArtifactBrokerService | null;
   laneService: ReturnType<typeof createLaneService>;
   sessionService: ReturnType<typeof createSessionService>;
@@ -2154,6 +2311,11 @@ export function createAgentChatService(args: {
     getTestService,
     ptyService,
     getAutomationService,
+    getGitService,
+    conflictService,
+    contextDocService,
+    getWorkerBudgetService,
+    getMissionBudgetService,
     computerUseArtifactBrokerService,
     laneService,
     sessionService,
@@ -2493,6 +2655,145 @@ export function createAgentChatService(args: {
     return headline;
   };
 
+  const hasClaudeAskUserAnswers = (input: Record<string, unknown>): boolean => {
+    const questions = Array.isArray(input.questions) ? input.questions : [];
+    const answers = asRecord(input.answers);
+    if (!answers || questions.length === 0) return false;
+    const hasAnswerValue = (value: unknown): boolean => {
+      if (typeof value === "string") return value.trim().length > 0;
+      if (Array.isArray(value)) return value.some((item) => hasAnswerValue(item));
+      if (value && typeof value === "object") {
+        return Object.values(value as Record<string, unknown>).some((item) => hasAnswerValue(item));
+      }
+      return value != null && value !== false;
+    };
+    return questions.every((q) => {
+      const key = typeof q === "object" && q !== null && typeof (q as Record<string, unknown>).id === "string"
+        ? (q as Record<string, unknown>).id as string
+        : typeof q === "object" && q !== null && typeof (q as Record<string, unknown>).question === "string"
+          ? (q as Record<string, unknown>).question as string
+          : null;
+      if (!key) return false;
+      // Check both the question id and the question text as answer keys
+      return hasAnswerValue(answers[key])
+        || (typeof (q as Record<string, unknown>).question === "string" && hasAnswerValue(answers[(q as Record<string, unknown>).question as string]));
+    });
+  };
+
+  const buildClaudeAskUserPendingRequest = (
+    runtime: ClaudeRuntime,
+    input: Record<string, unknown>,
+    sdkOptions?: { toolUseID?: string },
+  ): PendingInputRequest | null => {
+    const rawQuestions = Array.isArray(input.questions) ? input.questions : [];
+    const questions: PendingInputQuestion[] = [];
+
+    for (const [index, rawQuestion] of rawQuestions.entries()) {
+      const questionRecord = asRecord(rawQuestion);
+      if (!questionRecord) continue;
+
+      const question = typeof questionRecord.question === "string" ? questionRecord.question.trim() : "";
+      if (!question.length) continue;
+      const questionId = typeof questionRecord.id === "string" && questionRecord.id.trim().length > 0
+        ? questionRecord.id.trim()
+        : `question_${index + 1}`;
+
+      const header = typeof questionRecord.header === "string" ? questionRecord.header.trim() : "";
+      const isMultiSelect = questionRecord.multiSelect === true;
+      const options = Array.isArray(questionRecord.options)
+        ? questionRecord.options
+          .map((rawOption) => {
+            const optionRecord = asRecord(rawOption);
+            if (!optionRecord) return null;
+            const label = typeof optionRecord.label === "string" ? optionRecord.label.trim() : "";
+            if (!label.length) return null;
+            const description = typeof optionRecord.description === "string" ? optionRecord.description.trim() : "";
+            const preview = typeof optionRecord.preview === "string" ? optionRecord.preview : "";
+            const previewFormat: "markdown" | "html" =
+              optionRecord.previewFormat === "html" || optionRecord.previewFormat === "markdown"
+                ? optionRecord.previewFormat
+                : "markdown";
+            return {
+              label,
+              value: label,
+              ...(description.length ? { description } : {}),
+              ...(label.endsWith("(Recommended)") ? { recommended: true } : {}),
+              ...(preview.trim().length ? { preview, previewFormat } : {}),
+            };
+          })
+          .filter((option): option is NonNullable<typeof option> => option != null)
+        : [];
+
+      questions.push({
+        id: questionId,
+        question,
+        ...(header.length ? { header } : {}),
+        ...(options.length ? { options } : {}),
+        ...(isMultiSelect ? { multiSelect: true } : {}),
+        allowsFreeform: true,
+        ...(isMultiSelect
+          ? {
+              impact:
+                "This question allows multiple selections. If you want more than one option, type them as a comma-separated answer.",
+            }
+          : {}),
+      });
+    }
+
+    if (questions.length === 0) return null;
+
+    const firstQuestion = questions[0];
+    const hasStructuredChoices = questions.length > 1 || questions.some((question) => (question.options?.length ?? 0) > 0);
+    const itemId = randomUUID();
+    return {
+      requestId: itemId,
+      itemId,
+      source: "claude",
+      kind: hasStructuredChoices ? "structured_question" : "question",
+      title: questions.length === 1 ? "Question from Claude" : "Questions from Claude",
+      description: questions.length === 1
+        ? firstQuestion?.question ?? "Claude needs an answer before it can continue."
+        : "Claude needs a few answers before it can continue.",
+      questions,
+      allowsFreeform: true,
+      blocking: true,
+      canProceedWithoutAnswer: false,
+      providerMetadata: {
+        tool: "AskUserQuestion",
+        questionCount: questions.length,
+        ...(sdkOptions?.toolUseID ? { toolUseID: sdkOptions.toolUseID } : {}),
+      },
+      turnId: runtime.activeTurnId ?? null,
+    };
+  };
+
+  const buildClaudeAskUserUpdatedInput = (
+    input: Record<string, unknown>,
+    request: PendingInputRequest,
+    response: { answers?: Record<string, string | string[]>; responseText?: string | null },
+  ): Record<string, unknown> => {
+    const normalizedAnswers = normalizePendingInputAnswers(request, response.answers, response.responseText);
+    const mappedAnswers = Object.fromEntries(
+      Object.entries(normalizedAnswers)
+        .map(([questionId, values]) => {
+          // Map internal question ID back to the original question text
+          // so Claude's SDK receives answers keyed the way it expects.
+          const question = request.questions.find((q) => q.id === questionId);
+          const originalKey = question?.question ?? questionId;
+          // Preserve array structure for multi-select questions
+          const answer: string | string[] = question?.multiSelect ? values : values.join(", ").trim();
+          return [originalKey, answer] as const;
+        })
+        .filter(([, answer]) => (typeof answer === "string" ? answer.length > 0 : answer.length > 0)),
+    );
+
+    const existingAnswers = asRecord(input.answers) ?? {};
+    return {
+      ...input,
+      answers: { ...existingAnswers, ...mappedAnswers },
+    };
+  };
+
   const buildClaudeCanUseTool = (
     runtime: ClaudeRuntime,
     managed: ManagedChatSession,
@@ -2560,14 +2861,29 @@ export function createAgentChatService(args: {
       // Block until the user responds via the approval UI.
       let response: { decision?: AgentChatApprovalDecision; answers?: Record<string, string | string[]>; responseText?: string | null };
       try {
+        runtime.pauseIdleWatchdog?.();
         response = await new Promise<typeof response>((resolve) => {
           runtime.approvals.set(approvalItemId, { kind: "approval", resolve, request });
         });
       } finally {
         runtime.approvals.delete(approvalItemId);
+        runtime.resumeIdleWatchdog?.();
       }
 
+      // Emit tool_result so derivePendingInputRequests clears this entry.
       const approved = response.decision === "accept" || response.decision === "accept_for_session";
+      emitChatEvent(managed, {
+        type: "tool_result",
+        tool: "ExitPlanMode",
+        result: { approved },
+        itemId: approvalItemId,
+        turnId: runtime.activeTurnId ?? undefined,
+        status: approved ? "completed" : "failed",
+      });
+      if (sdkOptions?.toolUseID) {
+        runtime.resolvedToolUseIds.add(String(sdkOptions.toolUseID));
+      }
+
       if (approved) {
         // Switch session out of plan mode so the UI reflects the transition.
         if (managed.session.permissionMode === "plan" || managed.session.interactionMode === "plan") {
@@ -2590,6 +2906,77 @@ export function createAgentChatService(args: {
       };
     }
 
+    if (toolName === "AskUserQuestion") {
+      if (hasClaudeAskUserAnswers(input)) {
+        return { behavior: "allow" };
+      }
+
+      const request = buildClaudeAskUserPendingRequest(runtime, input, sdkOptions);
+      if (!request) {
+        return { behavior: "allow" };
+      }
+
+      const approvalItemId = request.itemId ?? request.requestId;
+      emitPendingInputRequest(managed, request, {
+        kind: "tool_call",
+        description: request.description ?? "Claude needs input before it can continue.",
+        detail: {
+          tool: "AskUserQuestion",
+          questionCount: request.questions.length,
+          ...(sdkOptions?.toolUseID ? { toolUseID: sdkOptions.toolUseID } : {}),
+        },
+      });
+
+      let response: { decision?: AgentChatApprovalDecision; answers?: Record<string, string | string[]>; responseText?: string | null };
+      try {
+        runtime.pauseIdleWatchdog?.();
+        response = await new Promise<typeof response>((resolve) => {
+          runtime.approvals.set(approvalItemId, { kind: "question", resolve, request });
+        });
+      } finally {
+        runtime.approvals.delete(approvalItemId);
+        runtime.resumeIdleWatchdog?.();
+      }
+
+      // Emit a tool_result so derivePendingInputRequests clears this entry
+      // and the question UI doesn't reappear on the next event flush.
+      const answered = response.decision !== "cancel" && response.decision !== "decline";
+      emitChatEvent(managed, {
+        type: "tool_result",
+        tool: "AskUserQuestion",
+        result: { answered, decision: response.decision ?? "none" },
+        itemId: approvalItemId,
+        turnId: runtime.activeTurnId ?? undefined,
+        status: answered ? "completed" : "failed",
+      });
+
+      // Track the SDK tool_use ID so flushOpenClaudeToolUses skips it
+      // (prevents the synthetic "Completed AskUserQuestion when turn ended" noise).
+      if (sdkOptions?.toolUseID) {
+        runtime.resolvedToolUseIds.add(String(sdkOptions.toolUseID));
+      }
+
+      if (response.decision === "cancel" || response.decision === "decline") {
+        return {
+          behavior: "deny",
+          message: "The user declined to answer the questions.",
+        };
+      }
+
+      const updatedInput = buildClaudeAskUserUpdatedInput(input, request, response);
+      if (!hasClaudeAskUserAnswers(updatedInput)) {
+        return {
+          behavior: "deny",
+          message: "The user did not provide answers to the questions.",
+        };
+      }
+
+      return {
+        behavior: "allow",
+        updatedInput,
+      };
+    }
+
     // ── Memory orientation guard ──
     const state = runtime.turnMemoryPolicyState;
     if (isMemorySearchToolName(toolName) && state) {
@@ -2656,11 +3043,13 @@ export function createAgentChatService(args: {
 
       let response: { decision?: AgentChatApprovalDecision; answers?: Record<string, string | string[]>; responseText?: string | null };
       try {
+        runtime.pauseIdleWatchdog?.();
         response = await new Promise<typeof response>((resolve) => {
           runtime.approvals.set(approvalItemId, { kind: "approval", resolve, request });
         });
       } finally {
         runtime.approvals.delete(approvalItemId);
+        runtime.resumeIdleWatchdog?.();
       }
 
       const approved = response.decision === "accept" || response.decision === "accept_for_session";
@@ -2796,7 +3185,19 @@ export function createAgentChatService(args: {
         testService: getTestService?.() ?? null,
         ptyService: ptyService ?? null,
         automationService: getAutomationService?.() ?? null,
+        gitService: getGitService?.() ?? null,
+        conflictService: conflictService ?? null,
+        contextDocService: contextDocService ?? null,
+        computerUseArtifactBrokerService: computerUseArtifactBrokerRef ?? null,
+        workerBudgetService: getWorkerBudgetService?.() ?? null,
+        missionBudgetService: getMissionBudgetService?.() ?? null,
+        steerChat: undefined,
+        cancelSteer: undefined,
+        handoffChat: undefined,
+        listSubagents: undefined,
+        approveToolUse: undefined,
         issueTracker: linearIssueTracker ?? null,
+        ctoStateService: ctoStateService ?? null,
         listChats: listSessions,
         getChatStatus: getSessionSummary,
         getChatTranscript,
@@ -2842,9 +3243,8 @@ export function createAgentChatService(args: {
     chatSessionId?: string | null,
     computerUsePolicy?: ComputerUsePolicy | null,
   ): Record<string, Record<string, unknown>> => {
-    // CLI providers (claude/codex) spawn the MCP server as a plain Node child
-    // process via stdio.  Skip the Electron bundled-proxy so the command
-    // resolves to `node dist/index.cjs` which the CLI can manage as stdio.
+    // Chat surfaces should use ADE's standard MCP launch resolution so both
+    // packaged and dev builds can route through the proxy when needed.
     const launch = resolveAdeMcpServerLaunch({
       projectRoot,
       workspaceRoot,
@@ -2853,7 +3253,6 @@ export function createAgentChatService(args: {
       ownerId: ownerId ?? undefined,
       chatSessionId: chatSessionId ?? undefined,
       computerUsePolicy: normalizeComputerUsePolicy(computerUsePolicy, createDefaultComputerUsePolicy()),
-      preferBundledProxy: false,
     });
     return providerResolver.normalizeCliMcpServers(provider, {
       ade: {
@@ -2986,7 +3385,6 @@ export function createAgentChatService(args: {
       ownerId: ownerId ?? undefined,
       chatSessionId: chatSessionId ?? undefined,
       computerUsePolicy: normalizeComputerUsePolicy(computerUsePolicy, createDefaultComputerUsePolicy()),
-      preferBundledProxy: false,
     });
 
     const mergedEnv: Record<string, string> = {};
@@ -4511,7 +4909,9 @@ export function createAgentChatService(args: {
     if (event.type !== "done") return;
 
     collector.usage = event.usage;
-    clearTimeout(collector.timeout);
+    if (collector.timeout) {
+      clearTimeout(collector.timeout);
+    }
     sessionTurnCollectors.delete(managed.session.id);
     collector.resolve({
       sessionId: managed.session.id,
@@ -4686,6 +5086,27 @@ export function createAgentChatService(args: {
     });
   };
 
+  const emitPendingInputResolved = (
+    managed: ManagedChatSession,
+    args: {
+      itemId: string;
+      decision: AgentChatApprovalDecision;
+      turnId?: string | null;
+    },
+  ): void => {
+    emitChatEvent(managed, {
+      type: "pending_input_resolved",
+      itemId: args.itemId,
+      resolution:
+        args.decision === "cancel"
+          ? "cancelled"
+          : args.decision === "decline"
+            ? "declined"
+            : "accepted",
+      ...(typeof args.turnId === "string" && args.turnId.trim().length ? { turnId: args.turnId.trim() } : {}),
+    });
+  };
+
   const normalizePendingInputAnswers = (
     request: PendingInputRequest | undefined,
     answers: Record<string, string | string[]> | undefined,
@@ -4713,8 +5134,14 @@ export function createAgentChatService(args: {
 
     const trimmedResponse = typeof responseText === "string" ? responseText.trim() : "";
     if (trimmedResponse.length > 0) {
-      const fallbackQuestionId = request?.questions[0]?.id ?? "response";
-      normalized[fallbackQuestionId] = [trimmedResponse];
+      if (request?.questions.length === 1) {
+        const [question] = request.questions;
+        if (question && !normalized[question.id]?.length) {
+          normalized[question.id] = [trimmedResponse];
+        }
+      } else {
+        normalized["response"] = [trimmedResponse];
+      }
     }
 
     return normalized;
@@ -4908,6 +5335,54 @@ export function createAgentChatService(args: {
     clearLaneDirectiveKey(managed);
   };
 
+  const keepChatSessionOpen = (
+    managed: ManagedChatSession,
+    args: {
+      message: string;
+      turnId?: string | null;
+      turnStatus?: "failed" | "interrupted";
+    },
+  ): void => {
+    if (managed.closed) return;
+
+    const resolvedTurnId = typeof args.turnId === "string" && args.turnId.trim().length
+      ? args.turnId.trim()
+      : null;
+
+    for (const pending of managed.localPendingInputs.values()) {
+      pending.resolve({ decision: "cancel" });
+    }
+    managed.localPendingInputs.clear();
+
+    emitChatEvent(managed, {
+      type: "error",
+      message: args.message,
+      ...(resolvedTurnId ? { turnId: resolvedTurnId } : {}),
+    });
+
+    if (resolvedTurnId && args.turnStatus) {
+      emitChatEvent(managed, {
+        type: "status",
+        turnStatus: args.turnStatus,
+        turnId: resolvedTurnId,
+      });
+      emitChatEvent(managed, {
+        type: "done",
+        turnId: resolvedTurnId,
+        status: args.turnStatus,
+        model: managed.session.model,
+        ...(managed.session.modelId ? { modelId: managed.session.modelId } : {}),
+      });
+    }
+
+    managed.session.status = "idle";
+    teardownRuntime(managed);
+    managed.closed = false;
+    managed.endedNotified = false;
+    sessionService.reopen(managed.session.id);
+    persistChatState(managed);
+  };
+
   const maybeGenerateSessionSummary = async (
     managed: ManagedChatSession,
     deterministicSummary: string | null
@@ -5337,10 +5812,28 @@ export function createAgentChatService(args: {
       });
     }
 
+    await runtime.collaborationModesReady?.catch(() => {});
+    const requestedCollaborationMode = resolveRequestedCodexCollaborationMode(managed.session);
+    const collaborationMode = buildCodexCollaborationMode(managed.session, runtime.collaborationModes);
+    if (
+      requestedCollaborationMode === "plan"
+      && collaborationMode?.mode !== "plan"
+      && !runtime.planModeFallbackNotified
+    ) {
+      emitChatEvent(managed, {
+        type: "system_notice",
+        noticeKind: "info",
+        message: "Native Codex plan mode is unavailable for this session, so ADE is continuing in default collaboration mode.",
+      });
+      runtime.planModeFallbackNotified = true;
+    } else if (collaborationMode?.mode === "plan") {
+      runtime.planModeFallbackNotified = false;
+    }
     const result = await managed.runtime.request<{ turn?: { id?: string } }>("turn/start", {
       threadId: managed.session.threadId,
       input,
-      ...(managed.session.reasoningEffort ? { reasoningEffort: managed.session.reasoningEffort } : {})
+      ...(managed.session.reasoningEffort ? { reasoningEffort: managed.session.reasoningEffort } : {}),
+      ...(collaborationMode ? { collaborationMode } : {}),
     });
     persistDeliveredLaneDirectiveKey(managed, args.laneDirectiveKey);
 
@@ -5473,6 +5966,7 @@ export function createAgentChatService(args: {
     runtime.busy = true;
     runtime.activeTurnId = turnId;
     runtime.interrupted = false;
+    runtime.resolvedToolUseIds.clear();
     managed.session.status = "active";
 
     const attachments = args.attachments ?? [];
@@ -5506,9 +6000,61 @@ export function createAgentChatService(args: {
     let firstStreamEventLogged = false;
     const emittedClaudeToolIds = new Set<string>();
     const emittedSyntheticItemIds = new Set<string>();
+    const openClaudeToolUses = new Map<string, { toolName: string }>();
     const toolInputJsonByContentIndex = new Map<number, string>();
     const toolUseMetaByContentIndex = new Map<number, { toolName: string; itemId: string }>();
     const emittedClaudeTodoIds = new Set<string>();
+    const emitClaudeToolCompletion = (
+      itemId: string,
+      result: Record<string, unknown>,
+      status: "completed" | "failed" | "interrupted",
+    ): void => {
+      const toolMeta = openClaudeToolUses.get(itemId);
+      if (!toolMeta) return;
+      openClaudeToolUses.delete(itemId);
+      emitChatEvent(managed, {
+        type: "tool_result",
+        tool: toolMeta.toolName,
+        result,
+        itemId,
+        turnId,
+        status,
+      });
+    };
+    const completeClaudeToolUsesFromSummary = (
+      toolUseIds: string[],
+      summaryText: string,
+    ): void => {
+      const cleanedSummary = summaryText.trim();
+      for (const toolUseId of toolUseIds) {
+        const normalizedToolUseId = toolUseId.trim();
+        if (!normalizedToolUseId || !openClaudeToolUses.has(normalizedToolUseId)) continue;
+        emitClaudeToolCompletion(normalizedToolUseId, {
+          synthetic: true,
+          source: "claude_tool_use_summary",
+          summary: cleanedSummary || `Completed ${openClaudeToolUses.get(normalizedToolUseId)?.toolName ?? "tool"}.`,
+        }, "completed");
+      }
+    };
+    const flushOpenClaudeToolUses = (
+      finalTurnStatus: "completed" | "failed" | "interrupted",
+    ): void => {
+      const remainingToolUses = [...openClaudeToolUses.entries()];
+      for (const [itemId, toolMeta] of remainingToolUses) {
+        // Skip tools already resolved by canUseTool (e.g. answered AskUserQuestion)
+        // — their tool_result was emitted inline; don't double-emit a synthetic one.
+        if (runtime.resolvedToolUseIds.has(itemId)) {
+          openClaudeToolUses.delete(itemId);
+          continue;
+        }
+        emitClaudeToolCompletion(itemId, {
+          synthetic: true,
+          source: "claude_turn_finalization",
+          finalTurnStatus,
+          summary: `Completed ${toolMeta.toolName} when the Claude turn ended.`,
+        }, finalTurnStatus);
+      }
+    };
     const maybeEmitTodoUpdate = (toolName: string, input: unknown, itemId: string): void => {
       if (toolName !== "TodoWrite") return;
       if (emittedClaudeTodoIds.has(itemId)) return;
@@ -5517,9 +6063,9 @@ export function createAgentChatService(args: {
       emittedClaudeTodoIds.add(itemId);
       emitChatEvent(managed, { type: "todo_update", items: todoItems, turnId });
     };
-    let turnTimeout: ReturnType<typeof setTimeout> | undefined;
     let idleTimeout: ReturnType<typeof setTimeout> | undefined;
     let timeoutError: Error | null = null;
+    let idleWatchdogPauseCount = 0;
     const buildDoneModelPayload = (): { model: string; modelId?: string } =>
       resolveClaudeTurnModelPayload(managed.session, [
         reportedAssistantModel,
@@ -5548,15 +6094,21 @@ export function createAgentChatService(args: {
       return `claude-${kind}:${turnId}:${contentIndex}`;
     };
     const clearClaudeTurnTimers = (): void => {
-      if (turnTimeout) {
-        clearTimeout(turnTimeout);
-        turnTimeout = undefined;
-      }
       if (idleTimeout) {
         clearTimeout(idleTimeout);
         idleTimeout = undefined;
       }
     };
+    const pauseClaudeIdleWatchdog = (): void => {
+      idleWatchdogPauseCount += 1;
+      clearClaudeTurnTimers();
+    };
+    const resumeClaudeIdleWatchdog = (): void => {
+      idleWatchdogPauseCount = Math.max(0, idleWatchdogPauseCount - 1);
+      if (idleWatchdogPauseCount === 0 && !timeoutError && !runtime.interrupted && runtime.busy) {
+        bumpClaudeIdleDeadline();
+      }
+    };
     const failClaudeTurn = (message: string, reason: "timeout" | "idle"): void => {
       if (timeoutError || runtime.interrupted) return;
       timeoutError = new Error(message);
@@ -5567,28 +6119,28 @@ export function createAgentChatService(args: {
       });
       cancelClaudeWarmup(managed, runtime, "timeout");
       try { runtime.v2Session?.close(); } catch { /* ignore */ }
-      runtime.sdkSessionId = null;
+      // Keep the persisted Claude V2 session id so the next turn can resume
+      // the same conversation after this local process is torn down.
     };
     const bumpClaudeIdleDeadline = (): void => {
+      if (idleWatchdogPauseCount > 0) {
+        clearClaudeTurnTimers();
+        return;
+      }
       if (idleTimeout) {
         clearTimeout(idleTimeout);
       }
       idleTimeout = setTimeout(() => {
         failClaudeTurn(
-          `Claude stopped streaming for ${Math.round(CLAUDE_STREAM_IDLE_TIMEOUT_MS / 1000)}s. The turn was reset so you can retry.`,
+          `Claude stopped streaming for ${Math.round(CLAUDE_STREAM_IDLE_TIMEOUT_MS / 1000)}s. This turn was interrupted, but the chat stayed open so you can retry.`,
           "idle",
         );
       }, CLAUDE_STREAM_IDLE_TIMEOUT_MS);
     };
+    runtime.pauseIdleWatchdog = pauseClaudeIdleWatchdog;
+    runtime.resumeIdleWatchdog = resumeClaudeIdleWatchdog;
 
     try {
-      turnTimeout = setTimeout(() => {
-        failClaudeTurn(
-          `Claude turn exceeded ${Math.round(TURN_TIMEOUT_MS / 1000)}s. The runtime was reset so you can retry.`,
-          "timeout",
-        );
-      }, TURN_TIMEOUT_MS);
-
       const autoMemoryPrompt = args.displayText?.trim().length ? args.displayText.trim() : args.promptText;
       const autoMemoryPlan = await buildAutoMemoryTurnPlan(managed, autoMemoryPrompt, attachments);
       const autoMemoryNotice = buildAutoMemorySystemNotice(autoMemoryPlan);
@@ -5959,6 +6511,7 @@ export function createAgentChatService(args: {
                 const nextActivity = activityForToolName(toolName);
                 if (!emittedClaudeToolIds.has(itemId)) {
                   emittedClaudeToolIds.add(itemId);
+                  openClaudeToolUses.set(itemId, { toolName });
                   emitChatEvent(managed, {
                     type: "activity",
                     activity: nextActivity.activity,
@@ -6075,6 +6628,7 @@ export function createAgentChatService(args: {
               const nextActivity = activityForToolName(toolName);
               if (!emittedClaudeToolIds.has(itemId)) {
                 emittedClaudeToolIds.add(itemId);
+                openClaudeToolUses.set(itemId, { toolName });
                 emitChatEvent(managed, {
                   type: "activity",
                   activity: nextActivity.activity,
@@ -6197,6 +6751,15 @@ export function createAgentChatService(args: {
               message: `${denials.length} tool call${denials.length === 1 ? " was" : "s were"} denied this turn: ${denialSummary}`,
               turnId,
             });
+            for (const denial of denials) {
+              if (denial.tool_use_id && openClaudeToolUses.has(denial.tool_use_id)) {
+                emitClaudeToolCompletion(denial.tool_use_id, {
+                  synthetic: true,
+                  source: "permission_denied",
+                  tool: denial.tool_name,
+                }, "failed");
+              }
+            }
           }
           continue;
         }
@@ -6204,10 +6767,12 @@ export function createAgentChatService(args: {
         // tool_use_summary — summarizes groups of tool calls
         if ((msg as any).type === "tool_use_summary") {
           const summaryMsg = msg as any;
+          const toolUseIds = Array.isArray(summaryMsg.preceding_tool_use_ids) ? summaryMsg.preceding_tool_use_ids.map(String) : [];
+          completeClaudeToolUsesFromSummary(toolUseIds, String(summaryMsg.summary ?? ""));
           emitChatEvent(managed, {
             type: "tool_use_summary",
             summary: String(summaryMsg.summary ?? ""),
-            toolUseIds: Array.isArray(summaryMsg.preceding_tool_use_ids) ? summaryMsg.preceding_tool_use_ids.map(String) : [],
+            toolUseIds,
             turnId,
           });
           continue;
@@ -6247,6 +6812,9 @@ export function createAgentChatService(args: {
 
       // ── Turn completion ──
       clearClaudeTurnTimers();
+      runtime.pauseIdleWatchdog = null;
+      runtime.resumeIdleWatchdog = null;
+      flushOpenClaudeToolUses(runtime.interrupted ? "interrupted" : "completed");
       // Note: v2Session is NOT closed here — it stays alive for the next turn
       runtime.activeQuery = null;
       runtime.busy = false;
@@ -6296,10 +6864,18 @@ export function createAgentChatService(args: {
       }
     } catch (error) {
       clearClaudeTurnTimers();
+      runtime.pauseIdleWatchdog = null;
+      runtime.resumeIdleWatchdog = null;
       runtime.activeQuery = null;
       runtime.busy = false;
       runtime.activeTurnId = null;
       runtime.turnMemoryPolicyState = null;
+      const effectiveError = timeoutError ?? error;
+      const finalToolStatus: "completed" | "failed" | "interrupted" =
+        runtime.interrupted || isAbortRelatedError(effectiveError)
+          ? "interrupted"
+          : "failed";
+      flushOpenClaudeToolUses(finalToolStatus);
 
       // Close V2 session on error so the next turn starts fresh
       try { runtime.v2Session?.close(); } catch { /* ignore */ }
@@ -6317,7 +6893,28 @@ export function createAgentChatService(args: {
           status: "interrupted",
           ...doneModel,
         });
-      } else if (isAbortRelatedError(error)) {
+      } else if (timeoutError) {
+        managed.session.status = "idle";
+        const errorMessage = effectiveError instanceof Error ? effectiveError.message : String(effectiveError);
+        reportProviderRuntimeFailure("claude", errorMessage);
+        emitChatEvent(managed, {
+          type: "error",
+          message: errorMessage,
+          turnId,
+        });
+        emitChatEvent(managed, { type: "status", turnStatus: "failed", turnId });
+        emitChatEvent(managed, {
+          type: "done",
+          turnId,
+          status: "failed",
+          ...doneModel,
+        });
+
+        appendWorkerActivityToCto(managed, {
+          activityType: "chat_turn",
+          summary: `Turn failed: ${errorMessage}`,
+        });
+      } else if (isAbortRelatedError(effectiveError)) {
         // System-triggered abort (dispose/teardown) that wasn't flagged as interrupted.
         // Treat as interruption to avoid surfacing raw SDK messages like "aborted by user".
         managed.session.status = "idle";
@@ -6330,10 +6927,10 @@ export function createAgentChatService(args: {
         });
       } else {
         managed.session.status = "idle";
-        const isAuthFailure = isClaudeRuntimeAuthError(error);
+        const isAuthFailure = isClaudeRuntimeAuthError(effectiveError);
         const errorMessage = isAuthFailure
           ? CLAUDE_RUNTIME_AUTH_ERROR
-          : (error instanceof Error ? error.message : String(error));
+          : (effectiveError instanceof Error ? effectiveError.message : String(effectiveError));
         if (isAuthFailure) {
           reportProviderRuntimeAuthFailure("claude", CLAUDE_RUNTIME_AUTH_ERROR);
         } else {
@@ -6358,11 +6955,15 @@ export function createAgentChatService(args: {
         });
 
         // If resume failed, clear sessionId and the caller can retry fresh
-        if (runtime.sdkSessionId && String(error).includes("session")) {
+        const isStaleSessionError = (err: unknown): boolean => {
+          const msg = (err instanceof Error ? err.message : String(err)).toLowerCase();
+          return msg.includes("session not found") || msg.includes("invalid session") || msg.includes("stale session") || msg.includes("session expired");
+        };
+        if (runtime.sdkSessionId && isStaleSessionError(effectiveError)) {
           logger.warn("agent_chat.claude_sdk_session_error", {
             sessionId: managed.session.id,
             sdkSessionId: runtime.sdkSessionId,
-            error: error instanceof Error ? error.message : String(error),
+            error: effectiveError instanceof Error ? effectiveError.message : String(effectiveError),
           });
           runtime.sdkSessionId = null;
           managed.runtimeInvalidated = true;
@@ -6449,8 +7050,6 @@ export function createAgentChatService(args: {
       });
     };
 
-    let turnTimeout: ReturnType<typeof setTimeout> | undefined;
-
     try {
       const autoMemoryPrompt = args.displayText?.trim().length ? args.displayText.trim() : args.promptText;
       const autoMemoryPlan = await buildAutoMemoryTurnPlan(managed, autoMemoryPrompt, attachments);
@@ -6490,22 +7089,6 @@ export function createAgentChatService(args: {
       const abortController = new AbortController();
       runtime.abortController = abortController;
 
-      // Turn-level timeout: abort if the entire turn exceeds the limit
-      turnTimeout = setTimeout(() => {
-        logger.warn("agent_chat.turn_timeout", {
-          sessionId: managed.session.id,
-          turnId,
-          timeoutMs: TURN_TIMEOUT_MS,
-        });
-        emitChatEvent(managed, {
-          type: "error",
-          message: `Turn timed out after ${TURN_TIMEOUT_MS / 1000}s. The agent loop was aborted.`,
-          turnId,
-        });
-        runtime.interrupted = true;
-        abortController.abort();
-      }, TURN_TIMEOUT_MS);
-
       const streamMessages = runtime.messages.map((message, index): ModelMessage => {
         const isCurrentUserMessage = index === runtime.messages.length - 1 && message.role === "user";
         if (!isCurrentUserMessage) {
@@ -6738,7 +7321,24 @@ export function createAgentChatService(args: {
             testService: getTestService?.() ?? null,
             ptyService: ptyService ?? null,
             automationService: getAutomationService?.() ?? null,
+            gitService: getGitService?.() ?? null,
+            conflictService: conflictService ?? null,
+            contextDocService: contextDocService ?? null,
+            computerUseArtifactBrokerService: computerUseArtifactBrokerRef ?? null,
+            workerBudgetService: getWorkerBudgetService?.() ?? null,
+            missionBudgetService: getMissionBudgetService?.() ?? null,
+            steerChat: (steerArgs: { sessionId: string; instruction: string }) =>
+              steer({ sessionId: steerArgs.sessionId, text: steerArgs.instruction }),
+            cancelSteer: (cancelArgs: { sessionId: string }) =>
+              cancelSteer({ sessionId: cancelArgs.sessionId, steerId: "" }),
+            handoffChat: (handoffArgs: { sessionId: string; targetIdentityKey?: string; reason?: string }) =>
+              handoffSession(handoffArgs as any),
+            listSubagents: (subArgs: { sessionId: string }) =>
+              Promise.resolve(listSubagents(subArgs as any)),
+            approveToolUse: (approveArgs: { sessionId: string; toolUseId: string; decision: "accept" | "accept_for_session" | "decline" | "cancel" }) =>
+              approveToolUse({ sessionId: approveArgs.sessionId, itemId: approveArgs.toolUseId, decision: approveArgs.decision }),
             issueTracker: linearIssueTracker ?? null,
+            ctoStateService: ctoStateService ?? null,
             listChats: listSessions,
             getChatStatus: getSessionSummary,
             getChatTranscript,
@@ -7031,7 +7631,6 @@ export function createAgentChatService(args: {
 
       // ── Shared turn completion ──
       persistDeliveredLaneDirectiveKey(managed, args.laneDirectiveKey);
-      clearTimeout(turnTimeout);
       if (runtime.interrupted) {
         runtime.busy = false;
         runtime.activeTurnId = null;
@@ -7086,7 +7685,6 @@ export function createAgentChatService(args: {
         }
       }
     } catch (error) {
-      clearTimeout(turnTimeout);
       runtime.busy = false;
       runtime.activeTurnId = null;
       runtime.abortController = null;
@@ -7298,7 +7896,8 @@ export function createAgentChatService(args: {
           question?: string;
           isOther?: boolean;
           isSecret?: boolean;
-          options?: Array<{ label?: string; description?: string }> | null;
+          multiSelect?: boolean;
+          options?: Array<{ label?: string; description?: string; preview?: string; previewFormat?: "markdown" | "html" }> | null;
         }>;
       } | null) ?? {};
       const itemId = String(params.itemId ?? randomUUID());
@@ -7312,10 +7911,12 @@ export function createAgentChatService(args: {
                   const label = typeof option?.label === "string" ? option.label.trim() : "";
                   if (!label.length) return [];
                   const description = typeof option?.description === "string" ? option.description.trim() : "";
+                  const preview = typeof option?.preview === "string" ? option.preview : "";
                   return [{
                     label,
                     value: label,
                     ...(description ? { description } : {}),
+                    ...(preview.trim().length ? { preview, ...(option?.previewFormat ? { previewFormat: option.previewFormat } : {}) } : {}),
                   }];
                 })
               : [];
@@ -7323,6 +7924,7 @@ export function createAgentChatService(args: {
               id: questionId,
               header: typeof question?.header === "string" && question.header.trim().length ? question.header.trim() : `Question ${index + 1}`,
               question: questionText,
+              ...(question?.multiSelect === true ? { multiSelect: true } : {}),
               allowsFreeform: question?.isOther === true || options.length === 0,
               isSecret: question?.isSecret === true,
               ...(options.length ? { options } : {}),
@@ -7345,17 +7947,278 @@ export function createAgentChatService(args: {
           threadId: params.threadId ?? null,
         },
       };
-      runtime.approvals.set(itemId, { requestId: id, kind: "structured_question", request });
-      emitPendingInputRequest(managed, request, {
-        kind: "tool_call",
-        description: request.description ?? "Codex requested input",
-      });
+      runtime.approvals.set(itemId, {
+        requestId: id,
+        kind: "structured_question",
+        request,
+        questionResponseKind: "native_request_user_input",
+      });
+      emitPendingInputRequest(managed, request, {
+        kind: "tool_call",
+        description: request.description ?? "Codex requested input",
+      });
+      return;
+    }
+
+    // ── MCP Elicitation (used by mcp__ade__ask_user for standalone chat) ──
+    if (method === "mcpServer/elicitation/request") {
+      const params = (payload.params as {
+        serverName?: string;
+        message?: string;
+        turnId?: string;
+        requestedSchema?: Record<string, unknown>;
+      } | null) ?? {};
+      const serverName = typeof params.serverName === "string" ? params.serverName.trim() : "MCP";
+      const message = typeof params.message === "string" ? params.message.trim() : "The agent needs input.";
+      const itemId = randomUUID();
+      const requestedSchema = params.requestedSchema && typeof params.requestedSchema === "object"
+        ? params.requestedSchema
+        : null;
+
+      const inferQuestionsFromSchema = (): PendingInputQuestion[] => {
+        const properties = requestedSchema && typeof requestedSchema.properties === "object" && requestedSchema.properties
+          ? requestedSchema.properties as Record<string, unknown>
+          : null;
+        if (!properties) {
+          return [{
+            id: "elicitation_answer",
+            header: "Question",
+            question: message,
+            allowsFreeform: true,
+          }];
+        }
+
+        const entries = Object.entries(properties).flatMap(([propertyKey, rawProperty], index) => {
+          if (!rawProperty || typeof rawProperty !== "object") return [];
+          const property = rawProperty as Record<string, unknown>;
+          const header = typeof property.title === "string" && property.title.trim().length
+            ? property.title.trim()
+            : `Question ${index + 1}`;
+          const enumOptions = Array.isArray(property.enum)
+            ? property.enum.filter((value): value is string => typeof value === "string" && value.trim().length > 0)
+            : [];
+          const itemEnumOptions = property.type === "array"
+            && property.items
+            && typeof property.items === "object"
+            && Array.isArray((property.items as Record<string, unknown>).enum)
+              ? ((property.items as Record<string, unknown>).enum as unknown[])
+                  .filter((value): value is string => typeof value === "string" && value.trim().length > 0)
+              : [];
+          const questionText = typeof property.description === "string" && property.description.trim().length
+            ? property.description.trim()
+            : Object.keys(properties).length === 1
+              ? message
+              : `${message} (${header})`;
+
+          if (enumOptions.length > 0) {
+            return [{
+              id: propertyKey,
+              header,
+              question: questionText,
+              options: enumOptions.map((value) => ({ label: value, value })),
+              allowsFreeform: false,
+            }];
+          }
+
+          if (itemEnumOptions.length > 0) {
+            return [{
+              id: propertyKey,
+              header,
+              question: questionText,
+              multiSelect: true,
+              options: itemEnumOptions.map((value) => ({ label: value, value })),
+              allowsFreeform: false,
+            }];
+          }
+
+          if (property.type === "boolean") {
+            return [{
+              id: propertyKey,
+              header,
+              question: questionText,
+              options: [
+                { label: "Yes", value: "true" },
+                { label: "No", value: "false" },
+              ],
+              allowsFreeform: false,
+            }];
+          }
+
+          return [{
+            id: propertyKey,
+            header,
+            question: questionText,
+            allowsFreeform: true,
+          }];
+        });
+
+        return entries.length > 0
+          ? entries
+          : [{
+              id: "elicitation_answer",
+              header: "Question",
+              question: message,
+              allowsFreeform: true,
+            }];
+      };
+
+      const questions = inferQuestionsFromSchema();
+
+      const request: PendingInputRequest = {
+        requestId: String(id),
+        itemId,
+        source: "codex",
+        kind: "structured_question",
+        title: `Question from ${serverName}`,
+        description: questions[0]?.question ?? message,
+        questions,
+        allowsFreeform: true,
+        blocking: true,
+        canProceedWithoutAnswer: false,
+        providerMetadata: requestedSchema ? { serverName, requestedSchema } : { serverName },
+        turnId: typeof params.turnId === "string" ? params.turnId : runtime.activeTurnId ?? null,
+      };
+      runtime.approvals.set(itemId, {
+        requestId: id,
+        kind: "structured_question",
+        request,
+        questionResponseKind: "mcp_elicitation",
+      });
+      emitPendingInputRequest(managed, request, {
+        kind: "tool_call",
+        description: message,
+      });
       return;
     }
 
     runtime.sendError(id, `Unsupported server request: ${method || "unknown"}`);
   };
 
+  const parseCodexPlanPayload = (
+    value: unknown,
+  ): { steps: Array<{ text: string; status: "pending" | "in_progress" | "completed" | "failed" }>; explanation: string | null } | null => {
+    const record = (() => {
+      if (typeof value !== "string") return asRecord(value);
+      try {
+        return asRecord(JSON.parse(value));
+      } catch {
+        return null;
+      }
+    })();
+    if (!record) return null;
+
+    const rawPlan = Array.isArray(record.plan)
+      ? record.plan
+      : Array.isArray(record.steps)
+        ? record.steps
+        : null;
+    if (!rawPlan) return null;
+
+    const steps = rawPlan
+      .map((step) => {
+        const entry = asRecord(step);
+        if (!entry) return null;
+        const text = typeof entry.step === "string"
+          ? entry.step
+          : typeof entry.text === "string"
+            ? entry.text
+            : typeof entry.description === "string"
+              ? entry.description
+              : "";
+        const normalizedText = text.trim();
+        if (!normalizedText.length) return null;
+        const rawStatus = typeof entry.status === "string" ? entry.status : "pending";
+        return {
+          text: normalizedText,
+          status: PLAN_STEP_STATUS_MAP[rawStatus] ?? "pending",
+        };
+      })
+      .filter((entry): entry is { text: string; status: "pending" | "in_progress" | "completed" | "failed" } => entry != null);
+
+    if (!steps.length) return null;
+
+    return {
+      steps,
+      explanation: typeof record.explanation === "string" && record.explanation.trim().length
+        ? record.explanation
+        : null,
+    };
+  };
+
+  const emitCodexPlanUpdate = (
+    managed: ManagedChatSession,
+    runtime: CodexRuntime,
+    payload: unknown,
+    turnId: string | undefined,
+  ): boolean => {
+    const normalized = parseCodexPlanPayload(payload);
+    if (!normalized) return false;
+
+    emitChatEvent(managed, {
+      type: "plan",
+      steps: normalized.steps,
+      ...(turnId ? { turnId } : {}),
+      explanation: normalized.explanation,
+    });
+
+    if (managed.session.permissionMode !== "plan") {
+      return true;
+    }
+
+    const allPending = normalized.steps.every((step) => step.status === "pending");
+    if (!allPending) {
+      return true;
+    }
+
+    const planSummary = normalized.steps.map((step, index) => `${index + 1}. ${step.text}`).join("\n");
+    const hasExistingApproval = [...runtime.approvals.values()].some((pending) =>
+      pending.kind === "plan_approval"
+      && (
+        (turnId && (pending.request?.turnId ?? null) === turnId)
+        || pending.request?.description === planSummary
+      ),
+    );
+    if (hasExistingApproval) {
+      return true;
+    }
+
+    const planApprovalItemId = randomUUID();
+    const request: PendingInputRequest = {
+      requestId: planApprovalItemId,
+      itemId: planApprovalItemId,
+      source: "codex",
+      kind: "plan_approval",
+      title: "Plan Ready for Review",
+      description: planSummary,
+      questions: [{
+        id: "plan_decision",
+        header: "Implementation Plan",
+        question: planSummary,
+        options: [
+          { label: "Approve & Implement", value: "approve", recommended: true },
+          { label: "Reject & Revise", value: "reject" },
+        ],
+        allowsFreeform: true,
+      }],
+      allowsFreeform: true,
+      blocking: true,
+      canProceedWithoutAnswer: false,
+      providerMetadata: { tool: "codexPlanApproval" },
+      turnId: turnId ?? runtime.activeTurnId ?? null,
+    };
+    runtime.approvals.set(planApprovalItemId, {
+      requestId: planApprovalItemId,
+      kind: "plan_approval",
+      request,
+    });
+    emitPendingInputRequest(managed, request, {
+      kind: "tool_call",
+      description: "Plan ready for approval",
+      detail: { planContent: planSummary },
+    });
+    return true;
+  };
+
   const handleCodexItemEvent = (
     managed: ManagedChatSession,
     runtime: CodexRuntime,
@@ -7576,6 +8439,9 @@ export function createAgentChatService(args: {
     // dynamicToolCall items → tool_call/tool_result events
     if (itemType === "dynamicToolCall") {
       const toolName = String(item.tool ?? "dynamic_tool");
+      if (toolName === "update_plan" && eventKind === "started") {
+        emitCodexPlanUpdate(managed, runtime, item.arguments, turnId);
+      }
       if (eventKind === "started") {
         emitChatEvent(managed, {
           type: "activity",
@@ -7720,6 +8586,7 @@ export function createAgentChatService(args: {
       const status = mapCodexTurnStatus(turn?.status);
       const usage = normalizeUsagePayload(turn?.usage ?? turn?.totalUsage);
       managed.session.status = "idle";
+      runtime.approvals.clear();
 
       if (status === "failed" && turn?.error?.message) {
         emitChatEvent(managed, {
@@ -7882,73 +8749,15 @@ export function createAgentChatService(args: {
     }
 
     if (method === "turn/plan/updated") {
-      const plan = Array.isArray(params.plan) ? params.plan : [];
-      const steps = plan
-        .map((step) => {
-          if (!step || typeof step !== "object") return null;
-          const record = step as { step?: unknown; status?: unknown };
-          const text = typeof record.step === "string" ? record.step : "";
-          if (!text) return null;
-          const rawStatus = typeof record.status === "string" ? record.status : "pending";
-          const mappedStatus = PLAN_STEP_STATUS_MAP[rawStatus] ?? "pending";
-          return {
-            text,
-            status: mappedStatus
-          };
-        })
-        .filter((entry): entry is { text: string; status: "pending" | "in_progress" | "completed" | "failed" } => entry != null);
-
-      emitChatEvent(managed, {
-        type: "plan",
-        steps,
-        turnId: typeof params.turnId === "string" ? params.turnId : undefined,
-        explanation: typeof params.explanation === "string" ? params.explanation : null
-      });
-
-      // Emit plan approval request when the session is in plan mode and a
-      // complete plan has been proposed (all steps still pending = freshly created).
-      if (managed.session.permissionMode === "plan" && steps.length > 0) {
-        const allPending = steps.every((s) => s.status === "pending");
-        if (allPending) {
-          const planSummary = steps.map((s, i) => `${i + 1}. ${s.text}`).join("\n");
-          const planApprovalItemId = randomUUID();
-          const planTurnId = typeof params.turnId === "string" ? params.turnId : runtime.activeTurnId ?? undefined;
-          const request: PendingInputRequest = {
-            requestId: planApprovalItemId,
-            itemId: planApprovalItemId,
-            source: "codex",
-            kind: "plan_approval",
-            title: "Plan Ready for Review",
-            description: planSummary,
-            questions: [{
-              id: "plan_decision",
-              header: "Implementation Plan",
-              question: planSummary,
-              options: [
-                { label: "Approve & Implement", value: "approve", recommended: true },
-                { label: "Reject & Revise", value: "reject" },
-              ],
-              allowsFreeform: true,
-            }],
-            allowsFreeform: true,
-            blocking: true,
-            canProceedWithoutAnswer: false,
-            providerMetadata: { tool: "codexPlanApproval" },
-            turnId: planTurnId ?? null,
-          };
-          runtime.approvals.set(planApprovalItemId, {
-            requestId: planApprovalItemId,
-            kind: "plan_approval",
-            request,
-          });
-          emitPendingInputRequest(managed, request, {
-            kind: "tool_call",
-            description: "Plan ready for approval",
-            detail: { planContent: planSummary },
-          });
-        }
-      }
-
+      emitCodexPlanUpdate(
+        managed,
+        runtime,
+        {
+          plan: Array.isArray(params.plan) ? params.plan : [],
+          explanation: typeof params.explanation === "string" ? params.explanation : null,
+        },
+        typeof params.turnId === "string" ? params.turnId : runtime.activeTurnId ?? undefined,
+      );
       return;
     }
 
@@ -7993,6 +8802,7 @@ export function createAgentChatService(args: {
       runtime.agentMessageScopeByTurn.clear();
       runtime.agentMessageTextByTurn.clear();
       runtime.recentNotificationKeys.clear();
+      runtime.approvals.clear();
       managed.session.status = "idle";
       emitChatEvent(managed, {
         type: "status",
@@ -8194,12 +9004,15 @@ export function createAgentChatService(args: {
       fileChangesByItemId: new Map<string, Array<{ path: string; kind: "create" | "modify" | "delete" }>>(),
       agentMessageScopeByTurn: new Map<string, "item" | "turn">(),
       agentMessageTextByTurn: new Map<string, string>(),
-      recentNotificationKeys: new Set<string>(),
-      slashCommands: [],
-      rateLimits: null,
-      request: async <T = unknown>(method: string, params?: unknown): Promise<T> => {
-        const id = runtime.nextRequestId;
-        runtime.nextRequestId += 1;
+    recentNotificationKeys: new Set<string>(),
+    slashCommands: [],
+    rateLimits: null,
+    collaborationModes: null,
+    collaborationModesReady: null,
+    planModeFallbackNotified: false,
+    request: async <T = unknown>(method: string, params?: unknown): Promise<T> => {
+      const id = runtime.nextRequestId;
+      runtime.nextRequestId += 1;
 
         const payload: JsonRpcEnvelope = {
           jsonrpc: "2.0",
@@ -8301,16 +9114,11 @@ export function createAgentChatService(args: {
       runtime.suppressExitError = true;
 
       if (managed.closed || managed.session.status === "ended") return;
-
-      emitChatEvent(managed, {
-        type: "error",
+      keepChatSessionOpen(managed, {
         message,
+        turnId: runtime.activeTurnId,
+        ...(runtime.activeTurnId ? { turnStatus: "failed" as const } : {}),
       });
-
-      void finishSession(managed, "failed", {
-        exitCode: null,
-        summary: message,
-      }).catch(() => {});
     });
 
     proc.on("exit", (code, signal) => {
@@ -8329,16 +9137,11 @@ export function createAgentChatService(args: {
 
       if (runtime.suppressExitError) return;
       if (managed.closed || managed.session.status === "ended") return;
-
-      emitChatEvent(managed, {
-        type: "error",
-        message
+      keepChatSessionOpen(managed, {
+        message,
+        turnId: runtime.activeTurnId,
+        ...(runtime.activeTurnId ? { turnStatus: "failed" as const } : {}),
       });
-
-      void finishSession(managed, "failed", {
-        summary: message,
-        exitCode: code ?? null
-      }).catch(() => {});
     });
 
     await runtime.request("initialize", {
@@ -8352,6 +9155,23 @@ export function createAgentChatService(args: {
       }
     });
 
+    const collaborationModesRequest = runtime.request<unknown>("collaborationMode/list", {})
+      .then((res) => {
+        const modes = parseCodexCollaborationModes(res);
+        if (modes) {
+          runtime.collaborationModes = modes;
+        }
+      })
+      .catch(() => { /* collaborationMode/list not supported — ignore */ });
+    runtime.collaborationModesReady = Promise.race([
+      collaborationModesRequest,
+      new Promise<void>((resolve) => {
+        const timer = setTimeout(resolve, DEFAULT_COLLABORATION_MODES_LIST_TIMEOUT_MS);
+        timer.unref?.();
+        collaborationModesRequest.finally(() => clearTimeout(timer)).catch(() => {});
+      }),
+    ]).then(() => undefined);
+
     runtime.notify("initialized");
     return runtime;
   };
@@ -8482,6 +9302,11 @@ export function createAgentChatService(args: {
       pathToClaudeCodeExecutable: claudeExecutable.path,
     };
     if (!lightweight) {
+      opts.toolConfig = {
+        askUserQuestion: {
+          previewFormat: "markdown",
+        },
+      };
       opts.systemPrompt = {
         type: "preset",
         preset: "claude_code",
@@ -8575,6 +9400,7 @@ export function createAgentChatService(args: {
             // Race: user clicks "Done" OR elicitation_complete arrives
             let userResponse: { decision?: AgentChatApprovalDecision };
             try {
+              runtime.pauseIdleWatchdog?.();
               userResponse = await Promise.race([
                 new Promise<{ decision?: AgentChatApprovalDecision }>((resolve) => {
                   runtime.approvals.set(approvalItemId, { kind: "approval", resolve, request });
@@ -8584,6 +9410,7 @@ export function createAgentChatService(args: {
             } finally {
               runtime.approvals.delete(approvalItemId);
               runtime.pendingElicitations.delete(elicitReq.elicitationId);
+              runtime.resumeIdleWatchdog?.();
             }
             if (userResponse.decision === "cancel" || userResponse.decision === "decline") {
               return { action: "cancel" };
@@ -8594,11 +9421,13 @@ export function createAgentChatService(args: {
           // No elicitationId — just wait for user click
           let elicitResponse: { decision?: AgentChatApprovalDecision };
           try {
+            runtime.pauseIdleWatchdog?.();
             elicitResponse = await new Promise<typeof elicitResponse>((resolve) => {
               runtime.approvals.set(approvalItemId, { kind: "approval", resolve, request });
             });
           } finally {
             runtime.approvals.delete(approvalItemId);
+            runtime.resumeIdleWatchdog?.();
           }
           return elicitResponse.decision === "cancel" || elicitResponse.decision === "decline"
             ? { action: "cancel" }
@@ -8653,11 +9482,13 @@ export function createAgentChatService(args: {
 
         let formResponse: { decision?: AgentChatApprovalDecision; answers?: Record<string, string | string[]>; responseText?: string | null };
         try {
+          runtime.pauseIdleWatchdog?.();
           formResponse = await new Promise<typeof formResponse>((resolve) => {
             runtime.approvals.set(approvalItemId, { kind: "approval", resolve, request });
           });
         } finally {
           runtime.approvals.delete(approvalItemId);
+          runtime.resumeIdleWatchdog?.();
         }
 
         if (formResponse.decision === "cancel" || formResponse.decision === "decline") {
@@ -8674,13 +9505,15 @@ export function createAgentChatService(args: {
         return { action: "accept", content };
       };
 
-      // Enable MCP tool search for sessions with many MCP tools.
+      // Enable MCP tool search for non-CTO sessions with many MCP tools.
       // When enabled, the SDK defers tool definitions and loads them on-demand
       // via the ToolSearch tool, keeping the context window lean.
+      // CTO sessions disable deferral so operator tools (spawnChat, gitCommit, etc.)
+      // are always visible without needing ToolSearch.
       opts.env = {
         ...process.env as Record<string, string>,
         ...opts.env as Record<string, string> | undefined,
-        ENABLE_TOOL_SEARCH: "auto",
+        ENABLE_TOOL_SEARCH: managed.session.identityKey === "cto" ? "0" : "auto",
       };
     }
     const claudeDescriptor = resolveSessionModelDescriptor(managed.session);
@@ -8790,7 +9623,6 @@ export function createAgentChatService(args: {
         try { runtime.v2Session?.close(); } catch { /* ignore */ }
         runtime.v2Session = null;
         runtime.v2WarmupDone = null;
-        runtime.sdkSessionId = null;
         emitChatEvent(managed, {
           type: "system_notice",
           noticeKind: "info",
@@ -9115,6 +9947,7 @@ export function createAgentChatService(args: {
       turnMemoryPolicyState: null,
       approvalOverrides: new Set<string>(persisted?.approvalOverrides ?? []),
       pendingElicitations: new Map<string, () => void>(),
+      resolvedToolUseIds: new Set<string>(),
     };
     managed.runtime = runtime;
     managed.runtimeInvalidated = false;
@@ -11004,6 +11837,7 @@ export function createAgentChatService(args: {
 
     if (managed.session.provider === "codex") {
       const runtime = await ensureCodexSessionRuntime(managed);
+      await runtime.collaborationModesReady?.catch(() => {});
       if (!managed.session.threadId || !runtime.activeTurnId) {
         throw new Error("No active turn to steer.");
       }
@@ -11134,6 +11968,7 @@ export function createAgentChatService(args: {
 
     if (managed.session.provider === "codex") {
       const runtime = await ensureCodexSessionRuntime(managed);
+      await runtime.collaborationModesReady?.catch(() => {});
       if (!managed.session.threadId || !runtime.activeTurnId) return;
       await runtime.request("turn/interrupt", {
         threadId: managed.session.threadId,
@@ -11454,16 +12289,6 @@ export function createAgentChatService(args: {
     const canonicalExisting = args.reuseExisting === false
       ? null
       : identitySessions.find((entry) => entry.laneId === canonicalLaneId) ?? null;
-    const legacySessions = identitySessions.filter((entry) => entry.laneId !== canonicalLaneId && entry.status !== "ended");
-
-    const retireLegacySessions = async (): Promise<void> => {
-      for (const legacy of legacySessions) {
-        const legacyManaged = ensureManagedSession(legacy.sessionId);
-        await finishSession(legacyManaged, "disposed", {
-          summary: "Superseded by the canonical primary-hosted identity session.",
-        });
-      }
-    };
 
     const preferred = canonicalExisting;
     if (preferred) {
@@ -11483,7 +12308,6 @@ export function createAgentChatService(args: {
       refreshReconstructionContext(managed, { includeConversationTail: usesIdentityContinuity(managed) });
       await refreshHeadShaStartForManagedExecutionLane(managed);
       persistChatState(managed);
-      await retireLegacySessions();
 
       if (managed.session.status === "ended") {
         await resumeSession({ sessionId: managed.session.id });
@@ -11550,7 +12374,6 @@ export function createAgentChatService(args: {
     refreshReconstructionContext(managed, { includeConversationTail: usesIdentityContinuity(managed) });
     await refreshHeadShaStartForManagedExecutionLane(managed);
     persistChatState(managed);
-    await retireLegacySessions();
     return managed.session;
   };
 
@@ -11562,25 +12385,52 @@ export function createAgentChatService(args: {
     responseText,
   }: AgentChatRespondToInputArgs): Promise<void> => {
     const managed = ensureManagedSession(sessionId);
+    const resolvedDecision: AgentChatApprovalDecision = decision ?? "decline";
     const localPending = managed.localPendingInputs.get(itemId);
     if (localPending) {
       managed.localPendingInputs.delete(itemId);
-      localPending.resolve({ decision, answers, responseText });
+      localPending.resolve({ decision: resolvedDecision, answers, responseText });
+      emitPendingInputResolved(managed, {
+        itemId,
+        decision: resolvedDecision,
+        turnId: localPending.request.turnId ?? null,
+      });
       return;
     }
 
     if (managed.runtime?.kind === "codex") {
-      const pending = managed.runtime.approvals.get(itemId);
+      const runtime = managed.runtime;
+      const pending = runtime.approvals.get(itemId);
       if (!pending) {
-        throw new Error(`No pending approval found for item '${itemId}'.`);
+        logger.warn("agent_chat.codex_approval_not_found", {
+          sessionId,
+          itemId,
+          decision: resolvedDecision,
+        });
+        emitPendingInputResolved(managed, {
+          itemId,
+          decision: resolvedDecision === "accept" || resolvedDecision === "accept_for_session" ? "cancel" : resolvedDecision,
+          turnId: null,
+        });
+        emitChatEvent(managed, {
+          type: "system_notice",
+          noticeKind: "info",
+          message: "That request is no longer active.",
+        });
+        persistChatState(managed);
+        return;
       }
-      managed.runtime.approvals.delete(itemId);
+      const ensureWritable = (): void => {
+        if (!runtime.process.stdin.writable) {
+          throw new Error("Codex app-server connection is unavailable. Retry after the session reconnects.");
+        }
+      };
 
       // Plan approval is created locally (not a JSON-RPC server request).
       // On approve, send a follow-up turn telling Codex to implement.
       // On reject, send feedback for revision.
       if (pending.kind === "plan_approval") {
-        const approved = decision === "accept" || decision === "accept_for_session";
+        const approved = resolvedDecision === "accept" || resolvedDecision === "accept_for_session";
         const feedback = typeof responseText === "string" ? responseText.trim() : "";
         if (approved) {
           // Switch out of plan mode and send implementation steer
@@ -11598,29 +12448,85 @@ export function createAgentChatService(args: {
               : "The user rejected the plan. Please revise your approach.",
           });
         }
+        runtime.approvals.delete(itemId);
+        emitPendingInputResolved(managed, {
+          itemId,
+          decision: resolvedDecision,
+          turnId: pending.request?.turnId ?? null,
+        });
         return;
       }
 
       if (pending.kind === "permissions") {
-        const approved = decision === "accept" || decision === "accept_for_session";
-        managed.runtime.sendResponse(pending.requestId, {
+        const approved = resolvedDecision === "accept" || resolvedDecision === "accept_for_session";
+        ensureWritable();
+        runtime.sendResponse(pending.requestId, {
           permissions: approved ? (pending.permissions ?? {}) : {},
-          scope: decision === "accept_for_session" ? "session" : "turn",
+          scope: resolvedDecision === "accept_for_session" ? "session" : "turn",
+        });
+        runtime.approvals.delete(itemId);
+        emitPendingInputResolved(managed, {
+          itemId,
+          decision: resolvedDecision,
+          turnId: pending.request?.turnId ?? null,
         });
         return;
       }
       if (pending.kind === "structured_question") {
+        if (resolvedDecision === "decline" || resolvedDecision === "cancel") {
+          if (pending.questionResponseKind === "mcp_elicitation") {
+            ensureWritable();
+            runtime.sendResponse(pending.requestId, {
+              action: resolvedDecision === "cancel" ? "cancel" : "decline",
+              content: null,
+            });
+          } else {
+            // Native Codex request_user_input only accepts an answers map.
+            // Empty answers represent a declined/cancelled prompt without
+            // interrupting the surrounding turn.
+            ensureWritable();
+            runtime.sendResponse(pending.requestId, { answers: {} });
+          }
+          runtime.approvals.delete(itemId);
+          emitPendingInputResolved(managed, {
+            itemId,
+            decision: resolvedDecision,
+            turnId: pending.request?.turnId ?? null,
+          });
+          return;
+        }
         const normalizedAnswers = normalizePendingInputAnswers(pending.request, answers, responseText);
-        managed.runtime.sendResponse(pending.requestId, {
-          answers: Object.fromEntries(
-            Object.entries(normalizedAnswers).map(([questionId, values]) => [questionId, { answers: values }]),
-          ),
+        ensureWritable();
+        if (pending.questionResponseKind === "mcp_elicitation") {
+          runtime.sendResponse(pending.requestId, {
+            action: "accept",
+            content: coerceCodexMcpElicitationContent(pending.request, normalizedAnswers),
+          });
+        } else {
+          runtime.sendResponse(pending.requestId, {
+            answers: Object.fromEntries(
+              Object.entries(normalizedAnswers).map(([questionId, values]) => [questionId, { answers: values }]),
+            ),
+          });
+        }
+        runtime.approvals.delete(itemId);
+        emitPendingInputResolved(managed, {
+          itemId,
+          decision: resolvedDecision,
+          turnId: pending.request?.turnId ?? null,
         });
         return;
       }
 
-      const mapped = mapApprovalDecisionForCodex(decision ?? "decline");
-      managed.runtime.sendResponse(pending.requestId, { decision: mapped });
+      const mapped = mapApprovalDecisionForCodex(resolvedDecision);
+      ensureWritable();
+      runtime.sendResponse(pending.requestId, { decision: mapped });
+      runtime.approvals.delete(itemId);
+      emitPendingInputResolved(managed, {
+        itemId,
+        decision: resolvedDecision,
+        turnId: pending.request?.turnId ?? null,
+      });
       return;
     }
 
@@ -11638,7 +12544,12 @@ export function createAgentChatService(args: {
         return;
       }
       managed.runtime.approvals.delete(itemId);
-      pending.resolve({ decision, answers, responseText });
+      pending.resolve({ decision: resolvedDecision, answers, responseText });
+      emitPendingInputResolved(managed, {
+        itemId,
+        decision: resolvedDecision,
+        turnId: pending.request?.turnId ?? null,
+      });
       return;
     }
 
@@ -11647,8 +12558,8 @@ export function createAgentChatService(args: {
       if (!pending) {
         throw new Error(`No pending approval found for item '${itemId}'.`);
       }
-      const approved = decision === "accept" || decision === "accept_for_session";
-      if (decision === "accept_for_session" && pending.category !== "askUser") {
+      const approved = resolvedDecision === "accept" || resolvedDecision === "accept_for_session";
+      if (resolvedDecision === "accept_for_session" && pending.category !== "askUser") {
         managed.runtime.approvalOverrides.add(pending.category);
         if (pending.category === "bash") {
           managed.runtime.permissionMode = "full-auto";
@@ -11664,7 +12575,12 @@ export function createAgentChatService(args: {
       }
       managed.session.permissionMode = syncLegacyPermissionMode(managed.session) ?? managed.session.permissionMode;
       managed.runtime.pendingApprovals.delete(itemId);
-      pending.resolve({ decision, answers, responseText });
+      pending.resolve({ decision: resolvedDecision, answers, responseText });
+      emitPendingInputResolved(managed, {
+        itemId,
+        decision: resolvedDecision,
+        turnId: pending.request?.turnId ?? null,
+      });
       return;
     }
 
@@ -11679,11 +12595,32 @@ export function createAgentChatService(args: {
         });
         return;
       }
-      pending.resolve(mapChatDecisionToCursorPermission(decision, pending.options, answers));
+      managed.runtime.permissionWaiters.delete(itemId);
+      pending.resolve(mapChatDecisionToCursorPermission(resolvedDecision, pending.options, answers));
+      emitPendingInputResolved(managed, {
+        itemId,
+        decision: resolvedDecision,
+        turnId: managed.runtime.activeTurnId ?? null,
+      });
       return;
     }
 
-    throw new Error(`Session '${sessionId}' does not have a live runtime for approvals.`);
+    logger.warn("agent_chat.approval_without_live_runtime", {
+      sessionId,
+      itemId,
+      decision: resolvedDecision,
+    });
+    emitPendingInputResolved(managed, {
+      itemId,
+      decision: resolvedDecision === "accept" || resolvedDecision === "accept_for_session" ? "cancel" : resolvedDecision,
+      turnId: null,
+    });
+    emitChatEvent(managed, {
+      type: "system_notice",
+      noticeKind: "info",
+      message: "That request is no longer active.",
+    });
+    persistChatState(managed);
   };
 
   const approveToolUse = async ({
@@ -12259,8 +13196,8 @@ export function createAgentChatService(args: {
     attachments = [],
     reasoningEffort,
     executionMode,
-    timeoutMs = 300_000,
-  }: AgentChatSendArgs & { timeoutMs?: number }): Promise<{
+    timeoutMs,
+  }: AgentChatSendArgs & { timeoutMs?: number | null }): Promise<{
     sessionId: string;
     provider: AgentChatProvider;
     model: string;
@@ -12312,29 +13249,213 @@ export function createAgentChatService(args: {
       };
     }
 
-    const safeTimeoutMs = Math.max(15_000, Math.floor(timeoutMs));
+    const normalizedTimeoutMs = timeoutMs === undefined
+      ? DEFAULT_RUN_SESSION_TURN_TIMEOUT_MS
+      : timeoutMs == null || Number(timeoutMs) === 0
+        ? null
+        : Number.isFinite(Number(timeoutMs)) && Number(timeoutMs) > 0
+          ? Math.max(15_000, Math.floor(Number(timeoutMs)))
+          : DEFAULT_RUN_SESSION_TURN_TIMEOUT_MS;
     return await new Promise((resolve, reject) => {
-      const timeout = setTimeout(() => {
-        sessionTurnCollectors.delete(sessionId);
-        reject(new Error(`Timed out waiting for session '${sessionId}' to finish the current turn.`));
-      }, safeTimeoutMs);
-
-      sessionTurnCollectors.set(sessionId, {
+      const collector: SessionTurnCollector = {
         resolve,
         reject,
         outputText: "",
         lastError: null,
-        timeout,
-      });
+        timeout: null,
+      };
+
+      if (normalizedTimeoutMs != null) {
+        collector.timeout = setTimeout(() => {
+          if (sessionTurnCollectors.get(sessionId) !== collector) return;
+          sessionTurnCollectors.delete(sessionId);
+          void interrupt({ sessionId }).catch((interruptError) => {
+            logger.warn("agent_chat.run_session_turn_timeout_interrupt_failed", {
+              sessionId,
+              error: interruptError instanceof Error ? interruptError.message : String(interruptError),
+            });
+          });
+          reject(new Error(
+            `Timed out waiting for session '${sessionId}' to finish the current turn. The turn was interrupted, but the chat stayed open.`,
+          ));
+        }, normalizedTimeoutMs);
+      }
+
+      sessionTurnCollectors.set(sessionId, collector);
 
       void executePreparedSendMessage(prepared).catch((error) => {
-        clearTimeout(timeout);
-        sessionTurnCollectors.delete(sessionId);
+        if (collector.timeout) {
+          clearTimeout(collector.timeout);
+        }
+        if (sessionTurnCollectors.get(sessionId) === collector) {
+          sessionTurnCollectors.delete(sessionId);
+        }
         reject(error instanceof Error ? error : new Error(String(error)));
       });
     });
   };
 
+  /**
+   * Create a blocking pending-input request for a chat session (used by MCP ask_user
+   * when no missionId is available).  Returns the user's answer.
+   */
+  const requestChatInput = async (args: {
+    chatSessionId: string;
+    title: string;
+    body: string;
+    questions?: Array<{
+      id?: string;
+      header?: string;
+      question: string;
+      options?: Array<{
+        label: string;
+        value?: string;
+        description?: string;
+        recommended?: boolean;
+        preview?: string;
+        previewFormat?: string;
+      }>;
+      multiSelect?: boolean;
+      allowsFreeform?: boolean;
+      isSecret?: boolean;
+      defaultAssumption?: string | null;
+      impact?: string | null;
+    }>;
+  }): Promise<{ decision: string; answers: Record<string, string[]>; responseText: string | null }> => {
+    const inferQuestionsFromBody = (bodyText: string): PendingInputQuestion[] | null => {
+      const normalizedBody = bodyText.replace(/\r/g, "").trim();
+      if (!normalizedBody.length) return null;
+
+      const buildStructuredQuestion = (
+        prompt: string,
+        options: Array<{ label: string; value: string }>,
+      ): PendingInputQuestion[] | null => {
+        const question = prompt.trim().replace(/\s+/g, " ");
+        const normalizedOptions = options
+          .map((option) => ({
+            label: option.label.trim(),
+            value: option.value.trim(),
+          }))
+          .filter((option) => option.label.length > 0 && option.value.length > 0);
+        if (!question.length || normalizedOptions.length < 2) return null;
+        return [{
+          id: "answer",
+          header: "Question 1",
+          question,
+          options: normalizedOptions,
+          allowsFreeform: true,
+        }];
+      };
+
+      const optionLinePattern = /^(?:[-*]\s*)?([0-9A-Za-z]+)[.)]\s+(.+)$/;
+      const nonEmptyLines = normalizedBody
+        .split("\n")
+        .map((line) => line.trim())
+        .filter((line) => line.length > 0);
+      const firstOptionLineIndex = nonEmptyLines.findIndex((line) => optionLinePattern.test(line));
+      if (firstOptionLineIndex >= 1) {
+        const prompt = nonEmptyLines.slice(0, firstOptionLineIndex).join(" ");
+        const options = nonEmptyLines.slice(firstOptionLineIndex).flatMap((line) => {
+          const match = line.match(optionLinePattern);
+          if (!match) return [];
+          return [{
+            value: match[1]!.trim(),
+            label: match[2]!.trim(),
+          }];
+        });
+        const inferred = buildStructuredQuestion(prompt, options);
+        if (inferred) return inferred;
+      }
+
+      const optionMarkerPattern = /([0-9A-Za-z]+)[.)]\s+/g;
+      const markers = Array.from(normalizedBody.matchAll(optionMarkerPattern));
+      if (markers.length < 2) return null;
+      const firstMarker = markers[0];
+      if (!firstMarker || firstMarker.index == null || firstMarker.index <= 0) return null;
+
+      const prompt = normalizedBody.slice(0, firstMarker.index).trim();
+      const options = markers.flatMap((match, index) => {
+        const start = (match.index ?? 0) + match[0].length;
+        const end = index + 1 < markers.length
+          ? (markers[index + 1]?.index ?? normalizedBody.length)
+          : normalizedBody.length;
+        const rawLabel = normalizedBody
+          .slice(start, end)
+          .replace(/\s+(?:Reply|Respond|Choose|Select|Pick|Answer)\b[\s\S]*$/i, "")
+          .trim();
+        if (!rawLabel.length) return [];
+        return [{
+          value: match[1]!.trim(),
+          label: rawLabel,
+        }];
+      });
+      return buildStructuredQuestion(prompt, options);
+    };
+
+    const managed = ensureManagedSession(args.chatSessionId);
+    const itemId = randomUUID();
+    const fallbackQuestions = inferQuestionsFromBody(args.body) ?? [{ id: "answer", header: "Question 1", question: args.body, allowsFreeform: true }];
+    const requestedQuestions = args.questions?.length ? args.questions : fallbackQuestions;
+    const questions: PendingInputQuestion[] = requestedQuestions.map(
+      (q, i) => ({
+        id: q.id ?? `q_${i + 1}`,
+        header: q.header?.trim().length ? q.header.trim() : `Question ${i + 1}`,
+        question: q.question.trim(),
+        ...(q.multiSelect === true ? { multiSelect: true } : {}),
+        ...(q.allowsFreeform !== undefined ? { allowsFreeform: q.allowsFreeform } : { allowsFreeform: true }),
+        ...(q.isSecret === true ? { isSecret: true } : {}),
+        ...(typeof q.defaultAssumption === "string" && q.defaultAssumption.trim().length
+          ? { defaultAssumption: q.defaultAssumption.trim() }
+          : {}),
+        ...(typeof q.impact === "string" && q.impact.trim().length
+          ? { impact: q.impact.trim() }
+          : {}),
+        ...(q.options?.length ? {
+          options: q.options.map((o) => ({
+            label: o.label,
+            value: o.value ?? o.label,
+            ...(typeof o.description === "string" && o.description.trim().length ? { description: o.description.trim() } : {}),
+            ...(o.recommended === true ? { recommended: true } : {}),
+            ...(typeof o.preview === "string" && o.preview.trim().length ? { preview: o.preview } : {}),
+            ...(o.previewFormat === "markdown" || o.previewFormat === "html" ? { previewFormat: o.previewFormat } : {}),
+          })),
+        } : {}),
+      }),
+    );
+    const request: PendingInputRequest = {
+      requestId: itemId,
+      itemId,
+      source: "ade",
+      kind: questions.some((q) => q.options?.length) ? "structured_question" : "question",
+      title: args.title,
+      description: questions[0]?.question ?? args.body,
+      questions,
+      allowsFreeform: true,
+      blocking: true,
+      canProceedWithoutAnswer: false,
+      turnId: managed.runtime?.activeTurnId ?? null,
+    };
+
+    const response = await new Promise<{
+      decision?: AgentChatApprovalDecision;
+      answers?: Record<string, string | string[]>;
+      responseText?: string | null;
+    }>((resolve) => {
+      managed.localPendingInputs.set(itemId, { request, resolve });
+      emitPendingInputRequest(managed, request, {
+        kind: "tool_call",
+        description: request.description ?? args.body,
+      });
+    });
+
+    const normalizedAnswers = normalizePendingInputAnswers(request, response.answers, response.responseText);
+    return {
+      decision: response.decision ?? "none",
+      answers: normalizedAnswers,
+      responseText: typeof response.responseText === "string" ? response.responseText : null,
+    };
+  };
+
   return {
     createSession,
     handoffSession,
@@ -12351,6 +13472,7 @@ export function createAgentChatService(args: {
     ensureIdentitySession,
     approveToolUse,
     respondToInput,
+    requestChatInput,
     getAvailableModels,
     getSlashCommands,
     codexFuzzyFileSearch,
diff --git a/apps/desktop/src/main/services/cto/ctoStateService.test.ts b/apps/desktop/src/main/services/cto/ctoStateService.test.ts
index 3792a2fc0..d023d4c34 100644
--- a/apps/desktop/src/main/services/cto/ctoStateService.test.ts
+++ b/apps/desktop/src/main/services/cto/ctoStateService.test.ts
@@ -543,17 +543,25 @@ describe("ctoStateService", () => {
     });
 
     const preview = service.previewSystemPrompt();
-    expect(preview.sections.map((section) => section.id)).toEqual(["doctrine", "personality", "memory", "capabilities"]);
+    expect(preview.sections.map((section) => section.id)).toEqual(["doctrine", "personality", "memory", "knowledge", "capabilities"]);
     expect(preview.sections[0]?.content).toContain("You are the CTO for the current project inside ADE.");
     expect(preview.sections[1]?.content).toContain("Operate as a strategic CTO.");
     expect(preview.sections[2]?.content).toContain("Immutable doctrine");
     expect(preview.sections[2]?.content).toContain("Use memoryUpdateCore only when the standing project brief changes");
     expect(preview.sections[2]?.content).toContain("Do not write ephemeral turn-by-turn status");
-    expect(preview.sections[3]?.content).toContain("ADE operator capability manifest");
-    expect(preview.sections[3]?.content).toContain("UI navigation is suggestion-only.");
+    // Knowledge section: ADE environment glossary, chat vs terminal disambiguation, task routing
+    expect(preview.sections[3]?.content).toContain("ADE environment glossary");
+    expect(preview.sections[3]?.content).toContain("spawnChat");
+    expect(preview.sections[3]?.content).toContain("createTerminal");
+    expect(preview.sections[3]?.content).toContain("spawn_agent is an MCP tool");
+    // Capabilities section: concrete tool list
+    expect(preview.sections[4]?.content).toContain("ADE operator tools");
+    expect(preview.sections[4]?.content).toContain("listLanes, inspectLane, createLane");
+    expect(preview.sections[4]?.content).toContain("UI navigation is suggestion-only.");
     expect(preview.prompt).toContain("Immutable ADE doctrine");
     expect(preview.prompt).toContain("Selected personality overlay");
-    expect(preview.prompt).toContain("ADE operator capability manifest");
+    expect(preview.prompt).toContain("ADE environment knowledge");
+    expect(preview.prompt).toContain("ADE operator tools");
 
     fixture.db.close();
   });
diff --git a/apps/desktop/src/main/services/cto/ctoStateService.ts b/apps/desktop/src/main/services/cto/ctoStateService.ts
index 4a05dce27..d52ff559c 100644
--- a/apps/desktop/src/main/services/cto/ctoStateService.ts
+++ b/apps/desktop/src/main/services/cto/ctoStateService.ts
@@ -96,15 +96,65 @@ const CTO_MEMORY_OPERATING_MODEL = [
   "- Distill important session context before compaction removes detail, but persist only durable insights.",
 ].join("\n");
 
+const CTO_ENVIRONMENT_KNOWLEDGE = [
+  "ADE environment glossary:",
+  "- Lane: a git worktree with its own branch, directory, processes, and chat sessions. Lanes isolate parallel work streams. Tools: listLanes, inspectLane, createLane, deleteLane.",
+  "- Native ADE chat: a persistent chat session in the ADE UI with streaming, tool approval, and full service integration. Created with spawnChat. NOT a terminal.",
+  "- PTY terminal: a shell terminal session (may run any CLI command). Created with createTerminal. Indirect tool access, no ADE service integration.",
+  "- Mission: a structured task unit with runs, steps, and workers. Can be launched, steered, paused, and observed. Tools: startMission, launchMissionRun, steerMission, getMissionStatus.",
+  "- Worker: a named agent instance (engineer, QA, researcher) that runs in a lane executing missions or tasks. Tools: listWorkers, createWorker, wakeWorker, getWorkerStatus.",
+  "- Convergence: ADE's PR merge pipeline with automated validation, issue detection, and iterative resolution rounds. Tools: getPullRequestConvergence, startPullRequestConvergenceRound.",
+  "- Conflict resolution: ADE can predict, simulate, propose, and apply merge conflict resolutions. Tools: getConflictStatus, simulateMerge, requestConflictProposal, applyConflictProposal.",
+  "",
+  "Critical distinction — chats vs terminals:",
+  "- To launch a native ADE chat session: call spawnChat({ laneId?, title?, initialPrompt? }) directly. Do NOT use ToolSearch to find it — just call it. This creates a full ADE work chat with UI, streaming, tool approval, and supervision.",
+  "- To open a terminal: call createTerminal({ laneId, title?, startupCommand? }) directly.",
+  "- spawn_agent is an MCP tool for Claude CLI subprocesses in tracked terminals. It is NOT the same as spawnChat. Never use spawn_agent when the user asks for 'a chat' or 'a new session'.",
+  "",
+  "Tool calling convention:",
+  "- ADE tools are available as MCP tools. When you see them in your tool list, they may be prefixed (e.g., mcp__ade__spawnChat). Call them directly by name — do not search for them with ToolSearch.",
+  "- If a tool from the manifest below is not in your immediate tool list, it may still be available. Try calling it directly before concluding it does not exist.",
+  "",
+  "Task routing:",
+  "- 'Start a chat' or 'launch an agent' → spawnChat with an initialPrompt describing the task.",
+  "- 'Check PR status' → getPullRequestStatus or getPullRequestConvergence.",
+  "- 'Start work on [feature]' → create/find a lane, then spawnChat or startMission.",
+  "- 'Open a terminal' → createTerminal.",
+  "- 'Commit and push' → gitCommit then gitPush.",
+  "- 'Check for conflicts' → getConflictStatus or getConflictRiskMatrix.",
+  "- 'Resolve merge conflicts' → getConflictStatus, requestConflictProposal, applyConflictProposal.",
+  "- 'Steer an active agent' → steerChat({ sessionId, instruction }).",
+  "- 'How is the project doing?' → getProjectHealthSummary.",
+  "- 'What happened recently?' → getRecentEvents.",
+  "- 'Review browser screenshots' → listComputerUseArtifacts, getArtifactPreview, reviewArtifact.",
+  "- 'How much are we spending?' → getProjectBudgetStatus or getWorkerCostBreakdown.",
+  "- 'Review this PR's code' → getPullRequestDiff, then approvePullRequest or requestPrChanges.",
+].join("\n");
+
+// Keep in sync with ctoOperatorTools.ts tool registrations
 const CTO_CAPABILITY_MANIFEST = [
-  "ADE operator capability manifest:",
-  "- Work chats: create, list, inspect, read transcripts, send follow-ups, interrupt, and end supervised sessions through ADE services.",
-  "- Lanes: list, inspect, create, and archive lanes, then hand back explicit navigation suggestions for opening them in ADE.",
-  "- Missions: create, inspect, launch, steer, read logs, export context, and route work into mission execution without exposing raw coordinator internals.",
-  "- Run / processes: inspect managed lane processes, start them, stop them, and read bounded log tails through ADE's process service.",
-  "- Pull requests and GitHub: inspect PR state, create PRs from lanes, update PR metadata, and post review-facing comments through stable PR services.",
-  "- Files and context: enumerate workspaces, read files, search text, and export bounded ADE context packs for project, lane, mission, conflict, plan, and feature scopes.",
-  "- Workers and Linear: supervise worker agents, trigger wakeups, inspect workflow runs, and route Linear issues into CTO, mission, or worker paths.",
+  "ADE operator tools (complete list):",
+  "- Lanes: listLanes, inspectLane, createLane, deleteLane",
+  "- Chats: listChats, spawnChat, sendChatMessage, interruptChat, resumeChat, endChat, getChatStatus, getChatTranscript",
+  "- Chat steering: steerChat, cancelSteer, handoffChat, listSubagents, approveToolUse",
+  "- Missions: listMissions, startMission, getMissionStatus, updateMission, launchMissionRun, resolveMissionIntervention, getMissionRunView, getMissionLogs, listMissionWorkerDigests, steerMission",
+  "- Workers: listWorkers, createWorker, updateWorker, removeWorker, updateWorkerStatus, wakeWorker, getWorkerStatus",
+  "- Git: gitStatus, gitCommit, gitPush, gitPull, gitFetch, gitListRecentCommits, gitListBranches, gitCheckoutBranch, gitStashPush, gitStashPop, gitStashList, gitGetConflictState, gitRebaseContinue, gitRebaseAbort, gitMergeAbort",
+  "- PRs: listPullRequests, getPullRequestStatus, commentOnPullRequest, updatePullRequestTitle, updatePullRequestBody, createPrFromLane, landPullRequest, closePullRequest, requestPrReviewers, getPullRequestDiff, approvePullRequest, requestPrChanges",
+  "- Convergence: getPullRequestConvergence, updatePullRequestConvergencePipeline, updatePullRequestConvergenceRuntime, startPullRequestConvergenceRound, stopPullRequestConvergence",
+  "- Conflicts: getConflictStatus, getConflictRiskMatrix, simulateMerge, runConflictPrediction, listConflictProposals, requestConflictProposal, applyConflictProposal, undoConflictProposal",
+  "- Files: listFileWorkspaces, readWorkspaceFile, searchWorkspaceText",
+  "- Context: getContextStatus, generateContextDocs",
+  "- Processes: listManagedProcesses, startManagedProcess, stopManagedProcess, getManagedProcessLog",
+  "- Tests: listTestSuites, runTests, stopTestRun, listTestRuns, getTestLog",
+  "- Terminals: createTerminal",
+  "- Linear: listLinearWorkflows, getLinearRunStatus, resolveLinearRunAction, cancelLinearRun, commentOnLinearIssue, updateLinearIssueState, routeLinearIssueToCto, routeLinearIssueToMission, routeLinearIssueToWorker, rerouteLinearRun, listLinearIssues, getLinearIssue, updateLinearIssueAssignee, addLinearIssueLabel",
+  "- Automations: listAutomations, triggerAutomation, listAutomationRuns",
+  "- Events: getRecentEvents",
+  "- Project health: getProjectHealthSummary",
+  "- Computer use: listComputerUseArtifacts, getArtifactPreview, reviewArtifact",
+  "- Budget: getProjectBudgetStatus, getWorkerCostBreakdown",
+  "- Memory: memorySearch, memoryAdd, memoryUpdateCore, memoryPin, memoryDelete",
   "",
   "Operating rules:",
   "- Internal ADE actions run through service-backed tools even when no renderer click occurs.",
@@ -978,6 +1028,9 @@ export function createCtoStateService(args: CtoStateServiceArgs) {
     sections.push("- Layer 4 — searchable durable project memory. Use memorySearch before non-trivial work and memoryAdd for reusable decisions, conventions, patterns, gotchas, and stable preferences.");
     sections.push("- Memory write policy: use memoryUpdateCore for standing brief changes, use memoryAdd for durable reusable lessons, and skip ephemeral status notes.");
     sections.push("");
+    sections.push("ADE Operational Knowledge");
+    sections.push(CTO_ENVIRONMENT_KNOWLEDGE);
+    sections.push("");
     sections.push("CTO Identity");
     sections.push(`- Name: ${snapshot.identity.name}`);
     sections.push(`- Persona: ${snapshot.identity.persona}`);
@@ -1087,9 +1140,14 @@ export function createCtoStateService(args: CtoStateServiceArgs) {
         title: "Memory and continuity model",
         content: CTO_MEMORY_OPERATING_MODEL,
       },
+      {
+        id: "knowledge",
+        title: "ADE environment knowledge",
+        content: CTO_ENVIRONMENT_KNOWLEDGE,
+      },
       {
         id: "capabilities",
-        title: "ADE operator capability manifest",
+        title: "ADE operator tools",
         content: CTO_CAPABILITY_MANIFEST,
       },
     ];
diff --git a/apps/desktop/src/main/services/git/gitOperationsService.test.ts b/apps/desktop/src/main/services/git/gitOperationsService.test.ts
index df2090841..4d27e7177 100644
--- a/apps/desktop/src/main/services/git/gitOperationsService.test.ts
+++ b/apps/desktop/src/main/services/git/gitOperationsService.test.ts
@@ -14,6 +14,46 @@ vi.mock("./git", () => ({
 
 import { createGitOperationsService } from "./gitOperationsService";
 
+function createTestGitOperationsService(branchRef = "feature/stash-test") {
+  const mockStart = vi.fn().mockReturnValue({ operationId: "op-1" });
+  const mockFinish = vi.fn();
+
+  const service = createGitOperationsService({
+    laneService: {
+      getLaneBaseAndBranch: vi.fn().mockReturnValue({
+        baseRef: "main",
+        branchRef,
+        worktreePath: "/tmp/ade-lane",
+        laneType: "worktree",
+      }),
+    } as any,
+    operationService: {
+      start: mockStart,
+      finish: mockFinish,
+    } as any,
+    projectConfigService: {
+      get: () => ({ effective: { ai: {} } }),
+    } as any,
+    aiIntegrationService: {
+      getFeatureFlag: () => false,
+      getStatus: vi.fn(async () => ({ availableModelIds: [] })),
+      generateCommitMessage: vi.fn(),
+    } as any,
+    logger: {
+      info: vi.fn(),
+      warn: vi.fn(),
+      error: vi.fn(),
+      debug: vi.fn(),
+    } as any,
+  });
+
+  return {
+    service,
+    mockStart,
+    mockFinish,
+  };
+}
+
 describe("gitOperationsService.stashClear", () => {
   beforeEach(() => {
     vi.clearAllMocks();
@@ -22,38 +62,7 @@ describe("gitOperationsService.stashClear", () => {
   it("calls git stash clear with the lane worktree path and returns the action result", async () => {
     mockGit.getHeadSha.mockResolvedValue("abc123");
     mockGit.runGitOrThrow.mockResolvedValue(undefined);
-
-    const mockStart = vi.fn().mockReturnValue({ operationId: "op-1" });
-    const mockFinish = vi.fn();
-
-    const service = createGitOperationsService({
-      laneService: {
-        getLaneBaseAndBranch: vi.fn().mockReturnValue({
-          baseRef: "main",
-          branchRef: "feature/stash-test",
-          worktreePath: "/tmp/ade-lane",
-          laneType: "worktree",
-        }),
-      } as any,
-      operationService: {
-        start: mockStart,
-        finish: mockFinish,
-      } as any,
-      projectConfigService: {
-        get: () => ({ effective: { ai: {} } }),
-      } as any,
-      aiIntegrationService: {
-        getFeatureFlag: () => false,
-        getStatus: vi.fn(async () => ({ availableModelIds: [] })),
-        generateCommitMessage: vi.fn(),
-      } as any,
-      logger: {
-        info: vi.fn(),
-        warn: vi.fn(),
-        error: vi.fn(),
-        debug: vi.fn(),
-      } as any,
-    });
+    const { service, mockStart, mockFinish } = createTestGitOperationsService();
 
     const result = await service.stashClear({ laneId: "lane-1" });
 
@@ -81,6 +90,74 @@ describe("gitOperationsService.stashClear", () => {
   });
 });
 
+describe("gitOperationsService stash item commands", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it("calls git stash pop with the lane worktree path and stash ref", async () => {
+    mockGit.getHeadSha.mockResolvedValue("abc123");
+    mockGit.runGitOrThrow.mockResolvedValue(undefined);
+    const { service, mockStart, mockFinish } = createTestGitOperationsService();
+
+    const result = await service.stashPop({ laneId: "lane-1", stashRef: "stash@{1}" });
+
+    expect(mockGit.runGitOrThrow).toHaveBeenCalledWith(
+      ["stash", "pop", "stash@{1}"],
+      { cwd: "/tmp/ade-lane", timeoutMs: 30_000 },
+    );
+    expect(result).toEqual({
+      operationId: "op-1",
+      preHeadSha: "abc123",
+      postHeadSha: "abc123",
+    });
+    expect(mockStart).toHaveBeenCalledWith(
+      expect.objectContaining({
+        laneId: "lane-1",
+        kind: "git_stash_pop",
+        metadata: expect.objectContaining({ stashRef: "stash@{1}" }),
+      }),
+    );
+    expect(mockFinish).toHaveBeenCalledWith(
+      expect.objectContaining({
+        operationId: "op-1",
+        status: "succeeded",
+      }),
+    );
+  });
+
+  it("calls git stash drop with the lane worktree path and stash ref", async () => {
+    mockGit.getHeadSha.mockResolvedValue("abc123");
+    mockGit.runGitOrThrow.mockResolvedValue(undefined);
+    const { service, mockStart, mockFinish } = createTestGitOperationsService();
+
+    const result = await service.stashDrop({ laneId: "lane-1", stashRef: "stash@{0}" });
+
+    expect(mockGit.runGitOrThrow).toHaveBeenCalledWith(
+      ["stash", "drop", "stash@{0}"],
+      { cwd: "/tmp/ade-lane", timeoutMs: 30_000 },
+    );
+    expect(result).toEqual({
+      operationId: "op-1",
+      preHeadSha: "abc123",
+      postHeadSha: "abc123",
+    });
+    expect(mockStart).toHaveBeenCalledWith(
+      expect.objectContaining({
+        laneId: "lane-1",
+        kind: "git_stash_drop",
+        metadata: expect.objectContaining({ stashRef: "stash@{0}" }),
+      }),
+    );
+    expect(mockFinish).toHaveBeenCalledWith(
+      expect.objectContaining({
+        operationId: "op-1",
+        status: "succeeded",
+      }),
+    );
+  });
+});
+
 describe("gitOperationsService.generateCommitMessage", () => {
   beforeEach(() => {
     vi.clearAllMocks();
diff --git a/apps/desktop/src/main/services/ipc/registerIpc.ts b/apps/desktop/src/main/services/ipc/registerIpc.ts
index c2ee480b6..29c99d9ae 100644
--- a/apps/desktop/src/main/services/ipc/registerIpc.ts
+++ b/apps/desktop/src/main/services/ipc/registerIpc.ts
@@ -11,6 +11,7 @@ import { buildPrAiResolutionContextKey } from "../../../shared/types";
 import { launchPrIssueResolutionChat, previewPrIssueResolutionPrompt } from "../prs/prIssueResolver";
 import { launchRebaseResolutionChat } from "../prs/prRebaseResolver";
 import type { AdeCleanupResult, AdeProjectSnapshot } from "../../../shared/types";
+import { toRecentProjectSummary } from "../projects/recentProjectSummary";
 import type {
   ApplyConflictProposalArgs,
   BatchAssessmentResult,
@@ -772,33 +773,6 @@ function normalizeAutopilotExecutor(value: unknown): OrchestratorExecutorKind {
   return "unified";
 }
 
-function toRecentProjectSummary(entry: { rootPath: string; displayName: string; lastOpenedAt: string }): RecentProjectSummary {
-  let laneCount: number | undefined;
-  try {
-    const gitPath = path.join(entry.rootPath, ".git");
-    const worktreesPath = path.join(gitPath, "worktrees");
-    if (fs.existsSync(gitPath)) {
-      laneCount = 1; // Primary lane
-      if (fs.existsSync(worktreesPath)) {
-        const wtCount = fs.readdirSync(worktreesPath, { withFileTypes: true })
-          .filter((dirent) => dirent.isDirectory())
-          .length;
-        laneCount += wtCount;
-      }
-    }
-  } catch {
-    // ignore
-  }
-
-  return {
-    rootPath: entry.rootPath,
-    displayName: entry.displayName,
-    lastOpenedAt: entry.lastOpenedAt,
-    exists: fs.existsSync(entry.rootPath),
-    laneCount,
-  };
-}
-
 type MemoryScope = "user" | "project" | "lane" | "mission";
 type UnifiedMemoryScope = "project" | "agent" | "mission";
 
diff --git a/apps/desktop/src/main/services/orchestrator/orchestratorService.ts b/apps/desktop/src/main/services/orchestrator/orchestratorService.ts
index 2a227b427..b3750df40 100644
--- a/apps/desktop/src/main/services/orchestrator/orchestratorService.ts
+++ b/apps/desktop/src/main/services/orchestrator/orchestratorService.ts
@@ -7302,10 +7302,19 @@ export function createOrchestratorService({
           if (sessionId && managedLaunch && agentChatService) {
             void (async () => {
               try {
+                const rawTimeoutMs = step.metadata?.timeoutMs;
+                const parsedTimeoutMs = Number(rawTimeoutMs);
+                const managedTurnTimeoutMs =
+                  rawTimeoutMs === null || parsedTimeoutMs === 0
+                    ? null
+                    : Number.isFinite(parsedTimeoutMs) && parsedTimeoutMs > 0
+                      ? Math.max(1_000, Math.floor(parsedTimeoutMs))
+                      : runtimeConfig.stepTimeoutDefaultMs;
                 await agentChatService.runSessionTurn({
                   sessionId,
                   text: managedLaunch.prompt,
                   displayText: managedLaunch.displayText,
+                  timeoutMs: managedTurnTimeoutMs,
                   ...(managedLaunch.reasoningEffort ? { reasoningEffort: managedLaunch.reasoningEffort } : {}),
                   ...(managedLaunch.executionMode ? { executionMode: managedLaunch.executionMode } : {}),
                 });
diff --git a/apps/desktop/src/main/services/projects/recentProjectSummary.test.ts b/apps/desktop/src/main/services/projects/recentProjectSummary.test.ts
new file mode 100644
index 000000000..e6316de86
--- /dev/null
+++ b/apps/desktop/src/main/services/projects/recentProjectSummary.test.ts
@@ -0,0 +1,176 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { describe, expect, it } from "vitest";
+import { openKvDb } from "../state/kvDb";
+import { resolveAdeLayout } from "../../../shared/adeLayout";
+import { toRecentProjectSummary } from "./recentProjectSummary";
+
+function createLogger() {
+  return {
+    debug: () => {},
+    info: () => {},
+    warn: () => {},
+    error: () => {},
+  } as any;
+}
+
+function insertProject(db: Awaited<ReturnType<typeof openKvDb>>, projectId: string, projectRoot: string, now: string) {
+  db.run(
+    "insert into projects(id, root_path, display_name, default_base_ref, created_at, last_opened_at) values (?, ?, ?, ?, ?, ?)",
+    [projectId, projectRoot, path.basename(projectRoot), "main", now, now],
+  );
+}
+
+function insertLane(
+  db: Awaited<ReturnType<typeof openKvDb>>,
+  args: {
+    laneId: string;
+    projectId: string;
+    laneType: "primary" | "worktree" | "attached";
+    worktreePath: string;
+    branchRef: string;
+    status?: "active" | "archived";
+    archivedAt?: string | null;
+    attachedRootPath?: string | null;
+  },
+) {
+  db.run(
+    `
+      insert into lanes(
+        id, project_id, name, description, lane_type, base_ref, branch_ref, worktree_path,
+        attached_root_path, is_edit_protected, parent_lane_id, color, icon, tags_json, status, created_at, archived_at
+      ) values (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `,
+    [
+      args.laneId,
+      args.projectId,
+      args.laneId,
+      null,
+      args.laneType,
+      "main",
+      args.branchRef,
+      args.worktreePath,
+      args.attachedRootPath ?? null,
+      args.laneType === "primary" ? 1 : 0,
+      null,
+      null,
+      null,
+      null,
+      args.status ?? "active",
+      "2026-04-02T12:00:00.000Z",
+      args.archivedAt ?? null,
+    ],
+  );
+}
+
+describe("toRecentProjectSummary", () => {
+  it("prefers active ADE lanes over raw git worktree metadata", async () => {
+    const projectRoot = fs.mkdtempSync(path.join(os.tmpdir(), "ade-recent-project-summary-"));
+    const gitWorktreesDir = path.join(projectRoot, ".git", "worktrees");
+    fs.mkdirSync(gitWorktreesDir, { recursive: true });
+    for (let index = 0; index < 18; index += 1) {
+      fs.mkdirSync(path.join(gitWorktreesDir, `raw-${index}`), { recursive: true });
+    }
+
+    const layout = resolveAdeLayout(projectRoot);
+    const managedLanePath = path.join(layout.worktreesDir, "lane-managed");
+    const missingLanePath = path.join(layout.worktreesDir, "lane-missing");
+    const attachedLanePath = fs.mkdtempSync(path.join(os.tmpdir(), "ade-recent-project-attached-"));
+    fs.mkdirSync(managedLanePath, { recursive: true });
+
+    const db = await openKvDb(layout.dbPath, createLogger());
+    const now = "2026-04-02T12:00:00.000Z";
+    insertProject(db, "proj-recent", projectRoot, now);
+    insertLane(db, {
+      laneId: "lane-primary",
+      projectId: "proj-recent",
+      laneType: "primary",
+      worktreePath: projectRoot,
+      branchRef: "main",
+    });
+    insertLane(db, {
+      laneId: "lane-managed",
+      projectId: "proj-recent",
+      laneType: "worktree",
+      worktreePath: managedLanePath,
+      branchRef: "feature/managed",
+    });
+    insertLane(db, {
+      laneId: "lane-missing",
+      projectId: "proj-recent",
+      laneType: "worktree",
+      worktreePath: missingLanePath,
+      branchRef: "feature/missing",
+    });
+    insertLane(db, {
+      laneId: "lane-attached",
+      projectId: "proj-recent",
+      laneType: "attached",
+      worktreePath: attachedLanePath,
+      attachedRootPath: attachedLanePath,
+      branchRef: "feature/attached",
+    });
+    insertLane(db, {
+      laneId: "lane-archived",
+      projectId: "proj-recent",
+      laneType: "worktree",
+      worktreePath: path.join(layout.worktreesDir, "lane-archived"),
+      branchRef: "feature/archived",
+      status: "archived",
+      archivedAt: now,
+    });
+    db.close();
+
+    const summary = toRecentProjectSummary({
+      rootPath: projectRoot,
+      displayName: "demo",
+      lastOpenedAt: now,
+    });
+
+    expect(summary.exists).toBe(true);
+    expect(summary.laneCount).toBe(3);
+  });
+
+  it("falls back to git worktree metadata when no ADE lane registry exists", () => {
+    const projectRoot = fs.mkdtempSync(path.join(os.tmpdir(), "ade-recent-project-git-fallback-"));
+    fs.mkdirSync(path.join(projectRoot, ".git", "worktrees", "lane-a"), { recursive: true });
+    fs.mkdirSync(path.join(projectRoot, ".git", "worktrees", "lane-b"), { recursive: true });
+
+    const summary = toRecentProjectSummary({
+      rootPath: projectRoot,
+      displayName: "demo",
+      lastOpenedAt: "2026-04-02T12:00:00.000Z",
+    });
+
+    expect(summary.laneCount).toBe(3);
+  });
+
+  it("falls back to git worktree metadata when ADE only has archived lanes", async () => {
+    const projectRoot = fs.mkdtempSync(path.join(os.tmpdir(), "ade-recent-project-archived-fallback-"));
+    fs.mkdirSync(path.join(projectRoot, ".git", "worktrees", "lane-a"), { recursive: true });
+
+    const layout = resolveAdeLayout(projectRoot);
+    const db = await openKvDb(layout.dbPath, createLogger());
+    const now = "2026-04-02T12:00:00.000Z";
+    insertProject(db, "proj-recent-archived", projectRoot, now);
+    insertLane(db, {
+      laneId: "lane-primary-archived",
+      projectId: "proj-recent-archived",
+      laneType: "primary",
+      worktreePath: projectRoot,
+      branchRef: "main",
+      status: "archived",
+      archivedAt: now,
+    });
+    db.close();
+
+    const summary = toRecentProjectSummary({
+      rootPath: projectRoot,
+      displayName: "demo",
+      lastOpenedAt: now,
+    });
+
+    expect(summary.laneCount).toBe(2);
+  });
+});
diff --git a/apps/desktop/src/main/services/projects/recentProjectSummary.ts b/apps/desktop/src/main/services/projects/recentProjectSummary.ts
new file mode 100644
index 000000000..c6e69fdfe
--- /dev/null
+++ b/apps/desktop/src/main/services/projects/recentProjectSummary.ts
@@ -0,0 +1,113 @@
+import { createRequire } from "node:module";
+import fs from "node:fs";
+import path from "node:path";
+import type { DatabaseSync as DatabaseSyncType } from "node:sqlite";
+import { resolveAdeLayout } from "../../../shared/adeLayout";
+import type { RecentProjectSummary } from "../../../shared/types";
+
+const require = createRequire(__filename);
+const { DatabaseSync } = require("node:sqlite") as { DatabaseSync: typeof DatabaseSyncType };
+
+type RecentProjectEntry = {
+  rootPath: string;
+  displayName: string;
+  lastOpenedAt: string;
+};
+
+type LaneCountRow = {
+  lane_type: string | null;
+  worktree_path: string | null;
+  attached_root_path: string | null;
+  status: string | null;
+  archived_at: string | null;
+};
+
+function normalizePath(value: string | null | undefined): string | null {
+  const trimmed = typeof value === "string" ? value.trim() : "";
+  return trimmed ? path.resolve(trimmed) : null;
+}
+
+function laneExistsOnDisk(row: LaneCountRow, projectRoot: string): boolean {
+  if ((row.lane_type ?? "").trim() === "primary") {
+    return fs.existsSync(projectRoot);
+  }
+  const candidatePath = normalizePath(row.worktree_path) ?? normalizePath(row.attached_root_path);
+  return candidatePath ? fs.existsSync(candidatePath) : false;
+}
+
+function readAdeLaneCount(projectRoot: string): number | null {
+  const dbPath = resolveAdeLayout(projectRoot).dbPath;
+  if (!fs.existsSync(dbPath)) return null;
+
+  let db: DatabaseSyncType | null = null;
+  try {
+    db = new DatabaseSync(dbPath);
+    const hasLanesTable = Boolean(
+      db.prepare("select 1 as present from sqlite_master where type = 'table' and name = ? limit 1")
+        .get<{ present?: number }>("lanes")?.present,
+    );
+    if (!hasLanesTable) return null;
+
+    const rows = db.prepare(
+      `
+        select lane_type, worktree_path, attached_root_path, status, archived_at
+        from lanes
+        where coalesce(status, 'active') != 'archived'
+          and archived_at is null
+      `,
+    ).all<LaneCountRow>();
+
+    let count = 0;
+    for (const row of rows) {
+      if (laneExistsOnDisk(row, projectRoot)) count += 1;
+    }
+    return count > 0 ? count : null;
+  } catch {
+    return null;
+  } finally {
+    db?.close();
+  }
+}
+
+function readGitLaneCount(projectRoot: string): number | undefined {
+  try {
+    const gitPath = path.join(projectRoot, ".git");
+    const gitStat = fs.existsSync(gitPath) ? fs.statSync(gitPath) : null;
+    if (!gitStat) return undefined;
+
+    let actualGitDir = gitPath;
+    if (gitStat.isFile()) {
+      // .git file in a worktree checkout — read the gitdir pointer
+      const content = fs.readFileSync(gitPath, "utf-8").trim();
+      const match = content.match(/^gitdir:\s*(.+)$/);
+      if (!match) return 1;
+      actualGitDir = path.resolve(projectRoot, match[1]);
+    } else if (!gitStat.isDirectory()) {
+      return 1;
+    }
+
+    let laneCount = 1;
+    const worktreesPath = path.join(actualGitDir, "worktrees");
+    if (fs.existsSync(worktreesPath)) {
+      laneCount += fs.readdirSync(worktreesPath, { withFileTypes: true })
+        .filter((dirent) => dirent.isDirectory())
+        .length;
+    }
+    return laneCount;
+  } catch {
+    return undefined;
+  }
+}
+
+export function toRecentProjectSummary(entry: RecentProjectEntry): RecentProjectSummary {
+  const exists = fs.existsSync(entry.rootPath);
+  const laneCount = exists ? (readAdeLaneCount(entry.rootPath) ?? readGitLaneCount(entry.rootPath)) : undefined;
+
+  return {
+    rootPath: entry.rootPath,
+    displayName: entry.displayName,
+    lastOpenedAt: entry.lastOpenedAt,
+    exists,
+    laneCount,
+  };
+}
diff --git a/apps/desktop/src/main/services/prs/prService.ts b/apps/desktop/src/main/services/prs/prService.ts
index c2b20f2ed..6071195cb 100644
--- a/apps/desktop/src/main/services/prs/prService.ts
+++ b/apps/desktop/src/main/services/prs/prService.ts
@@ -3532,6 +3532,13 @@ export function createPrService({
         adeKind: deriveAdeKind(workflowRow, groupRow, linkedPrRow),
         workflowDisplayState: workflowRow ? parseWorkflowDisplayState(workflowRow.workflow_display_state) : null,
         cleanupState: workflowRow ? parseCleanupState(workflowRow.cleanup_state) : null,
+        labels: Array.isArray(rawPr?.labels)
+          ? rawPr.labels
+              .filter((l: any) => l?.name)
+              .map((l: any) => ({ name: String(l.name), color: String(l.color || "cccccc"), description: l.description != null ? String(l.description) : null }))
+          : [],
+        isBot: asString(rawPr?.user?.type).toLowerCase() === "bot",
+        commentCount: Number(rawPr?.comments) || 0,
       };
     };
 
diff --git a/apps/desktop/src/main/services/runtime/adeMcpLaunch.ts b/apps/desktop/src/main/services/runtime/adeMcpLaunch.ts
index 4bd65964a..34da34d87 100644
--- a/apps/desktop/src/main/services/runtime/adeMcpLaunch.ts
+++ b/apps/desktop/src/main/services/runtime/adeMcpLaunch.ts
@@ -25,6 +25,7 @@ export type DesktopAdeMcpLaunchArgs = {
   runId?: string;
   stepId?: string;
   attemptId?: string;
+  chatSessionId?: string;
   defaultRole?: string;
   ownerId?: string;
   computerUsePolicy?: ComputerUsePolicy | null;
@@ -100,7 +101,7 @@ function buildLaunchEnv(args: {
   projectRoot: string;
   workspaceRoot: string;
   socketPath: string;
-} & Pick<DesktopAdeMcpLaunchArgs, "missionId" | "runId" | "stepId" | "attemptId" | "defaultRole" | "ownerId" | "computerUsePolicy">): Record<string, string> {
+} & Pick<DesktopAdeMcpLaunchArgs, "missionId" | "runId" | "stepId" | "attemptId" | "chatSessionId" | "defaultRole" | "ownerId" | "computerUsePolicy">): Record<string, string> {
   return {
     ADE_PROJECT_ROOT: args.projectRoot,
     ADE_WORKSPACE_ROOT: args.workspaceRoot,
@@ -109,6 +110,7 @@ function buildLaunchEnv(args: {
     ADE_RUN_ID: args.runId ?? "",
     ADE_STEP_ID: args.stepId ?? "",
     ADE_ATTEMPT_ID: args.attemptId ?? "",
+    ADE_CHAT_SESSION_ID: args.chatSessionId ?? "",
     ADE_DEFAULT_ROLE: args.defaultRole ?? "agent",
     ADE_OWNER_ID: args.ownerId ?? "",
     ADE_COMPUTER_USE_MODE: args.computerUsePolicy?.mode ?? "",
@@ -136,6 +138,7 @@ export function resolveDesktopAdeMcpLaunch(args: DesktopAdeMcpLaunchArgs): AdeMc
     runId: args.runId,
     stepId: args.stepId,
     attemptId: args.attemptId,
+    chatSessionId: args.chatSessionId,
     defaultRole: args.defaultRole,
     ownerId: args.ownerId,
     socketPath,
diff --git a/apps/desktop/src/main/services/sessions/sessionService.ts b/apps/desktop/src/main/services/sessions/sessionService.ts
index ea36ff74c..3e3a0d74a 100644
--- a/apps/desktop/src/main/services/sessions/sessionService.ts
+++ b/apps/desktop/src/main/services/sessions/sessionService.ts
@@ -135,22 +135,40 @@ export function createSessionService({ db }: { db: AdeDb }) {
 
     reconcileStaleRunningSessions({
       endedAt,
-      status
+      status,
+      excludeToolTypes,
     }: {
       endedAt?: string;
       status?: TerminalSessionStatus;
+      excludeToolTypes?: string[];
     } = {}): number {
-      const row = db.get<{ count: number }>("select count(1) as count from terminal_sessions where status = 'running'");
+      const normalizedExcludedToolTypes = Array.isArray(excludeToolTypes)
+        ? excludeToolTypes
+            .map((toolType) => normalizeToolType(toolType))
+            .filter((toolType): toolType is TerminalToolType => toolType != null)
+        : [];
+      const exclusionSql = normalizedExcludedToolTypes.length
+        ? ` and (tool_type is null or tool_type not in (${normalizedExcludedToolTypes.map(() => "?").join(", ")}))`
+        : "";
+      const whereSql = `status = 'running'${exclusionSql}`;
+      const row = db.get<{ count: number }>(
+        `select count(1) as count from terminal_sessions where ${whereSql}`,
+        normalizedExcludedToolTypes,
+      );
       const count = Number(row?.count ?? 0);
       if (!Number.isFinite(count) || count <= 0) return 0;
 
       const finalEndedAt = endedAt ?? new Date().toISOString();
       const finalStatus = status ?? "disposed";
-      db.run("update terminal_sessions set ended_at = ?, exit_code = ?, status = ?, pty_id = null where status = 'running'", [
-        finalEndedAt,
-        null,
-        finalStatus
-      ]);
+      db.run(
+        `update terminal_sessions set ended_at = ?, exit_code = ?, status = ?, pty_id = null where ${whereSql}`,
+        [
+          finalEndedAt,
+          null,
+          finalStatus,
+          ...normalizedExcludedToolTypes,
+        ],
+      );
       return count;
     },
 
diff --git a/apps/desktop/src/renderer/components/app/App.tsx b/apps/desktop/src/renderer/components/app/App.tsx
index bef97e810..baeec96ed 100644
--- a/apps/desktop/src/renderer/components/app/App.tsx
+++ b/apps/desktop/src/renderer/components/app/App.tsx
@@ -125,7 +125,7 @@ class PageErrorBoundaryInner extends React.Component<
 function PageErrorBoundary({ children }: { children: React.ReactNode }) {
   const navigate = useNavigate();
   return (
-    <PageErrorBoundaryInner onGoHome={() => navigate("/project")}>
+    <PageErrorBoundaryInner onGoHome={() => navigate("/work")}>
       {children}
     </PageErrorBoundaryInner>
   );
@@ -198,9 +198,9 @@ export function App() {
     <Router>
       <div data-theme={theme} className="h-full bg-bg text-fg font-sans antialiased selection:bg-accent/30">
         <Routes>
-          <Route path="/startup" element={<Navigate to="/project" replace />} />
+          <Route path="/startup" element={<Navigate to="/work" replace />} />
           <Route element={<ShellLayout />}>
-            <Route path="/" element={<Navigate to="/project" replace />} />
+            <Route path="/" element={<Navigate to="/work" replace />} />
             <Route path="/project" element={guarded(<RunPage />)} />
             <Route path="/onboarding" element={guarded(<ProjectSetupPage />)} />
             <Route path="/lanes" element={guardedLazy(<LanesPage />)} />
@@ -213,7 +213,7 @@ export function App() {
             <Route path="/missions" element={guardedLazy(<MissionsPage />)} />
             <Route path="/cto" element={guardedLazy(<CtoPage />)} />
             <Route path="/settings" element={guardedLazy(<SettingsPage />)} />
-            <Route path="*" element={<Navigate to="/project" replace />} />
+            <Route path="*" element={<Navigate to="/work" replace />} />
           </Route>
         </Routes>
       </div>
diff --git a/apps/desktop/src/renderer/components/app/AppShell.test.tsx b/apps/desktop/src/renderer/components/app/AppShell.test.tsx
index 5ff7a41c6..97ae7544c 100644
--- a/apps/desktop/src/renderer/components/app/AppShell.test.tsx
+++ b/apps/desktop/src/renderer/components/app/AppShell.test.tsx
@@ -3,7 +3,7 @@
 import React from "react";
 import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
 import { act, cleanup, fireEvent, render, screen } from "@testing-library/react";
-import { MemoryRouter } from "react-router-dom";
+import { MemoryRouter, useLocation } from "react-router-dom";
 import { AppShell } from "./AppShell";
 import { useAppStore } from "../../state/appStore";
 
@@ -57,6 +57,11 @@ vi.mock("../../lib/zoom", () => ({
   displayZoomToLevel: () => 0,
 }));
 
+function LocationProbe() {
+  const location = useLocation();
+  return <div data-testid="location-probe">{location.pathname}</div>;
+}
+
 function resetStore() {
   useAppStore.setState({
     project: { rootPath: "/Users/arul/ADE", name: "ADE" } as any,
@@ -194,4 +199,67 @@ describe("AppShell", () => {
 
     expect(screen.queryByText(/ADE context docs need regeneration/i)).toBeNull();
   });
+
+  it("moves project selection flows from run to work", async () => {
+    useAppStore.setState({
+      project: null,
+      showWelcome: true,
+    } as any);
+    globalThis.window.ade.app.getProject = vi.fn(async () => null);
+
+    render(
+      <MemoryRouter initialEntries={["/project"]}>
+        <AppShell>
+          <LocationProbe />
+        </AppShell>
+      </MemoryRouter>,
+    );
+
+    expect(screen.getByTestId("location-probe").textContent).toBe("/project");
+
+    await act(async () => {
+      useAppStore.getState().setProject({ rootPath: "/Users/arul/ADE-next", name: "ADE next" } as any);
+      useAppStore.getState().setShowWelcome(false);
+    });
+
+    expect(await screen.findByText("/work")).toBeTruthy();
+  });
+
+  it("waits for AI status before showing the missing provider banner", async () => {
+    vi.useFakeTimers();
+    try {
+      globalThis.window.ade.ai.getStatus = vi.fn(async () => ({
+        detectedAuth: [],
+        providerConnections: {
+          claude: { authAvailable: false },
+          codex: { authAvailable: false },
+          cursor: { authAvailable: false },
+        },
+        availableProviders: {
+          claude: false,
+          codex: false,
+          cursor: false,
+        },
+      })) as any;
+
+      render(
+        <MemoryRouter initialEntries={["/work"]}>
+          <AppShell>
+            <div>child</div>
+          </AppShell>
+        </MemoryRouter>,
+      );
+
+      expect(screen.queryByText(/No AI provider is configured yet/i)).toBeNull();
+
+      await act(async () => {
+        vi.advanceTimersByTime(1_000);
+        await Promise.resolve();
+      });
+
+      expect(screen.getByText(/No AI provider is configured yet/i)).toBeTruthy();
+    } finally {
+      vi.useRealTimers();
+    }
+  });
 });
diff --git a/apps/desktop/src/renderer/components/app/AppShell.tsx b/apps/desktop/src/renderer/components/app/AppShell.tsx
index 852054096..66a332a55 100644
--- a/apps/desktop/src/renderer/components/app/AppShell.tsx
+++ b/apps/desktop/src/renderer/components/app/AppShell.tsx
@@ -148,12 +148,14 @@ export function AppShell({ children }: { children: React.ReactNode }) {
   const [aiFailure, setAiFailure] = useState<AiBannerState | null>(null);
   const [aiMockProvider, setAiMockProvider] = useState<{ createdAt: string } | null>(null);
   const [aiStatus, setAiStatus] = useState<AiSettingsStatus | null>(null);
+  const [aiStatusLoaded, setAiStatusLoaded] = useState(false);
   const [githubStatus, setGithubStatus] = useState<GitHubStatus | null>(null);
   const [onboardingStatus, setOnboardingStatus] = useState<OnboardingStatus | null>(null);
   const [onboardingStatusLoading, setOnboardingStatusLoading] = useState(false);
   const [contextStatus, setContextStatus] = useState<ContextStatus | null>(null);
   const [dismissedContextBannerRoots, setDismissedContextBannerRoots] = useState<Record<string, true>>({});
   const [projectMissing, setProjectMissing] = useState(false);
+  const previousProjectRootRef = useRef<string | null | undefined>(undefined);
   const isOnboardingRoute = location.pathname === "/onboarding";
   const shouldTrackTerminalAttention =
     Boolean(project?.rootPath)
@@ -348,14 +350,28 @@ export function AppShell({ children }: { children: React.ReactNode }) {
     setProjectMissing(false);
   }, [project?.rootPath]);
 
+  useEffect(() => {
+    const previousProjectRoot = previousProjectRootRef.current;
+    const nextProjectRoot = project?.rootPath ?? null;
+    previousProjectRootRef.current = nextProjectRoot;
+
+    if (previousProjectRoot === undefined) return;
+    if (!nextProjectRoot || showWelcome) return;
+    if (location.pathname !== "/project") return;
+    if (previousProjectRoot === nextProjectRoot) return;
+    navigate("/work", { replace: true });
+  }, [location.pathname, navigate, project?.rootPath, showWelcome]);
+
   useEffect(() => {
     let cancelled = false;
     if (!project?.rootPath) {
       setContextStatus(null);
       setAiStatus(null);
+      setAiStatusLoaded(false);
       setGithubStatus(null);
       return;
     }
+    setAiStatusLoaded(false);
     const timer = window.setTimeout(() => {
       void Promise.allSettled([
         window.ade.context.getStatus(),
@@ -366,6 +382,7 @@ export function AppShell({ children }: { children: React.ReactNode }) {
         const [contextResult, aiResult, githubResult] = results;
         setContextStatus(contextResult.status === "fulfilled" ? contextResult.value : null);
         setAiStatus(aiResult.status === "fulfilled" ? aiResult.value : null);
+        setAiStatusLoaded(true);
         setGithubStatus(githubResult.status === "fulfilled" ? githubResult.value : null);
       });
     }, 1_000);
@@ -603,7 +620,7 @@ export function AppShell({ children }: { children: React.ReactNode }) {
         </div>
       ) : null}
 
-      {!hideSidebar && project?.rootPath && !showWelcome && !hasAnyAiProvider ? (
+      {!hideSidebar && project?.rootPath && !showWelcome && aiStatusLoaded && aiStatus !== null && !hasAnyAiProvider ? (
         <div className="shrink-0 mx-2 mt-1 rounded bg-amber-500/6 px-3 py-1.5 text-[11px] font-mono text-amber-800">
           No AI provider is configured yet. <Link to="/settings?tab=ai" className="underline">Set up AI</Link>
         </div>
diff --git a/apps/desktop/src/renderer/components/chat/AgentChatComposer.test.tsx b/apps/desktop/src/renderer/components/chat/AgentChatComposer.test.tsx
index 50d1c4440..13ea0904b 100644
--- a/apps/desktop/src/renderer/components/chat/AgentChatComposer.test.tsx
+++ b/apps/desktop/src/renderer/components/chat/AgentChatComposer.test.tsx
@@ -172,6 +172,163 @@ describe("AgentChatComposer", () => {
     });
   });
 
+  it("avoids promising option chips when a pending question is freeform only", () => {
+    renderComposer({
+      pendingInput: {
+        requestId: "req-1",
+        itemId: "item-1",
+        source: "ade",
+        kind: "question",
+        title: "Input needed",
+        description: "What should we test first?",
+        questions: [{
+          id: "answer",
+          header: "Question 1",
+          question: "What should we test first?",
+          allowsFreeform: true,
+        }],
+        allowsFreeform: true,
+        blocking: true,
+        canProceedWithoutAnswer: false,
+        turnId: null,
+      },
+    });
+
+    expect(screen.getByText("Type your answer below.")).toBeTruthy();
+    expect(screen.queryByText("Type your answer below or pick an option above.")).toBeNull();
+  });
+
+  it("keeps the option hint when a pending question includes selectable options", () => {
+    renderComposer({
+      pendingInput: {
+        requestId: "req-2",
+        itemId: "item-2",
+        source: "ade",
+        kind: "structured_question",
+        title: "Input needed",
+        description: "Which flow should we test first?",
+        questions: [{
+          id: "answer",
+          header: "Question 1",
+          question: "Which flow should we test first?",
+          allowsFreeform: true,
+          options: [
+            { label: "Question flow", value: "question_flow" },
+            { label: "Plan updates", value: "plan_updates" },
+          ],
+        }],
+        allowsFreeform: true,
+        blocking: true,
+        canProceedWithoutAnswer: false,
+        turnId: null,
+      },
+    });
+
+    expect(screen.getByText("Type your answer below or pick an option above.")).toBeTruthy();
+  });
+
+  it("keeps the option hint when any pending question includes selectable options", () => {
+    renderComposer({
+      pendingInput: {
+        requestId: "req-2b",
+        itemId: "item-2b",
+        source: "codex",
+        kind: "structured_question",
+        title: "Input needed",
+        description: "Two questions are pending",
+        questions: [
+          {
+            id: "first",
+            header: "Question 1",
+            question: "What should we inspect first?",
+            allowsFreeform: true,
+          },
+          {
+            id: "second",
+            header: "Question 2",
+            question: "Which flow should we use?",
+            allowsFreeform: true,
+            options: [
+              { label: "Question flow", value: "question_flow" },
+              { label: "Plan updates", value: "plan_updates" },
+            ],
+          },
+        ],
+        allowsFreeform: true,
+        blocking: true,
+        canProceedWithoutAnswer: false,
+        turnId: null,
+      },
+    });
+
+    expect(screen.getByText("Type your answer below or pick an option above.")).toBeTruthy();
+  });
+
+  it("uses decline wording for native Codex structured questions", () => {
+    const props = renderComposer({
+      pendingInput: {
+        requestId: "req-2c",
+        itemId: "item-2c",
+        source: "codex",
+        kind: "structured_question",
+        title: "Input needed",
+        description: "Which flow should we test first?",
+        questions: [{
+          id: "answer",
+          header: "Question 1",
+          question: "Which flow should we test first?",
+          allowsFreeform: true,
+          options: [
+            { label: "Question flow", value: "question_flow" },
+            { label: "Plan updates", value: "plan_updates" },
+          ],
+        }],
+        allowsFreeform: true,
+        blocking: true,
+        canProceedWithoutAnswer: false,
+        turnId: null,
+      },
+    });
+
+    const decline = screen.getByRole("button", { name: "Decline" });
+    fireEvent.click(decline);
+
+    expect(props.onApproval).toHaveBeenCalledWith("decline");
+  });
+
+  it("labels multi-question prompts explicitly in the pending banner", () => {
+    renderComposer({
+      pendingInput: {
+        requestId: "req-3",
+        itemId: "item-3",
+        source: "codex",
+        kind: "structured_question",
+        title: "Input needed",
+        description: "Multiple decisions are needed",
+        questions: [
+          {
+            id: "q1",
+            header: "Question 1",
+            question: "What should we test first?",
+            allowsFreeform: true,
+          },
+          {
+            id: "q2",
+            header: "Question 2",
+            question: "Which validation strategy should we use?",
+            allowsFreeform: true,
+          },
+        ],
+        allowsFreeform: true,
+        blocking: true,
+        canProceedWithoutAnswer: false,
+        turnId: null,
+      },
+    });
+
+    expect(screen.getByText("2 Questions · codex")).toBeTruthy();
+  });
+
   it("disables attachments while steering an active turn", () => {
     renderComposer({ turnActive: true });
 
@@ -216,4 +373,29 @@ describe("AgentChatComposer", () => {
 
     expect(screen.queryByTitle("Include project context (PRD + architecture) with first message")).toBeNull();
   });
+
+  it("uses a constrained resizable textarea in grid-tile mode", () => {
+    renderComposer({
+      layoutVariant: "grid-tile",
+      composerMaxHeightPx: 128,
+    });
+
+    const textarea = screen.getByPlaceholderText("Steer the active turn...") as HTMLTextAreaElement;
+    expect(textarea.dataset.chatLayoutVariant).toBe("grid-tile");
+    expect(textarea.style.maxHeight).toBe("128px");
+    expect(textarea.className).toContain("resize-y");
+  });
+
+  it("shows only the available session models when the chat catalog is restricted", () => {
+    renderComposer({
+      availableModelIds: ["openai/gpt-5.4-codex", "openai/gpt-5.2-codex"],
+      restrictModelCatalogToAvailable: true,
+      turnActive: false,
+    });
+
+    fireEvent.click(screen.getByRole("button", { name: "Select model" }));
+
+    expect(screen.getByText("GPT-5.2-Codex")).toBeTruthy();
+    expect(screen.queryByText("Claude Sonnet 4.6")).toBeNull();
+  });
 });
diff --git a/apps/desktop/src/renderer/components/chat/AgentChatComposer.tsx b/apps/desktop/src/renderer/components/chat/AgentChatComposer.tsx
index 27fbfbd4c..ca4429849 100644
--- a/apps/desktop/src/renderer/components/chat/AgentChatComposer.tsx
+++ b/apps/desktop/src/renderer/components/chat/AgentChatComposer.tsx
@@ -25,6 +25,7 @@ import { UnifiedModelSelector } from "../shared/UnifiedModelSelector";
 import { getPermissionOptions, safetyColors } from "../shared/permissionOptions";
 import { ChatAttachmentTray } from "./ChatAttachmentTray";
 import { ChatComposerShell } from "./ChatComposerShell";
+import { getPendingInputQuestionCount, hasPendingInputOptions } from "./pendingInput";
 import { CURSOR_MODE_LABELS } from "../../../shared/cursorModes";
 import { ChatStatusGlyph } from "./chatStatusVisuals";
 import { ChatSubagentStrip } from "./ChatSubagentStrip";
@@ -263,6 +264,8 @@ function PendingSteerItem({
 
 export function AgentChatComposer({
   surfaceMode = "standard",
+  layoutVariant = "standard",
+  composerMaxHeightPx = null,
   sdkSlashCommands = [],
   modelId,
   availableModelIds,
@@ -320,12 +323,15 @@ export function AgentChatComposer({
   promptSuggestion,
   subagentSnapshots = [],
   chatHasMessages = false,
+  restrictModelCatalogToAvailable = false,
   pendingSteers = [],
   onCancelSteer,
   onEditSteer,
   onOpenAiSettings,
 }: {
   surfaceMode?: ChatSurfaceMode;
+  layoutVariant?: "standard" | "grid-tile";
+  composerMaxHeightPx?: number | null;
   sdkSlashCommands?: AgentChatSlashCommand[];
   modelId: string;
   availableModelIds?: string[];
@@ -360,7 +366,7 @@ export function AgentChatComposer({
   onClearDraft?: () => void;
   onSubmit: () => void;
   onInterrupt: () => void;
-  onApproval: (decision: AgentChatApprovalDecision) => void;
+  onApproval: (decision: AgentChatApprovalDecision, responseText?: string | null) => void;
   onAddAttachment: (attachment: AgentChatFileRef) => void;
   onRemoveAttachment: (path: string) => void;
   onSearchAttachments: (query: string) => Promise<AgentChatFileRef[]>;
@@ -387,6 +393,7 @@ export function AgentChatComposer({
   promptSuggestion?: string | null;
   subagentSnapshots?: ChatSubagentSnapshot[];
   chatHasMessages?: boolean;
+  restrictModelCatalogToAvailable?: boolean;
   pendingSteers?: Array<{ steerId: string; text: string }>;
   onCancelSteer?: (steerId: string) => void;
   onEditSteer?: (steerId: string, text: string) => void;
@@ -897,8 +904,7 @@ export function AgentChatComposer({
     const shouldSend = sendOnEnter ? !commandEnter : commandEnter;
     if (!shouldSend) return;
     event.preventDefault();
-    if (busy || !modelId || !draft.trim().length) return;
-    onSubmit();
+    submitComposerDraft();
   };
 
   const openUploadPicker = () => {
@@ -930,11 +936,30 @@ export function AgentChatComposer({
     void addFileAttachments(event.dataTransfer.files);
   };
 
+  const submitComposerDraft = useCallback(() => {
+    const isQuestionPending = pendingInput && (pendingInput.kind === "question" || pendingInput.kind === "structured_question");
+    if (isQuestionPending) {
+      const answer = draft.trim();
+      if (!answer.length && !pendingInput.canProceedWithoutAnswer) return;
+      onApproval("accept", answer || null);
+      onDraftChange("");
+      return;
+    }
+    if (busy || !modelId || !draft.trim().length) return;
+    onSubmit();
+  }, [busy, draft, modelId, onApproval, onDraftChange, onSubmit, pendingInput]);
+
+  const pendingQuestionCount = getPendingInputQuestionCount(pendingInput);
+  const showPendingInputOptionsHint = hasPendingInputOptions(pendingInput);
+
   return (
     <>
       <ChatComposerShell
       mode={surfaceMode}
-      className="m-3 mt-0 rounded-[var(--chat-radius-shell)]"
+      className={cn(
+        "m-3 mt-0 rounded-[var(--chat-radius-shell)]",
+        layoutVariant === "grid-tile" ? "m-0 rounded-none border-0 bg-transparent shadow-none" : "",
+      )}
       pendingBanner={pendingInput ? (
         pendingInput.kind === "plan_approval" ? (
           <div className="px-4 py-3">
@@ -961,7 +986,11 @@ export function AgentChatComposer({
                 <ChatStatusGlyph status="waiting" size={11} />
               </span>
               <span className="font-mono text-[9px] font-bold uppercase tracking-widest text-amber-200">
-                {pendingInput.kind === "approval" || pendingInput.kind === "permissions" ? "Approval" : "Input needed"} · {pendingInput.source}
+                {pendingInput.kind === "approval" || pendingInput.kind === "permissions"
+                  ? "Approval"
+                  : pendingQuestionCount > 1
+                    ? `${pendingQuestionCount} Questions`
+                    : "Input needed"} · {pendingInput.source}
               </span>
             </div>
             <div className="mb-2 font-mono text-[11px] leading-relaxed text-fg/68">
@@ -974,8 +1003,18 @@ export function AgentChatComposer({
                 <button type="button" disabled={approvalResponding} className="rounded-[var(--chat-radius-pill)] border border-border/20 px-3 py-1 font-mono text-[9px] font-bold uppercase tracking-wider text-fg/40 transition-colors hover:bg-border/10 disabled:opacity-40 disabled:pointer-events-none" onClick={() => onApproval("decline")}>Decline</button>
               </div>
             ) : (
-              <div className="font-mono text-[10px] uppercase tracking-[0.14em] text-amber-200/60">
-                Open the question modal to answer and continue.
+              <div className="flex items-center gap-1.5">
+                <span className="font-mono text-[10px] uppercase tracking-[0.14em] text-amber-200/60">
+                  {showPendingInputOptionsHint ? "Type your answer below or pick an option above." : "Type your answer below."}
+                </span>
+                <button
+                  type="button"
+                  disabled={approvalResponding}
+                  className="rounded-[var(--chat-radius-pill)] border border-border/20 px-3 py-1 font-mono text-[9px] font-bold uppercase tracking-wider text-fg/40 transition-colors hover:bg-border/10 disabled:opacity-40 disabled:pointer-events-none"
+                  onClick={() => onApproval("decline")}
+                >
+                  Decline
+                </button>
               </div>
             )}
           </div>
@@ -1104,14 +1143,15 @@ export function AgentChatComposer({
         </>
       }
       footer={
-        <div className="flex items-center gap-2 px-3 py-1.5">
+        <div className="flex flex-wrap items-center gap-2 px-3 py-1.5">
           {/* Left: permission + model controls */}
-          <div className="flex min-w-0 items-center gap-1.5">
+          <div className="flex min-w-0 flex-wrap items-center gap-1.5">
             {nativeControlPanel}
             <UnifiedModelSelector
               value={modelId}
               onChange={onModelChange}
               availableModelIds={availableModelIds}
+              catalogMode={restrictModelCatalogToAvailable ? "available-only" : "all"}
               disabled={modelSelectionLocked}
               showReasoning
               reasoningEffort={reasoningEffort}
@@ -1211,7 +1251,7 @@ export function AgentChatComposer({
                   <button
                     type="button"
                     className="inline-flex h-6 w-6 items-center justify-center rounded-md border border-[color:color-mix(in_srgb,var(--chat-accent)_28%,transparent)] bg-[color:color-mix(in_srgb,var(--chat-accent)_12%,transparent)] text-[var(--chat-accent)] transition-all hover:bg-[color:color-mix(in_srgb,var(--chat-accent)_18%,transparent)]"
-                    onClick={onSubmit}
+                    onClick={submitComposerDraft}
                     title="Send steer message"
                     aria-label="Send steer message"
                   >
@@ -1238,7 +1278,7 @@ export function AgentChatComposer({
                     : "border-[color:color-mix(in_srgb,var(--chat-accent)_28%,transparent)] bg-[color:color-mix(in_srgb,var(--chat-accent)_12%,transparent)] text-[var(--chat-accent)] hover:bg-[color:color-mix(in_srgb,var(--chat-accent)_20%,transparent)]",
                 )}
                 disabled={busy || !draft.trim().length || !modelId}
-                onClick={onSubmit}
+                onClick={submitComposerDraft}
                 title={!modelId ? "Select a model first" : "Send"}
               >
                 <PaperPlaneTilt size={10} weight="fill" />
@@ -1306,10 +1346,15 @@ export function AgentChatComposer({
               if (val.startsWith("/")) { setSlashQuery(val.slice(1)); setSlashCursor(0); }
             }}
             className={cn(
-              "min-h-[44px] max-h-[200px] w-full resize-none bg-transparent px-4 py-2.5 text-[13px] leading-[1.6] text-fg/88 outline-none transition-colors placeholder:text-muted-fg/25",
+              "min-h-[44px] w-full bg-transparent px-4 py-2.5 text-[13px] leading-[1.6] text-fg/88 outline-none transition-colors placeholder:text-muted-fg/25",
+              layoutVariant === "grid-tile" ? "resize-y" : "max-h-[200px] resize-none",
               dragActive ? "opacity-30" : "",
             )}
-            placeholder={turnActive ? "Steer the active turn..." : (promptSuggestion ? "" : (messagePlaceholder ?? "Message the assistant..."))}
+            style={layoutVariant === "grid-tile" && composerMaxHeightPx != null
+              ? { maxHeight: `${composerMaxHeightPx}px` }
+              : undefined}
+            data-chat-layout-variant={layoutVariant}
+            placeholder={turnActive ? "Steer the active turn..." : (promptSuggestion ? "" : (messagePlaceholder ?? "Type to vibecode..."))}
             onKeyDown={handleKeyDown}
             onPaste={handlePaste}
           />
diff --git a/apps/desktop/src/renderer/components/chat/AgentChatMessageList.test.tsx b/apps/desktop/src/renderer/components/chat/AgentChatMessageList.test.tsx
index d23135fd3..07d427447 100644
--- a/apps/desktop/src/renderer/components/chat/AgentChatMessageList.test.tsx
+++ b/apps/desktop/src/renderer/components/chat/AgentChatMessageList.test.tsx
@@ -3,7 +3,7 @@
 import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
 import { cleanup, fireEvent, render, screen, waitFor } from "@testing-library/react";
 import { MemoryRouter, useLocation } from "react-router-dom";
-import type { AgentChatEventEnvelope } from "../../../shared/types";
+import type { AgentChatApprovalDecision, AgentChatEventEnvelope } from "../../../shared/types";
 import * as modelRegistry from "../../../shared/modelRegistry";
 import {
   AgentChatMessageList,
@@ -37,6 +37,7 @@ function renderMessageList(
     assistantLabel?: string;
     initialState?: Record<string, unknown>;
     showStreamingIndicator?: boolean;
+    onApproval?: (itemId: string, decision: AgentChatApprovalDecision, responseText?: string | null, answers?: Record<string, string | string[]>) => void;
   },
 ) {
   return render(
@@ -45,6 +46,7 @@ function renderMessageList(
         events={events}
         assistantLabel={options?.assistantLabel}
         showStreamingIndicator={options?.showStreamingIndicator}
+        onApproval={options?.onApproval as any}
       />
       <LocationProbe />
     </MemoryRouter>,
@@ -267,10 +269,7 @@ describe("AgentChatMessageList transcript rendering", () => {
       },
     ]);
 
-    expect(screen.getByText("Work log (2)")).toBeTruthy();
-
-    // Only the most recent entry is visible by default; expand to reveal the older one
-    fireEvent.click(screen.getByRole("button", { name: "Show 1 more" }));
+    expect(screen.getByText("Ran shell")).toBeTruthy();
 
     fireEvent.click(findButtonByTextContent(/npm test/i));
     fireEvent.click(findButtonByTextContent(/npm run lint/i));
@@ -309,10 +308,7 @@ describe("AgentChatMessageList transcript rendering", () => {
       },
     ]);
 
-    expect(screen.getByText("Work log (2)")).toBeTruthy();
-
-    // Only the most recent entry is visible by default; expand to reveal the older one
-    fireEvent.click(screen.getByRole("button", { name: "Show 1 more" }));
+    expect(screen.getByText("Edited files")).toBeTruthy();
 
     fireEvent.click(findButtonByTextContent(/foo\.ts/i));
     fireEvent.click(findButtonByTextContent(/bar\.ts/i));
@@ -322,7 +318,7 @@ describe("AgentChatMessageList transcript rendering", () => {
     expect(body).toContain("bar.ts");
   });
 
-  it("shows only the most recent work-log entry by default and expands overflow on demand", () => {
+  it("shows the four most recent work-log entries by default and expands overflow on demand", () => {
     renderMessageList(
       Array.from({ length: 7 }, (_, index) => ({
         sessionId: "session-1",
@@ -340,16 +336,98 @@ describe("AgentChatMessageList transcript rendering", () => {
       })),
     );
 
-    expect(screen.getByText("Work log (7)")).toBeTruthy();
-    expect(screen.getByText("Show 6 more")).toBeTruthy();
-    expect(screen.queryByText(/Shell - echo 1/i)).toBeNull();
+    expect(screen.getByText("Ran shell")).toBeTruthy();
+    expect(screen.getByText("Show 3 earlier")).toBeTruthy();
+    expect(screen.queryByText(/echo 3/i)).toBeNull();
+    expect(findButtonByTextContent(/echo 4/i)).toBeTruthy();
     expect(findButtonByTextContent(/echo 7/i)).toBeTruthy();
 
-    fireEvent.click(screen.getByRole("button", { name: "Show 6 more" }));
+    fireEvent.click(screen.getByRole("button", { name: "Show 3 earlier" }));
 
     expect(findButtonByTextContent(/echo 1/i)).toBeTruthy();
   });
 
+  it("uses a bounded assistant bubble width for long markdown responses", () => {
+    const view = renderMessageList([
+      {
+        sessionId: "session-1",
+        timestamp: "2026-03-17T10:00:00.000Z",
+        event: {
+          type: "text",
+          text: "Streaming response",
+          itemId: "text-1",
+          turnId: "turn-1",
+        },
+      },
+    ]);
+
+    expect(view.container.innerHTML).toContain("max-w-[78ch]");
+  });
+
+  it("renders markdown tables inside a dedicated scroll shell", () => {
+    renderMessageList([
+      {
+        sessionId: "session-1",
+        timestamp: "2026-03-17T10:00:00.000Z",
+        event: {
+          type: "text",
+          text: [
+            "| Aspect | ADE | Other UI |",
+            "| --- | --- | --- |",
+            "| Task progress | Flat tool cards | Step-based progress |",
+          ].join("\n"),
+          itemId: "text-table",
+          turnId: "turn-1",
+        },
+      },
+    ]);
+
+    const table = screen.getByRole("table");
+    expect(table.parentElement?.className).toContain("overflow-x-auto");
+    expect(screen.getByText("Task progress")).toBeTruthy();
+  });
+
+  it("absorbs tool summaries into the grouped work-log header instead of rendering a separate row", () => {
+    renderMessageList([
+      {
+        sessionId: "session-1",
+        timestamp: "2026-03-17T10:00:00.000Z",
+        event: {
+          type: "tool_call",
+          tool: "functions.exec_command",
+          args: { cmd: "pwd" },
+          itemId: "tool-1",
+          turnId: "turn-1",
+        },
+      },
+      {
+        sessionId: "session-1",
+        timestamp: "2026-03-17T10:00:01.000Z",
+        event: {
+          type: "tool_result",
+          tool: "functions.exec_command",
+          result: { stdout: "/tmp/project" },
+          itemId: "tool-1",
+          turnId: "turn-1",
+          status: "completed",
+        },
+      },
+      {
+        sessionId: "session-1",
+        timestamp: "2026-03-17T10:00:02.000Z",
+        event: {
+          type: "tool_use_summary",
+          summary: "Checked the current working directory",
+          toolUseIds: ["tool-1"],
+          turnId: "turn-1",
+        },
+      },
+    ]);
+
+    expect(screen.getByText("Checked the current working directory")).toBeTruthy();
+    expect(screen.queryByText("Tool summary")).toBeNull();
+  });
+
   it("makes workspace markdown links open the Files tab", () => {
     renderMessageList(
       [
@@ -623,13 +701,16 @@ describe("AgentChatMessageList transcript rendering", () => {
       },
     );
 
-    expect(screen.getAllByText("1 of 2 tasks completed").length).toBeGreaterThanOrEqual(1);
-    expect(screen.getAllByText(/1 file changed/i).length).toBeGreaterThanOrEqual(1);
-    expect(screen.getAllByText(/1 background agent/i).length).toBeGreaterThanOrEqual(1);
+    expect(screen.getByText("Turn recap")).toBeTruthy();
+    expect(screen.getAllByText("1/2 complete").length).toBeGreaterThanOrEqual(1);
+    expect(screen.getAllByText(/^1 file$/i).length).toBeGreaterThanOrEqual(1);
+    expect(screen.getAllByText(/^1 agent$/i).length).toBeGreaterThanOrEqual(1);
     expect(screen.getAllByText("1 active").length).toBeGreaterThanOrEqual(1);
     expect(screen.getAllByText("+1").length).toBeGreaterThanOrEqual(1);
     expect(screen.getAllByText("-1").length).toBeGreaterThanOrEqual(1);
+    expect(screen.queryByRole("button", { name: "Review changes" })).toBeNull();
 
+    fireEvent.click(screen.getByText("Turn recap"));
     fireEvent.click(screen.getByRole("button", { name: "Review changes" }));
 
     expect(screen.getByTestId("location").textContent).toBe("/files::{\"laneId\":\"lane-123\"}");
@@ -659,6 +740,131 @@ describe("AgentChatMessageList transcript rendering", () => {
     expect(view.container.querySelector(".animate-spin.text-amber-400")).toBeFalsy();
   });
 
+  it("renders structured question blocks and forwards structured answers from option chips", () => {
+    const onApproval = vi.fn();
+    renderMessageList([
+      {
+        sessionId: "session-1",
+        timestamp: "2026-03-17T10:00:00.000Z",
+        event: {
+          type: "approval_request",
+          itemId: "approval-structured",
+          kind: "tool_call",
+          description: "Choose how to proceed",
+          turnId: "turn-1",
+          detail: {
+            request: {
+              requestId: "request-structured",
+              itemId: "approval-structured",
+              source: "codex",
+              kind: "structured_question",
+              title: "Input needed",
+              description: "Choose how to proceed",
+              questions: [
+                {
+                  id: "question_1",
+                  header: "Question 1",
+                  question: "Which area should we test first?",
+                  options: [
+                    { label: "Question flow", value: "question_flow" },
+                    { label: "Plan updates", value: "plan_updates" },
+                  ],
+                  allowsFreeform: true,
+                },
+                {
+                  id: "question_2",
+                  header: "Question 2",
+                  question: "What validation strategy should we use?",
+                  allowsFreeform: true,
+                },
+              ],
+              allowsFreeform: true,
+              blocking: true,
+              canProceedWithoutAnswer: false,
+            },
+          },
+        },
+      },
+    ], { onApproval });
+
+    expect(screen.getByText("Question 1")).toBeTruthy();
+    expect(screen.getByText("Question 2")).toBeTruthy();
+    fireEvent.click(screen.getByRole("button", { name: "Question flow" }));
+
+    expect(onApproval).toHaveBeenCalledWith(
+      "approval-structured",
+      "accept",
+      null,
+      { question_1: ["question_flow"] },
+    );
+  });
+
+  it("shows structured questions as declined once the first resolution arrives and disables stale option chips", () => {
+    const onApproval = vi.fn();
+    renderMessageList([
+      {
+        sessionId: "session-1",
+        timestamp: "2026-03-17T10:00:00.000Z",
+        event: {
+          type: "approval_request",
+          itemId: "approval-structured",
+          kind: "tool_call",
+          description: "Choose how to proceed",
+          turnId: "turn-1",
+          detail: {
+            request: {
+              requestId: "request-structured",
+              itemId: "approval-structured",
+              source: "codex",
+              kind: "structured_question",
+              title: "Input needed",
+              description: "Choose how to proceed",
+              questions: [
+                {
+                  id: "question_1",
+                  header: "Question 1",
+                  question: "Which area should we test first?",
+                  options: [
+                    { label: "Question flow", value: "question_flow" },
+                    { label: "Plan updates", value: "plan_updates" },
+                  ],
+                  allowsFreeform: true,
+                },
+              ],
+              allowsFreeform: true,
+              blocking: true,
+              canProceedWithoutAnswer: false,
+            },
+          },
+        },
+      },
+      {
+        sessionId: "session-1",
+        timestamp: "2026-03-17T10:00:01.000Z",
+        event: {
+          type: "pending_input_resolved",
+          itemId: "approval-structured",
+          resolution: "declined",
+          turnId: "turn-1",
+        },
+      },
+      {
+        sessionId: "session-1",
+        timestamp: "2026-03-17T10:00:02.000Z",
+        event: {
+          type: "pending_input_resolved",
+          itemId: "approval-structured",
+          resolution: "cancelled",
+        },
+      },
+    ], { onApproval });
+
+    expect(screen.getByText("Declined")).toBeTruthy();
+    expect(screen.queryByRole("button", { name: "Question flow" })).toBeNull();
+    expect(screen.queryByRole("button", { name: "Plan updates" })).toBeNull();
+    expect(onApproval).not.toHaveBeenCalled();
+  });
+
   it("labels provider chats as Codex and preserves explicit assistant labels", () => {
     renderMessageList([
       {
@@ -819,12 +1025,15 @@ describe("AgentChatMessageList transcript rendering", () => {
       },
     );
 
-    expect(screen.getAllByText("1 of 2 tasks completed").length).toBeGreaterThanOrEqual(1);
+    expect(screen.getByText("Turn recap")).toBeTruthy();
+    expect(screen.getAllByText("1/2 complete").length).toBeGreaterThanOrEqual(1);
     expect(screen.getAllByText("Inspect shared renderer").length).toBeGreaterThanOrEqual(1);
     expect(screen.getAllByText("Implement calmer transcript rows").length).toBeGreaterThanOrEqual(1);
-    expect(screen.getAllByText(/1 file changed/i).length).toBeGreaterThanOrEqual(1);
-    expect(screen.getAllByText(/1 background agent/i).length).toBeGreaterThanOrEqual(1);
+    expect(screen.getAllByText(/^1 file$/i).length).toBeGreaterThanOrEqual(1);
+    expect(screen.getAllByText(/^1 agent$/i).length).toBeGreaterThanOrEqual(1);
+    expect(screen.queryByRole("button", { name: /Review changes/i })).toBeNull();
 
+    fireEvent.click(screen.getByText("Turn recap"));
     fireEvent.click(screen.getByRole("button", { name: /Review changes/i }));
 
     expect(screen.getByTestId("location").textContent).toBe(
@@ -857,7 +1066,8 @@ describe("AgentChatMessageList transcript rendering", () => {
       },
     ]);
 
-    expect(screen.getByText("1 of 1 tasks completed")).toBeTruthy();
+    expect(screen.getByText("Turn recap")).toBeTruthy();
+    expect(screen.getAllByText("1/1 complete").length).toBeGreaterThanOrEqual(1);
     expect(screen.getAllByText(/Claude Sonnet 4\.6/).length).toBeGreaterThanOrEqual(1);
   });
 
@@ -896,14 +1106,14 @@ describe("AgentChatMessageList transcript rendering", () => {
       },
     ]);
 
-    const reasoningButtons = screen.getAllByRole("button", { name: /Thought for/i });
+    const reasoningButtons = screen.getAllByRole("button", { name: /Thought/i });
     expect(reasoningButtons).toHaveLength(2);
 
     fireEvent.click(reasoningButtons[0]!);
     fireEvent.click(reasoningButtons[1]!);
 
-    expect(screen.getByText("First thought.")).toBeTruthy();
-    expect(screen.getByText("Second thought.")).toBeTruthy();
+    expect(screen.getAllByText("First thought.")).toHaveLength(2);
+    expect(screen.getAllByText("Second thought.")).toHaveLength(2);
     expect(screen.queryByText("First thought.Second thought.")).toBeNull();
   });
 });
diff --git a/apps/desktop/src/renderer/components/chat/AgentChatMessageList.tsx b/apps/desktop/src/renderer/components/chat/AgentChatMessageList.tsx
index c204670f4..0f1f3becf 100644
--- a/apps/desktop/src/renderer/components/chat/AgentChatMessageList.tsx
+++ b/apps/desktop/src/renderer/components/chat/AgentChatMessageList.tsx
@@ -1,6 +1,7 @@
 import React, { useCallback, useEffect, useId, useLayoutEffect, useMemo, useRef, useState } from "react";
 import ReactMarkdown from "react-markdown";
 import remarkGfm from "remark-gfm";
+import { motion } from "motion/react";
 import { useLocation, useNavigate } from "react-router-dom";
 import {
   CaretDown,
@@ -23,6 +24,7 @@ import {
   Globe,
   ShieldCheck,
   CopySimple,
+  Brain,
 } from "@phosphor-icons/react";
 import type {
   AgentChatApprovalDecision,
@@ -58,6 +60,7 @@ import {
 } from "./chatTranscriptRows";
 
 const NAVIGATION_SURFACES = new Set(["work", "missions", "lanes", "cto"]);
+type PendingInputResolution = Extract<AgentChatEvent, { type: "pending_input_resolved" }>["resolution"];
 
 function readOperatorNavigationSuggestion(value: unknown): OperatorNavigationSuggestion | null {
   const record = readRecord(value);
@@ -345,7 +348,8 @@ function MessageCopyButton({
 
 /* ── Status indicators ── */
 
-function StatusIcon({ status }: { status: "running" | "completed" | "failed" }) {
+function StatusIcon({ status }: { status: "running" | "completed" | "failed" | "interrupted" }) {
+  if (status === "interrupted") return <ChatStatusGlyph status="waiting" size={13} />;
   if (status === "completed" || status === "failed") return <ChatStatusGlyph status={status} size={13} />;
   return <ChatStatusGlyph status="working" size={13} />;
 }
@@ -372,6 +376,7 @@ function statusColorClass(status: string | undefined): string {
   switch (status) {
     case "failed":
       return "text-red-400/70";
+    case "interrupted":
     case "running":
       return "text-amber-400/70";
     default:
@@ -539,7 +544,7 @@ const MarkdownBlock = React.memo(function MarkdownBlock({
   }, [onOpenWorkspacePath, workspaceLaneId]);
 
   return (
-    <div className="prose prose-invert max-w-none text-[13px] leading-[1.78] text-fg/92 prose-headings:mb-3 prose-headings:mt-6 prose-headings:font-sans prose-headings:font-semibold prose-headings:tracking-tight prose-headings:text-fg prose-p:my-3 prose-ul:my-3 prose-ul:pl-5 prose-ol:my-3 prose-ol:pl-5 prose-li:my-1.5 prose-li:pl-1 prose-strong:text-fg prose-blockquote:border-l-2 prose-blockquote:border-l-white/20 prose-blockquote:pl-4 prose-blockquote:text-fg/78 prose-hr:my-5 prose-hr:border-white/[0.08] prose-table:my-4 prose-th:border-white/[0.08] prose-th:bg-white/[0.03] prose-th:px-3 prose-th:py-2 prose-td:border-white/[0.06] prose-td:px-3 prose-td:py-2">
+    <div className="ade-prose-themed prose prose-invert max-w-none text-[13px] leading-[1.8] text-fg/96 prose-headings:mb-3 prose-headings:mt-6 prose-headings:font-sans prose-headings:font-semibold prose-headings:tracking-tight prose-headings:text-fg prose-p:my-3 prose-p:text-fg/88 prose-ul:my-3 prose-ul:pl-5 prose-ol:my-3 prose-ol:pl-5 prose-li:my-1.5 prose-li:pl-1 prose-li:text-fg/86 prose-strong:text-fg prose-blockquote:border-l-2 prose-blockquote:border-l-white/20 prose-blockquote:pl-4 prose-blockquote:text-fg/76 prose-hr:my-5 prose-hr:border-white/[0.08]">
       <ReactMarkdown
         remarkPlugins={[remarkGfm]}
         components={{
@@ -555,10 +560,23 @@ const MarkdownBlock = React.memo(function MarkdownBlock({
             </blockquote>
           ),
           table: ({ children }) => (
-            <div className="overflow-x-auto">
-              <table className="w-full border-collapse text-[12px]">{children}</table>
+            <div className="my-4 overflow-x-auto rounded-xl border border-white/[0.08] bg-black/20 shadow-[inset_0_1px_0_rgba(255,255,255,0.02)]">
+              <table className="min-w-full border-separate border-spacing-0 text-[12px]">{children}</table>
             </div>
           ),
+          thead: ({ children, node: _, ...props }) => <thead className="bg-white/[0.04]" {...props}>{children}</thead>,
+          tbody: ({ children, node: _, ...props }) => <tbody {...props}>{children}</tbody>,
+          tr: ({ children, node: _, ...props }) => <tr className="align-top" {...props}>{children}</tr>,
+          th: ({ children, node: _, ...props }) => (
+            <th className="border-b border-white/[0.08] px-3 py-2 text-left font-medium text-fg/82 first:rounded-tl-xl last:rounded-tr-xl" {...props}>
+              {children}
+            </th>
+          ),
+          td: ({ children, node: _, ...props }) => (
+            <td className="border-b border-white/[0.05] px-3 py-2 align-top text-fg/76 last:border-r-0" {...props}>
+              {children}
+            </td>
+          ),
           pre: ({ children }) => (
             <pre className={cn("my-3 max-h-80", RECESSED_BLOCK_CLASS)}>
               {children}
@@ -626,7 +644,8 @@ function CollapsibleCard({
   defaultOpen = false,
   forceOpen,
   summary,
-  className
+  className,
+  style: styleProp,
 }: {
   children: React.ReactNode;
   defaultOpen?: boolean;
@@ -634,6 +653,7 @@ function CollapsibleCard({
   forceOpen?: boolean;
   summary: React.ReactNode;
   className?: string;
+  style?: React.CSSProperties;
 }) {
   const [open, setOpen] = useState(defaultOpen);
   // Track whether the user explicitly collapsed while forceOpen is active
@@ -657,12 +677,12 @@ function CollapsibleCard({
   const isOpen = forceOpen === true ? !userCollapsed : open;
 
   return (
-    <div className={cn(GLASS_CARD_CLASS, "transition-colors", className)} style={SURFACE_INLINE_CARD_STYLE}>
+    <div className={cn(GLASS_CARD_CLASS, "transition-colors", className)} style={styleProp ?? SURFACE_INLINE_CARD_STYLE}>
       <button
         type="button"
         aria-expanded={isOpen}
         aria-controls={panelId}
-        className="flex w-full items-center gap-2 px-3.5 py-3 text-left font-mono text-[11px]"
+        className="flex w-full items-center gap-2 px-3.5 py-3 text-left font-sans text-[11px]"
         onClick={() => {
           if (forceOpen === true) {
             setUserCollapsed((v) => !v);
@@ -739,7 +759,7 @@ function ActivityIndicator({ activity, detail }: { activity: string; detail?: st
   const displayText = detail ? `${label}: ${replaceInternalToolNames(detail)}` : `${label}...`;
 
   return (
-    <div className="flex items-center gap-2 py-1 font-mono text-[12px] text-emerald-200/75">
+    <div className="flex items-center gap-2 py-1 font-sans text-[12px] text-emerald-200/75">
       <ThinkingDots toneClass="bg-emerald-300/75" />
       <span className="truncate">{displayText}</span>
     </div>
@@ -1075,7 +1095,7 @@ function FileChangeEventCard({
 function renderEvent(
   envelope: RenderEnvelope,
   options?: {
-    onApproval?: (itemId: string, decision: AgentChatApprovalDecision, responseText?: string | null) => void;
+    onApproval?: (itemId: string, decision: AgentChatApprovalDecision, responseText?: string | null, answers?: Record<string, string | string[]>) => void;
     turnModel?: { label: string; modelId?: string; model?: string } | null;
     surfaceMode?: ChatSurfaceMode;
     surfaceProfile?: ChatSurfaceProfile;
@@ -1084,6 +1104,7 @@ function renderEvent(
     onOpenWorkspacePath?: (path: string) => void;
     respondingApprovalIds?: Set<string>;
     pendingApprovalIds?: Set<string>;
+    resolvedInputStates?: Map<string, PendingInputResolution>;
   }
 ) {
   const event = envelope.event;
@@ -1117,7 +1138,17 @@ function renderEvent(
       );
     }
     return (
-      <div className="flex justify-end">
+      <motion.div
+        className="flex justify-end"
+        initial={{ opacity: 0.7, y: 20, scale: 1.02 }}
+        animate={{ opacity: 1, y: 0, scale: 1 }}
+        transition={{
+          type: "spring",
+          stiffness: 300,
+          damping: 24,
+          mass: 0.8,
+        }}
+      >
         <div className={cn(GLASS_CARD_CLASS, "group relative max-w-[82%] px-4 py-2.5")} style={MESSAGE_CARD_STYLE}>
           {deliveryChip ? (
             <span className={cn("mb-1 inline-flex items-center border px-1.5 py-0.5 font-sans text-[9px] font-medium", deliveryChip.className)}>
@@ -1132,7 +1163,7 @@ function renderEvent(
             <ChatAttachmentTray attachments={event.attachments} mode={options?.surfaceMode ?? "standard"} className="mt-1 px-0 py-0" />
           ) : null}
         </div>
-      </div>
+      </motion.div>
     );
   }
 
@@ -1147,7 +1178,7 @@ function renderEvent(
         <div
           className={cn(
             GLASS_CARD_CLASS,
-            "group max-w-[94%] px-4 py-3",
+            "group max-w-[78ch] px-5 py-4",
             options?.turnActive && "min-h-[5.5rem]",
           )}
           style={ASSISTANT_MESSAGE_CARD_STYLE}
@@ -1577,7 +1608,7 @@ function renderEvent(
         <CollapsibleCard
           defaultOpen={false}
           summary={
-            <div className="flex items-center gap-2 font-mono text-[11px]">
+            <div className="flex items-center gap-2 font-sans text-[11px]">
               <NoticeIcon size={12} weight="bold" className={style.text} />
               <span className={cn("inline-flex items-center border px-1.5 py-0.5 text-[9px] font-bold uppercase tracking-[0.16em]", style.border, style.bg, style.text)}>
                 {event.noticeKind.replace("_", " ")}
@@ -1594,12 +1625,12 @@ function renderEvent(
 
     return (
       <div className={cn(
-        "inline-flex items-center gap-2 rounded-[var(--chat-radius-pill)] border px-3 py-1.5 font-mono text-[10px] uppercase tracking-[0.16em]",
-        style.border, style.bg, style.text,
+        "inline-flex items-center gap-2 px-1 py-1 font-sans text-[10px]",
+        style.text,
       )}>
         <NoticeIcon size={11} weight="bold" />
-        <span className="text-[9px] font-bold">{event.noticeKind.replace("_", " ")}</span>
-        <span className="normal-case tracking-normal text-fg/55">{event.message}</span>
+        <span className="text-[9px] font-bold uppercase tracking-[0.16em]">{event.noticeKind.replace("_", " ")}</span>
+        <span className="normal-case tracking-normal text-fg/45">{event.message}</span>
       </div>
     );
   }
@@ -1608,6 +1639,7 @@ function renderEvent(
   if (event.type === "reasoning") {
     const reasoningText = event.text.trim();
     const isLive = Boolean(options?.turnActive);
+    const reasoningPreview = summarizeInlineText(reasoningText, 108);
 
     // Compute duration if we have timestamps
     const startTs = (event as any).startTimestamp ?? envelope.timestamp;
@@ -1620,18 +1652,32 @@ function renderEvent(
         defaultOpen={false}
         forceOpen={isLive ? true : undefined}
         summary={
-          <span className="font-mono text-[12px] text-fg/52">
+          <span className="flex flex-wrap items-center gap-x-2 gap-y-1 font-sans text-[11px] text-fg/52">
+            <Brain size={13} weight="duotone" className="text-fg/40" />
             {isLive ? (
               <span className="flex items-center gap-2">
                 <ThinkingDots toneClass="bg-fg/40" />
                 Thinking...
               </span>
             ) : (
-              `Thought for ${durationLabel}`
+              <>
+                <span className="font-medium text-fg/62">Thought</span>
+                {durationLabel ? (
+                  <span className="rounded-full border border-white/[0.08] bg-white/[0.03] px-2 py-0.5 text-[9px] text-fg/42">
+                    {durationLabel}
+                  </span>
+                ) : null}
+                {reasoningPreview ? (
+                  <span className="max-w-[32rem] truncate text-[10px] text-fg/40">
+                    {reasoningPreview}
+                  </span>
+                ) : null}
+              </>
             )}
           </span>
         }
-        className={WORK_LOG_CARD_CLASS}
+        className="border-0 bg-transparent rounded-none"
+        style={{ background: "transparent", border: "none" }}
       >
         <div className="text-fg/55 text-[12px] leading-relaxed">
           <MarkdownBlock markdown={reasoningText.length ? event.text : "Thinking..."} />
@@ -1773,7 +1819,8 @@ function renderEvent(
     const handleApproval = options?.onApproval ? (d: AgentChatApprovalDecision) => options.onApproval?.(event.itemId, d) : undefined;
     const isResponding = options?.respondingApprovalIds?.has(event.itemId) ?? false;
     const isPending = options?.pendingApprovalIds?.has(event.itemId) ?? true;
-    const isResolved = !isPending && !isResponding;
+    const resolvedState = options?.resolvedInputStates?.get(event.itemId) ?? null;
+    const isResolved = resolvedState != null || (!isPending && !isResponding);
     const detail = readRecord(event.detail);
     const request = readRecord(detail?.request);
     const requestKind = typeof request?.kind === "string" ? request.kind.trim() : "";
@@ -1782,20 +1829,45 @@ function renderEvent(
     const requestQuestions = Array.isArray(request?.questions)
       ? request.questions.map((question) => readRecord(question)).filter((question): question is Record<string, unknown> => question != null)
       : [];
-    const primaryQuestion = requestQuestions[0] ?? null;
-    const primaryQuestionText = typeof primaryQuestion?.question === "string" ? primaryQuestion.question.trim() : "";
-    const quickOptions = Array.isArray(primaryQuestion?.options)
-      ? primaryQuestion.options
-          .map((option) => readRecord(option))
-          .filter((option): option is Record<string, unknown> => option != null)
-          .map((option) => {
-            const label = typeof option.label === "string" ? option.label.trim() : "";
-            const value = typeof option.value === "string" ? option.value.trim() : label;
-            if (!label.length || !value.length) return null;
-            return { label, value };
-          })
-          .filter((option): option is { label: string; value: string } => option != null)
-      : [];
+    const questionCards = requestQuestions.map((question, index) => {
+      const header = typeof question.header === "string" && question.header.trim().length
+        ? question.header.trim()
+        : `Question ${index + 1}`;
+      const questionText = typeof question.question === "string" ? question.question.trim() : "";
+      const options = Array.isArray(question.options)
+        ? question.options
+            .map((option) => readRecord(option))
+            .filter((option): option is Record<string, unknown> => option != null)
+            .map((option) => {
+              const label = typeof option.label === "string" ? option.label.trim() : "";
+              const value = typeof option.value === "string" ? option.value.trim() : label;
+              if (!label.length || !value.length) return null;
+              return {
+                label,
+                value,
+                ...(typeof option.description === "string" && option.description.trim().length ? { description: option.description.trim() } : {}),
+                ...(option.recommended === true ? { recommended: true } : {}),
+              };
+            })
+            .filter((option): option is { label: string; value: string; description?: string; recommended?: boolean } => option != null)
+        : [];
+      return {
+        id: typeof question.id === "string" && question.id.trim().length ? question.id.trim() : `question_${index + 1}`,
+        header,
+        questionText,
+        options,
+        allowsFreeform: question.allowsFreeform !== false,
+        isSecret: question.isSecret === true,
+        defaultAssumption: typeof question.defaultAssumption === "string" && question.defaultAssumption.trim().length
+          ? question.defaultAssumption.trim()
+          : "",
+        impact: typeof question.impact === "string" && question.impact.trim().length
+          ? question.impact.trim()
+          : "",
+      };
+    });
+    const primaryQuestion = questionCards[0] ?? null;
+    const primaryQuestionText = primaryQuestion?.questionText ?? "";
     const detailTool = typeof detail?.tool === "string" ? detail.tool.trim() : "";
     const question = typeof detail?.question === "string" ? detail.question.trim() : "";
     const normalizedTool = detailTool.toLowerCase();
@@ -1844,17 +1916,50 @@ function renderEvent(
         ) : (
           <div className="text-[12px] leading-relaxed text-fg/75">{bodyText}</div>
         )}
-        {isQuestionRequest && quickOptions.length > 0 && options?.onApproval ? (
-          <div className="mt-3 flex flex-wrap items-center gap-1.5">
-            {quickOptions.map((option) => (
-              <button
-                key={option.value}
-                type="button"
-                className="rounded-[var(--chat-radius-pill)] border border-accent/25 bg-accent/[0.08] px-3 py-1 font-mono text-[9px] font-bold uppercase tracking-wider text-fg/80 transition-colors hover:bg-accent/[0.16]"
-                onClick={() => options.onApproval?.(event.itemId, "accept", option.value)}
-              >
-                {option.label}
-              </button>
+        {isQuestionRequest && questionCards.length > 0 ? (
+          <div className="mt-3 space-y-2">
+            {questionCards.map((card) => (
+              <div key={card.id} className="rounded-[calc(var(--chat-radius-card)-6px)] border border-white/[0.06] bg-black/15 px-3 py-2">
+                <div className="flex items-center justify-between gap-2">
+                  <span className="font-mono text-[10px] uppercase tracking-wider text-amber-300/75">
+                    {card.header}
+                  </span>
+                  {card.allowsFreeform ? (
+                    <span className="font-mono text-[9px] uppercase tracking-[0.14em] text-fg/30">
+                      Freeform allowed
+                    </span>
+                  ) : null}
+                </div>
+                <div className="mt-1.5 text-[12px] leading-relaxed text-fg/78 whitespace-pre-wrap">
+                  {card.questionText}
+                </div>
+                {card.defaultAssumption.length || card.impact.length || card.isSecret ? (
+                  <div className="mt-1.5 flex flex-wrap gap-1.5 font-mono text-[9px] uppercase tracking-[0.14em] text-fg/32">
+                    {card.isSecret ? <span>Secret answer</span> : null}
+                    {card.defaultAssumption.length ? <span>Assumption: {card.defaultAssumption}</span> : null}
+                    {card.impact.length ? <span>Impact: {card.impact}</span> : null}
+                  </div>
+                ) : null}
+                {card.options.length > 0 && options?.onApproval && !isResolved ? (
+                  <div className="mt-2 flex flex-wrap items-center gap-1.5">
+                    {card.options.map((option) => (
+                      <button
+                        key={`${card.id}:${option.value}`}
+                        type="button"
+                        className={cn(
+                          "rounded-[var(--chat-radius-pill)] border px-3 py-1 font-mono text-[9px] font-bold uppercase tracking-wider transition-colors",
+                          option.recommended
+                            ? "border-emerald-400/30 bg-emerald-500/[0.10] text-emerald-100/85 hover:bg-emerald-500/[0.18]"
+                            : "border-accent/25 bg-accent/[0.08] text-fg/80 hover:bg-accent/[0.16]",
+                        )}
+                        onClick={() => options.onApproval?.(event.itemId, "accept", null, { [card.id]: [option.value] })}
+                      >
+                        {option.label}
+                      </button>
+                    ))}
+                  </div>
+                ) : null}
+              </div>
             ))}
           </div>
         ) : null}
@@ -1871,9 +1976,43 @@ function renderEvent(
             </CollapsibleCard>
           </div>
         ) : null}
-        {isAskUser ? (
-          <div className="mt-3 border border-accent/15 bg-accent/[0.05] px-3 py-2 font-mono text-[10px] uppercase tracking-[0.16em] text-accent/65">
-            Answer this from the question modal to keep the agent moving.
+        {handleApproval && isAskUser && !isResolved ? (
+          <div className="mt-3 flex flex-wrap items-center gap-1.5">
+            <button
+              type="button"
+              disabled={isResponding}
+              className="border border-red-400/30 bg-red-500/10 px-3 py-1.5 font-mono text-[10px] font-bold uppercase tracking-wider text-red-200/80 transition-colors hover:bg-red-500/20 disabled:opacity-40 disabled:pointer-events-none"
+              onClick={() => handleApproval("decline")}
+            >
+              Decline
+            </button>
+          </div>
+        ) : null}
+        {isAskUser && isResolved ? (
+          <div className="mt-3 flex flex-wrap items-center gap-1.5">
+            <span
+              className={cn(
+                "inline-flex items-center gap-1.5 rounded-[var(--chat-radius-pill)] px-3 py-1.5 font-mono text-[10px] font-bold uppercase tracking-wider",
+                resolvedState === "accepted"
+                  ? "border border-emerald-500/20 bg-emerald-500/8 text-emerald-300/70"
+                  : resolvedState === "declined"
+                    ? "border border-red-500/20 bg-red-500/8 text-red-300/75"
+                    : "border border-border/25 bg-transparent text-fg/45",
+              )}
+            >
+              {resolvedState === "accepted" ? (
+                <Check size={12} weight="bold" />
+              ) : resolvedState === "declined" ? (
+                <XCircle size={12} weight="bold" />
+              ) : (
+                <Circle size={12} weight="bold" />
+              )}
+              {resolvedState === "accepted"
+                ? "Answered"
+                : resolvedState === "declined"
+                  ? "Declined"
+                  : "Closed"}
+            </span>
           </div>
         ) : null}
         {handleApproval && !isAskUser ? (
@@ -2067,13 +2206,13 @@ function renderEvent(
         : "border-amber-500/15 bg-amber-500/[0.05] text-amber-300";
 
     return (
-      <div className={cn("flex items-start justify-between gap-3 rounded-lg border px-3 py-1.5 font-sans text-[10px]", statusTone)}>
-        <div className="flex min-w-0 flex-1 flex-wrap items-center gap-x-2 gap-y-1">
+      <div className={cn("flex items-center justify-center gap-3 rounded-lg border px-3 py-1.5 font-sans text-[10px]", statusTone)}>
+        <div className="flex flex-wrap items-center justify-center gap-x-2 gap-y-1">
           <span className="font-medium text-fg/40">Usage</span>
           {modelLabel ? (
-            <span className="inline-flex min-w-0 max-w-full items-center gap-1.5 text-fg/35">
+            <span className="inline-flex items-center gap-1.5 text-fg/35">
               <ModelGlyph modelId={event.modelId} model={event.model} size={10} className="shrink-0 text-fg/40" />
-              <span className="min-w-0 break-words">{modelLabel}</span>
+              <span>{modelLabel}</span>
             </span>
           ) : null}
           {inputTokens ? <span className="text-fg/30">In {inputTokens}</span> : null}
@@ -2081,10 +2220,10 @@ function renderEvent(
           {cacheRead ? <span className="text-emerald-400/35">Cache {cacheRead}</span> : null}
           {cacheCreation ? <span className="text-violet-400/35">New cache {cacheCreation}</span> : null}
           {costLabel ? <span className="text-fg/30">{costLabel}</span> : null}
+          {event.status !== "completed" ? (
+            <span className="text-[9px] font-medium uppercase tracking-wide text-current">{event.status}</span>
+          ) : null}
         </div>
-        {event.status !== "completed" ? (
-          <span className="shrink-0 self-center text-[9px] font-medium uppercase tracking-wide text-current">{event.status}</span>
-        ) : null}
       </div>
     );
   }
@@ -2261,74 +2400,150 @@ function TurnSummaryCard({
   const completedCount = summary.tasks.filter((task) => task.status === "completed").length;
   const totalCount = summary.tasks.length;
   const filesLabel = summary.files.length
-    ? `${summary.files.length} file${summary.files.length === 1 ? "" : "s"} changed`
+    ? `${summary.files.length} file${summary.files.length === 1 ? "" : "s"}`
     : null;
   const agentsLabel = summary.backgroundAgentCount
-    ? `${summary.backgroundAgentCount} background agent${summary.backgroundAgentCount === 1 ? "" : "s"}`
+    ? `${summary.backgroundAgentCount} agent${summary.backgroundAgentCount === 1 ? "" : "s"}`
     : null;
+  const taskLabel = totalCount ? `${completedCount}/${totalCount} complete` : null;
+  const hasDetails = summary.tasks.length > 0 || summary.files.length > 0 || summary.backgroundAgentCount > 0;
+
+  const summaryHeader = (
+    <div className="flex min-w-0 flex-wrap items-center gap-x-2 gap-y-1 font-mono text-[10px] text-fg/46">
+      <span className="inline-flex items-center gap-1 rounded-full border border-white/[0.08] bg-white/[0.03] px-2 py-0.5 text-[9px] uppercase tracking-[0.14em] text-fg/44">
+        <ListChecks size={10} weight="bold" className="text-fg/44" />
+        Turn recap
+      </span>
+      {taskLabel ? (
+        <span className="font-medium text-fg/74">{taskLabel}</span>
+      ) : null}
+      {filesLabel ? (
+        <span className="text-fg/56">
+          {filesLabel}
+          {summary.totalAdditions > 0 ? <span className="ml-1.5 text-emerald-300/70">+{summary.totalAdditions}</span> : null}
+          {summary.totalDeletions > 0 ? <span className="ml-1 text-red-300/70">-{summary.totalDeletions}</span> : null}
+        </span>
+      ) : null}
+      {agentsLabel ? (
+        <span className="text-fg/56">
+          {agentsLabel}
+          {summary.activeBackgroundAgentCount > 0 ? <span className="ml-1.5 text-sky-300/60">{summary.activeBackgroundAgentCount} active</span> : null}
+        </span>
+      ) : null}
+      {summary.turnModel?.label ? (
+        <span className="inline-flex items-center gap-1 rounded-full border border-white/[0.08] bg-white/[0.03] px-1.5 py-0.5 text-[9px] text-fg/42">
+          <ModelGlyph modelId={summary.turnModel.modelId} model={summary.turnModel.model} size={10} className="text-fg/32" />
+          <span>{summary.turnModel.label}</span>
+        </span>
+      ) : null}
+    </div>
+  );
 
-  return (
-    <div className="overflow-hidden rounded-[20px] border border-white/[0.08] bg-[linear-gradient(180deg,rgba(26,26,29,0.92),rgba(19,19,22,0.94))] shadow-[0_24px_80px_-48px_rgba(0,0,0,0.85)]">
-      <div className="border-b border-white/[0.05] px-4 py-3">
-        <div className="flex items-center gap-2">
-          <ListChecks size={13} weight="bold" className="text-fg/58" />
-          <span className="font-sans text-[13px] font-medium text-fg/86">
-            {totalCount
-              ? `${completedCount} of ${totalCount} tasks completed`
-              : filesLabel ?? agentsLabel ?? "Turn summary"}
-          </span>
-          {summary.turnModel?.label ? (
-            <span className="inline-flex items-center gap-1 rounded-full border border-white/[0.08] bg-white/[0.03] px-2 py-0.5 font-mono text-[10px] text-fg/45">
-              <ModelGlyph modelId={summary.turnModel.modelId} model={summary.turnModel.model} size={10} className="text-fg/35" />
-              <span>{summary.turnModel.label}</span>
+  const details = hasDetails ? (
+    <div className="space-y-3 pb-0.5">
+      {summary.tasks.length > 0 ? (
+        <div className="space-y-1.5">
+          <div className="font-mono text-[9px] uppercase tracking-[0.14em] text-muted-fg/42">Tasks</div>
+          <div className="space-y-1.5">
+            {summary.tasks.map((task) => (
+              <div
+                key={task.id}
+                className="flex items-start gap-2 rounded-md border border-white/[0.05] bg-black/10 px-2.5 py-2"
+              >
+                <div className="mt-0.5 flex-shrink-0">
+                  <PlanStepIcon status={task.status} />
+                </div>
+                <div
+                  className={cn(
+                    "min-w-0 flex-1 text-[12px] leading-5",
+                    task.status === "completed" ? "text-fg/45 line-through decoration-fg/15" : "text-fg/78",
+                  )}
+                >
+                  {task.description}
+                </div>
+                <span
+                  className={cn(
+                    "inline-flex shrink-0 items-center border px-1.5 py-0.5 text-[8px] font-bold uppercase tracking-[0.16em]",
+                    todoItemStatusClass(task.status),
+                  )}
+                >
+                  {task.status.replace("_", " ")}
+                </span>
+              </div>
+            ))}
+          </div>
+        </div>
+      ) : null}
+      {summary.files.length > 0 ? (
+        <div className="space-y-1.5">
+          <div className="font-mono text-[9px] uppercase tracking-[0.14em] text-muted-fg/42">Files</div>
+          <div className="space-y-1.5">
+            {summary.files.map((file) => {
+              const basename = basenamePathLabel(file.path);
+              const dirname = dirnamePathLabel(file.path);
+              return (
+                <div
+                  key={`${file.path}:${file.kind}`}
+                  className="flex items-start gap-2 rounded-md border border-white/[0.05] bg-black/10 px-2.5 py-2"
+                >
+                  <div className="mt-0.5 flex-shrink-0">
+                    <FileCode size={12} weight="regular" className="text-fg/38" />
+                  </div>
+                  <div className="min-w-0 flex-1">
+                    <div className="flex flex-wrap items-center gap-x-2 gap-y-1 text-[12px] leading-5 text-fg/78">
+                      <span className="font-medium">{formatFileAction(file.kind)}</span>
+                      <span>{basename}</span>
+                      {file.additions > 0 ? <span className="text-emerald-300/70">+{file.additions}</span> : null}
+                      {file.deletions > 0 || file.kind === "delete" ? <span className="text-red-300/70">-{file.deletions}</span> : null}
+                    </div>
+                    {dirname ? (
+                      <div className="truncate font-mono text-[10px] text-fg/34">
+                        {dirname}
+                      </div>
+                    ) : null}
+                  </div>
+                </div>
+              );
+            })}
+          </div>
+        </div>
+      ) : null}
+      {summary.backgroundAgentCount > 0 ? (
+        <div className="rounded-md border border-white/[0.05] bg-black/10 px-2.5 py-2">
+          <div className="mb-1 font-mono text-[9px] uppercase tracking-[0.14em] text-muted-fg/42">Background agents</div>
+          <div className="flex flex-wrap items-center gap-2 text-[12px] text-fg/72">
+            <Robot size={12} weight="regular" className="text-fg/38" />
+            <span>
+              {summary.activeBackgroundAgentCount === summary.backgroundAgentCount
+                ? `${summary.backgroundAgentCount} background ${summary.backgroundAgentCount === 1 ? "agent" : "agents"} running`
+                : summary.activeBackgroundAgentCount > 0
+                  ? `${summary.activeBackgroundAgentCount} of ${summary.backgroundAgentCount} background ${summary.backgroundAgentCount === 1 ? "agent" : "agents"} still running`
+                  : `${summary.backgroundAgentCount} background ${summary.backgroundAgentCount === 1 ? "agent" : "agents"} completed`}
             </span>
-          ) : null}
-          {onReviewChanges && summary.files.length > 0 ? (
-            <button
-              type="button"
-              className="ml-auto inline-flex items-center gap-1 rounded-md border border-white/[0.08] bg-white/[0.03] px-2.5 py-1 text-[11px] text-fg/70 transition-colors hover:bg-white/[0.05] hover:text-fg/88"
-              onClick={onReviewChanges}
-            >
-              Review changes
-            </button>
-          ) : null}
+          </div>
         </div>
-      </div>
-
-      {summary.tasks.length ? (
-        <div className="space-y-1 border-b border-white/[0.05] px-4 py-3">
-          {summary.tasks.map((task, index) => (
-            <div key={task.id || `${task.description}:${index}`} className="flex items-start gap-2.5 py-1">
-              <div className="mt-0.5 shrink-0">
-                <PlanStepIcon status={task.status} />
-              </div>
-              <div className={cn(
-                "flex-1 text-[12px] leading-6",
-                task.status === "completed" ? "text-fg/42 line-through decoration-fg/15" : "text-fg/82",
-              )}>
-                {task.description}
-              </div>
-            </div>
-          ))}
+      ) : null}
+      {onReviewChanges && summary.files.length > 0 ? (
+        <div className="flex justify-end">
+          <button
+            type="button"
+            className="inline-flex items-center gap-1 rounded-md border border-white/[0.08] bg-white/[0.03] px-2.5 py-1 text-[11px] text-fg/70 transition-colors hover:bg-white/[0.05] hover:text-fg/88"
+            onClick={onReviewChanges}
+          >
+            Review changes
+          </button>
         </div>
       ) : null}
-
-      <div className="flex flex-wrap items-center gap-3 px-4 py-3 font-mono text-[10px] text-fg/44">
-        {filesLabel ? (
-          <span>
-            {filesLabel}
-            {summary.totalAdditions > 0 ? <span className="ml-2 text-emerald-300/70">+{summary.totalAdditions}</span> : null}
-            {summary.totalDeletions > 0 ? <span className="ml-1 text-red-300/70">-{summary.totalDeletions}</span> : null}
-          </span>
-        ) : null}
-        {agentsLabel ? (
-          <span>
-            {agentsLabel}
-            {summary.activeBackgroundAgentCount > 0 ? <span className="ml-2 text-sky-300/60">{summary.activeBackgroundAgentCount} active</span> : null}
-          </span>
-        ) : null}
-      </div>
     </div>
+  ) : null;
+
+  return (
+    <InlineDisclosureRow
+      summary={summaryHeader}
+      className="rounded-xl border border-white/[0.05] bg-[#0f1116]/66 px-1 py-0.5"
+    >
+      {details}
+    </InlineDisclosureRow>
   );
 }
 
@@ -2361,7 +2576,7 @@ function deriveActiveTurnId(events: AgentChatEventEnvelope[]): string | null {
 function getGroupedTurnId(envelope: TranscriptGroupedEnvelope | undefined): string | null {
   if (!envelope) return null;
   if (envelope.event.type === "work_log_group") {
-    return envelope.event.entries[0]?.turnId ?? null;
+    return envelope.event.turnId ?? envelope.event.entries[0]?.turnId ?? null;
   }
   return "turnId" in envelope.event ? envelope.event.turnId ?? null : null;
 }
@@ -2373,7 +2588,7 @@ type EventRowProps = {
   showTurnDivider: boolean;
   turnDividerLabel: string | null;
   turnModel: { label: string; modelId?: string; model?: string } | null;
-  onApproval?: (itemId: string, decision: AgentChatApprovalDecision, responseText?: string | null) => void;
+  onApproval?: (itemId: string, decision: AgentChatApprovalDecision, responseText?: string | null, answers?: Record<string, string | string[]>) => void;
   surfaceMode?: ChatSurfaceMode;
   surfaceProfile?: ChatSurfaceProfile;
   assistantLabel?: string;
@@ -2382,6 +2597,7 @@ type EventRowProps = {
   onNavigateSuggestion?: (suggestion: OperatorNavigationSuggestion) => void;
   respondingApprovalIds?: Set<string>;
   pendingApprovalIds?: Set<string>;
+  resolvedInputStates?: Map<string, PendingInputResolution>;
 };
 
 const EventRow = React.memo(function EventRow({
@@ -2398,6 +2614,7 @@ const EventRow = React.memo(function EventRow({
   onNavigateSuggestion,
   respondingApprovalIds,
   pendingApprovalIds,
+  resolvedInputStates,
 }: EventRowProps) {
   return (
     <div className="space-y-3">
@@ -2421,10 +2638,22 @@ const EventRow = React.memo(function EventRow({
         ? (
           <ChatWorkLogBlock
             entries={envelope.event.entries}
+            summary={envelope.event.summary}
             onNavigateSuggestion={onNavigateSuggestion}
           />
         )
-        : renderEvent(envelope as RenderEnvelope, { onApproval, turnModel, surfaceMode, surfaceProfile, assistantLabel, turnActive, onOpenWorkspacePath, respondingApprovalIds, pendingApprovalIds })}
+        : renderEvent(envelope as RenderEnvelope, {
+            onApproval,
+            turnModel,
+            surfaceMode,
+            surfaceProfile,
+            assistantLabel,
+            turnActive,
+            onOpenWorkspacePath,
+            respondingApprovalIds,
+            pendingApprovalIds,
+            resolvedInputStates,
+          })}
     </div>
   );
 });
@@ -2567,19 +2796,19 @@ export function reconcileMeasuredScrollTop({
 export function AgentChatMessageList({
   events,
   showStreamingIndicator = false,
-  className,
-  onApproval,
-  surfaceMode = "standard",
+    className,
+    onApproval,
+    surfaceMode = "standard",
   surfaceProfile = "standard",
   assistantLabel,
   onOpenWorkspacePath,
   respondingApprovalIds,
   pendingApprovalIds,
-}: {
+  }: {
   events: AgentChatEventEnvelope[];
   showStreamingIndicator?: boolean;
   className?: string;
-  onApproval?: (itemId: string, decision: AgentChatApprovalDecision, responseText?: string | null) => void;
+  onApproval?: (itemId: string, decision: AgentChatApprovalDecision, responseText?: string | null, answers?: Record<string, string | string[]>) => void;
   surfaceMode?: ChatSurfaceMode;
   surfaceProfile?: ChatSurfaceProfile;
   assistantLabel?: string;
@@ -2598,6 +2827,16 @@ export function AgentChatMessageList({
   const [filesWorkspaces, setFilesWorkspaces] = useState<FilesWorkspace[]>([]);
   const stickToBottomRef = useRef(true);
   const onApprovalRef = useRef(onApproval);
+  const resolvedInputStates = useMemo(() => {
+    const resolved = new Map<string, PendingInputResolution>();
+    for (const envelope of events) {
+      if (envelope.event.type !== "pending_input_resolved") continue;
+      if (!resolved.has(envelope.event.itemId)) {
+        resolved.set(envelope.event.itemId, envelope.event.resolution);
+      }
+    }
+    return resolved;
+  }, [events]);
 
   // Virtualization scroll tracking
   const [scrollTop, setScrollTop] = useState(0);
@@ -2616,8 +2855,8 @@ export function AgentChatMessageList({
     onApprovalRef.current = onApproval;
   }, [onApproval]);
 
-  const handleApproval = useCallback((itemId: string, decision: AgentChatApprovalDecision, responseText?: string | null) => {
-    onApprovalRef.current?.(itemId, decision, responseText);
+  const handleApproval = useCallback((itemId: string, decision: AgentChatApprovalDecision, responseText?: string | null, answers?: Record<string, string | string[]>) => {
+    onApprovalRef.current?.(itemId, decision, responseText, answers);
   }, []);
 
   const rows = useMemo(() => {
@@ -2863,6 +3102,7 @@ export function AgentChatMessageList({
           onNavigateSuggestion={handleNavigateSuggestion}
           respondingApprovalIds={respondingApprovalIds}
           pendingApprovalIds={pendingApprovalIds}
+          resolvedInputStates={resolvedInputStates}
         />
       );
     }
@@ -2883,9 +3123,10 @@ export function AgentChatMessageList({
         onNavigateSuggestion={handleNavigateSuggestion}
         respondingApprovalIds={respondingApprovalIds}
         pendingApprovalIds={pendingApprovalIds}
+        resolvedInputStates={resolvedInputStates}
       />
     );
-  }, [activeTurnId, assistantLabel, surfaceMode, surfaceProfile, groupedRows, turnModelState, handleApproval, handleMeasure, openWorkspacePath, handleNavigateSuggestion, respondingApprovalIds, pendingApprovalIds]);
+  }, [activeTurnId, assistantLabel, surfaceMode, surfaceProfile, groupedRows, turnModelState, handleApproval, handleMeasure, openWorkspacePath, handleNavigateSuggestion, respondingApprovalIds, pendingApprovalIds, resolvedInputStates]);
 
   // Compute the bottom spacer height for virtualized mode.
   const bottomSpacerHeight = useMemo(() => {
@@ -2906,7 +3147,7 @@ export function AgentChatMessageList({
       {latestActivity ? (
         <ActivityIndicator activity={latestActivity.activity} detail={latestActivity.detail} />
       ) : (
-        <div className="flex items-center gap-2 py-1 font-mono text-[12px] text-emerald-200/75">
+        <div className="flex items-center gap-2 py-1 font-sans text-[12px] text-emerald-200/75">
           <ThinkingDots toneClass="bg-emerald-300/75" />
           <span>Working...</span>
         </div>
@@ -2925,18 +3166,7 @@ export function AgentChatMessageList({
       onScroll={handleScroll}
     >
       {rows.length === 0 && !streamingIndicator ? (
-        <div className="flex h-full flex-col items-center justify-center gap-5">
-          <div className="relative flex h-20 w-20 items-center justify-center rounded-full border border-[color:color-mix(in_srgb,var(--chat-accent)_24%,transparent)] bg-[color:color-mix(in_srgb,var(--chat-accent)_10%,transparent)]">
-            <Robot size={34} weight="thin" className="text-[var(--chat-accent)]" />
-            <div className="absolute inset-0 animate-pulse rounded-full bg-[var(--chat-accent-glow)] blur-2xl" />
-          </div>
-          <div className="space-y-1 text-center">
-            <div className="font-sans text-[18px] font-semibold tracking-tight text-fg/78">Start a chat session</div>
-            <span className="font-mono text-[10px] uppercase tracking-[2px] text-muted-fg/28">
-              {surfaceMode === "resolver" ? "Launch the resolver to start the transcript" : "Start a conversation"}
-            </span>
-          </div>
-        </div>
+        null
       ) : shouldVirtualize ? (
         /* ── Virtualized path: only render rows in / near the viewport ── */
         <div className="space-y-3">
diff --git a/apps/desktop/src/renderer/components/chat/AgentChatPane.submit.test.tsx b/apps/desktop/src/renderer/components/chat/AgentChatPane.submit.test.tsx
index 23906ca95..20c695b38 100644
--- a/apps/desktop/src/renderer/components/chat/AgentChatPane.submit.test.tsx
+++ b/apps/desktop/src/renderer/components/chat/AgentChatPane.submit.test.tsx
@@ -7,6 +7,7 @@ import { MemoryRouter } from "react-router-dom";
 import {
   createDefaultComputerUsePolicy,
   type AgentChatEventEnvelope,
+  type AgentChatSession,
   type AgentChatSessionSummary,
 } from "../../../shared/types";
 import { getModelById } from "../../../shared/modelRegistry";
@@ -41,6 +42,24 @@ function buildSession(sessionId: string, overrides: Partial<AgentChatSessionSumm
   };
 }
 
+function buildCreatedSession(sessionId: string, overrides: Partial<AgentChatSession> = {}): AgentChatSession {
+  return {
+    id: sessionId,
+    laneId: "lane-1",
+    provider: "codex",
+    model: "gpt-5.4",
+    modelId: "openai/gpt-5.4-codex",
+    status: "idle",
+    sessionProfile: "workflow",
+    reasoningEffort: "xhigh",
+    executionMode: "focused",
+    computerUse: createDefaultComputerUsePolicy(),
+    createdAt: "2026-03-24T05:57:45.700Z",
+    lastActivityAt: "2026-03-24T05:57:45.700Z",
+    ...overrides,
+  };
+}
+
 function buildStatusStartedTranscript(sessionId: string): string {
   return `${JSON.stringify({
     sessionId,
@@ -76,7 +95,7 @@ function installAdeMocks(options?: {
   sendError?: Error;
   steerError?: Error;
   listError?: Error;
-  handoffResult?: { session: { id: string }; usedFallbackSummary: boolean };
+  handoffResult?: { session: AgentChatSession; usedFallbackSummary: boolean };
   sessions?: AgentChatSessionSummary[];
   includeClaudeModel?: boolean;
 }) {
@@ -90,9 +109,10 @@ function installAdeMocks(options?: {
     ? vi.fn().mockRejectedValue(options.listError)
     : vi.fn().mockResolvedValue(options?.sessions ?? [buildSession("session-1")]);
   const handoff = vi.fn().mockResolvedValue(options?.handoffResult ?? {
-    session: { id: "handoff-session-1" },
+    session: buildCreatedSession("handoff-session-1"),
     usedFallbackSummary: false,
   });
+  const create = vi.fn().mockResolvedValue(buildCreatedSession("created-session"));
   const chatEventListeners = new Set<(event: AgentChatEventEnvelope) => void>();
 
   globalThis.window.ade = {
@@ -134,7 +154,7 @@ function installAdeMocks(options?: {
       respondToInput: vi.fn().mockResolvedValue(undefined),
       warmupModel: vi.fn().mockResolvedValue(undefined),
       fileSearch: vi.fn().mockResolvedValue([]),
-      create: vi.fn().mockResolvedValue({ id: "created-session" }),
+      create,
       dispose: vi.fn().mockResolvedValue(undefined),
     },
     sessions: {
@@ -158,6 +178,7 @@ function installAdeMocks(options?: {
     send,
     steer,
     list,
+    create,
     handoff,
     emitChatEvent: (event: AgentChatEventEnvelope) => {
       for (const listener of chatEventListeners) {
@@ -257,6 +278,38 @@ describe("AgentChatPane submit recovery", () => {
     expect(await screen.findByLabelText("Waiting for your input")).toBeTruthy();
   });
 
+  it("falls back to the session summary when a chat is awaiting input", async () => {
+    const session = buildSession("session-1", {
+      status: "active",
+      awaitingInput: true,
+    });
+    installAdeMocks({
+      sessions: [session],
+    });
+
+    renderTabbedPane(session);
+
+    expect(await screen.findByLabelText("Waiting for your input")).toBeTruthy();
+    expect(screen.queryByLabelText("Agent working")).toBeNull();
+  });
+
+  it("does not keep showing a working indicator when the session summary is idle", async () => {
+    const session = buildSession("session-1", {
+      status: "idle",
+    });
+    installAdeMocks({
+      sessions: [session],
+      transcript: buildStatusStartedTranscript(session.sessionId),
+    });
+
+    renderTabbedPane(session);
+
+    await waitFor(() => {
+      expect(screen.queryByLabelText("Agent working")).toBeNull();
+    });
+    expect(screen.getByLabelText("Ready for next prompt")).toBeTruthy();
+  });
+
   it("keeps the draft cleared after send succeeds even if session refresh fails", async () => {
     const session = buildSession("session-1");
     const { send, list } = installAdeMocks({
@@ -600,7 +653,7 @@ describe("AgentChatPane submit recovery", () => {
     const onSessionCreated = vi.fn().mockResolvedValue(undefined);
     const { handoff } = installAdeMocks({
       handoffResult: {
-        session: { id: "session-2" },
+        session: buildCreatedSession("session-2"),
         usedFallbackSummary: false,
       },
     });
@@ -625,7 +678,43 @@ describe("AgentChatPane submit recovery", () => {
         sourceSessionId: session.sessionId,
         targetModelId: "openai/gpt-5.4-mini",
       });
-      expect(onSessionCreated).toHaveBeenCalledWith("session-2");
+      expect(onSessionCreated).toHaveBeenCalledWith(expect.objectContaining({ id: "session-2" }));
+    });
+  });
+
+  it("does not wait for onSessionCreated before sending the first message in a new chat", async () => {
+    const onSessionCreated = vi.fn().mockImplementation(() => new Promise<void>(() => {}));
+    const { send, create } = installAdeMocks({ sessions: [] });
+
+    render(
+      <MemoryRouter>
+        <AgentChatPane
+          laneId="lane-1"
+          forceNewSession
+          onSessionCreated={onSessionCreated}
+        />
+      </MemoryRouter>,
+    );
+
+    const trigger = await screen.findByRole("button", { name: "Select model" });
+    const codexLabel = getModelById("openai/gpt-5.4-codex")?.displayName ?? "GPT-5.4 Codex";
+
+    fireEvent.click(trigger);
+    fireEvent.click(await screen.findByRole("button", { name: /OpenAI/i }));
+    await clickEnabledModelOption(new RegExp(escapeRegExp(codexLabel), "i"));
+
+    const textbox = await screen.findByRole("textbox");
+    fireEvent.change(textbox, { target: { value: "Ship the instant route fix." } });
+    fireEvent.click(screen.getByTitle("Send"));
+
+    await waitFor(() => {
+      expect(create).toHaveBeenCalled();
+      expect(onSessionCreated).toHaveBeenCalledWith(expect.objectContaining({ id: "created-session" }));
+      expect(send).toHaveBeenCalledWith(expect.objectContaining({
+        sessionId: "created-session",
+        text: "Ship the instant route fix.",
+        displayText: "Ship the instant route fix.",
+      }));
     });
   });
 
diff --git a/apps/desktop/src/renderer/components/chat/AgentChatPane.tsx b/apps/desktop/src/renderer/components/chat/AgentChatPane.tsx
index a84bfa5f4..8340d840f 100644
--- a/apps/desktop/src/renderer/components/chat/AgentChatPane.tsx
+++ b/apps/desktop/src/renderer/components/chat/AgentChatPane.tsx
@@ -1,5 +1,6 @@
 import { useCallback, useEffect, useMemo, useRef, useState } from "react";
 import { useNavigate } from "react-router-dom";
+import { AnimatePresence, motion } from "motion/react";
 import { GitBranch, Plus } from "@phosphor-icons/react";
 import {
   createDefaultComputerUsePolicy,
@@ -14,6 +15,7 @@ import {
   type AgentChatFileRef,
   type AgentChatInteractionMode,
   type AiProviderConnectionStatus,
+  type AgentChatSession,
   type AgentChatUnifiedPermissionMode,
   type AgentChatSessionProfile,
   type ChatSurfaceChip,
@@ -36,7 +38,6 @@ import { CURSOR_AVAILABLE_MODE_IDS } from "../../../shared/cursorModes";
 import { cn } from "../ui/cn";
 import { AgentChatComposer } from "./AgentChatComposer";
 import { AgentChatMessageList } from "./AgentChatMessageList";
-import { AgentQuestionModal } from "./AgentQuestionModal";
 import { ChatStatusGlyph } from "./chatStatusVisuals";
 import { isChatToolType } from "../../lib/sessions";
 import { ToolLogo } from "../terminals/ToolLogos";
@@ -534,7 +535,10 @@ export function AgentChatPane({
   permissionModeLocked = false,
   presentation,
   embeddedWorkLayout = false,
+  layoutVariant = "standard",
   onSessionCreated,
+  availableLanes,
+  onLaneChange,
 }: {
   laneId: string | null;
   laneLabel?: string | null;
@@ -550,7 +554,12 @@ export function AgentChatPane({
   presentation?: ChatSurfacePresentation;
   /** Work tab draft: flatter shell, no duplicate header chrome above the composer. */
   embeddedWorkLayout?: boolean;
-  onSessionCreated?: (sessionId: string) => void | Promise<void>;
+  layoutVariant?: "standard" | "grid-tile";
+  onSessionCreated?: (session: AgentChatSession) => void | Promise<void>;
+  /** Available lanes for the lane selector in empty state */
+  availableLanes?: Array<{ id: string; name: string; color?: string | null }>;
+  /** Callback when lane selection changes in empty state */
+  onLaneChange?: (laneId: string) => void;
 }) {
   const navigate = useNavigate();
   const openAiProvidersSettings = useCallback(() => {
@@ -611,6 +620,10 @@ export function AgentChatPane({
   const [handoffOpen, setHandoffOpen] = useState(false);
   const [handoffBusy, setHandoffBusy] = useState(false);
   const [handoffModelId, setHandoffModelId] = useState("");
+  const shellRef = useRef<HTMLElement | null>(null);
+  const [composerMaxHeightPx, setComposerMaxHeightPx] = useState<number | null>(null);
+  const composerMaxHeightPxRef = useRef<number | null>(null);
+  const sessionsRef = useRef<AgentChatSessionSummary[]>(sessions);
 
   const appliedInitialSessionIdRef = useRef<string | null>(initialSessionId ?? null);
   const loadedHistoryRef = useRef<Set<string>>(new Set());
@@ -652,6 +665,8 @@ export function AgentChatPane({
     return [...selectedEvents, optimisticOutgoingMessage.envelope];
   }, [optimisticOutgoingMessage, selectedEvents, selectedSessionId]);
   const selectedSubagentSnapshots = useMemo(() => deriveChatSubagentSnapshots(selectedEvents), [selectedEvents]);
+  const pendingInput = selectedSessionId ? (pendingInputsBySession[selectedSessionId]?.[0] ?? null) : null;
+  const selectedSessionAwaitingInput = Boolean(pendingInput) || selectedSession?.awaitingInput === true;
   const turnActive = selectedSessionId ? (turnActiveBySession[selectedSessionId] ?? false) : false;
   const activeProviderConnection = selectedSession?.provider === "claude"
     ? (providerConnections?.claude ?? null)
@@ -660,7 +675,6 @@ export function AgentChatPane({
       : selectedSession?.provider === "cursor"
         ? (providerConnections?.cursor ?? null)
         : null;
-  const pendingInput = selectedSessionId ? (pendingInputsBySession[selectedSessionId]?.[0] ?? null) : null;
   const pendingApprovalIds = useMemo(() => {
     const ids = new Set<string>();
     for (const entry of pendingInputsBySession[selectedSessionId ?? ""] ?? []) {
@@ -674,6 +688,14 @@ export function AgentChatPane({
   const surfaceMode = presentation?.mode ?? "standard";
   const identitySessionSettingsBusy = isPersistentIdentitySurface && sessionMutationKind !== null;
 
+  useEffect(() => {
+    sessionsRef.current = sessions;
+  }, [sessions]);
+
+  useEffect(() => {
+    composerMaxHeightPxRef.current = composerMaxHeightPx;
+  }, [composerMaxHeightPx]);
+
   const modelSelectionDiffersFromSession = Boolean(selectedSession && selectedSessionModelId && selectedSessionModelId !== modelId);
 
   const sessionProvider = useMemo(() => {
@@ -749,8 +771,7 @@ export function AgentChatPane({
     || (surfaceMode === "resolver" ? "AI Resolver" : selectedSession ? chatSessionTitle(selectedSession) : "New chat");
   const assistantLabel = presentation?.assistantLabel?.trim()
     || resolveAssistantLabel(selectedModelDesc, selectedSession?.provider);
-  const messagePlaceholder = presentation?.messagePlaceholder?.trim()
-    || (assistantLabel === "Assistant" ? "Message the assistant..." : `Message ${assistantLabel}...`);
+  const messagePlaceholder = presentation?.messagePlaceholder?.trim() || "Type to vibecode...";
   const chipsJson = JSON.stringify(presentation?.chips ?? []);
   const resolvedChips = useMemo(() => JSON.parse(chipsJson) as ChatSurfaceChip[], [chipsJson]);
 
@@ -783,7 +804,7 @@ export function AgentChatPane({
       && !isPersistentIdentitySurface
       && (selectedSession.surface ?? "work") === "work",
   );
-  const handoffBlocked = turnActive || Boolean(pendingInput) || handoffBusy;
+  const handoffBlocked = turnActive || selectedSessionAwaitingInput || handoffBusy;
   const handoffButtonTitle = handoffBlocked
     ? "Wait for the current output or approval to finish before handing off this chat."
     : "Create a new work chat on another model and seed it with a summary of this chat.";
@@ -878,6 +899,17 @@ export function AgentChatPane({
     const rows = await window.ade.agentChat.list({ laneId });
     const nextRows = sortSessionSummariesByRecency(rows, localTouchBySessionRef.current);
     setSessions(nextRows);
+    setTurnActiveBySession((prev) => {
+      let next: Record<string, boolean> | null = null;
+      for (const row of nextRows) {
+        const shouldAppearRunning = row.status === "active" && row.awaitingInput !== true;
+        if ((prev[row.sessionId] ?? false) && !shouldAppearRunning) {
+          next ??= { ...prev };
+          next[row.sessionId] = false;
+        }
+      }
+      return next ?? prev;
+    });
     const nextSessionIds = new Set(nextRows.map((row) => row.sessionId));
     for (const sessionId of [...localTouchBySessionRef.current.keys()]) {
       if (!nextSessionIds.has(sessionId) && !optimisticSessionIdsRef.current.has(sessionId)) {
@@ -994,7 +1026,10 @@ export function AgentChatPane({
     }
   }, []);
 
-  const loadHistory = useCallback(async (sessionId: string) => {
+  const loadHistory = useCallback(async (sessionId: string, options?: { force?: boolean }) => {
+    if (options?.force) {
+      loadedHistoryRef.current.delete(sessionId);
+    }
     if (loadedHistoryRef.current.has(sessionId)) return;
     loadedHistoryRef.current.add(sessionId);
 
@@ -1027,15 +1062,18 @@ export function AgentChatPane({
       }
 
       const derived = deriveRuntimeState(merged);
+      const sessionSummary = sessionsRef.current.find((entry) => entry.sessionId === sessionId)
+        ?? (initialSessionSummary?.sessionId === sessionId ? initialSessionSummary : null);
+      const allowRunningFromSummary = sessionSummary?.status === "active" && sessionSummary.awaitingInput !== true;
       eventsBySessionRef.current = { ...eventsBySessionRef.current, [sessionId]: merged };
       setEventsBySession((prev) => ({ ...prev, [sessionId]: merged }));
-      setTurnActiveBySession((prev) => ({ ...prev, [sessionId]: derived.turnActive }));
+      setTurnActiveBySession((prev) => ({ ...prev, [sessionId]: allowRunningFromSummary ? derived.turnActive : false }));
       setPendingInputsBySession((prev) => ({ ...prev, [sessionId]: derived.pendingInputs }));
       setPendingSteersBySession((prev) => ({ ...prev, [sessionId]: derived.pendingSteers }));
     } catch {
       // Ignore transcript history failures.
     }
-  }, []);
+  }, [initialSessionSummary]);
 
   const clearSessionView = useCallback((sessionId: string) => {
     eventsBySessionRef.current = { ...eventsBySessionRef.current, [sessionId]: [] };
@@ -1578,6 +1616,10 @@ export function AgentChatPane({
     setModelId(snapshot.nextModelId);
     setReasoningEffort(snapshot.nextReasoningEffort);
   }, []);
+  const notifySessionCreated = useCallback((session: AgentChatSession) => {
+    if (!onSessionCreated) return;
+    void Promise.resolve(onSessionCreated(session)).catch((err) => { console.error("notifySessionCreated failed:", err); });
+  }, [onSessionCreated]);
 
   const createSession = useCallback(async (): Promise<string | null> => {
     if (createSessionPromiseRef.current) {
@@ -1611,11 +1653,8 @@ export function AgentChatPane({
           modelId,
         }).then(() => refreshSessions()).catch(() => { /* warmup is best-effort */ });
       }
-      // Await tab navigation and session-list refresh before returning so the
-      // caller doesn't send the first message while the user is still on the
-      // blank "new chat" screen.
-      await onSessionCreated?.(created.id);
-      await refreshSessions().catch(() => {});
+      notifySessionCreated(created);
+      void refreshSessions().catch(() => {});
       return created.id;
     })();
     createSessionPromiseRef.current = createPromise;
@@ -1626,7 +1665,7 @@ export function AgentChatPane({
         createSessionPromiseRef.current = null;
       }
     }
-  }, [buildNativeControlPayload, computerUsePolicy, laneId, modelId, onSessionCreated, reasoningEffort, refreshSessions, touchSession]);
+  }, [buildNativeControlPayload, computerUsePolicy, laneId, modelId, notifySessionCreated, reasoningEffort, refreshSessions, touchSession]);
 
   const handoffSession = useCallback(async () => {
     if (!canShowHandoff || !selectedSessionId || !handoffModelId || handoffBlocked) return;
@@ -1638,14 +1677,14 @@ export function AgentChatPane({
         targetModelId: handoffModelId,
       });
       setHandoffOpen(false);
-      await onSessionCreated?.(result.session.id);
+      notifySessionCreated(result.session);
       void refreshSessions().catch(() => {});
     } catch (handoffError) {
       setError(handoffError instanceof Error ? handoffError.message : String(handoffError));
     } finally {
       setHandoffBusy(false);
     }
-  }, [canShowHandoff, handoffBlocked, handoffModelId, onSessionCreated, refreshSessions, selectedSessionId]);
+  }, [canShowHandoff, handoffBlocked, handoffModelId, notifySessionCreated, refreshSessions, selectedSessionId]);
 
   // ── Eager session creation ──
   // Create a session as soon as we have a model + lane, so slash commands,
@@ -1952,6 +1991,26 @@ export function AgentChatPane({
     }
   }, [isPersistentIdentitySurface, patchSessionSummary, refreshComputerUseSnapshot, refreshSessions, selectedSessionId, sessionMutationKind]);
 
+  useEffect(() => {
+    if (layoutVariant !== "grid-tile") {
+      setComposerMaxHeightPx(null);
+      return;
+    }
+    const node = shellRef.current;
+    if (!node || typeof ResizeObserver === "undefined") return;
+    const observer = new ResizeObserver((entries) => {
+      const entry = entries[0];
+      if (!entry) return;
+      const next = Math.max(96, Math.min(168, Math.floor(entry.contentRect.height * 0.28)));
+      if (composerMaxHeightPxRef.current !== next) {
+        composerMaxHeightPxRef.current = next;
+        setComposerMaxHeightPx(next);
+      }
+    });
+    observer.observe(node);
+    return () => observer.disconnect();
+  }, [layoutVariant]);
+
   if (!laneId) {
     return (
       <ChatSurfaceShell mode={surfaceMode} accentColor={presentation?.accentColor}>
@@ -1962,6 +2021,29 @@ export function AgentChatPane({
     );
   }
   const draftAccent = selectedModelDesc?.color ?? "#A1A1AA";
+  const proofSessionId = selectedSessionId ?? "";
+  const proofPanelContent = (
+    <>
+      <div className="flex shrink-0 items-center justify-between gap-3 border-b border-white/[0.06] px-4 py-2.5">
+        <span className="font-sans text-[12px] font-medium text-fg/80">Artifacts</span>
+        <button
+          type="button"
+          className="rounded-md border border-white/[0.06] bg-white/[0.03] px-2 py-0.5 font-sans text-[10px] font-medium text-fg/50 transition-colors hover:text-fg/80"
+          onClick={() => setProofDrawerOpen(false)}
+          title="Close artifacts panel"
+        >
+          Close
+        </button>
+      </div>
+      <div className="min-h-0 flex-1 overflow-auto px-4 py-3">
+        <ChatComputerUsePanel
+          sessionId={proofSessionId}
+          snapshot={computerUseSnapshot}
+          onRefresh={() => refreshComputerUseSnapshot(selectedSessionId, { force: true })}
+        />
+      </div>
+    </>
+  );
   const shellHeader = (
     <div className="space-y-2 px-4 py-2">
       {/* Clean single-row header */}
@@ -2024,6 +2106,7 @@ export function AgentChatPane({
                       value={handoffModelId}
                       onChange={setHandoffModelId}
                       availableModelIds={handoffAvailableModelIds}
+                      catalogMode="available-only"
                       showReasoning={false}
                       onOpenAiSettings={openAiProvidersSettings}
                     />
@@ -2071,9 +2154,19 @@ export function AgentChatPane({
             {sessions.map((session) => {
               const title = chatSessionTitle(session);
               const isActive = session.sessionId === selectedSessionId;
-              const isRunning = turnActiveBySession[session.sessionId] ?? false;
-              const sessionNeedsInput = Boolean(pendingInputsBySession[session.sessionId]?.length);
-              const sessionIndicatorStatus = sessionNeedsInput ? "waiting" : isRunning ? "working" : null;
+              const sessionNeedsInput = Boolean(pendingInputsBySession[session.sessionId]?.length) || session.awaitingInput === true;
+              const isRunning = !sessionNeedsInput && turnActiveBySession[session.sessionId] === true;
+              const sessionReadyForPrompt = !sessionNeedsInput && !isRunning && session.status === "idle";
+              const sessionIndicatorStatus = sessionNeedsInput || sessionReadyForPrompt
+                ? "waiting"
+                : isRunning
+                  ? "working"
+                  : null;
+              const sessionIndicatorLabel = sessionNeedsInput
+                ? "Waiting for your input"
+                : sessionReadyForPrompt
+                  ? "Ready for next prompt"
+                  : "Agent working";
               return (
                 <button
                   key={session.sessionId}
@@ -2106,8 +2199,8 @@ export function AgentChatPane({
                   ) : null}
                   {sessionIndicatorStatus ? (
                     <span
-                      aria-label={sessionIndicatorStatus === "working" ? "Agent working" : "Waiting for your input"}
-                      title={sessionIndicatorStatus === "working" ? "Agent working" : "Waiting for your input"}
+                      aria-label={sessionIndicatorLabel}
+                      title={sessionIndicatorLabel}
                       className="inline-flex h-3.5 w-3.5 items-center justify-center"
                     >
                       <ChatStatusGlyph status={sessionIndicatorStatus} size={11} />
@@ -2139,16 +2232,14 @@ export function AgentChatPane({
   );
 
   const embedDraft = embeddedWorkLayout && forceDraft;
-  return (
-    <>
-      <ChatSurfaceShell
-        mode={surfaceMode}
-        accentColor={presentation?.accentColor ?? draftAccent}
-        className={embedDraft ? cn("border-0 shadow-none rounded-none bg-transparent") : undefined}
-        header={embedDraft ? undefined : shellHeader}
-        footer={
+  const compactShell = embedDraft || layoutVariant === "grid-tile";
+  const isEmptyState = !selectedSessionId;
+
+  const composerElement = (
           <AgentChatComposer
             surfaceMode={surfaceMode}
+            layoutVariant={layoutVariant}
+            composerMaxHeightPx={composerMaxHeightPx}
             sdkSlashCommands={sdkSlashCommands}
             modelId={modelId}
             availableModelIds={effectiveAvailableModelIds}
@@ -2280,8 +2371,8 @@ export function AgentChatPane({
             onInterrupt={() => {
               void interrupt();
             }}
-            onApproval={(decision) => {
-              void approve(decision);
+            onApproval={(decision, responseText) => {
+              void approve(decision, responseText);
             }}
             onAddAttachment={addAttachment}
             onRemoveAttachment={removeAttachment}
@@ -2296,6 +2387,7 @@ export function AgentChatPane({
             promptSuggestion={promptSuggestion}
             subagentSnapshots={selectedSubagentSnapshots}
             chatHasMessages={selectedEventsForDisplay.some((env) => env.event.type === "user_message" || env.event.type === "text")}
+            restrictModelCatalogToAvailable={selectedEvents.length > 0}
             pendingSteers={pendingSteers}
             onCancelSteer={(steerId) => {
               if (selectedSessionId) {
@@ -2308,7 +2400,18 @@ export function AgentChatPane({
               }
             }}
           />
-        }
+  );
+
+  return (
+    <>
+      <ChatSurfaceShell
+        containerRef={shellRef}
+        mode={surfaceMode}
+        accentColor={presentation?.accentColor ?? draftAccent}
+        className={compactShell ? cn("border-0 shadow-none rounded-none bg-transparent") : undefined}
+        header={compactShell ? undefined : shellHeader}
+        footer={isEmptyState ? undefined : composerElement}
+        footerClassName={compactShell ? "px-0 pb-0 pt-0" : undefined}
         bodyClassName="flex min-h-0 flex-col overflow-hidden"
       >
         {error ? (
@@ -2331,8 +2434,8 @@ export function AgentChatPane({
           </div>
         ) : null}
 
-        <div className="min-h-0 flex-1 overflow-hidden">
-          {loading ? (
+        <div className="relative min-h-0 flex-1 overflow-hidden">
+          {loading && !embedDraft && !selectedSessionId ? (
             <div className="flex h-full items-center justify-center">
               <div className="flex flex-col items-center gap-3">
                 <div className="flex items-center gap-1.5">
@@ -2343,104 +2446,134 @@ export function AgentChatPane({
                 <span className="font-mono text-[10px] uppercase tracking-[2px] text-muted-fg/25">Loading sessions...</span>
               </div>
             </div>
-          ) : selectedSessionId ? (
-            <div className="flex h-full min-h-0 overflow-hidden">
-              {/* Chat column */}
-              <div className="flex min-h-0 min-w-[280px] flex-1 flex-col overflow-hidden">
-                <AgentChatMessageList
-                  key={selectedSessionId ?? "chat-draft"}
-                  events={selectedEventsForDisplay}
-                  showStreamingIndicator={turnActive}
-                  className="min-h-0 border-0"
-                  surfaceMode={surfaceMode}
-                  surfaceProfile={surfaceProfile}
-                  assistantLabel={assistantLabel}
-                  respondingApprovalIds={respondingApprovalIds}
-                  pendingApprovalIds={pendingApprovalIds}
-                  onApproval={(itemId, decision, responseText) => {
-                    void handleApproval(itemId, decision, responseText);
-                  }}
-                />
-                {sessionDelta ? (
-                  <div className="flex items-center gap-3 border-t border-white/[0.04] px-4 py-1.5 font-mono text-[11px]">
-                    <span className="text-emerald-400/70">+{sessionDelta.insertions}</span>
-                    <span className="text-red-400/70">-{sessionDelta.deletions}</span>
+          ) : (
+            <AnimatePresence mode="sync">
+              {selectedSessionId ? (
+                <motion.div
+                  key="chat-view"
+                  initial={{ opacity: 0 }}
+                  animate={{ opacity: 1 }}
+                  transition={{ duration: 0.25, ease: "easeOut", delay: 0.15 }}
+                  className="absolute inset-0 flex min-h-0 overflow-hidden"
+                >
+                  {/* Chat column */}
+                  <div className={cn(
+                    "flex min-h-0 flex-1 flex-col overflow-hidden",
+                    layoutVariant === "grid-tile" ? "min-w-0" : "min-w-[280px]",
+                  )}>
+                    <AgentChatMessageList
+                      key={selectedSessionId ?? "chat-draft"}
+                      events={selectedEventsForDisplay}
+                      showStreamingIndicator={turnActive}
+                      className="min-h-0 border-0"
+                      surfaceMode={surfaceMode}
+                      surfaceProfile={surfaceProfile}
+                      assistantLabel={assistantLabel}
+                      respondingApprovalIds={respondingApprovalIds}
+                      pendingApprovalIds={pendingApprovalIds}
+                      onApproval={(itemId, decision, responseText, answers) => {
+                        void handleApproval(itemId, decision, responseText, answers);
+                      }}
+                    />
+                    {sessionDelta ? (
+                      <div className="flex items-center gap-3 border-t border-white/[0.04] px-4 py-1.5 font-mono text-[11px]">
+                        <span className="text-emerald-400/70">+{sessionDelta.insertions}</span>
+                        <span className="text-red-400/70">-{sessionDelta.deletions}</span>
+                      </div>
+                    ) : null}
                   </div>
-                ) : null}
-              </div>
 
-              {/* Proof panel (push) */}
-              {proofDrawerOpen ? (
-                <div className="flex h-full w-[40%] min-w-[280px] max-w-[480px] shrink-0 flex-col border-l border-white/[0.06] bg-surface/80">
-                  <div className="flex shrink-0 items-center justify-between gap-3 border-b border-white/[0.06] px-4 py-2.5">
-                    <span className="font-sans text-[12px] font-medium text-fg/80">Artifacts</span>
-                    <button
-                      type="button"
-                      className="rounded-md border border-white/[0.06] bg-white/[0.03] px-2 py-0.5 font-sans text-[10px] font-medium text-fg/50 transition-colors hover:text-fg/80"
-                      onClick={() => setProofDrawerOpen(false)}
-                      title="Close artifacts panel"
+                  {/* Proof panel (push) */}
+                  {proofDrawerOpen ? (
+                    layoutVariant === "grid-tile" ? (
+                      <div className="absolute inset-3 z-10 flex min-h-0 flex-col overflow-hidden rounded-xl border border-white/[0.08] bg-[color:color-mix(in_srgb,var(--chat-panel-bg-strong)_92%,black_8%)] shadow-[var(--chat-shell-shadow)] backdrop-blur-xl">
+                        {proofPanelContent}
+                      </div>
+                    ) : (
+                      <div className="flex h-full w-[40%] min-w-[280px] max-w-[480px] shrink-0 flex-col border-l border-white/[0.06] bg-surface/80">
+                        {proofPanelContent}
+                      </div>
+                    )
+                  ) : null}
+                </motion.div>
+              ) : (
+                <motion.div
+                  key="empty-state"
+                  initial={{ opacity: 1, scale: 1 }}
+                  exit={{ opacity: 0, scale: 0.95, transition: { duration: 0.2, ease: "easeIn" } }}
+                  className="absolute inset-0 flex flex-col items-center justify-center px-6"
+                >
+                  <div className="flex flex-col items-center text-center">
+                    {/* ADE logo with subtle glow */}
+                    <motion.div
+                      className="relative mb-5"
+                      exit={{ opacity: 0, scale: 0.8, transition: { duration: 0.3, ease: "easeOut" } }}
                     >
-                      Close
-                    </button>
-                  </div>
-                  <div className="min-h-0 flex-1 overflow-auto px-4 py-3">
-                    <ChatComputerUsePanel
-                      sessionId={selectedSessionId}
-                      snapshot={computerUseSnapshot}
-                      onRefresh={() => refreshComputerUseSnapshot(selectedSessionId, { force: true })}
-                    />
+                      <div
+                        className="absolute top-1/2 left-1/2 -translate-x-1/2 -translate-y-1/2 h-[400px] w-[400px] rounded-full pointer-events-none"
+                        style={{
+                          background: "var(--color-accent)",
+                          opacity: 0.08,
+                          filter: "blur(100px)",
+                        }}
+                      />
+                      <img
+                        src="./logo.png"
+                        alt="ADE"
+                        className="relative z-10 w-64 h-64 object-contain"
+                        style={{ filter: "drop-shadow(0 0 40px rgba(168,130,255,0.15))" }}
+                      />
+                    </motion.div>
+
+                    {/* Lane selector pill */}
+                    {availableLanes && availableLanes.length > 0 && onLaneChange ? (
+                      <motion.div
+                        className="mb-4"
+                        exit={{ opacity: 0, transition: { duration: 0.15 } }}
+                      >
+                        <select
+                          aria-label="Select lane"
+                          value={laneId ?? ""}
+                          onChange={(e) => onLaneChange(e.target.value)}
+                          className="appearance-none rounded-full px-4 py-1.5 text-[11px] font-medium text-fg/70 outline-none transition-colors cursor-pointer"
+                          style={{
+                            background: "rgba(255,255,255,0.04)",
+                            border: "1px solid rgba(255,255,255,0.08)",
+                            backgroundImage: `url("data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' width='10' height='10' viewBox='0 0 24 24' fill='none' stroke='rgba(255,255,255,0.4)' stroke-width='2' stroke-linecap='round' stroke-linejoin='round'%3E%3Cpolyline points='6 9 12 15 18 9'%3E%3C/polyline%3E%3C/svg%3E")`,
+                            backgroundRepeat: "no-repeat",
+                            backgroundPosition: "right 10px center",
+                            paddingRight: "28px",
+                          }}
+                        >
+                          {availableLanes.map((lane) => (
+                            <option key={lane.id} value={lane.id}>
+                              {lane.name}
+                            </option>
+                          ))}
+                        </select>
+                      </motion.div>
+                    ) : laneDisplayLabel ? (
+                      <motion.div
+                        className="mb-4 flex items-center gap-2 rounded-full px-4 py-1.5"
+                        style={{ background: "rgba(255,255,255,0.04)", border: "1px solid rgba(255,255,255,0.08)" }}
+                        exit={{ opacity: 0, transition: { duration: 0.15 } }}
+                      >
+                        <span className="inline-block h-2 w-2 rounded-full" style={{ backgroundColor: draftAccent }} />
+                        <span className="text-[11px] font-medium text-fg/60">{laneDisplayLabel}</span>
+                      </motion.div>
+                    ) : null}
+
+                    {/* Inline composer for empty state */}
+                    <div className="w-full max-w-[640px]">
+                      {composerElement}
+                    </div>
                   </div>
-                </div>
-              ) : null}
-            </div>
-          ) : (
-            <div className="flex h-full flex-col items-center justify-center px-6">
-              <div className="flex flex-col items-center gap-4 text-center">
-                <div className="flex items-center gap-2">
-                  <span className="inline-block h-2 w-2 rounded-full" style={{ backgroundColor: draftAccent }} />
-                  <span className="font-mono text-[10px] font-bold uppercase tracking-[2px] text-muted-fg/40">
-                    {laneDisplayLabel}
-                  </span>
-                </div>
-                <div className="font-sans text-[15px] font-medium tracking-tight text-fg/60">
-                  Start typing below
-                </div>
-                <div className="mt-2 grid grid-cols-2 gap-2">
-                  {[
-                    "Explain the project structure",
-                    "Review recent changes",
-                    "Plan the next feature",
-                    "Find bugs and propose fixes",
-                  ].map((prompt) => (
-                    <button
-                      key={prompt}
-                      type="button"
-                      className="rounded-[var(--chat-radius-pill)] border border-white/8 bg-black/10 px-3 py-2 text-left font-mono text-[10px] text-muted-fg/42 transition-colors hover:border-white/16 hover:text-fg/72"
-                      onClick={() => setDraft(prompt)}
-                    >
-                      {prompt}
-                    </button>
-                  ))}
-                </div>
-              </div>
-            </div>
+                </motion.div>
+              )}
+            </AnimatePresence>
           )}
         </div>
       </ChatSurfaceShell>
-      {pendingInput && selectedSessionId && (pendingInput.request.kind === "question" || pendingInput.request.kind === "structured_question") ? (
-        <AgentQuestionModal
-          request={pendingInput.request}
-          onClose={() => {
-            void approve("cancel");
-          }}
-          onSubmit={({ answers, responseText }) => {
-            void approve("accept", responseText, answers);
-          }}
-          onDecline={() => {
-            void approve("decline");
-          }}
-        />
-      ) : null}
     </>
   );
 }
diff --git a/apps/desktop/src/renderer/components/chat/AgentQuestionModal.test.tsx b/apps/desktop/src/renderer/components/chat/AgentQuestionModal.test.tsx
new file mode 100644
index 000000000..bb5ee19fd
--- /dev/null
+++ b/apps/desktop/src/renderer/components/chat/AgentQuestionModal.test.tsx
@@ -0,0 +1,236 @@
+/* @vitest-environment jsdom */
+
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { cleanup, fireEvent, render, screen } from "@testing-library/react";
+import type { PendingInputRequest } from "../../../shared/types";
+import { AgentQuestionModal } from "./AgentQuestionModal";
+
+afterEach(cleanup);
+
+function renderModal(request: PendingInputRequest) {
+  const onClose = vi.fn();
+  const onDecline = vi.fn();
+  const onSubmit = vi.fn();
+
+  render(
+    <AgentQuestionModal
+      request={request}
+      onClose={onClose}
+      onSubmit={onSubmit}
+      onDecline={onDecline}
+    />,
+  );
+
+  return { onClose, onDecline, onSubmit };
+}
+
+describe("AgentQuestionModal", () => {
+  it("supports multi-select answers and preview rendering", () => {
+    const request: PendingInputRequest = {
+      requestId: "req-1",
+      itemId: "item-1",
+      source: "claude",
+      kind: "structured_question",
+      title: "Task list decision",
+      description: "Claude needs help choosing a layout.",
+      questions: [
+        {
+          id: "layout",
+          header: "Layout",
+          question: "Which layouts should we keep exploring?",
+          multiSelect: true,
+          allowsFreeform: true,
+          options: [
+            {
+              label: "Cards",
+              value: "Cards",
+              preview: "<div><strong>Cards preview panel</strong></div>",
+              previewFormat: "html",
+            },
+            {
+              label: "Table",
+              value: "Table",
+              preview: "<div><strong>Table preview panel</strong></div>",
+              previewFormat: "html",
+              recommended: true,
+            },
+          ],
+        },
+      ],
+      allowsFreeform: true,
+      blocking: true,
+      canProceedWithoutAnswer: false,
+    };
+
+    const { onSubmit } = renderModal(request);
+
+    expect(screen.getByText("Task list decision")).toBeTruthy();
+    expect(screen.getByText("Table preview panel")).toBeTruthy();
+
+    fireEvent.click(screen.getByRole("button", { name: /Cards/i }));
+    expect(screen.getByText("Cards preview panel")).toBeTruthy();
+
+    fireEvent.click(screen.getByRole("button", { name: /Table/i }));
+    fireEvent.change(screen.getByRole("textbox"), {
+      target: { value: "Kanban, Timeline" },
+    });
+
+    fireEvent.click(screen.getByRole("button", { name: /Send answer/i }));
+
+    expect(onSubmit).toHaveBeenCalledWith({
+      answers: {
+        layout: ["Cards", "Table", "Kanban", "Timeline"],
+      },
+      responseText: null,
+    });
+  });
+
+  it("does not allow passive dismissal for blocking requests", () => {
+    const request: PendingInputRequest = {
+      requestId: "req-blocking",
+      itemId: "item-blocking",
+      source: "claude",
+      kind: "structured_question",
+      title: "Blocking clarification",
+      description: "Claude needs a decision before it can continue.",
+      questions: [
+        {
+          id: "direction",
+          header: "Direction",
+          question: "Which direction should we take?",
+          allowsFreeform: true,
+          options: [
+            { label: "Option A", value: "Option A" },
+            { label: "Option B", value: "Option B" },
+          ],
+        },
+      ],
+      allowsFreeform: true,
+      blocking: true,
+      canProceedWithoutAnswer: false,
+    };
+
+    const { onClose } = renderModal(request);
+
+    fireEvent.keyDown(window, { key: "Escape" });
+    fireEvent.click(screen.getByTestId("agent-question-modal-overlay"));
+
+    expect(onClose).not.toHaveBeenCalled();
+    expect(screen.queryByLabelText("Close question modal")).toBeNull();
+    expect(screen.queryByRole("button", { name: "Cancel" })).toBeNull();
+  });
+
+  it("lets freeform text override a single selected option", () => {
+    const request: PendingInputRequest = {
+      requestId: "req-2",
+      itemId: "item-2",
+      source: "claude",
+      kind: "structured_question",
+      description: "Claude needs a final preference.",
+      questions: [
+        {
+          id: "summary",
+          header: "Summary",
+          question: "What should the summary card do?",
+          allowsFreeform: true,
+          options: [
+            { label: "Collapse automatically", value: "Collapse automatically" },
+            { label: "Stay expanded", value: "Stay expanded" },
+          ],
+        },
+      ],
+      allowsFreeform: true,
+      blocking: true,
+      canProceedWithoutAnswer: false,
+    };
+
+    const { onSubmit } = renderModal(request);
+
+    fireEvent.click(screen.getByRole("button", { name: /Collapse automatically/i }));
+    fireEvent.change(screen.getByRole("textbox"), {
+      target: { value: "Collapse unless the agent is actively streaming." },
+    });
+
+    fireEvent.click(screen.getByRole("button", { name: /Send answer/i }));
+
+    expect(onSubmit).toHaveBeenCalledWith({
+      answers: {
+        summary: "Collapse unless the agent is actively streaming.",
+      },
+      responseText: "Collapse unless the agent is actively streaming.",
+    });
+  });
+
+  it("submits on Cmd/Ctrl+Enter when answers are ready", () => {
+    const request: PendingInputRequest = {
+      requestId: "req-shortcut",
+      itemId: "item-shortcut",
+      source: "claude",
+      kind: "question",
+      description: "Claude needs a concise answer.",
+      questions: [
+        {
+          id: "reply",
+          header: "Reply",
+          question: "What should Claude do next?",
+          allowsFreeform: true,
+        },
+      ],
+      allowsFreeform: true,
+      blocking: true,
+      canProceedWithoutAnswer: false,
+    };
+
+    const { onSubmit } = renderModal(request);
+
+    fireEvent.change(screen.getByRole("textbox", { name: "Reply" }), {
+      target: { value: "Use the shared modal everywhere chat questions appear." },
+    });
+
+    const expectedPayload = {
+      answers: {
+        reply: "Use the shared modal everywhere chat questions appear.",
+      },
+      responseText: "Use the shared modal everywhere chat questions appear.",
+    };
+
+    fireEvent.keyDown(window, { key: "Enter", metaKey: true });
+    expect(onSubmit).toHaveBeenCalledWith(expectedPayload);
+
+    onSubmit.mockClear();
+
+    fireEvent.keyDown(window, { key: "Enter", ctrlKey: true });
+    expect(onSubmit).toHaveBeenCalledWith(expectedPayload);
+  });
+
+  it("keeps Codex structured questions on a normal decline path", () => {
+    const request: PendingInputRequest = {
+      requestId: "req-codex",
+      itemId: "item-codex",
+      source: "codex",
+      kind: "structured_question",
+      title: "Planning question",
+      description: "Which planning path should we take?",
+      questions: [
+        {
+          id: "plan",
+          header: "Plan",
+          question: "Which planning path should we take?",
+          allowsFreeform: true,
+        },
+      ],
+      allowsFreeform: true,
+      blocking: true,
+      canProceedWithoutAnswer: false,
+    };
+
+    const { onDecline } = renderModal(request);
+
+    expect(screen.getByText(/Send a concrete answer so the agent can continue/i)).toBeTruthy();
+
+    fireEvent.click(screen.getByRole("button", { name: "Decline" }));
+
+    expect(onDecline).toHaveBeenCalledTimes(1);
+    expect(screen.queryByRole("button", { name: "Cancel turn" })).toBeNull();
+  });
+});
diff --git a/apps/desktop/src/renderer/components/chat/AgentQuestionModal.tsx b/apps/desktop/src/renderer/components/chat/AgentQuestionModal.tsx
index 87bbc7a7b..9182e1544 100644
--- a/apps/desktop/src/renderer/components/chat/AgentQuestionModal.tsx
+++ b/apps/desktop/src/renderer/components/chat/AgentQuestionModal.tsx
@@ -1,4 +1,8 @@
-import { useEffect, useMemo, useState } from "react";
+import { useCallback, useEffect, useMemo, useState } from "react";
+import ReactMarkdown from "react-markdown";
+import rehypeRaw from "rehype-raw";
+import rehypeSanitize, { defaultSchema } from "rehype-sanitize";
+import remarkGfm from "remark-gfm";
 import { ChatCircleText, HandPalm, PaperPlaneTilt, X } from "@phosphor-icons/react";
 import type { PendingInputRequest } from "../../../shared/types";
 import { Button } from "../ui/Button";
@@ -10,76 +14,173 @@ type AgentQuestionModalProps = {
   onDecline?: () => void;
 };
 
+type QuestionDraft = {
+  text: string;
+  selectedValues: string[];
+  activePreviewValue: string | null;
+};
+
+const SAFE_PREVIEW_SCHEMA = {
+  ...defaultSchema,
+  tagNames: [
+    "p",
+    "ul",
+    "ol",
+    "li",
+    "strong",
+    "em",
+    "code",
+    "pre",
+    "blockquote",
+    "table",
+    "thead",
+    "tbody",
+    "tr",
+    "th",
+    "td",
+    "br",
+    "hr",
+  ],
+};
+
+function createEmptyDraft(): QuestionDraft {
+  return {
+    text: "",
+    selectedValues: [],
+    activePreviewValue: null,
+  };
+}
+
 export function AgentQuestionModal({
   request,
   onClose,
   onSubmit,
   onDecline,
 }: AgentQuestionModalProps) {
-  const [answers, setAnswers] = useState<Record<string, string>>({});
+  const [drafts, setDrafts] = useState<Record<string, QuestionDraft>>({});
+  const passiveDismissAllowed = request.canProceedWithoutAnswer;
+  const questionCountLabel = request.questions.length === 1 ? "1 question" : `${request.questions.length} questions`;
+  const modalTitle = request.title?.trim().length
+    ? request.title.trim()
+    : request.kind === "structured_question"
+      ? "Input needed"
+      : "Agent question";
 
   useEffect(() => {
-    setAnswers({});
+    setDrafts({});
   }, [request.itemId, request.requestId]);
 
-  useEffect(() => {
-    const onKeyDown = (event: KeyboardEvent) => {
-      if (event.key === "Escape") {
-        event.stopPropagation();
-        onClose();
-      }
-    };
-    window.addEventListener("keydown", onKeyDown, true);
-    return () => window.removeEventListener("keydown", onKeyDown, true);
-  }, [onClose]);
+  const getDraft = (questionId: string): QuestionDraft => drafts[questionId] ?? createEmptyDraft();
 
   const normalizedAnswers = useMemo(() => {
-    return Object.fromEntries(
-      Object.entries(answers)
-        .map(([questionId, value]) => [questionId, value.trim()])
-        .filter((entry): entry is [string, string] => entry[1].length > 0),
-    );
-  }, [answers]);
+    const next: Record<string, string | string[]> = {};
+
+    for (const question of request.questions) {
+      const draft = drafts[question.id] ?? createEmptyDraft();
+      const selectedValues = draft.selectedValues
+        .map((value) => value.trim())
+        .filter((value, index, values) => value.length > 0 && values.indexOf(value) === index);
+      const text = draft.text.trim();
+
+      if (question.multiSelect) {
+        const extraValues = text.length > 0
+          ? text.split(",").map((value) => value.trim()).filter((value) => value.length > 0)
+          : [];
+        const values = [...selectedValues];
+        for (const value of extraValues) {
+          if (!values.includes(value)) values.push(value);
+        }
+        if (values.length > 0) {
+          next[question.id] = values;
+        }
+        continue;
+      }
+
+      if (text.length > 0) {
+        next[question.id] = text;
+        continue;
+      }
+
+      if (selectedValues[0]) {
+        next[question.id] = selectedValues[0];
+      }
+    }
+
+    return next;
+  }, [drafts, request.questions]);
 
   const canSubmit = request.canProceedWithoutAnswer || request.questions.every((question) => {
     const value = normalizedAnswers[question.id];
-    return typeof value === "string" && value.length > 0;
+    return (typeof value === "string" && value.length > 0)
+      || (Array.isArray(value) && value.length > 0);
   });
 
-  const handleSubmit = () => {
+  const handleSubmit = useCallback(() => {
     const primaryQuestionId = request.questions[0]?.id;
+    const primaryAnswer = primaryQuestionId ? normalizedAnswers[primaryQuestionId] : undefined;
     onSubmit({
       answers: { ...normalizedAnswers },
-      responseText: primaryQuestionId ? (normalizedAnswers[primaryQuestionId] ?? null) : null,
+      responseText: typeof primaryAnswer === "string" ? primaryAnswer : null,
     });
-  };
+  }, [normalizedAnswers, onSubmit, request.questions]);
+
+  useEffect(() => {
+    const onKeyDown = (event: KeyboardEvent) => {
+      if (event.key === "Escape") {
+        event.stopPropagation();
+        event.preventDefault();
+        if (!passiveDismissAllowed) return;
+        onClose();
+        return;
+      }
+      if (event.key === "Enter" && (event.metaKey || event.ctrlKey)) {
+        event.stopPropagation();
+        event.preventDefault();
+        if (!canSubmit) return;
+        handleSubmit();
+      }
+    };
+    window.addEventListener("keydown", onKeyDown, true);
+    return () => window.removeEventListener("keydown", onKeyDown, true);
+  }, [canSubmit, handleSubmit, onClose, passiveDismissAllowed]);
 
   return (
     <div
+      data-testid="agent-question-modal-overlay"
       className="fixed inset-0 z-[9999] flex items-center justify-center bg-[radial-gradient(circle_at_top,rgba(78,154,241,0.12),rgba(8,7,12,0.84))] px-4 backdrop-blur-md"
       onClick={(event) => {
-        if (event.target === event.currentTarget) onClose();
+        if (passiveDismissAllowed && event.target === event.currentTarget) onClose();
       }}
     >
       <div className="ade-glass-card w-full max-w-3xl overflow-hidden border-border/20 bg-[linear-gradient(180deg,rgba(18,24,38,0.94),rgba(11,15,24,0.88))] shadow-[var(--shadow-panel)]">
-        <div className="flex items-center justify-between border-b border-border/15 bg-[linear-gradient(90deg,rgba(78,154,241,0.12),transparent)] px-5 py-3">
-          <div className="flex items-center gap-2">
-            <ChatCircleText size={16} className="text-sky-300/85" />
-            <div className="font-mono text-[11px] font-bold uppercase tracking-[0.18em] text-sky-200/80">
-              {request.kind === "structured_question" ? "Input needed" : "Agent question"}
+        <div className="flex items-start justify-between gap-3 border-b border-border/15 bg-[linear-gradient(90deg,rgba(78,154,241,0.12),transparent)] px-5 py-3">
+          <div className="min-w-0">
+            <div className="mb-1 flex flex-wrap items-center gap-2">
+              <ChatCircleText size={16} className="text-sky-300/85" />
+              <div className="font-mono text-[11px] font-bold uppercase tracking-[0.18em] text-sky-200/80">
+                {request.kind === "structured_question" ? "Input needed" : "Agent question"}
+              </div>
+              <div className="rounded-sm border border-white/[0.08] px-2 py-0.5 font-mono text-[9px] uppercase tracking-[0.16em] text-muted-fg/55">
+                {request.source}
+              </div>
+              <div className="rounded-sm border border-sky-300/15 px-2 py-0.5 font-mono text-[9px] uppercase tracking-[0.14em] text-sky-200/65">
+                {questionCountLabel}
+              </div>
             </div>
-            <div className="rounded-sm border border-white/[0.08] px-2 py-0.5 font-mono text-[9px] uppercase tracking-[0.16em] text-muted-fg/55">
-              {request.source}
+            <div className="text-[15px] font-semibold leading-6 text-fg">
+              {modalTitle}
             </div>
           </div>
-          <button
-            type="button"
-            className="text-muted-fg/45 transition-colors hover:text-fg/80"
-            onClick={onClose}
-            aria-label="Close question modal"
-          >
-            <X size={14} />
-          </button>
+          {passiveDismissAllowed ? (
+            <button
+              type="button"
+              className="text-muted-fg/45 transition-colors hover:text-fg/80"
+              onClick={onClose}
+              aria-label="Close question modal"
+            >
+              <X size={14} />
+            </button>
+          ) : null}
         </div>
 
         <div className="space-y-4 px-5 py-5">
@@ -96,11 +197,28 @@ export function AgentQuestionModal({
 
           <div className="space-y-4">
             {request.questions.map((question, index) => {
-              const selectedValue = answers[question.id] ?? "";
-              const helperText = question.defaultAssumption ?? question.impact ?? null;
-              const placeholder = question.options?.length
-                ? "Choose an option or type a custom answer..."
-                : "Type the answer you want the agent to follow...";
+              const draft = getDraft(question.id);
+              const selectedValues = draft.selectedValues;
+              const selectedValue = selectedValues[0] ?? "";
+              const helperText = [question.defaultAssumption, question.impact].filter((value): value is string => Boolean(value?.trim())).join(" ");
+              const placeholder = question.multiSelect
+                ? "Select one or more options, or type comma-separated custom answers..."
+                : question.options?.length
+                  ? "Choose an option or type a custom answer..."
+                  : "Type the answer you want the agent to follow...";
+              const normalizedQuestionAnswer = normalizedAnswers[question.id];
+              const selectedAnswerValues = Array.isArray(normalizedQuestionAnswer)
+                ? normalizedQuestionAnswer
+                : typeof normalizedQuestionAnswer === "string" && normalizedQuestionAnswer.trim().length > 0
+                  ? [normalizedQuestionAnswer.trim()]
+                  : [];
+              const previewOptions = (question.options ?? []).filter((option) => typeof option.preview === "string" && option.preview.trim().length > 0);
+              const activePreviewOption = (
+                previewOptions.find((option) => option.value === draft.activePreviewValue)
+                ?? previewOptions.find((option) => selectedValues.includes(option.value))
+                ?? previewOptions.find((option) => option.recommended)
+                ?? previewOptions[0]
+              ) ?? null;
 
               return (
                 <div key={question.id} className="space-y-2 rounded-sm border border-white/[0.06] bg-black/10 px-4 py-3">
@@ -108,6 +226,11 @@ export function AgentQuestionModal({
                     <div className="font-mono text-[10px] uppercase tracking-[0.16em] text-sky-200/65">
                       {question.header?.trim() || `Question ${index + 1}`}
                     </div>
+                    {question.multiSelect ? (
+                      <div className="rounded-sm border border-sky-300/20 px-2 py-0.5 font-mono text-[9px] uppercase tracking-[0.14em] text-sky-200/70">
+                        Multi-select
+                      </div>
+                    ) : null}
                     {question.isSecret ? (
                       <div className="rounded-sm border border-amber-400/15 px-2 py-0.5 font-mono text-[9px] uppercase tracking-[0.14em] text-amber-200/65">
                         Secret
@@ -123,54 +246,189 @@ export function AgentQuestionModal({
                     </div>
                   ) : null}
                   {question.options?.length ? (
-                    <div className="flex flex-wrap gap-2">
-                      {question.options.map((option) => {
-                        const isSelected = selectedValue === option.value;
-                        return (
-                          <button
-                            key={`${question.id}:${option.value}`}
-                            type="button"
-                            className={[
-                              "rounded-sm border px-3 py-1.5 text-left transition-colors",
-                              isSelected
-                                ? "border-sky-300/45 bg-sky-400/[0.12] text-fg"
-                                : "border-white/[0.08] bg-white/[0.02] text-fg/72 hover:border-sky-300/30 hover:bg-sky-400/[0.06]",
-                            ].join(" ")}
-                            onClick={() => {
-                              setAnswers((current) => ({ ...current, [question.id]: option.value }));
-                            }}
-                          >
-                            <div className="font-mono text-[10px] font-bold uppercase tracking-[0.14em]">
-                              {option.label}
-                            </div>
-                            {option.description ? (
-                              <div className="mt-1 max-w-[240px] text-[11px] leading-5 text-muted-fg/55">
-                                {option.description}
+                    <div className={previewOptions.length ? "grid gap-3 lg:grid-cols-[minmax(0,0.95fr)_minmax(260px,1.05fr)]" : "space-y-3"}>
+                      <div className="flex flex-wrap gap-2">
+                        {question.options.map((option) => {
+                          const isSelected = question.multiSelect
+                            ? selectedValues.includes(option.value)
+                            : selectedValue === option.value;
+                          const activatePreview = option.preview?.trim()
+                            ? () => {
+                                setDrafts((current) => ({
+                                  ...current,
+                                  [question.id]: {
+                                    ...(current[question.id] ?? createEmptyDraft()),
+                                    activePreviewValue: option.value,
+                                  },
+                                }));
+                              }
+                            : undefined;
+                          return (
+                            <button
+                              key={`${question.id}:${option.value}`}
+                              type="button"
+                              className={[
+                                "rounded-sm border px-3 py-1.5 text-left transition-colors",
+                                isSelected
+                                  ? "border-sky-300/45 bg-sky-400/[0.12] text-fg"
+                                  : "border-white/[0.08] bg-white/[0.02] text-fg/72 hover:border-sky-300/30 hover:bg-sky-400/[0.06]",
+                              ].join(" ")}
+                              aria-pressed={isSelected}
+                              onMouseEnter={activatePreview}
+                              onFocus={activatePreview}
+                              onClick={() => {
+                                setDrafts((current) => {
+                                  const existing = current[question.id] ?? createEmptyDraft();
+                                  const nextSelectedValues = question.multiSelect
+                                    ? (existing.selectedValues.includes(option.value)
+                                        ? existing.selectedValues.filter((value) => value !== option.value)
+                                        : [...existing.selectedValues, option.value])
+                                    : [option.value];
+                                  return {
+                                    ...current,
+                                    [question.id]: {
+                                      ...existing,
+                                      selectedValues: nextSelectedValues,
+                                      activePreviewValue: option.preview?.trim().length ? option.value : existing.activePreviewValue,
+                                    },
+                                  };
+                                });
+                              }}
+                            >
+                              <div className="flex items-center gap-2">
+                                <div className="font-mono text-[10px] font-bold uppercase tracking-[0.14em]">
+                                  {option.label}
+                                </div>
+                                {option.recommended ? (
+                                  <div className="rounded-sm border border-emerald-300/20 px-1.5 py-0.5 font-mono text-[8px] uppercase tracking-[0.14em] text-emerald-200/75">
+                                    Recommended
+                                  </div>
+                                ) : null}
+                                {option.preview?.trim().length ? (
+                                  <div className="rounded-sm border border-white/[0.08] px-1.5 py-0.5 font-mono text-[8px] uppercase tracking-[0.14em] text-muted-fg/55">
+                                    Preview
+                                  </div>
+                                ) : null}
                               </div>
-                            ) : null}
-                          </button>
-                        );
-                      })}
+                              {option.description ? (
+                                <div className="mt-1 max-w-[240px] text-[11px] leading-5 text-muted-fg/55">
+                                  {option.description}
+                                </div>
+                              ) : null}
+                            </button>
+                          );
+                        })}
+                      </div>
+                      {!previewOptions.length && selectedAnswerValues.length > 0 ? (
+                        <div className="flex flex-wrap gap-2">
+                          {selectedAnswerValues.map((value) => (
+                            <div
+                              key={`${question.id}:selected:${value}`}
+                              className="rounded-sm border border-sky-300/15 bg-sky-400/[0.08] px-2 py-1 text-[11px] text-sky-50/90"
+                            >
+                              {value}
+                            </div>
+                          ))}
+                        </div>
+                      ) : null}
+                      {activePreviewOption?.preview?.trim().length ? (
+                        <div className="overflow-hidden rounded-sm border border-sky-400/15 bg-[linear-gradient(180deg,rgba(78,154,241,0.08),rgba(78,154,241,0.02))]">
+                          <div className="flex items-center justify-between gap-2 border-b border-sky-400/10 px-3 py-2">
+                            <div className="font-mono text-[10px] uppercase tracking-[0.16em] text-sky-200/70">
+                              Preview
+                            </div>
+                            <div className="text-[11px] text-fg/72">
+                              {activePreviewOption.label}
+                            </div>
+                          </div>
+                          <div className="max-h-[320px] overflow-auto px-3 py-3 text-[12px] leading-6 text-fg/86">
+                            <ReactMarkdown
+                              remarkPlugins={[remarkGfm]}
+                              rehypePlugins={[rehypeRaw, [rehypeSanitize, SAFE_PREVIEW_SCHEMA]]}
+                              components={{
+                                p: ({ children }) => <p className="mb-3 whitespace-pre-wrap">{children}</p>,
+                                ul: ({ children }) => <ul className="mb-3 list-disc space-y-1 pl-5">{children}</ul>,
+                                ol: ({ children }) => <ol className="mb-3 list-decimal space-y-1 pl-5">{children}</ol>,
+                                li: ({ children }) => <li>{children}</li>,
+                                pre: ({ children }) => (
+                                  <pre className="mb-3 overflow-auto rounded-sm border border-white/[0.06] bg-black/25 p-3 font-mono text-[11px] leading-5">
+                                    {children}
+                                  </pre>
+                                ),
+                                code: ({ children, className }) => (
+                                  <code className={className ?? "rounded-sm bg-black/30 px-1 py-0.5 font-mono text-[11px]"}>
+                                    {children}
+                                  </code>
+                                ),
+                                blockquote: ({ children }) => (
+                                  <blockquote className="mb-3 border-l-2 border-sky-300/25 pl-3 text-muted-fg/72">
+                                    {children}
+                                  </blockquote>
+                                ),
+                                table: ({ children }) => <table className="mb-3 w-full border-collapse text-left">{children}</table>,
+                                th: ({ children }) => <th className="border border-white/[0.08] px-2 py-1 font-semibold">{children}</th>,
+                                td: ({ children }) => <td className="border border-white/[0.08] px-2 py-1 align-top">{children}</td>,
+                              }}
+                            >
+                              {activePreviewOption.preview}
+                            </ReactMarkdown>
+                          </div>
+                        </div>
+                      ) : null}
+                    </div>
+                  ) : null}
+                  {question.options?.length && question.allowsFreeform !== false ? (
+                    <div className="text-[11px] leading-5 text-muted-fg/55">
+                      {question.multiSelect
+                        ? "Selected options stay active while you add custom answers. Separate custom answers with commas."
+                        : "Leave the text box empty to send the selected option as-is. Typing a custom answer overrides the selection."}
                     </div>
                   ) : null}
-                  {question.allowsFreeform !== false ? (
-                    question.isSecret ? (
+                  {(() => {
+                    if (question.allowsFreeform === false) return null;
+                    const handleTextChange = (event: React.ChangeEvent<HTMLInputElement | HTMLTextAreaElement>) => {
+                      const nextText = event.target.value;
+                      setDrafts((current) => {
+                        const existing = current[question.id] ?? createEmptyDraft();
+                        return {
+                          ...current,
+                          [question.id]: {
+                            ...existing,
+                            text: nextText,
+                            selectedValues:
+                              !question.multiSelect
+                                && nextText.trim().length > 0
+                                && existing.selectedValues.length > 0
+                                && nextText.trim() !== existing.selectedValues[0]
+                                ? []
+                                : existing.selectedValues,
+                          },
+                        };
+                      });
+                    };
+                    const ariaLabel = question.header?.trim() || question.question;
+                    return question.isSecret ? (
                       <input
                         type="password"
-                        value={selectedValue}
-                        onChange={(event) => setAnswers((current) => ({ ...current, [question.id]: event.target.value }))}
+                        value={draft.text}
+                        onChange={handleTextChange}
                         placeholder={placeholder}
                         className="h-10 w-full border border-border/20 bg-[linear-gradient(180deg,rgba(17,15,26,0.94),rgba(13,11,19,0.9))] px-3 font-mono text-[12px] text-fg outline-none transition-colors placeholder:text-muted-fg/30 focus:border-sky-300/35"
+                        aria-label={ariaLabel}
                       />
                     ) : (
                       <textarea
-                        value={selectedValue}
-                        onChange={(event) => setAnswers((current) => ({ ...current, [question.id]: event.target.value }))}
+                        value={draft.text}
+                        onChange={handleTextChange}
                         placeholder={placeholder}
-                        className="min-h-[110px] w-full resize-y border border-border/20 bg-[linear-gradient(180deg,rgba(17,15,26,0.94),rgba(13,11,19,0.9))] px-4 py-3 font-mono text-[12px] leading-6 text-fg outline-none transition-colors placeholder:text-muted-fg/30 focus:border-sky-300/35"
+                        className={[
+                          "w-full resize-y border border-border/20 bg-[linear-gradient(180deg,rgba(17,15,26,0.94),rgba(13,11,19,0.9))] px-4 py-3 font-mono text-[12px] leading-6 text-fg outline-none transition-colors placeholder:text-muted-fg/30 focus:border-sky-300/35",
+                          question.options?.length ? "min-h-[88px]" : "min-h-[110px]",
+                        ].join(" ")}
+                        aria-label={ariaLabel}
                       />
-                    )
-                  ) : null}
+                    );
+                  })()}
                 </div>
               );
             })}
@@ -180,13 +438,15 @@ export function AgentQuestionModal({
         <div className="flex items-center justify-between gap-3 border-t border-border/15 bg-[linear-gradient(180deg,rgba(255,255,255,0.02),transparent)] px-5 py-3">
           <div className="text-[12px] text-muted-fg/55">
             {request.canProceedWithoutAnswer
-              ? "You can skip this and let the agent continue, or send a concrete answer."
-              : "Send a concrete answer so the agent can continue with the right context."}
+              ? "You can close this and let the agent continue, or send a concrete answer. Press Cmd/Ctrl+Enter to submit."
+              : "Send a concrete answer so the agent can continue with the right context. Press Cmd/Ctrl+Enter to submit."}
           </div>
           <div className="flex items-center gap-2">
-            <Button variant="ghost" size="sm" onClick={onClose}>
-              Close
-            </Button>
+            {request.canProceedWithoutAnswer && (
+              <Button variant="ghost" size="sm" onClick={onClose}>
+                Close
+              </Button>
+            )}
             {onDecline ? (
               <Button variant="danger" size="sm" onClick={onDecline}>
                 <HandPalm size={12} />
diff --git a/apps/desktop/src/renderer/components/chat/ChatComposerShell.tsx b/apps/desktop/src/renderer/components/chat/ChatComposerShell.tsx
index f7b8547bf..915a76f30 100644
--- a/apps/desktop/src/renderer/components/chat/ChatComposerShell.tsx
+++ b/apps/desktop/src/renderer/components/chat/ChatComposerShell.tsx
@@ -22,9 +22,14 @@ export function ChatComposerShell({
   return (
     <div
       className={cn(
-        "relative overflow-hidden rounded-[var(--chat-radius-shell)] border border-[color:var(--chat-panel-border)] bg-[var(--chat-panel-bg)] shadow-[var(--chat-composer-shadow)] transition-colors",
+        "relative overflow-hidden rounded-[var(--chat-radius-shell)] transition-colors",
+        "bg-[rgba(30,30,40,0.7)] border border-[rgba(255,255,255,0.08)] shadow-[0_8px_32px_rgba(0,0,0,0.4),inset_0_1px_0_rgba(255,255,255,0.05)]",
         className,
       )}
+      style={{
+        backdropFilter: "blur(20px)",
+        WebkitBackdropFilter: "blur(20px)",
+      }}
       data-chat-composer-mode={mode}
     >
       {pendingBanner ? <div className="relative border-b border-[color:var(--chat-panel-border)]">{pendingBanner}</div> : null}
diff --git a/apps/desktop/src/renderer/components/chat/ChatSurfaceShell.tsx b/apps/desktop/src/renderer/components/chat/ChatSurfaceShell.tsx
index c6928953b..340370114 100644
--- a/apps/desktop/src/renderer/components/chat/ChatSurfaceShell.tsx
+++ b/apps/desktop/src/renderer/components/chat/ChatSurfaceShell.tsx
@@ -1,4 +1,4 @@
-import type { ReactNode } from "react";
+import type { ReactNode, Ref } from "react";
 import type { ChatSurfaceMode } from "../../../shared/types";
 import { cn } from "../ui/cn";
 import { chatSurfaceVars } from "./chatSurfaceTheme";
@@ -11,6 +11,8 @@ export function ChatSurfaceShell({
   children,
   className,
   bodyClassName,
+  footerClassName,
+  containerRef,
 }: {
   mode: ChatSurfaceMode;
   accentColor?: string | null;
@@ -19,25 +21,37 @@ export function ChatSurfaceShell({
   children: ReactNode;
   className?: string;
   bodyClassName?: string;
+  footerClassName?: string;
+  containerRef?: Ref<HTMLElement>;
 }) {
   return (
     <section
+      ref={containerRef}
       className={cn(
-        "relative flex h-full min-h-0 flex-col overflow-hidden rounded-[var(--chat-radius-shell)] border border-[color:var(--chat-panel-border)] bg-[var(--chat-surface-bg)] shadow-[var(--chat-shell-shadow)]",
+        "relative flex h-full min-h-0 flex-col overflow-hidden",
         className,
       )}
-      style={chatSurfaceVars(mode, accentColor)}
+      style={{ ...chatSurfaceVars(mode, accentColor), background: "var(--color-bg)" }}
     >
       {header ? (
-        <div className="relative border-b border-[color:var(--chat-panel-border)] bg-[var(--chat-panel-bg)]/92 backdrop-blur-xl">
+        <div
+          className="relative z-10 mx-3 mt-2 overflow-hidden rounded-[var(--chat-radius-shell)]"
+          style={{
+            backdropFilter: "blur(20px)",
+            WebkitBackdropFilter: "blur(20px)",
+            background: "rgba(30, 30, 40, 0.7)",
+            border: "1px solid rgba(255, 255, 255, 0.08)",
+            boxShadow: "0 4px 16px rgba(0, 0, 0, 0.3), inset 0 1px 0 rgba(255, 255, 255, 0.05)",
+          }}
+        >
           {header}
         </div>
       ) : null}
-      <div className={cn("relative min-h-0 flex-1 overflow-hidden bg-[var(--chat-surface-bg)]", bodyClassName)}>
+      <div className={cn("relative min-h-0 flex-1 overflow-hidden", bodyClassName)}>
         {children}
       </div>
       {footer ? (
-        <div className="relative border-t border-[color:var(--chat-panel-border)] bg-[var(--chat-panel-bg)]/92 backdrop-blur-xl">
+        <div className={cn("relative px-3 pb-3 pt-2", footerClassName)} style={{ background: "var(--color-bg)" }}>
           {footer}
         </div>
       ) : null}
diff --git a/apps/desktop/src/renderer/components/chat/ChatWorkLogBlock.tsx b/apps/desktop/src/renderer/components/chat/ChatWorkLogBlock.tsx
index 2dfbc5ac6..0101584ed 100644
--- a/apps/desktop/src/renderer/components/chat/ChatWorkLogBlock.tsx
+++ b/apps/desktop/src/renderer/components/chat/ChatWorkLogBlock.tsx
@@ -1,4 +1,4 @@
-import React, { useState } from "react";
+import React, { useMemo, useState } from "react";
 import {
   CaretDown,
   CaretRight,
@@ -14,15 +14,16 @@ import {
   readRecord,
   summarizeDiffStats,
   summarizeInlineText,
+  type ChatWorkLogGroupEvent,
   type ChatWorkLogEntry,
   type ChatWorkLogFileChange,
 } from "./chatTranscriptRows";
 import { cn } from "../ui/cn";
 import { getToolMeta } from "./chatToolAppearance";
-import { ChatStatusGlyph, chatStatusTextClass } from "./chatStatusVisuals";
-import { describeToolIdentifier, replaceInternalToolNames } from "./toolPresentation";
+import { ChatStatusGlyph, chatStatusTextClass, type ChatStatusVisualState } from "./chatStatusVisuals";
+import { replaceInternalToolNames } from "./toolPresentation";
 
-const MAX_VISIBLE_WORK_LOG_ENTRIES = 1;
+const MAX_VISIBLE_WORK_LOG_ENTRIES = 4;
 const RECESSED_BLOCK_CLASS =
   "overflow-auto whitespace-pre-wrap break-words rounded-[10px] border border-white/[0.05] bg-[#09090b] px-4 py-3 font-mono text-[11px] leading-[1.6] text-fg/76";
 
@@ -126,35 +127,62 @@ function workToneIcon(entry: ChatWorkLogEntry): { icon: Icon; className: string
   return { icon: Warning, className: "text-fg/34" };
 }
 
-function workStatusState(status: ChatWorkLogEntry["status"]): "working" | "completed" | "failed" {
+function workStatusState(status: ChatWorkLogEntry["status"]): ChatStatusVisualState {
   if (status === "completed" || status === "failed") return status;
+  if (status === "interrupted") return "waiting";
   return "working";
 }
 
 function workStatusLabel(status: ChatWorkLogEntry["status"]): string {
-  switch (status) {
-    case "completed":
-      return "completed";
-    case "failed":
-      return "failed";
-    default:
-      return "running";
-  }
+  if (status === "completed" || status === "failed" || status === "interrupted") return status;
+  return "running";
 }
 
 function workEntryHeading(entry: ChatWorkLogEntry): string {
   if (entry.entryKind === "tool" && entry.toolName) {
     const meta = getToolMeta(entry.toolName);
-    const toolDisplay = describeToolIdentifier(entry.toolName);
     const args = readRecord(entry.args) ?? {};
     const targetLine = meta.getTarget ? meta.getTarget(args) : null;
-    if (targetLine) return `${meta.label} ${targetLine}`.trim();
-    if (toolDisplay.secondaryLabel) return `${meta.label} ${toolDisplay.secondaryLabel}`.trim();
-    return meta.label;
+
+    if (meta.label === "Shell") {
+      return targetLine ? `Run ${summarizeInlineText(targetLine, 72)}` : "Run shell";
+    }
+    if (meta.label === "Read") {
+      return targetLine ? `Read ${basenamePathLabel(targetLine)}` : "Read files";
+    }
+    if (meta.label === "Search") {
+      return meta.category === "web"
+        ? "Search web"
+        : targetLine ? `Search ${summarizeInlineText(targetLine, 72)}` : "Search";
+    }
+    if (meta.label === "Find Files") {
+      return targetLine ? `Find ${summarizeInlineText(targetLine, 72)}` : "Find files";
+    }
+    if (meta.label === "List Files" || meta.label === "List") {
+      return targetLine ? `List ${summarizeInlineText(targetLine, 72)}` : "List files";
+    }
+    if (meta.label === "Write") {
+      return targetLine ? `Write ${basenamePathLabel(targetLine)}` : "Write file";
+    }
+    if (meta.label === "Edit" || meta.label === "Multi Edit" || meta.label === "Patch") {
+      return targetLine ? `Edit ${basenamePathLabel(targetLine)}` : "Edit files";
+    }
+    if (meta.label === "Plan") {
+      return "Update plan";
+    }
+    if (meta.label === "Plan Approval") {
+      return "Review plan";
+    }
+    if (meta.label === "Memory" || meta.label === "Core Memory" || meta.label === "Memory Add" || meta.label === "Memory Pin") {
+      return "Update memory";
+    }
+
+    return targetLine ? `${meta.label} ${summarizeInlineText(targetLine, 72)}`.trim() : meta.label;
   }
 
   if (entry.entryKind === "command") {
-    return "Shell";
+    const cmdText = summarizeInlineText(entry.command ?? "", 72);
+    return cmdText.length > 0 ? `Run ${cmdText}` : "Run shell";
   }
 
   if (entry.entryKind === "file_change") {
@@ -166,7 +194,7 @@ function workEntryHeading(entry: ChatWorkLogEntry): string {
   }
 
   if (entry.entryKind === "web_search") {
-    return "Web search";
+    return "Search web";
   }
 
   return entry.label;
@@ -174,7 +202,8 @@ function workEntryHeading(entry: ChatWorkLogEntry): string {
 
 function workEntryPreview(entry: ChatWorkLogEntry): string {
   if (entry.entryKind === "command") {
-    return summarizeInlineText(entry.command ?? "", 110);
+    const cmdText = summarizeInlineText(entry.command ?? "", 110);
+    return cmdText.length > 0 ? cmdText : "Run shell";
   }
 
   if (entry.entryKind === "file_change") {
@@ -192,10 +221,25 @@ function workEntryPreview(entry: ChatWorkLogEntry): string {
   }
 
   if (entry.entryKind === "web_search") {
-    return summarizeInlineText(entry.query ?? "", 110);
+    const queryText = summarizeInlineText(entry.query ?? "", 110);
+    return queryText.length > 0 ? queryText : "Search web";
   }
 
   if (entry.entryKind === "tool") {
+    if (entry.toolName) {
+      const meta = getToolMeta(entry.toolName);
+      if (meta.label === "Shell") {
+        const args = readRecord(entry.args);
+        const shellCmd = summarizeInlineText(typeof args?.command === "string" ? args.command : "", 110);
+        return shellCmd.length > 0 ? shellCmd : "Run shell";
+      }
+      if (meta.label === "Search" && meta.category === "web") return "Search web";
+    }
+    const resultRecord = readRecord(entry.result);
+    const resultSummary = typeof resultRecord?.summary === "string" ? resultRecord.summary.trim() : "";
+    if (resultSummary.length > 0) {
+      return summarizeInlineText(resultSummary, 110);
+    }
     if (typeof entry.result === "string" && entry.result.trim().length > 0) {
       return summarizeInlineText(entry.result, 110);
     }
@@ -211,6 +255,53 @@ function workEntryPreview(entry: ChatWorkLogEntry): string {
   return summarizeInlineText(entry.detail ?? "", 110);
 }
 
+function workGroupSummaryLabel(entry: ChatWorkLogEntry): string {
+  if (entry.entryKind === "command") return "ran shell";
+  if (entry.entryKind === "file_change") {
+    const firstFile = entry.changedFiles?.[0];
+    if (firstFile?.kind === "create") return "created files";
+    if (firstFile?.kind === "delete") return "deleted files";
+    return "edited files";
+  }
+  if (entry.entryKind === "web_search") return "searched web";
+  if (entry.entryKind === "tool" && entry.toolName) {
+    const meta = getToolMeta(entry.toolName);
+    if (meta.label === "Shell") return "ran shell";
+    if (meta.label === "Read" || meta.label === "List Files" || meta.label === "List" || meta.label === "Find Files") return "read files";
+    if (meta.label === "Search") return "searched";
+    if (meta.label === "Write" || meta.label === "Edit" || meta.label === "Multi Edit" || meta.label === "Patch") return "edited files";
+    if (meta.label === "Plan") return "updated plan";
+    if (meta.label === "Plan Approval") return "reviewed plan";
+    if (meta.label === "Memory" || meta.label === "Core Memory" || meta.label === "Memory Add" || meta.label === "Memory Pin") return "updated memory";
+    return summarizeInlineText(replaceInternalToolNames(meta.label).toLowerCase(), 32);
+  }
+  return summarizeInlineText(replaceInternalToolNames(entry.label).toLowerCase(), 32);
+}
+
+function buildWorkGroupSummary({
+  summary,
+  entries,
+}: {
+  summary?: string;
+  entries: ChatWorkLogEntry[];
+}): string {
+  const cleanedSummary = replaceInternalToolNames(summary?.trim() ?? "");
+  if (cleanedSummary.length > 0) return cleanedSummary;
+
+  const latestEntries = entries.slice(Math.max(0, entries.length - MAX_VISIBLE_WORK_LOG_ENTRIES));
+  const labels: string[] = [];
+  const seen = new Set<string>();
+  for (const entry of latestEntries) {
+    const label = workGroupSummaryLabel(entry);
+    if (!label.length || seen.has(label)) continue;
+    seen.add(label);
+    labels.push(label);
+  }
+  if (labels.length === 0) return "Recent agent activity";
+  const summaryText = labels.slice(0, 3).join(", ");
+  return `${summaryText.charAt(0).toUpperCase()}${summaryText.slice(1)}`;
+}
+
 function WorkLogEntryDetail({
   entry,
   onNavigateSuggestion,
@@ -351,23 +442,23 @@ function WorkLogEntryDetail({
 
 export function ChatWorkLogBlock({
   entries,
+  summary,
   className,
   onNavigateSuggestion,
 }: {
   entries: ChatWorkLogEntry[];
+  summary?: ChatWorkLogGroupEvent["summary"];
   className?: string;
   onNavigateSuggestion?: (suggestion: OperatorNavigationSuggestion) => void;
 }) {
   const [expandedGroup, setExpandedGroup] = useState(false);
   const [expandedEntries, setExpandedEntries] = useState<Record<string, boolean>>({});
-  const reversedEntries = [...entries].reverse();
   const hasOverflow = entries.length > MAX_VISIBLE_WORK_LOG_ENTRIES;
   const visibleEntries = hasOverflow && !expandedGroup
-    ? reversedEntries.slice(0, MAX_VISIBLE_WORK_LOG_ENTRIES)
-    : reversedEntries;
+    ? entries.slice(Math.max(0, entries.length - MAX_VISIBLE_WORK_LOG_ENTRIES))
+    : entries;
   const hiddenCount = entries.length - visibleEntries.length;
-  const onlyToolEntries = entries.every((entry) => entry.entryKind === "tool");
-  const groupLabel = onlyToolEntries ? "Tool calls" : "Work log";
+  const groupSummary = useMemo(() => buildWorkGroupSummary({ summary, entries }), [entries, summary]);
 
   const toggleEntry = (entryId: string) => {
     setExpandedEntries((current) => ({
@@ -377,54 +468,67 @@ export function ChatWorkLogBlock({
   };
 
   return (
-    <div className={cn("rounded-xl border border-white/[0.06] bg-[#111317]/70 px-2 py-1.5", className)}>
-      <div className="mb-1.5 flex items-center justify-between gap-2 px-0.5">
-        <p className="font-mono text-[9px] uppercase tracking-[0.16em] text-muted-fg/55">
-          {groupLabel} ({entries.length})
-        </p>
-        {hasOverflow ? (
-          <button
-            type="button"
-            className="font-mono text-[9px] uppercase tracking-[0.12em] text-muted-fg/55 transition-colors duration-150 hover:text-fg/75"
-            onClick={() => setExpandedGroup((current) => !current)}
-          >
-            {expandedGroup ? "Show less" : `Show ${hiddenCount} more`}
-          </button>
-        ) : null}
+    <div className={cn("rounded-2xl border border-white/[0.06] bg-[#111317]/78 px-3 py-3", className)}>
+      <div className="mb-2.5 flex items-start justify-between gap-3">
+        <div className="min-w-0">
+          <p className="font-mono text-[9px] uppercase tracking-[0.16em] text-muted-fg/50">
+            Activity
+          </p>
+          <p className="mt-1 text-[13px] leading-5 text-fg/82">
+            {groupSummary}
+          </p>
+        </div>
+        <div className="flex shrink-0 items-center gap-2">
+          <span className="rounded-full border border-white/[0.08] bg-white/[0.03] px-2 py-1 font-mono text-[9px] uppercase tracking-[0.12em] text-fg/46">
+            {entries.length} step{entries.length === 1 ? "" : "s"}
+          </span>
+          {hasOverflow ? (
+            <button
+              type="button"
+              className="font-mono text-[9px] uppercase tracking-[0.12em] text-muted-fg/55 transition-colors duration-150 hover:text-fg/75"
+              onClick={() => setExpandedGroup((current) => !current)}
+            >
+              {expandedGroup ? "Show fewer" : `Show ${hiddenCount} earlier`}
+            </button>
+          ) : null}
+        </div>
       </div>
 
-      <div className="space-y-1">
+      <div className="space-y-1.5">
         {visibleEntries.map((entry) => {
           const { icon: EntryIcon, className: iconClassName } = workToneIcon(entry);
           const hasSuggestions = readNavigationSuggestions(entry.result).length > 0;
           const isExpanded = (expandedEntries[entry.id] ?? hasSuggestions) || entry.status === "failed";
-          const heading = workEntryHeading(entry);
+          const heading = replaceInternalToolNames(workEntryHeading(entry));
           const preview = workEntryPreview(entry);
           const statusLabel = workStatusLabel(entry.status);
 
           return (
-            <div key={entry.id} className="rounded-lg border border-white/[0.04] bg-black/15">
+            <div key={entry.id} className="rounded-xl border border-white/[0.05] bg-black/15">
               <button
                 type="button"
-                className="flex w-full items-center gap-2 px-2.5 py-2 text-left"
+                className="flex w-full items-start gap-2.5 px-3 py-2.5 text-left"
                 onClick={() => toggleEntry(entry.id)}
               >
                 {isExpanded ? (
-                  <CaretDown size={10} weight="bold" className="text-fg/30" />
+                  <CaretDown size={10} weight="bold" className="mt-1 text-fg/30" />
                 ) : (
-                  <CaretRight size={10} weight="bold" className="text-fg/30" />
+                  <CaretRight size={10} weight="bold" className="mt-1 text-fg/30" />
                 )}
-                <span className="inline-flex h-3 w-3 items-center justify-center">
+                <span className="mt-0.5 inline-flex h-3 w-3 items-center justify-center">
                   <ChatStatusGlyph status={workStatusState(entry.status)} size={11} />
                 </span>
-                <EntryIcon size={12} weight="regular" className={iconClassName} />
+                <EntryIcon size={12} weight="regular" className={cn("mt-0.5", iconClassName)} />
                 <div className="min-w-0 flex-1 overflow-hidden">
-                  <p className="truncate font-mono text-[11px] leading-5 text-fg/78">
-                    {preview.length ? `${heading} - ${preview}` : heading}
-                  </p>
+                  <p className="truncate text-[12px] leading-5 text-fg/80">{heading}</p>
+                  {preview.length > 0 && preview !== heading ? (
+                    <p className="truncate font-mono text-[10px] leading-4 text-fg/42">
+                      {replaceInternalToolNames(preview)}
+                    </p>
+                  ) : null}
                 </div>
                 <span className={cn(
-                  "shrink-0 font-mono text-[9px] uppercase tracking-[0.12em]",
+                  "mt-0.5 shrink-0 font-mono text-[9px] uppercase tracking-[0.12em]",
                   chatStatusTextClass(workStatusState(entry.status)),
                 )}>
                   {statusLabel}
diff --git a/apps/desktop/src/renderer/components/chat/chatStatusVisuals.test.ts b/apps/desktop/src/renderer/components/chat/chatStatusVisuals.test.ts
deleted file mode 100644
index 902cffc66..000000000
--- a/apps/desktop/src/renderer/components/chat/chatStatusVisuals.test.ts
+++ /dev/null
@@ -1,45 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { CHAT_STATUS_HEX, chatStatusTextClass, type ChatStatusVisualState } from "./chatStatusVisuals";
-
-describe("CHAT_STATUS_HEX", () => {
-  it("maps all expected statuses to hex color strings", () => {
-    expect(CHAT_STATUS_HEX.working).toBe("#10B981");
-    expect(CHAT_STATUS_HEX.waiting).toBe("#F59E0B");
-    expect(CHAT_STATUS_HEX.completed).toBe("#10B981");
-    expect(CHAT_STATUS_HEX.failed).toBe("#EF4444");
-    expect(CHAT_STATUS_HEX.idle).toBe("#6B7280");
-  });
-
-  it("does not expose unexpected keys", () => {
-    const keys = Object.keys(CHAT_STATUS_HEX);
-    expect(keys).toEqual(expect.arrayContaining(["working", "waiting", "completed", "failed", "idle"]));
-    expect(keys).toHaveLength(5);
-  });
-});
-
-describe("chatStatusTextClass", () => {
-  it("returns the correct class for completed status", () => {
-    expect(chatStatusTextClass("completed")).toBe("text-emerald-300/75");
-  });
-
-  it("returns the correct class for failed status", () => {
-    expect(chatStatusTextClass("failed")).toBe("text-red-300/80");
-  });
-
-  it("returns the correct class for waiting status", () => {
-    expect(chatStatusTextClass("waiting")).toBe("text-amber-300/80");
-  });
-
-  it("returns the working default for the working status", () => {
-    expect(chatStatusTextClass("working")).toBe("text-emerald-300/80");
-  });
-
-  it("returns distinct classes for each status", () => {
-    const statuses: ChatStatusVisualState[] = ["working", "waiting", "completed", "failed"];
-    const classes = statuses.map(chatStatusTextClass);
-    // completed and working are different classes
-    expect(classes[0]).not.toBe(classes[1]);
-    expect(classes[0]).not.toBe(classes[2]);
-    expect(classes[1]).not.toBe(classes[3]);
-  });
-});
diff --git a/apps/desktop/src/renderer/components/chat/chatSurfaceTheme.test.ts b/apps/desktop/src/renderer/components/chat/chatSurfaceTheme.test.ts
deleted file mode 100644
index 0e3396791..000000000
--- a/apps/desktop/src/renderer/components/chat/chatSurfaceTheme.test.ts
+++ /dev/null
@@ -1,271 +0,0 @@
-import { describe, expect, it } from "vitest";
-import type { ChatSurfaceChipTone, ChatSurfaceMode } from "../../../shared/types";
-import {
-  CHAT_SURFACE_ACCENTS,
-  chatChipToneClass,
-  chatSurfaceVars,
-  colorToRgba,
-  resolveChatSurfaceAccent,
-} from "./chatSurfaceTheme";
-
-// ---------------------------------------------------------------------------
-// colorToRgba
-// ---------------------------------------------------------------------------
-
-describe("colorToRgba", () => {
-  it("converts a 6-digit hex color to rgba", () => {
-    expect(colorToRgba("#FF8800", 1)).toBe("rgba(255, 136, 0, 1)");
-  });
-
-  it("converts a 6-digit hex color with fractional alpha", () => {
-    expect(colorToRgba("#FF8800", 0.5)).toBe("rgba(255, 136, 0, 0.5)");
-  });
-
-  it("converts a 3-digit hex color by expanding digits", () => {
-    // #F80 -> #FF8800
-    expect(colorToRgba("#F80", 1)).toBe("rgba(255, 136, 0, 1)");
-  });
-
-  it("handles lowercase hex values", () => {
-    expect(colorToRgba("#ff8800", 0.14)).toBe("rgba(255, 136, 0, 0.14)");
-  });
-
-  it("handles mixed case hex values", () => {
-    expect(colorToRgba("#Ff8800", 0.28)).toBe("rgba(255, 136, 0, 0.28)");
-  });
-
-  it("handles alpha = 0", () => {
-    expect(colorToRgba("#000000", 0)).toBe("rgba(0, 0, 0, 0)");
-  });
-
-  it("handles all-black hex", () => {
-    expect(colorToRgba("#000000", 1)).toBe("rgba(0, 0, 0, 1)");
-  });
-
-  it("handles all-white hex", () => {
-    expect(colorToRgba("#FFFFFF", 1)).toBe("rgba(255, 255, 255, 1)");
-  });
-
-  it("falls back to default color for invalid hex", () => {
-    // normalizeHex defaults to "#71717A" for invalid input
-    // #71717A => r=113, g=113, b=122
-    expect(colorToRgba("not-a-color", 0.5)).toBe("rgba(113, 113, 122, 0.5)");
-  });
-
-  it("falls back for empty string", () => {
-    expect(colorToRgba("", 1)).toBe("rgba(113, 113, 122, 1)");
-  });
-
-  it("handles hex with leading/trailing whitespace", () => {
-    expect(colorToRgba("  #FF0000  ", 1)).toBe("rgba(255, 0, 0, 1)");
-  });
-
-  it("falls back for 4-digit hex (not valid shorthand)", () => {
-    // #1234 is neither 3 nor 6 hex digits
-    expect(colorToRgba("#1234", 1)).toBe("rgba(113, 113, 122, 1)");
-  });
-
-  it("falls back for 5-digit hex", () => {
-    expect(colorToRgba("#12345", 1)).toBe("rgba(113, 113, 122, 1)");
-  });
-
-  it("correctly expands 3-digit shorthand #000", () => {
-    expect(colorToRgba("#000", 1)).toBe("rgba(0, 0, 0, 1)");
-  });
-
-  it("correctly expands 3-digit shorthand #FFF", () => {
-    expect(colorToRgba("#FFF", 1)).toBe("rgba(255, 255, 255, 1)");
-  });
-
-  it("correctly expands 3-digit shorthand #abc", () => {
-    // #abc -> #aabbcc => r=170, g=187, b=204
-    expect(colorToRgba("#abc", 1)).toBe("rgba(170, 187, 204, 1)");
-  });
-});
-
-// ---------------------------------------------------------------------------
-// resolveChatSurfaceAccent
-// ---------------------------------------------------------------------------
-
-describe("resolveChatSurfaceAccent", () => {
-  it("returns mode-default accent when no custom color is provided", () => {
-    expect(resolveChatSurfaceAccent("standard")).toBe("#71717A");
-    expect(resolveChatSurfaceAccent("resolver")).toBe("#F97316");
-    expect(resolveChatSurfaceAccent("mission-thread")).toBe("#38BDF8");
-    expect(resolveChatSurfaceAccent("mission-feed")).toBe("#22C55E");
-  });
-
-  it("returns mode-default accent when accentColor is null", () => {
-    expect(resolveChatSurfaceAccent("resolver", null)).toBe("#F97316");
-  });
-
-  it("returns mode-default accent when accentColor is undefined", () => {
-    expect(resolveChatSurfaceAccent("resolver", undefined)).toBe("#F97316");
-  });
-
-  it("returns mode-default accent when accentColor is empty string", () => {
-    expect(resolveChatSurfaceAccent("resolver", "")).toBe("#F97316");
-  });
-
-  it("returns mode-default accent when accentColor is whitespace only", () => {
-    expect(resolveChatSurfaceAccent("resolver", "   ")).toBe("#F97316");
-  });
-
-  it("returns the custom color normalized when it is a valid 6-digit hex", () => {
-    expect(resolveChatSurfaceAccent("standard", "#FF0000")).toBe("#FF0000");
-  });
-
-  it("expands a valid 3-digit hex custom color", () => {
-    expect(resolveChatSurfaceAccent("standard", "#F00")).toBe("#FF0000");
-  });
-
-  it("normalizes invalid custom color to the default fallback hex", () => {
-    expect(resolveChatSurfaceAccent("standard", "garbage")).toBe("#71717A");
-  });
-
-  it("trims custom color before normalizing", () => {
-    expect(resolveChatSurfaceAccent("standard", "  #00FF00  ")).toBe("#00FF00");
-  });
-});
-
-// ---------------------------------------------------------------------------
-// chatSurfaceVars
-// ---------------------------------------------------------------------------
-
-describe("chatSurfaceVars", () => {
-  it("returns an object with all expected CSS custom properties", () => {
-    const vars = chatSurfaceVars("standard");
-    const keys = Object.keys(vars);
-    expect(keys).toContain("--chat-accent");
-    expect(keys).toContain("--chat-accent-soft");
-    expect(keys).toContain("--chat-accent-faint");
-    expect(keys).toContain("--chat-accent-glow");
-    expect(keys).toContain("--chat-surface-bg");
-    expect(keys).toContain("--chat-surface-raised");
-    expect(keys).toContain("--chat-panel-bg");
-    expect(keys).toContain("--chat-panel-bg-strong");
-    expect(keys).toContain("--chat-card-bg");
-    expect(keys).toContain("--chat-card-bg-strong");
-    expect(keys).toContain("--chat-panel-border");
-    expect(keys).toContain("--chat-card-border");
-    expect(keys).toContain("--chat-code-bg");
-    expect(keys).toContain("--chat-code-border");
-    expect(keys).toContain("--chat-code-fg");
-    expect(keys).toContain("--chat-notice-bg");
-    expect(keys).toContain("--chat-notice-border");
-  });
-
-  it("uses the mode-default accent color when no custom color is provided", () => {
-    const vars = chatSurfaceVars("resolver");
-    expect(vars["--chat-accent" as keyof typeof vars]).toBe("#F97316");
-  });
-
-  it("uses custom accent color when provided", () => {
-    const vars = chatSurfaceVars("standard", "#FF0000");
-    expect(vars["--chat-accent" as keyof typeof vars]).toBe("#FF0000");
-  });
-
-  it("derives soft/faint/glow from the resolved accent color", () => {
-    const vars = chatSurfaceVars("standard", "#FF0000");
-    expect(vars["--chat-accent-soft" as keyof typeof vars]).toBe("rgba(255, 0, 0, 0.14)");
-    expect(vars["--chat-accent-faint" as keyof typeof vars]).toBe("rgba(255, 0, 0, 0.08)");
-    expect(vars["--chat-accent-glow" as keyof typeof vars]).toBe("rgba(255, 0, 0, 0.28)");
-  });
-
-  it("has color-mix expressions for layout vars", () => {
-    const vars = chatSurfaceVars("standard");
-    const surfaceBg = vars["--chat-surface-bg" as keyof typeof vars] as string;
-    expect(surfaceBg).toContain("color-mix");
-  });
-
-  it("produces different accent for different modes", () => {
-    const standard = chatSurfaceVars("standard");
-    const resolver = chatSurfaceVars("resolver");
-    expect(standard["--chat-accent" as keyof typeof standard]).not.toBe(
-      resolver["--chat-accent" as keyof typeof resolver],
-    );
-  });
-
-  it("passes through null accentColor without error", () => {
-    const vars = chatSurfaceVars("mission-feed", null);
-    expect(vars["--chat-accent" as keyof typeof vars]).toBe("#22C55E");
-  });
-});
-
-// ---------------------------------------------------------------------------
-// chatChipToneClass
-// ---------------------------------------------------------------------------
-
-describe("chatChipToneClass", () => {
-  it("returns a non-empty class string for every tone", () => {
-    const tones: ChatSurfaceChipTone[] = ["accent", "success", "warning", "danger", "info", "muted"];
-    for (const tone of tones) {
-      const result = chatChipToneClass(tone);
-      expect(result).toBeTruthy();
-      expect(typeof result).toBe("string");
-      expect(result.length).toBeGreaterThan(0);
-    }
-  });
-
-  it("defaults to 'accent' tone when called with no argument", () => {
-    const defaultResult = chatChipToneClass();
-    const accentResult = chatChipToneClass("accent");
-    expect(defaultResult).toBe(accentResult);
-  });
-
-  it("returns different class strings for different tones", () => {
-    const success = chatChipToneClass("success");
-    const danger = chatChipToneClass("danger");
-    expect(success).not.toBe(danger);
-  });
-
-  it("accent tone references --chat-accent CSS variable", () => {
-    const result = chatChipToneClass("accent");
-    expect(result).toContain("--chat-accent");
-  });
-
-  it("success tone includes emerald classes", () => {
-    const result = chatChipToneClass("success");
-    expect(result).toContain("emerald");
-  });
-
-  it("warning tone includes amber classes", () => {
-    const result = chatChipToneClass("warning");
-    expect(result).toContain("amber");
-  });
-
-  it("danger tone includes red classes", () => {
-    const result = chatChipToneClass("danger");
-    expect(result).toContain("red");
-  });
-
-  it("info tone includes sky classes", () => {
-    const result = chatChipToneClass("info");
-    expect(result).toContain("sky");
-  });
-
-  it("muted tone includes white opacity classes", () => {
-    const result = chatChipToneClass("muted");
-    expect(result).toContain("white");
-  });
-});
-
-// ---------------------------------------------------------------------------
-// CHAT_SURFACE_ACCENTS
-// ---------------------------------------------------------------------------
-
-describe("CHAT_SURFACE_ACCENTS", () => {
-  it("has entries for all four chat surface modes", () => {
-    const modes: ChatSurfaceMode[] = ["standard", "resolver", "mission-thread", "mission-feed"];
-    for (const mode of modes) {
-      expect(CHAT_SURFACE_ACCENTS[mode]).toBeTruthy();
-      expect(CHAT_SURFACE_ACCENTS[mode]).toMatch(/^#[0-9A-Fa-f]{6}$/);
-    }
-  });
-
-  it("all accent values are distinct", () => {
-    const values = Object.values(CHAT_SURFACE_ACCENTS);
-    const unique = new Set(values);
-    expect(unique.size).toBe(values.length);
-  });
-});
diff --git a/apps/desktop/src/renderer/components/chat/chatTranscriptRows.test.ts b/apps/desktop/src/renderer/components/chat/chatTranscriptRows.test.ts
index d1f5e9e87..557d77a7f 100644
--- a/apps/desktop/src/renderer/components/chat/chatTranscriptRows.test.ts
+++ b/apps/desktop/src/renderer/components/chat/chatTranscriptRows.test.ts
@@ -371,6 +371,52 @@ describe("chatTranscriptRows", () => {
     expect(grouped[0]!.event.entries[0]!.status).toBe("failed");
     expect(grouped[0]!.event.entries[0]!.result).toEqual({ error: "permission denied" });
   });
+
+  it("absorbs tool_use_summary into the preceding work log group", () => {
+    const grouped = groupEvents([
+      {
+        sessionId: "session-1",
+        timestamp: "2026-03-17T10:00:00.000Z",
+        event: {
+          type: "tool_call",
+          tool: "functions.exec_command",
+          args: { cmd: "pwd" },
+          itemId: "tool-1",
+          turnId: "turn-1",
+        },
+      },
+      {
+        sessionId: "session-1",
+        timestamp: "2026-03-17T10:00:01.000Z",
+        event: {
+          type: "tool_result",
+          tool: "functions.exec_command",
+          result: { stdout: "/tmp/project" },
+          itemId: "tool-1",
+          turnId: "turn-1",
+          status: "completed",
+        },
+      },
+      {
+        sessionId: "session-1",
+        timestamp: "2026-03-17T10:00:02.000Z",
+        event: {
+          type: "tool_use_summary",
+          summary: "Checked the current working directory",
+          toolUseIds: ["tool-1"],
+          turnId: "turn-1",
+        },
+      },
+    ]);
+
+    expect(grouped).toHaveLength(1);
+    expect(grouped[0]!.event.type).toBe("work_log_group");
+    if (grouped[0]!.event.type !== "work_log_group") {
+      throw new Error("Expected a work log group");
+    }
+    expect(grouped[0]!.event.summary).toBe("Checked the current working directory");
+    expect(grouped[0]!.event.toolUseIds).toEqual(["tool-1"]);
+  });
 });
 
 describe("summarizeInlineText", () => {
diff --git a/apps/desktop/src/renderer/components/chat/chatTranscriptRows.ts b/apps/desktop/src/renderer/components/chat/chatTranscriptRows.ts
index c4142efa8..ab431d7c4 100644
--- a/apps/desktop/src/renderer/components/chat/chatTranscriptRows.ts
+++ b/apps/desktop/src/renderer/components/chat/chatTranscriptRows.ts
@@ -1,6 +1,6 @@
 import type { AgentChatEvent, AgentChatEventEnvelope } from "../../../shared/types";
 
-export type ChatWorkLogStatus = "running" | "completed" | "failed";
+export type ChatWorkLogStatus = "running" | "completed" | "failed" | "interrupted";
 export type ChatWorkLogEntryKind = "tool" | "command" | "file_change" | "web_search";
 export type ChatWorkLogEntryTone = "tool" | "info" | "error";
 
@@ -42,7 +42,8 @@ type HiddenTranscriptEvent =
   | Extract<AgentChatEvent, { type: "command" }>
   | Extract<AgentChatEvent, { type: "file_change" }>
   | Extract<AgentChatEvent, { type: "web_search" }>
-  | Extract<AgentChatEvent, { type: "reasoning" }>;
+  | Extract<AgentChatEvent, { type: "reasoning" }>
+  | Extract<AgentChatEvent, { type: "pending_input_resolved" }>;
 
 type ChatTranscriptVisibleEvent = Exclude<AgentChatEvent, HiddenTranscriptEvent>;
 
@@ -56,6 +57,14 @@ type WorkLogRenderEvent = {
   collapseKey?: string;
 };
 
+export type ChatWorkLogGroupEvent = {
+  type: "work_log_group";
+  entries: ChatWorkLogEntry[];
+  summary?: string;
+  toolUseIds?: string[];
+  turnId?: string | null;
+};
+
 export type ChatTranscriptRenderEvent =
   | ChatTranscriptVisibleEvent
   | RenderReasoningEvent
@@ -70,12 +79,7 @@ export type ChatTranscriptRenderEnvelope = {
 export type ChatTranscriptGroupedEnvelope = {
   key: string;
   timestamp: string;
-  event:
-    | ChatTranscriptRenderEvent
-    | {
-        type: "work_log_group";
-        entries: ChatWorkLogEntry[];
-      };
+  event: ChatTranscriptRenderEvent | ChatWorkLogGroupEvent;
 };
 
 export function summarizeInlineText(value: string, maxChars = 120): string {
@@ -187,6 +191,14 @@ function shouldMergeTextRows(
   return !previous.turnId && !next.turnId && !previous.itemId && !next.itemId;
 }
 
+function shouldMergePlanTextRows(
+  previous: Extract<AgentChatEvent, { type: "plan_text" }>,
+  next: Extract<AgentChatEvent, { type: "plan_text" }>,
+): boolean {
+  return turnAndItemMatch(previous, next)
+    || (!previous.turnId && !next.turnId && !previous.itemId && !next.itemId);
+}
+
 function buildCollapseKey(
   prefix: string,
   event: { turnId?: string; itemId?: string; logicalItemId?: string },
@@ -432,7 +444,7 @@ export function appendCollapsedChatTranscriptEvent(
 ): void {
   const { event } = envelope;
 
-  if (event.type === "step_boundary" || event.type === "activity") {
+  if (event.type === "step_boundary" || event.type === "activity" || event.type === "pending_input_resolved") {
     return;
   }
 
@@ -530,6 +542,24 @@ export function appendCollapsedChatTranscriptEvent(
     }
   }
 
+  if (event.type === "plan_text") {
+    if (!event.text.trim().length) return;
+    const previous = rows[rows.length - 1];
+    if (previous?.event.type === "plan_text" && shouldMergePlanTextRows(previous.event, event)) {
+      rows[rows.length - 1] = {
+        ...previous,
+        timestamp: envelope.timestamp,
+        event: {
+          ...previous.event,
+          text: mergeStreamingText(previous.event.text, event.text),
+          ...(event.turnId && !previous.event.turnId ? { turnId: event.turnId } : {}),
+          ...(event.itemId && !previous.event.itemId ? { itemId: event.itemId } : {}),
+        },
+      };
+      return;
+    }
+  }
+
   if (event.type === "system_notice") {
     const previous = rows[rows.length - 1];
     if (
@@ -570,6 +600,37 @@ export function appendCollapsedChatTranscriptEvent(
     return;
   }
 
+  if (event.type === "plan") {
+    const nextTurn = event.turnId ?? null;
+    if (nextTurn !== null) {
+      for (let index = rows.length - 1; index >= 0; index -= 1) {
+        const candidate = rows[index];
+        if (
+          candidate?.event.type === "plan_text"
+          && (candidate.event.turnId ?? null) === nextTurn
+        ) {
+          rows.splice(index, 1);
+        }
+      }
+
+      const matchIndex = [...rows]
+        .reverse()
+        .findIndex((candidate) =>
+          candidate.event.type === "plan"
+          && (candidate.event.turnId ?? null) === nextTurn,
+        );
+      if (matchIndex >= 0) {
+        const actualIndex = rows.length - 1 - matchIndex;
+        rows[actualIndex] = {
+          ...rows[actualIndex]!,
+          timestamp: envelope.timestamp,
+          event,
+        };
+        return;
+      }
+    }
+  }
+
   if (event.type === "subagent_progress") {
     const matchIndex = [...rows]
       .reverse()
@@ -650,8 +711,58 @@ export function groupConsecutiveWorkLogRows(
   const grouped: ChatTranscriptGroupedEnvelope[] = [];
   let index = 0;
 
+  const absorbToolSummary = (
+    toolSummary: Extract<AgentChatEvent, { type: "tool_use_summary" }>,
+  ): boolean => {
+    const summary = toolSummary.summary.trim();
+    const toolUseIds = toolSummary.toolUseIds.filter((id) => id.trim().length > 0);
+    const candidate = grouped[grouped.length - 1];
+    if (!candidate || candidate.event.type !== "work_log_group") return false;
+
+    const candidateEvent = candidate.event;
+    const candidateTurnId = candidateEvent.turnId ?? candidateEvent.entries[0]?.turnId ?? null;
+    if (toolSummary.turnId && candidateTurnId && candidateTurnId !== toolSummary.turnId) return false;
+
+    if (toolUseIds.length > 0) {
+      const candidateToolIds = new Set(
+        candidateEvent.entries
+          .filter((entry) => entry.entryKind === "tool" && typeof entry.itemId === "string" && entry.itemId.trim().length > 0)
+          .map((entry) => entry.itemId!.trim()),
+      );
+      const hasMatch = toolUseIds.some((toolUseId) => candidateToolIds.has(toolUseId));
+      if (!hasMatch) return false;
+    }
+
+    grouped[grouped.length - 1] = {
+      ...candidate,
+      event: {
+        ...candidateEvent,
+        ...(summary.length > 0 ? { summary } : {}),
+        ...(toolUseIds.length > 0
+          ? {
+              toolUseIds: [
+                ...(candidateEvent.toolUseIds ?? []),
+                ...toolUseIds.filter((toolUseId) => !(candidateEvent.toolUseIds ?? []).includes(toolUseId)),
+              ],
+            }
+          : {}),
+        turnId: candidateTurnId ?? toolSummary.turnId ?? null,
+      },
+    };
+    return true;
+  };
+
   while (index < rows.length) {
     const row = rows[index]!;
+    if (row.event.type === "tool_use_summary") {
+      const prevRow = index > 0 ? rows[index - 1] : null;
+      const prevIsWorkLog = prevRow?.event.type === "work_log_entry";
+      if (prevIsWorkLog && absorbToolSummary(row.event)) {
+        index += 1;
+        continue;
+      }
+    }
+
     if (row.event.type === "work_log_entry") {
       const entries: ChatWorkLogEntry[] = [];
       let cursor = index;
@@ -665,6 +776,7 @@ export function groupConsecutiveWorkLogRows(
         event: {
           type: "work_log_group",
           entries,
+          turnId: entries[0]?.turnId ?? null,
         },
       });
       index = cursor;
diff --git a/apps/desktop/src/renderer/components/chat/pendingInput.test.ts b/apps/desktop/src/renderer/components/chat/pendingInput.test.ts
index 7aa828847..7a22ae766 100644
--- a/apps/desktop/src/renderer/components/chat/pendingInput.test.ts
+++ b/apps/desktop/src/renderer/components/chat/pendingInput.test.ts
@@ -1,9 +1,12 @@
 /* @vitest-environment jsdom */
 
 import { describe, expect, it } from "vitest";
-import type { AgentChatEventEnvelope } from "../../../shared/types";
-import { derivePendingInputRequests } from "./pendingInput";
-import type { DerivedPendingInput } from "./pendingInput";
+import type { AgentChatEventEnvelope, PendingInputRequest } from "../../../shared/types";
+import {
+  derivePendingInputRequests,
+  getPendingInputQuestionCount,
+  hasPendingInputOptions,
+} from "./pendingInput";
 
 // ---------------------------------------------------------------------------
 // Helpers for building test envelopes
@@ -116,6 +119,35 @@ describe("derivePendingInputRequests", () => {
     expect(result[0]!.request.questions[0]!.id).toBe("q1");
   });
 
+  it("recognizes options anywhere in a pending request", () => {
+    const request = {
+      requestId: "req-options",
+      source: "codex",
+      kind: "structured_question",
+      questions: [
+        {
+          id: "q1",
+          question: "What should we inspect first?",
+          allowsFreeform: true,
+        },
+        {
+          id: "q2",
+          question: "Which option should we use?",
+          allowsFreeform: true,
+          options: [
+            { label: "Question flow", value: "question_flow" },
+          ],
+        },
+      ],
+      allowsFreeform: true,
+      blocking: true,
+      canProceedWithoutAnswer: false,
+    } satisfies PendingInputRequest;
+
+    expect(getPendingInputQuestionCount(request)).toBe(2);
+    expect(hasPendingInputOptions(request)).toBe(true);
+  });
+
   it("preserves Cursor structured permission requests", () => {
     const structuredRequest = {
       requestId: "req-cursor-1",
@@ -702,6 +734,42 @@ describe("derivePendingInputRequests", () => {
     expect(opts[2]!.recommended).toBeUndefined();
   });
 
+  it("preserves option previews and preview formats", () => {
+    const structuredRequest = {
+      requestId: "req-preview",
+      source: "mission",
+      kind: "structured_question",
+      questions: [
+        {
+          id: "q-preview",
+          question: "Compare layouts",
+          options: [
+            { label: "Cards", value: "cards", preview: "<div><strong>Cards</strong></div>", previewFormat: "html" },
+            { label: "Table", value: "table", preview: "```md\n| A | B |\n```", previewFormat: "markdown" },
+            { label: "None", value: "none", preview: "" },
+          ],
+        },
+      ],
+    };
+    const events: AgentChatEventEnvelope[] = [
+      envelope({
+        type: "approval_request",
+        itemId: "item-preview",
+        kind: "tool_call",
+        description: "test",
+        turnId: "turn-1",
+        detail: { request: structuredRequest },
+      }),
+    ];
+
+    const result = derivePendingInputRequests(events);
+    const opts = result[0]!.request.questions[0]!.options!;
+    expect(opts[0]!.preview).toBe("<div><strong>Cards</strong></div>");
+    expect(opts[0]!.previewFormat).toBe("html");
+    expect(opts[1]!.previewFormat).toBe("markdown");
+    expect(opts[2]!.preview).toBeUndefined();
+  });
+
   // ---- Question parsing with optional fields ----------------------------
 
   it("parses question with all optional fields", () => {
@@ -714,6 +782,7 @@ describe("derivePendingInputRequests", () => {
           id: "q-full",
           question: "What next?",
           header: "Decision Point",
+          multiSelect: true,
           allowsFreeform: true,
           isSecret: true,
           defaultAssumption: "Continue as planned",
@@ -738,6 +807,7 @@ describe("derivePendingInputRequests", () => {
     expect(q.id).toBe("q-full");
     expect(q.question).toBe("What next?");
     expect(q.header).toBe("Decision Point");
+    expect(q.multiSelect).toBe(true);
     expect(q.allowsFreeform).toBe(true);
     expect(q.isSecret).toBe(true);
     expect(q.defaultAssumption).toBe("Continue as planned");
@@ -775,6 +845,7 @@ describe("derivePendingInputRequests", () => {
     const result = derivePendingInputRequests(events);
     const q = result[0]!.request.questions[0]!;
     expect(q.header).toBeUndefined();
+    expect(q.multiSelect).toBeUndefined();
     expect(q.allowsFreeform).toBeUndefined();
     expect(q.isSecret).toBeUndefined();
     expect(q.defaultAssumption).toBeUndefined();
diff --git a/apps/desktop/src/renderer/components/chat/pendingInput.ts b/apps/desktop/src/renderer/components/chat/pendingInput.ts
index 09da1db67..1f4920880 100644
--- a/apps/desktop/src/renderer/components/chat/pendingInput.ts
+++ b/apps/desktop/src/renderer/components/chat/pendingInput.ts
@@ -12,6 +12,17 @@ export type DerivedPendingInput = {
   request: PendingInputRequest;
 };
 
+export function getPendingInputQuestionCount(request: PendingInputRequest | null | undefined): number {
+  return request?.questions?.length ?? 0;
+}
+
+export function hasPendingInputOptions(request: PendingInputRequest | null | undefined): boolean {
+  if (!request) return false;
+  if (Array.isArray(request.options) && request.options.length > 0) return true;
+  return Array.isArray(request.questions)
+    && request.questions.some((question) => Array.isArray(question.options) && question.options.length > 0);
+}
+
 function readPendingInputOption(value: unknown): PendingInputOption | null {
   const record = readRecord(value);
   if (!record) return null;
@@ -25,6 +36,12 @@ function readPendingInputOption(value: unknown): PendingInputOption | null {
       ? { description: record.description.trim() }
       : {}),
     ...(record.recommended === true ? { recommended: true } : {}),
+    ...(typeof record.preview === "string" && record.preview.trim().length
+      ? { preview: record.preview }
+      : {}),
+    ...(record.previewFormat === "html" || record.previewFormat === "markdown"
+      ? { previewFormat: record.previewFormat }
+      : {}),
   };
 }
 
@@ -38,6 +55,7 @@ function readPendingInputQuestion(value: unknown): PendingInputQuestion | null {
     id,
     question,
     ...(typeof record.header === "string" && record.header.trim().length ? { header: record.header.trim() } : {}),
+    ...(record.multiSelect === true ? { multiSelect: true } : {}),
     ...(record.allowsFreeform === true ? { allowsFreeform: true } : {}),
     ...(record.isSecret === true ? { isSecret: true } : {}),
     ...(typeof record.defaultAssumption === "string" && record.defaultAssumption.trim().length
@@ -175,7 +193,20 @@ export function derivePendingInputRequests(events: AgentChatEventEnvelope[]): De
     const event = envelope.event;
 
     if (event.type === "done") {
-      pending.clear();
+      if (event.status !== "completed") {
+        pending.clear();
+        continue;
+      }
+      for (const [itemId, entry] of pending) {
+        if ((entry.request.turnId ?? null) !== event.turnId) continue;
+        const keepAfterCompletedTurn =
+          entry.request.kind === "question"
+          || entry.request.kind === "structured_question"
+          || entry.request.kind === "plan_approval";
+        if (!keepAfterCompletedTurn) {
+          pending.delete(itemId);
+        }
+      }
       continue;
     }
 
@@ -202,6 +233,11 @@ export function derivePendingInputRequests(events: AgentChatEventEnvelope[]): De
       continue;
     }
 
+    if (event.type === "pending_input_resolved") {
+      pending.delete(event.itemId);
+      continue;
+    }
+
     if (event.type === "tool_result" || event.type === "command" || event.type === "file_change") {
       pending.delete(event.itemId);
     }
diff --git a/apps/desktop/src/renderer/components/cto/OnboardingWizard.tsx b/apps/desktop/src/renderer/components/cto/OnboardingWizard.tsx
index 6325f64e4..1c810a81a 100644
--- a/apps/desktop/src/renderer/components/cto/OnboardingWizard.tsx
+++ b/apps/desktop/src/renderer/components/cto/OnboardingWizard.tsx
@@ -1,14 +1,32 @@
 import React, { useCallback, useEffect, useState } from "react";
-import { CheckCircle } from "@phosphor-icons/react";
+import { Briefcase, Handshake, Lightning, Sparkle, Strategy, Wrench } from "@phosphor-icons/react";
 import type { CtoPersonalityPreset } from "../../../shared/types";
 import { Button } from "../ui/Button";
 import { cn } from "../ui/cn";
-import { cardCls, labelCls, recessedPanelCls, textareaCls } from "./shared/designTokens";
+import { labelCls, textareaCls } from "./shared/designTokens";
 import { CTO_PERSONALITY_PRESETS, getCtoPersonalityPreset } from "./identityPresets";
-import { CtoPromptPreview } from "./CtoPromptPreview";
 
 const CTO_DISPLAY_NAME = "CTO";
 
+const PERSONALITY_THEME: Record<
+  CtoPersonalityPreset,
+  { rgb: string; hex: string; icon: React.ElementType }
+> = {
+  strategic: { rgb: "96, 165, 250", hex: "#60A5FA", icon: Strategy },
+  professional: { rgb: "167, 139, 250", hex: "#A78BFA", icon: Briefcase },
+  hands_on: { rgb: "52, 211, 153", hex: "#34D399", icon: Wrench },
+  casual: { rgb: "251, 191, 36", hex: "#FBBF24", icon: Handshake },
+  minimal: { rgb: "34, 211, 238", hex: "#22D3EE", icon: Lightning },
+  custom: { rgb: "244, 114, 182", hex: "#F472B6", icon: Sparkle },
+};
+
+const HINTS = [
+  "Memory layers active",
+  "Context discovered automatically",
+  "Recovery across compaction",
+  "Doctrine stays immutable",
+];
+
 type PersonalityDraft = {
   customPersonality: string;
   personality: CtoPersonalityPreset;
@@ -27,6 +45,7 @@ export function OnboardingWizard({
   });
   const [saving, setSaving] = useState(false);
   const [error, setError] = useState<string | null>(null);
+  const [hintIndex, setHintIndex] = useState(0);
 
   useEffect(() => {
     const bridge = window.ade?.cto;
@@ -51,6 +70,13 @@ export function OnboardingWizard({
     };
   }, []);
 
+  useEffect(() => {
+    const id = setInterval(() => {
+      setHintIndex((prev) => (prev + 1) % HINTS.length);
+    }, 2500);
+    return () => clearInterval(id);
+  }, []);
+
   const handleFinish = useCallback(async () => {
     const bridge = window.ade?.cto;
     if (!bridge) {
@@ -87,8 +113,6 @@ export function OnboardingWizard({
     }
   }, [draft, onComplete]);
 
-  const selectedPreset = getCtoPersonalityPreset(draft.personality);
-
   return (
     <div
       className="fixed inset-0 z-50 flex items-center justify-center p-4"
@@ -98,12 +122,13 @@ export function OnboardingWizard({
       }}
     >
       <div
-        className="flex max-h-[92vh] w-full max-w-[1080px] flex-col overflow-hidden rounded-[28px] border shadow-float"
+        className="flex max-h-[80vh] w-full max-w-[720px] flex-col overflow-hidden rounded-[28px] border shadow-float"
         style={{
           background: "linear-gradient(180deg, #0A1016 0%, #080C12 100%)",
           borderColor: "rgba(255, 255, 255, 0.08)",
         }}
       >
+        {/* Header */}
         <div
           className="border-b px-6 py-5"
           style={{
@@ -112,124 +137,108 @@ export function OnboardingWizard({
           }}
         >
           <div className="text-[11px] font-semibold uppercase tracking-[0.2em] text-muted-fg/38">CTO setup</div>
-          <div className="mt-2 text-[1.35rem] font-semibold tracking-[-0.03em] text-fg">Set the CTO personality</div>
-          <div className="mt-2 max-w-[44rem] text-[13px] leading-6 text-muted-fg/48">
-            Pick how the persistent CTO should sound. ADE handles project discovery, memory layers, and compaction recovery automatically.
-          </div>
+          <div className="mt-2 text-[1.35rem] font-semibold tracking-[-0.03em] text-fg">Choose a personality</div>
         </div>
 
+        {/* Body */}
         <div className="min-h-0 flex-1 overflow-y-auto p-5">
-          <div className="grid gap-5 xl:grid-cols-[minmax(0,1fr)_320px]">
-            <div className="space-y-4">
-              <div className={cn(cardCls, "space-y-4 p-4")}>
-                <div>
-                  <div className="font-sans text-base font-semibold text-fg">Choose a style</div>
-                  <div className="mt-1 text-xs leading-5 text-muted-fg/45">
-                    You can change this later in CTO settings. The personality overlay affects tone and decision style, not memory or ADE permissions.
-                  </div>
-                </div>
-
-                <div className="grid gap-2 md:grid-cols-2">
-                  {CTO_PERSONALITY_PRESETS.map((preset) => (
-                    <button
-                      key={preset.id}
-                      type="button"
-                      onClick={() => {
-                        setDraft((current) => ({ ...current, personality: preset.id }));
-                        setError(null);
+          <div className="grid grid-cols-2 gap-3 lg:grid-cols-3">
+            {CTO_PERSONALITY_PRESETS.map((preset) => {
+              const theme = PERSONALITY_THEME[preset.id];
+              const isSelected = draft.personality === preset.id;
+              const Icon = theme.icon;
+
+              return (
+                <button
+                  key={preset.id}
+                  type="button"
+                  onClick={() => {
+                    setDraft((current) => ({ ...current, personality: preset.id }));
+                    setError(null);
+                  }}
+                  className="rounded-2xl px-4 py-4 text-left transition-all duration-200"
+                  style={isSelected
+                    ? {
+                        background: `linear-gradient(180deg, rgba(${theme.rgb}, 0.14) 0%, rgba(${theme.rgb}, 0.06) 100%)`,
+                        border: `1px solid rgba(${theme.rgb}, 0.35)`,
+                        backdropFilter: "blur(20px)",
+                        boxShadow: `0 0 20px rgba(${theme.rgb}, 0.15), inset 0 1px 0 rgba(255,255,255,0.06)`,
+                      }
+                    : {
+                        background: `linear-gradient(180deg, rgba(${theme.rgb}, 0.06) 0%, rgba(${theme.rgb}, 0.02) 100%)`,
+                        border: "1px solid rgba(255, 255, 255, 0.06)",
+                        backdropFilter: "blur(20px)",
+                        boxShadow: "inset 0 1px 0 rgba(255,255,255,0.04)",
+                      }
+                  }
+                >
+                  <div className="flex items-center gap-3">
+                    <div
+                      className="flex h-9 w-9 shrink-0 items-center justify-center rounded-xl"
+                      style={{
+                        background: `rgba(${theme.rgb}, ${isSelected ? 0.18 : 0.12})`,
+                        border: `1px solid rgba(${theme.rgb}, ${isSelected ? 0.3 : 0.20})`,
                       }}
-                      className={cn(
-                        "rounded-2xl border px-3 py-3 text-left transition-all duration-200",
-                        draft.personality === preset.id
-                          ? "border-[rgba(56,189,248,0.28)] bg-[rgba(56,189,248,0.08)]"
-                          : "border-white/[0.06] bg-[rgba(24,20,35,0.4)] hover:border-[rgba(56,189,248,0.16)]",
-                      )}
                     >
-                      <div className="text-xs font-medium text-fg">{preset.label}</div>
-                      <div className="mt-1 text-[11px] leading-5 text-muted-fg/45">{preset.description}</div>
-                    </button>
-                  ))}
-                </div>
-
-                {draft.personality === "custom" ? (
-                  <label className="block space-y-1">
-                    <div className={labelCls}>Custom personality overlay</div>
-                    <textarea
-                      className={cn(textareaCls, "min-h-[140px]")}
-                      rows={6}
-                      placeholder="Describe the CTO's tone, standards, and decision style."
-                      value={draft.customPersonality}
-                      onChange={(event) => {
-                        setDraft((current) => ({ ...current, customPersonality: event.target.value }));
-                        setError(null);
-                      }}
-                    />
-                    <div className="text-[11px] leading-5 text-muted-fg/40">
-                      Custom text only changes the personality overlay. ADE still controls doctrine, memory behavior, and recovery across compaction.
+                      <Icon size={16} weight="duotone" style={{ color: theme.hex }} />
                     </div>
-                  </label>
-                ) : null}
-
-                {error ? (
-                  <div className="rounded-lg border border-red-500/20 bg-red-500/[0.06] px-3 py-2 text-[11px] text-red-300">
-                    {error}
-                  </div>
-                ) : null}
-              </div>
-
-              <div className={cn(recessedPanelCls, "space-y-3 p-4")}>
-                <div className="text-[10px] font-medium uppercase tracking-wider text-muted-fg/50">ADE handles the rest</div>
-                <div className="space-y-2">
-                  {[
-                    "Repo and runtime context are discovered as needed instead of being manually stuffed into setup.",
-                    "The CTO writes memory through ADE tools: memorySearch before work, memoryUpdateCore for standing brief changes, and memoryAdd for durable lessons.",
-                    "The same persistent CTO identity survives chat compaction because ADE rehydrates doctrine, memory, and current context automatically.",
-                  ].map((item) => (
-                    <div key={item} className="flex items-start gap-2 text-[11px] leading-5 text-fg/66">
-                      <CheckCircle size={11} weight="fill" style={{ color: "#34D399", marginTop: 2 }} />
-                      <span>{item}</span>
+                    <div className="min-w-0">
+                      <div className="text-sm font-semibold text-fg">{preset.label}</div>
+                      <div className="mt-0.5 text-[11px] leading-4 text-muted-fg/50">{preset.description}</div>
                     </div>
-                  ))}
-                </div>
-              </div>
+                  </div>
+                </button>
+              );
+            })}
+          </div>
+
+          {draft.personality === "custom" ? (
+            <div className="mt-4">
+              <label className="block space-y-1">
+                <div className={labelCls}>Custom personality overlay</div>
+                <textarea
+                  className={cn(textareaCls, "min-h-[120px]")}
+                  rows={5}
+                  placeholder="Describe the CTO's tone, standards, and decision style."
+                  value={draft.customPersonality}
+                  onChange={(event) => {
+                    setDraft((current) => ({ ...current, customPersonality: event.target.value }));
+                    setError(null);
+                  }}
+                />
+              </label>
             </div>
+          ) : null}
 
-            <div className="space-y-3">
-              <div className={cn(recessedPanelCls, "p-4")}>
-                <div className="text-[10px] font-medium uppercase tracking-wider text-muted-fg/50">Current choice</div>
-                <div className="mt-3 rounded-xl border border-white/[0.05] bg-white/[0.02] px-3 py-3">
-                  <div className="text-[10px] text-muted-fg/42">Personality</div>
-                  <div className="mt-1 text-sm font-medium text-fg">{selectedPreset.label}</div>
-                  <div className="mt-1 text-[11px] leading-5 text-muted-fg/45">{selectedPreset.description}</div>
-                </div>
-              </div>
-
-              <CtoPromptPreview
-                compact
-                title="Prompt preview"
-                subtitle="Only the personality overlay changes here. ADE still injects doctrine, memory rules, current context, and capabilities."
-                identityOverride={{
-                  name: CTO_DISPLAY_NAME,
-                  personality: draft.personality,
-                  customPersonality: draft.personality === "custom" ? draft.customPersonality : undefined,
-                  persona: draft.personality === "custom" ? draft.customPersonality : undefined,
-                }}
-              />
+          {error ? (
+            <div className="mt-3 rounded-lg border border-red-500/20 bg-red-500/[0.06] px-3 py-2 text-[11px] text-red-300">
+              {error}
             </div>
-          </div>
+          ) : null}
         </div>
 
+        {/* Footer */}
         <div
-          className="flex items-center justify-between gap-3 border-t px-5 py-4"
+          className="flex items-center justify-between gap-3 border-t px-5 py-3.5"
           style={{
             borderColor: "rgba(255, 255, 255, 0.06)",
             background: "linear-gradient(180deg, rgba(10, 14, 21, 0.9), rgba(8, 11, 17, 0.96))",
           }}
         >
-          <div className="text-[11px] text-muted-fg/38">
-            Personality only. Project context and memory are managed inside ADE.
+          <div className="relative h-5 min-w-0 flex-1 overflow-hidden">
+            {HINTS.map((hint, i) => (
+              <span
+                key={hint}
+                className={cn(
+                  "absolute inset-0 text-[11px] text-muted-fg/40 transition-all duration-500",
+                  i === hintIndex ? "translate-y-0 opacity-100" : "translate-y-2 opacity-0",
+                )}
+              >
+                {hint}
+              </span>
+            ))}
           </div>
-          <div className="flex items-center gap-2">
+          <div className="flex shrink-0 items-center gap-2">
             <Button variant="ghost" onClick={onSkip} disabled={saving}>
               Not now
             </Button>
diff --git a/apps/desktop/src/renderer/components/cto/shared/designTokens.test.ts b/apps/desktop/src/renderer/components/cto/shared/designTokens.test.ts
deleted file mode 100644
index a3117b75a..000000000
--- a/apps/desktop/src/renderer/components/cto/shared/designTokens.test.ts
+++ /dev/null
@@ -1,197 +0,0 @@
-import { describe, expect, it } from "vitest";
-import {
-  inputCls,
-  selectCls,
-  labelCls,
-  ACCENT,
-  textareaCls,
-  cardCls,
-  surfaceCardCls,
-  recessedPanelCls,
-  shellTabBarCls,
-  shellBodyCls,
-  compactHeaderCls,
-  statChipCls,
-  stageCardCls,
-  pipelineCanvasCls,
-  agentStatusMap,
-  WORKER_TEMPLATES,
-} from "./designTokens";
-
-/* ── ACCENT palette ── */
-
-describe("ACCENT", () => {
-  it("exports all five named colors as hex strings", () => {
-    expect(ACCENT.purple).toMatch(/^#[0-9A-Fa-f]{6}$/);
-    expect(ACCENT.blue).toMatch(/^#[0-9A-Fa-f]{6}$/);
-    expect(ACCENT.green).toMatch(/^#[0-9A-Fa-f]{6}$/);
-    expect(ACCENT.pink).toMatch(/^#[0-9A-Fa-f]{6}$/);
-    expect(ACCENT.amber).toMatch(/^#[0-9A-Fa-f]{6}$/);
-  });
-
-  it("has exactly 5 keys", () => {
-    expect(Object.keys(ACCENT)).toHaveLength(5);
-  });
-
-  it("values are all distinct colors", () => {
-    const values = Object.values(ACCENT);
-    const unique = new Set(values);
-    expect(unique.size).toBe(values.length);
-  });
-});
-
-/* ── CSS class strings ── */
-
-describe("CSS class exports", () => {
-  it("inputCls is a non-empty string with common Tailwind input classes", () => {
-    expect(inputCls).toBeTruthy();
-    expect(typeof inputCls).toBe("string");
-    expect(inputCls).toContain("rounded");
-    expect(inputCls).toContain("border");
-  });
-
-  it("selectCls extends inputCls with appearance-none", () => {
-    expect(selectCls).toContain("appearance-none");
-    expect(selectCls).toContain("rounded");
-  });
-
-  it("labelCls includes uppercase and tracking", () => {
-    expect(labelCls).toContain("uppercase");
-    expect(labelCls).toContain("tracking");
-  });
-
-  it("textareaCls is a valid string with border and resize classes", () => {
-    expect(textareaCls).toBeTruthy();
-    expect(textareaCls).toContain("border");
-    expect(textareaCls).toContain("resize");
-  });
-
-  it("cardCls includes rounded corners and shadow", () => {
-    expect(cardCls).toContain("rounded-2xl");
-    expect(cardCls).toContain("shadow");
-  });
-
-  it("surfaceCardCls includes backdrop blur", () => {
-    expect(surfaceCardCls).toContain("backdrop-blur");
-  });
-
-  it("recessedPanelCls includes inset shadow", () => {
-    expect(recessedPanelCls).toContain("shadow");
-  });
-
-  it("shellTabBarCls includes flex layout", () => {
-    expect(shellTabBarCls).toContain("flex");
-  });
-
-  it("shellBodyCls includes background gradient", () => {
-    expect(shellBodyCls).toContain("bg-");
-  });
-
-  it("compactHeaderCls includes border-b for bottom border", () => {
-    expect(compactHeaderCls).toContain("border-b");
-  });
-
-  it("statChipCls includes rounded-full for pill shape", () => {
-    expect(statChipCls).toContain("rounded-full");
-  });
-
-  it("stageCardCls includes hover effects", () => {
-    expect(stageCardCls).toContain("hover:");
-    expect(stageCardCls).toContain("transition");
-  });
-
-  it("pipelineCanvasCls includes gradient background", () => {
-    expect(pipelineCanvasCls).toContain("radial-gradient");
-  });
-});
-
-/* ── agentStatusMap ── */
-
-describe("agentStatusMap", () => {
-  it("covers all four agent statuses", () => {
-    const statuses = ["running", "active", "paused", "idle"] as const;
-    for (const status of statuses) {
-      const entry = agentStatusMap[status];
-      expect(entry, `missing agentStatusMap entry for: ${status}`).toBeDefined();
-      expect(entry.color).toBeTruthy();
-      expect(entry.label).toBeTruthy();
-      expect(entry.dotCls).toBeTruthy();
-      expect(entry.textCls).toBeTruthy();
-      expect(entry.bgCls).toBeTruthy();
-    }
-  });
-
-  it("running status has animate-pulse in dotCls", () => {
-    expect(agentStatusMap.running.dotCls).toContain("animate-pulse");
-  });
-
-  it("labels match expected display values", () => {
-    expect(agentStatusMap.running.label).toBe("Running");
-    expect(agentStatusMap.active.label).toBe("Active");
-    expect(agentStatusMap.paused.label).toBe("Paused");
-    expect(agentStatusMap.idle.label).toBe("Idle");
-  });
-});
-
-/* ── WORKER_TEMPLATES ── */
-
-describe("WORKER_TEMPLATES", () => {
-  it("has 6 templates", () => {
-    expect(WORKER_TEMPLATES).toHaveLength(6);
-  });
-
-  it("each template has required fields", () => {
-    for (const template of WORKER_TEMPLATES) {
-      expect(template.id, "template missing id").toBeTruthy();
-      expect(template.name, `template ${template.id} missing name`).toBeTruthy();
-      expect(template.role, `template ${template.id} missing role`).toBeTruthy();
-      expect(template.description, `template ${template.id} missing description`).toBeTruthy();
-      expect(template.adapterType, `template ${template.id} missing adapterType`).toBeTruthy();
-    }
-  });
-
-  it("includes expected template IDs", () => {
-    const ids = WORKER_TEMPLATES.map((t) => t.id);
-    expect(ids).toContain("backend-engineer");
-    expect(ids).toContain("frontend-engineer");
-    expect(ids).toContain("qa-tester");
-    expect(ids).toContain("devops");
-    expect(ids).toContain("researcher");
-    expect(ids).toContain("custom");
-  });
-
-  it("custom template has empty capabilities", () => {
-    const custom = WORKER_TEMPLATES.find((t) => t.id === "custom");
-    expect(custom, "custom template should exist").toBeTruthy();
-    expect(custom!.capabilities).toHaveLength(0);
-    expect(custom!.title).toBe("");
-  });
-
-  it("non-custom templates have a model specified", () => {
-    const nonCustom = WORKER_TEMPLATES.filter((t) => t.id !== "custom");
-    for (const template of nonCustom) {
-      expect(template.model, `template ${template.id} missing model`).toBeTruthy();
-    }
-  });
-
-  it("each template has unique id", () => {
-    const ids = WORKER_TEMPLATES.map((t) => t.id);
-    const uniqueIds = new Set(ids);
-    expect(uniqueIds.size).toBe(ids.length);
-  });
-
-  it("backend-engineer has expected capabilities", () => {
-    const be = WORKER_TEMPLATES.find((t) => t.id === "backend-engineer");
-    expect(be).toBeTruthy();
-    expect(be!.capabilities).toContain("api");
-    expect(be!.capabilities).toContain("database");
-  });
-
-  it("frontend-engineer has expected capabilities", () => {
-    const fe = WORKER_TEMPLATES.find((t) => t.id === "frontend-engineer");
-    expect(fe).toBeTruthy();
-    expect(fe!.capabilities).toContain("react");
-    expect(fe!.capabilities).toContain("css");
-    expect(fe!.capabilities).toContain("ui");
-  });
-});
diff --git a/apps/desktop/src/renderer/components/lanes/LaneGitActionsPane.test.tsx b/apps/desktop/src/renderer/components/lanes/LaneGitActionsPane.test.tsx
index d91354aa1..121a5ccb8 100644
--- a/apps/desktop/src/renderer/components/lanes/LaneGitActionsPane.test.tsx
+++ b/apps/desktop/src/renderer/components/lanes/LaneGitActionsPane.test.tsx
@@ -5,7 +5,7 @@ import { cleanup, render, screen, waitFor } from "@testing-library/react";
 import userEvent from "@testing-library/user-event";
 import { MemoryRouter } from "react-router-dom";
 import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-import type { DiffChanges, GitConflictState, GitUpstreamSyncStatus, LaneSummary } from "../../../shared/types";
+import type { DiffChanges, GitConflictState, GitStashSummary, GitUpstreamSyncStatus, LaneSummary } from "../../../shared/types";
 import { __resetLaneGitActionRuntimeForTests, LaneGitActionsPane } from "./LaneGitActionsPane";
 
 vi.mock("./CommitTimeline", () => ({
@@ -63,11 +63,21 @@ function buildLane(overrides: Partial<LaneSummary> = {}): LaneSummary {
   };
 }
 
+function buildStash(ref: string, subject: string, createdAt = "2026-03-31T12:00:00.000Z"): GitStashSummary {
+  return {
+    ref,
+    subject,
+    createdAt,
+  };
+}
+
 describe("LaneGitActionsPane rescue action", () => {
   const originalAde = globalThis.window.ade;
   let mockChangesByLaneId: Record<string, DiffChanges>;
+  let mockStashesByLaneId: Record<string, GitStashSummary[]>;
   let mockConflictState: GitConflictState;
   let mockSyncStatus: GitUpstreamSyncStatus;
+  let failDiffRefresh: boolean;
 
   beforeEach(() => {
     mockStoreState = {
@@ -101,6 +111,10 @@ describe("LaneGitActionsPane rescue action", () => {
         unstaged: [],
       },
     };
+    mockStashesByLaneId = {
+      "lane-1": [],
+      "lane-2": [],
+    };
     mockConflictState = {
       laneId: "lane-1",
       kind: null,
@@ -118,15 +132,26 @@ describe("LaneGitActionsPane rescue action", () => {
       recommendedAction: "push",
     };
     mockAutoRebaseStatuses = [];
+    failDiffRefresh = false;
 
     globalThis.window.ade = {
       diff: {
-        getChanges: vi.fn(async ({ laneId }: { laneId: string }) => mockChangesByLaneId[laneId] ?? { staged: [], unstaged: [] }),
+        getChanges: vi.fn(async ({ laneId }: { laneId: string }) => {
+          if (failDiffRefresh) {
+            throw new Error("diff refresh noisy");
+          }
+          return mockChangesByLaneId[laneId] ?? { staged: [], unstaged: [] };
+        }),
       },
       git: {
         commit: vi.fn(async () => ({ operationId: "git-commit", preHeadSha: "abc", postHeadSha: "def" })),
         generateCommitMessage: vi.fn(async () => ({ message: "feat: auto", model: "openai/gpt-5.4-mini" })),
-        stashList: vi.fn(async () => []),
+        stashList: vi.fn(async ({ laneId }: { laneId: string }) => mockStashesByLaneId[laneId] ?? []),
+        stashPush: vi.fn(async () => ({ operationId: "stash-push", preHeadSha: "abc", postHeadSha: "abc" })),
+        stashApply: vi.fn(async () => ({ operationId: "stash-apply", preHeadSha: "abc", postHeadSha: "abc" })),
+        stashPop: vi.fn(async () => ({ operationId: "stash-pop", preHeadSha: "abc", postHeadSha: "abc" })),
+        stashDrop: vi.fn(async () => ({ operationId: "stash-drop", preHeadSha: "abc", postHeadSha: "abc" })),
+        stashClear: vi.fn(async () => ({ operationId: "stash-clear", preHeadSha: "abc", postHeadSha: "abc" })),
         getSyncStatus: vi.fn(async () => mockSyncStatus),
         getConflictState: vi.fn(async () => mockConflictState),
       },
@@ -278,6 +303,137 @@ describe("LaneGitActionsPane rescue action", () => {
     expect(resolveRebaseConflict).toHaveBeenCalledWith("lane-1", "lane-main");
   });
 
+  it("updates the stash count after deleting a stash", async () => {
+    const user = userEvent.setup();
+    mockStashesByLaneId["lane-1"] = [
+      buildStash("stash@{0}", "drop me"),
+      buildStash("stash@{1}", "keep me", "2026-03-30T12:00:00.000Z"),
+    ];
+    (window.ade.git.stashDrop as any).mockImplementationOnce(async ({ stashRef }: { stashRef: string }) => {
+      expect(stashRef).toBe("stash@{0}");
+      mockStashesByLaneId["lane-1"] = [buildStash("stash@{0}", "keep me", "2026-03-30T12:00:00.000Z")];
+      return { operationId: "stash-drop", preHeadSha: "abc", postHeadSha: "abc" };
+    });
+
+    renderPane();
+
+    await screen.findByText("2 saved");
+    expect(screen.getByText("drop me")).toBeTruthy();
+
+    await user.click(screen.getAllByRole("button", { name: "DELETE" })[0]);
+
+    await waitFor(() => {
+      expect(window.ade.git.stashDrop).toHaveBeenCalledWith({ laneId: "lane-1", stashRef: "stash@{0}" });
+    });
+    await waitFor(() => {
+      expect(screen.getByText("1 saved")).toBeTruthy();
+    });
+    expect(screen.queryByText("drop me")).toBeNull();
+    expect(screen.getByText("keep me")).toBeTruthy();
+  });
+
+  it("updates the stash count after restoring a stash", async () => {
+    const user = userEvent.setup();
+    mockStashesByLaneId["lane-1"] = [
+      buildStash("stash@{0}", "restore me"),
+      buildStash("stash@{1}", "keep me", "2026-03-30T12:00:00.000Z"),
+    ];
+    (window.ade.git.stashPop as any).mockImplementationOnce(async ({ stashRef }: { stashRef: string }) => {
+      expect(stashRef).toBe("stash@{0}");
+      mockStashesByLaneId["lane-1"] = [buildStash("stash@{0}", "keep me", "2026-03-30T12:00:00.000Z")];
+      return { operationId: "stash-pop", preHeadSha: "abc", postHeadSha: "abc" };
+    });
+
+    renderPane();
+
+    await screen.findByText("2 saved");
+    expect(screen.getByText("restore me")).toBeTruthy();
+
+    await user.click(screen.getAllByRole("button", { name: "RESTORE" })[0]);
+
+    await waitFor(() => {
+      expect(window.ade.git.stashPop).toHaveBeenCalledWith({ laneId: "lane-1", stashRef: "stash@{0}" });
+    });
+    await waitFor(() => {
+      expect(screen.getByText("1 saved")).toBeTruthy();
+    });
+    expect(screen.queryByText("restore me")).toBeNull();
+    expect(screen.getByText("keep me")).toBeTruthy();
+  });
+
+  it("updates the stash section even if the broader refresh fails afterward", async () => {
+    const user = userEvent.setup();
+    mockStashesByLaneId["lane-1"] = [
+      buildStash("stash@{0}", "drop me"),
+      buildStash("stash@{1}", "keep me", "2026-03-30T12:00:00.000Z"),
+    ];
+    (window.ade.git.stashDrop as any).mockImplementationOnce(async () => {
+      mockStashesByLaneId["lane-1"] = [buildStash("stash@{0}", "keep me", "2026-03-30T12:00:00.000Z")];
+      failDiffRefresh = true;
+      return { operationId: "stash-drop", preHeadSha: "abc", postHeadSha: "abc" };
+    });
+
+    renderPane();
+
+    await screen.findByText("2 saved");
+    await user.click(screen.getAllByRole("button", { name: "DELETE" })[0]);
+
+    await waitFor(() => {
+      expect(screen.getByText("1 saved")).toBeTruthy();
+    });
+    await waitFor(() => {
+      expect(screen.getByText("ERROR: diff refresh noisy")).toBeTruthy();
+    });
+    expect(screen.getByText("keep me")).toBeTruthy();
+  });
+
+  it("clears all stash entries after confirmation", async () => {
+    const user = userEvent.setup();
+    mockStashesByLaneId["lane-1"] = [
+      buildStash("stash@{0}", "drop me"),
+      buildStash("stash@{1}", "keep me", "2026-03-30T12:00:00.000Z"),
+    ];
+    (window.ade.git.stashClear as any).mockImplementationOnce(async () => {
+      mockStashesByLaneId["lane-1"] = [];
+      return { operationId: "stash-clear", preHeadSha: "abc", postHeadSha: "abc" };
+    });
+
+    renderPane();
+
+    await screen.findByText("2 saved");
+    await user.click(screen.getByRole("button", { name: "CLEAR ALL" }));
+    await user.type(await screen.findByPlaceholderText("Type 2 to confirm"), "2");
+    await user.click(screen.getByRole("button", { name: "DELETE ALL" }));
+
+    await waitFor(() => {
+      expect(window.ade.git.stashClear).toHaveBeenCalledWith({ laneId: "lane-1" });
+    });
+    await waitFor(() => {
+      expect(screen.getByText("None saved")).toBeTruthy();
+    });
+  });
+
+  it("leaves the stash list unchanged when deleting a stash fails", async () => {
+    const user = userEvent.setup();
+    mockStashesByLaneId["lane-1"] = [
+      buildStash("stash@{0}", "drop me"),
+      buildStash("stash@{1}", "keep me", "2026-03-30T12:00:00.000Z"),
+    ];
+    (window.ade.git.stashDrop as any).mockRejectedValueOnce(new Error("drop failed"));
+
+    renderPane();
+
+    await screen.findByText("2 saved");
+    await user.click(screen.getAllByRole("button", { name: "DELETE" })[0]);
+
+    await waitFor(() => {
+      expect(screen.getByText("ERROR: drop failed")).toBeTruthy();
+    });
+    expect(screen.getByText("2 saved")).toBeTruthy();
+    expect(screen.getByText("drop me")).toBeTruthy();
+    expect(screen.getByText("keep me")).toBeTruthy();
+  });
+
   it("keeps the generating commit state when leaving and returning to the lane", async () => {
     const user = userEvent.setup();
     let resolveGeneratedMessage: ((value: { message: string; model: string | null }) => void) | undefined;
diff --git a/apps/desktop/src/renderer/components/lanes/LaneGitActionsPane.tsx b/apps/desktop/src/renderer/components/lanes/LaneGitActionsPane.tsx
index 39a6d24d4..f6ba34ce9 100644
--- a/apps/desktop/src/renderer/components/lanes/LaneGitActionsPane.tsx
+++ b/apps/desktop/src/renderer/components/lanes/LaneGitActionsPane.tsx
@@ -1917,6 +1917,7 @@ export function LaneGitActionsPane({
                           });
                           if (confirmation == null) throw new Error("__ade_cancelled__");
                           await window.ade.git.stashClear({ laneId });
+                          await refreshGitMeta(laneId);
                         });
                       }}
                     >
@@ -1982,6 +1983,7 @@ export function LaneGitActionsPane({
                             if (!laneId) return;
                             void runAction("stash pop", async () => {
                               await window.ade.git.stashPop({ laneId, stashRef: stash.ref });
+                              await refreshGitMeta(laneId);
                             });
                           }}
                         >
@@ -2010,6 +2012,7 @@ export function LaneGitActionsPane({
                             if (!laneId) return;
                             void runAction("stash drop", async () => {
                               await window.ade.git.stashDrop({ laneId, stashRef: stash.ref });
+                              await refreshGitMeta(laneId);
                             });
                           }}
                         >
diff --git a/apps/desktop/src/renderer/components/lanes/LaneTerminalsPanel.tsx b/apps/desktop/src/renderer/components/lanes/LaneTerminalsPanel.tsx
index e8bd46faf..a40716dc9 100644
--- a/apps/desktop/src/renderer/components/lanes/LaneTerminalsPanel.tsx
+++ b/apps/desktop/src/renderer/components/lanes/LaneTerminalsPanel.tsx
@@ -318,7 +318,8 @@ export function LaneTerminalsPanel({ overrideLaneId }: { overrideLaneId?: string
               const indicator = sessionIndicatorState({
                 status: s.status,
                 lastOutputPreview: s.lastOutputPreview,
-                runtimeState: s.runtimeState
+                runtimeState: s.runtimeState,
+                toolType: s.toolType,
               });
               const dotClass = statusDotCls(indicator);
               const dotSpin = !profileColor && indicator === "running-active";
diff --git a/apps/desktop/src/renderer/components/lanes/LaneWorkPane.tsx b/apps/desktop/src/renderer/components/lanes/LaneWorkPane.tsx
index 1f1d2110e..1030285cf 100644
--- a/apps/desktop/src/renderer/components/lanes/LaneWorkPane.tsx
+++ b/apps/desktop/src/renderer/components/lanes/LaneWorkPane.tsx
@@ -81,13 +81,13 @@ export function LaneWorkPane({
 
       <div className="min-h-0 flex-1">
         <WorkViewArea
+          gridLayoutId={work.gridLayoutId}
           lanes={laneList}
           sessions={work.sessions}
           visibleSessions={work.visibleSessions}
           activeItemId={work.activeItemId}
           viewMode={work.viewMode}
           draftKind={work.draftKind}
-          showingDraft={work.activeItemId == null}
           setViewMode={work.setViewMode}
           onSelectItem={work.setActiveItemId}
           onCloseItem={work.closeTab}
diff --git a/apps/desktop/src/renderer/components/lanes/LanesPage.tsx b/apps/desktop/src/renderer/components/lanes/LanesPage.tsx
index 4d42d39ec..a191f0ed9 100644
--- a/apps/desktop/src/renderer/components/lanes/LanesPage.tsx
+++ b/apps/desktop/src/renderer/components/lanes/LanesPage.tsx
@@ -244,6 +244,7 @@ export function LanesPage() {
         status: session.status,
         lastOutputPreview: session.lastOutputPreview,
         runtimeState: session.runtimeState,
+        toolType: session.toolType,
       });
       if (bucket === "running") laneSummary.runningCount += 1;
       else if (bucket === "awaiting-input") laneSummary.awaitingInputCount += 1;
@@ -464,22 +465,6 @@ export function LanesPage() {
 
   /* ---- Effects ---- */
 
-  useEffect(() => {
-    const laneId = params.get("laneId");
-    const sessionId = params.get("sessionId");
-    const inspectorTabParam = params.get("inspectorTab");
-    if (laneId) {
-      selectLane(laneId);
-      if (params.get("focus") === "single") {
-        setActiveLaneIds([laneId]);
-      }
-      if (inspectorTabParam) {
-        setLaneInspectorTab(laneId, inspectorTabParam as LaneInspectorTab);
-      }
-    }
-    if (sessionId) focusSession(sessionId);
-  }, [params, selectLane, focusSession, setLaneInspectorTab]);
-
   useEffect(() => { void loadConflictStatuses(); }, [loadConflictStatuses, lanes.length]);
 
   useEffect(() => {
@@ -531,6 +516,7 @@ export function LanesPage() {
         status: session.status,
         lastOutputPreview: session.lastOutputPreview,
         runtimeState: session.runtimeState,
+        toolType: session.toolType,
       });
       return bucket === "running" || bucket === "awaiting-input";
     });
@@ -1141,6 +1127,28 @@ export function LanesPage() {
     setCreateOpen(true);
   }, [lanes]);
 
+  // Intentionally ignore prepareCreateDialog churn so an open ?action=create URL
+  // doesn't reopen and reset the dialog when lanes refresh.
+  // eslint-disable-next-line react-hooks/exhaustive-deps
+  useEffect(() => {
+    const laneId = params.get("laneId");
+    const sessionId = params.get("sessionId");
+    const inspectorTabParam = params.get("inspectorTab");
+    if (params.get("action") === "create") {
+      prepareCreateDialog();
+    }
+    if (laneId) {
+      selectLane(laneId);
+      if (params.get("focus") === "single") {
+        setActiveLaneIds([laneId]);
+      }
+      if (inspectorTabParam) {
+        setLaneInspectorTab(laneId, inspectorTabParam as LaneInspectorTab);
+      }
+    }
+    if (sessionId) focusSession(sessionId);
+  }, [params, selectLane, focusSession, setLaneInspectorTab]);
+
   const handleCreateDialogOpenChange = useCallback((open: boolean) => {
     if (!open && createBusy) return;
     if (!open) resetCreateDialogState();
diff --git a/apps/desktop/src/renderer/components/lanes/TilingLayout.tsx b/apps/desktop/src/renderer/components/lanes/TilingLayout.tsx
index 42ba0a3f3..bd7a6bb38 100644
--- a/apps/desktop/src/renderer/components/lanes/TilingLayout.tsx
+++ b/apps/desktop/src/renderer/components/lanes/TilingLayout.tsx
@@ -139,7 +139,7 @@ function TileRenderer({
           {isChat ? (
             <AgentChatPane laneId={laneId} laneLabel={session.laneName} lockSessionId={session.id} />
           ) : isRunning ? (
-            <TerminalView ptyId={session.ptyId!} sessionId={session.id} className="h-full" />
+            <TerminalView ptyId={session.ptyId!} sessionId={session.id} isActive={isActive} className="h-full" />
           ) : (
             <div className="flex h-full flex-col items-center justify-center p-4 text-center text-muted-fg">
               <div className="text-xs font-semibold">{session.title}</div>
diff --git a/apps/desktop/src/renderer/components/lanes/laneDesignTokens.test.ts b/apps/desktop/src/renderer/components/lanes/laneDesignTokens.test.ts
deleted file mode 100644
index 5246d41ac..000000000
--- a/apps/desktop/src/renderer/components/lanes/laneDesignTokens.test.ts
+++ /dev/null
@@ -1,190 +0,0 @@
-import { describe, expect, it } from "vitest";
-import {
-  COLORS,
-  SANS_FONT,
-  inlineBadge,
-  outlineButton,
-  primaryButton,
-  dangerButton,
-  cardStyle,
-  recessedStyle,
-  processStatusColor,
-  healthColor,
-  formatTimestamp,
-  conflictDotColor,
-} from "./laneDesignTokens";
-
-// ── Style factory functions ──
-
-describe("inlineBadge", () => {
-  it("returns correct base style for a given color", () => {
-    const style = inlineBadge("#FF0000");
-    expect(style.color).toBe("#FF0000");
-    expect(style.background).toBe("#FF000010");
-    expect(style.display).toBe("inline-flex");
-    expect(style.fontSize).toBe(11);
-    expect(style.border).toBe("1px solid transparent");
-    expect(style.borderRadius).toBe(6);
-  });
-
-  it("applies overrides", () => {
-    const style = inlineBadge("#FF0000", { fontWeight: 800, borderRadius: 0 });
-    expect(style.fontWeight).toBe(800);
-    expect(style.borderRadius).toBe(0);
-    // Base properties still present
-    expect(style.color).toBe("#FF0000");
-  });
-});
-
-describe("outlineButton", () => {
-  it("returns default style", () => {
-    const style = outlineButton();
-    expect(style.height).toBe(32);
-    expect(style.cursor).toBe("pointer");
-    expect(style.borderRadius).toBe(8);
-    expect(style.color).toBe(COLORS.textSecondary);
-  });
-
-  it("applies overrides", () => {
-    const style = outlineButton({ color: "red", height: 40 });
-    expect(style.color).toBe("red");
-    expect(style.height).toBe(40);
-  });
-});
-
-describe("primaryButton", () => {
-  it("returns default style", () => {
-    const style = primaryButton();
-    expect(style.height).toBe(32);
-    expect(style.cursor).toBe("pointer");
-    expect(style.color).toBe(COLORS.pageBg);
-    expect(style.border).toBe("none");
-  });
-
-  it("applies overrides", () => {
-    const style = primaryButton({ height: 48 });
-    expect(style.height).toBe(48);
-  });
-});
-
-describe("dangerButton", () => {
-  it("returns default style with danger color", () => {
-    const style = dangerButton();
-    expect(style.color).toBe(COLORS.danger);
-    expect(style.background).toBe(`${COLORS.danger}10`);
-    expect(style.cursor).toBe("pointer");
-    expect(style.border).toBe("1px solid transparent");
-  });
-
-  it("applies overrides", () => {
-    const style = dangerButton({ border: "2px solid red" });
-    expect(style.border).toBe("2px solid red");
-  });
-});
-
-describe("cardStyle", () => {
-  it("returns default card style", () => {
-    const style = cardStyle();
-    expect(style.borderRadius).toBe(16);
-    expect(style.padding).toBe(20);
-    expect(style.border).toContain("1px solid");
-  });
-
-  it("applies overrides", () => {
-    const style = cardStyle({ padding: 10 });
-    expect(style.padding).toBe(10);
-  });
-});
-
-describe("recessedStyle", () => {
-  it("returns default recessed style", () => {
-    const style = recessedStyle();
-    expect(style.borderRadius).toBe(12);
-    expect(style.padding).toBe(12);
-  });
-
-  it("applies overrides", () => {
-    const style = recessedStyle({ borderRadius: 0 });
-    expect(style.borderRadius).toBe(0);
-  });
-});
-
-// ── Status color functions ──
-
-describe("processStatusColor", () => {
-  it("returns success for running", () => {
-    expect(processStatusColor("running")).toBe(COLORS.success);
-  });
-
-  it("returns warning for starting and stopping", () => {
-    expect(processStatusColor("starting")).toBe(COLORS.warning);
-    expect(processStatusColor("stopping")).toBe(COLORS.warning);
-  });
-
-  it("returns danger for degraded, crashed, exited", () => {
-    expect(processStatusColor("degraded")).toBe(COLORS.danger);
-    expect(processStatusColor("crashed")).toBe(COLORS.danger);
-    expect(processStatusColor("exited")).toBe(COLORS.danger);
-  });
-
-  it("returns textDim for undefined/unknown", () => {
-    expect(processStatusColor(undefined)).toBe(COLORS.textDim);
-    expect(processStatusColor("unknown" as any)).toBe(COLORS.textDim);
-  });
-});
-
-describe("healthColor", () => {
-  it("returns success for healthy", () => {
-    expect(healthColor("healthy")).toBe(COLORS.success);
-  });
-
-  it("returns warning for degraded", () => {
-    expect(healthColor("degraded")).toBe(COLORS.warning);
-  });
-
-  it("returns danger for unhealthy", () => {
-    expect(healthColor("unhealthy")).toBe(COLORS.danger);
-  });
-
-  it("returns textDim for unknown and unrecognized values", () => {
-    expect(healthColor("unknown")).toBe(COLORS.textDim);
-    expect(healthColor("something-else")).toBe(COLORS.textDim);
-  });
-});
-
-describe("formatTimestamp", () => {
-  it("formats a valid ISO string to locale time", () => {
-    const result = formatTimestamp("2026-03-26T14:30:45.000Z");
-    // The result should contain hour:minute:second
-    expect(result).toMatch(/\d{1,2}:\d{2}:\d{2}/);
-  });
-
-  it("returns the original string for invalid dates", () => {
-    const result = formatTimestamp("not-a-date");
-    // Either returns locale string for 'Invalid Date' or the original
-    expect(typeof result).toBe("string");
-  });
-});
-
-describe("conflictDotColor", () => {
-  it("returns danger for conflict-active", () => {
-    expect(conflictDotColor("conflict-active")).toBe(COLORS.danger);
-  });
-
-  it("returns warning for conflict-predicted", () => {
-    expect(conflictDotColor("conflict-predicted")).toBe(COLORS.warning);
-  });
-
-  it("returns warning for behind-base", () => {
-    expect(conflictDotColor("behind-base")).toBe(COLORS.warning);
-  });
-
-  it("returns success for merge-ready", () => {
-    expect(conflictDotColor("merge-ready")).toBe(COLORS.success);
-  });
-
-  it("returns textMuted for unknown/undefined", () => {
-    expect(conflictDotColor(undefined)).toBe(COLORS.textMuted);
-    expect(conflictDotColor("other")).toBe(COLORS.textMuted);
-  });
-});
diff --git a/apps/desktop/src/renderer/components/lanes/useLaneWorkSessions.test.ts b/apps/desktop/src/renderer/components/lanes/useLaneWorkSessions.test.ts
index 261551d04..750a345a4 100644
--- a/apps/desktop/src/renderer/components/lanes/useLaneWorkSessions.test.ts
+++ b/apps/desktop/src/renderer/components/lanes/useLaneWorkSessions.test.ts
@@ -30,6 +30,28 @@ vi.mock("../../lib/terminalAttention", () => ({
 }));
 
 vi.mock("../../lib/sessions", () => ({
+  buildOptimisticChatSessionSummary: vi.fn((args: { session: { id: string; laneId: string }; laneName?: string | null }) => ({
+    id: args.session.id,
+    laneId: args.session.laneId,
+    laneName: args.laneName ?? args.session.laneId,
+    ptyId: null,
+    tracked: true,
+    pinned: false,
+    goal: null,
+    toolType: "claude-chat",
+    title: "Claude chat",
+    status: "running",
+    startedAt: "2026-04-01T12:00:00.000Z",
+    endedAt: null,
+    exitCode: null,
+    transcriptPath: "",
+    headShaStart: null,
+    headShaEnd: null,
+    lastOutputPreview: null,
+    summary: null,
+    runtimeState: "idle",
+    resumeCommand: null,
+  })),
   isRunOwnedSession: vi.fn(() => false),
 }));
 
@@ -166,9 +188,9 @@ describe("useLaneWorkSessions — refresh-before-focus ordering", () => {
   });
 
   // -----------------------------------------------------------------------
-  // handleOpenChatSession: refresh() must complete before focusSession / openSessionTab
+  // handleOpenChatSession: opens immediately, then reconciles in background
   // -----------------------------------------------------------------------
-  it("handleOpenChatSession: awaits refresh() before calling focusSession and openSessionTab", async () => {
+  it("handleOpenChatSession: focuses and opens the tab before the refresh finishes", async () => {
     const callOrder: string[] = [];
 
     const { result } = renderHook(() => useLaneWorkSessions("lane-1"));
@@ -200,9 +222,17 @@ describe("useLaneWorkSessions — refresh-before-focus ordering", () => {
     });
 
     // Act: start handleOpenChatSession
-    let handlePromise!: Promise<void>;
     act(() => {
-      handlePromise = result.current.handleOpenChatSession("session-abc");
+      result.current.handleOpenChatSession({
+        id: "session-abc",
+        laneId: "lane-1",
+        provider: "claude",
+        model: "claude-sonnet-4-6",
+        modelId: "anthropic/claude-sonnet-4-6",
+        status: "idle",
+        createdAt: "2026-04-01T12:00:00.000Z",
+        lastActivityAt: "2026-04-01T12:00:00.000Z",
+      });
     });
 
     // Give the async function a tick
@@ -210,16 +240,16 @@ describe("useLaneWorkSessions — refresh-before-focus ordering", () => {
       await new Promise((r) => setTimeout(r, 10));
     });
 
-    // refresh-start should be recorded, focusSession NOT yet
+    // The tab should open immediately while the forced refresh is still pending.
     expect(callOrder).toContain("refresh-start");
-    expect(callOrder).not.toContain("focusSession");
-    expect(callOrder).not.toContain("openSessionTab");
+    expect(callOrder).toContain("focusSession");
+    expect(callOrder).toContain("openSessionTab");
 
     // Resolve the refresh
     await act(async () => {
       expect(refreshResolve).not.toBeNull();
       refreshResolve!();
-      await handlePromise;
+      await new Promise((r) => setTimeout(r, 0));
     });
 
     // Verify ordering
@@ -230,7 +260,48 @@ describe("useLaneWorkSessions — refresh-before-focus ordering", () => {
     expect(refreshDoneIdx).toBeGreaterThanOrEqual(0);
     expect(focusIdx).toBeGreaterThanOrEqual(0);
     expect(openTabIdx).toBeGreaterThanOrEqual(0);
-    expect(refreshDoneIdx).toBeLessThan(focusIdx);
-    expect(refreshDoneIdx).toBeLessThan(openTabIdx);
+    expect(focusIdx).toBeLessThan(refreshDoneIdx);
+    expect(openTabIdx).toBeLessThan(refreshDoneIdx);
+  });
+
+  it("showDraftKind: clears the active lane session and re-enters chat draft mode without closing lane tabs", () => {
+    const previousState = {
+      openItemIds: ["session-1", "session-2"],
+      activeItemId: "session-2",
+      selectedItemId: "session-2",
+      viewMode: "grid",
+      draftKind: "shell",
+      laneFilter: "all",
+      statusFilter: "all",
+      search: "",
+      sessionListOrganization: "all-lanes-by-status",
+      workCollapsedLaneIds: [],
+      workFocusSessionsHidden: false,
+    };
+    let nextState: typeof previousState | null = null;
+
+    setLaneWorkViewStateSpy.mockImplementation(
+      (
+        _projectRoot: string,
+        _laneId: string,
+        next: ((prev: typeof previousState) => typeof previousState) | Partial<typeof previousState>,
+      ) => {
+        nextState = typeof next === "function" ? next(previousState) : { ...previousState, ...next };
+      },
+    );
+
+    const { result } = renderHook(() => useLaneWorkSessions("lane-1"));
+
+    act(() => {
+      result.current.showDraftKind("chat");
+    });
+
+    expect(nextState).toEqual({
+      ...previousState,
+      activeItemId: null,
+      selectedItemId: null,
+      viewMode: "tabs",
+      draftKind: "chat",
+    });
   });
 });
diff --git a/apps/desktop/src/renderer/components/lanes/useLaneWorkSessions.ts b/apps/desktop/src/renderer/components/lanes/useLaneWorkSessions.ts
index 5c564c036..c3b2fd775 100644
--- a/apps/desktop/src/renderer/components/lanes/useLaneWorkSessions.ts
+++ b/apps/desktop/src/renderer/components/lanes/useLaneWorkSessions.ts
@@ -1,10 +1,10 @@
 import { useCallback, useEffect, useMemo, useRef, useState } from "react";
-import type { TerminalSessionSummary } from "../../../shared/types";
+import type { AgentChatSession, TerminalSessionSummary } from "../../../shared/types";
 import { useAppStore, type WorkDraftKind, type WorkProjectViewState, type WorkViewMode } from "../../state/appStore";
 import { listSessionsCached } from "../../lib/sessionListCache";
 import { sessionStatusBucket } from "../../lib/terminalAttention";
 import { shouldRefreshSessionListForChatEvent } from "../../lib/chatSessionEvents";
-import { isRunOwnedSession } from "../../lib/sessions";
+import { buildOptimisticChatSessionSummary, isRunOwnedSession } from "../../lib/sessions";
 import { defaultTrackedCliStartupCommand } from "../terminals/cliLaunch";
 
 const EMPTY_WORK_STATE: WorkProjectViewState = {
@@ -34,6 +34,7 @@ function isActiveSession(session: TerminalSessionSummary): boolean {
     status: session.status,
     lastOutputPreview: session.lastOutputPreview,
     runtimeState: session.runtimeState,
+    toolType: session.toolType,
   }) !== "ended";
 }
 
@@ -57,6 +58,7 @@ export function useLaneWorkSessions(laneId: string | null) {
   const backgroundRefreshTimerRef = useRef<number | null>(null);
   const hasActiveSessionsRef = useRef(false);
   const hasLoadedOnceRef = useRef(false);
+  const hasFetchedOnceRef = useRef(false);
 
   const currentLane = useMemo(
     () => (laneId ? lanes.find((lane) => lane.id === laneId) ?? null : null),
@@ -114,6 +116,7 @@ export function useLaneWorkSessions(laneId: string | null) {
         );
         setSessions(rows.filter((session) => !isRunOwnedSession(session)));
         hasLoadedOnceRef.current = true;
+        hasFetchedOnceRef.current = true;
       } catch (err) {
         console.warn("[useLaneWorkSessions] Failed to refresh sessions:", err);
       } finally {
@@ -143,9 +146,28 @@ export function useLaneWorkSessions(laneId: string | null) {
     }, delayMs);
   }, [refresh]);
 
+  const upsertOptimisticChatSession = useCallback((session: AgentChatSession) => {
+    if (!laneId || session.laneId !== laneId) return;
+    const laneName = currentLane?.name ?? lanes.find((lane) => lane.id === session.laneId)?.name ?? session.laneId;
+    const optimistic = buildOptimisticChatSessionSummary({
+      session,
+      laneName,
+    });
+    optimistic.startedAt = new Date().toISOString();
+    hasLoadedOnceRef.current = true;
+    setSessions((prev) => {
+      const next = [optimistic, ...prev.filter((entry) => entry.id !== session.id)];
+      next.sort((left, right) => (
+        new Date(right.startedAt).getTime() - new Date(left.startedAt).getTime()
+      ));
+      return next;
+    });
+  }, [currentLane?.name, laneId, lanes]);
+
   useEffect(() => {
     setSessions([]);
     hasLoadedOnceRef.current = false;
+    hasFetchedOnceRef.current = false;
     if (!laneId) return;
     void refresh({ showLoading: true, force: true });
   }, [laneId, refresh]);
@@ -225,10 +247,17 @@ export function useLaneWorkSessions(laneId: string | null) {
       .filter((session): session is TerminalSessionSummary => session != null);
   }, [laneOpenItemIds, sessionsById]);
 
+  const gridLayoutId = useMemo(
+    () => `work:grid:v2:${projectRoot ?? "global"}::${laneId ?? "none"}`,
+    [laneId, projectRoot],
+  );
+
   // Validate lane-local activeItemId/selectedItemId against the derived open items.
   // openItemIds are managed at the project level, so we only fix up lane-local pointers here.
+  // Use hasFetchedOnceRef (not hasLoadedOnceRef) so that optimistic inserts don't
+  // trigger pruning before the first real fetch has established an authoritative list.
   useEffect(() => {
-    if (!hasLoadedOnceRef.current) return;
+    if (!hasFetchedOnceRef.current) return;
     setViewState((prev) => {
       const userIsViewingDraft = prev.activeItemId == null && prev.selectedItemId == null;
       if (userIsViewingDraft) return prev;
@@ -429,14 +458,17 @@ export function useLaneWorkSessions(laneId: string | null) {
     [focusSession, openSessionTab, refresh, selectLane],
   );
 
-  const handleOpenChatSession = useCallback(async (sessionId: string) => {
-    if (!laneId) return;
-    selectLane(laneId);
-    // Refresh first so the session is in the list before we activate the tab.
-    await refresh({ showLoading: false, force: true });
-    focusSession(sessionId);
-    openSessionTab(sessionId);
-  }, [focusSession, laneId, openSessionTab, refresh, selectLane]);
+  const handleOpenChatSession = useCallback((session: AgentChatSession) => {
+    selectLane(session.laneId);
+    if (!laneId || session.laneId !== laneId) {
+      focusSession(session.id);
+      return;
+    }
+    upsertOptimisticChatSession(session);
+    focusSession(session.id);
+    openSessionTab(session.id);
+    void refresh({ showLoading: false, force: true });
+  }, [focusSession, laneId, openSessionTab, refresh, selectLane, upsertOptimisticChatSession]);
 
   const closePtySession = useCallback(async (ptyId: string) => {
     setClosingPtyIds((prev) => {
@@ -461,6 +493,7 @@ export function useLaneWorkSessions(laneId: string | null) {
     loading,
     sessions,
     visibleSessions,
+    gridLayoutId,
     activeItemId: laneViewState.activeItemId,
     viewMode: laneViewState.viewMode,
     draftKind: laneViewState.draftKind,
diff --git a/apps/desktop/src/renderer/components/missions/AgentChannels.test.tsx b/apps/desktop/src/renderer/components/missions/AgentChannels.test.tsx
index a0d76593e..22359ec49 100644
--- a/apps/desktop/src/renderer/components/missions/AgentChannels.test.tsx
+++ b/apps/desktop/src/renderer/components/missions/AgentChannels.test.tsx
@@ -82,8 +82,8 @@ describe("AgentChannels", () => {
       expect(globalThis.window.ade.orchestrator.getThreadMessages).toHaveBeenCalled();
     });
 
-    expect(await screen.findByText("Tool calls (1)")).toBeTruthy();
-    expect(await screen.findByText("Work log (1)")).toBeTruthy();
+    expect(await screen.findByText("Run pwd")).toBeTruthy();
+    expect((await waitFor(() => findButtonByTextContent(/foo\.ts/i))).textContent).toContain("Edited");
     expect(screen.queryByText("Tool Call")).toBeNull();
     expect(screen.queryByText("File Edit")).toBeNull();
 
diff --git a/apps/desktop/src/renderer/components/missions/MissionPhaseBadge.test.ts b/apps/desktop/src/renderer/components/missions/MissionPhaseBadge.test.ts
deleted file mode 100644
index 4ba67c9e9..000000000
--- a/apps/desktop/src/renderer/components/missions/MissionPhaseBadge.test.ts
+++ /dev/null
@@ -1,91 +0,0 @@
-/**
- * Tests for MissionPhaseBadge phase-mapping logic.
- *
- * Since MissionPhaseBadge is a React component, we test the exported
- * component's behavior via lightweight DOM assertions (jsdom) to
- * verify phase-key mapping and empty/null handling.
- */
-/* @vitest-environment jsdom */
-
-import { cleanup, render, screen } from "@testing-library/react";
-import { afterEach, describe, expect, it } from "vitest";
-import { createElement } from "react";
-import type { PhaseCard } from "../../../shared/types";
-import { MissionPhaseBadge } from "./MissionPhaseBadge";
-
-afterEach(() => {
-  cleanup();
-});
-
-function makePhase(key: string): PhaseCard {
-  return {
-    phaseKey: key,
-    label: key,
-    status: "active",
-    startedAt: "2026-03-01T00:00:00.000Z",
-    completedAt: null,
-  } as unknown as PhaseCard;
-}
-
-describe("MissionPhaseBadge", () => {
-  it("renders 'NO PHASES' when phases is null", () => {
-    render(createElement(MissionPhaseBadge, { phases: null }));
-    expect(screen.getByText("NO PHASES")).toBeTruthy();
-  });
-
-  it("renders 'NO PHASES' when phases is undefined", () => {
-    render(createElement(MissionPhaseBadge, {}));
-    expect(screen.getByText("NO PHASES")).toBeTruthy();
-  });
-
-  it("renders 'NO PHASES' when phases is empty array", () => {
-    render(createElement(MissionPhaseBadge, { phases: [] }));
-    expect(screen.getByText("NO PHASES")).toBeTruthy();
-  });
-
-  it("renders phase icons P/D/T/V/R for all standard phases", () => {
-    const phases: PhaseCard[] = [
-      makePhase("planning"),
-      makePhase("development"),
-      makePhase("testing"),
-      makePhase("validation"),
-      makePhase("code_review"),
-    ];
-    render(createElement(MissionPhaseBadge, { phases }));
-
-    // All phase indicators should be present
-    expect(screen.getByTitle("Planning")).toBeTruthy();
-    expect(screen.getByTitle("Development")).toBeTruthy();
-    expect(screen.getByTitle("Testing")).toBeTruthy();
-    expect(screen.getByTitle("Validation")).toBeTruthy();
-    expect(screen.getByTitle("Review")).toBeTruthy();
-  });
-
-  it("activates Development phase icon for 'implementation' phaseKey", () => {
-    const phases: PhaseCard[] = [makePhase("implementation")];
-    render(createElement(MissionPhaseBadge, { phases }));
-
-    // Development should be active (implementation maps to D)
-    const devIcon = screen.getByTitle("Development");
-    expect(devIcon).toBeTruthy();
-  });
-
-  it("activates Review phase icon for 'test_review' and 'review' phaseKeys", () => {
-    const phases: PhaseCard[] = [makePhase("test_review")];
-    render(createElement(MissionPhaseBadge, { phases }));
-    const reviewIcon = screen.getByTitle("Review");
-    expect(reviewIcon).toBeTruthy();
-  });
-
-  it("renders profile name badge when provided", () => {
-    const phases: PhaseCard[] = [makePhase("planning")];
-    render(createElement(MissionPhaseBadge, { phases, profileName: "Full Stack" }));
-    expect(screen.getByText("Full Stack")).toBeTruthy();
-  });
-
-  it("does not render profile name badge when null", () => {
-    const phases: PhaseCard[] = [makePhase("planning")];
-    render(createElement(MissionPhaseBadge, { phases, profileName: null }));
-    expect(screen.queryByText("Full Stack")).toBeNull();
-  });
-});
diff --git a/apps/desktop/src/renderer/components/onboarding/ProjectSetupPage.tsx b/apps/desktop/src/renderer/components/onboarding/ProjectSetupPage.tsx
index 2230eaf74..128bfd28d 100644
--- a/apps/desktop/src/renderer/components/onboarding/ProjectSetupPage.tsx
+++ b/apps/desktop/src/renderer/components/onboarding/ProjectSetupPage.tsx
@@ -208,7 +208,7 @@ export function ProjectSetupPage() {
         const next = await window.ade.onboarding.complete();
         setStatus(next);
         publishOnboardingStatusUpdated(next);
-        navigate("/project", { replace: true });
+        navigate("/work", { replace: true });
       } finally {
         setBusy(false);
       }
@@ -228,7 +228,7 @@ export function ProjectSetupPage() {
       const next = await window.ade.onboarding.setDismissed(true);
       setStatus(next);
       publishOnboardingStatusUpdated(next);
-      navigate("/project", { replace: true });
+      navigate("/work", { replace: true });
     } finally {
       setBusy(false);
     }
diff --git a/apps/desktop/src/renderer/components/prs/tabs/GitHubTab.test.tsx b/apps/desktop/src/renderer/components/prs/tabs/GitHubTab.test.tsx
index 02dceb69f..45f0aed52 100644
--- a/apps/desktop/src/renderer/components/prs/tabs/GitHubTab.test.tsx
+++ b/apps/desktop/src/renderer/components/prs/tabs/GitHubTab.test.tsx
@@ -53,6 +53,9 @@ function makeGitHubPr(overrides: Partial<GitHubPrSnapshot["repoPullRequests"][nu
     adeKind: "single",
     workflowDisplayState: null,
     cleanupState: null,
+    labels: [],
+    isBot: false,
+    commentCount: 0,
     ...overrides,
   };
 }
@@ -190,4 +193,159 @@ describe("GitHubTab", () => {
       expect(screen.getAllByLabelText("CI running").length).toBeGreaterThan(0);
     });
   });
+
+  it("filters by ADE scope showing only linked PRs", async () => {
+    const snapshotWithUnlinked: GitHubPrSnapshot = {
+      ...snapshot,
+      repoPullRequests: [
+        ...snapshot.repoPullRequests,
+        makeGitHubPr({
+          id: "repo-unlinked",
+          githubPrNumber: 200,
+          title: "Unlinked PR",
+          linkedPrId: null,
+          linkedLaneId: null,
+          linkedLaneName: null,
+          adeKind: null,
+          createdAt: "2026-03-13T12:00:00.000Z",
+        }),
+      ],
+    };
+    (window.ade.prs.getGitHubSnapshot as ReturnType<typeof vi.fn>).mockResolvedValue(snapshotWithUnlinked);
+    const user = userEvent.setup();
+    renderTab();
+
+    await waitFor(() => {
+      expect(screen.getByText("Unlinked PR")).not.toBeNull();
+    });
+
+    await user.click(screen.getByRole("button", { name: /^ADE/i }));
+
+    await waitFor(() => {
+      expect(screen.queryByText("Unlinked PR")).toBeNull();
+      expect(screen.getByText("Open PR")).not.toBeNull();
+    });
+  });
+
+  it("filters by External scope showing only unlinked PRs", async () => {
+    const snapshotWithUnlinked: GitHubPrSnapshot = {
+      ...snapshot,
+      repoPullRequests: [
+        ...snapshot.repoPullRequests,
+        makeGitHubPr({
+          id: "repo-unlinked",
+          githubPrNumber: 200,
+          title: "Unlinked PR",
+          linkedPrId: null,
+          linkedLaneId: null,
+          linkedLaneName: null,
+          adeKind: null,
+          createdAt: "2026-03-13T12:00:00.000Z",
+        }),
+      ],
+    };
+    (window.ade.prs.getGitHubSnapshot as ReturnType<typeof vi.fn>).mockResolvedValue(snapshotWithUnlinked);
+    const user = userEvent.setup();
+    renderTab();
+
+    await waitFor(() => {
+      expect(screen.getByText("Open PR")).not.toBeNull();
+    });
+
+    await user.click(screen.getByRole("button", { name: /^External/i }));
+
+    await waitFor(() => {
+      expect(screen.queryByText("Open PR")).toBeNull();
+      expect(screen.getByText("Unlinked PR")).not.toBeNull();
+    });
+  });
+
+  it("renders bot badge when isBot is true", async () => {
+    const snapshotWithBot: GitHubPrSnapshot = {
+      ...snapshot,
+      repoPullRequests: [
+        makeGitHubPr({
+          id: "bot-pr",
+          githubPrNumber: 300,
+          title: "Bot PR",
+          author: "dependabot[bot]",
+          isBot: true,
+          createdAt: "2026-03-13T12:00:00.000Z",
+        }),
+      ],
+    };
+    (window.ade.prs.getGitHubSnapshot as ReturnType<typeof vi.fn>).mockResolvedValue(snapshotWithBot);
+    renderTab();
+
+    await waitFor(() => {
+      expect(screen.getByText("bot")).not.toBeNull();
+    });
+  });
+
+  it("renders labels when present", async () => {
+    const snapshotWithLabels: GitHubPrSnapshot = {
+      ...snapshot,
+      repoPullRequests: [
+        makeGitHubPr({
+          id: "labeled-pr",
+          githubPrNumber: 400,
+          title: "Labeled PR",
+          labels: [
+            { name: "bug", color: "d73a4a", description: null },
+            { name: "enhancement", color: "a2eeef", description: null },
+          ],
+          createdAt: "2026-03-13T12:00:00.000Z",
+        }),
+      ],
+    };
+    (window.ade.prs.getGitHubSnapshot as ReturnType<typeof vi.fn>).mockResolvedValue(snapshotWithLabels);
+    renderTab();
+
+    await waitFor(() => {
+      expect(screen.getByText("bug")).not.toBeNull();
+      expect(screen.getByText("enhancement")).not.toBeNull();
+    });
+  });
+
+  it("renders comment count when greater than zero", async () => {
+    const snapshotWithComments: GitHubPrSnapshot = {
+      ...snapshot,
+      repoPullRequests: [
+        makeGitHubPr({
+          id: "commented-pr",
+          githubPrNumber: 500,
+          title: "Commented PR",
+          commentCount: 42,
+          createdAt: "2026-03-13T12:00:00.000Z",
+        }),
+      ],
+    };
+    (window.ade.prs.getGitHubSnapshot as ReturnType<typeof vi.fn>).mockResolvedValue(snapshotWithComments);
+    renderTab();
+
+    await waitFor(() => {
+      expect(screen.getByText("42")).not.toBeNull();
+    });
+  });
+
+  it("sorts PRs by createdAt descending", async () => {
+    const snapshotOrdered: GitHubPrSnapshot = {
+      ...snapshot,
+      repoPullRequests: [
+        makeGitHubPr({ id: "pr-old", githubPrNumber: 50, title: "Old PR", createdAt: "2026-03-13T08:00:00.000Z" }),
+        makeGitHubPr({ id: "pr-new", githubPrNumber: 150, title: "New PR", createdAt: "2026-03-13T12:00:00.000Z" }),
+      ],
+    };
+    (window.ade.prs.getGitHubSnapshot as ReturnType<typeof vi.fn>).mockResolvedValue(snapshotOrdered);
+    renderTab();
+
+    await waitFor(() => {
+      const buttons = screen.getAllByRole("button").filter((btn) =>
+        btn.textContent?.includes("PR") && (btn.textContent?.includes("Old") || btn.textContent?.includes("New")),
+      );
+      expect(buttons.length).toBe(2);
+      expect(buttons[0]!.textContent).toContain("New PR");
+      expect(buttons[1]!.textContent).toContain("Old PR");
+    });
+  });
 });
diff --git a/apps/desktop/src/renderer/components/prs/tabs/GitHubTab.tsx b/apps/desktop/src/renderer/components/prs/tabs/GitHubTab.tsx
index eb541576a..2239b93af 100644
--- a/apps/desktop/src/renderer/components/prs/tabs/GitHubTab.tsx
+++ b/apps/desktop/src/renderer/components/prs/tabs/GitHubTab.tsx
@@ -1,5 +1,5 @@
 import React from "react";
-import { ArrowsClockwise, ArrowSquareOut, CaretDown, CaretRight, CircleNotch, GitMerge, GithubLogo, Link, MagnifyingGlass, Warning } from "@phosphor-icons/react";
+import { ArrowsClockwise, ArrowSquareOut, ChatText, CheckCircle, CircleNotch, GitMerge, GithubLogo, Link, MagnifyingGlass, Warning, XCircle } from "@phosphor-icons/react";
 import { useNavigate } from "react-router-dom";
 import type { GitHubPrListItem, GitHubPrSnapshot, LaneSummary, MergeMethod, PrSummary } from "../../../../shared/types";
 import { EmptyState } from "../../ui/EmptyState";
@@ -21,6 +21,7 @@ type GitHubTabProps = {
 };
 
 type GitHubFilter = "open" | "closed" | "merged" | "all";
+type ScopeFilter = "all" | "ade" | "external";
 
 function matchesFilter(item: GitHubPrListItem, filter: GitHubFilter): boolean {
   if (filter === "all") return true;
@@ -83,7 +84,7 @@ function reviewIndicator(linkedPr: PrSummary | null): { color: string; label: st
     case "changes_requested":
       return { color: COLORS.danger, label: "Changes" };
     case "requested":
-      return { color: COLORS.warning, label: "Review" };
+      return { color: COLORS.warning, label: "Review required" };
     default:
       return null;
   }
@@ -125,6 +126,23 @@ function adeKindBadge(kind: GitHubPrListItem["adeKind"]): React.CSSProperties |
   };
 }
 
+/* -- Label text color from hex background (luminance-aware) -- */
+function labelTextColor(hexColor: string): string {
+  const hex = hexColor.replace("#", "");
+  const r = parseInt(hex.substring(0, 2), 16) || 0;
+  const g = parseInt(hex.substring(2, 4), 16) || 0;
+  const b = parseInt(hex.substring(4, 6), 16) || 0;
+  const luminance = (0.299 * r + 0.587 * g + 0.114 * b) / 255;
+  return luminance > 0.5 ? "#1a1a2e" : "#f0f0f0";
+}
+
+/* -- Scope filter match -- */
+function matchesScope(item: GitHubPrListItem, scope: ScopeFilter): boolean {
+  if (scope === "all") return true;
+  if (scope === "ade") return item.adeKind !== null;
+  return item.adeKind === null;
+}
+
 /* -- Filter button styles -- */
 const FILTER_COLORS: Record<GitHubFilter, { active: { bg: string; border: string; text: string; shadow: string }; inactive: { text: string } }> = {
   open: {
@@ -327,7 +345,7 @@ export function GitHubTab({ lanes, mergeMethod, selectedPrId, onSelectPr, onRefr
   const [error, setError] = React.useState<string | null>(null);
   const [filter, setFilter] = React.useState<GitHubFilter>("open");
   const [selectedItemId, setSelectedItemId] = React.useState<string | null>(null);
-  const [showExternal, setShowExternal] = React.useState(false);
+  const [scopeFilter, setScopeFilter] = React.useState<ScopeFilter>("all");
   const [linkLaneId, setLinkLaneId] = React.useState("");
   const [linkingItemId, setLinkingItemId] = React.useState<string | null>(null);
   const [syncing, setSyncing] = React.useState(false);
@@ -446,25 +464,38 @@ export function GitHubTab({ lanes, mergeMethod, selectedPrId, onSelectPr, onRefr
     );
   }, [searchQuery]);
 
-  const repoItems = React.useMemo(
-    () => (snapshot?.repoPullRequests ?? []).filter((item) => matchesFilter(item, filter) && matchesSearch(item)),
-    [snapshot, filter, matchesSearch],
+  const allItems = React.useMemo(
+    () => [...(snapshot?.repoPullRequests ?? []), ...(snapshot?.externalPullRequests ?? [])],
+    [snapshot],
   );
-  const externalItems = React.useMemo(
-    () => (snapshot?.externalPullRequests ?? []).filter((item) => matchesFilter(item, filter) && matchesSearch(item)),
-    [snapshot, filter, matchesSearch],
+
+  const filteredItems = React.useMemo(
+    () => allItems
+      .filter((item) => matchesFilter(item, filter) && matchesScope(item, scopeFilter) && matchesSearch(item))
+      .sort((a, b) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime()),
+    [allItems, filter, scopeFilter, matchesSearch],
   );
 
-  // Counts for filter tabs (unfiltered by search to show totals)
+  // Counts for filter tabs (scoped but not search-filtered)
   const filterCounts = React.useMemo(() => {
-    const all = snapshot?.repoPullRequests ?? [];
+    const scoped = allItems.filter((item) => matchesScope(item, scopeFilter));
     return {
-      open: all.filter((item) => item.state === "open" || item.state === "draft").length,
-      closed: all.filter((item) => item.state === "closed").length,
-      merged: all.filter((item) => item.state === "merged").length,
-      all: all.length,
+      open: scoped.filter((item) => item.state === "open" || item.state === "draft").length,
+      closed: scoped.filter((item) => item.state === "closed").length,
+      merged: scoped.filter((item) => item.state === "merged").length,
+      all: scoped.length,
     };
-  }, [snapshot]);
+  }, [allItems, scopeFilter]);
+
+  // Counts for scope sub-tabs (status-filtered but not search-filtered)
+  const scopeCounts = React.useMemo(() => {
+    const statusFiltered = allItems.filter((item) => matchesFilter(item, filter));
+    return {
+      all: statusFiltered.length,
+      ade: statusFiltered.filter((item) => item.adeKind !== null).length,
+      external: statusFiltered.filter((item) => item.adeKind === null).length,
+    };
+  }, [allItems, filter]);
 
   React.useEffect(() => {
     if (!snapshot) return;
@@ -476,7 +507,7 @@ export function GitHubTab({ lanes, mergeMethod, selectedPrId, onSelectPr, onRefr
       return;
     }
 
-    const linkedItem = snapshot.repoPullRequests.find((item) => item.linkedPrId === selectedPrId);
+    const linkedItem = allItems.find((item) => item.linkedPrId === selectedPrId);
     if (!linkedItem) {
       pendingSelectedItemIdRef.current = null;
       return;
@@ -500,22 +531,21 @@ export function GitHubTab({ lanes, mergeMethod, selectedPrId, onSelectPr, onRefr
       }
     }
 
-    const visibleItems = [...repoItems, ...externalItems];
-    if (selectedItemId && visibleItems.some((item) => item.id === selectedItemId)) return;
+    if (selectedItemId && filteredItems.some((item) => item.id === selectedItemId)) return;
     if (!hasInitializedSelectionRef.current) {
-      const next = visibleItems[0] ?? null;
+      const next = filteredItems[0] ?? null;
       if (next) {
         hasInitializedSelectionRef.current = true;
         setSelectedItemId(next.id);
         onSelectPr(next.linkedPrId ?? null);
       }
     }
-  }, [snapshot, repoItems, externalItems, selectedItemId, onSelectPr]);
+  }, [snapshot, filteredItems, selectedItemId, onSelectPr]);
 
-  const selectedItem = React.useMemo(() => {
-    const allItems = [...(snapshot?.repoPullRequests ?? []), ...(snapshot?.externalPullRequests ?? [])];
-    return allItems.find((item) => item.id === selectedItemId) ?? null;
-  }, [snapshot, selectedItemId]);
+  const selectedItem = React.useMemo(
+    () => allItems.find((item) => item.id === selectedItemId) ?? null,
+    [allItems, selectedItemId],
+  );
 
   const selectedLinkedPr = React.useMemo(
     () => (selectedItem?.linkedPrId ? prs.find((pr) => pr.id === selectedItem.linkedPrId) ?? null : null),
@@ -712,6 +742,44 @@ export function GitHubTab({ lanes, mergeMethod, selectedPrId, onSelectPr, onRefr
             );
           })}
         </div>
+        {/* Scope sub-tabs: All / ADE / External */}
+        <div style={{ display: "flex", alignItems: "center", gap: 2, padding: "4px 16px 6px", borderTop: "1px solid rgba(255,255,255,0.03)" }}>
+          {(["all", "ade", "external"] as ScopeFilter[]).map((scope) => {
+            const active = scopeFilter === scope;
+            const count = scopeCounts[scope];
+            const label = scope === "ade" ? "ADE" : scope === "external" ? "External" : "All";
+            return (
+              <button
+                key={scope}
+                type="button"
+                onClick={() => {
+                  setScopeFilter(scope);
+                  setSelectedItemId(null);
+                  onSelectPr(null);
+                }}
+                style={{
+                  display: "inline-flex",
+                  alignItems: "center",
+                  gap: 4,
+                  height: 24,
+                  padding: "0 10px",
+                  fontSize: 11,
+                  fontWeight: active ? 600 : 400,
+                  fontFamily: SANS_FONT,
+                  color: active ? "#C4B5FD" : COLORS.textMuted,
+                  background: active ? "rgba(167,139,250,0.10)" : "transparent",
+                  border: active ? "1px solid rgba(167,139,250,0.15)" : "1px solid transparent",
+                  borderRadius: 6,
+                  cursor: "pointer",
+                  transition: "all 150ms ease",
+                }}
+              >
+                {label}
+                <span style={{ fontSize: 10, fontFamily: MONO_FONT, opacity: 0.7 }}>{count}</span>
+              </button>
+            );
+          })}
+        </div>
       </div>
 
       {error ? (
@@ -731,7 +799,7 @@ export function GitHubTab({ lanes, mergeMethod, selectedPrId, onSelectPr, onRefr
       <div style={{ display: "flex", minHeight: 0, flex: 1 }}>
         {/* PR list sidebar */}
         <div style={{ width: 380, borderRight: "1px solid rgba(255,255,255,0.06)", overflow: "auto", flexShrink: 0 }}>
-          {/* Section header: Repo PRs */}
+          {/* Section header */}
           <div style={{
             padding: "10px 14px",
             borderBottom: "1px solid rgba(255,255,255,0.06)",
@@ -740,7 +808,7 @@ export function GitHubTab({ lanes, mergeMethod, selectedPrId, onSelectPr, onRefr
             justifyContent: "space-between",
           }}>
             <div style={{ fontFamily: SANS_FONT, fontSize: 11, fontWeight: 600, color: COLORS.textMuted, letterSpacing: "0.3px" }}>
-              Repo Pull Requests
+              Pull Requests
             </div>
             <span style={{
               fontFamily: MONO_FONT,
@@ -751,23 +819,25 @@ export function GitHubTab({ lanes, mergeMethod, selectedPrId, onSelectPr, onRefr
               padding: "2px 7px",
               borderRadius: 4,
             }}>
-              {repoItems.length}
+              {filteredItems.length}
             </span>
           </div>
 
-          {repoItems.length === 0 ? (
+          {filteredItems.length === 0 ? (
             <div style={{ padding: 20 }}>
-              <EmptyState title="No pull requests" description="No pull requests match the current GitHub filter." />
+              <EmptyState title="No pull requests" description="No pull requests match the current filters." />
             </div>
           ) : (
-            repoItems.map((item) => {
+            filteredItems.map((item) => {
               const selected = item.id === selectedItemId;
               const sc = stateColor(item.state);
               const linkedPr = item.linkedPrId ? prsByIdMap.get(item.linkedPrId) ?? null : null;
               const ci = ciDotColor(linkedPr);
               const ciRunning = linkedPr?.checksStatus === "pending";
               const review = reviewIndicator(linkedPr);
-              const ago = formatTimeAgoCompact(item.updatedAt);
+              const ago = formatTimeAgoCompact(item.createdAt);
+              const visibleLabels = item.labels.slice(0, 4);
+              const overflowCount = item.labels.length - 4;
               return (
                 <button
                   key={item.id}
@@ -777,7 +847,7 @@ export function GitHubTab({ lanes, mergeMethod, selectedPrId, onSelectPr, onRefr
                     display: "flex",
                     width: "100%",
                     flexDirection: "column",
-                    gap: 8,
+                    gap: 6,
                     padding: "11px 14px",
                     textAlign: "left",
                     border: "none",
@@ -792,8 +862,8 @@ export function GitHubTab({ lanes, mergeMethod, selectedPrId, onSelectPr, onRefr
                   onMouseEnter={(e) => { if (!selected) e.currentTarget.style.background = "rgba(255,255,255,0.025)"; }}
                   onMouseLeave={(e) => { if (!selected) e.currentTarget.style.background = "transparent"; }}
                 >
-                  {/* Row 1: avatar, PR number, title, time ago */}
-                  <div style={{ display: "flex", alignItems: "center", gap: 8, minWidth: 0 }}>
+                  {/* Row 1: avatar, bot badge, PR number, title, CI icon, time, comments */}
+                  <div style={{ display: "flex", alignItems: "center", gap: 6, minWidth: 0 }}>
                     {item.author ? (
                       <img
                         src={`https://avatars.githubusercontent.com/${item.author}?size=32`}
@@ -817,6 +887,22 @@ export function GitHubTab({ lanes, mergeMethod, selectedPrId, onSelectPr, onRefr
                         border: "1px solid rgba(255,255,255,0.08)",
                       }} />
                     )}
+                    {item.isBot ? (
+                      <span style={{
+                        fontSize: 9,
+                        fontWeight: 700,
+                        fontFamily: SANS_FONT,
+                        textTransform: "uppercase",
+                        padding: "1px 5px",
+                        borderRadius: 3,
+                        background: "rgba(255,255,255,0.06)",
+                        color: COLORS.textDim,
+                        flexShrink: 0,
+                        letterSpacing: "0.3px",
+                      }}>
+                        bot
+                      </span>
+                    ) : null}
                     <span style={{ fontFamily: MONO_FONT, fontSize: 11, color: sc.text, flexShrink: 0 }}>
                       #{item.githubPrNumber}
                     </span>
@@ -833,13 +919,63 @@ export function GitHubTab({ lanes, mergeMethod, selectedPrId, onSelectPr, onRefr
                     }}>
                       {item.title}
                     </span>
+                    {ci ? (
+                      <span title={ci.title} style={{ display: "inline-flex", flexShrink: 0 }}>
+                        {linkedPr?.checksStatus === "passing" ? (
+                          <CheckCircle size={14} weight="fill" style={{ color: "#4ADE80" }} />
+                        ) : linkedPr?.checksStatus === "failing" ? (
+                          <XCircle size={14} weight="fill" style={{ color: "#EF4444" }} />
+                        ) : ciRunning ? (
+                          <PrCiRunningIndicator color="#FBBF24" size={14} />
+                        ) : null}
+                      </span>
+                    ) : null}
                     {ago ? (
-                      <span style={{ fontFamily: MONO_FONT, fontSize: 10, color: COLORS.textDim, flexShrink: 0, marginLeft: "auto" }}>
+                      <span style={{ fontFamily: MONO_FONT, fontSize: 10, color: COLORS.textDim, flexShrink: 0 }}>
                         {ago}
                       </span>
                     ) : null}
+                    {item.commentCount > 0 ? (
+                      <span style={{ display: "inline-flex", alignItems: "center", gap: 3, flexShrink: 0, color: COLORS.textDim }}>
+                        <ChatText size={12} />
+                        <span style={{ fontFamily: MONO_FONT, fontSize: 10 }}>{item.commentCount}</span>
+                      </span>
+                    ) : null}
                   </div>
-                  {/* Row 2: branch info (Better-Hub style: base ← head) */}
+                  {/* Row 1.5: labels */}
+                  {visibleLabels.length > 0 ? (
+                    <div style={{ display: "flex", alignItems: "center", gap: 4, paddingLeft: 30, flexWrap: "wrap" }}>
+                      {visibleLabels.map((label) => {
+                        const bg = `#${label.color}`;
+                        const textColor = labelTextColor(label.color);
+                        return (
+                          <span
+                            key={label.name}
+                            style={{
+                              display: "inline-flex",
+                              alignItems: "center",
+                              padding: "1px 8px",
+                              fontSize: 10,
+                              fontWeight: 600,
+                              fontFamily: SANS_FONT,
+                              color: textColor,
+                              background: bg,
+                              borderRadius: 10,
+                              lineHeight: "16px",
+                            }}
+                          >
+                            {label.name}
+                          </span>
+                        );
+                      })}
+                      {overflowCount > 0 ? (
+                        <span style={{ fontSize: 10, fontFamily: SANS_FONT, color: COLORS.textDim }}>
+                          +{overflowCount}
+                        </span>
+                      ) : null}
+                    </div>
+                  ) : null}
+                  {/* Row 2: branch info */}
                   {item.baseBranch && item.headBranch ? (
                     <div style={{ display: "flex", alignItems: "center", gap: 4, paddingLeft: 30, fontFamily: MONO_FONT, fontSize: 10, color: COLORS.textDim }}>
                       <span>{item.baseBranch}</span>
@@ -847,10 +983,15 @@ export function GitHubTab({ lanes, mergeMethod, selectedPrId, onSelectPr, onRefr
                       <span style={{ color: COLORS.textMuted, overflow: "hidden", textOverflow: "ellipsis", whiteSpace: "nowrap" }}>{item.headBranch}</span>
                     </div>
                   ) : null}
-                  {/* Row 3: inline stats (Better-Hub style) */}
+                  {/* Row 3: inline stats */}
                   <div style={{ display: "flex", alignItems: "center", flexWrap: "wrap", gap: 6, paddingLeft: 30 }}>
                     <span style={stateBadgeStyle(item)}>{item.state}</span>
                     {adeKindBadge(item.adeKind) ? <span style={adeKindBadge(item.adeKind)!}>{item.adeKind}</span> : null}
+                    {item.scope === "external" ? (
+                      <span style={{ fontFamily: MONO_FONT, fontSize: 10, color: COLORS.textDim }}>
+                        {item.repoOwner}/{item.repoName}
+                      </span>
+                    ) : null}
                     {item.linkedLaneName ? (
                       <span style={{ ...inlineBadge(COLORS.textSecondary), fontSize: 10, padding: "2px 7px", borderRadius: 5 }}>
                         {item.linkedLaneName}
@@ -860,19 +1001,11 @@ export function GitHubTab({ lanes, mergeMethod, selectedPrId, onSelectPr, onRefr
                         unmapped
                       </span>
                     )}
-                    {ci ? (
-                      <span title={ci.title} style={{ display: "inline-flex", alignItems: "center", gap: 4, fontSize: 10, fontFamily: SANS_FONT, color: ci.color }}>
-                        <span style={{ width: 6, height: 6, borderRadius: "50%", background: ci.color, display: "inline-block", boxShadow: `0 0 4px ${ci.color}44` }} />
-                        CI
-                        {ciRunning ? <PrCiRunningIndicator color={ci.color} /> : null}
-                      </span>
-                    ) : null}
                     {review ? (
                       <span style={{ display: "inline-flex", alignItems: "center", padding: "2px 6px", fontSize: 10, fontWeight: 500, fontFamily: SANS_FONT, color: review.color, background: `${review.color}10`, borderRadius: 4 }}>
                         {review.label}
                       </span>
                     ) : null}
-                    {/* +/- stats from linked PR (Better-Hub style) */}
                     {linkedPr ? (
                       <span style={{ display: "inline-flex", alignItems: "center", gap: 4, fontSize: 10, fontFamily: MONO_FONT }}>
                         <span style={{ color: COLORS.success }}>+{linkedPr.additions}</span>
@@ -932,162 +1065,6 @@ export function GitHubTab({ lanes, mergeMethod, selectedPrId, onSelectPr, onRefr
               );
             })
           )}
-
-          {/* External / Unmapped section */}
-          <div style={{ borderTop: "1px solid rgba(255,255,255,0.06)" }}>
-            <button
-              type="button"
-              onClick={() => setShowExternal((value) => !value)}
-              style={{
-                display: "flex",
-                width: "100%",
-                alignItems: "center",
-                gap: 8,
-                padding: "11px 14px",
-                border: "none",
-                borderBottom: "1px solid rgba(255,255,255,0.04)",
-                background: showExternal ? "rgba(245,158,11,0.03)" : "transparent",
-                cursor: "pointer",
-                transition: "background 150ms ease",
-              }}
-            >
-              <span style={{ color: COLORS.warning, display: "flex" }}>
-                {showExternal ? <CaretDown size={13} weight="bold" /> : <CaretRight size={13} weight="bold" />}
-              </span>
-              <span style={{
-                fontFamily: SANS_FONT,
-                fontSize: 11,
-                fontWeight: 600,
-                letterSpacing: "0.3px",
-                color: COLORS.textMuted,
-              }}>
-                External / Unmapped
-              </span>
-              <span style={{
-                marginLeft: "auto",
-                fontFamily: MONO_FONT,
-                fontSize: 10,
-                fontWeight: 600,
-                color: "#FBBF24",
-                background: "rgba(245,158,11,0.10)",
-                padding: "2px 7px",
-                borderRadius: 4,
-              }}>
-                {externalItems.length}
-              </span>
-            </button>
-            {showExternal ? (
-              externalItems.length === 0 ? (
-                <div style={{ padding: "12px 14px", fontFamily: SANS_FONT, fontSize: 12, color: COLORS.textMuted }}>
-                  No external pull requests match this filter.
-                </div>
-              ) : (
-                externalItems.map((item) => {
-                  const selected = item.id === selectedItemId;
-                  const sc = stateColor(item.state);
-                  const ago = formatTimeAgoCompact(item.updatedAt);
-                  return (
-                    <button
-                      key={item.id}
-                      type="button"
-                      onClick={() => handleSelectItem(item)}
-                      style={{
-                        display: "flex",
-                        width: "100%",
-                        flexDirection: "column",
-                        gap: 6,
-                        padding: "11px 14px",
-                        textAlign: "left",
-                        border: "none",
-                        borderLeft: selected ? `3px solid ${sc.text}` : "3px solid transparent",
-                        borderBottom: "1px solid rgba(255,255,255,0.04)",
-                        background: selected
-                          ? `linear-gradient(90deg, ${sc.bg} 0%, rgba(255,255,255,0.02) 100%)`
-                          : "transparent",
-                        cursor: "pointer",
-                        transition: "background 150ms ease",
-                      }}
-                      onMouseEnter={(e) => { if (!selected) e.currentTarget.style.background = "rgba(255,255,255,0.025)"; }}
-                      onMouseLeave={(e) => { if (!selected) e.currentTarget.style.background = "transparent"; }}
-                    >
-                      <div style={{ display: "flex", alignItems: "center", gap: 8, minWidth: 0 }}>
-                        {item.author ? (
-                          <img
-                            src={`https://avatars.githubusercontent.com/${item.author}?size=32`}
-                            alt=""
-                            style={{
-                              width: 22,
-                              height: 22,
-                              borderRadius: "50%",
-                              flexShrink: 0,
-                              border: `1.5px solid ${sc.bg}`,
-                            }}
-                            onError={(e) => { (e.target as HTMLImageElement).style.display = "none"; }}
-                          />
-                        ) : (
-                          <div style={{
-                            width: 22,
-                            height: 22,
-                            borderRadius: "50%",
-                            flexShrink: 0,
-                            background: "rgba(255,255,255,0.05)",
-                            border: "1px solid rgba(255,255,255,0.08)",
-                          }} />
-                        )}
-                        <span style={{
-                          fontSize: 12,
-                          fontWeight: 600,
-                          color: COLORS.textPrimary,
-                          fontFamily: SANS_FONT,
-                          overflow: "hidden",
-                          textOverflow: "ellipsis",
-                          whiteSpace: "nowrap",
-                          flex: 1,
-                          minWidth: 0,
-                        }}>
-                          {item.title}
-                        </span>
-                        {ago ? (
-                          <span style={{ fontFamily: MONO_FONT, fontSize: 10, color: COLORS.textDim, flexShrink: 0 }}>
-                            {ago}
-                          </span>
-                        ) : null}
-                      </div>
-                      <div style={{ display: "flex", alignItems: "center", gap: 6, paddingLeft: 30 }}>
-                        <span style={stateBadgeStyle(item)}>{item.state}</span>
-                        <span style={{ fontFamily: MONO_FONT, fontSize: 10, color: COLORS.textDim }}>
-                          {item.repoOwner}/{item.repoName} #{item.githubPrNumber}
-                        </span>
-                        <button
-                          type="button"
-                          onClick={(e) => {
-                            e.stopPropagation();
-                            void window.ade.app.openExternal(item.githubUrl);
-                          }}
-                          style={{
-                            display: "inline-flex",
-                            alignItems: "center",
-                            marginLeft: "auto",
-                            padding: 0,
-                            background: "transparent",
-                            border: "none",
-                            cursor: "pointer",
-                            color: COLORS.textDim,
-                            transition: "color 100ms ease",
-                          }}
-                          title="Open on GitHub"
-                          onMouseEnter={(e) => { e.currentTarget.style.color = COLORS.textSecondary; }}
-                          onMouseLeave={(e) => { e.currentTarget.style.color = COLORS.textDim; }}
-                        >
-                          <ArrowSquareOut size={13} />
-                        </button>
-                      </div>
-                    </button>
-                  );
-                })
-              )
-            ) : null}
-          </div>
         </div>
 
         {/* Detail pane */}
diff --git a/apps/desktop/src/renderer/components/shared/UnifiedModelSelector.tsx b/apps/desktop/src/renderer/components/shared/UnifiedModelSelector.tsx
index 7c7ae4a78..40a943aa7 100644
--- a/apps/desktop/src/renderer/components/shared/UnifiedModelSelector.tsx
+++ b/apps/desktop/src/renderer/components/shared/UnifiedModelSelector.tsx
@@ -29,6 +29,7 @@ type UnifiedModelSelectorProps = {
   onChange: (modelId: string) => void;
   filter?: (model: ModelDescriptor) => boolean;
   availableModelIds?: string[];
+  catalogMode?: "all" | "available-only";
   className?: string;
   disabled?: boolean;
   showReasoning?: boolean;
@@ -131,6 +132,7 @@ function mergeSelectorModels(
   availableModelIds?: string[],
   selectedModelId?: string,
   filter?: (model: ModelDescriptor) => boolean,
+  catalogMode: "all" | "available-only" = "all",
 ): ModelDescriptor[] {
   const merged = new Map<string, ModelDescriptor>();
   const selectedId = String(selectedModelId ?? "").trim();
@@ -139,10 +141,12 @@ function mergeSelectorModels(
       .map((entry) => String(entry ?? "").trim())
       .filter(Boolean),
   );
-  for (const model of MODEL_REGISTRY) {
-    if (model.deprecated) continue;
-    if (filter && !filter(model)) continue;
-    merged.set(model.id, model);
+  if (catalogMode === "all") {
+    for (const model of MODEL_REGISTRY) {
+      if (model.deprecated) continue;
+      if (filter && !filter(model)) continue;
+      merged.set(model.id, model);
+    }
   }
 
   for (const rawId of availableIdSet) {
@@ -181,6 +185,7 @@ export function UnifiedModelSelector({
   onChange,
   filter,
   availableModelIds,
+  catalogMode = "all",
   className,
   disabled = false,
   showReasoning,
@@ -207,8 +212,8 @@ export function UnifiedModelSelector({
   );
   const modelOrder = useMemo(() => createModelOrderMap(), []);
   const selectorModels = useMemo(
-    () => mergeSelectorModels(availableModelIds, value, filter),
-    [availableModelIds, filter, value],
+    () => mergeSelectorModels(availableModelIds, value, filter, catalogMode),
+    [availableModelIds, catalogMode, filter, value],
   );
 
   const fullTree = useMemo(
diff --git a/apps/desktop/src/renderer/components/shared/conflictResolver/ResolverTerminalModal.tsx b/apps/desktop/src/renderer/components/shared/conflictResolver/ResolverTerminalModal.tsx
index f1cef982e..1a4a29b43 100644
--- a/apps/desktop/src/renderer/components/shared/conflictResolver/ResolverTerminalModal.tsx
+++ b/apps/desktop/src/renderer/components/shared/conflictResolver/ResolverTerminalModal.tsx
@@ -882,7 +882,7 @@ export function ResolverTerminalModal({
                 </div>
               )}
               <div className="h-[480px] w-full overflow-hidden rounded-lg border border-border">
-                <TerminalView ptyId={ptyId} sessionId={sessionId} />
+                <TerminalView ptyId={ptyId} sessionId={sessionId} isActive />
               </div>
               <div className="mt-3 flex justify-end">
                 <Button size="sm" variant="outline" onClick={() => void handleCancel()}>
@@ -954,7 +954,7 @@ export function ResolverTerminalModal({
               {/* Show terminal output in smaller view */}
               {ptyId && sessionId && (
                 <div className="h-[300px] w-full overflow-hidden rounded-lg border border-border">
-                  <TerminalView ptyId={ptyId} sessionId={sessionId} />
+                  <TerminalView ptyId={ptyId} sessionId={sessionId} isActive />
                 </div>
               )}
 
diff --git a/apps/desktop/src/renderer/components/terminals/PackedSessionGrid.test.tsx b/apps/desktop/src/renderer/components/terminals/PackedSessionGrid.test.tsx
new file mode 100644
index 000000000..9753305f9
--- /dev/null
+++ b/apps/desktop/src/renderer/components/terminals/PackedSessionGrid.test.tsx
@@ -0,0 +1,237 @@
+/* @vitest-environment jsdom */
+
+import { act, fireEvent, render } from "@testing-library/react";
+import { afterEach, beforeAll, beforeEach, describe, expect, it, vi } from "vitest";
+import { PackedSessionGrid } from "./PackedSessionGrid";
+
+const layoutGetMock = vi.fn();
+const layoutSetMock = vi.fn();
+let mockViewportWidth = 1000;
+let mockViewportHeight = 800;
+
+type ResizeObserverRecord = {
+  callback: ResizeObserverCallback;
+  target: Element | null;
+  observer: MockResizeObserver | null;
+};
+
+const resizeObservers: ResizeObserverRecord[] = [];
+
+class MockResizeObserver {
+  callback: ResizeObserverCallback;
+  target: Element | null = null;
+  private record: ResizeObserverRecord;
+
+  constructor(callback: ResizeObserverCallback) {
+    this.callback = callback;
+    this.record = { callback, target: null, observer: this };
+    resizeObservers.push(this.record);
+  }
+
+  observe = (target: Element) => {
+    this.target = target;
+    this.record.target = target;
+    this.callback([
+      {
+        target,
+        contentRect: {
+          width: (target as HTMLElement).clientWidth,
+          height: (target as HTMLElement).clientHeight,
+          top: 0,
+          left: 0,
+          right: (target as HTMLElement).clientWidth,
+          bottom: (target as HTMLElement).clientHeight,
+          x: 0,
+          y: 0,
+          toJSON() {
+            return {};
+          },
+        },
+      } as ResizeObserverEntry,
+    ], this as unknown as ResizeObserver);
+  };
+
+  disconnect = vi.fn();
+}
+
+function triggerResizeObservers() {
+  for (const observer of resizeObservers) {
+    if (!observer.target) continue;
+    observer.callback([
+      {
+        target: observer.target,
+        contentRect: {
+          width: (observer.target as HTMLElement).clientWidth,
+          height: (observer.target as HTMLElement).clientHeight,
+          top: 0,
+          left: 0,
+          right: (observer.target as HTMLElement).clientWidth,
+          bottom: (observer.target as HTMLElement).clientHeight,
+          x: 0,
+          y: 0,
+          toJSON() {
+            return {};
+          },
+        },
+      } as ResizeObserverEntry,
+    ], {} as ResizeObserver);
+  }
+}
+
+beforeAll(() => {
+  vi.stubGlobal("ResizeObserver", MockResizeObserver);
+  vi.stubGlobal("PointerEvent", MouseEvent as typeof PointerEvent);
+  Object.defineProperty(HTMLElement.prototype, "clientWidth", {
+    configurable: true,
+    get() {
+      return mockViewportWidth;
+    },
+  });
+  Object.defineProperty(HTMLElement.prototype, "clientHeight", {
+    configurable: true,
+    get() {
+      return mockViewportHeight;
+    },
+  });
+});
+
+beforeEach(() => {
+  vi.useFakeTimers();
+  resizeObservers.length = 0;
+  mockViewportWidth = 1000;
+  mockViewportHeight = 800;
+  layoutGetMock.mockResolvedValue(null);
+  layoutSetMock.mockResolvedValue(undefined);
+  (window as any).ade = {
+    layout: {
+      get: layoutGetMock,
+      set: layoutSetMock,
+    },
+  };
+});
+
+afterEach(() => {
+  vi.clearAllMocks();
+  delete (window as any).ade;
+  vi.useRealTimers();
+});
+
+function buildTiles(count: number, minWidth = 300, minHeight = 220) {
+  return Array.from({ length: count }, (_, index) => {
+    const label = String(index + 1);
+    return {
+      id: `tile-${label}`,
+      minWidth,
+      minHeight,
+      header: <div>{label}</div>,
+      children: <div>{label} body</div>,
+    };
+  });
+}
+
+function renderGrid(tileCount = 3, minWidth = 300, minHeight = 220) {
+  return render(
+    <PackedSessionGrid
+      layoutId="work:grid:test"
+      tiles={buildTiles(tileCount, minWidth, minHeight)}
+    />,
+  );
+}
+
+describe("PackedSessionGrid", () => {
+  it("lays out three tiles evenly across the first row on a wide surface", async () => {
+    const { container } = renderGrid();
+
+    await act(async () => {
+      await vi.runAllTimersAsync();
+    });
+    triggerResizeObservers();
+
+    const first = container.querySelector('[data-grid-tile-id="tile-1"]');
+    const second = container.querySelector('[data-grid-tile-id="tile-2"]');
+    const third = container.querySelector('[data-grid-tile-id="tile-3"]');
+
+    expect(first?.getAttribute("data-grid-slot-start")).toBe("1");
+    expect(second?.getAttribute("data-grid-slot-start")).toBe("2");
+    expect(third?.getAttribute("data-grid-slot-start")).toBe("3");
+    expect(first?.getAttribute("data-grid-row-start")).toBe("1");
+    expect(second?.getAttribute("data-grid-row-start")).toBe("1");
+    expect(third?.getAttribute("data-grid-row-start")).toBe("1");
+  });
+
+  it("uses a balanced 3x2 layout for six wide chat tiles instead of leaving a sparse last row", async () => {
+    mockViewportWidth = 2200;
+    mockViewportHeight = 1200;
+    const { container } = renderGrid(6, 440, 340);
+
+    await act(async () => {
+      await vi.runAllTimersAsync();
+    });
+    triggerResizeObservers();
+
+    expect(container.querySelector('[data-grid-tile-id="tile-1"]')?.getAttribute("data-grid-slot-start")).toBe("1");
+    expect(container.querySelector('[data-grid-tile-id="tile-2"]')?.getAttribute("data-grid-slot-start")).toBe("2");
+    expect(container.querySelector('[data-grid-tile-id="tile-3"]')?.getAttribute("data-grid-slot-start")).toBe("3");
+    expect(container.querySelector('[data-grid-tile-id="tile-4"]')?.getAttribute("data-grid-slot-start")).toBe("1");
+    expect(container.querySelector('[data-grid-tile-id="tile-5"]')?.getAttribute("data-grid-slot-start")).toBe("2");
+    expect(container.querySelector('[data-grid-tile-id="tile-6"]')?.getAttribute("data-grid-slot-start")).toBe("3");
+    expect(container.querySelector('[data-grid-tile-id="tile-4"]')?.getAttribute("data-grid-row-start")).toBe("4");
+  });
+
+  it("uses three columns for five wide chat tiles instead of collapsing into a single stack", async () => {
+    mockViewportWidth = 2200;
+    mockViewportHeight = 1200;
+    const { container } = renderGrid(5, 440, 340);
+
+    await act(async () => {
+      await vi.runAllTimersAsync();
+    });
+    triggerResizeObservers();
+
+    expect(container.querySelector('[data-grid-tile-id="tile-1"]')?.getAttribute("data-grid-slot-start")).toBe("1");
+    expect(container.querySelector('[data-grid-tile-id="tile-2"]')?.getAttribute("data-grid-slot-start")).toBe("2");
+    expect(container.querySelector('[data-grid-tile-id="tile-3"]')?.getAttribute("data-grid-slot-start")).toBe("3");
+    expect(container.querySelector('[data-grid-tile-id="tile-4"]')?.getAttribute("data-grid-slot-start")).toBe("1");
+    expect(container.querySelector('[data-grid-tile-id="tile-5"]')?.getAttribute("data-grid-slot-start")).toBe("2");
+    expect(container.querySelector('[data-grid-tile-id="tile-4"]')?.getAttribute("data-grid-row-start")).toBe("4");
+    expect(container.querySelector('[data-grid-tile-id="tile-5"]')?.getAttribute("data-grid-row-start")).toBe("4");
+  });
+
+  it("persists resized spans and clamps width growth to the available columns", async () => {
+    const { container } = renderGrid();
+
+    await act(async () => {
+      await vi.runAllTimersAsync();
+    });
+    triggerResizeObservers();
+    await act(async () => {
+      await vi.advanceTimersByTimeAsync(150);
+    });
+    layoutSetMock.mockClear();
+
+    const handle = container.querySelector('[data-grid-tile-id="tile-1"] [data-grid-resize-handle="se"]');
+    expect(handle).toBeTruthy();
+
+    fireEvent.pointerDown(handle!, { clientX: 0, clientY: 0 });
+    fireEvent.pointerMove(window, { clientX: 4000, clientY: 500 });
+    await act(async () => {
+      await vi.advanceTimersByTimeAsync(150);
+    });
+
+    expect(layoutSetMock).not.toHaveBeenCalled();
+
+    fireEvent.pointerUp(window);
+
+    await act(async () => {
+      await vi.advanceTimersByTimeAsync(150);
+    });
+
+    expect(layoutSetMock).toHaveBeenCalledTimes(1);
+    const lastCall = layoutSetMock.mock.calls.at(-1);
+    expect(lastCall?.[0]).toBe("work:grid:test");
+    expect(lastCall?.[1]).toMatchObject({
+      "tile-1:col": 36,
+      "tile-1:row": 3,
+    });
+  });
+});
diff --git a/apps/desktop/src/renderer/components/terminals/PackedSessionGrid.tsx b/apps/desktop/src/renderer/components/terminals/PackedSessionGrid.tsx
new file mode 100644
index 000000000..7694e2811
--- /dev/null
+++ b/apps/desktop/src/renderer/components/terminals/PackedSessionGrid.tsx
@@ -0,0 +1,401 @@
+import { useCallback, useEffect, useMemo, useRef, useState, type CSSProperties, type PointerEvent as ReactPointerEvent } from "react";
+import { useDockLayout } from "../ui/DockLayoutState";
+import { cn } from "../ui/cn";
+import {
+  GRID_GAP_PX,
+  GRID_MAX_ROW_SPAN,
+  GRID_COLUMN_SUBDIVISIONS,
+  clampPackedGridSpan,
+  computeDefaultRowSpan,
+  computeMinimumColSpan,
+  computeGridColumnCount,
+  computeMinimumRowSpan,
+  computePackedGridRowHeight,
+  computePackedSpanPixels,
+  packGridItems,
+  readPackedGridSpan,
+  reconcilePackedGridLayout,
+  type PackedGridPlacement,
+  type PackedGridSpan,
+} from "./packedSessionGridMath";
+
+type ResizeDirection = "n" | "s" | "e" | "w" | "ne" | "nw" | "se" | "sw";
+
+type PackedSessionGridTile = {
+  id: string;
+  minWidth: number;
+  minHeight: number;
+  selected?: boolean;
+  onSelect?: () => void;
+  header: React.ReactNode;
+  children: React.ReactNode;
+  className?: string;
+};
+
+type ResizeState = {
+  tileId: string;
+  direction: ResizeDirection;
+  startX: number;
+  startY: number;
+  startSpan: PackedGridSpan;
+  currentSpan: PackedGridSpan;
+  pointerId: number;
+  pointerTarget: HTMLElement | null;
+};
+
+const RESIZE_HANDLES: Array<{ direction: ResizeDirection; style: CSSProperties }> = [
+  { direction: "n", style: { top: -6, left: 4, right: 4, height: 16, cursor: "n-resize" } },
+  { direction: "s", style: { bottom: -6, left: 4, right: 4, height: 16, cursor: "s-resize" } },
+  { direction: "e", style: { right: -6, top: 4, bottom: 4, width: 16, cursor: "e-resize" } },
+  { direction: "w", style: { left: -6, top: 4, bottom: 4, width: 16, cursor: "w-resize" } },
+  { direction: "ne", style: { right: -8, top: -8, width: 20, height: 20, cursor: "ne-resize" } },
+  { direction: "nw", style: { left: -8, top: -8, width: 20, height: 20, cursor: "nw-resize" } },
+  { direction: "se", style: { right: -8, bottom: -8, width: 20, height: 20, cursor: "se-resize" } },
+  { direction: "sw", style: { left: -8, bottom: -8, width: 20, height: 20, cursor: "sw-resize" } },
+];
+
+function hasHorizontalResize(direction: ResizeDirection): boolean {
+  return direction.includes("e") || direction.includes("w");
+}
+
+function hasVerticalResize(direction: ResizeDirection): boolean {
+  return direction.includes("n") || direction.includes("s");
+}
+
+export function PackedSessionGrid({
+  layoutId,
+  tiles,
+  className,
+}: {
+  layoutId: string;
+  tiles: PackedSessionGridTile[];
+  className?: string;
+}) {
+  const { layout, loaded, saveLayout } = useDockLayout(layoutId, {});
+  const viewportRef = useRef<HTMLDivElement | null>(null);
+  const resizeStateRef = useRef<ResizeState | null>(null);
+  const [viewportSize, setViewportSize] = useState({ width: 0, height: 0 });
+  const [resizingTileId, setResizingTileId] = useState<string | null>(null);
+  const [draftSpansById, setDraftSpansById] = useState<Record<string, PackedGridSpan>>({});
+
+  useEffect(() => {
+    const node = viewportRef.current;
+    if (!node || typeof ResizeObserver === "undefined") return;
+    const observer = new ResizeObserver((entries) => {
+      const entry = entries[0];
+      if (!entry) return;
+      setViewportSize({
+        width: Math.floor(entry.contentRect.width),
+        height: Math.floor(entry.contentRect.height),
+      });
+    });
+    observer.observe(node);
+    return () => observer.disconnect();
+  }, []);
+
+  const minRowSpans = useMemo(() => {
+    const next: Record<string, number> = {};
+    for (const tile of tiles) {
+      next[tile.id] = computeMinimumRowSpan(tile.minHeight);
+    }
+    return next;
+  }, [tiles]);
+
+  const defaultRowSpan = useMemo(
+    () => computeDefaultRowSpan(Object.values(minRowSpans)),
+    [minRowSpans],
+  );
+
+  const defaultSpansById = useMemo(() => {
+    const next: Record<string, PackedGridSpan> = {};
+    for (const tile of tiles) {
+      next[tile.id] = {
+        colSpan: GRID_COLUMN_SUBDIVISIONS,
+        rowSpan: Math.max(minRowSpans[tile.id] ?? 1, defaultRowSpan),
+      };
+    }
+    return next;
+  }, [defaultRowSpan, minRowSpans, tiles]);
+
+  useEffect(() => {
+    if (!loaded) return;
+    const nextLayout = reconcilePackedGridLayout({
+      layout,
+      tileIds: tiles.map((tile) => tile.id),
+      defaultSpansById,
+    });
+    const sameKeys = Object.keys(nextLayout).length === Object.keys(layout).length
+      && Object.entries(nextLayout).every(([key, value]) => layout[key] === value);
+    if (!sameKeys) {
+      saveLayout(nextLayout);
+    }
+  }, [defaultSpansById, layout, loaded, saveLayout, tiles]);
+
+  const columnCount = useMemo(() => {
+    const minTileWidth = tiles.reduce((largest, tile) => Math.max(largest, tile.minWidth), 0);
+    return computeGridColumnCount({
+      containerWidth: viewportSize.width,
+      tileCount: tiles.length,
+      minTileWidth,
+    });
+  }, [tiles, viewportSize.width]);
+
+  const trackCount = useMemo(
+    () => Math.max(GRID_COLUMN_SUBDIVISIONS, columnCount * GRID_COLUMN_SUBDIVISIONS),
+    [columnCount],
+  );
+
+  const trackWidth = useMemo(() => {
+    if (trackCount <= 0 || viewportSize.width <= 0) return 0;
+    const availableWidth = viewportSize.width - GRID_GAP_PX * Math.max(0, trackCount - 1);
+    return Math.max(0, availableWidth / trackCount);
+  }, [trackCount, viewportSize.width]);
+
+  const minColSpans = useMemo(() => {
+    const next: Record<string, number> = {};
+    for (const tile of tiles) {
+      next[tile.id] = computeMinimumColSpan({
+        minWidthPx: tile.minWidth,
+        trackWidthPx: trackWidth,
+      });
+    }
+    return next;
+  }, [tiles, trackWidth]);
+
+  const spansById = useMemo(() => {
+    const next: Record<string, PackedGridSpan> = {};
+    for (const tile of tiles) {
+      next[tile.id] = clampPackedGridSpan({
+        span: readPackedGridSpan(layout, tile.id, defaultSpansById[tile.id] ?? { colSpan: 1, rowSpan: 1 }),
+        columnCount: trackCount,
+        minColSpan: minColSpans[tile.id] ?? 1,
+        minRowSpan: minRowSpans[tile.id] ?? 1,
+        maxRowSpan: GRID_MAX_ROW_SPAN,
+      });
+    }
+    return next;
+  }, [defaultSpansById, layout, minColSpans, minRowSpans, tiles, trackCount]);
+
+  const effectiveSpansById = useMemo(() => {
+    if (!Object.keys(draftSpansById).length) return spansById;
+    const next = { ...spansById };
+    for (const [tileId, span] of Object.entries(draftSpansById)) {
+      next[tileId] = span;
+    }
+    return next;
+  }, [draftSpansById, spansById]);
+
+  const packedItems = useMemo(() => {
+    return tiles.map((tile) => ({
+      id: tile.id,
+      minRowSpan: minRowSpans[tile.id] ?? 1,
+      span: effectiveSpansById[tile.id] ?? defaultSpansById[tile.id] ?? { colSpan: 1, rowSpan: 1 },
+    }));
+  }, [defaultSpansById, effectiveSpansById, minRowSpans, tiles]);
+
+  const packed = useMemo(
+    () => packGridItems(packedItems, trackCount),
+    [packedItems, trackCount],
+  );
+
+  const rowHeight = useMemo(
+    () =>
+      computePackedGridRowHeight({
+        containerHeight: viewportSize.height,
+        totalRows: packed.totalRows,
+      }),
+    [packed.totalRows, viewportSize.height],
+  );
+
+  const placementById = useMemo(() => {
+    const next = new Map<string, PackedGridPlacement>();
+    for (const placement of packed.placements) {
+      next.set(placement.id, placement);
+    }
+    return next;
+  }, [packed.placements]);
+
+  const contentHeight = useMemo(
+    () => computePackedSpanPixels(packed.totalRows, rowHeight),
+    [packed.totalRows, rowHeight],
+  );
+
+  const stopResize = useCallback((clearDraft = true) => {
+    const state = resizeStateRef.current;
+    if (state?.pointerTarget && state.pointerTarget.hasPointerCapture?.(state.pointerId)) {
+      state.pointerTarget.releasePointerCapture(state.pointerId);
+    }
+    resizeStateRef.current = null;
+    setResizingTileId(null);
+    if (clearDraft) {
+      setDraftSpansById({});
+    }
+    document.body.style.userSelect = "";
+    document.body.style.cursor = "";
+  }, []);
+
+  useEffect(() => {
+    return () => {
+      stopResize();
+    };
+  }, [stopResize]);
+
+  useEffect(() => {
+    const handlePointerMove = (event: PointerEvent) => {
+      const state = resizeStateRef.current;
+      if (!state || trackWidth <= 0 || rowHeight <= 0) return;
+      const colUnit = trackWidth + GRID_GAP_PX;
+      const rowUnit = rowHeight + GRID_GAP_PX;
+
+      let nextColSpan = state.startSpan.colSpan;
+      let nextRowSpan = state.startSpan.rowSpan;
+
+      if (hasHorizontalResize(state.direction)) {
+        const rawDelta = (event.clientX - state.startX) / colUnit;
+        const normalizedDelta = state.direction.includes("w") ? -rawDelta : rawDelta;
+        nextColSpan = state.startSpan.colSpan + Math.round(normalizedDelta);
+      }
+
+      if (hasVerticalResize(state.direction)) {
+        const rawDelta = (event.clientY - state.startY) / rowUnit;
+        const normalizedDelta = state.direction.includes("n") ? -rawDelta : rawDelta;
+        nextRowSpan = state.startSpan.rowSpan + Math.round(normalizedDelta);
+      }
+
+      const clamped = clampPackedGridSpan({
+        span: { colSpan: nextColSpan, rowSpan: nextRowSpan },
+        columnCount: trackCount,
+        minColSpan: minColSpans[state.tileId] ?? 1,
+        minRowSpan: minRowSpans[state.tileId] ?? 1,
+        maxRowSpan: GRID_MAX_ROW_SPAN,
+      });
+      if (
+        clamped.colSpan === state.currentSpan.colSpan
+        && clamped.rowSpan === state.currentSpan.rowSpan
+      ) {
+        return;
+      }
+
+      resizeStateRef.current = {
+        ...state,
+        currentSpan: clamped,
+      };
+      setDraftSpansById((prev) => {
+        const current = prev[state.tileId];
+        if (current?.colSpan === clamped.colSpan && current?.rowSpan === clamped.rowSpan) {
+          return prev;
+        }
+        return {
+          ...prev,
+          [state.tileId]: clamped,
+        };
+      });
+    };
+
+    const handlePointerUp = () => {
+      const state = resizeStateRef.current;
+      if (state && (
+        state.currentSpan.colSpan !== state.startSpan.colSpan
+        || state.currentSpan.rowSpan !== state.startSpan.rowSpan
+      )) {
+        saveLayout((prev) => ({
+          ...prev,
+          [`${state.tileId}:col`]: state.currentSpan.colSpan,
+          [`${state.tileId}:row`]: state.currentSpan.rowSpan,
+        }));
+      }
+      stopResize();
+    };
+
+    window.addEventListener("pointermove", handlePointerMove);
+    window.addEventListener("pointerup", handlePointerUp);
+    return () => {
+      window.removeEventListener("pointermove", handlePointerMove);
+      window.removeEventListener("pointerup", handlePointerUp);
+    };
+  }, [minColSpans, minRowSpans, rowHeight, saveLayout, stopResize, trackCount, trackWidth]);
+
+  const beginResize = useCallback((tileId: string, direction: ResizeDirection, event: ReactPointerEvent<HTMLElement>) => {
+    event.preventDefault();
+    event.stopPropagation();
+    event.currentTarget.setPointerCapture?.(event.pointerId);
+    document.body.style.cursor = `${direction}-resize`;
+    resizeStateRef.current = {
+      tileId,
+      direction,
+      startX: event.clientX,
+      startY: event.clientY,
+      startSpan: spansById[tileId] ?? { colSpan: 1, rowSpan: 1 },
+      currentSpan: spansById[tileId] ?? { colSpan: 1, rowSpan: 1 },
+      pointerId: event.pointerId,
+      pointerTarget: event.currentTarget,
+    };
+    setResizingTileId(tileId);
+    document.body.style.userSelect = "none";
+  }, [spansById]);
+
+  return (
+    <div ref={viewportRef} className={cn("min-h-0 flex-1 overflow-auto p-2", className)}>
+      <div
+        className="relative min-h-full"
+        style={{ height: `${Math.max(contentHeight, viewportSize.height)}px` }}
+      >
+        {tiles.map((tile) => {
+          const placement = placementById.get(tile.id);
+          if (!placement) return null;
+
+          const left = (placement.column - 1) * (trackWidth + GRID_GAP_PX);
+          const top = (placement.row - 1) * (rowHeight + GRID_GAP_PX);
+          const width = computePackedSpanPixels(placement.colSpan, trackWidth);
+          const height = computePackedSpanPixels(placement.rowSpan, rowHeight);
+          const slotStart = Math.ceil(placement.column / GRID_COLUMN_SUBDIVISIONS);
+
+          return (
+            <section
+              key={tile.id}
+              data-grid-tile-id={tile.id}
+              data-grid-slot-start={slotStart}
+              data-grid-col-start={placement.column}
+              data-grid-col-span={placement.colSpan}
+              data-grid-row-start={placement.row}
+              data-grid-row-span={placement.rowSpan}
+              className={cn(
+                "group absolute min-h-0 min-w-0",
+              )}
+              style={{
+                left,
+                top,
+                width,
+                height,
+              }}
+              onMouseDown={() => tile.onSelect?.()}
+            >
+              <div className={cn(
+                "flex h-full min-h-0 min-w-0 flex-col overflow-hidden rounded-md",
+                tile.className,
+              )}>
+                {tile.header}
+                <div className="min-h-0 flex-1 overflow-hidden">{tile.children}</div>
+              </div>
+              <div
+                className={cn(
+                  "pointer-events-none absolute inset-0 rounded-md border border-white/[0.04] transition-opacity",
+                  tile.selected || resizingTileId === tile.id ? "opacity-100" : "opacity-0 group-hover:opacity-100",
+                )}
+              />
+              {RESIZE_HANDLES.map((handle) => (
+                <div
+                  key={handle.direction}
+                  data-grid-resize-handle={handle.direction}
+                  className="pointer-events-none absolute z-10 rounded-md group-hover:pointer-events-auto"
+                  style={{ ...handle.style, touchAction: "none" }}
+                  onPointerDown={(event) => beginResize(tile.id, handle.direction, event)}
+                />
+              ))}
+            </section>
+          );
+        })}
+      </div>
+    </div>
+  );
+}
diff --git a/apps/desktop/src/renderer/components/terminals/SessionCard.tsx b/apps/desktop/src/renderer/components/terminals/SessionCard.tsx
index 0b26114b3..4026dc978 100644
--- a/apps/desktop/src/renderer/components/terminals/SessionCard.tsx
+++ b/apps/desktop/src/renderer/components/terminals/SessionCard.tsx
@@ -50,7 +50,7 @@ export const SessionCard = React.memo(function SessionCard({
   const dot = sessionStatusDot(session);
   const canResume = session.status !== "running" && Boolean(session.resumeCommand);
   const isEnded = session.status !== "running";
-  const delta = useSessionDelta(session.id, isEnded);
+  const delta = useSessionDelta(session.id, true);
   const primaryText = primarySessionLabel(session);
   const secondaryText = truncateSummary(secondarySessionLabel(session), 20);
 
diff --git a/apps/desktop/src/renderer/components/terminals/SessionInfoPopover.tsx b/apps/desktop/src/renderer/components/terminals/SessionInfoPopover.tsx
index 083e19dc9..e7030926d 100644
--- a/apps/desktop/src/renderer/components/terminals/SessionInfoPopover.tsx
+++ b/apps/desktop/src/renderer/components/terminals/SessionInfoPopover.tsx
@@ -11,7 +11,7 @@ import {
 import type { TerminalSessionSummary } from "../../../shared/types";
 import { sanitizeTerminalInlineText } from "../../lib/terminalAttention";
 import { formatToolTypeLabel, isChatToolType } from "../../lib/sessions";
-import { getTerminalRuntimeHealth } from "./TerminalView";
+import { getTerminalRuntimeSnapshot } from "./TerminalView";
 import { SessionDeltaCard } from "./SessionDeltaCard";
 import { Button } from "../ui/Button";
 
@@ -69,7 +69,8 @@ export function SessionInfoPopover({
 
   const { session, x, y } = popover;
   const isChat = isChatToolType(session.toolType);
-  const health = getTerminalRuntimeHealth(session.id);
+  const runtime = getTerminalRuntimeSnapshot(session.id);
+  const health = runtime?.health ?? null;
 
   // Position: try to place to the right, but clamp to viewport
   const left = Math.min(x + 8, window.innerWidth - 420);
@@ -191,10 +192,12 @@ export function SessionInfoPopover({
               Terminal health
             </div>
             <div className="grid grid-cols-2 gap-1 text-[11px] font-mono text-muted-fg/70">
+              <span>renderer_mode: {runtime?.renderer ?? "dom"}</span>
               <span>fit_failures: {health.fitFailures}</span>
               <span>zero_dim: {health.zeroDimFits}</span>
-              <span>renderer: {health.rendererFallbacks}</span>
+              <span>renderer_fallbacks: {health.rendererFallbacks}</span>
               <span>dropped: {health.droppedChunks}</span>
+              <span>fit_recoveries: {health.fitRecoveries}</span>
             </div>
           </div>
         ) : null}
diff --git a/apps/desktop/src/renderer/components/terminals/SessionListPane.tsx b/apps/desktop/src/renderer/components/terminals/SessionListPane.tsx
index 71fc0a2d7..8dc8eb0a2 100644
--- a/apps/desktop/src/renderer/components/terminals/SessionListPane.tsx
+++ b/apps/desktop/src/renderer/components/terminals/SessionListPane.tsx
@@ -1,5 +1,6 @@
 import React, { useMemo, useState } from "react";
-import { CaretDown, CaretRight, Terminal, MagnifyingGlass, Funnel } from "@phosphor-icons/react";
+import { useNavigate } from "react-router-dom";
+import { CaretDown, CaretRight, Terminal, MagnifyingGlass, Funnel, Plus } from "@phosphor-icons/react";
 import type { LaneSummary, TerminalSessionSummary } from "../../../shared/types";
 import { SessionCard } from "./SessionCard";
 import { LaneCombobox } from "./LaneCombobox";
@@ -16,6 +17,7 @@ function bucketSessions(sessions: TerminalSessionSummary[]) {
       status: s.status,
       lastOutputPreview: s.lastOutputPreview,
       runtimeState: s.runtimeState,
+      toolType: s.toolType,
     });
     if (b === "running") running.push(s);
     else if (b === "awaiting-input") awaiting.push(s);
@@ -82,7 +84,7 @@ export const SessionListPane = React.memo(function SessionListPane({
   selectedSessionId,
   draftKind: _draftKind,
   showingDraft: _showingDraft,
-  onShowDraftKind: _onShowDraftKind,
+  onShowDraftKind,
   onSelectSession,
   onResume,
   resumingSessionId,
@@ -120,6 +122,7 @@ export const SessionListPane = React.memo(function SessionListPane({
   toggleWorkLaneCollapsed: (laneId: string) => void;
   sessionsGroupedByLane: Map<string, TerminalSessionSummary[]> | null;
 }) {
+  const navigate = useNavigate();
   const orderedLanes = useMemo(() => sortLanesForTabs(lanes), [lanes]);
 
   const hasAnySessions =
@@ -264,6 +267,23 @@ export const SessionListPane = React.memo(function SessionListPane({
               onChange={(e) => setQ(e.target.value)}
             />
           </div>
+          <button
+            type="button"
+            className="inline-flex h-7 shrink-0 items-center gap-1 rounded-lg px-2 text-[10px] font-medium transition-colors"
+            style={{
+              border: "1px solid rgba(168,130,255,0.35)",
+              background: "rgba(168,130,255,0.08)",
+              color: "rgba(168,130,255,0.9)",
+              cursor: "pointer",
+              whiteSpace: "nowrap",
+            }}
+            onClick={() => onShowDraftKind("chat")}
+            title="New Chat"
+            aria-label="Start a new chat"
+          >
+            <Plus size={10} weight="bold" />
+            New Chat
+          </button>
           <button
             type="button"
             className="inline-flex h-7 w-7 shrink-0 items-center justify-center rounded-lg transition-colors"
@@ -341,6 +361,24 @@ export const SessionListPane = React.memo(function SessionListPane({
           groupedByStatusList
         )}
       </div>
+
+      {/* Add Lane button */}
+      <div className="shrink-0 px-2 pb-2 pt-1" style={{ borderTop: "1px solid var(--work-pane-border)" }}>
+        <button
+          type="button"
+          className="inline-flex w-full items-center justify-center gap-1.5 rounded-lg py-1.5 text-[11px] font-medium transition-colors hover:bg-white/[0.06]"
+          style={{
+            color: "var(--color-muted-fg)",
+            border: "1px solid rgba(255,255,255,0.06)",
+            background: "rgba(255,255,255,0.02)",
+            cursor: "pointer",
+          }}
+          onClick={() => navigate("/lanes?action=create")}
+        >
+          <Plus size={11} weight="bold" />
+          Add Lane
+        </button>
+      </div>
     </div>
   );
 });
diff --git a/apps/desktop/src/renderer/components/terminals/TerminalView.test.tsx b/apps/desktop/src/renderer/components/terminals/TerminalView.test.tsx
new file mode 100644
index 000000000..1cdbb32f0
--- /dev/null
+++ b/apps/desktop/src/renderer/components/terminals/TerminalView.test.tsx
@@ -0,0 +1,338 @@
+/* @vitest-environment jsdom */
+
+import React from "react";
+import { act, render, cleanup } from "@testing-library/react";
+import { afterEach, beforeAll, beforeEach, describe, expect, it, vi } from "vitest";
+
+const mockState = vi.hoisted(() => ({
+  terminalInstances: [] as Array<Record<string, unknown>>,
+  nextFitDims: { cols: 120, rows: 40 },
+  shouldThrowWebglAddon: false,
+  lastContextLossHandler: null as (() => void) | null,
+}));
+
+const resizeObservers: MockResizeObserver[] = [];
+
+class MockResizeObserver {
+  callback: ResizeObserverCallback;
+  observe = vi.fn();
+  disconnect = vi.fn();
+
+  constructor(callback: ResizeObserverCallback) {
+    this.callback = callback;
+    resizeObservers.push(this);
+  }
+}
+
+class MockIntersectionObserver {
+  observe = vi.fn();
+  disconnect = vi.fn();
+
+  constructor(_callback: IntersectionObserverCallback) {}
+}
+
+vi.mock("../../state/appStore", () => ({
+  useAppStore: vi.fn((selector: (state: { theme: "dark" }) => unknown) => selector({ theme: "dark" })),
+}));
+
+vi.mock("@xterm/xterm", () => ({
+  Terminal: class MockTerminal {
+    cols = 80;
+    rows = 24;
+    element: HTMLElement | null = null;
+    options: Record<string, unknown>;
+    focus = vi.fn();
+    blur = vi.fn();
+    write = vi.fn();
+    refresh = vi.fn();
+    resize = vi.fn((cols: number, rows: number) => {
+      this.cols = cols;
+      this.rows = rows;
+    });
+    scrollToBottom = vi.fn();
+    dispose = vi.fn();
+    clearTextureAtlas = vi.fn();
+    getSelection = vi.fn(() => "");
+    attachCustomKeyEventHandler = vi.fn();
+    onData = vi.fn(() => ({ dispose: vi.fn() }));
+    loadAddon = vi.fn((addon: { activate?: (term: unknown) => void }) => {
+      addon.activate?.(this);
+    });
+
+    constructor(options: Record<string, unknown>) {
+      this.options = { ...options };
+      mockState.terminalInstances.push(this as unknown as Record<string, unknown>);
+    }
+
+    open(host: HTMLElement) {
+      this.element = host;
+    }
+  },
+}));
+
+vi.mock("@xterm/addon-fit", () => ({
+  FitAddon: class MockFitAddon {
+    private terminal: { cols: number; rows: number } | null = null;
+
+    activate(term: { cols: number; rows: number }) {
+      this.terminal = term;
+    }
+
+    fit() {
+      if (!this.terminal) throw new Error("fit called before activate");
+      this.terminal.cols = mockState.nextFitDims.cols;
+      this.terminal.rows = mockState.nextFitDims.rows;
+    }
+  },
+}));
+
+vi.mock("@xterm/addon-webgl", () => ({
+  WebglAddon: class MockWebglAddon {
+    dispose = vi.fn();
+
+    constructor() {
+      if (mockState.shouldThrowWebglAddon) {
+        throw new Error("webgl unavailable");
+      }
+    }
+
+    onContextLoss(cb: () => void) {
+      mockState.lastContextLossHandler = cb;
+    }
+  },
+}));
+
+vi.mock("@xterm/xterm/css/xterm.css", () => ({}));
+
+import { TerminalView, getTerminalRuntimeSnapshot } from "./TerminalView";
+
+function installWindowAde() {
+  (window as any).ade = {
+    pty: {
+      resize: vi.fn().mockResolvedValue(undefined),
+      write: vi.fn().mockResolvedValue(undefined),
+      onData: vi.fn(() => () => {}),
+      onExit: vi.fn(() => () => {}),
+    },
+    sessions: {
+      readTranscriptTail: vi.fn().mockResolvedValue(""),
+    },
+  };
+}
+
+async function flushAllTimers() {
+  await act(async () => {
+    await vi.runAllTimersAsync();
+  });
+}
+
+async function flushAnimationFrame() {
+  await act(async () => {
+    await vi.advanceTimersByTimeAsync(0);
+  });
+}
+
+function triggerResizeObserver() {
+  const latest = resizeObservers.at(-1);
+  if (!latest) throw new Error("ResizeObserver not installed");
+  latest.callback([], latest as unknown as ResizeObserver);
+}
+
+function terminalWidthFor(element: HTMLElement): number {
+  if (element.getAttribute("data-ade-terminal-parking") === "true") return 0;
+  if (element.classList.contains("ade-terminal-host")) return 640;
+  if (element.parentElement?.classList.contains("ade-terminal-host")) return 640;
+  return 320;
+}
+
+function terminalHeightFor(element: HTMLElement): number {
+  if (element.getAttribute("data-ade-terminal-parking") === "true") return 0;
+  if (element.classList.contains("ade-terminal-host")) return 360;
+  if (element.parentElement?.classList.contains("ade-terminal-host")) return 360;
+  return 180;
+}
+
+beforeAll(() => {
+  vi.stubGlobal("ResizeObserver", MockResizeObserver);
+  vi.stubGlobal("IntersectionObserver", MockIntersectionObserver);
+  vi.stubGlobal("requestAnimationFrame", (callback: FrameRequestCallback) =>
+    window.setTimeout(() => callback(performance.now()), 0));
+  vi.stubGlobal("cancelAnimationFrame", (id: number) => window.clearTimeout(id));
+  vi.stubGlobal("matchMedia", vi.fn(() => ({
+    matches: false,
+    media: "",
+    onchange: null,
+    addEventListener: vi.fn(),
+    removeEventListener: vi.fn(),
+    addListener: vi.fn(),
+    removeListener: vi.fn(),
+    dispatchEvent: vi.fn(),
+  })));
+  vi.stubGlobal("visualViewport", {
+    addEventListener: vi.fn(),
+    removeEventListener: vi.fn(),
+  });
+
+  Object.defineProperty(HTMLElement.prototype, "clientWidth", {
+    configurable: true,
+    get() {
+      return terminalWidthFor(this);
+    },
+  });
+  Object.defineProperty(HTMLElement.prototype, "clientHeight", {
+    configurable: true,
+    get() {
+      return terminalHeightFor(this);
+    },
+  });
+  Object.defineProperty(HTMLElement.prototype, "offsetWidth", {
+    configurable: true,
+    get() {
+      return terminalWidthFor(this);
+    },
+  });
+  Object.defineProperty(HTMLElement.prototype, "offsetHeight", {
+    configurable: true,
+    get() {
+      return terminalHeightFor(this);
+    },
+  });
+  Object.defineProperty(HTMLElement.prototype, "getBoundingClientRect", {
+    configurable: true,
+    value() {
+      const width = terminalWidthFor(this as HTMLElement);
+      const height = terminalHeightFor(this as HTMLElement);
+      return {
+        width,
+        height,
+        top: 0,
+        left: 0,
+        right: width,
+        bottom: height,
+        x: 0,
+        y: 0,
+        toJSON() {
+          return {};
+        },
+      };
+    },
+  });
+});
+
+describe("TerminalView", () => {
+  beforeEach(() => {
+    vi.useFakeTimers();
+    vi.clearAllMocks();
+    cleanup();
+    installWindowAde();
+    resizeObservers.length = 0;
+    mockState.terminalInstances.length = 0;
+    mockState.nextFitDims = { cols: 120, rows: 40 };
+    mockState.shouldThrowWebglAddon = false;
+    mockState.lastContextLossHandler = null;
+  });
+
+  afterEach(() => {
+    cleanup();
+    delete (window as any).ade;
+    vi.useRealTimers();
+  });
+
+  it("fits to the container and resizes the PTY when the fit result is valid", async () => {
+    render(<TerminalView ptyId="pty-valid" sessionId="session-valid" isActive />);
+    await flushAllTimers();
+
+    const runtime = getTerminalRuntimeSnapshot("session-valid");
+    expect(runtime?.renderer).toBe("webgl");
+    expect(runtime?.health.fitRecoveries).toBe(0);
+    expect((window as any).ade.pty.resize).toHaveBeenCalledWith({
+      ptyId: "pty-valid",
+      cols: 120,
+      rows: 40,
+    });
+  });
+
+  it("rejects implausible fit results, restores the last good size, and skips PTY resize", async () => {
+    render(<TerminalView ptyId="pty-recover" sessionId="session-recover" isActive />);
+    await flushAllTimers();
+
+    const resizeSpy = (window as any).ade.pty.resize as { mock: { calls: unknown[][] } };
+    const resizeCallCount = resizeSpy.mock.calls.length;
+    expect(resizeCallCount).toBeGreaterThan(0);
+
+    mockState.nextFitDims = { cols: 1, rows: 1 };
+    triggerResizeObserver();
+    await flushAnimationFrame();
+
+    const terminal = mockState.terminalInstances.at(-1) as {
+      resize: ReturnType<typeof vi.fn>;
+      cols: number;
+      rows: number;
+    } | undefined;
+    const runtime = getTerminalRuntimeSnapshot("session-recover");
+    expect(terminal?.resize).toHaveBeenLastCalledWith(120, 40);
+    expect(terminal?.cols).toBe(120);
+    expect(terminal?.rows).toBe(40);
+    expect(resizeSpy.mock.calls).toHaveLength(resizeCallCount);
+    expect(runtime?.health.fitRecoveries).toBe(1);
+  });
+
+  it("stays unfocused while inactive and only focuses once the terminal becomes active", async () => {
+    const view = render(<TerminalView ptyId="pty-inactive" sessionId="session-inactive" isActive={false} />);
+    await flushAllTimers();
+
+    const terminal = mockState.terminalInstances.at(-1) as {
+      focus: ReturnType<typeof vi.fn>;
+    } | undefined;
+    expect(terminal?.focus).not.toHaveBeenCalled();
+
+    view.rerender(<TerminalView ptyId="pty-inactive" sessionId="session-inactive" isActive />);
+    await flushAllTimers();
+
+    expect(terminal?.focus).toHaveBeenCalled();
+  });
+
+  it("keeps fitting visible inactive terminals without focusing them", async () => {
+    render(<TerminalView ptyId="pty-visible" sessionId="session-visible" isActive={false} isVisible />);
+    await flushAllTimers();
+
+    const resizeSpy = (window as any).ade.pty.resize as ReturnType<typeof vi.fn>;
+    const terminal = mockState.terminalInstances.at(-1) as {
+      focus: ReturnType<typeof vi.fn>;
+    } | undefined;
+
+    expect(resizeSpy).toHaveBeenCalledWith({
+      ptyId: "pty-visible",
+      cols: 120,
+      rows: 40,
+    });
+    expect(terminal?.focus).not.toHaveBeenCalled();
+
+    mockState.nextFitDims = { cols: 140, rows: 44 };
+    triggerResizeObserver();
+    await flushAnimationFrame();
+
+    expect(resizeSpy).toHaveBeenLastCalledWith({
+      ptyId: "pty-visible",
+      cols: 140,
+      rows: 44,
+    });
+    expect(terminal?.focus).not.toHaveBeenCalled();
+  });
+
+  it("falls back to the DOM renderer when webgl initialization fails", async () => {
+    mockState.shouldThrowWebglAddon = true;
+    const previousFallbacks = getTerminalRuntimeSnapshot("session-dom")?.health.rendererFallbacks ?? 0;
+
+    render(<TerminalView ptyId="pty-dom" sessionId="session-dom" isActive />);
+    await flushAllTimers();
+    // Extra flush: initRendererChain is fire-and-forget and its dynamic import
+    // may not settle within a single timer flush cycle in CI environments.
+    await act(async () => {});
+    await flushAllTimers();
+
+    const runtime = getTerminalRuntimeSnapshot("session-dom");
+    expect(runtime?.renderer).toBe("dom");
+    expect(runtime?.health.rendererFallbacks).toBeGreaterThan(previousFallbacks);
+  });
+});
diff --git a/apps/desktop/src/renderer/components/terminals/TerminalView.tsx b/apps/desktop/src/renderer/components/terminals/TerminalView.tsx
index b1345c227..c239af680 100644
--- a/apps/desktop/src/renderer/components/terminals/TerminalView.tsx
+++ b/apps/desktop/src/renderer/components/terminals/TerminalView.tsx
@@ -7,13 +7,14 @@ import { MONO_FONT } from "../lanes/laneDesignTokens";
 import { useAppStore, type ThemeId } from "../../state/appStore";
 
 type XtermTheme = NonNullable<ConstructorParameters<typeof Terminal>[0]>["theme"];
-type TerminalRendererMode = "webgl" | "canvas" | "dom";
+type TerminalRendererMode = "webgl" | "dom";
 
 export type TerminalHealthCounters = {
   fitFailures: number;
   zeroDimFits: number;
   rendererFallbacks: number;
   droppedChunks: number;
+  fitRecoveries: number;
 };
 
 type RuntimeSnapshot = {
@@ -61,12 +62,21 @@ type CachedRuntime = {
   termDataSub: { dispose: () => void } | null;
   rendererInitStarted: boolean;
   inputEnabled: boolean;
+  active: boolean;
+  visible: boolean;
+  invalidFitRetryTimer: ReturnType<typeof setTimeout> | null;
+  fitWarningLogged: boolean;
 };
 
 const HYDRATE_TAIL_BYTES = 240_000;
 const MAX_PENDING_HYDRATION_BYTES = 400_000;
 const MAX_FRAME_WRITE_BYTES = 450_000;
 const EXITED_RUNTIME_KEEPALIVE_MS = 8_000;
+const MIN_VALID_COLS = 20;
+const MIN_VALID_ROWS = 6;
+const MIN_HOST_WIDTH_PX = 120;
+const MIN_HOST_HEIGHT_PX = 48;
+const INVALID_FIT_RETRY_MS = 90;
 
 const runtimeCache = new Map<string, CachedRuntime>();
 let parkedRoot: HTMLDivElement | null = null;
@@ -97,10 +107,22 @@ function cloneHealth(health: TerminalHealthCounters): TerminalHealthCounters {
     fitFailures: health.fitFailures,
     zeroDimFits: health.zeroDimFits,
     rendererFallbacks: health.rendererFallbacks,
-    droppedChunks: health.droppedChunks
+    droppedChunks: health.droppedChunks,
+    fitRecoveries: health.fitRecoveries
   };
 }
 
+type HostMeasurement = {
+  width: number;
+  height: number;
+  visible: boolean;
+};
+
+type TerminalDims = {
+  cols: number;
+  rows: number;
+};
+
 function computeSuffixPrefixOverlap(left: string, right: string, maxChars = 12_000): number {
   if (!left.length || !right.length) return 0;
   const cap = Math.min(maxChars, left.length, right.length);
@@ -142,6 +164,68 @@ function ensureParkedRoot(): HTMLDivElement {
   return next;
 }
 
+function measureHost(host: HTMLDivElement): HostMeasurement {
+  const rect = host.getBoundingClientRect();
+  const width = Math.max(rect.width, host.clientWidth, host.offsetWidth, 0);
+  const height = Math.max(rect.height, host.clientHeight, host.offsetHeight, 0);
+  return {
+    width,
+    height,
+    visible: host.isConnected && width >= MIN_HOST_WIDTH_PX && height >= MIN_HOST_HEIGHT_PX
+  };
+}
+
+function hasValidDims(dims: TerminalDims | null | undefined): dims is TerminalDims {
+  return Boolean(
+    dims
+    && Number.isFinite(dims.cols)
+    && Number.isFinite(dims.rows)
+    && dims.cols >= MIN_VALID_COLS
+    && dims.rows >= MIN_VALID_ROWS
+  );
+}
+
+function clearTextureAtlas(runtime: CachedRuntime) {
+  try {
+    runtime.term.clearTextureAtlas();
+  } catch {
+    // ignore when the active renderer doesn't support the texture atlas API
+  }
+}
+
+function restoreTerminalDims(runtime: CachedRuntime, dims: TerminalDims) {
+  try {
+    runtime.term.resize(dims.cols, dims.rows);
+  } catch {
+    // ignore restore failures after disposal
+  }
+}
+
+function scheduleInvalidFitRetry(runtime: CachedRuntime) {
+  if (runtime.disposed || runtime.invalidFitRetryTimer) return;
+  runtime.invalidFitRetryTimer = setTimeout(() => {
+    runtime.invalidFitRetryTimer = null;
+    if (runtime.disposed) return;
+    scheduleFit(runtime);
+  }, INVALID_FIT_RETRY_MS);
+}
+
+function warnInvalidFitOnce(runtime: CachedRuntime, args: {
+  measurement: HostMeasurement;
+  nextDims: TerminalDims;
+  previousDims: TerminalDims | null;
+}) {
+  if (runtime.fitWarningLogged) return;
+  runtime.fitWarningLogged = true;
+  console.warn("[TerminalView] rejected implausible fit result", {
+    sessionId: runtime.sessionId,
+    ptyId: runtime.ptyId,
+    measurement: args.measurement,
+    nextDims: args.nextDims,
+    previousDims: args.previousDims
+  });
+}
+
 function notifyRuntime(runtime: CachedRuntime) {
   const snapshot: RuntimeSnapshot = {
     exitCode: runtime.exitCode,
@@ -176,6 +260,7 @@ function parkRuntime(runtime: CachedRuntime) {
 }
 
 function setRuntimeInteractionState(runtime: CachedRuntime, active: boolean) {
+  runtime.active = active;
   runtime.inputEnabled = active;
   try {
     runtime.host.tabIndex = active ? 0 : -1;
@@ -194,6 +279,10 @@ function setRuntimeInteractionState(runtime: CachedRuntime, active: boolean) {
   }
 }
 
+function setRuntimeVisibilityState(runtime: CachedRuntime, visible: boolean) {
+  runtime.visible = visible;
+}
+
 function teardownRuntime(runtime: CachedRuntime) {
   runtime.disposed = true;
   clearDisposeTimer(runtime);
@@ -203,6 +292,7 @@ function teardownRuntime(runtime: CachedRuntime) {
   if (runtime.settleTimer2) clearTimeout(runtime.settleTimer2);
   if (runtime.hydrateTimer) clearTimeout(runtime.hydrateTimer);
   if (runtime.hydrateRetryTimer) clearTimeout(runtime.hydrateRetryTimer);
+  if (runtime.invalidFitRetryTimer) clearTimeout(runtime.invalidFitRetryTimer);
 
   try {
     runtime.ptyDataUnsub?.();
@@ -249,8 +339,8 @@ function scheduleRuntimeDispose(runtime: CachedRuntime, delayMs: number) {
 function ensureOpen(runtime: CachedRuntime): boolean {
   if (runtime.disposed) return false;
   if (runtime.term.element) return true;
-  if (!runtime.host.isConnected) return false;
-  if (runtime.host.clientWidth <= 0 || runtime.host.clientHeight <= 0) return false;
+  if (!runtime.visible) return false;
+  if (!measureHost(runtime.host).visible) return false;
   try {
     runtime.term.open(runtime.host);
     runtime.opened = true;
@@ -262,8 +352,15 @@ function ensureOpen(runtime: CachedRuntime): boolean {
 
 function doFit(runtime: CachedRuntime, forcePtyResize = false) {
   if (runtime.disposed) return;
+  if (!runtime.visible && runtime.hasFittedOnce) return;
   if (!ensureOpen(runtime)) return;
-  if (!runtime.host.isConnected || runtime.host.clientWidth <= 0 || runtime.host.clientHeight <= 0) return;
+  const measurement = measureHost(runtime.host);
+  if (!measurement.visible) return;
+  const previousDims = hasValidDims(runtime.lastDims)
+    ? runtime.lastDims
+    : hasValidDims({ cols: runtime.term.cols, rows: runtime.term.rows })
+      ? { cols: runtime.term.cols, rows: runtime.term.rows }
+      : null;
 
   // Hide cursor before fit to prevent ghost cursor artifact at stale position
   const cursorLayer = runtime.host.querySelector<HTMLElement>(".xterm-cursor-layer");
@@ -278,13 +375,30 @@ function doFit(runtime: CachedRuntime, forcePtyResize = false) {
   }
 
   const next = { cols: runtime.term.cols, rows: runtime.term.rows };
-  if (!Number.isFinite(next.cols) || !Number.isFinite(next.rows) || next.cols <= 0 || next.rows <= 0) {
-    incrementHealth(runtime, "zeroDimFits");
+  const zeroDimFit =
+    !Number.isFinite(next.cols) || !Number.isFinite(next.rows) || next.cols <= 0 || next.rows <= 0;
+  const implausibleFit = zeroDimFit || next.cols < MIN_VALID_COLS || next.rows < MIN_VALID_ROWS;
+  if (implausibleFit) {
+    if (zeroDimFit) incrementHealth(runtime, "zeroDimFits");
+    incrementHealth(runtime, "fitRecoveries");
+    if (previousDims) restoreTerminalDims(runtime, previousDims);
+    warnInvalidFitOnce(runtime, { measurement, nextDims: next, previousDims });
+    scheduleInvalidFitRetry(runtime);
+    try {
+      runtime.term.refresh(0, Math.max(0, runtime.term.rows - 1));
+    } catch {
+      // ignore refresh failures after dispose
+    }
+    if (cursorLayer) {
+      requestAnimationFrame(() => {
+        cursorLayer.style.visibility = "";
+      });
+    }
     return;
   }
 
   runtime.hasFittedOnce = true;
-  const prev = runtime.lastDims;
+  const prev = previousDims;
   if (!prev || prev.cols !== next.cols || prev.rows !== next.rows || forcePtyResize) {
     runtime.lastDims = next;
     window.ade.pty.resize({ ptyId: runtime.ptyId, cols: next.cols, rows: next.rows }).catch(() => {});
@@ -325,6 +439,8 @@ function doFit(runtime: CachedRuntime, forcePtyResize = false) {
 
 function scheduleFit(runtime: CachedRuntime, forcePtyResize = false) {
   if (runtime.disposed) return;
+  if (!runtime.visible && runtime.hasFittedOnce) return;
+  if (forcePtyResize && !runtime.visible) return;
   runtime.pendingForceResize = runtime.pendingForceResize || forcePtyResize;
   if (runtime.fitRafId != null) return;
   runtime.fitRafId = requestAnimationFrame(() => {
@@ -456,9 +572,7 @@ async function setRenderer(runtime: CachedRuntime, mode: TerminalRendererMode):
     return true;
   }
 
-  const moduleName = mode === "webgl" ? "@xterm/addon-webgl" : "@xterm/addon-canvas";
-  const exportName = mode === "webgl" ? "WebglAddon" : "CanvasAddon";
-  const Ctor = await loadAddonCtor(moduleName, exportName);
+  const Ctor = await loadAddonCtor("@xterm/addon-webgl", "WebglAddon");
   if (!Ctor) return false;
 
   try {
@@ -476,11 +590,10 @@ async function setRenderer(runtime: CachedRuntime, mode: TerminalRendererMode):
       const maybeOnContextLoss = (addon as { onContextLoss?: (cb: () => void) => void }).onContextLoss;
       if (typeof maybeOnContextLoss === "function") {
         maybeOnContextLoss(() => {
+          clearTextureAtlas(runtime);
           incrementHealth(runtime, "rendererFallbacks");
-          void setRenderer(runtime, "canvas").then((ok) => {
-            if (!ok) {
-              void setRenderer(runtime, "dom");
-            }
+          void setRenderer(runtime, "dom").finally(() => {
+            scheduleFit(runtime, runtime.active);
           });
         });
       }
@@ -499,11 +612,6 @@ async function initRendererChain(runtime: CachedRuntime) {
 
   const webgl = await setRenderer(runtime, "webgl");
   if (webgl) return;
-  const canvas = await setRenderer(runtime, "canvas");
-  if (canvas) {
-    incrementHealth(runtime, "rendererFallbacks");
-    return;
-  }
   incrementHealth(runtime, "rendererFallbacks");
   await setRenderer(runtime, "dom");
 }
@@ -517,6 +625,7 @@ function createRuntime(args: { ptyId: string; sessionId: string; theme: XtermThe
     convertEol: true,
     cursorBlink: true,
     cursorInactiveStyle: "none",
+    documentOverride: document,
     scrollback: 6000,
     fontFamily: MONO_FONT,
     fontSize: 13,
@@ -541,7 +650,7 @@ function createRuntime(args: { ptyId: string; sessionId: string; theme: XtermThe
     exitCode: null,
     renderer: "dom",
     rendererAddon: null,
-    health: { fitFailures: 0, zeroDimFits: 0, rendererFallbacks: 0, droppedChunks: 0 },
+    health: { fitFailures: 0, zeroDimFits: 0, rendererFallbacks: 0, droppedChunks: 0, fitRecoveries: 0 },
     lastDims: null,
     pendingForceResize: false,
     fitRafId: null,
@@ -563,7 +672,11 @@ function createRuntime(args: { ptyId: string; sessionId: string; theme: XtermThe
     ptyExitUnsub: null,
     termDataSub: null,
     rendererInitStarted: false,
-    inputEnabled: true
+    inputEnabled: true,
+    active: true,
+    visible: true,
+    invalidFitRetryTimer: null,
+    fitWarningLogged: false
   };
 
   // Capture-phase paste listener on host: intercepts ALL paste sources (Cmd+V,
@@ -713,13 +826,33 @@ function ensureRuntime(args: { ptyId: string; sessionId: string; theme: XtermThe
   return runtime;
 }
 
-export function getTerminalRuntimeHealth(sessionId: string): TerminalHealthCounters | null {
+export function getTerminalRuntimeSnapshot(sessionId: string): RuntimeSnapshot | null {
   const runtime = runtimeCache.get(sessionId);
   if (!runtime || runtime.disposed) return null;
-  return cloneHealth(runtime.health);
+  return {
+    exitCode: runtime.exitCode,
+    renderer: runtime.renderer,
+    health: cloneHealth(runtime.health)
+  };
 }
 
-export function TerminalView({ ptyId, sessionId, className, isActive }: { ptyId: string; sessionId: string; className?: string; isActive?: boolean }) {
+export function getTerminalRuntimeHealth(sessionId: string): TerminalHealthCounters | null {
+  return getTerminalRuntimeSnapshot(sessionId)?.health ?? null;
+}
+
+export function TerminalView({
+  ptyId,
+  sessionId,
+  className,
+  isActive,
+  isVisible = isActive,
+}: {
+  ptyId: string;
+  sessionId: string;
+  className?: string;
+  isActive: boolean;
+  isVisible?: boolean;
+}) {
   const appTheme = useAppStore((s) => s.theme);
   const wrapperRef = useRef<HTMLDivElement | null>(null);
   const containerRef = useRef<HTMLDivElement | null>(null);
@@ -727,15 +860,20 @@ export function TerminalView({ ptyId, sessionId, className, isActive }: { ptyId:
   const [exited, setExited] = useState<number | null>(null);
 
   const termTheme = useMemo(() => terminalThemes[isDarkTheme(appTheme) ? "dark" : "light"], [appTheme]);
+  const mountConfigRef = useRef({ isActive, isVisible, theme: termTheme });
+  mountConfigRef.current = { isActive, isVisible, theme: termTheme };
 
   useEffect(() => {
     const el = containerRef.current;
     if (!el) return;
 
-    const runtime = ensureRuntime({ ptyId, sessionId, theme: termTheme });
+    const mountConfig = mountConfigRef.current;
+    const runtime = ensureRuntime({ ptyId, sessionId, theme: mountConfig.theme });
     runtimeRef.current = runtime;
     runtime.refs += 1;
     clearDisposeTimer(runtime);
+    setRuntimeInteractionState(runtime, mountConfig.isActive);
+    setRuntimeVisibilityState(runtime, mountConfig.isVisible);
 
     const onRuntimeSnapshot: RuntimeListener = (snapshot) => {
       setExited(snapshot.exitCode);
@@ -749,14 +887,14 @@ export function TerminalView({ ptyId, sessionId, className, isActive }: { ptyId:
 
     const schedule = (forceResize = false) => scheduleFit(runtime, forceResize);
 
-    schedule(true);
+    schedule(mountConfig.isVisible);
     runtime.settleTimer1 = setTimeout(() => {
       runtime.settleTimer1 = null;
-      schedule(true);
+      schedule(mountConfig.isVisible);
     }, 120);
     runtime.settleTimer2 = setTimeout(() => {
       runtime.settleTimer2 = null;
-      schedule(true);
+      schedule(mountConfig.isVisible);
     }, 320);
 
     startHydration(runtime);
@@ -797,6 +935,7 @@ export function TerminalView({ ptyId, sessionId, className, isActive }: { ptyId:
 
     const onVisibilityChange = () => {
       if (document.hidden) return;
+      clearTextureAtlas(runtime);
       requestAnimationFrame(() => schedule(true));
     };
     const onWindowFocus = () => {
@@ -810,22 +949,13 @@ export function TerminalView({ ptyId, sessionId, className, isActive }: { ptyId:
     window.addEventListener("resize", onWindowResize);
     window.visualViewport?.addEventListener("resize", onWindowResize);
 
-    const mutObs = new MutationObserver(() => {
-      requestAnimationFrame(() => schedule(true));
-    });
-
-    let ancestor: HTMLElement | null = el.parentElement;
-    for (let depth = 0; depth < 4 && ancestor; depth++) {
-      mutObs.observe(ancestor, { attributes: true, attributeFilter: ["class", "style"] });
-      ancestor = ancestor.parentElement;
-    }
-
     const setupDprListener = () => {
       let cleanup: (() => void) | null = null;
       const query = `(resolution: ${window.devicePixelRatio}dppx)`;
       const media = window.matchMedia(query);
       const onDprChange = () => {
         if (cleanup) cleanup();
+        clearTextureAtlas(runtime);
         requestAnimationFrame(() => schedule(true));
       };
 
@@ -866,11 +996,6 @@ export function TerminalView({ ptyId, sessionId, className, isActive }: { ptyId:
       } catch {
         // ignore
       }
-      try {
-        mutObs.disconnect();
-      } catch {
-        // ignore
-      }
       try {
         teardownDpr?.();
       } catch {
@@ -910,13 +1035,13 @@ export function TerminalView({ ptyId, sessionId, className, isActive }: { ptyId:
     const runtime = runtimeRef.current ?? runtimeCache.get(sessionId);
     if (!runtime || runtime.disposed) return;
 
-    const active = isActive !== false;
     const wrapper = wrapperRef.current;
-    setRuntimeInteractionState(runtime, active);
+    setRuntimeInteractionState(runtime, isActive);
+    setRuntimeVisibilityState(runtime, isVisible);
 
     if (wrapper) {
       wrapper.tabIndex = -1;
-      if (active) {
+      if (isVisible) {
         wrapper.removeAttribute("aria-hidden");
         wrapper.removeAttribute("inert");
       } else {
@@ -925,7 +1050,13 @@ export function TerminalView({ ptyId, sessionId, className, isActive }: { ptyId:
       }
     }
 
-    if (!active) {
+    if (isVisible) {
+      requestAnimationFrame(() => {
+        scheduleFit(runtime, false);
+      });
+    }
+
+    if (!isActive) {
       try {
         runtime.term.blur();
       } catch {
@@ -937,7 +1068,7 @@ export function TerminalView({ ptyId, sessionId, className, isActive }: { ptyId:
         // ignore
       }
     }
-  }, [isActive, sessionId]);
+  }, [isActive, isVisible, sessionId]);
 
   useEffect(() => {
     const runtime = runtimeRef.current ?? runtimeCache.get(sessionId);
@@ -959,23 +1090,29 @@ export function TerminalView({ ptyId, sessionId, className, isActive }: { ptyId:
     if (!runtime || runtime.disposed) return;
 
     const raf = requestAnimationFrame(() => {
+      clearTextureAtlas(runtime);
       doFit(runtime, true);
-      try {
-        runtime.term.focus();
-        runtime.term.scrollToBottom();
-      } catch {
-        // ignore
+      if (isVisible) {
+        try {
+          runtime.term.focus();
+          runtime.term.scrollToBottom();
+        } catch {
+          // ignore
+        }
       }
     });
 
     // Second settle pass after CSS transitions complete
     const timer = setTimeout(() => {
       if (runtime.disposed) return;
+      clearTextureAtlas(runtime);
       doFit(runtime, true);
-      try {
-        runtime.term.focus();
-      } catch {
-        // ignore
+      if (isVisible) {
+        try {
+          runtime.term.focus();
+        } catch {
+          // ignore
+        }
       }
     }, 100);
 
@@ -983,7 +1120,7 @@ export function TerminalView({ ptyId, sessionId, className, isActive }: { ptyId:
       cancelAnimationFrame(raf);
       clearTimeout(timer);
     };
-  }, [isActive, sessionId]);
+  }, [isActive, isVisible, sessionId]);
 
   return (
     <div
diff --git a/apps/desktop/src/renderer/components/terminals/TerminalsPage.tsx b/apps/desktop/src/renderer/components/terminals/TerminalsPage.tsx
index e86eab097..216dd9c9e 100644
--- a/apps/desktop/src/renderer/components/terminals/TerminalsPage.tsx
+++ b/apps/desktop/src/renderer/components/terminals/TerminalsPage.tsx
@@ -1,12 +1,12 @@
 import React, { useCallback, useMemo, useState } from "react";
-import { SidebarSimple, Terminal } from "@phosphor-icons/react";
+import { SidebarSimple } from "@phosphor-icons/react";
 import { PaneTilingLayout, type PaneConfig, type PaneSplit } from "../ui/PaneTilingLayout";
 import { useWorkSessions } from "./useWorkSessions";
 import { SessionListPane } from "./SessionListPane";
 import { WorkViewArea } from "./WorkViewArea";
 import { SessionContextMenu, type SessionContextMenuState } from "./SessionContextMenu";
 import { SessionInfoPopover, type InfoPopoverState } from "./SessionInfoPopover";
-import type { TerminalSessionSummary } from "../../../shared/types";
+import type { AgentChatSession, TerminalSessionSummary } from "../../../shared/types";
 import { sortLanesForTabs } from "../lanes/laneUtils";
 
 const TERMINALS_TILING_TREE: PaneSplit = {
@@ -49,14 +49,18 @@ export function TerminalsPage() {
   );
 
   const handleOpenChatSession = useCallback(
-    async (sessionId: string) => {
-      // Refresh first so the session is in the list before activating the tab.
-      try {
-        await work.refresh({ showLoading: false });
-      } catch {
-        // Best-effort: proceed to open the tab even if refresh fails
-      }
-      work.openSessionTab(sessionId);
+    (session: AgentChatSession) => {
+      work.selectLane(session.laneId);
+      work.upsertOptimisticChatSession(session);
+      work.focusSession(session.id);
+      work.openSessionTab(session.id);
+      void work.refresh({ showLoading: false, force: true }).catch((err: unknown) => {
+        console.error("[TerminalsPage] refresh after opening chat session failed", {
+          sessionId: session.id,
+          laneId: session.laneId,
+          err,
+        });
+      });
     },
     [work],
   );
@@ -73,13 +77,13 @@ export function TerminalsPage() {
   const workViewArea = useMemo(
     () => (
       <WorkViewArea
+        gridLayoutId={work.gridLayoutId}
         lanes={sortedLanes}
         sessions={work.sessions}
         visibleSessions={work.visibleSessions}
         activeItemId={work.activeItemId}
         viewMode={work.viewMode}
         draftKind={work.draftKind}
-        showingDraft={work.activeItemId == null}
         setViewMode={work.setViewMode}
         onSelectItem={work.setActiveItemId}
         onCloseItem={work.closeTab}
@@ -92,6 +96,7 @@ export function TerminalsPage() {
     ),
     [
       sortedLanes,
+      work.gridLayoutId,
       work.sessions,
       work.visibleSessions,
       work.activeItemId,
diff --git a/apps/desktop/src/renderer/components/terminals/WorkStartSurface.tsx b/apps/desktop/src/renderer/components/terminals/WorkStartSurface.tsx
index 53a6ff327..a57548c42 100644
--- a/apps/desktop/src/renderer/components/terminals/WorkStartSurface.tsx
+++ b/apps/desktop/src/renderer/components/terminals/WorkStartSurface.tsx
@@ -3,7 +3,7 @@ import {
   Terminal,
   ArrowRight,
 } from "@phosphor-icons/react";
-import type { LaneSummary, AgentChatPermissionMode } from "../../../shared/types";
+import type { AgentChatPermissionMode, AgentChatSession, LaneSummary } from "../../../shared/types";
 import type { WorkDraftKind } from "../../state/appStore";
 import { useAppStore } from "../../state/appStore";
 import { AgentChatPane } from "../chat/AgentChatPane";
@@ -16,7 +16,7 @@ import { ClaudeLogo, CodexLogo } from "./ToolLogos";
 type WorkStartSurfaceProps = {
   draftKind: WorkDraftKind;
   lanes: LaneSummary[];
-  onOpenChatSession: (sessionId: string) => void | Promise<void>;
+  onOpenChatSession: (session: AgentChatSession) => void | Promise<void>;
   onLaunchPtySession: (args: {
     laneId: string;
     profile: "claude" | "codex" | "shell";
@@ -141,6 +141,8 @@ export function WorkStartSurface({
             forceDraftMode
             embeddedWorkLayout
             onSessionCreated={onOpenChatSession}
+            availableLanes={lanes}
+            onLaneChange={setLaneAndSync}
           />
         </div>
       </div>
@@ -151,13 +153,8 @@ export function WorkStartSurface({
   if (draftKind === "cli") {
     return (
       <div className="flex h-full min-h-0 flex-col items-center justify-center" style={{ background: "var(--color-bg)" }}>
-        <div
-          className="flex w-full max-w-sm flex-col gap-4 rounded-lg p-5"
-          style={{
-            background: "var(--color-surface)",
-            border: "1px solid var(--work-pane-border)",
-          }}
-        >
+        <LogoGlow size="lg" />
+        <GlassCard>
           {/* Lane */}
           <div className="flex items-center gap-2">
             <span className="text-[10px] text-muted-fg/60 shrink-0">Lane</span>
@@ -229,7 +226,7 @@ export function WorkStartSurface({
             Open {cliProvider === "claude" ? "Claude Code" : "Codex CLI"}
             <ArrowRight size={12} weight="regular" />
           </button>
-        </div>
+        </GlassCard>
       </div>
     );
   }
@@ -237,13 +234,8 @@ export function WorkStartSurface({
   /* ---- Shell draft ---- */
   return (
     <div className="flex h-full min-h-0 flex-col items-center justify-center" style={{ background: "var(--color-bg)" }}>
-      <div
-        className="flex w-full max-w-sm flex-col gap-4 rounded-lg p-5"
-        style={{
-          background: "var(--color-surface)",
-          border: "1px solid var(--work-pane-border)",
-        }}
-      >
+      <LogoGlow size="sm" />
+      <GlassCard>
         {/* Lane */}
         <div className="flex items-center gap-2">
           <span className="text-[10px] text-muted-fg/60 shrink-0">Lane</span>
@@ -279,7 +271,47 @@ export function WorkStartSurface({
           Open Shell
           <ArrowRight size={12} weight="regular" />
         </button>
-      </div>
+      </GlassCard>
+    </div>
+  );
+}
+
+const LOGO_SIZES = {
+  lg: { glow: "h-[400px] w-[400px]", blur: "blur(100px)", img: "w-64 h-64" },
+  sm: { glow: "h-[200px] w-[200px]", blur: "blur(80px)", img: "h-[140px] w-[140px]" },
+} as const;
+
+function LogoGlow({ size }: { size: "lg" | "sm" }) {
+  const s = LOGO_SIZES[size];
+  return (
+    <div className="relative mb-6">
+      <div
+        className={`absolute top-1/2 left-1/2 -translate-x-1/2 -translate-y-1/2 ${s.glow} rounded-full pointer-events-none`}
+        style={{ background: "var(--color-accent)", opacity: 0.08, filter: s.blur }}
+      />
+      <img
+        src="./logo.png"
+        alt="ADE"
+        className={`relative z-10 ${s.img} object-contain`}
+        style={{ filter: "drop-shadow(0 0 40px rgba(168,130,255,0.15))" }}
+      />
+    </div>
+  );
+}
+
+function GlassCard({ children }: { children: React.ReactNode }) {
+  return (
+    <div
+      className="flex w-full max-w-sm flex-col gap-4 rounded-lg p-5"
+      style={{
+        backdropFilter: "blur(20px)",
+        WebkitBackdropFilter: "blur(20px)",
+        background: "rgba(30, 30, 40, 0.7)",
+        border: "1px solid rgba(255, 255, 255, 0.08)",
+        boxShadow: "0 8px 32px rgba(0, 0, 0, 0.4), inset 0 1px 0 rgba(255, 255, 255, 0.05)",
+      }}
+    >
+      {children}
     </div>
   );
 }
diff --git a/apps/desktop/src/renderer/components/terminals/WorkViewArea.tsx b/apps/desktop/src/renderer/components/terminals/WorkViewArea.tsx
index b216ed71e..009b7bcab 100644
--- a/apps/desktop/src/renderer/components/terminals/WorkViewArea.tsx
+++ b/apps/desktop/src/renderer/components/terminals/WorkViewArea.tsx
@@ -1,6 +1,6 @@
 import { useMemo } from "react";
-import { GridFour, List, X } from "@phosphor-icons/react";
-import type { LaneSummary, TerminalSessionSummary } from "../../../shared/types";
+import { GridFour, List, Plus, X } from "@phosphor-icons/react";
+import type { AgentChatSession, LaneSummary, TerminalSessionSummary } from "../../../shared/types";
 import type { WorkDraftKind, WorkViewMode } from "../../state/appStore";
 import { TerminalView } from "./TerminalView";
 import { ToolLogo } from "./ToolLogos";
@@ -8,6 +8,12 @@ import { AgentChatPane } from "../chat/AgentChatPane";
 import { WorkStartSurface } from "./WorkStartSurface";
 import { isChatToolType, primarySessionLabel, secondarySessionLabel, truncateSessionLabel } from "../../lib/sessions";
 import { sessionStatusDot } from "../../lib/terminalAttention";
+import { PackedSessionGrid } from "./PackedSessionGrid";
+
+const CHAT_TILE_MIN_WIDTH = 440;
+const CHAT_TILE_MIN_HEIGHT = 340;
+const TERMINAL_TILE_MIN_WIDTH = 320;
+const TERMINAL_TILE_MIN_HEIGHT = 220;
 
 function isRunningPtySession(
   session: TerminalSessionSummary | null | undefined,
@@ -23,15 +29,27 @@ function isRunningPtySession(
 function SessionSurface({
   session,
   isActive,
+  layoutVariant = "standard",
+  terminalVisible = isActive,
   onOpenChatSession,
 }: {
   session: TerminalSessionSummary;
   isActive: boolean;
-  onOpenChatSession: (sessionId: string) => void | Promise<void>;
+  layoutVariant?: "standard" | "grid-tile";
+  terminalVisible?: boolean;
+  onOpenChatSession: (session: AgentChatSession) => void | Promise<void>;
 }) {
   const isChat = isChatToolType(session.toolType);
   if (isChat) {
-    return <AgentChatPane laneId={session.laneId} laneLabel={session.laneName} lockSessionId={session.id} onSessionCreated={onOpenChatSession} />;
+    return (
+      <AgentChatPane
+        laneId={session.laneId}
+        laneLabel={session.laneName}
+        lockSessionId={session.id}
+        onSessionCreated={onOpenChatSession}
+        layoutVariant={layoutVariant}
+      />
+    );
   }
   if (isRunningPtySession(session)) {
     return (
@@ -39,6 +57,8 @@ function SessionSurface({
         key={session.id}
         ptyId={session.ptyId}
         sessionId={session.id}
+        isActive={isActive}
+        isVisible={terminalVisible}
         className="h-full w-full"
       />
     );
@@ -92,13 +112,13 @@ function ModeSwitcherPills({
 }
 
 export function WorkViewArea({
+  gridLayoutId,
   lanes,
   sessions,
   visibleSessions,
   activeItemId,
   viewMode,
   draftKind,
-  showingDraft,
   setViewMode,
   onSelectItem,
   onCloseItem,
@@ -108,17 +128,17 @@ export function WorkViewArea({
   closingPtyIds,
   onContextMenu,
 }: {
+  gridLayoutId: string;
   lanes: LaneSummary[];
   sessions: TerminalSessionSummary[];
   visibleSessions: TerminalSessionSummary[];
   activeItemId: string | null;
   viewMode: WorkViewMode;
   draftKind: WorkDraftKind;
-  showingDraft: boolean;
   setViewMode: (mode: WorkViewMode) => void;
   onSelectItem: (sessionId: string) => void;
   onCloseItem: (sessionId: string) => void;
-  onOpenChatSession: (sessionId: string) => void | Promise<void>;
+  onOpenChatSession: (session: AgentChatSession) => void | Promise<void>;
   onLaunchPtySession: (args: {
     laneId: string;
     profile: "claude" | "codex" | "shell";
@@ -136,9 +156,8 @@ export function WorkViewArea({
     return map;
   }, [sessions]);
 
-  const displaySessions = visibleSessions;
   const activeSession = activeItemId
-    ? sessionsById.get(activeItemId) ?? displaySessions[0] ?? null
+    ? sessionsById.get(activeItemId) ?? visibleSessions[0] ?? null
     : null;
   const activeRunningTerminalSession = isRunningPtySession(activeSession) ? activeSession : null;
 
@@ -159,11 +178,11 @@ export function WorkViewArea({
           <ViewModeToggle viewMode={viewMode} setViewMode={setViewMode} />
           <span className="text-[11px] font-medium text-muted-fg">Grid</span>
           <span className="inline-flex items-center px-1.5 text-[10px] text-muted-fg/60 rounded" style={{ background: "rgba(255,255,255,0.04)" }}>
-            {displaySessions.length}
+            {visibleSessions.length}
           </span>
         </div>
 
-        {displaySessions.length === 0 ? (
+        {visibleSessions.length === 0 ? (
           <div className="flex h-full flex-col">
             <div className="flex shrink-0 items-center justify-center py-2">
               <ModeSwitcherPills draftKind={draftKind} onShowDraftKind={onShowDraftKind} />
@@ -178,86 +197,90 @@ export function WorkViewArea({
             </div>
           </div>
         ) : (
-          <div className="min-h-0 flex-1 overflow-auto p-2">
-            <div className="grid gap-2" style={{
-              gridTemplateColumns: "repeat(auto-fill, minmax(min(100%, 360px), 1fr))",
-              gridAutoRows: "minmax(240px, 33vh)",
-            }}>
-              {displaySessions.map((session) => {
-                const isActive = activeSession?.id === session.id;
-                const dot = sessionStatusDot(session);
-                const isBusy = session.ptyId ? closingPtyIds.has(session.ptyId) : false;
-                const primary = primarySessionLabel(session);
-                const secondary = secondarySessionLabel(session);
-                return (
+          <PackedSessionGrid
+            layoutId={gridLayoutId}
+            tiles={visibleSessions.map((session) => {
+              const isActive = activeSession?.id === session.id;
+              const dot = sessionStatusDot(session);
+              const isBusy = session.ptyId ? closingPtyIds.has(session.ptyId) : false;
+              const primary = primarySessionLabel(session);
+              const secondary = secondarySessionLabel(session);
+              const isChat = isChatToolType(session.toolType);
+              return {
+                id: session.id,
+                minWidth: isChat ? CHAT_TILE_MIN_WIDTH : TERMINAL_TILE_MIN_WIDTH,
+                minHeight: isChat ? CHAT_TILE_MIN_HEIGHT : TERMINAL_TILE_MIN_HEIGHT,
+                selected: isActive,
+                onSelect: () => onSelectItem(session.id),
+                className: isActive
+                  ? "border border-white/[0.08] bg-white/[0.02]"
+                  : "border border-white/[0.04] bg-transparent",
+                header: (
                   <div
-                    key={session.id}
-                    className="flex min-h-0 flex-col overflow-hidden rounded-md"
+                    className="flex items-center gap-2 px-2 py-1.5"
                     onContextMenu={(e) => handleContextMenu(session, e)}
                     style={{
-                      border: isActive
-                        ? "1px solid rgba(255,255,255,0.08)"
-                        : "1px solid rgba(255,255,255,0.04)",
-                      background: "transparent",
+                      borderBottom: "1px solid rgba(255,255,255,0.04)",
+                      background: isActive ? "rgba(255,255,255,0.02)" : "transparent",
                     }}
                   >
-                    <div
-                      className="flex items-center gap-2 px-2 py-1.5"
-                      style={{
-                        borderBottom: "1px solid rgba(255,255,255,0.04)",
-                        background: isActive ? "rgba(255,255,255,0.02)" : "transparent",
-                      }}
+                    <button
+                      type="button"
+                      className="min-w-0 flex-1 text-left"
+                      onClick={() => onSelectItem(session.id)}
                     >
-                      <button
-                        type="button"
-                        className="min-w-0 flex-1 text-left"
-                        onClick={() => onSelectItem(session.id)}
-                      >
-                        <span className="flex items-center gap-2 text-[11px]">
-                          <span
-                            title={dot.label}
-                            className={`${dot.cls} h-2 w-2 shrink-0${dot.spinning ? " animate-spin" : ""}`}
-                          />
-                          <ToolLogo toolType={session.toolType} size={11} />
-                          <span className="truncate text-fg">
-                            {truncateSessionLabel(primary)}
-                          </span>
+                      <span className="flex items-center gap-2 text-[11px]">
+                        <span
+                          title={dot.label}
+                          className={`${dot.cls} h-2 w-2 shrink-0${dot.spinning ? " animate-spin" : ""}`}
+                        />
+                        <ToolLogo toolType={session.toolType} size={11} />
+                        <span className="truncate text-fg">
+                          {truncateSessionLabel(primary)}
                         </span>
-                        <span className="mt-0.5 flex items-center gap-2 pl-[18px]">
-                          <span className="text-[10px] text-muted-fg/50">
-                            {session.laneName}
-                          </span>
-                          {secondary ? (
-                            <span className="truncate text-[10px] text-muted-fg/60">
-                              {truncateSessionLabel(secondary, 36)}
-                            </span>
-                          ) : null}
+                      </span>
+                      <span className="mt-0.5 flex items-center gap-2 pl-[18px]">
+                        <span className="text-[10px] text-muted-fg/50">
+                          {session.laneName}
                         </span>
-                      </button>
-                      <button
-                        type="button"
-                        onClick={() => onCloseItem(session.id)}
-                        title={isBusy ? "Closing..." : "Close"}
-                        disabled={isBusy}
-                        className="inline-flex items-center justify-center w-5 h-5 text-muted-fg/50 hover:text-fg transition-colors"
-                        style={{
-                          border: "none",
-                          background: "transparent",
-                          cursor: isBusy ? "default" : "pointer",
-                          opacity: isBusy ? 0.4 : 1,
-                        }}
-                      >
-                        <X size={10} />
-                      </button>
-                    </div>
-                    <div className="min-h-0 flex-1 overflow-auto">
-                      <SessionSurface session={session} isActive={isActive} onOpenChatSession={onOpenChatSession} />
-                    </div>
+                        {secondary ? (
+                          <span className="truncate text-[10px] text-muted-fg/60">
+                            {truncateSessionLabel(secondary, 36)}
+                          </span>
+                        ) : null}
+                      </span>
+                    </button>
+                    <button
+                      type="button"
+                      onClick={() => onCloseItem(session.id)}
+                      title={isBusy ? "Closing..." : "Close"}
+                      disabled={isBusy}
+                      className="inline-flex h-5 w-5 items-center justify-center text-muted-fg/50 transition-colors hover:text-fg"
+                      style={{
+                        border: "none",
+                        background: "transparent",
+                        cursor: isBusy ? "default" : "pointer",
+                        opacity: isBusy ? 0.4 : 1,
+                      }}
+                    >
+                      <X size={10} />
+                    </button>
                   </div>
-                );
-              })}
-            </div>
-          </div>
+                ),
+                children: (
+                  <div className="min-h-0 h-full flex-1 overflow-hidden" onContextMenu={(e) => handleContextMenu(session, e)}>
+                    <SessionSurface
+                      session={session}
+                      isActive={isActive}
+                      terminalVisible
+                      layoutVariant="grid-tile"
+                      onOpenChatSession={onOpenChatSession}
+                    />
+                  </div>
+                ),
+              };
+            })}
+          />
         )}
       </div>
     );
@@ -279,7 +302,7 @@ export function WorkViewArea({
         <ViewModeToggle viewMode={viewMode} setViewMode={setViewMode} />
         <div className="mx-1" style={{ width: 1, height: 14, background: "var(--work-pane-border)" }} />
         <div className="flex-1 flex items-center gap-0 overflow-x-auto scrollbar-none min-w-0">
-          {displaySessions.map((session) => {
+          {visibleSessions.map((session) => {
             const isActive = activeSession?.id === session.id;
             const dot = sessionStatusDot(session);
             const isBusy = session.ptyId ? closingPtyIds.has(session.ptyId) : false;
@@ -342,16 +365,36 @@ export function WorkViewArea({
               </button>
             );
           })}
+          <button
+            type="button"
+            className="inline-flex shrink-0 items-center justify-center transition-colors hover:opacity-80"
+            style={{
+              width: 22,
+              height: 22,
+              marginLeft: 4,
+              borderRadius: "50%",
+              border: "1px solid rgba(168,130,255,0.35)",
+              background: "rgba(168,130,255,0.08)",
+              color: "rgba(168,130,255,0.9)",
+              cursor: "pointer",
+            }}
+            onClick={() => onShowDraftKind("chat")}
+            title="New Chat"
+            aria-label="Start a new chat"
+          >
+            <Plus size={11} weight="bold" />
+          </button>
         </div>
       </div>
 
-      <div className="relative min-h-0 flex-1" style={{ background: "var(--color-card)" }}>
+      <div className="relative min-h-0 flex-1" style={{ background: "var(--color-bg)" }}>
         {activeRunningTerminalSession ? (
           <TerminalView
             key={activeRunningTerminalSession.id}
             ptyId={activeRunningTerminalSession.ptyId}
             sessionId={activeRunningTerminalSession.id}
             isActive
+            isVisible
             className="absolute inset-0 h-full w-full"
           />
         ) : null}
@@ -359,7 +402,7 @@ export function WorkViewArea({
         {activeSession ? (
           activeRunningTerminalSession ? null : (
             <div className="absolute inset-0">
-              <SessionSurface session={activeSession} isActive onOpenChatSession={onOpenChatSession} />
+              <SessionSurface session={activeSession} isActive terminalVisible onOpenChatSession={onOpenChatSession} />
             </div>
           )
         ) : (
diff --git a/apps/desktop/src/renderer/components/terminals/packedSessionGridMath.test.ts b/apps/desktop/src/renderer/components/terminals/packedSessionGridMath.test.ts
new file mode 100644
index 000000000..02a879ea5
--- /dev/null
+++ b/apps/desktop/src/renderer/components/terminals/packedSessionGridMath.test.ts
@@ -0,0 +1,86 @@
+import { describe, expect, it } from "vitest";
+import {
+  computeDefaultRowSpan,
+  computeGridColumnCount,
+  computeMinimumRowSpan,
+  packGridItems,
+  reconcilePackedGridLayout,
+} from "./packedSessionGridMath";
+
+describe("packedSessionGridMath", () => {
+  it("chooses evenly distributed columns when the container is wide enough", () => {
+    expect(
+      computeGridColumnCount({
+        containerWidth: 1500,
+        tileCount: 3,
+        minTileWidth: 440,
+      }),
+    ).toBe(3);
+  });
+
+  it("prefers a balanced 3x2 layout over a sparse 4x2 layout for six wide chat tiles", () => {
+    expect(
+      computeGridColumnCount({
+        containerWidth: 2200,
+        tileCount: 6,
+        minTileWidth: 440,
+      }),
+    ).toBe(3);
+  });
+
+  it("uses three columns for five wide chat tiles when that minimizes rows and empty space", () => {
+    expect(
+      computeGridColumnCount({
+        containerWidth: 2200,
+        tileCount: 5,
+        minTileWidth: 440,
+      }),
+    ).toBe(3);
+  });
+
+  it("packs three equal tiles across the first row on a wide surface", () => {
+    const defaultRowSpan = computeDefaultRowSpan([
+      computeMinimumRowSpan(220),
+      computeMinimumRowSpan(220),
+      computeMinimumRowSpan(220),
+    ]);
+
+    const packed = packGridItems([
+      { id: "a", minRowSpan: 2, span: { colSpan: 1, rowSpan: defaultRowSpan } },
+      { id: "b", minRowSpan: 2, span: { colSpan: 1, rowSpan: defaultRowSpan } },
+      { id: "c", minRowSpan: 2, span: { colSpan: 1, rowSpan: defaultRowSpan } },
+    ], 3);
+
+    expect(packed.placements).toEqual([
+      { id: "a", column: 1, row: 1, colSpan: 1, rowSpan: 2 },
+      { id: "b", column: 2, row: 1, colSpan: 1, rowSpan: 2 },
+      { id: "c", column: 3, row: 1, colSpan: 1, rowSpan: 2 },
+    ]);
+    expect(packed.totalRows).toBe(2);
+  });
+
+  it("preserves absent-tile layout entries and seeds missing tiles with defaults", () => {
+    const reconciled = reconcilePackedGridLayout({
+      layout: {
+        "keep:col": 2,
+        "keep:row": 3,
+        "absent:col": 4,
+        "absent:row": 4,
+      },
+      tileIds: ["keep", "new"],
+      defaultSpansById: {
+        keep: { colSpan: 1, rowSpan: 2 },
+        new: { colSpan: 1, rowSpan: 3 },
+      },
+    });
+
+    expect(reconciled).toEqual({
+      "absent:col": 4,
+      "absent:row": 4,
+      "keep:col": 2,
+      "keep:row": 3,
+      "new:col": 1,
+      "new:row": 3,
+    });
+  });
+});
diff --git a/apps/desktop/src/renderer/components/terminals/packedSessionGridMath.ts b/apps/desktop/src/renderer/components/terminals/packedSessionGridMath.ts
new file mode 100644
index 000000000..3cba614d3
--- /dev/null
+++ b/apps/desktop/src/renderer/components/terminals/packedSessionGridMath.ts
@@ -0,0 +1,238 @@
+import type { DockLayout } from "../../../shared/types";
+
+export const GRID_GAP_PX = 8;
+export const GRID_BASE_ROW_PX = 120;
+export const GRID_MAX_ROW_SPAN = 8;
+export const GRID_COLUMN_SUBDIVISIONS = 12;
+
+export type PackedGridSpan = {
+  colSpan: number;
+  rowSpan: number;
+};
+
+export type PackedGridPlacement = PackedGridSpan & {
+  id: string;
+  column: number;
+  row: number;
+};
+
+export type PackedGridItem = {
+  id: string;
+  minRowSpan: number;
+  span: PackedGridSpan;
+};
+
+function spanKey(id: string, axis: "col" | "row"): string {
+  return `${id}:${axis}`;
+}
+
+export function computeMinimumRowSpan(
+  minHeightPx: number,
+  rowPx = GRID_BASE_ROW_PX,
+  gapPx = GRID_GAP_PX,
+): number {
+  if (!Number.isFinite(minHeightPx) || minHeightPx <= 0) return 1;
+  const numerator = minHeightPx + gapPx;
+  const denominator = rowPx + gapPx;
+  if (!Number.isFinite(denominator) || denominator <= 0) return 1;
+  return Math.max(1, Math.ceil(numerator / denominator));
+}
+
+export function computeDefaultRowSpan(minRowSpans: number[]): number {
+  if (minRowSpans.length === 0) return 1;
+  return Math.max(1, ...minRowSpans);
+}
+
+export function computeMinimumColSpan(args: {
+  minWidthPx: number;
+  trackWidthPx: number;
+  gapPx?: number;
+}): number {
+  const { minWidthPx, trackWidthPx, gapPx = GRID_GAP_PX } = args;
+  if (!Number.isFinite(minWidthPx) || minWidthPx <= 0) return 1;
+  if (!Number.isFinite(trackWidthPx) || trackWidthPx <= 0) return 1;
+  const numerator = minWidthPx + gapPx;
+  const denominator = trackWidthPx + gapPx;
+  return Math.max(1, Math.ceil(numerator / denominator));
+}
+
+export function computeGridColumnCount(args: {
+  containerWidth: number;
+  tileCount: number;
+  minTileWidth: number;
+  gapPx?: number;
+}): number {
+  const {
+    containerWidth,
+    tileCount,
+    minTileWidth,
+    gapPx = GRID_GAP_PX,
+  } = args;
+  if (!Number.isFinite(containerWidth) || containerWidth <= 0 || tileCount <= 0) return 1;
+  const safeMinWidth = Math.max(1, Math.floor(minTileWidth));
+  const maxColumns = Math.max(1, Math.min(tileCount, Math.floor((containerWidth + gapPx) / (safeMinWidth + gapPx))));
+  if (maxColumns <= 1) {
+    return maxColumns;
+  }
+  const minRows = Math.ceil(tileCount / maxColumns);
+  for (let columns = 1; columns <= maxColumns; columns += 1) {
+    if (Math.ceil(tileCount / columns) === minRows) {
+      return columns;
+    }
+  }
+  return maxColumns;
+}
+
+export function readPackedGridSpan(
+  layout: DockLayout,
+  tileId: string,
+  defaults: PackedGridSpan,
+): PackedGridSpan {
+  const rawColSpan = Number(layout[spanKey(tileId, "col")] ?? defaults.colSpan);
+  const rawRowSpan = Number(layout[spanKey(tileId, "row")] ?? defaults.rowSpan);
+  return {
+    colSpan: Number.isFinite(rawColSpan) ? rawColSpan : defaults.colSpan,
+    rowSpan: Number.isFinite(rawRowSpan) ? rawRowSpan : defaults.rowSpan,
+  };
+}
+
+export function clampPackedGridSpan(args: {
+  span: PackedGridSpan;
+  columnCount: number;
+  minColSpan?: number;
+  minRowSpan: number;
+  maxRowSpan?: number;
+}): PackedGridSpan {
+  const {
+    span,
+    columnCount,
+    minColSpan = 1,
+    minRowSpan,
+    maxRowSpan = GRID_MAX_ROW_SPAN,
+  } = args;
+  return {
+    colSpan: Math.max(minColSpan, Math.min(columnCount, Math.round(span.colSpan || minColSpan))),
+    rowSpan: Math.max(minRowSpan, Math.min(maxRowSpan, Math.round(span.rowSpan || minRowSpan))),
+  };
+}
+
+export function reconcilePackedGridLayout(args: {
+  layout: DockLayout;
+  tileIds: string[];
+  defaultSpansById: Record<string, PackedGridSpan>;
+}): DockLayout {
+  const { layout, tileIds, defaultSpansById } = args;
+  const activeTileIds = new Set(tileIds);
+  const next: DockLayout = {};
+
+  // Preserve persisted spans for tiles not currently active
+  for (const [key, value] of Object.entries(layout)) {
+    const match = key.match(/^(.+):(col|row)$/);
+    if (match && !activeTileIds.has(match[1])) {
+      next[key] = value;
+    }
+  }
+
+  // Reconcile active tiles with defaults
+  for (const tileId of tileIds) {
+    const defaults = defaultSpansById[tileId] ?? { colSpan: 1, rowSpan: 1 };
+    const persistedColSpan = Number(layout[spanKey(tileId, "col")]);
+    const persistedRowSpan = Number(layout[spanKey(tileId, "row")]);
+    next[spanKey(tileId, "col")] = Number.isFinite(persistedColSpan) ? persistedColSpan : defaults.colSpan;
+    next[spanKey(tileId, "row")] = Number.isFinite(persistedRowSpan) ? persistedRowSpan : defaults.rowSpan;
+  }
+  return next;
+}
+
+function canPlaceAt(
+  occupied: Set<string>,
+  column: number,
+  row: number,
+  colSpan: number,
+  rowSpan: number,
+  columnCount: number,
+): boolean {
+  if (column + colSpan - 1 > columnCount) return false;
+  for (let rowOffset = 0; rowOffset < rowSpan; rowOffset += 1) {
+    for (let colOffset = 0; colOffset < colSpan; colOffset += 1) {
+      const key = `${row + rowOffset}:${column + colOffset}`;
+      if (occupied.has(key)) return false;
+    }
+  }
+  return true;
+}
+
+function occupy(
+  occupied: Set<string>,
+  column: number,
+  row: number,
+  colSpan: number,
+  rowSpan: number,
+): void {
+  for (let rowOffset = 0; rowOffset < rowSpan; rowOffset += 1) {
+    for (let colOffset = 0; colOffset < colSpan; colOffset += 1) {
+      occupied.add(`${row + rowOffset}:${column + colOffset}`);
+    }
+  }
+}
+
+export function packGridItems(items: PackedGridItem[], columnCount: number): {
+  placements: PackedGridPlacement[];
+  totalRows: number;
+} {
+  const clampedColumnCount = Math.max(1, Math.floor(Number(columnCount) || 0));
+  const placements: PackedGridPlacement[] = [];
+  const occupied = new Set<string>();
+  let totalRows = 0;
+
+  for (const item of items) {
+    const colSpan = Math.max(1, Math.min(clampedColumnCount, item.span.colSpan));
+    const rowSpan = Math.max(item.minRowSpan, item.span.rowSpan);
+    let placed = false;
+    let row = 1;
+
+    while (!placed) {
+      for (let column = 1; column <= clampedColumnCount; column += 1) {
+        if (!canPlaceAt(occupied, column, row, colSpan, rowSpan, clampedColumnCount)) continue;
+        occupy(occupied, column, row, colSpan, rowSpan);
+        placements.push({
+          id: item.id,
+          column,
+          row,
+          colSpan,
+          rowSpan,
+        });
+        totalRows = Math.max(totalRows, row + rowSpan - 1);
+        placed = true;
+        break;
+      }
+      row += 1;
+    }
+  }
+
+  return {
+    placements,
+    totalRows,
+  };
+}
+
+export function computePackedGridRowHeight(args: {
+  containerHeight: number;
+  totalRows: number;
+  gapPx?: number;
+  baseRowPx?: number;
+}): number {
+  const {
+    containerHeight,
+    totalRows,
+    gapPx = GRID_GAP_PX,
+    baseRowPx = GRID_BASE_ROW_PX,
+  } = args;
+  if (!Number.isFinite(containerHeight) || containerHeight <= 0 || totalRows <= 0) return baseRowPx;
+  const available = (containerHeight - gapPx * Math.max(0, totalRows - 1)) / totalRows;
+  return Math.max(baseRowPx, Math.floor(available));
+}
+
+export function computePackedSpanPixels(span: number, unitPx: number, gapPx = GRID_GAP_PX): number {
+  return span * unitPx + Math.max(0, span - 1) * gapPx;
+}
diff --git a/apps/desktop/src/renderer/components/terminals/useWorkSessions.test.ts b/apps/desktop/src/renderer/components/terminals/useWorkSessions.test.ts
index 0758bd959..f9bc74e0a 100644
--- a/apps/desktop/src/renderer/components/terminals/useWorkSessions.test.ts
+++ b/apps/desktop/src/renderer/components/terminals/useWorkSessions.test.ts
@@ -30,6 +30,28 @@ vi.mock("../../lib/terminalAttention", () => ({
 }));
 
 vi.mock("../../lib/sessions", () => ({
+  buildOptimisticChatSessionSummary: vi.fn((args: { session: { id: string; laneId: string }; laneName?: string | null }) => ({
+    id: args.session.id,
+    laneId: args.session.laneId,
+    laneName: args.laneName ?? args.session.laneId,
+    ptyId: null,
+    tracked: true,
+    pinned: false,
+    goal: null,
+    toolType: "claude-chat",
+    title: "Claude chat",
+    status: "running",
+    startedAt: "2026-04-01T12:00:00.000Z",
+    endedAt: null,
+    exitCode: null,
+    transcriptPath: "",
+    headShaStart: null,
+    headShaEnd: null,
+    lastOutputPreview: null,
+    summary: null,
+    runtimeState: "idle",
+    resumeCommand: null,
+  })),
   isRunOwnedSession: vi.fn(() => false),
   isChatToolType: vi.fn(() => false),
 }));
@@ -165,4 +187,41 @@ describe("useWorkSessions — refresh-before-focus ordering", () => {
     expect(refreshDoneIdx).toBeLessThan(focusIdx);
     expect(refreshDoneIdx).toBeLessThan(openTabIdx);
   });
+
+  it("showDraftKind: clears the active session and re-enters chat draft mode without closing tabs", () => {
+    const previousState = {
+      openItemIds: ["session-1", "session-2"],
+      activeItemId: "session-2",
+      selectedItemId: "session-2",
+      viewMode: "grid",
+      draftKind: "shell",
+      laneFilter: "lane-1",
+      statusFilter: "running",
+      search: "alpha",
+      sessionListOrganization: "by-time",
+      workCollapsedLaneIds: ["lane-1"],
+      workFocusSessionsHidden: true,
+    };
+    let nextState: typeof previousState | null = null;
+
+    setWorkViewStateSpy.mockImplementation(
+      (_projectRoot: string, next: ((prev: typeof previousState) => typeof previousState) | Partial<typeof previousState>) => {
+        nextState = typeof next === "function" ? next(previousState) : { ...previousState, ...next };
+      },
+    );
+
+    const { result } = renderHook(() => useWorkSessions());
+
+    act(() => {
+      result.current.showDraftKind("chat");
+    });
+
+    expect(nextState).toEqual({
+      ...previousState,
+      activeItemId: null,
+      selectedItemId: null,
+      viewMode: "tabs",
+      draftKind: "chat",
+    });
+  });
 });
diff --git a/apps/desktop/src/renderer/components/terminals/useWorkSessions.ts b/apps/desktop/src/renderer/components/terminals/useWorkSessions.ts
index c0b8c6582..0b944b20a 100644
--- a/apps/desktop/src/renderer/components/terminals/useWorkSessions.ts
+++ b/apps/desktop/src/renderer/components/terminals/useWorkSessions.ts
@@ -1,6 +1,6 @@
 import { useCallback, useEffect, useMemo, useRef, useState } from "react";
 import { useNavigate, useSearchParams } from "react-router-dom";
-import type { TerminalSessionSummary, TerminalToolType } from "../../../shared/types";
+import type { AgentChatSession, TerminalSessionSummary, TerminalToolType } from "../../../shared/types";
 import {
   useAppStore,
   type WorkDraftKind,
@@ -10,8 +10,8 @@ import {
   type WorkViewMode,
 } from "../../state/appStore";
 import { listSessionsCached } from "../../lib/sessionListCache";
-import { sessionMatchesStatusFilter, sessionStatusBucket } from "../../lib/terminalAttention";
-import { isChatToolType, isRunOwnedSession } from "../../lib/sessions";
+import { sessionStatusBucket } from "../../lib/terminalAttention";
+import { buildOptimisticChatSessionSummary, isChatToolType, isRunOwnedSession } from "../../lib/sessions";
 import { shouldRefreshSessionListForChatEvent } from "../../lib/chatSessionEvents";
 import { defaultTrackedCliStartupCommand, withCodexNoAltScreen } from "./cliLaunch";
 
@@ -55,6 +55,16 @@ function mapUrlStatusFilter(statusParamRaw: string): WorkStatusFilter | null {
   return null;
 }
 
+type QueuedRefresh = {
+  showLoading: boolean;
+  force: boolean;
+  deferred: {
+    promise: Promise<void>;
+    resolve: () => void;
+    reject: (reason: unknown) => void;
+  };
+};
+
 export function useWorkSessions() {
   const navigate = useNavigate();
   const [searchParams] = useSearchParams();
@@ -71,7 +81,7 @@ export function useWorkSessions() {
   const [closingChatSessionId, setClosingChatSessionId] = useState<string | null>(null);
   const [resumingSessionId, setResumingSessionId] = useState<string | null>(null);
   const refreshInFlightRef = useRef(false);
-  const refreshQueuedRef = useRef(false);
+  const refreshQueuedRef = useRef<QueuedRefresh | null>(null);
   const hasRunningSessionsRef = useRef(false);
   const backgroundRefreshTimerRef = useRef<number | null>(null);
   const appliedQuerySessionIdRef = useRef<string | null>(null);
@@ -259,28 +269,65 @@ export function useWorkSessions() {
     [setProjectViewState],
   );
 
-  const refresh = useCallback(async (options: { showLoading?: boolean } = {}) => {
+  const refresh = useCallback(async (options: { showLoading?: boolean; force?: boolean } = {}) => {
     const showLoading = options.showLoading ?? true;
     if (refreshInFlightRef.current) {
-      refreshQueuedRef.current = true;
-      return;
+      if (refreshQueuedRef.current) {
+        refreshQueuedRef.current.showLoading = refreshQueuedRef.current.showLoading || showLoading;
+        refreshQueuedRef.current.force = refreshQueuedRef.current.force || Boolean(options.force);
+        return refreshQueuedRef.current.deferred.promise;
+      }
+      let resolve!: () => void;
+      let reject!: (reason: unknown) => void;
+      const promise = new Promise<void>((nextResolve, nextReject) => {
+        resolve = nextResolve;
+        reject = nextReject;
+      });
+      refreshQueuedRef.current = {
+        showLoading,
+        force: Boolean(options.force),
+        deferred: { promise, resolve, reject },
+      };
+      return promise;
     }
     refreshInFlightRef.current = true;
     if (showLoading) setLoading(true);
     try {
-      const rows = (await listSessionsCached({ limit: 500 })).filter((session) => !isRunOwnedSession(session));
+      const rows = (
+        await listSessionsCached(
+          { limit: 500 },
+          options.force ? { force: true } : undefined,
+        )
+      ).filter((session) => !isRunOwnedSession(session));
       setSessions(rows);
       hasLoadedOnceRef.current = true;
     } finally {
       if (showLoading) setLoading(false);
       refreshInFlightRef.current = false;
-      if (refreshQueuedRef.current) {
-        refreshQueuedRef.current = false;
-        void refresh({ showLoading: false });
+      const queued = refreshQueuedRef.current;
+      refreshQueuedRef.current = null;
+      if (queued) {
+        void refresh({ showLoading: queued.showLoading, force: queued.force })
+          .then(queued.deferred.resolve, queued.deferred.reject);
       }
     }
   }, []);
 
+  const upsertOptimisticChatSession = useCallback((session: AgentChatSession) => {
+    const laneName = lanes.find((lane) => lane.id === session.laneId)?.name ?? session.laneId;
+    const optimistic = buildOptimisticChatSessionSummary({
+      session,
+      laneName,
+    });
+    setSessions((prev) => {
+      const next = [optimistic, ...prev.filter((entry) => entry.id !== session.id)];
+      next.sort((left, right) => (
+        new Date(right.startedAt).getTime() - new Date(left.startedAt).getTime()
+      ));
+      return next;
+    });
+  }, [lanes]);
+
   const scheduleBackgroundRefresh = useCallback((delayMs = 450) => {
     if (backgroundRefreshTimerRef.current != null) return;
     backgroundRefreshTimerRef.current = window.setTimeout(() => {
@@ -430,44 +477,23 @@ export function useWorkSessions() {
     });
   }, [sessions, filterLaneId, q]);
 
-  const runningFiltered = useMemo(
-    () =>
-      filtered.filter(
-        (session) =>
-          sessionStatusBucket({
-            status: session.status,
-            lastOutputPreview: session.lastOutputPreview,
-            runtimeState: session.runtimeState,
-          }) === "running",
-      ),
-    [filtered],
-  );
-
-  const awaitingInputFiltered = useMemo(
-    () =>
-      filtered.filter(
-        (session) =>
-          sessionStatusBucket({
-            status: session.status,
-            lastOutputPreview: session.lastOutputPreview,
-            runtimeState: session.runtimeState,
-          }) === "awaiting-input",
-      ),
-    [filtered],
-  );
-
-  const endedFiltered = useMemo(
-    () =>
-      filtered.filter(
-        (session) =>
-          sessionStatusBucket({
-            status: session.status,
-            lastOutputPreview: session.lastOutputPreview,
-            runtimeState: session.runtimeState,
-          }) === "ended",
-      ),
-    [filtered],
-  );
+  const { runningFiltered, awaitingInputFiltered, endedFiltered } = useMemo(() => {
+    const running: TerminalSessionSummary[] = [];
+    const awaiting: TerminalSessionSummary[] = [];
+    const ended: TerminalSessionSummary[] = [];
+    for (const session of filtered) {
+      const bucket = sessionStatusBucket({
+        status: session.status,
+        lastOutputPreview: session.lastOutputPreview,
+        runtimeState: session.runtimeState,
+        toolType: session.toolType,
+      });
+      if (bucket === "running") running.push(session);
+      else if (bucket === "awaiting-input") awaiting.push(session);
+      else ended.push(session);
+    }
+    return { runningFiltered: running, awaitingInputFiltered: awaiting, endedFiltered: ended };
+  }, [filtered]);
 
   const sessionsGroupedByLane = useMemo(() => {
     if (sessionListOrganization !== "by-lane") return null;
@@ -497,6 +523,11 @@ export function useWorkSessions() {
       .filter((session): session is TerminalSessionSummary => session != null);
   }, [openItemIds, sessionsById]);
 
+  const gridLayoutId = useMemo(
+    () => `work:grid:v2:${projectRoot ?? "global"}`,
+    [projectRoot],
+  );
+
   const selectedSession = useMemo(
     () => (selectedSessionId ? sessions.find((session) => session.id === selectedSessionId) ?? null : null),
     [sessions, selectedSessionId],
@@ -681,7 +712,7 @@ export function useWorkSessions() {
       // Refresh the session list before activating the tab so the new
       // session is in sessionsById when the UI resolves activeSession.
       try {
-        await refresh();
+        await refresh({ force: true });
       } catch {
         // Best-effort: if refresh fails the session was still created,
         // so proceed to focus/open it.
@@ -702,6 +733,7 @@ export function useWorkSessions() {
     endedFiltered,
     runningSessions,
     visibleSessions,
+    gridLayoutId,
     selectedSession,
     loading,
 
@@ -739,6 +771,7 @@ export function useWorkSessions() {
     resumingSessionId,
 
     refresh,
+    upsertOptimisticChatSession,
     closeSession,
     closeAllRunning,
     resumeSession,
diff --git a/apps/desktop/src/renderer/lib/platform.test.ts b/apps/desktop/src/renderer/lib/platform.test.ts
deleted file mode 100644
index 598620f8a..000000000
--- a/apps/desktop/src/renderer/lib/platform.test.ts
+++ /dev/null
@@ -1,29 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { revealLabel } from "./platform";
-
-describe("platform detection", () => {
-  it("exports revealLabel as a non-empty string", () => {
-    expect(typeof revealLabel).toBe("string");
-    expect(revealLabel.length).toBeGreaterThan(0);
-  });
-
-  it("returns the correct label for the current platform", () => {
-    // In vitest (node environment), navigator is typically undefined,
-    // so the module falls back to process.platform.
-    // On macOS (darwin), it should detect as Mac.
-    const expectMac =
-      typeof process !== "undefined" &&
-      typeof process.platform === "string" &&
-      process.platform === "darwin";
-
-    if (expectMac) {
-      expect(revealLabel).toBe("Reveal in Finder");
-    } else {
-      expect(revealLabel).toBe("Reveal in File Explorer");
-    }
-  });
-
-  it("label is one of the two known values", () => {
-    expect(["Reveal in Finder", "Reveal in File Explorer"]).toContain(revealLabel);
-  });
-});
diff --git a/apps/desktop/src/renderer/lib/sessions.ts b/apps/desktop/src/renderer/lib/sessions.ts
index 5963a2b42..5a4c787c3 100644
--- a/apps/desktop/src/renderer/lib/sessions.ts
+++ b/apps/desktop/src/renderer/lib/sessions.ts
@@ -1,6 +1,6 @@
 /** Shared session/terminal utilities for the renderer. */
 
-import type { TerminalSessionSummary } from "../../shared/types";
+import type { AgentChatProvider, AgentChatSession, TerminalSessionSummary, TerminalToolType } from "../../shared/types";
 
 /** Returns true if the tool type represents an AI chat session. */
 export function isChatToolType(toolType: string | null | undefined): boolean {
@@ -12,6 +12,15 @@ export function isChatToolType(toolType: string | null | undefined): boolean {
   );
 }
 
+export function chatToolTypeForProvider(provider: AgentChatProvider | string | null | undefined): TerminalToolType {
+  switch (provider) {
+    case "claude": return "claude-chat";
+    case "codex": return "codex-chat";
+    case "cursor": return "cursor";
+    default: return "ai-chat";
+  }
+}
+
 export function isRunOwnedToolType(toolType: string | null | undefined): boolean {
   return toolType === "run-shell";
 }
@@ -35,6 +44,37 @@ export function defaultSessionLabel(toolType: string | null | undefined): string
   return "Session";
 }
 
+export function buildOptimisticChatSessionSummary(args: {
+  session: Pick<AgentChatSession, "id" | "laneId" | "provider" | "status" | "createdAt" | "lastActivityAt">;
+  laneName?: string | null;
+}): TerminalSessionSummary {
+  const toolType = chatToolTypeForProvider(args.session.provider);
+  const isEnded = args.session.status === "ended";
+
+  return {
+    id: args.session.id,
+    laneId: args.session.laneId,
+    laneName: args.laneName?.trim() || args.session.laneId,
+    ptyId: null,
+    tracked: true,
+    pinned: false,
+    goal: null,
+    toolType,
+    title: defaultSessionLabel(toolType),
+    status: isEnded ? "completed" : "running",
+    startedAt: args.session.createdAt,
+    endedAt: isEnded ? args.session.lastActivityAt : null,
+    exitCode: null,
+    transcriptPath: "",
+    headShaStart: null,
+    headShaEnd: null,
+    lastOutputPreview: null,
+    summary: null,
+    runtimeState: isEnded ? "exited" : args.session.status === "active" ? "running" : "idle",
+    resumeCommand: null,
+  };
+}
+
 export function formatToolTypeLabel(toolType: string | null | undefined): string {
   if (toolType === "claude-orchestrated") return "Claude worker runtime";
   if (toolType === "codex-orchestrated") return "Codex worker runtime";
diff --git a/apps/desktop/src/renderer/lib/terminalAttention.test.ts b/apps/desktop/src/renderer/lib/terminalAttention.test.ts
index 61092af3e..da0394a8a 100644
--- a/apps/desktop/src/renderer/lib/terminalAttention.test.ts
+++ b/apps/desktop/src/renderer/lib/terminalAttention.test.ts
@@ -22,6 +22,17 @@ describe("terminalAttention", () => {
     ).toBe("running-needs-attention");
   });
 
+  it("treats idle chat sessions as a static ready state", () => {
+    expect(
+      sessionIndicatorState({
+        status: "running",
+        lastOutputPreview: "Completed response",
+        runtimeState: "idle",
+        toolType: "claude-chat",
+      }),
+    ).toBe("running-needs-attention");
+  });
+
   describe("sessionStatusDot", () => {
     it("returns a spinning emerald dot for a running active session", () => {
       const dot = sessionStatusDot({
@@ -43,6 +54,18 @@ describe("terminalAttention", () => {
       expect(dot.label).toBe("Awaiting input");
     });
 
+    it("returns a solid amber dot for an idle chat session", () => {
+      const dot = sessionStatusDot({
+        status: "running",
+        lastOutputPreview: "Completed response",
+        runtimeState: "idle",
+        toolType: "claude-chat",
+      });
+      expect(dot.spinning).toBe(false);
+      expect(dot.cls).toContain("amber");
+      expect(dot.label).toBe("Ready");
+    });
+
     it("returns a solid red dot for an ended session", () => {
       const dot = sessionStatusDot({
         status: "completed",
diff --git a/apps/desktop/src/renderer/lib/terminalAttention.ts b/apps/desktop/src/renderer/lib/terminalAttention.ts
index 91c4a5642..0a220764c 100644
--- a/apps/desktop/src/renderer/lib/terminalAttention.ts
+++ b/apps/desktop/src/renderer/lib/terminalAttention.ts
@@ -1,4 +1,5 @@
-import type { TerminalRuntimeState, TerminalSessionStatus, TerminalSessionSummary } from "../../shared/types";
+import type { TerminalRuntimeState, TerminalSessionStatus, TerminalSessionSummary, TerminalToolType } from "../../shared/types";
+import { isChatToolType } from "./sessions";
 
 export type TerminalRunIndicatorState = "none" | "running-active" | "running-needs-attention";
 export type SessionStatusFilter = "all" | "running" | "awaiting-input" | "ended";
@@ -72,9 +73,11 @@ export function sessionIndicatorState(args: {
   status: TerminalSessionStatus;
   lastOutputPreview: string | null;
   runtimeState?: TerminalRuntimeState;
+  toolType?: TerminalToolType | null;
 }): SessionUiState {
   if (args.status === "running") {
     if (args.runtimeState === "waiting-input") return "running-needs-attention";
+    if (args.runtimeState === "idle" && isChatToolType(args.toolType)) return "running-needs-attention";
     return runningSessionNeedsAttention(args.lastOutputPreview) ? "running-needs-attention" : "running-active";
   }
   return "ended";
@@ -84,6 +87,7 @@ export function sessionStatusBucket(args: {
   status: TerminalSessionStatus;
   lastOutputPreview: string | null;
   runtimeState?: TerminalRuntimeState;
+  toolType?: TerminalToolType | null;
 }): SessionStatusBucket {
   const state = sessionIndicatorState(args);
   if (state === "running-active") return "running";
@@ -96,6 +100,7 @@ export function sessionMatchesStatusFilter(
     status: TerminalSessionStatus;
     lastOutputPreview: string | null;
     runtimeState?: TerminalRuntimeState;
+    toolType?: TerminalToolType | null;
   },
   filter: SessionStatusFilter,
 ): boolean {
@@ -114,13 +119,18 @@ export function sessionStatusDot(session: {
   status: TerminalSessionStatus;
   lastOutputPreview: string | null;
   runtimeState?: TerminalRuntimeState;
+  toolType?: TerminalToolType | null;
 }): SessionStatusDot {
   const indicator = sessionIndicatorState(session);
   if (indicator === "running-active") {
     return { cls: "border-2 border-emerald-400 border-t-transparent bg-transparent", spinning: true, label: "Running" };
   }
   if (indicator === "running-needs-attention") {
-    return { cls: "bg-amber-300", spinning: false, label: "Awaiting input" };
+    return {
+      cls: "bg-amber-300",
+      spinning: false,
+      label: session.runtimeState === "idle" && isChatToolType(session.toolType) ? "Ready" : "Awaiting input",
+    };
   }
   return { cls: "bg-red-400", spinning: false, label: "Ended" };
 }
@@ -136,6 +146,7 @@ export function summarizeTerminalAttention(sessions: TerminalSessionSummary[]):
       status: session.status,
       lastOutputPreview: session.lastOutputPreview,
       runtimeState: session.runtimeState,
+      toolType: session.toolType,
     });
     if (indicator === "ended") continue;
     const lane = byLane[session.laneId] ?? { runningCount: 0, activeCount: 0, needsAttentionCount: 0 };
diff --git a/apps/desktop/src/renderer/state/appStore.ts b/apps/desktop/src/renderer/state/appStore.ts
index b0dbf543c..9cbda2462 100644
--- a/apps/desktop/src/renderer/state/appStore.ts
+++ b/apps/desktop/src/renderer/state/appStore.ts
@@ -60,7 +60,7 @@ function createDefaultWorkProjectViewState(): WorkProjectViewState {
     laneFilter: "all",
     statusFilter: "all",
     search: "",
-    sessionListOrganization: "by-time",
+    sessionListOrganization: "all-lanes-by-status",
     workCollapsedLaneIds: [],
     workFocusSessionsHidden: false,
   };
diff --git a/apps/desktop/src/shared/types/chat.ts b/apps/desktop/src/shared/types/chat.ts
index 4dde71285..df5d2fd49 100644
--- a/apps/desktop/src/shared/types/chat.ts
+++ b/apps/desktop/src/shared/types/chat.ts
@@ -155,7 +155,7 @@ export type AgentChatEvent =
       logicalItemId?: string;
       parentItemId?: string;
       turnId?: string;
-      status?: "running" | "completed" | "failed";
+      status?: "running" | "completed" | "failed" | "interrupted";
     }
   | {
       type: "file_change";
@@ -201,6 +201,12 @@ export type AgentChatEvent =
       turnId?: string;
       detail?: unknown;
     }
+  | {
+      type: "pending_input_resolved";
+      itemId: string;
+      resolution: "accepted" | "declined" | "cancelled";
+      turnId?: string;
+    }
   | {
       type: "status";
       turnStatus: "started" | "completed" | "interrupted" | "failed";
@@ -408,6 +414,8 @@ export type PendingInputOption = {
   value: string;
   description?: string;
   recommended?: boolean;
+  preview?: string;
+  previewFormat?: "markdown" | "html";
 };
 
 export type PendingInputQuestion = {
@@ -415,6 +423,7 @@ export type PendingInputQuestion = {
   header?: string;
   question: string;
   options?: PendingInputOption[] | null;
+  multiSelect?: boolean;
   allowsFreeform?: boolean;
   isSecret?: boolean;
   defaultAssumption?: string | null;
diff --git a/apps/desktop/src/shared/types/cto.ts b/apps/desktop/src/shared/types/cto.ts
index e36d47025..b0eaeeae8 100644
--- a/apps/desktop/src/shared/types/cto.ts
+++ b/apps/desktop/src/shared/types/cto.ts
@@ -120,7 +120,7 @@ export type CtoOnboardingState = {
 };
 
 export type CtoSystemPromptPreviewSection = {
-  id: "doctrine" | "personality" | "memory" | "capabilities";
+  id: "doctrine" | "personality" | "memory" | "knowledge" | "capabilities";
   title: string;
   content: string;
 };
diff --git a/apps/desktop/src/shared/types/prs.ts b/apps/desktop/src/shared/types/prs.ts
index fed7f3f1a..317a02217 100644
--- a/apps/desktop/src/shared/types/prs.ts
+++ b/apps/desktop/src/shared/types/prs.ts
@@ -127,6 +127,9 @@ export type GitHubPrListItem = {
   adeKind: "single" | "queue" | "integration" | null;
   workflowDisplayState: IntegrationWorkflowDisplayState | null;
   cleanupState: IntegrationCleanupState | null;
+  labels: PrLabel[];
+  isBot: boolean;
+  commentCount: number;
 };
 
 export type GitHubPrSnapshot = {
diff --git a/apps/mcp-server/src/bootstrap.ts b/apps/mcp-server/src/bootstrap.ts
index e728b209c..9b8806c27 100644
--- a/apps/mcp-server/src/bootstrap.ts
+++ b/apps/mcp-server/src/bootstrap.ts
@@ -208,7 +208,10 @@ export async function createAdeMcpRuntime(args: { projectRoot: string; workspace
   await laneService.ensurePrimaryLane();
 
   const sessionService = createSessionService({ db });
-  sessionService.reconcileStaleRunningSessions({ status: "disposed" });
+  sessionService.reconcileStaleRunningSessions({
+    status: "disposed",
+    excludeToolTypes: ["claude-chat", "codex-chat", "ai-chat", "cursor"],
+  });
 
   const projectConfigService = createProjectConfigService({
     projectRoot,
diff --git a/apps/mcp-server/src/mcpServer.test.ts b/apps/mcp-server/src/mcpServer.test.ts
index 0bff73a4c..a3c31b5c8 100644
--- a/apps/mcp-server/src/mcpServer.test.ts
+++ b/apps/mcp-server/src/mcpServer.test.ts
@@ -438,6 +438,11 @@ function createRuntime() {
         createdAt: "2026-03-17T19:10:00.000Z",
         lastActivityAt: "2026-03-17T19:10:00.000Z",
       })),
+      requestChatInput: vi.fn(async () => ({
+        decision: "accept",
+        answers: { answer: ["yes"] },
+        responseText: "yes",
+      })),
       sendMessage: vi.fn(async () => {}),
       interrupt: vi.fn(async () => {}),
       resumeSession: vi.fn(async ({ sessionId }: { sessionId: string }) => ({
@@ -2615,6 +2620,86 @@ describe("mcpServer", () => {
     expect(response.structuredContent.blocking).toBe(true);
   });
 
+  it("returns explicit declined semantics for standalone ask_user with structured questions", async () => {
+    const fixture = createRuntime();
+    fixture.runtime.agentChatService.requestChatInput = vi.fn(async () => ({
+      decision: "decline",
+      answers: {},
+      responseText: null,
+    }));
+    const handler = createMcpRequestHandler({ runtime: fixture.runtime, serverVersion: "test" });
+
+    await initialize(handler, {
+      callerId: "chat-session-1",
+      role: "agent",
+      chatSessionId: "chat-session-1",
+    });
+    const response = await callTool(handler, "ask_user", {
+      title: "Pick a flow",
+      body: "Which part should we test first? 1. Question flow 2. Plan updates",
+      questions: [
+        {
+          id: "flow",
+          header: "Choose one",
+          question: "Which part should we test first?",
+          options: [
+            { label: "Question flow", value: "question_flow" },
+            { label: "Plan updates", value: "plan_updates" },
+          ],
+        },
+      ],
+    });
+
+    expect(response?.isError).toBeUndefined();
+    expect(fixture.runtime.agentChatService.requestChatInput).toHaveBeenCalledWith(expect.objectContaining({
+      chatSessionId: "chat-session-1",
+      questions: [
+        expect.objectContaining({
+          id: "flow",
+          question: "Which part should we test first?",
+          options: [
+            expect.objectContaining({ label: "Question flow", value: "question_flow" }),
+            expect.objectContaining({ label: "Plan updates", value: "plan_updates" }),
+          ],
+        }),
+      ],
+    }));
+    expect(response.structuredContent.outcome).toBe("declined");
+    expect(response.structuredContent.answered).toBe(false);
+    expect(response.structuredContent.declined).toBe(true);
+    expect(response.structuredContent.cancelled).toBe(false);
+    expect(response.structuredContent.timedOut).toBe(false);
+    expect(response.structuredContent.awaitingUserResponse).toBe(false);
+    expect(response.structuredContent.blocking).toBe(false);
+    expect(response.structuredContent.responseText).toContain("declined");
+  });
+
+  it("returns explicit timed_out semantics for standalone ask_user when the user does not answer in time", async () => {
+    const fixture = createRuntime();
+    fixture.runtime.agentChatService.requestChatInput = vi.fn(() => new Promise(() => {}));
+    const handler = createMcpRequestHandler({ runtime: fixture.runtime, serverVersion: "test" });
+
+    await initialize(handler, {
+      callerId: "chat-session-2",
+      role: "agent",
+      chatSessionId: "chat-session-2",
+    });
+    const response = await callTool(handler, "ask_user", {
+      title: "Pick a flow",
+      body: "Which part should we test first? 1. Question flow 2. Plan updates",
+      waitForResolutionMs: 10,
+    });
+
+    expect(response?.isError).toBeUndefined();
+    expect(response.structuredContent.outcome).toBe("timed_out");
+    expect(response.structuredContent.decision).toBe("timeout");
+    expect(response.structuredContent.answered).toBe(false);
+    expect(response.structuredContent.timedOut).toBe(true);
+    expect(response.structuredContent.awaitingUserResponse).toBe(true);
+    expect(response.structuredContent.blocking).toBe(true);
+    expect(response.structuredContent.responseText).toContain("timed out");
+  });
+
   it("stamps worker-owned ask_user provenance and enforces per-step phase policy", async () => {
     const fixture = createRuntime();
     fixture.runtime.orchestratorService.getRunGraph = vi.fn(() => ({
diff --git a/apps/mcp-server/src/mcpServer.ts b/apps/mcp-server/src/mcpServer.ts
index 44db993f0..b3400b836 100644
--- a/apps/mcp-server/src/mcpServer.ts
+++ b/apps/mcp-server/src/mcpServer.ts
@@ -173,15 +173,51 @@ const TOOL_SPECS: ToolSpec[] = [
   },
   {
     name: "ask_user",
-    description: "Create a mission intervention and optionally wait for user resolution.",
+    description: "Ask the user a question and wait for their answer. Works in both mission contexts (with missionId) and standalone chat sessions (without missionId). Returns explicit outcome fields (`outcome`, `resolved`, `answered`, `declined`, `cancelled`, `timedOut`, `awaitingUserResponse`) so declines/cancels/timeouts cannot be mistaken for a still-pending question.",
     inputSchema: {
       type: "object",
-      required: ["missionId", "title", "body"],
+      required: ["title", "body"],
       additionalProperties: false,
       properties: {
         missionId: { type: "string", minLength: 1 },
         title: { type: "string", minLength: 1 },
         body: { type: "string", minLength: 1 },
+        questions: {
+          type: "array",
+          minItems: 1,
+          maxItems: 3,
+          items: {
+            type: "object",
+            required: ["question"],
+            additionalProperties: false,
+            properties: {
+              id: { type: "string", minLength: 1 },
+              header: { type: "string", minLength: 1 },
+              question: { type: "string", minLength: 1 },
+              multiSelect: { type: "boolean" },
+              allowsFreeform: { type: "boolean" },
+              isSecret: { type: "boolean" },
+              defaultAssumption: { type: "string" },
+              impact: { type: "string" },
+              options: {
+                type: "array",
+                items: {
+                  type: "object",
+                  required: ["label"],
+                  additionalProperties: false,
+                  properties: {
+                    label: { type: "string", minLength: 1 },
+                    value: { type: "string", minLength: 1 },
+                    description: { type: "string" },
+                    recommended: { type: "boolean" },
+                    preview: { type: "string" },
+                    previewFormat: { type: "string", enum: ["markdown", "html"] }
+                  }
+                }
+              }
+            }
+          }
+        },
         requestedAction: { type: "string" },
         laneId: { type: "string" },
         phase: { type: "string" },
@@ -2233,6 +2269,11 @@ function parseInitializeIdentity(params: unknown): SessionIdentity {
   const data = safeObject(params);
   const identity = safeObject(data.identity);
   const envContext = resolveEnvCallerContext();
+  const identityRole = asOptionalTrimmedString(identity.role);
+  const parsedIdentityRole: SessionIdentity["role"] | null =
+    identityRole === "cto" || identityRole === "orchestrator" || identityRole === "agent" || identityRole === "external" || identityRole === "evaluator"
+      ? identityRole
+      : null;
   const validRole: SessionIdentity["role"] = envContext.role ?? "external";
   const requestedComputerUsePolicy = normalizeComputerUsePolicy(
     identity.computerUsePolicy ?? envContext.computerUsePolicy,
@@ -3540,7 +3581,7 @@ async function runTool(args: {
   if (name === "ask_user") {
     ensureAskUserAllowed(session);
 
-    const missionId = assertNonEmptyString(toolArgs.missionId, "missionId");
+    const missionId = asOptionalTrimmedString(toolArgs.missionId) ?? callerCtx.missionId ?? undefined;
     const title = assertNonEmptyString(toolArgs.title, "title");
     const body = assertNonEmptyString(toolArgs.body, "body");
     const requestedAction = asOptionalTrimmedString(toolArgs.requestedAction);
@@ -3548,7 +3589,140 @@ async function runTool(args: {
     const phase = asOptionalTrimmedString(toolArgs.phase);
     const waitForResolutionMs = Math.max(0, Math.floor(asNumber(toolArgs.waitForResolutionMs, 0)));
     const pollIntervalMs = Math.max(100, Math.floor(asNumber(toolArgs.pollIntervalMs, 1000)));
+    const structuredQuestions = Array.isArray(toolArgs.questions)
+      ? toolArgs.questions.flatMap((rawQuestion, index) => {
+          if (!rawQuestion || typeof rawQuestion !== "object") return [];
+          const q = rawQuestion as Record<string, unknown>;
+          const question = asOptionalTrimmedString(q.question);
+          if (!question) return [];
+          const options = Array.isArray(q.options)
+            ? q.options.flatMap((rawOption) => {
+                if (!rawOption || typeof rawOption !== "object") return [];
+                const o = rawOption as Record<string, unknown>;
+                const label = asOptionalTrimmedString(o.label);
+                if (!label) return [];
+                const value = asOptionalTrimmedString(o.value);
+                const description = asOptionalTrimmedString(o.description);
+                const preview = asOptionalTrimmedString(o.preview);
+                const previewFormat = o.previewFormat === "markdown" || o.previewFormat === "html" ? o.previewFormat : undefined;
+                return [{
+                  label,
+                  ...(value ? { value } : {}),
+                  ...(description ? { description } : {}),
+                  ...(o.recommended === true ? { recommended: true } : {}),
+                  ...(preview ? { preview } : {}),
+                  ...(previewFormat ? { previewFormat } : {}),
+                }];
+              })
+            : undefined;
+          const header = asOptionalTrimmedString(q.header);
+          const defaultAssumption = asOptionalTrimmedString(q.defaultAssumption);
+          const impact = asOptionalTrimmedString(q.impact);
+          return [{
+            id: asOptionalTrimmedString(q.id) ?? `question_${index + 1}`,
+            ...(header ? { header } : {}),
+            question,
+            ...(options?.length ? { options } : {}),
+            ...(q.multiSelect === true ? { multiSelect: true } : {}),
+            ...(typeof q.allowsFreeform === "boolean" ? { allowsFreeform: q.allowsFreeform } : {}),
+            ...(q.isSecret === true ? { isSecret: true } : {}),
+            ...(defaultAssumption ? { defaultAssumption } : {}),
+            ...(impact ? { impact } : {}),
+          }];
+        })
+      : undefined;
     const askUserPolicy = getAgentAskUserPolicy({ runtime, callerCtx });
+    const summarizeAskUserDecision = (decision: string, responseText: string | null, answered: boolean): string | null => {
+      const trimmed = typeof responseText === "string" ? responseText.trim() : "";
+      if (trimmed.length) return trimmed;
+      if (answered) return null;
+      if (decision === "cancel") return "The user cancelled the question.";
+      if (decision === "decline") return "The user declined to answer the question.";
+      if (decision === "timeout") return "The question timed out before the user answered.";
+      return "The user did not answer the question.";
+    };
+    const buildAskUserResult = (args: {
+      intervention?: unknown;
+      awaitingUserResponse: boolean;
+      blocking: boolean;
+      outcome: "pending" | "answered" | "declined" | "cancelled" | "timed_out";
+      decision?: string;
+      responseText?: string | null;
+      answers?: Record<string, string[]>;
+    }): Record<string, unknown> => ({
+      decision: args.decision ?? (args.outcome === "answered" ? "accept" : args.outcome),
+      outcome: args.outcome,
+      resolved: args.outcome !== "pending" && !args.awaitingUserResponse,
+      answered: args.outcome === "answered",
+      declined: args.outcome === "declined",
+      cancelled: args.outcome === "cancelled",
+      timedOut: args.outcome === "timed_out",
+      awaitingUserResponse: args.awaitingUserResponse,
+      blocking: args.blocking,
+      ...(args.intervention ? { intervention: args.intervention } : {}),
+      answers: args.answers ?? {},
+      responseText: args.responseText ?? null,
+    });
+
+    // ── Standalone chat session path (no missionId) ──
+    // Route through agentChatService.requestChatInput which creates an inline
+    // pending-input in the chat UI and blocks until the user answers.
+    if (!missionId) {
+      // Use server-authorized chatSessionId; reject unverified client-supplied ids.
+      const serverChatSessionId = callerCtx.chatSessionId;
+      const clientChatSessionId = session.identity.chatSessionId;
+      if (clientChatSessionId && serverChatSessionId && clientChatSessionId !== serverChatSessionId) {
+        throw new JsonRpcError(
+          JsonRpcErrorCode.invalidParams,
+          "ask_user: client-supplied chatSessionId does not match server-authorized session.",
+        );
+      }
+      const chatSessionId = serverChatSessionId ?? clientChatSessionId;
+      if (!chatSessionId || !runtime.agentChatService) {
+        throw new JsonRpcError(
+          JsonRpcErrorCode.invalidParams,
+          "ask_user requires either a missionId or an active chat session (chatSessionId).",
+        );
+      }
+
+      // Race the chat input against an optional timeout.
+      const inputPromise = runtime.agentChatService.requestChatInput({
+        chatSessionId,
+        title,
+        body,
+        ...(structuredQuestions?.length ? { questions: structuredQuestions } : {}),
+      });
+      const result = waitForResolutionMs > 0
+        ? await Promise.race([
+            inputPromise,
+            new Promise<null>((resolve) => setTimeout(() => resolve(null), waitForResolutionMs)),
+          ])
+        : await inputPromise;
+
+      if (!result) {
+        return buildAskUserResult({
+          awaitingUserResponse: true,
+          blocking: true,
+          outcome: "timed_out",
+          decision: "timeout",
+          responseText: summarizeAskUserDecision("timeout", null, false),
+        });
+      }
+      const answered = result.decision !== "decline" && result.decision !== "cancel";
+      const outcome = result.decision === "decline"
+        ? "declined"
+        : result.decision === "cancel"
+          ? "cancelled"
+          : "answered";
+      return buildAskUserResult({
+        awaitingUserResponse: false,
+        blocking: false,
+        outcome,
+        decision: result.decision,
+        answers: result.answers,
+        responseText: summarizeAskUserDecision(result.decision, result.responseText, answered),
+      });
+    }
 
     if (askUserPolicy && !askUserPolicy.enabled) {
       throw new JsonRpcError(
@@ -3613,19 +3787,13 @@ async function runTool(args: {
       }
     }
 
-    if (session.identity.role === "orchestrator" || callerCtx.runId) {
-      return {
+    if (session.identity.role === "orchestrator" || callerCtx.runId || waitForResolutionMs <= 0) {
+      return buildAskUserResult({
         intervention,
         awaitingUserResponse: true,
-        blocking: true
-      };
-    }
-
-    if (waitForResolutionMs <= 0) {
-      return {
-        intervention,
-        awaitingUserResponse: true
-      };
+        blocking: true,
+        outcome: "pending",
+      });
     }
 
     const deadline = Date.now() + waitForResolutionMs;
@@ -3633,21 +3801,24 @@ async function runTool(args: {
       const mission = runtime.missionService.get(missionId);
       const latest = mission?.interventions.find((entry) => entry.id === intervention.id) ?? null;
       if (latest && latest.status !== "open") {
-        return {
+        return buildAskUserResult({
           intervention: latest,
-          awaitingUserResponse: false
-        };
+          awaitingUserResponse: false,
+          blocking: false,
+          outcome: latest.status === "dismissed" ? "declined" : "answered",
+        });
       }
       await sleep(pollIntervalMs);
     }
 
     const mission = runtime.missionService.get(missionId);
     const latest = mission?.interventions.find((entry) => entry.id === intervention.id) ?? intervention;
-    return {
+    return buildAskUserResult({
       intervention: latest,
       awaitingUserResponse: true,
-      timedOut: true
-    };
+      blocking: true,
+      outcome: "timed_out",
+    });
   }
 
   if (name === "get_environment_info") {
diff --git a/apps/web/index.html b/apps/web/index.html
index 4d8ffeb7b..0f5815d2b 100644
--- a/apps/web/index.html
+++ b/apps/web/index.html
@@ -19,7 +19,7 @@
 
     <meta name="theme-color" content="#0a0a0f" />
 
-    <link rel="icon" href="/favicon.svg" />
+    <link rel="icon" type="image/png" href="/images/ade-wordmark.png" />
     <link rel="preconnect" href="https://fonts.googleapis.com" />
     <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin />
     <link
diff --git a/apps/web/package-lock.json b/apps/web/package-lock.json
index e8a72280c..82dd58135 100644
--- a/apps/web/package-lock.json
+++ b/apps/web/package-lock.json
@@ -8,6 +8,7 @@
       "name": "ade-web",
       "version": "0.0.0",
       "dependencies": {
+        "@lobehub/icons-static-svg": "^1.84.0",
         "clsx": "^2.1.1",
         "framer-motion": "^12.34.2",
         "lucide-react": "^0.563.0",
@@ -701,6 +702,12 @@
         "@jridgewell/sourcemap-codec": "^1.4.14"
       }
     },
+    "node_modules/@lobehub/icons-static-svg": {
+      "version": "1.84.0",
+      "resolved": "https://registry.npmjs.org/@lobehub/icons-static-svg/-/icons-static-svg-1.84.0.tgz",
+      "integrity": "sha512-4agZ/xGsf0bTXSofvWHZJev+TTfn9MFvV7x+feYvVTNCmmH9u8ZHxZOpKRU+9+vFZD/QTjfWne/nD1/kwChqhA==",
+      "license": "MIT"
+    },
     "node_modules/@rolldown/pluginutils": {
       "version": "1.0.0-rc.3",
       "resolved": "https://registry.npmjs.org/@rolldown/pluginutils/-/pluginutils-1.0.0-rc.3.tgz",
diff --git a/apps/web/package.json b/apps/web/package.json
index 8f38dba4c..c00b98446 100644
--- a/apps/web/package.json
+++ b/apps/web/package.json
@@ -10,6 +10,7 @@
     "typecheck": "tsc -p tsconfig.json --noEmit"
   },
   "dependencies": {
+    "@lobehub/icons-static-svg": "^1.84.0",
     "clsx": "^2.1.1",
     "framer-motion": "^12.34.2",
     "lucide-react": "^0.563.0",
@@ -31,4 +32,3 @@
     "vite": "^4.5.3"
   }
 }
-
diff --git a/apps/web/public/images/features/agent-chat.png b/apps/web/public/images/features/agent-chat.png
index dc57040e3..33f0b7754 100644
Binary files a/apps/web/public/images/features/agent-chat.png and b/apps/web/public/images/features/agent-chat.png differ
diff --git a/apps/web/public/images/features/cto.png b/apps/web/public/images/features/cto.png
new file mode 100644
index 000000000..4d44db16b
Binary files /dev/null and b/apps/web/public/images/features/cto.png differ
diff --git a/apps/web/public/images/features/lanes.png b/apps/web/public/images/features/lanes.png
index e015876d2..93d1fa77c 100644
Binary files a/apps/web/public/images/features/lanes.png and b/apps/web/public/images/features/lanes.png differ
diff --git a/apps/web/public/images/features/linear-sync.png b/apps/web/public/images/features/linear-sync.png
new file mode 100644
index 000000000..2257c2e39
Binary files /dev/null and b/apps/web/public/images/features/linear-sync.png differ
diff --git a/apps/web/public/images/features/multi-tasking.png b/apps/web/public/images/features/multi-tasking.png
new file mode 100644
index 000000000..42cfda464
Binary files /dev/null and b/apps/web/public/images/features/multi-tasking.png differ
diff --git a/apps/web/public/images/features/run.png b/apps/web/public/images/features/run.png
new file mode 100644
index 000000000..698276fd8
Binary files /dev/null and b/apps/web/public/images/features/run.png differ
diff --git "a/apps/web/public/images/screenshots/Screenshot 2026-04-02 at 2.10.22\342\200\257PM.png" "b/apps/web/public/images/screenshots/Screenshot 2026-04-02 at 2.10.22\342\200\257PM.png"
new file mode 100644
index 000000000..804bec8f6
Binary files /dev/null and "b/apps/web/public/images/screenshots/Screenshot 2026-04-02 at 2.10.22\342\200\257PM.png" differ
diff --git "a/apps/web/public/images/screenshots/Screenshot 2026-04-02 at 2.13.22\342\200\257PM.png" "b/apps/web/public/images/screenshots/Screenshot 2026-04-02 at 2.13.22\342\200\257PM.png"
new file mode 100644
index 000000000..ef4f1d6e7
Binary files /dev/null and "b/apps/web/public/images/screenshots/Screenshot 2026-04-02 at 2.13.22\342\200\257PM.png" differ
diff --git a/apps/web/public/images/screenshots/agent-chat.png b/apps/web/public/images/screenshots/agent-chat.png
new file mode 100644
index 000000000..33f0b7754
Binary files /dev/null and b/apps/web/public/images/screenshots/agent-chat.png differ
diff --git a/apps/web/public/images/screenshots/cto.png b/apps/web/public/images/screenshots/cto.png
new file mode 100644
index 000000000..4d44db16b
Binary files /dev/null and b/apps/web/public/images/screenshots/cto.png differ
diff --git a/apps/web/public/images/screenshots/files copy.png b/apps/web/public/images/screenshots/files copy.png
new file mode 100644
index 000000000..3d8c94049
Binary files /dev/null and b/apps/web/public/images/screenshots/files copy.png differ
diff --git a/apps/web/public/images/screenshots/files.png b/apps/web/public/images/screenshots/files.png
new file mode 100644
index 000000000..3d8c94049
Binary files /dev/null and b/apps/web/public/images/screenshots/files.png differ
diff --git a/apps/web/public/images/screenshots/git history.png b/apps/web/public/images/screenshots/git history.png
new file mode 100644
index 000000000..42bcdbca0
Binary files /dev/null and b/apps/web/public/images/screenshots/git history.png differ
diff --git a/apps/web/public/images/screenshots/lanes.png b/apps/web/public/images/screenshots/lanes.png
new file mode 100644
index 000000000..93d1fa77c
Binary files /dev/null and b/apps/web/public/images/screenshots/lanes.png differ
diff --git a/apps/web/public/images/screenshots/linear-sync.png b/apps/web/public/images/screenshots/linear-sync.png
new file mode 100644
index 000000000..2257c2e39
Binary files /dev/null and b/apps/web/public/images/screenshots/linear-sync.png differ
diff --git a/apps/web/public/images/screenshots/multi-tasking.png b/apps/web/public/images/screenshots/multi-tasking.png
new file mode 100644
index 000000000..42cfda464
Binary files /dev/null and b/apps/web/public/images/screenshots/multi-tasking.png differ
diff --git a/apps/web/public/images/screenshots/prs.png b/apps/web/public/images/screenshots/prs.png
new file mode 100644
index 000000000..77f5f6ece
Binary files /dev/null and b/apps/web/public/images/screenshots/prs.png differ
diff --git a/apps/web/public/images/screenshots/run.png b/apps/web/public/images/screenshots/run.png
new file mode 100644
index 000000000..698276fd8
Binary files /dev/null and b/apps/web/public/images/screenshots/run.png differ
diff --git a/apps/web/public/images/screenshots/workspacegraph.png b/apps/web/public/images/screenshots/workspacegraph.png
new file mode 100644
index 000000000..acc5977d8
Binary files /dev/null and b/apps/web/public/images/screenshots/workspacegraph.png differ
diff --git a/apps/web/public/images/splash/left.png b/apps/web/public/images/splash/left.png
deleted file mode 100644
index f38bb0114..000000000
Binary files a/apps/web/public/images/splash/left.png and /dev/null differ
diff --git a/apps/web/public/images/splash/middle.png b/apps/web/public/images/splash/middle.png
deleted file mode 100644
index 2bef40835..000000000
Binary files a/apps/web/public/images/splash/middle.png and /dev/null differ
diff --git a/apps/web/public/images/splash/right.png b/apps/web/public/images/splash/right.png
deleted file mode 100644
index 73172e3c7..000000000
Binary files a/apps/web/public/images/splash/right.png and /dev/null differ
diff --git a/apps/web/src/app/pages/HomePage.tsx b/apps/web/src/app/pages/HomePage.tsx
index 8ef56a53a..52a895725 100644
--- a/apps/web/src/app/pages/HomePage.tsx
+++ b/apps/web/src/app/pages/HomePage.tsx
@@ -1,14 +1,12 @@
 import {
   ArrowUpRight,
   BookOpen,
-  Bot,
   Download,
   Github,
   GitMerge,
   Layers,
   MonitorCheck,
   Package,
-  Play,
   Workflow,
   Zap,
 } from "lucide-react";
@@ -21,8 +19,9 @@ import { Page } from "../../components/Page";
 import { LINKS } from "../../lib/links";
 import { useDocumentTitle } from "../../lib/useDocumentTitle";
 
-import { HeroVisual } from "../../components/ui/HeroVisual";
+import { ImageAutoSlider } from "../../components/ui/ImageAutoSlider";
 import { ProductShowcase } from "../../components/ProductShowcase";
+import { ProviderOrbit } from "../../components/ProviderOrbit";
 
 /* ──────────────────────────────────────────────
    Competitor apps that ADE replaces
@@ -44,45 +43,41 @@ const COMPETITORS = [
 ] as const;
 
 const ALSO_BUILT_IN = [
-  {
-    icon: Bot,
-    label: "CTO agent",
-    detail: "A long-lived lead for architecture and decisions, with memory and team workflows.",
-  },
   {
     icon: Workflow,
     label: "Missions",
     detail: "Coordinated multi-step runs with visibility across phases — planning, testing, and PRs.",
+    docsPath: "/missions/overview",
   },
   {
     icon: Package,
     label: "Unified memory",
     detail: "Vector-indexed memory across projects and agents so work compounds instead of resetting.",
+    docsPath: "/cto/memory",
   },
   {
     icon: Zap,
     label: "Automations",
     detail: "Event-driven agents on git events, PR activity, or schedules — with guardrails while you are away.",
+    docsPath: "/automations/overview",
   },
   {
     icon: GitMerge,
     label: "Merge conflicts",
     detail: "Resolve conflicts with side-by-side diffs and a focused flow so you can land merges in one place.",
+    docsPath: "/tools/conflicts",
   },
   {
     icon: MonitorCheck,
     label: "Computer use",
     detail: "Screenshot-based verification of agent output when you need proof, not just prose.",
+    docsPath: "/computer-use/overview",
   },
   {
     icon: Layers,
     label: "35+ MCP tools",
     detail: "Built-in server for file ops, git, search, and more — desktop and headless paths.",
-  },
-  {
-    icon: Play,
-    label: "Process monitor",
-    detail: "Track every terminal command agents spawn and inspect output in one timeline.",
+    docsPath: "/configuration/mcp-servers",
   },
 ] as const;
 
@@ -210,7 +205,7 @@ export function HomePage() {
 
           {/* Headline */}
           <Reveal delay={0.14}>
-            <h1 className="mt-4 mx-auto max-w-4xl text-3xl font-bold tracking-tight text-fg sm:text-4xl lg:text-5xl leading-[1.15]">
+            <h1 className="mt-4 mx-auto max-w-4xl text-4xl font-bold tracking-tight text-fg sm:text-5xl lg:text-6xl leading-[1.15]">
               Every AI coding tool.{" "}
               <span className="bg-gradient-to-r from-violet-400 via-accent to-indigo-400 bg-clip-text text-transparent animate-gradient-text">
                 One app.
@@ -220,10 +215,9 @@ export function HomePage() {
 
           {/* Subtitle */}
           <Reveal delay={0.18}>
-            <p className="mx-auto mt-2.5 max-w-2xl text-sm leading-relaxed text-muted-fg sm:text-base">
-              ADE replaces your scattered AI coding tools with a single local-first desktop app.
-              Agent chat, parallel missions, git isolation, memory, automations — everything on
-              your machine.
+            <p className="mx-auto mt-3 max-w-2xl text-base leading-relaxed text-muted-fg sm:text-lg">
+              ADE replaces all your AI tools with a single Agentic Development Environment.
+              Use your existing subscriptions, API keys, or even local models. Fully Open Source!
             </p>
           </Reveal>
 
@@ -249,7 +243,7 @@ export function HomePage() {
           {/* Hero app visual */}
           <Reveal delay={0.26} className="overflow-visible">
             <div className="relative left-1/2 mt-5 w-screen max-w-[100vw] -translate-x-1/2 sm:mt-6 lg:mt-7">
-              <HeroVisual />
+              <ImageAutoSlider />
             </div>
           </Reveal>
         </Container>
@@ -257,25 +251,38 @@ export function HomePage() {
 
       <ProductShowcase />
 
+      <ProviderOrbit />
+
       {/* ── MORE CAPABILITIES ─────────────────── */}
       <section className="border-y border-border/70 bg-card/20 py-16 sm:py-20">
         <Container>
           <Reveal>
             <h2 className="text-2xl font-bold tracking-tight text-fg sm:text-3xl">Also built in</h2>
             <p className="mt-2 max-w-2xl text-sm text-muted-fg sm:text-base">
-              Everything below ships in the same app; the gallery above highlights the visuals we are showcasing on
-              the site right now.
+              More capabilities that ship in the same app — no plugins or extensions required.
             </p>
           </Reveal>
 
-          <div className="mt-10 grid gap-4 sm:grid-cols-2 lg:grid-cols-4">
+          <div className="mt-10 grid gap-4 sm:grid-cols-2 lg:grid-cols-3">
             {ALSO_BUILT_IN.map((cap, idx) => (
               <Reveal key={cap.label} delay={idx * 0.03}>
-                <div className="rounded-xl border border-border/70 bg-card/40 p-5 transition-colors hover:bg-card/60">
-                  <cap.icon className="h-5 w-5 text-accent" />
-                  <div className="mt-3 text-sm font-semibold text-fg">{cap.label}</div>
-                  <div className="mt-1 text-sm text-muted-fg">{cap.detail}</div>
-                </div>
+                <a
+                  href={`https://www.ade-app.dev/docs${cap.docsPath}`}
+                  target="_blank"
+                  rel="noreferrer"
+                  className="group flex flex-col rounded-xl border border-border/70 bg-card/40 p-5 transition-all duration-200 hover:bg-card/60 hover:border-accent/30 hover:shadow-[0_0_30px_rgba(124,58,237,0.08)]"
+                >
+                  <div className="flex items-center gap-3">
+                    <div className="flex h-9 w-9 shrink-0 items-center justify-center rounded-lg bg-accent/10 text-accent">
+                      <cap.icon className="h-4.5 w-4.5" />
+                    </div>
+                    <div className="text-sm font-semibold text-fg">{cap.label}</div>
+                  </div>
+                  <div className="mt-3 flex-1 text-sm leading-relaxed text-muted-fg">{cap.detail}</div>
+                  <div className="mt-3 inline-flex items-center gap-1 text-xs font-medium text-accent/70 transition-colors group-hover:text-accent">
+                    Read docs <ArrowUpRight className="h-3 w-3" />
+                  </div>
+                </a>
               </Reveal>
             ))}
           </div>
diff --git a/apps/web/src/components/ProductShowcase.tsx b/apps/web/src/components/ProductShowcase.tsx
index d878c5c9e..52198dd6b 100644
--- a/apps/web/src/components/ProductShowcase.tsx
+++ b/apps/web/src/components/ProductShowcase.tsx
@@ -1,72 +1,116 @@
-import type { ReactNode } from "react";
-import { motion, useReducedMotion } from "framer-motion";
-import { KeyRound } from "lucide-react";
+import { useState, type ReactNode } from "react";
+import { motion, AnimatePresence, useReducedMotion } from "framer-motion";
+import { ArrowUpRight, X } from "lucide-react";
 import { Container } from "./Container";
 import { cn } from "../lib/cn";
 import { ADE_EASE_OUT } from "../lib/motion";
 
-/**
- * Product screenshots: `apps/web/public/images/features/`
- * Filenames match the assets under `apps/web/public/images/features/`.
- */
-type FeatureAsset = {
-  /** Basename under `/images/features/` (may include spaces). */
+const DOCS_BASE = "https://www.ade-app.dev/docs";
+
+type Feature = {
   image: string;
   name: string;
   tagline: string;
   description: string;
+  docsPath: string;
 };
 
-const FEATURES: FeatureAsset[] = [
+const FEATURES: Feature[] = [
   {
     image: "agent-chat.png",
     name: "Agent chat",
-    tagline: "Native · multi-provider",
+    tagline: "Native multi-provider chat",
+    description:
+      "First-class AI chat sessions with tools and context — Claude, GPT, Gemini, local models, and whatever you already subscribe to.",
+    docsPath: "/chat/overview",
+  },
+  {
+    image: "cto.png",
+    name: "CTO agent",
+    tagline: "Persistent technical lead",
     description:
-      "First-class sessions with tools and context — Claude, Codex, Gemini, local models, and what you already subscribe to.",
+      "A long-lived agent that knows your codebase, remembers prior decisions, and delegates work across your team of agents.",
+    docsPath: "/cto/overview",
   },
   {
     image: "lanes.png",
     name: "Lanes",
     tagline: "Parallel git worktrees",
     description:
-      "Each agent in its own worktree — run builds, tests, and installs at the same time without stepping on the same tree.",
+      "Each agent works in its own isolated worktree — run builds, tests, and installs in parallel without conflicts.",
+    docsPath: "/lanes/overview",
+  },
+  {
+    image: "multi-tasking.png",
+    name: "Multi-tasking",
+    tagline: "Parallel agent sessions",
+    description:
+      "Run multiple agents side-by-side across lanes, each with their own chat, terminal, and file context.",
+    docsPath: "/lanes/overview",
   },
   {
     image: "terminals.png",
     name: "Terminals",
     tagline: "Live PTY output",
-    description: "Shells with live streams so you see every command agents run and every line of output.",
+    description:
+      "Real terminal shells with live streams so you see every command agents run and every line of output.",
+    docsPath: "/tools/terminals",
   },
   {
     image: "files.png",
     name: "Files",
-    tagline: "Edit in place",
-    description: "Jump from chat or review into the file surface without losing context.",
-  },
-  {
-    image: "workspacegraph.png",
-    name: "Workspace graph",
-    tagline: "See how work connects",
-    description: "A visual map of your workspace — including how PRs and lanes relate to the repo.",
+    tagline: "Built-in editor",
+    description:
+      "Jump from chat or review into the file editor without losing context — syntax-highlighted and diff-aware.",
+    docsPath: "/tools/files-editor",
   },
   {
     image: "prs.png",
-    name: "PRs",
+    name: "Pull requests",
     tagline: "Review in one place",
-    description: "Open, review, and track pull requests from the same desktop shell as your agents.",
+    description:
+      "Open, review, and track pull requests from the same desktop shell where your agents work.",
+    docsPath: "/tools/pull-requests",
+  },
+  {
+    image: "workspacegraph.png",
+    name: "Workspace graph",
+    tagline: "Visualize your work",
+    description:
+      "A visual map of your workspace showing how PRs, lanes, and branches relate to each other.",
+    docsPath: "/tools/workspace-graph",
   },
   {
     image: "git history.png",
     name: "Git history",
     tagline: "Timeline in context",
-    description: "Inspect commits and history beside the lane and file you are working in — without leaving ADE.",
+    description:
+      "Inspect commits and history beside the lane and file you are working in — without leaving ADE.",
+    docsPath: "/tools/history",
   },
   {
     image: "modelconfig.png",
     name: "Model configuration",
     tagline: "Your keys and models",
-    description: "Wire providers, models, and API keys in one settings surface — BYOK and subscriptions you already use.",
+    description:
+      "Wire providers, models, and API keys in one settings surface — BYOK with subscriptions you already pay for.",
+    docsPath: "/configuration/ai-providers",
+  },
+  {
+    image: "linear-sync.png",
+    name: "Linear sync",
+    tagline: "Issues to agents",
+    description:
+      "Connect Linear projects so the CTO agent can pick up issues, plan work, and drive them to completion.",
+    docsPath: "/cto/linear",
+  },
+  {
+    image: "run.png",
+    name: "Process runner",
+    tagline: "Monitor every command",
+    description:
+      "Track every terminal process agents spawn — view output, status, and timing in one unified timeline.",
+    docsPath: "/tools/project-home",
   },
 ];
 
@@ -74,30 +118,58 @@ function featureSrc(image: string) {
   return `/images/features/${encodeURIComponent(image)}`;
 }
 
-function FeatureImage({ image, title }: { image: string; title: string }) {
+/** Lightbox overlay for full-screen image view */
+function Lightbox({
+  src,
+  alt,
+  onClose,
+}: {
+  src: string;
+  alt: string;
+  onClose: () => void;
+}) {
   return (
-    <div className="relative aspect-[16/10] w-full overflow-hidden rounded-xl border border-border/50 bg-[#0a0f1a]">
-      <img
-        src={featureSrc(image)}
-        alt={title}
-        className="absolute inset-0 h-full w-full object-cover object-top"
-        loading="lazy"
-        decoding="async"
+    <motion.div
+      className="fixed inset-0 z-[100] flex items-center justify-center bg-black/80 backdrop-blur-sm"
+      initial={{ opacity: 0 }}
+      animate={{ opacity: 1 }}
+      exit={{ opacity: 0 }}
+      transition={{ duration: 0.25, ease: ADE_EASE_OUT }}
+      onClick={onClose}
+    >
+      <button
+        type="button"
+        className="absolute top-5 right-5 z-10 flex h-10 w-10 items-center justify-center rounded-full bg-white/10 text-white/80 transition-colors hover:bg-white/20"
+        onClick={onClose}
+        aria-label="Close"
+      >
+        <X className="h-5 w-5" />
+      </button>
+      <motion.img
+        src={src}
+        alt={alt}
+        className="max-h-[90vh] max-w-[92vw] rounded-xl border border-border/30 object-contain shadow-2xl"
+        initial={{ scale: 0.92, opacity: 0 }}
+        animate={{ scale: 1, opacity: 1 }}
+        exit={{ scale: 0.92, opacity: 0 }}
+        transition={{ duration: 0.3, ease: ADE_EASE_OUT }}
+        onClick={(e) => e.stopPropagation()}
       />
-    </div>
+    </motion.div>
   );
 }
 
-function ShowcaseCard({
-  item,
+function FeatureCard({
+  feature,
   delay,
-  children,
+  onImageClick,
 }: {
-  item: FeatureAsset;
+  feature: Feature;
   delay: number;
-  children: ReactNode;
+  onImageClick: () => void;
 }) {
   const reduceMotion = useReducedMotion();
+
   return (
     <motion.article
       initial={reduceMotion ? undefined : { opacity: 0, y: 20 }}
@@ -107,87 +179,124 @@ function ShowcaseCard({
       whileHover={reduceMotion ? undefined : { y: -2 }}
       className={cn(
         "group flex flex-col overflow-hidden rounded-2xl border border-border/60 bg-card/50 shadow-[inset_0_1px_0_0_rgba(255,255,255,0.04)] transition-shadow duration-300",
-        "hover:border-accent/25 hover:shadow-[0_0_40px_rgba(124,58,237,0.1)]",
+        "hover:border-accent/25 hover:shadow-[0_0_40px_rgba(124,58,237,0.1)]"
       )}
     >
-      {children}
+      {/* Image — zoomed in by default, zooms out on hover */}
+      <button
+        type="button"
+        className="relative aspect-[16/10] w-full overflow-hidden bg-[#0a0f1a] cursor-zoom-in"
+        onClick={onImageClick}
+        aria-label={`View ${feature.name} full screen`}
+      >
+        <img
+          src={featureSrc(feature.image)}
+          alt={feature.name}
+          className="absolute inset-0 h-full w-full object-cover object-top transition-transform duration-500 ease-out scale-[1.15] group-hover:scale-100"
+          loading="lazy"
+          decoding="async"
+        />
+      </button>
+
+      {/* Text content */}
+      <div className="flex flex-1 flex-col p-5 sm:p-6">
+        <h3 className="text-lg font-semibold text-fg">{feature.name}</h3>
+        <p className="mt-0.5 text-sm font-medium text-accent/90">
+          {feature.tagline}
+        </p>
+        <p className="mt-2 flex-1 text-sm leading-relaxed text-muted-fg">
+          {feature.description}
+        </p>
+        <a
+          href={`${DOCS_BASE}${feature.docsPath}`}
+          target="_blank"
+          rel="noreferrer"
+          className="mt-3 inline-flex items-center gap-1 text-sm font-medium text-accent/80 transition-colors hover:text-accent"
+        >
+          View in docs <ArrowUpRight className="h-3.5 w-3.5" />
+        </a>
+      </div>
     </motion.article>
   );
 }
 
 export function ProductShowcase() {
   const reduceMotion = useReducedMotion();
+  const [lightbox, setLightbox] = useState<{
+    src: string;
+    alt: string;
+  } | null>(null);
 
   return (
-    <section
-      id="features"
-      className="relative scroll-mt-20 overflow-hidden border-y border-border/50 bg-[#08080c] py-16 sm:py-24"
-    >
-      <div
-        className="pointer-events-none absolute inset-0 opacity-90"
-        style={{
-          background: [
-            "radial-gradient(ellipse 70% 45% at 20% 0%, rgba(124,58,237,0.12) 0%, transparent 55%)",
-            "radial-gradient(ellipse 50% 40% at 100% 30%, rgba(59,130,246,0.08) 0%, transparent 50%)",
-            "radial-gradient(ellipse 40% 35% at 50% 100%, rgba(236,72,153,0.06) 0%, transparent 45%)",
-          ].join(", "),
-        }}
-      />
-      <div className="pointer-events-none absolute inset-0 bg-[linear-gradient(to_bottom,transparent,rgba(0,0,0,0.35))]" />
-
-      <Container className="relative">
-        <motion.div
-          initial={reduceMotion ? undefined : { opacity: 0, y: 16 }}
-          whileInView={reduceMotion ? undefined : { opacity: 1, y: 0 }}
-          viewport={{ once: true, amount: 0.25 }}
-          transition={{ duration: 0.55, ease: ADE_EASE_OUT }}
-          className="mx-auto max-w-3xl text-center"
-        >
-          <p className="text-xs font-semibold uppercase tracking-[0.2em] text-accent/80">Product</p>
-          <h2 className="mt-3 text-3xl font-bold tracking-tight text-fg sm:text-4xl">
-            The whole loop in{" "}
-            <span className="bg-gradient-to-r from-violet-300 via-fuchsia-300 to-sky-300 bg-clip-text text-transparent">
-              one native window
-            </span>
-          </h2>
-          <p className="mt-3 text-base text-muted-fg sm:text-lg">
-            Chat, lanes, terminals, files, the workspace graph, pull requests, git history, and model setup — all
-            captured from the real app. More capabilities are listed below under &ldquo;Also built in.&rdquo;
-          </p>
-        </motion.div>
-
-        <div className="mt-12 grid grid-cols-1 gap-4 sm:grid-cols-2 sm:gap-5 xl:grid-cols-4">
-          {FEATURES.map((item, idx) => (
-            <ShowcaseCard key={item.image} item={item} delay={idx * 0.04}>
-              <div className="flex flex-1 flex-col p-5 sm:p-6">
-                <FeatureImage image={item.image} title={item.name} />
-                <h3 className="mt-4 text-lg font-semibold text-fg">{item.name}</h3>
-                <p className="mt-0.5 text-sm font-medium text-accent/90">{item.tagline}</p>
-                <p className="mt-2 flex-1 text-sm leading-relaxed text-muted-fg">{item.description}</p>
-              </div>
-            </ShowcaseCard>
-          ))}
-        </div>
+    <>
+      <section
+        id="features"
+        className="relative scroll-mt-20 overflow-hidden border-y border-border/50 bg-[#08080c] py-16 sm:py-24"
+      >
+        <div
+          className="pointer-events-none absolute inset-0 opacity-90"
+          style={{
+            background: [
+              "radial-gradient(ellipse 70% 45% at 20% 0%, rgba(124,58,237,0.12) 0%, transparent 55%)",
+              "radial-gradient(ellipse 50% 40% at 100% 30%, rgba(59,130,246,0.08) 0%, transparent 50%)",
+              "radial-gradient(ellipse 40% 35% at 50% 100%, rgba(236,72,153,0.06) 0%, transparent 45%)",
+            ].join(", "),
+          }}
+        />
+        <div className="pointer-events-none absolute inset-0 bg-[linear-gradient(to_bottom,transparent,rgba(0,0,0,0.35))]" />
 
-        <motion.div
-          initial={reduceMotion ? undefined : { opacity: 0, y: 14 }}
-          whileInView={reduceMotion ? undefined : { opacity: 1, y: 0 }}
-          viewport={{ once: true, amount: 0.35 }}
-          transition={{ duration: 0.5, delay: 0.1, ease: ADE_EASE_OUT }}
-          className="mt-10 flex flex-col items-center gap-4 rounded-2xl border border-accent/20 bg-gradient-to-br from-accent/10 via-card/60 to-transparent px-6 py-8 text-center sm:flex-row sm:text-left"
-        >
-          <div className="flex h-14 w-14 shrink-0 items-center justify-center rounded-2xl border border-accent/30 bg-accent/15 text-accent">
-            <KeyRound className="h-7 w-7" />
-          </div>
-          <div className="min-w-0 flex-1">
-            <h3 className="text-lg font-semibold text-fg">Your keys. Your seats.</h3>
-            <p className="mt-1 text-sm leading-relaxed text-muted-fg">
-              Wire ADE to API keys and subscriptions you already use — we unify the workspace, not your provider
-              billing.
+        <Container className="relative">
+          <motion.div
+            initial={reduceMotion ? undefined : { opacity: 0, y: 16 }}
+            whileInView={reduceMotion ? undefined : { opacity: 1, y: 0 }}
+            viewport={{ once: true, amount: 0.25 }}
+            transition={{ duration: 0.55, ease: ADE_EASE_OUT }}
+            className="mx-auto max-w-3xl text-center"
+          >
+            <p className="text-xs font-semibold uppercase tracking-[0.2em] text-accent/80">
+              Product
+            </p>
+            <h2 className="mt-3 text-3xl font-bold tracking-tight text-fg sm:text-4xl">
+              The whole loop in{" "}
+              <span className="bg-gradient-to-r from-violet-300 via-fuchsia-300 to-sky-300 bg-clip-text text-transparent">
+                one native window
+              </span>
+            </h2>
+            <p className="mt-3 text-base text-muted-fg sm:text-lg">
+              Chat, lanes, terminals, files, the workspace graph, pull requests,
+              git history, and model setup — all captured from the real app.
+              Click any screenshot to view full size.
             </p>
+          </motion.div>
+
+          <div className="mt-12 grid grid-cols-1 gap-5 sm:gap-6 lg:grid-cols-2">
+            {FEATURES.map((feature, idx) => (
+              <FeatureCard
+                key={feature.image}
+                feature={feature}
+                delay={idx * 0.04}
+                onImageClick={() =>
+                  setLightbox({
+                    src: featureSrc(feature.image),
+                    alt: feature.name,
+                  })
+                }
+              />
+            ))}
           </div>
-        </motion.div>
-      </Container>
-    </section>
+        </Container>
+      </section>
+
+      {/* Lightbox */}
+      <AnimatePresence>
+        {lightbox && (
+          <Lightbox
+            src={lightbox.src}
+            alt={lightbox.alt}
+            onClose={() => setLightbox(null)}
+          />
+        )}
+      </AnimatePresence>
+    </>
   );
 }
diff --git a/apps/web/src/components/ProviderOrbit.tsx b/apps/web/src/components/ProviderOrbit.tsx
new file mode 100644
index 000000000..9f449f74f
--- /dev/null
+++ b/apps/web/src/components/ProviderOrbit.tsx
@@ -0,0 +1,204 @@
+import { useState, useEffect } from "react";
+import { motion, useReducedMotion } from "framer-motion";
+import { Container } from "./Container";
+import { Reveal } from "./Reveal";
+import { ADE_EASE_OUT } from "../lib/motion";
+
+import anthropic from "@lobehub/icons-static-svg/icons/anthropic.svg";
+import deepseekColor from "@lobehub/icons-static-svg/icons/deepseek-color.svg";
+import googleColor from "@lobehub/icons-static-svg/icons/google-color.svg";
+import groq from "@lobehub/icons-static-svg/icons/groq.svg";
+import lmstudio from "@lobehub/icons-static-svg/icons/lmstudio.svg";
+import metaColor from "@lobehub/icons-static-svg/icons/meta-color.svg";
+import mistralColor from "@lobehub/icons-static-svg/icons/mistral-color.svg";
+import ollama from "@lobehub/icons-static-svg/icons/ollama.svg";
+import openai from "@lobehub/icons-static-svg/icons/openai.svg";
+import openrouter from "@lobehub/icons-static-svg/icons/openrouter.svg";
+import togetherColor from "@lobehub/icons-static-svg/icons/together-color.svg";
+import vllmColor from "@lobehub/icons-static-svg/icons/vllm-color.svg";
+import xai from "@lobehub/icons-static-svg/icons/xai.svg";
+
+/**
+ * Each icon is hand-placed as a percentage (x%, y%) within the container.
+ * The positions are designed to look organically scattered within a
+ * rough semi-circle / cloud shape — denser toward the center-top,
+ * spreading outward toward the bottom-left and bottom-right.
+ */
+type Provider = {
+  name: string;
+  icon: string;
+  invert?: boolean;
+  /** [x%, y%] position within the container */
+  pos: [number, number];
+};
+
+const PROVIDERS: Provider[] = [
+  // Top cluster — tight
+  { name: "Anthropic",  icon: anthropic,     invert: true,  pos: [38, 6] },
+  { name: "OpenAI",     icon: openai,        invert: true,  pos: [56, 3] },
+  { name: "Google",     icon: googleColor,                  pos: [48, 22] },
+
+  // Mid band — a bit wider
+  { name: "DeepSeek",   icon: deepseekColor,                pos: [27, 18] },
+  { name: "Mistral",    icon: mistralColor,                 pos: [68, 14] },
+  { name: "xAI",        icon: xai,           invert: true,  pos: [33, 38] },
+  { name: "Groq",       icon: groq,          invert: true,  pos: [62, 34] },
+  { name: "Meta",       icon: metaColor,                    pos: [49, 44] },
+
+  // Outer spread — widest, lower
+  { name: "Together",   icon: togetherColor,                pos: [16, 52] },
+  { name: "OpenRouter",  icon: openrouter,   invert: true,  pos: [78, 48] },
+  { name: "Ollama",     icon: ollama,        invert: true,  pos: [8, 72] },
+  { name: "LM Studio",  icon: lmstudio,     invert: true,  pos: [88, 68] },
+  { name: "vLLM",       icon: vllmColor,                    pos: [30, 70] },
+];
+
+export function ProviderOrbit() {
+  const [width, setWidth] = useState(0);
+  const reduceMotion = useReducedMotion();
+
+  useEffect(() => {
+    const update = () => setWidth(window.innerWidth);
+    update();
+    window.addEventListener("resize", update);
+    return () => window.removeEventListener("resize", update);
+  }, []);
+
+  if (width === 0) return null;
+
+  const baseWidth = Math.min(width * 0.7, 520);
+  const aspectHeight = baseWidth * 0.52;
+
+  const iconSize =
+    width < 480
+      ? Math.max(30, baseWidth * 0.075)
+      : width < 768
+      ? Math.max(34, baseWidth * 0.08)
+      : Math.max(38, baseWidth * 0.085);
+
+  return (
+    <section className="relative overflow-hidden py-10 sm:py-14">
+      {/* Background glow */}
+      <div
+        className="pointer-events-none absolute inset-0"
+        style={{
+          background: [
+            "radial-gradient(ellipse 60% 50% at 50% 60%, rgba(124,58,237,0.10) 0%, transparent 70%)",
+            "radial-gradient(ellipse 40% 30% at 30% 70%, rgba(59,130,246,0.06) 0%, transparent 50%)",
+          ].join(", "),
+        }}
+      />
+
+      <Container className="relative">
+        <Reveal>
+          <div className="mx-auto max-w-3xl text-center">
+            <p className="text-xs font-semibold uppercase tracking-[0.2em] text-accent/80">
+              Providers
+            </p>
+            <h2 className="mt-3 text-3xl font-bold tracking-tight text-fg sm:text-4xl">
+              Works with{" "}
+              <span className="bg-gradient-to-r from-violet-300 via-fuchsia-300 to-sky-300 bg-clip-text text-transparent">
+                any AI model
+              </span>
+            </h2>
+            <p className="mt-3 text-base text-muted-fg sm:text-lg">
+              Bring your own API keys, use existing subscriptions, or run local models.
+              ADE unifies them all in one workspace.
+            </p>
+          </div>
+        </Reveal>
+
+        <div className="mt-6 flex justify-center">
+          <div
+            className="relative"
+            style={{ width: baseWidth, height: aspectHeight }}
+          >
+            {/* Radial glow behind icons */}
+            <div className="pointer-events-none absolute inset-0 flex justify-center">
+              <div
+                className="rounded-full blur-3xl"
+                style={{
+                  width: baseWidth * 0.75,
+                  height: aspectHeight * 1.1,
+                  marginTop: -aspectHeight * 0.05,
+                  background:
+                    "radial-gradient(ellipse at 50% 30%, rgba(124,58,237,0.14) 0%, transparent 70%)",
+                }}
+              />
+            </div>
+
+            {PROVIDERS.map((p, i) => {
+              const left = (p.pos[0] / 100) * baseWidth - iconSize / 2;
+              const top = (p.pos[1] / 100) * aspectHeight - iconSize / 2;
+              const tooltipAbove = p.pos[1] < 40;
+
+              return (
+                <motion.div
+                  key={p.name}
+                  className="absolute flex flex-col items-center group"
+                  style={{ left, top, zIndex: 5 }}
+                  initial={reduceMotion ? undefined : { opacity: 0, scale: 0.4 }}
+                  whileInView={reduceMotion ? undefined : { opacity: 1, scale: 1 }}
+                  viewport={{ once: true, amount: 0.1 }}
+                  transition={{
+                    duration: 0.5,
+                    delay: i * 0.045,
+                    ease: ADE_EASE_OUT,
+                  }}
+                >
+                  <motion.div
+                    animate={
+                      reduceMotion
+                        ? undefined
+                        : { y: [0, -7, 0] }
+                    }
+                    transition={{
+                      duration: 3 + (i % 3) * 0.7,
+                      repeat: Infinity,
+                      ease: "easeInOut",
+                      delay: i * 0.2,
+                    }}
+                  >
+                    <div
+                      className="flex items-center justify-center rounded-xl border border-border/50 bg-white/[0.06] p-2 transition-all duration-300 hover:scale-110 hover:border-accent/40 hover:bg-white/[0.12] hover:shadow-[0_0_24px_rgba(124,58,237,0.25)]"
+                      style={{ width: iconSize, height: iconSize }}
+                    >
+                      <img
+                        src={p.icon}
+                        alt={p.name}
+                        className="h-full w-full object-contain"
+                        style={{
+                          filter: p.invert
+                            ? "invert(1) brightness(0.9)"
+                            : undefined,
+                        }}
+                      />
+                    </div>
+                  </motion.div>
+
+                  {/* Tooltip */}
+                  <div
+                    className={`absolute ${
+                      tooltipAbove
+                        ? "top-[calc(100%+8px)]"
+                        : "bottom-[calc(100%+8px)]"
+                    } hidden group-hover:block whitespace-nowrap rounded-lg bg-card border border-border/60 px-2.5 py-1 text-xs font-medium text-fg shadow-lg text-center`}
+                  >
+                    {p.name}
+                    <div
+                      className={`absolute left-1/2 -translate-x-1/2 w-2.5 h-2.5 rotate-45 bg-card border border-border/60 ${
+                        tooltipAbove
+                          ? "bottom-full -mb-1.5 border-b-0 border-r-0"
+                          : "top-full -mt-1.5 border-t-0 border-l-0"
+                      }`}
+                    />
+                  </div>
+                </motion.div>
+              );
+            })}
+          </div>
+        </div>
+      </Container>
+    </section>
+  );
+}
diff --git a/apps/web/src/components/SiteHeader.tsx b/apps/web/src/components/SiteHeader.tsx
index e20b608a7..755699268 100644
--- a/apps/web/src/components/SiteHeader.tsx
+++ b/apps/web/src/components/SiteHeader.tsx
@@ -47,8 +47,6 @@ export function SiteHeader() {
 
   const items = useMemo<NavItem[]>(
     () => [
-      { label: "Features", to: "/#features", kind: "internal" },
-      { label: "Get Started", to: "/#quickstart", kind: "internal" },
       { label: "Docs", to: LINKS.docs, kind: "external" },
     ],
     []
@@ -68,7 +66,7 @@ export function SiteHeader() {
               <img
                 src="/images/ade-wordmark.png"
                 alt=""
-                className="h-8 w-auto object-contain object-left sm:h-9"
+                className="h-9 w-auto object-contain object-left sm:h-10"
                 width={180}
                 height={36}
                 decoding="async"
@@ -102,13 +100,13 @@ export function SiteHeader() {
             )}
 
             <a
-              className="focus-ring ml-1 inline-flex h-9 w-9 items-center justify-center rounded-lg border border-border/70 bg-card/60 text-muted-fg transition-colors hover:text-fg hover:bg-card"
+              className="focus-ring ml-1 inline-flex h-9 items-center gap-2 rounded-lg border border-border/70 bg-card/60 px-3 text-sm font-medium text-muted-fg transition-colors hover:text-fg hover:bg-card"
               href={LINKS.github}
               target="_blank"
               rel="noreferrer"
-              aria-label="GitHub"
             >
               <Github className="h-4 w-4" />
+              GitHub
             </a>
 
             <LinkButton to={LINKS.releases} variant="primary" size="sm" target="_blank" rel="noreferrer" className="ml-2">
diff --git a/apps/web/src/components/ui/ImageAutoSlider.tsx b/apps/web/src/components/ui/ImageAutoSlider.tsx
new file mode 100644
index 000000000..5568bcaef
--- /dev/null
+++ b/apps/web/src/components/ui/ImageAutoSlider.tsx
@@ -0,0 +1,87 @@
+const SCREENSHOTS = [
+  { src: "/images/screenshots/agent-chat.png", alt: "Agent chat" },
+  { src: "/images/screenshots/cto.png", alt: "CTO agent" },
+  { src: "/images/screenshots/files.png", alt: "File explorer" },
+  { src: "/images/screenshots/git history.png", alt: "Git history" },
+  { src: "/images/screenshots/lanes.png", alt: "Lanes" },
+  { src: "/images/screenshots/linear-sync.png", alt: "Linear sync" },
+  { src: "/images/screenshots/multi-tasking.png", alt: "Multi-tasking" },
+  { src: "/images/screenshots/prs.png", alt: "Pull requests" },
+  { src: "/images/screenshots/run.png", alt: "Process runner" },
+  { src: "/images/screenshots/workspacegraph.png", alt: "Workspace graph" },
+];
+
+const FEATURES = [
+  { src: "/images/features/agent-chat.png", alt: "Agent chat feature" },
+  { src: "/images/features/cto.png", alt: "CTO feature" },
+  { src: "/images/features/files.png", alt: "Files feature" },
+  { src: "/images/features/git history.png", alt: "Git history feature" },
+  { src: "/images/features/linear-sync.png", alt: "Linear sync feature" },
+  { src: "/images/features/modelconfig.png", alt: "Model config" },
+  { src: "/images/features/multi-tasking.png", alt: "Multi-tasking feature" },
+  { src: "/images/features/prs.png", alt: "Pull requests feature" },
+  { src: "/images/features/run.png", alt: "Run feature" },
+  { src: "/images/features/terminals.png", alt: "Terminals" },
+  { src: "/images/features/workspacegraph.png", alt: "Workspace graph feature" },
+];
+
+const ALL_IMAGES = [...SCREENSHOTS, ...FEATURES];
+
+export function ImageAutoSlider() {
+  // Duplicate the array for seamless infinite loop
+  const doubled = [...ALL_IMAGES, ...ALL_IMAGES];
+
+  return (
+    <>
+      <style>{`
+        @keyframes autoslide {
+          0% { transform: translateX(0); }
+          100% { transform: translateX(-50%); }
+        }
+        .autoslide-track {
+          animation: autoslide 180s linear infinite;
+        }
+        .autoslide-mask {
+          mask-image: linear-gradient(
+            to right,
+            transparent 0%,
+            black 8%,
+            black 92%,
+            transparent 100%
+          );
+          -webkit-mask-image: linear-gradient(
+            to right,
+            transparent 0%,
+            black 8%,
+            black 92%,
+            transparent 100%
+          );
+        }
+      `}</style>
+
+      <div
+        className="autoslide-mask relative w-full overflow-hidden py-4"
+        role="region"
+        aria-label="ADE product screenshots"
+      >
+        <div className="autoslide-track flex w-max items-center gap-5 sm:gap-6">
+          {doubled.map((img, i) => (
+            <div
+              key={`${img.src}-${i}`}
+              className="shrink-0 w-[42rem] h-[26rem] md:w-[56rem] md:h-[34rem] lg:w-[72rem] lg:h-[44rem] overflow-hidden rounded-xl border border-border/50 transition-transform duration-300 hover:scale-[1.02]"
+            >
+              <img
+                src={img.src}
+                alt={img.alt}
+                className="h-full w-full object-cover object-top"
+                draggable={false}
+                loading="lazy"
+                decoding="async"
+              />
+            </div>
+          ))}
+        </div>
+      </div>
+    </>
+  );
+}
diff --git a/automations/templates.mdx b/automations/templates.mdx
index 6a7dcae01..488acbf4a 100644
--- a/automations/templates.mdx
+++ b/automations/templates.mdx
@@ -6,46 +6,138 @@ icon: "layer-group"
 
 ## Automation Templates
 
-ADE ships with the following built-in templates. Enable them from **Automations → Templates**.
+Templates are pre-configured automation rules that you can enable with one click. Each template comes with a tested trigger, execution configuration, model settings, guardrails, and prompt — all editable after creation.
+
+Navigate to **Automations > Templates** to browse and activate templates.
+
+### Available Templates
 
 <CardGroup cols={2}>
-  <Card title="PR Reviewer" icon="code-pull-request">
-    **Trigger:** `git.pr_opened`
-    **Execution:** `agent-session`
+  <Card title="Daily Agent Brief" icon="chat-circle-text">
+    **Trigger:** `schedule` — weekdays at 9am
+    **Execution:** Agent session
+
+    Summarizes repo activity since the last weekday brief — commits, PRs, missions, and risks. Runs in an automation-only chat thread and saves the transcript in Automations history. Uses project memory and procedures as context sources.
+  </Card>
+  <Card title="PR Review Session" icon="code-pull-request">
+    **Trigger:** `git.pr_opened` on `main`
+    **Execution:** Agent session
 
-    Automatically reviews every PR opened in ADE. Checks for missing error handling, untested code paths, and obvious logic bugs. Posts a structured review comment.
+    Reviews every new PR for risky changes, missing tests, and release impact. Posts concrete findings citing specific files and checks. Uses high thinking level for thorough analysis.
   </Card>
-  <Card title="Test Guardian" icon="shield">
-    **Trigger:** `git.commit`
-    **Execution:** `agent-session`
+  <Card title="Linear Triage Mission" icon="shield-check">
+    **Trigger:** `linear.issue_created` (team: ENG)
+    **Execution:** Mission
 
-    Runs your test suite on every commit. If tests fail, posts a comment on the associated PR with the failure summary and a suggested fix.
+    Launches a mission when new Linear issues arrive. The mission triages the issue — recommends an owner, severity level, and next action — using mission-level tooling for deeper context gathering.
   </Card>
-  <Card title="Daily Standup" icon="sun">
-    **Trigger:** `schedule` — `0 9 * * 1-5`
-    **Execution:** `agent-session`
+  <Card title="Nightly Test Sweep" icon="test-tube">
+    **Trigger:** `schedule` — weekdays at 2am
+    **Execution:** Built-in task (run-tests)
 
-    Every weekday morning, generates a summary of all lane activity from the previous day: commits made, PRs opened/merged, missions completed, and any active conflicts.
+    Runs your configured test suite on a nightly schedule without starting a mission or agent chat. Results are saved as automation artifacts. Requires a test suite ID to be configured.
   </Card>
-  <Card title="Dependency Updater" icon="arrow-rotate-right">
-    **Trigger:** `schedule` — `0 2 * * 0` (weekly, Sunday 2am)
-    **Execution:** `mission`
+  <Card title="Push Conflict Scan" icon="bug">
+    **Trigger:** `git.push` on `main`
+    **Execution:** Built-in task (predict-conflicts)
 
-    Weekly check for outdated dependencies. Opens a draft PR with the proposed updates and a compatibility assessment for each changed package.
+    Runs conflict prediction after every push to the default branch. Surfaces lanes that are now at risk of merge conflicts so you can address them before they block work.
   </Card>
 </CardGroup>
 
 ---
 
+## Using a Template
+
+<Steps>
+  <Step title="Browse templates">
+    Open **Automations > Templates**. Each card shows the trigger type, execution kind, and a description of what the template does.
+  </Step>
+  <Step title="Click Use Template">
+    Click the **Use** button on any template. ADE creates a new automation rule pre-filled with the template's configuration.
+  </Step>
+  <Step title="Customize (optional)">
+    The rule opens in the automation editor where you can adjust:
+    - **Trigger conditions** — change the branch, schedule, team, or event type
+    - **Prompt** — refine what the agent should focus on
+    - **Model configuration** — change the model, thinking level, or permission mode
+    - **Guardrails** — adjust duration limits, confidence thresholds
+    - **Outputs** — change where results are routed
+  </Step>
+  <Step title="Enable the rule">
+    Toggle the rule to **enabled**. It will start firing on its next matching trigger.
+  </Step>
+</Steps>
+
+<Tip>
+Templates use `anthropic/claude-sonnet-4-6` as the default model with medium or high thinking levels. You can switch to any configured provider and model after creating the rule.
+</Tip>
+
+---
+
+## Template Anatomy
+
+Every template generates a rule with these fields:
+
+| Field | Description |
+|-------|-------------|
+| **Name** | Human-readable identifier shown in the Automations list |
+| **Trigger** | The event or schedule that fires the rule |
+| **Execution kind** | `agent-session`, `mission`, or `built-in` — determines what runs |
+| **Executor mode** | Always `automation-bot` for template-created rules |
+| **Prompt** | The instruction the agent receives (only for agent-session and mission kinds) |
+| **Model config** | Which model and thinking level to use |
+| **Tool palette** | Which MCP tool categories the agent can access (repo, git, github, linear, memory, mission, tests) |
+| **Context sources** | What context is injected (project-memory, procedures, lane packs) |
+| **Memory mode** | How the automation accesses ADE's memory system (`project`, `automation-plus-project`) |
+| **Guardrails** | Max duration, confidence threshold, and other safety limits |
+| **Outputs** | How results are delivered (comment-only, create artifact, etc.) |
+| **Review profile** | `quick` for lightweight checks, `full` for thorough analysis |
+| **Billing code** | Cost tracking identifier prefixed with `auto:` |
+
+---
+
 ## Outputs and Routing
 
-Automations can produce the following output types. Configure output routing in the automation settings to control where results land.
+Automations can produce several output types. Configure output routing in the automation rule's settings to control where results land.
+
+| Output Type | Description | Example |
+|-------------|-------------|---------|
+| **Commits** | Code changes committed to a branch in a specific lane | Test fixes, dependency updates |
+| **Pull Requests** | New or updated PRs on GitHub | Dependency update PRs, auto-generated feature PRs |
+| **Linear Updates** | Issue state changes, comments, label assignments | Moving a triaged issue to "Ready" |
+| **Notifications** | In-ADE toast notifications or macOS system notifications | "Nightly tests passed" or "3 lanes have conflicts" |
+| **Lane Pack Updates** | Triggers a refresh of a lane's context pack | After an automation modifies files in a lane |
+| **Chat Messages** | Posts a message into a specific lane's chat | Review findings posted to the PR's lane chat |
+| **Artifacts** | Saved output files (reports, logs, summaries) visible in Automations history | Test sweep results, daily brief summary |
 
-| Output Type | Description |
-|---|---|
-| Commits | Committed changes to a branch in a specific lane |
-| Pull Requests | New or updated PRs on GitHub |
-| Linear Updates | Issue status changes, comments, assignments |
-| Notifications | In-ADE toast notifications or macOS system notifications |
-| Lane Pack Updates | Triggers a refresh of a lane's context pack |
-| Chat Messages | Posts a message into a specific lane's chat |
+### Output Disposition
+
+Each rule's output disposition controls how the automation's findings are delivered:
+
+- **Comment-only** — results are saved as automation artifacts and optionally posted as comments (to PRs, Linear issues, or lane chats). No code changes are made.
+- **Commit** — the automation can make code changes and commit them. Use this for rules like dependency updates that produce actual code modifications.
+- **Draft PR** — the automation creates a draft PR with its changes for human review before merging.
+
+<Warning>
+Rules with `commit` or `draft PR` disposition can modify your codebase. Always use guardrails (max duration, confidence threshold) and consider starting with `review` mode, which pauses for your approval before the automation acts.
+</Warning>
+
+---
+
+## Creating Custom Templates
+
+ADE does not currently support saving your own automation rules as reusable templates. However, you can duplicate an existing rule (right-click > **Duplicate**) to create a copy with all settings preserved, then modify it for a different use case.
+
+---
+
+## Next Steps
+
+<CardGroup cols={2}>
+  <Card title="Automation Rules Guide" icon="scroll" href="/guides/automation-rules">
+    Step-by-step guide for creating custom automation rules from scratch.
+  </Card>
+  <Card title="Guardrails" icon="shield" href="/automations/guardrails">
+    Configure safety limits, review modes, and intervention policies for automation rules.
+  </Card>
+</CardGroup>
diff --git a/changelog/v1.0.3.mdx b/changelog/v1.0.3.mdx
index 03c049eca..411f0d4de 100644
--- a/changelog/v1.0.3.mdx
+++ b/changelog/v1.0.3.mdx
@@ -1,6 +1,6 @@
 ---
 title: "v1.0.3"
-description: "Release notes for ADE v1.0.3 — April 1, 2026"
+description: "Release notes for ADE v1.0.3 — April 2, 2026"
 ---
 
 ## Added
@@ -14,6 +14,14 @@ description: "Release notes for ADE v1.0.3 — April 1, 2026"
 - **ADE MCP tool namespacing** — PR issue resolution tools exposed with `ade:` prefix in agent sessions
 - **Codex MCP override mapping** — ADE server settings correctly forwarded to Codex MCP launches
 - **Reusable JSON-RPC server** — Refactored MCP socket handling into a shared server module
+- **Packed session grid** — Resizable tile layout for the Work view with drag-handle resizing and bin-packing arrangement
+- **Multi-select agent questions** — Agent question modal supports toggling multiple options with Markdown/HTML preview
+- **New Chat quick-create** — Faster optimistic session opening with immediate tab activation
+- **Turn recap UI** — Summary row at the end of each turn showing tool invocation counts and task progress
+- **Claude tool-use tracking** — Per-invocation lifecycle tracking with start/complete events for work log status indicators
+- **MCP initialize probe** — Pre-checks MCP server availability before starting Claude sessions
+- **Inline AskUserQuestion UI** — Agent questions now render inline in the chat transcript with a unified `ask_user` tool, replacing the modal-only flow. Supports both single-select and multi-select answers with Markdown preview.
+- **AskUserQuestion tool_result emission** — Agent receives the user's answer as a proper `tool_result` message, enabling the agent to continue its workflow without re-prompting
 
 ## Changed
 
@@ -24,6 +32,12 @@ description: "Release notes for ADE v1.0.3 — April 1, 2026"
 - **MCP config hardening** — ADE query controls enforced across all MCP tool invocations
 - **Chat abort handling** — Aborts treated as interruptions that preserve chat state instead of clearing it
 - **Rebase route selection** — Active rebase needs now correctly resolved when selecting navigation routes
+- **Terminal renderer** — Simplified from WebGL/canvas/DOM to WebGL-first with DOM fallback; added fit recovery with retry on invalid dimensions
+- **Work log headings** — Human-readable labels replace generic tool identifiers; default visible entries increased to 4
+- **Model catalog filtering** — Model selector supports `available-only` mode to restrict picker to configured providers
+- **Git stash actions** — Pop, drop, and clear now refresh workspace metadata after completion
+- **Composer sizing** — New compact and grid-tile sizing modes
+- **Stale session detection** — Session expiry checks now also match "session expired" error strings, preventing zombie sessions from blocking new agent launches
 
 ## Fixed
 
@@ -33,3 +47,5 @@ description: "Release notes for ADE v1.0.3 — April 1, 2026"
 - **Thinking indicator positioning** — Fixed CSS positioning of the thinking/reasoning indicator in chat messages
 - **Artifact URL handling** — Textual artifact URLs are now ignored (only real PR branch pushes trigger updates)
 - **projectRoot forwarding** — Codex MCP launches now correctly receive the project root path
+- **Tree refresh stale closure** — Fixed stale closure in the FilesPage tree refresh drain loop that caused flaky re-renders and test failures
+- **Database backup tracking** — Removed tracked `.bak` database files from the repository and added `*.bak` to `.gitignore`
diff --git a/chat/capabilities.mdx b/chat/capabilities.mdx
index 7c90aece2..f85b46abc 100644
--- a/chat/capabilities.mdx
+++ b/chat/capabilities.mdx
@@ -96,6 +96,12 @@ When a task is too large for a single chat session, escalate it to a Mission wit
 
 ---
 
+## Agent Questions and Multi-Select
+
+When an agent needs input — permission to proceed, a choice between options, or a freeform answer — a question modal appears. Questions with predefined options support **multi-select**: toggle multiple values and preview each option's description rendered as Markdown. The modal also supports freeform text input alongside option selection.
+
+---
+
 ## Long-Running Tool Calls
 
 Tool calls that take more than a few seconds are displayed as **expandable blocks** in the chat message list:
diff --git a/cto/linear.mdx b/cto/linear.mdx
index 42b305d18..0fa99c547 100644
--- a/cto/linear.mdx
+++ b/cto/linear.mdx
@@ -4,40 +4,193 @@ description: "Connect Linear for bidirectional issue sync — the CTO reads from
 icon: "arrow-right-arrow-left"
 ---
 
-## Linear Integration
+## How the CTO Uses Linear
 
-The CTO is the owner of ADE's bidirectional Linear integration. Connecting Linear unlocks a tight feedback loop between project management and development.
+The CTO is the owner of ADE's bidirectional Linear integration. Once connected, the CTO monitors your Linear workspace for issue changes, routes incoming issues to the right execution target (worker, mission, or PR convergence), and pushes updates back to Linear when work completes.
 
-### Connecting Linear
+This is not a simple webhook mirror — the CTO makes intelligent decisions about how to handle each issue based on configurable workflow definitions. It tracks issue state transitions, matches triggers against assignees/labels/priorities, and orchestrates the full lifecycle from intake to closeout.
+
+---
+
+## Connecting Linear
 
 <Steps>
   <Step title="Open CTO > Linear sub-tab">
-    Click the **Linear** sub-tab in the CTO tab.
+    Click the **Linear** sub-tab in the CTO tab from the sidebar.
   </Step>
   <Step title="Authenticate">
     Click **Connect Linear**. Choose between:
-    - **OAuth** (recommended) — authorizes ADE to access Linear on your behalf with scoped permissions
-    - **Personal Access Token** — paste a token from your Linear account settings
+    - **OAuth** (recommended) — authorizes ADE to access Linear on your behalf with scoped permissions. ADE stores the token securely using Electron's safeStorage.
+    - **Personal Access Token** — paste a token from your Linear account settings (`Settings > API > Personal API keys`)
+  </Step>
+  <Step title="Select projects and teams">
+    ADE discovers your Linear workspace and lists accessible projects and teams. Select which ones the CTO should monitor. You can change this later without re-authenticating.
+  </Step>
+  <Step title="Configure workflow definitions">
+    Set up workflow rules that map Linear events to ADE actions. Each workflow definition specifies:
+    - **Trigger conditions** — which issues match (assignee, labels, priority, team, state transitions)
+    - **Execution target** — what ADE does (launch a mission, start a worker session, open a PR convergence run)
+    - **Lane selection** — where the work happens (primary lane, fresh issue-specific lane, or operator-prompted)
+    - **Closeout policy** — what happens when the work completes (update issue state, add comments, apply labels)
+  </Step>
+</Steps>
+
+---
+
+## Workflow Definitions
+
+A workflow definition is the core configuration unit for Linear integration. Each definition describes a complete automation pipeline: which issues to act on, how to process them, and what to do when they complete.
+
+### Trigger Conditions
+
+Triggers filter which Linear issues a workflow applies to. You can combine multiple conditions — all must match for the workflow to fire.
+
+| Condition | Description |
+|-----------|-------------|
+| **Assignees** | Only issues assigned to specific users |
+| **Labels** | Only issues with specific Linear labels |
+| **Project slugs** | Only issues in specific Linear projects |
+| **Team keys** | Only issues belonging to specific teams |
+| **Priority** | Filter by priority level: urgent, high, normal, low, or none |
+| **State transitions** | Fire only when an issue moves between specific states (e.g., from "Backlog" to "In Progress") |
+| **Metadata tags** | Custom tags added by the CTO for internal routing |
+
+### Execution Targets
+
+When a workflow triggers, the CTO dispatches work to one of these targets:
+
+| Target | When to use |
+|--------|-------------|
+| **Mission** | Complex issues that need a structured plan, multiple steps, and validation |
+| **Employee session** | Issues where a single agent chat session can handle the work |
+| **Worker run** | Background worker execution managed by the CTO |
+| **PR resolution** | Issues that map directly to an existing PR that needs convergence work |
+| **Review gate** | Issues that need human review before the CTO proceeds |
+
+Each target can be configured with a worker selector (by ID, slug, or capability), model configuration, permission modes, and session templates.
+
+### Lane Selection
+
+| Mode | Behavior |
+|------|----------|
+| **Primary** | Work happens in the primary lane (the main checkout) |
+| **Fresh issue lane** | ADE creates a new lane specifically for this issue, branching from the default branch |
+| **Operator prompt** | The CTO asks the human operator which lane to use before starting |
+
+### PR Timing
+
+| Setting | Behavior |
+|---------|----------|
+| **None** | No PR is created automatically |
+| **After start** | A draft PR is opened as soon as the first commit lands |
+| **After target complete** | PR is opened only after the execution target reports success |
+
+### Closeout Policy
+
+When a workflow run completes (successfully or not), the closeout policy determines what happens in Linear:
+
+- **Success state** — move the issue to this Linear state (e.g., "Done")
+- **Failure state** — move the issue to this state on failure (e.g., "Blocked")
+- **Comments** — add a completion or failure comment with configurable templates
+- **Labels** — apply specific labels on completion
+- **Reopen on failure** — automatically reopen the issue if the workflow fails
+- **Artifact mode** — attach proof artifacts as Linear attachments or as links in comments
+
+---
+
+## Inbound Flow (Linear to ADE)
+
+When a Linear issue changes and matches a workflow trigger, the CTO processes it through a pipeline:
+
+<Steps>
+  <Step title="Intake">
+    The Linear sync service detects the issue change (new issue, state transition, assignment change). It normalizes the issue data and checks if it matches any enabled workflow.
+  </Step>
+  <Step title="Queue">
+    Matched issues enter a sync queue. The queue deduplicates rapid changes (e.g., multiple quick state updates) and batches processing for efficiency. Issues that are already being processed or have reached a terminal state are skipped.
   </Step>
-  <Step title="Select projects">
-    ADE discovers your Linear workspace and lists all accessible projects. Select the projects you want the CTO to monitor and sync.
+  <Step title="Routing">
+    The CTO's routing service evaluates which workflow to apply, resolves the execution target and lane selection, and prepares the dispatch context.
   </Step>
-  <Step title="Configure sync rules">
-    Set up workflow definitions: which Linear issue statuses map to which ADE actions (e.g., "In Progress" → spawn a worker, "In Review" → link the PR, "Done" → close the lane).
+  <Step title="Dispatch">
+    The dispatcher creates the execution target — starts a mission, opens a chat session, or launches a worker run. The issue's description, comments, and attachments are injected as context.
+  </Step>
+  <Step title="Tracking">
+    A workflow run is created with per-step status tracking. The CTO monitors the run and updates Linear as milestones are reached.
   </Step>
 </Steps>
 
-### What the CTO can do with Linear
+### Reconciliation
+
+The sync service runs a periodic reconciliation loop (default: every 30 seconds) to catch any issues that were missed by event-based triggers. It compares the tracked issue state against Linear's current state and re-queues any discrepancies.
+
+---
+
+## Outbound Flow (ADE to Linear)
+
+The CTO pushes updates back to Linear through the outbound service:
+
+- **Issue state updates** — move issues to configured states when work completes or fails
+- **Workpad comments** — maintain a persistent "workpad" comment on each issue that the CTO updates with progress notes, PR links, and analysis results. The workpad uses content hashing to avoid duplicate updates.
+- **New sub-issues** — when the CTO discovers additional scope during implementation, it can create child issues in Linear
+- **Label management** — apply or remove labels based on workflow outcomes
+- **Proof artifacts** — attach mission artifacts, test reports, or screenshots as Linear attachments or comment links
+
+---
+
+## Sync Dashboard
 
-**Inbound (Linear → ADE)**:
-- Detect issues assigned to you or matching configured criteria and route them to missions or workers
-- React to status transitions (e.g., issue moved to "In Progress" → create a lane and start a worker)
-- Read issue descriptions, attachments, and comments as context for agent work
+The Linear sub-tab in the CTO view shows a live sync dashboard with:
+
+- **Queue status** — how many issues are queued, processing, or completed
+- **Active workflow runs** — which issues have in-flight execution targets
+- **Recent sync events** — a timeline of all sync activity with issue IDs, event types, and outcomes
+- **Error log** — any sync failures with diagnostic details
+
+---
+
+## Linear vs. Automation Rules
+
+Both the CTO's Linear integration and Automation rules can react to Linear events. They serve different purposes:
+
+| Aspect | CTO Linear Integration | Automation Rules |
+|--------|----------------------|------------------|
+| **Intelligence** | Stateful — tracks issue lifecycle, makes routing decisions, manages workflow runs | Stateless — fires once per trigger, no memory of past events |
+| **Scope** | Full workflow from intake to closeout | Single action per trigger |
+| **Configuration** | Workflow definitions with triggers, targets, and closeout policies | Simple trigger-action pairs |
+| **Best for** | Ongoing issue management, complex routing, PR convergence | Simple notifications, one-shot tasks, scheduled checks |
+
+The two systems are complementary. Use automation rules for simple event-response patterns. Use the CTO's Linear integration for stateful, intelligent issue management.
+
+<Note>
+Automation rules that trigger on Linear events use the `linear.issue_created` or `linear.issue_updated` trigger types (separate from the CTO's sync). They do not conflict with the CTO's workflows — both can be active simultaneously.
+</Note>
+
+---
+
+## Troubleshooting
+
+<AccordionGroup>
+  <Accordion title="Issues are not being picked up" icon="circle-question">
+    Check that: (1) the workflow is enabled, (2) the trigger conditions match the issue (assignee, labels, team, priority), and (3) the issue is not in a terminal state (completed, canceled). Review the sync dashboard's event log for diagnostic details.
+  </Accordion>
+  <Accordion title="OAuth token expired" icon="lock">
+    Re-authenticate from the Linear sub-tab. ADE stores tokens securely but cannot refresh expired OAuth tokens automatically in all cases. If re-auth fails, try disconnecting and reconnecting.
+  </Accordion>
+  <Accordion title="Duplicate comments on issues" icon="copy">
+    The outbound service uses content hashing to prevent duplicate workpad comments. If you see duplicates, check if multiple workflow runs are targeting the same issue simultaneously. The sync dashboard shows active runs per issue.
+  </Accordion>
+</AccordionGroup>
+
+---
 
-**Outbound (ADE → Linear)**:
-- Create new issues when the CTO identifies unreported work from code changes
-- Update issue status when PRs merge (e.g., move to "Done" automatically)
-- Add comments with agent analysis, PR links, and proof artifacts
-- Create sub-issues for discovered scope discovered during implementation
+## Next Steps
 
-<Note>Linear sync is owned entirely by the CTO. Automation rules that trigger on Linear events use the `linear-trigger` automation type (separate from the CTO's sync). The two systems are complementary: Automations handle simple event-response rules; the CTO handles stateful, intelligent Linear management.</Note>
+<CardGroup cols={2}>
+  <Card title="CTO-Linear Workflow Guide" icon="route" href="/guides/cto-linear-workflow">
+    Step-by-step guide for setting up a complete CTO-driven Linear workflow from issue creation to PR merge.
+  </Card>
+  <Card title="CTO Workers" icon="users" href="/cto/workers">
+    Learn how the CTO delegates execution to workers — the agents that do the actual coding work.
+  </Card>
+</CardGroup>
diff --git a/docs/architecture/AI_INTEGRATION.md b/docs/architecture/AI_INTEGRATION.md
index 89ad2774b..c5ce8c639 100644
--- a/docs/architecture/AI_INTEGRATION.md
+++ b/docs/architecture/AI_INTEGRATION.md
@@ -382,7 +382,7 @@ The MCP server is a standalone package (`apps/mcp-server`) that exposes ADE's in
 - **Lifecycle**: Headless mode runs standalone with its own AI backend; embedded mode shares the desktop app's service instances
 - **Smart entry point**: Auto-detects `.ade/mcp.sock` to choose proxy (embedded) vs headless mode
 - **Session identity**: The MCP server propagates a `chatSessionId` field through `SessionIdentity`, resolved from the `ADE_CHAT_SESSION_ID` environment variable or the `initialize` handshake params. This links MCP tool calls back to their originating chat session for artifact ownership, computer use proof association, and audit logging. For standalone chat sessions (no mission/run/step context), the server infers the chat session from the caller ID when not explicitly provided.
-- **Role resolution**: Session roles are determined by environment context first. When the environment does not specify a role, the session defaults to `external`. The `external` role receives the base tool set plus any external MCP tool specs; internal roles (`agent`, `cto`, `orchestrator`, `evaluator`) are assigned only through trusted environment variables set by ADE's own worker spawning infrastructure. External sessions also receive a restrictive default computer use policy (`allowLocalFallback: false`).
+- **Role resolution**: Session roles are resolved through a cascade: environment variable (`ADE_DEFAULT_ROLE`), then `identity.role` from the `initialize` handshake params, then `external` as the default. The `identity.role` field is validated against the known role set (`cto`, `orchestrator`, `agent`, `external`, `evaluator`) — invalid values are ignored. The `external` role receives the base tool set plus any external MCP tool specs; internal roles (`agent`, `cto`, `orchestrator`, `evaluator`) are assigned through trusted environment variables set by ADE's own worker spawning infrastructure or through the initialize handshake identity. External sessions also receive a restrictive default computer use policy (`allowLocalFallback: false`).
 
 #### MCP Launch Resolution
 
@@ -390,7 +390,7 @@ Worker and chat processes connect to ADE's MCP server through one of three launc
 
 | Mode | Binary | When used |
 |------|--------|-----------|
-| `bundled_proxy` | `adeMcpProxy.cjs` run via Electron's Node | Packaged desktop builds where the proxy binary exists alongside the app bundle. The proxy connects to the desktop's `.ade/mcp.sock` Unix socket and relays stdio, injecting worker identity (mission/run/step/attempt) into the MCP `initialize` handshake. |
+| `bundled_proxy` | `adeMcpProxy.cjs` run via Electron's Node | Packaged desktop builds where the proxy binary exists alongside the app bundle. The proxy connects to the desktop's `.ade/mcp.sock` Unix socket and relays stdio, injecting worker identity (`chatSessionId`, `missionId`, `runId`, `stepId`, `attemptId`, `ownerId`, `role`, and `computerUsePolicy`) into the MCP `initialize` handshake. The proxy identity is resolved from environment variables (`ADE_CHAT_SESSION_ID`, `ADE_MISSION_ID`, `ADE_RUN_ID`, `ADE_STEP_ID`, `ADE_ATTEMPT_ID`, `ADE_OWNER_ID`, `ADE_DEFAULT_ROLE`, `ADE_COMPUTER_USE_*`). |
 | `headless_built` | `apps/mcp-server/dist/index.cjs` via `node` | Development or CI environments where the MCP server has been pre-built but no bundled proxy is available. |
 | `headless_source` | `apps/mcp-server/src/index.ts` via `npx tsx` | Development environments where only TypeScript source is available. |
 
@@ -405,7 +405,7 @@ The launch resolver checks candidates in order: bundled proxy path (from `proces
 | `create_lane` | Create a new lane with a worktree for agent work | Yes |
 | `check_conflicts` | Run conflict prediction against other active lanes | No |
 | `merge_lane` | Merge a lane back to its parent | Yes |
-| `ask_user` | Route an intervention to the ADE UI for human input | No |
+| `ask_user` | Ask the user a question and wait for their answer. Works in both mission contexts (with missionId) and standalone chat sessions. Supports structured questions with options, multi-select, freeform input, and rich option previews. Returns explicit outcome fields (`outcome`, `resolved`, `answered`, `declined`, `cancelled`, `timedOut`, `awaitingUserResponse`). | No |
 | `run_tests` | Execute test suites in a lane's worktree | No (reads only) |
 | `get_lane_status` | Get current status of a specific lane | No |
 | `list_lanes` | List all active lanes with summary status | No |
@@ -1525,8 +1525,12 @@ type ChatEvent =
   | { type: "plan"; steps: Array<{ text: string; status: "pending" | "in_progress" | "completed" | "failed" }> }
   | { type: "reasoning"; summary: string; isCollapsed: boolean }
   | { type: "approval_request"; itemId: string; kind: "command" | "file_change"; description: string; detail: unknown }
+  | { type: "pending_input_resolved"; itemId: string; resolution: "accepted" | "declined" | "cancelled"; turnId?: string }
   | { type: "system_notice"; noticeKind: "auth" | "rate_limit" | "hook" | "file_persist" | "info" | "memory" | "provider_health" | "thread_error"; message: string; detail?: string | AgentChatNoticeDetail; steerId?: string }
   | { type: "status"; turnStatus: "started" | "completed" | "interrupted" | "failed"; error?: string }
+  | { type: "tool_use_start"; toolUseId: string; toolName: string; turnId?: string }
+  | { type: "tool_use_complete"; toolUseId: string; summary: string; turnId?: string }
+  | { type: "tool_use_summary"; summary: string; toolUseIds: string[]; turnId?: string }
   | { type: "subagent_started"; taskId: string; description: string; turnId?: string }
   | { type: "subagent_result"; taskId: string; status: "completed" | "stopped" | "failed"; summary: string; turnId?: string }
   | { type: "error"; message: string; errorInfo?: string }
@@ -1619,6 +1623,10 @@ send({ method: "initialized", params: {} });
 | Workspace write | `{ type: "workspaceWrite", writableRoots: [cwd] }` | Agent can write within lane worktree |
 | Full access | `{ type: "externalSandbox" }` | No restrictions |
 
+**Collaboration modes**: Codex sessions support collaboration modes (`default`, `plan`) via the `thread/setCollaborationMode` JSON-RPC method. The chat service fetches supported modes via `thread/getCollaborationModes` (with a 1.5-second timeout) and persists them in the `CodexRuntime`. When `interactionMode` or `permissionMode` is `plan`, the service sends a collaboration mode change. If the requested mode is not supported, it falls back to `default` and notifies the user once via a system notice. The `buildCodexCollaborationMode()` helper constructs the mode payload including model and reasoning effort settings.
+
+**MCP elicitation**: Codex MCP elicitation requests (`item/mcpApproval`) flow through the same pending input abstraction as other approval types. The `questionResponseKind` field on `PendingCodexApproval` distinguishes native request-user-input from MCP elicitation, and the response path coerces answer values to the expected JSON schema types via `coerceCodexMcpElicitationContent()`.
+
 **Error handling**: Codex errors include `codexErrorInfo` values (`ContextWindowExceeded`, `UsageLimitExceeded`, `HttpConnectionFailed`, etc.) which are mapped to user-facing messages in the chat UI.
 
 #### ClaudeChatBackend
diff --git a/docs/architecture/UI_FRAMEWORK.md b/docs/architecture/UI_FRAMEWORK.md
index 875b681d8..51346389b 100644
--- a/docs/architecture/UI_FRAMEWORK.md
+++ b/docs/architecture/UI_FRAMEWORK.md
@@ -2,8 +2,6 @@
 
 > Roadmap reference: `docs/final-plan/README.md` is the canonical future plan and sequencing source.
 
-> Last updated: 2026-03-31
-
 This document describes the renderer architecture in `apps/desktop/src/renderer`, including routing, theme system, state model, layout patterns, and IPC integration constraints.
 
 ---
@@ -161,7 +159,7 @@ ADE uses multiple layout systems depending on surface complexity:
 - `PaneTilingLayout`: recursive pane trees for high-density workspaces
 - `SplitPane` / resizable panels: 2-pane and 3-pane structured views
 - Floating pane primitives for modular lane/conflict/terminal sub-surfaces
-- **Work view session grid** (`WorkViewArea`): CSS Grid with `auto-fill` and `minmax` for fluid responsive session card layout that adapts to viewport width without fixed breakpoints. The session list sidebar supports two organization modes: flat status-grouped ("all-lanes-by-status") and lane-folder-grouped ("by-lane") with collapsible lane sections and a `LaneCombobox` for lane filtering
+- **Work view session grid**: `WorkViewArea` uses `PackedSessionGrid` for all multi-session views — resizable tiles with per-session column/row spans and a bin-packing algorithm (`packedSessionGridMath.ts`) for compact layout. Each tile receives `layoutVariant` and `terminalVisible` props so terminals in background tiles skip unnecessary fit operations. The session list sidebar supports two organization modes: flat status-grouped ("all-lanes-by-status") and lane-folder-grouped ("by-lane") with collapsible lane sections and a `LaneCombobox` for lane filtering
 
 Layout state persistence is backed by IPC calls into local SQLite (`layout`, `tilingTree`, `graphState` domains).
 
@@ -177,7 +175,7 @@ Renderer components are feature-grouped under `apps/desktop/src/renderer/compone
 - `project/`: Play tab and run/test/process controls
 - `lanes/`: lane list/detail/inspector, stack workflows, design tokens (`laneDesignTokens.ts`)
 - `files/`: workspace browser/editor
-- `terminals/`: global terminal/session surfaces
+- `terminals/`: global terminal/session surfaces (`TerminalView`, `PackedSessionGrid`, `WorkViewArea`, `WorkStartSurface`, `packedSessionGridMath.ts`)
 - `conflicts/`: risk, merge simulation, resolution workflows
 - `context/`: shared context helpers used by Settings context/docs surfaces (`contextShared.ts`)
 - `packs/`: pack visualization
@@ -346,6 +344,8 @@ Renderer architecture is fully operational for the current desktop scope:
 - Mission chat is split by channel purpose: Global is the high-signal summary/broadcast view, while orchestrator and worker threads reuse the shared agent chat message renderer for detailed structured event/tool/thinking display.
 - Context doc banner is dismissible per project per session.
 - Work tab session sidebar supports two organization modes (flat status-grouped and lane-folder-grouped) with collapsible lane sections and sidebar-toggle focus mode.
+- Work view uses packed session grid as the default multi-session layout, with bin-packing placement, per-session span persistence, and visibility-aware terminal fit management.
+- `UnifiedModelSelector` supports `catalogMode` (`"all"` | `"available-only"`) to filter the model registry to only models available via configured providers.
 - Commit timeline scrolls to the bottom (newest commits) on initial load.
 - PR convergence panel with issue inventory, round-based convergence progress, embedded agent chat, and pipeline settings.
 
diff --git a/docs/features/CHAT.md b/docs/features/CHAT.md
index eec5fe17f..7ec0b5417 100644
--- a/docs/features/CHAT.md
+++ b/docs/features/CHAT.md
@@ -259,38 +259,73 @@ When an agent needs human input -- either permission to proceed or answers to qu
 - `requestId` -- unique identifier for the request.
 - `source` -- `"claude" | "codex" | "unified" | "mission" | "ade"`.
 - `kind` -- `"approval" | "question" | "structured_question" | "permissions" | "plan_approval"`.
-- `questions` -- array of `PendingInputQuestion` with optional predefined options, freeform input, and impact descriptions.
+- `questions` -- array of `PendingInputQuestion` with optional predefined options, freeform input, multi-select support, and impact descriptions.
 - `blocking` / `canProceedWithoutAnswer` -- whether the agent is blocked or can continue with a default assumption.
 
-The renderer derives pending inputs from the event stream via `derivePendingInputRequests()` (in `pendingInput.ts`), which replaces the previous `PendingApproval` model. The derivation function processes `approval_request` events (including embedded `PendingInputRequest` payloads in the detail field and legacy `askUser` tool calls) and `structured_question` events. A `done` event clears all pending inputs for that session. Tool results, command completions, and file changes auto-resolve their corresponding pending items.
+The renderer derives pending inputs from the event stream via `derivePendingInputRequests()` (in `pendingInput.ts`), which replaces the previous `PendingApproval` model. The derivation function processes `approval_request` events (including embedded `PendingInputRequest` payloads in the detail field and legacy `askUser` tool calls), `structured_question` events, and `pending_input_resolved` events (which explicitly clear a resolved pending input by `itemId`). A `done` event with a non-`completed` status clears all pending inputs; a `done` event with `status: "completed"` only clears approval-type inputs for that turn, preserving question and plan-approval inputs that may still need a response.
 
-The `AgentQuestionModal` renders the first pending input with Accept / Accept for Session / Decline / Cancel buttons and optional freeform text. User responses are sent back via the `respondToInput` IPC channel (which accepts `AgentChatRespondToInputArgs` with structured `answers` and optional `decision`), or the legacy `approve` channel for backward compatibility.
+Tool results, command completions, and file changes auto-resolve their corresponding pending items. Helper functions `getPendingInputQuestionCount()` and `hasPendingInputOptions()` provide quick introspection into request structure.
+
+The `AgentQuestionModal` renders the first pending input inline in the chat transcript with Accept / Accept for Session / Decline / Cancel buttons and optional freeform text. Questions with predefined options support **multi-select**: users can toggle multiple values for a single question, and a preview pane renders the selected option's description as sanitized HTML/Markdown (via `ReactMarkdown` with `rehype-raw`, `rehype-sanitize`, and `remark-gfm`). The per-question draft state (`QuestionDraft`) tracks `text`, `selectedValues`, and `activePreviewValue` independently. Options can carry `preview` content and a `previewFormat` (`"markdown"` or `"html"`) for rich inline previews. User responses are sent back via the `respondToInput` IPC channel (which accepts `AgentChatRespondToInputArgs` with structured `answers` — values may be `string` or `string[]` for multi-select — and optional `decision`), or the legacy `approve` channel for backward compatibility.
+
+### AskUserQuestion Tool (Claude V2)
+
+The `AskUserQuestion` tool is handled specially in the Claude V2 runtime. When the SDK invokes `AskUserQuestion`, the service builds a `PendingInputRequest` from the tool input, attaches the `toolUseID`, and emits it as an inline pending input in the chat transcript. The idle watchdog is paused while the service waits for the user's response, preventing the turn from timing out during human deliberation. Once the user responds (accept, decline, or cancel), the watchdog resumes, and a `tool_result` is emitted back to the SDK with the answer text. The `toolUseID` is tracked in a `resolvedToolUseIds` set on the Claude runtime to prevent duplicate resolution. A `pending_input_resolved` event is emitted to explicitly clear the UI state.
 
 Plan approval requests carry the actual plan description text (extracted from the `ExitPlanMode` tool input) as the event description, so the UI can display meaningful content rather than a generic label. The message list renders plan approval cards in a scrollable container (max 288px) with pre-wrapped text to handle long multi-step plans.
 
 If a Claude approval is resolved more than once (e.g., due to a UI double-click, an interrupted turn, or stale state), the service logs a warning and returns silently instead of throwing. This prevents spurious errors from surfacing to the user when approvals have already been consumed.
 
-Codex `permissions` requests and Claude `structured_question` events both flow through the same pending input abstraction.
+Codex `permissions` requests, Codex MCP elicitation requests, and Claude `structured_question` events all flow through the same pending input abstraction. Codex MCP elicitation responses coerce answer values to match the requested JSON schema property types (string, number, integer, boolean, array) via `coerceCodexMcpElicitationContent()`.
 
 ## Chat Transcript and Work Log
 
 The chat message list renders events through a two-layer pipeline defined in `chatTranscriptRows.ts`:
 
-1. **Render events** -- Raw `AgentChatEventEnvelope` events are mapped to `ChatTranscriptRenderEvent` values. Tool calls, commands, file changes, and web searches are collapsed into `ChatWorkLogEntry` objects (with status, label, diff stats, and output). Text, reasoning, plans, user messages, status updates, and other visible events pass through directly.
+1. **Render events** -- Raw `AgentChatEventEnvelope` events are mapped to `ChatTranscriptRenderEvent` values. Tool calls, commands, file changes, and web searches are collapsed into `ChatWorkLogEntry` objects (with status, label, diff stats, and output). Text, reasoning, plans, user messages, status updates, and other visible events pass through directly. The `pending_input_resolved` event type is treated as hidden (not rendered as a transcript row) since it is consumed by the pending input derivation logic.
 
-2. **Grouped envelopes** -- Adjacent work log entries in the same turn are grouped into `work_log_group` blocks so the message list can render them as a single collapsible card (`ChatWorkLogBlock`) rather than individual rows. This keeps the transcript compact when the agent performs many tool operations in a single turn.
+2. **Grouped envelopes** -- Adjacent work log entries in the same turn are grouped into `work_log_group` blocks so the message list can render them as a single collapsible card (`ChatWorkLogBlock`) rather than individual rows. Work log groups carry optional `summary`, `toolUseIds`, and `turnId` fields. When a `tool_use_summary` event immediately follows a work log group from the same turn, it is absorbed into the group, attaching its summary text and matching tool-use IDs to the group rather than rendering as a separate row. This keeps the transcript compact when the agent performs many tool operations in a single turn.
 
-Each work log entry carries a `collapseKey` derived from the turn, logical item identity (`logicalItemId` when present, otherwise `itemId`), and tool/command identity. Streaming updates for the same tool call or command merge into the existing entry rather than appending new rows.
+Each work log entry carries a `collapseKey` derived from the turn, logical item identity (`logicalItemId` when present, otherwise `itemId`), and tool/command identity. Streaming updates for the same tool call or command merge into the existing entry rather than appending new rows. Work log entry status now includes an `"interrupted"` state (in addition to `"running"`, `"completed"`, `"failed"`), which maps to the "waiting" visual style in the UI.
 
 Adjacent assistant text events are merged using `shouldMergeTextRows()`, which compares `messageId`, `turnId`, and `itemId` fields to decide whether two text fragments belong to the same logical message. Events with matching `messageId` values always merge; events without `messageId` fall back to turn/item identity. This prevents duplicate text rows when the streaming backend emits fragmented text events.
 
+Adjacent `plan_text` events are also merged using `shouldMergePlanTextRows()` with the same turn/item matching logic. When a final `plan` event arrives for a turn, any preceding `plan_text` rows for that turn are removed and replaced by the single `plan` event, preventing duplicate plan content.
+
+### Turn Recap
+
+When a turn completes, `chatTranscriptRows` emits a `turn_recap` row that summarizes the turn's tool activity. The recap aggregates completed, failed, and interrupted tool invocations into a single summary line with task-progress counts. This provides a concise at-a-glance view of what the agent accomplished during each turn without requiring the user to expand every work log group.
+
 The `ChatWorkLogBlock` component renders grouped entries with:
 
 - Collapsible header showing entry count and a summary of operations
-- Per-entry rows with tool/command icons, labels, status indicators, and expandable detail sections
+- Per-entry rows with human-readable headings (e.g. "Read utils.ts", "Run shell", "Write index.ts") derived from tool metadata and arguments
+- Status indicators including an `interrupted` state mapped to the "waiting" visual style
+- Up to 4 entries visible by default before the expand toggle
 - File change summaries with addition/deletion counts
 - Operator navigation suggestions extracted from tool results (linking to Work, Missions, Lanes, or CTO surfaces)
 
+## Claude Tool-Use Tracking
+
+The Claude V2 runtime tracks the lifecycle of individual tool invocations
+via tool-use IDs. When the SDK emits a tool call with a `toolUseID`, the
+service records it as an in-progress tool invocation and emits a
+`tool_use_start` event. When the SDK returns a `tool_use_summary`
+message with `preceding_tool_use_ids`, the service matches each ID back
+to its pending invocation, marks it complete, and emits a
+`tool_use_complete` event with the summary text. This allows the
+renderer to show per-tool status indicators (spinner while running,
+checkmark on completion, warning on failure) inside work log entries.
+
+The `AskUserQuestion` tool is handled specially: when the SDK invokes it,
+the service builds a `PendingInputRequest` from the tool input, attaches
+the `toolUseID`, pauses the idle watchdog (to prevent turn timeout while
+waiting for human input), and emits the request inline in the chat
+transcript. When the user responds, the watchdog resumes, a
+`tool_result` is emitted back to the SDK, and a `pending_input_resolved`
+event clears the UI. The `toolUseID` is recorded in `resolvedToolUseIds`
+to prevent duplicate resolution.
+
 ## Model Handoff
 
 When a user switches model families mid-session (e.g., from Claude to Codex), the chat service performs a session handoff via `handoffSession`. The current session is summarized, ended gracefully, and a new session is created with the target model. The handoff preserves context by injecting the summarized transcript into the new session. The `AgentChatHandoffResult` reports whether a fallback summary was used.
@@ -339,6 +374,19 @@ merged into the picker. When steers are queued during an active turn,
 the composer shows a pending steers section above the input area with
 per-message edit and cancel controls (see [Steering and Steer Queue](#steering-and-steer-queue)).
 
+When a question-type pending input is active, pressing Enter in the
+composer submits the draft text as the answer (via `onApproval("accept", answer)`)
+rather than sending a new message. This allows users to answer agent
+questions directly from the composer without navigating to a separate
+modal. The composer accepts a `layoutVariant` prop (`"standard"` or
+`"grid-tile"`) and an optional `composerMaxHeightPx` for constrained
+layouts like packed grid tiles.
+
+The `ChatSurfaceShell` uses a floating header with backdrop blur and
+subtle glass-morphism styling. The body and footer regions use the
+theme's `--color-bg` as background for visual consistency with the
+surrounding layout.
+
 ## Image Attachments
 
 Image attachments are supported across all providers, with
@@ -386,7 +434,12 @@ for virtualized rendering of long transcripts. This keeps render cost
 proportional to the visible viewport rather than the total message count.
 Turn dividers (`ChatTurnDivider`) separate consecutive turns with
 contextual labels. Code blocks in assistant messages use a dedicated
-`HighlightedCode` component.
+`HighlightedCode` component. User messages animate in with a spring
+transition (via `motion/react`). Assistant message cards use a
+constrained `max-w-[78ch]` width for improved readability. Tables
+render with rounded borders, separated spacing, and a subtle inset
+shadow treatment. System notices use compact inline styling rather than
+pill-shaped badges.
 
 ## Diagnostic Logging
 
diff --git a/docs/features/CTO.md b/docs/features/CTO.md
index c2cbf7bd0..cc0c1c740 100644
--- a/docs/features/CTO.md
+++ b/docs/features/CTO.md
@@ -213,15 +213,18 @@ For desktop portability, treat these differently:
 
 ### Identity system prompt
 
-The CTO prompt model is now explicit and split into three layers:
+The CTO prompt model is now explicit and split into four layers:
 
 - **Immutable ADE doctrine** -- defines who the CTO is, what ADE is, how memory/compaction work, and that the CTO is the project's technical/operator lead. This layer is ADE-owned, always present, and not compacted away.
 - **Personality overlay** -- selected from presets or one custom personality field. This is the only user-editable identity layer.
 - **Memory and continuity model** -- explains the long-term CTO brief, current working context, and durable searchable memory.
+- **ADE environment knowledge** -- a glossary and task-routing guide injected into the CTO system prompt. This layer explains ADE's core entities (lanes, native chats vs. PTY terminals, missions, workers, convergence), the critical distinction between `spawnChat` (native ADE chat sessions) and `createTerminal` (PTY shells) and `spawn_agent` (MCP CLI subprocesses), tool calling conventions (call MCP tools directly by name, do not use ToolSearch), and common task-routing patterns (e.g., "start a chat" maps to `spawnChat`, "open a terminal" maps to `createTerminal`).
+
+The capability manifest section now lists the complete CTO operator tool surface organized by domain (lanes, chats, missions, workers, git, PRs, convergence, conflicts, files, context, processes, tests, terminals, Linear, automations, events, project health, computer use, budget, memory) rather than a high-level summary.
 
 Project-specific summary, conventions, focus, and recent continuity live in memory layers, not inside the immutable doctrine.
 
-The prompt preview in onboarding and settings reflects those same three sections so the UI now matches the actual runtime model.
+The prompt preview in onboarding and settings reflects those same sections so the UI now matches the actual runtime model.
 
 ### Daily logs
 
diff --git a/docs/features/LANES.md b/docs/features/LANES.md
index d858add98..6f4f5d35b 100644
--- a/docs/features/LANES.md
+++ b/docs/features/LANES.md
@@ -169,7 +169,7 @@ The center pane is the main working area. The LanesPage uses `PaneTilingLayout`
 
 **Sub-panes** within the center area (via PaneTilingLayout):
 - **Diff pane** (`LaneDiffPane`): Git diff viewer with Monaco side-by-side diffs, per-file stage/unstage/discard, commit diff viewing
-- **Git actions pane** (`LaneGitActionsPane`): Commit, stash, fetch, sync (merge/rebase), push operations with recent commits list, rebase button for stacked lanes. The Pull button flashes and shows a behind-count badge when the lane is behind its upstream. Stash buttons use user-friendly labels (Save Changes, Restore, Copy to Worktree, Delete) with inline explanations. The Save Changes button is disabled when there are no working tree changes. A Clear All button (with numeric confirmation) appears when stashes exist.
+- **Git actions pane** (`LaneGitActionsPane`): Commit, stash, fetch, sync (merge/rebase), push operations with recent commits list, rebase button for stacked lanes. The Pull button flashes and shows a behind-count badge when the lane is behind its upstream. Stash buttons use user-friendly labels (Save Changes, Restore, Copy to Worktree, Delete) with inline explanations. The Save Changes button is disabled when there are no working tree changes. A Clear All button (with numeric confirmation) appears when stashes exist. Stash pop, drop, and clear operations now refresh git metadata immediately after completion.
 - **Terminals pane** (`LaneTerminalsPanel`): Embedded terminal sessions with tab/tiling views, quick-launch profiles, session delta cards
 - **Work pane** (`LaneWorkPane`): Embedded terminal sessions and agent chat view (terminal/chat toggle)
 - **Stack pane** (`LaneStackPane`): Stack chain visualization and management
diff --git a/docs/features/PULL_REQUESTS.md b/docs/features/PULL_REQUESTS.md
index 5782075cc..a1b7f14d1 100644
--- a/docs/features/PULL_REQUESTS.md
+++ b/docs/features/PULL_REQUESTS.md
@@ -43,7 +43,9 @@ The snapshot still includes:
 - external pull requests involving the current user
 - lane linkage and ADE workflow metadata
 
-The GitHub tab remains the read-only inspection and import/linking surface for remote PRs.
+Each PR in the snapshot now includes `labels` (name, color, description), `isBot` (whether the author is a bot account), and `commentCount` fields, enabling richer filtering and display in the GitHub tab.
+
+The GitHub tab is the read-only inspection, filtering, and import/linking surface for remote PRs. The tab now merges repo and external PRs into a single unified list sorted by creation date, with a scope filter (`all` / `ade` / `external`) replacing the previous separate external PR toggle. Filter tab counts respect the active scope. PR labels render inline with luminance-aware text colors. Review status indicators use more descriptive labels (e.g., "Review required" instead of "Review"). Check status shows pass/fail icons per PR row.
 
 ---
 
diff --git a/docs/features/TERMINALS_AND_SESSIONS.md b/docs/features/TERMINALS_AND_SESSIONS.md
index 32f7b793c..a74b1e151 100644
--- a/docs/features/TERMINALS_AND_SESSIONS.md
+++ b/docs/features/TERMINALS_AND_SESSIONS.md
@@ -28,9 +28,20 @@ Tracked sessions still feed history, lane refresh, conflict follow-up, and missi
 
 ### Work view session grid
 
-The Work tab renders active sessions in a responsive card grid (`WorkViewArea`). The grid uses CSS `auto-fill` with `minmax(min(100%, 360px), 1fr)` columns and `minmax(240px, 33vh)` row heights, so card count per row adjusts fluidly to the viewport width without fixed breakpoints. Each card wraps a `SessionSurface` (live terminal via xterm.js or agent chat pane) and supports right-click context menus for session-level actions.
+The Work tab's multi-session grid mode uses `PackedSessionGrid` — a resizable tile layout where each tile has an independent column/row span. The grid uses a bin-packing algorithm (`packGridItems` in `packedSessionGridMath.ts`) to arrange tiles compactly, minimizing wasted space. Layout spans are persisted per session via `readPackedGridSpan` / `reconcilePackedGridLayout` and survive session switches.
 
-The grid view and a single-session focused view are toggled via a view mode selector in the Work tab header.
+The grid math module (`packedSessionGridMath.ts`) provides:
+
+- `computeGridColumnCount()` -- determines optimal column count from container width, tile count, and minimum tile width
+- `computeMinimumRowSpan()` / `computeMinimumColSpan()` -- convert pixel minimums to grid span units
+- `clampPackedGridSpan()` -- enforces minimum/maximum span constraints per tile
+- `packGridItems()` -- bin-packing placement algorithm that iterates rows/columns to find the first available slot for each tile
+- `computePackedGridRowHeight()` -- distributes container height evenly across rows, respecting a minimum base row height (`GRID_BASE_ROW_PX = 120`)
+- `reconcilePackedGridLayout()` -- reconciles persisted layout spans with active tile IDs, preserving spans for inactive tiles
+
+Each `SessionSurface` receives a `layoutVariant` prop (`"standard"` or `"grid-tile"`) and a `terminalVisible` flag so that terminals in non-visible tiles can skip fit operations. Chat tiles use minimum dimensions of 440x340px; terminal tiles use 320x220px.
+
+The Work tab also supports a single-session focused view and a tab-bar mode with a "New Chat" button in the tab strip for quick session creation.
 
 ### Shared session-list cache
 
@@ -114,6 +125,10 @@ The lifecycle model remains the same:
 
 UI observers subscribe selectively and reuse cached list results where possible.
 
+### Stale session reconciliation
+
+On startup, the session service reconciles stale running sessions via `reconcileStaleRunningSessions()`. This marks orphaned sessions (those still in `running` status from a previous app lifecycle) as `disposed`. The method now accepts an `excludeToolTypes` parameter to skip specific tool types during reconciliation — for example, chat sessions may be excluded so they can be resumed rather than force-closed. The exclusion uses normalized tool types and generates a dynamic SQL `NOT IN` clause.
+
 ### Refresh-before-activate ordering
 
 When a new session is created or an existing session is opened, the renderer refreshes the session list *before* activating the session tab. This ensures the new session exists in `sessionsById` when the UI resolves `activeSession` for the tab. Without this ordering, the active item ID would point to an unknown session and the view would fall back to the most recent session or display a blank pane until the next refresh cycle.
@@ -156,6 +171,14 @@ That preserves ADE's session-awareness while making the session system a lighter
 
 ---
 
+## Terminal renderer and fit recovery
+
+`TerminalView` initializes xterm.js with a **WebGL-first renderer** and falls back to the DOM renderer if WebGL initialization fails (e.g. GPU driver issues, WebGL context loss). The previous three-tier strategy (WebGL -> canvas -> DOM) was simplified to two tiers since the canvas renderer offered no meaningful advantage over the DOM fallback. On WebGL context loss, the runtime clears the texture atlas, increments the `rendererFallbacks` health counter, falls back to the DOM renderer, and re-triggers a fit cycle.
+
+The `TerminalView` component accepts `isActive` and `isVisible` props that control runtime interaction and visibility state. The runtime tracks these via `active` and `visible` fields on the cached runtime. When a terminal is not visible, fit operations are skipped (unless it has never been fitted), and forced PTY resize requests are suppressed. This prevents unnecessary layout work for terminals in background tiles. The `documentOverride` option is set to `document` at creation time to support proper rendering when terminals are mounted in packed grid tiles.
+
+When a terminal is resized or re-parented (e.g. moved between grid tiles), the fit addon computes new column/row dimensions from the host container. If the computed dimensions are invalid (below `MIN_VALID_COLS = 20` / `MIN_VALID_ROWS = 6`, or the host is smaller than `MIN_HOST_WIDTH_PX = 120` / `MIN_HOST_HEIGHT_PX = 48`), the previous valid dimensions are restored, the fit is retried after a short delay (`INVALID_FIT_RETRY_MS = 90ms`), and the terminal content is refreshed to prevent visual artifacts. Successful retries after an initial invalid fit are counted as `fitRecoveries` in the `TerminalHealthCounters`. The `measureHost` helper uses the maximum of `getBoundingClientRect`, `clientWidth`/`clientHeight`, and `offsetWidth`/`offsetHeight` to handle edge cases where one measurement API returns zero during layout transitions. A `fitWarningLogged` flag prevents log spam when a host remains too small across multiple retry cycles.
+
 ## Terminal status indicators
 
 Terminal session status dots use distinct visual treatments per state:
diff --git a/getting-started/first-agent.mdx b/getting-started/first-agent.mdx
index da9ea1b2f..836f57e54 100644
--- a/getting-started/first-agent.mdx
+++ b/getting-started/first-agent.mdx
@@ -1,49 +1,174 @@
 ---
 title: "Run your first agent"
-description: "Choose between a direct chat and a structured mission for your first ADE task."
+description: "Choose between a direct chat and a structured mission for your first ADE task — with step-by-step instructions for each approach and guidance on what to try first."
 icon: "robot"
 ---
 
+You have a lane ready. Now it is time to run an agent in it. ADE offers two paths depending on the scope of the task.
+
+---
+
 ## Two good first paths
 
 <Tabs>
-  <Tab title="Agent chat">
-    Use this when the task is small and you want the fastest iteration loop.
+  <Tab title="Agent Chat (recommended for first run)">
+    Use Agent Chat when the task is small and you want the fastest iteration loop. Chat is conversational — you describe what you want, the agent makes changes, you review and iterate.
 
     <Steps>
       <Step title="Open the lane chat">
-        Select your lane and open its chat surface.
+        Select your lane in the Lanes panel. Click the **Chat** button in the lane toolbar, or press `Cmd+K`. A new chat session opens with automatic context injection from the lane's pack.
+      </Step>
+      <Step title="Choose a model (optional)">
+        The model selector in the chat header defaults to your configured preferred model. Click it to switch models for this session. If you set up Anthropic, Claude Sonnet is a good default for a first task.
       </Step>
       <Step title="Send one narrow task">
-        Start with something easy to review, like a small endpoint, a copy update, or a focused refactor.
+        Start with something small and easy to review. Type your task description and press Enter. The agent receives your message along with the injected context and begins working immediately.
+
+        See [suggested first prompt](#first-prompt-to-try) below.
+      </Step>
+      <Step title="Watch the agent work">
+        As the agent processes your request, you will see:
+        - **Text responses** explaining what it plans to do
+        - **Tool call blocks** showing file reads, writes, and terminal commands in expandable cards
+        - **A progress indicator** in the chat header showing token usage
+
+        Tool calls that take more than a few seconds show a spinner with elapsed time. Click to expand and see partial output as it streams.
       </Step>
       <Step title="Review the diff">
-        Check the file changes before you commit or continue.
+        After the agent finishes, switch to the **Files** view (or stay in the lane's center pane) to inspect what changed. ADE shows a side-by-side diff of every modified file.
+
+        If the changes look good, you can commit directly from the Files view or ask the agent to commit for you.
       </Step>
     </Steps>
+
+    <Tip>
+    If the agent asks a question, a question modal appears in the chat. Read the options, select your answer, and the agent continues. This is ADE's **AskUserQuestion** flow — the agent pauses cleanly instead of guessing when it needs your input.
+    </Tip>
   </Tab>
-  <Tab title="Mission">
-    Use this when the task needs a plan, validation, or a stronger audit trail.
+  <Tab title="Mission (for structured work)">
+    Use a Mission when the task needs a formal plan, parallel workers, validation, or a stronger audit trail. Missions are overkill for a first test — but if you want to see ADE's full orchestration, here is how.
 
     <Steps>
       <Step title="Open Missions">
-        Create a mission and target the lane you just created.
+        Click **Missions** in the left sidebar. Click **+ New Mission**.
       </Step>
-      <Step title="Review preflight">
-        Confirm the provider, permissions, and lane state are ready.
+      <Step title="Set a goal">
+        Write a clear, specific goal. The planner agent uses this to generate a structured execution plan.
+
+        Example: *"Add a REST endpoint `GET /api/health` that returns `{ status: 'ok' }` with a corresponding test."*
       </Step>
-      <Step title="Launch and monitor">
-        Follow the plan, execution, and validation phases from one place.
+      <Step title="Choose launch mode">
+        Select **Supervised** for your first mission. This pauses for your approval before the agent starts executing — so you can review the plan before any code is written.
+      </Step>
+      <Step title="Review the plan">
+        The planner generates a step-by-step execution plan. Review the steps, lane assignments, and estimated cost. Click **Approve** to proceed or **Edit** to adjust.
+      </Step>
+      <Step title="Monitor execution">
+        Workers execute the plan. The Mission Run panel shows:
+        - Live status of each step (queued, running, completed, failed)
+        - Terminal output from each worker
+        - File changes and tool call logs
+
+        When all steps complete, the mission enters validation.
+      </Step>
+      <Step title="Review results">
+        Check the Artifacts tab for test reports, code changes, and summaries. Create a PR from the mission's result lane if the work looks good.
       </Step>
     </Steps>
   </Tab>
 </Tabs>
 
+---
+
 ## First prompt to try
 
+For your first agent task, use something narrow enough to verify the full loop but broad enough to exercise the core workflow:
+
 ```text
 Add a GET /health endpoint that returns { "status": "ok" } and add one test for it.
 ```
 
-That prompt is small enough to inspect quickly and broad enough to exercise the ADE workflow end to end.
+This prompt is effective because it:
+- Creates a small, reviewable change (one route handler + one test)
+- Exercises file creation, code writing, and test generation
+- Gives you a clear way to verify the result (`curl localhost:PORT/health`)
+- Completes in under a minute with most models
+
+Other good first prompts:
+- `"Add a TypeScript type for UserPreferences with name (string), theme (light | dark), and notifications (boolean)."`
+- `"Write a utility function that validates email addresses and add 3 unit tests for it."`
+- `"Update the README with a Getting Started section that explains how to install dependencies and run the dev server."`
+
+---
+
+## What to expect during your first session
+
+**Context injection**: Before the agent sees your message, ADE prepends the Lane Pack — a structured context block with your project's architecture, the lane's intent, and recent file state. This means the agent already knows what project it is in and what branch it is working on.
+
+**Tool calls**: The agent reads files, writes code, and runs commands using ADE's MCP tools. Each tool call appears as an expandable block in the chat. You do not need to grant per-call permissions in the default configuration.
+
+**Session recording**: Every message, tool call, and response is captured in the session transcript. You can review it later in the History tab.
+
+**Interrupting**: Press **Escape** or click the **Stop** button to interrupt a running agent at any time. The agent reports partial results and you can continue the conversation or start a new session.
+
+---
+
+## After your first task
+
+Once you have verified the result:
+
+<Steps>
+  <Step title="Review the diff">
+    Open the Files view scoped to your lane. Check every changed file. The side-by-side diff makes it easy to spot issues.
+  </Step>
+  <Step title="Commit the changes">
+    If the changes look correct, commit them. You can:
+    - Ask the agent: *"Commit these changes with a descriptive message"*
+    - Use the git operations bar at the bottom of the Files view
+    - Use the terminal in the lane to run `git commit` manually
+  </Step>
+  <Step title="Create a PR (optional)">
+    Ask the agent: *"Create a PR for this work"* — or use the lane's PR action in the right inspector. ADE pre-fills the PR title and description from the Lane Pack.
+  </Step>
+</Steps>
+
+---
+
+## Troubleshooting your first run
+
+<AccordionGroup>
+  <Accordion title="The agent is not responding" icon="circle-question">
+    Check that at least one AI provider is configured and verified in **Settings > AI Providers**. A green indicator means the provider is ready. If the provider shows a red indicator, verify your API key.
+  </Accordion>
+  <Accordion title="The agent made changes to the wrong files" icon="file-circle-exclamation">
+    Verify you are in the correct lane — check the lane selector in the chat header. If the agent is in the Primary Lane, it writes to your main working directory. Create a Worktree Lane for agent-driven tasks.
+  </Accordion>
+  <Accordion title="The agent's changes do not compile or tests fail" icon="circle-xmark">
+    This is normal for a first run, especially on complex codebases. The Lane Pack may not have captured all relevant context. Try:
+    1. Tell the agent what failed: *"The tests are failing with this error: [paste error]"*
+    2. The agent will read the error and attempt a fix
+    3. If it still fails, provide more context about your project's testing setup
+  </Accordion>
+  <Accordion title="The session is taking very long" icon="clock">
+    Check the token usage indicator in the chat header. If the agent is consuming tokens but not producing visible output, it may be reading large files. Press **Escape** to interrupt, then try a more focused prompt.
+  </Accordion>
+</AccordionGroup>
+
+---
+
+## Next steps
 
+<CardGroup cols={2}>
+  <Card title="Key Concepts" icon="book" href="/key-concepts">
+    Understand every core concept in ADE: Lanes, Packs, Missions, the CTO, Automations, and more.
+  </Card>
+  <Card title="Chat Capabilities" icon="toolbox" href="/chat/capabilities">
+    See the full list of what the chat agent can do — file operations, git, PRs, missions, and more.
+  </Card>
+  <Card title="Missions" icon="bullseye" href="/missions/overview">
+    Learn how to configure multi-step missions with planning, validation, and cost tracking.
+  </Card>
+  <Card title="Multi-Agent Setup" icon="users" href="/guides/multi-agent-setup">
+    Run parallel agents across multiple lanes and monitor them from the Workspace Graph.
+  </Card>
+</CardGroup>
diff --git a/getting-started/first-lane.mdx b/getting-started/first-lane.mdx
index 3473b2d81..177bdfccd 100644
--- a/getting-started/first-lane.mdx
+++ b/getting-started/first-lane.mdx
@@ -1,34 +1,119 @@
 ---
 title: "Create your first lane"
-description: "Start your first isolated worktree so AI tasks do not run in the primary checkout."
+description: "Start your first isolated worktree so AI tasks do not run in the primary checkout — step-by-step walkthrough with naming tips, environment setup, and verification."
 icon: "code-branch"
 ---
 
 ## Why lanes matter
 
-A lane is ADE's unit of parallel work. Each lane maps to its own Git worktree and branch state, so separate tasks do not collide immediately.
+A lane is ADE's unit of parallel work. Each lane maps to its own Git worktree and branch state, so separate tasks never collide. When you create a lane, ADE:
+
+- Runs `git worktree add` to create a physically separate copy of your repo
+- Allocates a unique port so dev servers in different lanes do not conflict
+- Generates an initial Lane Pack — the context bundle every agent in this lane will receive
+- Registers the lane in ADE's tracking system for conflict detection, status monitoring, and PR linking
+
+Without lanes, every agent would write to the same working directory simultaneously. Lanes make parallel development safe by default.
+
+<Note>
+The **Primary Lane** is your main repository checkout. It always exists and cannot be deleted. For agent-driven work, create a Worktree Lane — this keeps the primary checkout clean and lets you work manually without interference.
+</Note>
+
+---
 
 ## Create a lane
 
 <Steps>
   <Step title="Open the Lanes view">
-    Use the **Lanes** view from the sidebar.
+    Click the **Lanes** icon (branch icon) in the left sidebar, or press `Cmd+Shift+L` to jump directly to the new lane dialog.
   </Step>
-  <Step title="Create a new lane">
-    Click **New Lane** and choose a name plus a base branch.
+  <Step title="Click New Lane">
+    Click the **+ New Lane** button at the top of the lane list. The creation dialog opens.
   </Step>
-  <Step title="Wait for the worktree">
-    ADE creates the worktree, registers it, and marks it ready once the checkout is usable.
+  <Step title="Choose a name">
+    Enter a short, task-oriented name. ADE uses this as both the lane identifier and the worktree directory name.
+
+    Good names describe the work:
+    - `add-health-endpoint`
+    - `fix-auth-redirect`
+    - `refactor-payment-api`
+
+    Avoid generic names like `test` or `feature-1` — they become confusing when you have several lanes open at once.
+  </Step>
+  <Step title="Select a base branch">
+    Choose which branch this lane branches from. For your first lane, select your project's default branch (usually `main` or `develop`).
+
+    For stacked work, you would select another lane's branch as the base. See [Stacked Lanes](/lanes/stacks) for details.
+  </Step>
+  <Step title="Configure the environment (optional)">
+    Expand the **Advanced** section to set:
+    - **Environment variable overlays** — key-value pairs applied only in this lane (e.g., `DATABASE_URL` pointing to a test database)
+    - **Startup command** — a command ADE runs when the lane initializes (e.g., `npm run dev`)
+    - **Port offset** — override the auto-assigned port if needed
+
+    For your first lane, the defaults are fine. You can change these later in the lane's environment settings.
+  </Step>
+  <Step title="Create the lane">
+    Click **Create Lane**. ADE will:
+    1. Run `git worktree add` to create the isolated directory under `.ade/worktrees/<lane-name>/`
+    2. Initialize the lane environment (port lease, env overlay)
+    3. Generate an initial Lane Pack from the branch state
+    4. Add the lane to the list with `idle` status
+
+    This takes 2-5 seconds for most repositories.
   </Step>
 </Steps>
 
+---
+
+## Verify the lane is ready
+
+Once created, your new lane appears in the lane list with a grey dot (`idle` status). Confirm:
+
+- The lane name and branch are correct in the list
+- Click the lane to select it — the center pane shows the lane detail with a clean diff (no changes yet)
+- The right inspector's **Packs** sub-tab shows a freshly generated Lane Pack
+
+You are now ready to [run your first agent](/getting-started/first-agent) in this lane.
+
+---
+
 ## Naming guidance
 
-- Use a short task-oriented name
-- Match your Git branch conventions when they matter
-- Prefer one lane per feature, fix, or experiment
+| Convention | Example | When to use |
+|-----------|---------|-------------|
+| Feature prefix | `feature/user-preferences` | Following git-flow or similar branch conventions |
+| Task-oriented | `add-health-endpoint` | Quick, descriptive — works well for most tasks |
+| Issue-linked | `linear/ENG-142` | When the CTO creates lanes from Linear issues |
+| Hotfix | `hotfix/auth-redirect` | Urgent fixes that need fast-tracked review |
 
 <Tip>
-If you are unsure, start from your project's default branch and let ADE create a fresh feature lane from there.
+Prefer one lane per feature, fix, or experiment. If a task grows beyond what you expected, split it into stacked lanes rather than making one lane do too much. Narrow lanes have fewer conflicts and are easier to review.
 </Tip>
 
+---
+
+## What happens under the hood
+
+When you create a lane, ADE executes these steps in sequence:
+
+1. **`git worktree add .ade/worktrees/<name> -b <branch> <base>`** — creates the worktree
+2. **Port lease** — reserves a unique port from the configured range (default: 3001-3099)
+3. **Environment overlay** — merges your project `.env` with any lane-specific overrides
+4. **Lane Pack generation** — an AI-synthesized context bundle capturing the lane's intent, touched files, and diff summary
+5. **Registry update** — the lane is added to ADE's local database with full metadata
+
+The worktree directory is fully self-contained. An agent working in this lane sees exactly the files on its branch, with no interleaving from other branches.
+
+---
+
+## Next steps
+
+<CardGroup cols={2}>
+  <Card title="Run your first agent" icon="robot" href="/getting-started/first-agent">
+    Use Agent Chat for a quick task or launch a Mission for structured execution.
+  </Card>
+  <Card title="Lanes deep dive" icon="code-branch" href="/lanes/overview">
+    Learn about lane types, status indicators, the 3-pane layout, and health monitoring.
+  </Card>
+</CardGroup>
diff --git a/getting-started/open-project.mdx b/getting-started/open-project.mdx
index 617d58c55..ef8f0f39e 100644
--- a/getting-started/open-project.mdx
+++ b/getting-started/open-project.mdx
@@ -1,54 +1,123 @@
 ---
 title: "Open your first project"
-description: "Connect ADE to a Git repository and complete the first-run onboarding flow."
+description: "Connect ADE to a Git repository, understand what the .ade directory contains, and complete the first-run onboarding flow."
 icon: "folder-open"
 ---
 
-## Open a repository
+## Open a Repository
 
-Use **Open Repository** on the welcome screen or press `Cmd+O`.
+Launch ADE and use **Open Repository** on the welcome screen, or press `Cmd+O` at any time.
 
-ADE expects the root of a Git repository. If you do not have one ready, create a new directory and run:
+ADE expects the root of a Git repository — the directory containing the `.git` folder. If you point ADE at a subdirectory, it walks up to find the repository root automatically.
+
+If you do not have a repository ready, create one:
 
 ```bash
+mkdir my-project && cd my-project
 git init
 ```
 
-## What ADE creates
+<Note>
+ADE supports any Git repository — new or existing, small or large, monorepo or single-package. The onboarding wizard adapts its suggestions based on what it finds in the repo.
+</Note>
 
-When ADE opens a repository for the first time, it creates a local `.ade/` directory for worktrees, metadata, packs, and artifacts.
+---
 
-## First-run onboarding
+## What ADE Creates
 
-When ADE opens a new repository, it launches the **project setup wizard** — a 7-step flow that configures your development tools, AI providers, GitHub, Linear, and context docs.
+When ADE opens a repository for the first time, it creates a `.ade/` directory at the repository root. This directory is ADE's local workspace — it stores everything ADE needs without modifying your source code.
+
+```
+.ade/
+  artifacts/           ← packs, proofs, and mission outputs
+    packs/
+      project/         ← project-wide context pack
+      lanes/           ← per-lane context packs
+      features/        ← per-feature context packs (Linear-linked)
+      conflicts/       ← conflict resolution context
+      missions/        ← mission plans and phase snapshots
+  context/             ← generated PRD and architecture docs
+  cto/                 ← CTO identity, memory, and configuration
+  worktrees/           ← git worktrees for lanes (one per lane)
+  db/                  ← SQLite database for lanes, sessions, history
+```
+
+<Warning>
+Add `.ade/` to your `.gitignore` if it is not already there. The `.ade/` directory contains machine-local state (worktree paths, database files, API tokens) that should not be committed to version control.
+</Warning>
+
+---
+
+## First-Run Onboarding
+
+When ADE opens a new repository, it launches the **project setup wizard** — a 7-step flow that configures your development tools, AI providers, GitHub integration, and context documents.
 
 <Steps>
   <Step title="Dev tools check">
-    ADE checks for Git, GitHub CLI, and Node.js.
+    ADE checks for Git, GitHub CLI (`gh`), and Node.js. Missing tools are flagged with install instructions. Git is required; the others are optional but recommended.
   </Step>
   <Step title="AI connections">
-    Connect API key providers (Anthropic, OpenAI) or CLI-based providers (Claude Code, Codex, Cursor).
+    Connect your AI providers. ADE supports two categories:
+    - **API key providers** — Anthropic (Claude), OpenAI (GPT, Codex). Paste your API key and ADE verifies it immediately.
+    - **CLI-based providers** — Claude Code, Codex CLI, Cursor (ACP). ADE detects these from your PATH and checks authentication status.
+
+    You need at least one provider to use agent features. You can add more later in Settings.
   </Step>
   <Step title="Background helpers">
-    Enable auto-titling, context doc generation, and auto-refresh.
+    Enable optional background services:
+    - **Auto-titling** — generates descriptive names for lanes and sessions based on their content
+    - **Context doc generation** — creates baseline PRD and architecture docs from your codebase (see step 7)
+    - **Auto-refresh** — keeps lane packs and context docs up to date automatically after commits
   </Step>
   <Step title="GitHub">
-    Authenticate for PR management, CI sync, and stacked PR workflows.
+    Authenticate with GitHub for PR management, CI sync, and stacked PR workflows. ADE uses the GitHub CLI (`gh`) for authentication — if you are already logged in via `gh auth login`, ADE detects this automatically.
   </Step>
   <Step title="Semantic search">
-    Build a local embedding index for faster context retrieval.
+    Build a local embedding index for faster context retrieval. This indexes your codebase so agents can find relevant code without scanning every file. The initial build takes 30 seconds to a few minutes depending on repo size.
   </Step>
   <Step title="Linear">
-    Connect for bidirectional issue tracking with the CTO agent.
+    Connect Linear for bidirectional issue tracking with the CTO agent. This step is optional — skip it if you do not use Linear. See [Linear Integration](/cto/linear) for details.
   </Step>
   <Step title="Context docs">
-    Generate baseline PRD and architecture docs from your codebase.
+    Generate baseline PRD and architecture documents from your codebase. ADE scans your repository's documentation files (README, docs/, etc.), code structure, and dependency graph to produce two structured documents:
+    - **PRD.ade.md** — what the project is, who it is for, and its feature areas
+    - **ARCHITECTURE.ade.md** — system shape, core services, data model, and key patterns
+
+    These documents become part of the Project Pack and are injected into every agent session as foundational context.
   </Step>
 </Steps>
 
-You can skip any step and configure it later in Settings. For a detailed walkthrough of each step, see [Project Setup & Onboarding](/getting-started/project-setup).
+You can skip any step and configure it later in **Settings**. For a detailed walkthrough of each step with screenshots and troubleshooting, see [Project Setup & Onboarding](/getting-started/project-setup).
+
+---
+
+## After Opening
+
+Once the wizard completes, ADE loads the project and you land on the **Lanes** view. You will see:
+
+- **Primary Lane** — your main repository checkout, always present and read-only by default
+- **Left sidebar** — navigation to Lanes, CTO, Missions, Automations, History, and Settings
+- **Right inspector** — context-sensitive detail panel showing lane info, packs, and environment
+
+From here, [create your first lane](/getting-started/first-lane) and [run your first agent](/getting-started/first-agent).
+
+---
+
+## Re-Opening a Project
+
+When you re-open a project that was previously configured, ADE loads the existing `.ade/` directory and restores your lanes, sessions, and settings. No onboarding wizard runs on subsequent opens.
+
+If you want to re-run onboarding (e.g., to reconfigure providers or rebuild the embedding index), open **Settings > Project** and click **Re-run Setup Wizard**.
+
+---
 
-<Tip>
-If `.ade/` is not already ignored, add it to `.gitignore`.
-</Tip>
+## Next Steps
 
+<CardGroup cols={2}>
+  <Card title="Project Setup Details" icon="gear" href="/getting-started/project-setup">
+    Detailed walkthrough of each onboarding step with troubleshooting for common issues.
+  </Card>
+  <Card title="Create Your First Lane" icon="code-branch" href="/getting-started/first-lane">
+    Set up an isolated worktree so AI tasks do not run in the primary checkout.
+  </Card>
+</CardGroup>
diff --git a/lanes/packs.mdx b/lanes/packs.mdx
index b2a1c7e16..447705544 100644
--- a/lanes/packs.mdx
+++ b/lanes/packs.mdx
@@ -1,38 +1,171 @@
 ---
 title: "Lane Packs"
-description: "Lane Packs are auto-generated, versioned context bundles that travel with each lane and are automatically injected into every agent session."
+description: "Lane Packs are auto-generated, versioned context bundles that travel with each lane — giving every agent session instant orientation on the lane's intent, touched files, and current state."
 icon: "cube"
 ---
 
-## Lane Packs
+## What is a Lane Pack?
 
-Every lane carries a **Lane Pack** — an auto-generated, versioned context bundle that travels with the lane and is automatically injected into every agent session that starts in it.
+A Lane Pack is a structured context document that captures everything an agent needs to know about a specific lane's work. It is auto-generated by ADE, versioned on each commit, and automatically injected into every agent session that starts in the lane.
 
-A Lane Pack contains:
-- **Intent** — the stated goal of this lane (editable; ADE generates an initial version from the branch name and recent commits)
-- **Coding criteria** — acceptance criteria and constraints the agent should respect
-- **Touched files** — the set of files modified since the lane branched from its base
-- **Recent checkpoints** — the last N session boundaries with their SHAs, diffs, and outcomes
-- **Current diff summary** — a narrative description of what has changed and why
+Without Lane Packs, an agent would need to read the branch name, scan the diff, re-derive the intent from commit messages, and figure out what was already tried in prior sessions — every single time. Lane Packs eliminate this cold-start problem by handing the agent a pre-built briefing before it reads your first message.
 
 ---
 
-### Pack Freshness
+## What is in a Lane Pack?
 
-ADE regenerates the Lane Pack automatically after each committed checkpoint. You can also manually trigger regeneration from the Packs sub-tab. A freshness indicator turns amber if the pack is more than one session stale — this matters because agents injected with stale packs may not have accurate context about recent changes.
+| Section | Description |
+|---------|-------------|
+| **Intent** | The stated goal of this lane. ADE generates an initial version from the branch name and early commits. You can edit this to be more specific. |
+| **Coding Criteria** | Acceptance criteria and constraints the agent should respect — definition of done, style requirements, testing expectations. |
+| **Touched Files** | Every file modified since the lane branched from its base. Agents use this to scope their work and avoid modifying unrelated files. |
+| **Recent Checkpoints** | The last N session boundaries with their commit SHAs, diffs, and outcomes. This tells the agent what was already done and whether it succeeded. |
+| **Current Diff Summary** | A narrative description of what has changed and why, derived from the actual diff. More useful than a raw diff for agent orientation. |
+| **Active Conflicts** | If this lane has merge conflicts with other lanes, the conflict summary is included so the agent knows about unresolved issues. |
 
-<Tip>If the freshness indicator turns amber, use the keyboard shortcut `Cmd+Shift+P` to instantly regenerate the Lane Pack without leaving the current view.</Tip>
+### Example Pack (Simplified)
+
+```markdown
+<!-- ade:pack type=lane id=lane-abc123 generated=2026-04-01T14:30:00Z version=5 -->
+
+<!-- section: intent -->
+Add a refresh token endpoint to the auth service and update the existing
+login flow to return both access and refresh tokens.
+
+<!-- section: criteria -->
+- All existing auth tests must pass
+- New refresh token endpoint needs integration tests
+- No changes to the public API surface of existing endpoints
+
+<!-- section: touched-files -->
+- src/auth/refreshToken.ts (created)
+- src/auth/refreshToken.test.ts (created)
+- src/api/routes/auth.ts (modified)
+- src/api/middleware/tokenValidator.ts (modified)
+
+<!-- section: diff-summary -->
+Added `refreshToken()` function implementing JWT refresh with rotation.
+Extended the `/auth/login` response to include a refresh token. Updated
+tokenValidator middleware to accept both access and refresh tokens.
+```
+
+---
+
+## Pack Freshness
+
+ADE regenerates the Lane Pack automatically after each committed checkpoint. The freshness system ensures agents always have accurate context.
+
+### How freshness works
+
+| Indicator | Meaning |
+|-----------|---------|
+| **Green** | Pack was regenerated after the most recent commit. Fully fresh. |
+| **Amber** | Pack is one or more sessions stale — commits have happened since the last regeneration. Agents injected with this pack may have outdated context. |
+| **Red** | Pack generation failed or the pack is missing. Agent sessions will start without lane-specific context. |
+
+### Triggering a refresh
+
+Lane Packs refresh automatically on commit. You can also trigger a manual refresh:
+
+- **Keyboard shortcut** — press `Cmd+Shift+P` from any view in the lane
+- **Packs sub-tab** — click the **Regenerate** button in the right inspector's Packs sub-tab
+- **Agent request** — ask the agent: *"Regenerate the lane pack"* (the agent calls the pack refresh MCP tool)
+
+<Tip>
+If the freshness indicator turns amber, regenerate the pack before starting a new agent session. Agents with stale packs may repeat work that was already done or miss recent changes.
+</Tip>
+
+---
+
+## Context Injection
+
+When an agent starts in a lane, ADE prepends the Lane Pack as a system context block before the agent's first prompt. This happens automatically — you do not need to copy-paste context or tell the agent what to do.
+
+The injection order follows a priority stack:
+
+1. **Lane Pack** (highest priority) — the specific work context for this lane
+2. **Feature Pack** (if the lane is linked to a Linear issue) — cross-lane awareness and original requirements
+3. **Project Pack** (base layer) — project-wide architecture, conventions, and risk signals
+4. **Conflict Pack** (if active conflicts exist) — both sides of any unresolved merge conflicts
+
+More specific context always takes precedence. If the Lane Pack and Project Pack contain conflicting guidance (e.g., the project convention is tabs but this lane is converting to spaces), the Lane Pack wins.
+
+<Note>
+The context stack is assembled at session start and does not update mid-session. If the Lane Pack is refreshed while a session is running, the agent continues with the version from session start. Start a new session to pick up a refreshed pack.
+</Note>
+
+---
+
+## Editing the Intent
+
+The intent section is the most important part of the Lane Pack — it tells every agent what this lane exists to accomplish. ADE generates an initial intent from the branch name and early commits, but you should refine it to be specific.
+
+A weak intent:
+> Fix auth
+
+A strong intent:
+> Add a refresh token endpoint (`POST /auth/refresh`) that accepts an expired access token and a valid refresh token, validates the refresh token against the database, rotates it, and returns a new access/refresh token pair. The existing login endpoint must also return a refresh token in its response body.
+
+To edit the intent, open the lane in the Lanes panel and click the **intent** field in the right inspector's Packs sub-tab. Changes take effect on the next pack regeneration or immediately if you trigger a manual refresh.
+
+---
+
+## Pack Storage
+
+Lane Packs are stored as Markdown files in your project's `.ade` directory:
+
+```
+.ade/
+  artifacts/
+    packs/
+      lanes/
+        <lane-id>/
+          current.md        ← the latest pack
+          history/
+            <timestamp>.md  ← previous versions
+```
+
+Pack files are plain Markdown with stable section markers. You can read them in any text editor, diff them across versions, or use them outside ADE. History files are retained for 30 days by default (configurable in **Settings > Context > Pack History Retention**).
+
+---
+
+## Packs and Stacked Lanes
+
+In a stacked lane setup, each lane has its own Lane Pack. Child lanes inherit awareness of the parent lane's intent through the stack topology — but each pack is independently generated from that lane's specific diff and state.
+
+This means an agent working in a child lane knows:
+- What the child lane is specifically doing (from its own Lane Pack)
+- What the parent lane is doing (from the stack context included in the pack)
+- The full project context (from the Project Pack)
 
 ---
 
-### Context Injection
+## Troubleshooting
 
-When an agent starts in a lane, ADE prepends the Lane Pack as a system context block before the agent's first prompt. The agent receives the intent, criteria, touched files, and diff summary before it reads any user instructions. This means agents never start cold in a lane — they always know what they are working on and why.
+<AccordionGroup>
+  <Accordion title="Pack shows amber freshness but I just committed" icon="clock">
+    Pack regeneration runs asynchronously after a commit. Wait a few seconds, then check again. If it stays amber, trigger a manual refresh with `Cmd+Shift+P`.
+  </Accordion>
+  <Accordion title="Agent is ignoring the lane context" icon="robot">
+    Verify the pack exists and is fresh in the Packs sub-tab. If the pack is empty or missing, the agent may have started without lane-specific context. Regenerate the pack and start a new session.
+  </Accordion>
+  <Accordion title="Intent does not match what I am doing" icon="pen">
+    ADE infers the intent from branch names and commits, which may not capture your actual goal. Edit the intent manually in the Packs sub-tab — a precise intent significantly improves agent behavior.
+  </Accordion>
+  <Accordion title="Pack generation failed" icon="circle-exclamation">
+    Check ADE's developer logs (**Settings > Developer > Log file**). Pack generation requires access to the lane's worktree and git history. If the worktree is in a broken state (e.g., mid-rebase), resolve the git state first, then regenerate.
+  </Accordion>
+</AccordionGroup>
 
 ---
 
-## Learn More
+## Next Steps
 
-<Card title="Context Packs" icon="box" href="/context-packs/overview">
-  Understand how Lane Packs, Project Packs, and other pack types are generated, versioned, and used across ADE.
-</Card>
+<CardGroup cols={2}>
+  <Card title="Context Packs Overview" icon="cubes" href="/context-packs/overview">
+    Learn about all pack types — Project, Lane, Feature, Conflict, Plan, and Mission — and how they work together.
+  </Card>
+  <Card title="Pack Structure & Priority" icon="code" href="/context-packs/structure">
+    Understand the pack content contract, section markers, export levels, and context priority injection order.
+  </Card>
+</CardGroup>
diff --git a/lanes/stacks.mdx b/lanes/stacks.mdx
index bdc2f252c..85264b9ce 100644
--- a/lanes/stacks.mdx
+++ b/lanes/stacks.mdx
@@ -1,36 +1,185 @@
 ---
 title: "Stacked Lanes"
-description: "Arrange lanes into stacks — layered branch chains for stacked PR workflows with automatic rebase propagation and drag-to-reparent."
+description: "Arrange lanes into stacks — layered branch chains for stacked PR workflows with automatic rebase propagation, drag-to-reparent, and conflict-aware stack management."
 icon: "layer-group"
 ---
 
-## Stacks
+## What is a Stack?
 
-Lanes can be arranged into **stacks** — a layered chain where each lane's branch is based on another lane's branch, rather than directly on `main`. This enables stacked PR workflows where changes are reviewed incrementally.
+A stack is a chain of lanes where each lane's branch is based on another lane's branch instead of directly on `main`. This mirrors the stacked PR workflow used in many engineering teams — break a large feature into small, reviewable chunks that build on each other.
 
 ```
 main
-└── lane/auth-refactor        (base: main)
-    └── lane/auth-tests       (base: lane/auth-refactor)
-        └── lane/auth-docs    (base: lane/auth-tests)
+└── lane/auth-models        (base: main)
+    └── lane/auth-ui        (base: lane/auth-models)
+        └── lane/auth-tests (base: lane/auth-ui)
 ```
 
+Each lane in the stack maps to one pull request. Reviewers see small, focused diffs. The stack topology is tracked automatically — ADE knows which lanes depend on which, and uses this knowledge for rebase propagation, conflict detection, and PR targeting.
+
+---
+
+## Creating a Stack
+
+There are two ways to add a lane to a stack.
+
+<Tabs>
+  <Tab title="New Child Lane (recommended)">
+    <Steps>
+      <Step title="Select the parent lane">
+        In the Lanes panel, click the lane you want to build on top of.
+      </Step>
+      <Step title="Create a child lane">
+        Click **New Child Lane** from the lane's context menu or toolbar. ADE pre-fills the base branch to the parent lane's branch and sets the parent-child relationship in the stack topology.
+      </Step>
+      <Step title="Name the child">
+        Use a descriptive name that reflects the work this slice handles (e.g., `auth-ui` if the parent is `auth-models`). ADE uses this as both the lane identifier and the branch name.
+      </Step>
+    </Steps>
+  </Tab>
+  <Tab title="Set base branch manually">
+    When creating any new lane, expand the base branch selector and choose another lane's branch instead of `main`. ADE detects the parent-child relationship automatically and adds the lane to the stack.
+  </Tab>
+</Tabs>
+
+You can nest lanes as deep as needed — each child targets the lane directly above it. However, stacks deeper than 3-4 levels become harder to manage and review. If a stack is growing deep, consider whether some layers can be merged or parallelized.
+
+---
+
+## Viewing the Stack
+
+ADE surfaces stack relationships in multiple places:
+
+| Location | What you see |
+|----------|-------------|
+| **Lanes panel** | Indented tree showing parent-child relationships with depth indicators |
+| **Workspace Graph** | Connected chain of nodes with edges showing base-branch dependencies |
+| **PR panel** | Stack context in PR descriptions — which PR this builds on, full chain visualization |
+| **Lane detail** | Parent lane reference and stack depth in the lane header |
+
+The Workspace Graph is the most powerful view for stacks. Each lane appears as a node, and you can see status badges (uncommitted changes, open PRs, active agents, conflicts) at a glance across the entire chain.
+
+---
+
+## Stack Chain Resolution
+
+ADE resolves the full stack chain using a recursive query that walks parent-child relationships from any lane in the stack. The chain includes every lane from the root (the lane based on `main`) down to the deepest leaf.
+
+Each item in the chain tracks:
+- **Lane identity** — name, branch, and worktree path
+- **Depth** — how many levels from the root
+- **Status** — dirty state, ahead/behind counts relative to the parent, rebase state
+- **Parent reference** — which lane this one depends on
+
+This chain is used for rebase propagation, conflict simulation, and PR auto-targeting.
+
+---
+
+## Rebasing a Stack
+
+When a parent lane receives new commits, its children are now out of date. ADE handles this through **rebase suggestions** and **rebase runs**.
+
+### Rebase Suggestions
+
+ADE monitors the relationship between each lane and its parent. When the parent's HEAD moves ahead, ADE surfaces a rebase suggestion on each affected child with:
+- The number of commits the child is behind
+- A preview of what the rebase will touch
+- Whether the rebase is likely to conflict (based on merge simulation)
+
+You can **Accept** to rebase immediately, **Defer** to handle it later, or **Dismiss** if the suggestion is not relevant.
+
+### Rebase Scope
+
+When you start a rebase, ADE offers two scopes:
+
+| Scope | Behavior |
+|-------|----------|
+| **Lane only** (`lane_only`) | Rebases just the selected lane onto its updated parent. Child lanes below it are not touched. |
+| **Lane and descendants** (`lane_and_descendants`) | Rebases the selected lane, then propagates through every descendant in dependency order. This is the "rebase the whole stack" action. |
+
+### How Stack Rebase Works
+
+For a `lane_and_descendants` rebase, ADE creates a **Rebase Run** — a tracked operation that processes each lane in the chain sequentially:
+
+<Steps>
+  <Step title="Start from the target lane">
+    ADE rebases the selected lane onto its parent's current HEAD using `git rebase`.
+  </Step>
+  <Step title="Walk the descendants">
+    For each child lane in dependency order, ADE rebases it onto its parent's updated HEAD. The order is deterministic — children are processed in creation order within each level.
+  </Step>
+  <Step title="Handle conflicts">
+    If a conflict is detected during any lane's rebase, that lane enters `conflict` status and the run pauses. You resolve the conflict in that lane's worktree, then resume. Lanes below the conflicting lane are marked `blocked` until the conflict is resolved.
+  </Step>
+  <Step title="Optional push">
+    After a successful rebase, ADE can force-push each rebased lane's branch to its remote. You choose the push mode (`none` or `review_then_push`) when starting the rebase.
+  </Step>
+</Steps>
+
+Each Rebase Run tracks per-lane status (`pending`, `running`, `succeeded`, `conflict`, `blocked`, `skipped`), pre/post HEAD SHAs, and any errors. You can inspect the run in the Rebase tab or the History view.
+
+<Note>
+ADE uses `git rebase` (not `git rebase --onto`) for standard stack rebases. If conflicts occur, ADE aborts the rebase on that lane and enters conflict status rather than leaving the worktree in a partially-rebased state. The previous state is always recoverable.
+</Note>
+
+### Rollback
+
+If a rebase run produces unexpected results, you can roll it back. ADE records the pre-rebase HEAD SHA for each lane in the run, so rollback restores each lane to its exact state before the rebase started.
+
 ---
 
-### Creating a Stack
+## Drag-to-Reparent
+
+In the **Workspace Graph**, you can restructure a stack by dragging a lane node onto a different parent.
 
-When creating a new lane, set its **base branch** to the branch of an existing lane (rather than `main`). ADE recognizes this as a stack relationship and visualizes it in the Stack Graph view in the left pane.
+<Steps>
+  <Step title="Open the Workspace Graph">
+    Navigate to the Workspace Graph view from the sidebar.
+  </Step>
+  <Step title="Drag a lane node">
+    Click and drag a lane node onto the lane you want as its new parent.
+  </Step>
+  <Step title="Confirm the reparent">
+    ADE previews the operation and asks for confirmation. The preview shows:
+    - The old parent and new parent
+    - Whether a rebase is needed (it usually is)
+    - Any potential conflicts detected by merge simulation
+  </Step>
+  <Step title="ADE executes the reparent">
+    ADE updates the lane's base branch reference, then rebases the lane onto the new parent's HEAD. If the rebase fails due to conflicts, ADE aborts and reverts the base branch reference — the lane stays with its original parent.
+  </Step>
+</Steps>
+
+<Warning>
+You cannot reparent the primary lane, reparent a lane to itself, or create a circular dependency (e.g., making a parent lane a child of one of its descendants). ADE validates all of these cases before executing the reparent.
+</Warning>
 
 ---
 
-### Rebasing a Stack
+## Stacked PRs
+
+Stacks and stacked PRs are closely related. When you open a PR from a lane in a stack, ADE automatically targets the parent lane's branch (not `main`). When the base PR merges into `main`, ADE suggests retargeting the next child PR to `main` and rebasing.
+
+See the [Stacked PR Workflows guide](/guides/stacked-prs) for the full end-to-end workflow including landing strategies.
+
+---
 
-When the root lane's branch receives new commits (from a merge or rebase against `main`), ADE detects that child lanes are now stale and offers a **Rebase Stack** action. This propagates the parent's changes through each child in dependency order, handling the full rebase chain automatically.
+## Tips
 
-<Note>ADE uses `git rebase --onto` internally to rebase each child onto the updated parent. If conflicts are detected during this process, the affected lane enters `conflict` status and the rebase pauses for human resolution before continuing down the chain.</Note>
+- **Keep stacks shallow.** 2-3 levels is the sweet spot. Beyond 4 levels, rebase chains become slow and conflicts multiply.
+- **Rebase frequently.** Accept rebase suggestions promptly — the longer you wait, the more likely conflicts become.
+- **Use the Graph.** The Workspace Graph gives the best overview of stack health. Status badges tell you at a glance which lanes need attention.
+- **Land from the bottom.** Always merge the base PR first, then retarget and merge upward. Landing out of order creates unnecessary conflicts.
 
 ---
 
-### Drag-to-Reparent
+## Next Steps
 
-In the **Workspace Graph** view, you can drag a lane node onto another lane to change its base branch. ADE will preview the reparenting operation and ask for confirmation before executing the rebase chain.
+<CardGroup cols={2}>
+  <Card title="Stacked PR Workflows" icon="layer-group" href="/guides/stacked-prs">
+    Full guide for creating, reviewing, and landing stacked PRs using ADE lanes.
+  </Card>
+  <Card title="Workspace Graph" icon="diagram-project" href="/tools/workspace-graph">
+    Visualize stacks, run merge simulations, and drag-reparent lanes in the interactive graph.
+  </Card>
+</CardGroup>
diff --git a/tools/terminals.mdx b/tools/terminals.mdx
index cfd41b822..43952af1f 100644
--- a/tools/terminals.mdx
+++ b/tools/terminals.mdx
@@ -194,6 +194,23 @@ The profile script runs in every new terminal session in this project, including
 
 ---
 
+## Work View Grid
+
+The Work tab offers two grid modes for arranging terminal and chat sessions:
+
+- **Standard grid**: Fluid CSS Grid layout where session cards auto-fill available width. Good for uniform-sized sessions.
+- **Packed grid**: Resizable tile layout where each session has its own column and row span. Drag any edge or corner to resize a tile. The grid uses bin-packing to keep tiles compact and avoid wasted space. Tile sizes persist across session switches.
+
+Toggle between modes using the view-mode selector in the Work tab header.
+
+---
+
+## Terminal Renderer
+
+ADE uses **WebGL-first rendering** for terminal output, falling back to a **DOM-based renderer** if WebGL initialization fails (GPU issues, context loss, etc.). When a terminal is resized or moved between tiles, ADE validates the computed dimensions and retries the fit if they are too small — this prevents blank terminals during rapid layout transitions.
+
+---
+
 ## Terminal Themes
 
 All terminal sessions inherit ADE's global terminal theme. Change it in `Settings → Appearance → Terminal Theme`. Available themes: