diff --git a/apps/ade-cli/src/cli.ts b/apps/ade-cli/src/cli.ts
index cd0a9cb6c..4cfe020b5 100644
--- a/apps/ade-cli/src/cli.ts
+++ b/apps/ade-cli/src/cli.ts
@@ -1,6 +1,7 @@
 #!/usr/bin/env node
 import { Buffer } from "node:buffer";
 import { spawn, spawnSync } from "node:child_process";
+import { createHash } from "node:crypto";
 import fs from "node:fs";
 import net from "node:net";
 import path from "node:path";
@@ -7839,15 +7840,17 @@ function automationsExampleText(): string {
         laneMode: "create",
         laneNamePreset: "issue-num-title",
         session: {
-          prompt: "Investigate and propose a fix for {{trigger.issue.title}}.",
+          title: "Issue fix",
+          codexFastMode: true,
         },
       },
-      actions: [
-        {
-          type: "agent-session",
-          modelId: "claude-opus-4-7",
+      prompt: "Investigate and propose a fix for {{trigger.issue.title}}.",
+      modelConfig: {
+        orchestratorModel: {
+          modelId: "openai/gpt-5.5",
+          thinkingLevel: "xhigh",
         },
-      ],
+      },
     },
     null,
     2,
@@ -10256,6 +10259,14 @@ function shouldReplaceMachineRuntimeVersion(runtimeVersion: string | null): bool
   return runtimeVersion == null || runtimeVersion !== VERSION;
 }
 
+function computeRuntimeBuildHash(filePath: string): string | null {
+  try {
+    return createHash("sha256").update(fs.readFileSync(filePath)).digest("hex");
+  } catch {
+    return null;
+  }
+}
+
 async function initializeMachineRuntimeDaemon(
   client: SocketJsonRpcClient,
   options: GlobalOptions,
@@ -10291,6 +10302,7 @@ async function spawnMachineRuntimeDaemon(
   const { resolveAdeServeCommand } = await import("./serviceManager/common");
   const serviceCommand = resolveAdeServeCommand();
   const args = [...serviceCommand.args];
+  let runtimeBuildHash: string | null = null;
   if (
     serviceCommand.command === process.execPath &&
     args.length === 1 &&
@@ -10298,19 +10310,27 @@ async function spawnMachineRuntimeDaemon(
     fs.existsSync(CLI_DIST_PATH)
   ) {
     args.splice(0, 1, CLI_DIST_PATH, "serve");
+    runtimeBuildHash = computeRuntimeBuildHash(CLI_DIST_PATH);
+  } else if (serviceCommand.command === process.execPath && args[0]) {
+    runtimeBuildHash = computeRuntimeBuildHash(path.resolve(args[0]));
   }
   args.push("--socket", socketPath);
 
+  const env: NodeJS.ProcessEnv = {
+    ...process.env,
+    ...(serviceCommand.env ?? {}),
+    ADE_DEFAULT_ROLE: options.role,
+    ADE_RPC_SOCKET_PATH: socketPath,
+    ADE_RUNTIME_SOCKET_PATH: socketPath,
+  };
+  if (runtimeBuildHash) {
+    env.ADE_RUNTIME_BUILD_HASH = runtimeBuildHash;
+  }
+
   const child = spawn(serviceCommand.command, args, {
     detached: true,
     stdio: "ignore",
-    env: {
-      ...process.env,
-      ...(serviceCommand.env ?? {}),
-      ADE_DEFAULT_ROLE: options.role,
-      ADE_RPC_SOCKET_PATH: socketPath,
-      ADE_RUNTIME_SOCKET_PATH: socketPath,
-    },
+    env,
   });
   child.once("error", () => {});
   child.unref();
diff --git a/apps/ade-cli/src/services/projects/projectScope.test.ts b/apps/ade-cli/src/services/projects/projectScope.test.ts
index 00334a181..ad76c4a92 100644
--- a/apps/ade-cli/src/services/projects/projectScope.test.ts
+++ b/apps/ade-cli/src/services/projects/projectScope.test.ts
@@ -140,14 +140,24 @@ describe("ProjectScopeRegistry", () => {
     await scopeRegistry.disposeAll();
   });
 
-  it("can switch the daemon sync host to a requested project", async () => {
+  it("switches the daemon sync host without disposing active project scopes", async () => {
     const { registry, first, second } = createRegistry();
     const firstDispose = vi.fn();
     const secondDispose = vi.fn();
     const onDisposeProject = vi.fn();
+    const firstSyncService = {
+      initialize: vi.fn(async () => undefined),
+      setHostDiscoveryEnabled: vi.fn(),
+      setHostStartupEnabled: vi.fn(async () => undefined),
+    };
+    const secondSyncService = {
+      initialize: vi.fn(async () => undefined),
+      setHostDiscoveryEnabled: vi.fn(),
+      setHostStartupEnabled: vi.fn(async () => undefined),
+    };
     createAdeRuntimeMock
-      .mockResolvedValueOnce({ dispose: firstDispose })
-      .mockResolvedValueOnce({ dispose: secondDispose });
+      .mockResolvedValueOnce({ dispose: firstDispose, syncService: firstSyncService })
+      .mockResolvedValueOnce({ dispose: secondDispose, syncService: secondSyncService });
     const scopeRegistry = new ProjectScopeRegistry(registry, {
       onDisposeProject,
       syncRuntime: {
@@ -162,8 +172,14 @@ describe("ProjectScopeRegistry", () => {
     await scopeRegistry.ensureSyncHost(first.projectId);
     await scopeRegistry.ensureSyncHost(second.projectId);
 
-    expect(firstDispose).toHaveBeenCalledTimes(1);
-    expect(onDisposeProject).toHaveBeenCalledWith(first.projectId);
+    expect(firstDispose).not.toHaveBeenCalled();
+    expect(secondDispose).not.toHaveBeenCalled();
+    expect(onDisposeProject).not.toHaveBeenCalled();
+    expect(firstSyncService.setHostDiscoveryEnabled).toHaveBeenCalledWith(false);
+    expect(firstSyncService.setHostStartupEnabled).toHaveBeenCalledWith(false);
+    expect(secondSyncService.setHostDiscoveryEnabled).toHaveBeenCalledWith(true);
+    expect(secondSyncService.setHostStartupEnabled).toHaveBeenCalledWith(true);
+    expect(secondSyncService.initialize).toHaveBeenCalled();
     expect(createAdeRuntimeMock).toHaveBeenCalledTimes(2);
     expect(createAdeRuntimeMock.mock.calls[1]?.[0]).toMatchObject({
       projectRoot: second.rootPath,
@@ -176,9 +192,58 @@ describe("ProjectScopeRegistry", () => {
     });
 
     await scopeRegistry.disposeAll();
+    expect(firstDispose).toHaveBeenCalledTimes(1);
     expect(secondDispose).toHaveBeenCalledTimes(1);
   });
 
+  it("promotes an existing warm project when selecting the default sync host", async () => {
+    const { registry, first, second } = createRegistry();
+    const firstSyncService = {
+      initialize: vi.fn(async () => undefined),
+      setHostDiscoveryEnabled: vi.fn(),
+      setHostStartupEnabled: vi.fn(async () => undefined),
+    };
+    const secondSyncService = {
+      initialize: vi.fn(async () => undefined),
+      setHostDiscoveryEnabled: vi.fn(),
+      setHostStartupEnabled: vi.fn(async () => undefined),
+    };
+    createAdeRuntimeMock
+      .mockResolvedValueOnce({ dispose: vi.fn(), syncService: firstSyncService })
+      .mockResolvedValueOnce({ dispose: vi.fn(), syncService: secondSyncService });
+    const scopeRegistry = new ProjectScopeRegistry(registry, {
+      syncRuntime: {
+        enabled: true,
+        hostStartupEnabled: true,
+        hostDiscoveryEnabled: true,
+        forceHostRole: true,
+        runtimeKind: "daemon",
+      },
+    });
+
+    await scopeRegistry.ensureSyncHost(first.projectId);
+    await scopeRegistry.get(second.projectId);
+    const file = JSON.parse(fs.readFileSync(registry.path, "utf8")) as {
+      projects: Array<{ projectId: string; lastOpenedAt: number; addedAt: number }>;
+    };
+    file.projects = file.projects.map((project) => ({
+      ...project,
+      lastOpenedAt: project.projectId === second.projectId ? 2_000 : 1_000,
+      addedAt: project.projectId === second.projectId ? 2_000 : 1_000,
+    }));
+    fs.writeFileSync(registry.path, JSON.stringify(file, null, 2));
+    await scopeRegistry.dispose(first.projectId);
+    const promoted = await scopeRegistry.ensureSyncHost();
+
+    expect(promoted?.registryProjectId).toBe(second.projectId);
+    expect(createAdeRuntimeMock).toHaveBeenCalledTimes(2);
+    expect(secondSyncService.setHostDiscoveryEnabled).toHaveBeenCalledWith(true);
+    expect(secondSyncService.setHostStartupEnabled).toHaveBeenCalledWith(true);
+    expect(secondSyncService.initialize).toHaveBeenCalled();
+
+    await scopeRegistry.disposeAll();
+  });
+
   it("passes runtime capability options into project runtimes", async () => {
     const { registry, first } = createRegistry();
     const scopeRegistry = new ProjectScopeRegistry(registry, {
diff --git a/apps/ade-cli/src/services/projects/projectScope.ts b/apps/ade-cli/src/services/projects/projectScope.ts
index c2a8d0f20..6ff7d5538 100644
--- a/apps/ade-cli/src/services/projects/projectScope.ts
+++ b/apps/ade-cli/src/services/projects/projectScope.ts
@@ -112,15 +112,21 @@ export class ProjectScopeRegistry {
   async ensureSyncHost(projectId?: ProjectId): Promise<ProjectScope | null> {
     if (!this.options.syncRuntime?.enabled) return null;
     if (projectId) {
-      if (this.scopes.has(projectId) && this.syncHostProjectId !== projectId) {
-        await this.dispose(projectId);
-      }
       const existingHostId = this.syncHostProjectId;
       if (existingHostId && existingHostId !== projectId) {
-        await this.dispose(existingHostId);
+        await this.configureCachedSyncHost(existingHostId, false);
       }
       this.syncHostProjectId = projectId;
-      return await this.get(projectId);
+      try {
+        const scope = await this.get(projectId);
+        await this.configureSyncHost(scope, true);
+        return scope;
+      } catch (error) {
+        if (this.syncHostProjectId === projectId) {
+          this.syncHostProjectId = null;
+        }
+        throw error;
+      }
     }
 
     const existingHostId = this.syncHostProjectId;
@@ -139,7 +145,28 @@ export class ProjectScopeRegistry {
         const openedDelta = right.lastOpenedAt - left.lastOpenedAt;
         return openedDelta !== 0 ? openedDelta : right.addedAt - left.addedAt;
       })[0];
-    return record ? this.get(record.projectId) : null;
+    return record ? this.ensureSyncHost(record.projectId) : null;
+  }
+
+  private async configureCachedSyncHost(
+    projectId: ProjectId,
+    enabled: boolean,
+  ): Promise<void> {
+    const cached = this.scopes.get(projectId);
+    if (!cached) return;
+    const scope = await cached.catch(() => null);
+    if (scope) await this.configureSyncHost(scope, enabled);
+  }
+
+  private async configureSyncHost(
+    scope: ProjectScope,
+    enabled: boolean,
+  ): Promise<void> {
+    const syncService = scope.runtime.syncService;
+    if (!syncService) return;
+    syncService.setHostDiscoveryEnabled?.(enabled);
+    await syncService.setHostStartupEnabled?.(enabled);
+    if (enabled) await syncService.initialize();
   }
 
   private buildSyncRuntimeOptions(projectId: ProjectId): AdeRuntimeSyncOptions | null {
diff --git a/apps/ade-cli/src/tuiClient/app.tsx b/apps/ade-cli/src/tuiClient/app.tsx
index a6cd53664..bc1ffdf67 100644
--- a/apps/ade-cli/src/tuiClient/app.tsx
+++ b/apps/ade-cli/src/tuiClient/app.tsx
@@ -551,176 +551,8 @@ function formatContextUsage(usage: AgentChatContextUsage | null): string {
     .join("\n");
 }
 
-function buildResolvedSubagentIdsByParent(events: AgentChatEventEnvelope[]): Map<string, Set<string>> {
-  const idsByParent = new Map<string, Set<string>>();
-  for (const envelope of events) {
-    const event = envelope.event as Record<string, unknown>;
-    const type = typeof event.type === "string" ? event.type : "";
-    if (!type.startsWith("subagent")) continue;
-    const parent = typeof event.parentToolUseId === "string" && event.parentToolUseId.trim()
-      ? event.parentToolUseId.trim()
-      : null;
-    if (!parent) continue;
-    const taskId = typeof event.taskId === "string" && event.taskId.trim() ? event.taskId.trim() : null;
-    const agentId = typeof event.agentId === "string" && event.agentId.trim() ? event.agentId.trim() : null;
-    const id = agentId ?? taskId;
-    if (!id || id === parent) continue;
-    const ids = idsByParent.get(parent) ?? new Set<string>();
-    ids.add(id);
-    idsByParent.set(parent, ids);
-  }
-  return idsByParent;
-}
-
-function isParentSubagentPlaceholder(snapshot: SubagentSnapshot | undefined, parentToolUseId: string): snapshot is SubagentSnapshot {
-  return Boolean(
-    snapshot
-      && snapshot.id === parentToolUseId
-      && snapshot.parentToolUseId === parentToolUseId,
-  );
-}
-
-export function subagentSnapshotsFromEvents(events: AgentChatEventEnvelope[]): SubagentSnapshot[] {
-  const snapshots = new Map<string, SubagentSnapshot>();
-  const terminalTurnIds = new Set<string>();
-  const resolvedIdsByParent = buildResolvedSubagentIdsByParent(events);
-
-  for (const envelope of events) {
-    const event = envelope.event as Record<string, unknown>;
-    const turnId = typeof event.turnId === "string" ? event.turnId : null;
-    if (!turnId) continue;
-    const isDone = event.type === "done";
-    const isTerminalStatus = event.type === "status" && event.turnStatus !== "started";
-    if (isDone || isTerminalStatus) terminalTurnIds.add(turnId);
-  }
-
-  for (const envelope of events) {
-    const event = envelope.event as Record<string, unknown>;
-    const type = typeof event.type === "string" ? event.type : "";
-
-    if (type === "teammate.idle") {
-      const teamName = typeof event.teamName === "string" ? event.teamName : "";
-      const teammateName = typeof event.teammateName === "string" ? event.teammateName : "";
-      if (!teammateName) continue;
-      const id = `teammate:${teamName}:${teammateName}`;
-      const existing = snapshots.get(id);
-      snapshots.set(id, {
-        id,
-        name: teamName ? `${teamName}/${teammateName}` : teammateName,
-        kind: "teammate",
-        status: "running",
-        summary: existing?.summary ?? "idle",
-        turnId: typeof event.turnId === "string" ? event.turnId : existing?.turnId,
-        startedAt: existing?.startedAt ?? envelope.timestamp,
-        tokens: existing?.tokens,
-        durationMs: existing?.durationMs,
-        lastToolName: existing?.lastToolName,
-      });
-      continue;
-    }
-
-    if (type === "task.completed") {
-      const teamName = typeof event.teamName === "string" ? event.teamName : "";
-      const teammateName = typeof event.teammateName === "string" ? event.teammateName : "";
-      const subject = typeof event.subject === "string" ? event.subject : "";
-      if (!teammateName) continue;
-      const id = `teammate:${teamName}:${teammateName}`;
-      const existing = snapshots.get(id);
-      snapshots.set(id, {
-        id,
-        name: existing?.name ?? (teamName ? `${teamName}/${teammateName}` : teammateName),
-        kind: "teammate",
-        status: "completed",
-        summary: subject || existing?.summary || "",
-        turnId: typeof event.turnId === "string" ? event.turnId : existing?.turnId,
-        startedAt: existing?.startedAt ?? envelope.timestamp,
-        endedAt: envelope.timestamp,
-        tokens: existing?.tokens,
-        durationMs: existing?.durationMs,
-        lastToolName: existing?.lastToolName,
-      });
-      continue;
-    }
-
-    if (!type.startsWith("subagent")) continue;
-    const taskId = typeof event.taskId === "string" && event.taskId.trim() ? event.taskId.trim() : null;
-    const agentId = typeof event.agentId === "string" && event.agentId.trim() ? event.agentId.trim() : null;
-    const id = agentId ?? taskId;
-    if (!id) continue;
-    const incomingParentToolUseId = typeof event.parentToolUseId === "string" && event.parentToolUseId.trim()
-      ? event.parentToolUseId.trim()
-      : null;
-    const parentPlaceholder = incomingParentToolUseId ? snapshots.get(incomingParentToolUseId) : undefined;
-    const parentResolvedIds = incomingParentToolUseId ? resolvedIdsByParent.get(incomingParentToolUseId) : undefined;
-    const parentIsPlaceholder = Boolean(
-      incomingParentToolUseId
-        && isParentSubagentPlaceholder(parentPlaceholder, incomingParentToolUseId),
-    );
-    const canAdoptParentPlaceholder = parentIsPlaceholder
-      && parentResolvedIds?.size === 1
-      && parentResolvedIds.has(id);
-    const taskAlias = taskId && taskId !== id ? snapshots.get(taskId) : undefined;
-    const existing = snapshots.get(id) ?? taskAlias ?? (canAdoptParentPlaceholder ? parentPlaceholder : undefined);
-    if (taskId && id !== taskId) snapshots.delete(taskId);
-    if (
-      incomingParentToolUseId
-      && parentIsPlaceholder
-      && (canAdoptParentPlaceholder || (parentResolvedIds && parentResolvedIds.size > 1))
-    ) {
-      snapshots.delete(incomingParentToolUseId);
-    }
-    const agentType = typeof event.agentType === "string" ? event.agentType : "subagent";
-    const usage = event.usage && typeof event.usage === "object" ? event.usage as Record<string, unknown> : {};
-    const parentToolUseId = incomingParentToolUseId ?? existing?.parentToolUseId ?? null;
-    const startedAt = existing?.startedAt ?? envelope.timestamp;
-    const endedAt = type === "subagent_result" || type === "subagent.completed" ? envelope.timestamp : existing?.endedAt;
-    const parsedDurationMs = endedAt && startedAt ? Date.parse(endedAt) - Date.parse(startedAt) : Number.NaN;
-    const fallbackDurationMs = Number.isFinite(parsedDurationMs) ? Math.max(0, parsedDurationMs) : existing?.durationMs;
-    const summaryFromEvent = [event.summary, event.finalSummary, event.text, event.description]
-      .find((value): value is string => typeof value === "string" && value.trim().length > 0);
-    const summary = summaryFromEvent ?? existing?.summary ?? "";
-    const base: SubagentSnapshot = {
-      id,
-      name: typeof event.description === "string" ? event.description : existing?.name ?? agentType,
-      kind: "subagent",
-      status: existing?.status ?? "running",
-      summary,
-      parentToolUseId,
-      turnId: typeof event.turnId === "string" ? event.turnId : existing?.turnId ?? null,
-      background: event.background === true || existing?.background === true,
-      startedAt,
-      endedAt,
-      tokens: typeof usage.totalTokens === "number" ? usage.totalTokens : typeof event.tokens === "number" ? event.tokens : existing?.tokens,
-      durationMs: typeof usage.durationMs === "number" ? usage.durationMs : fallbackDurationMs,
-      lastToolName: typeof event.lastToolName === "string" ? event.lastToolName : existing?.lastToolName,
-    };
-    if (type === "subagent_result" || type === "subagent.completed") {
-      const status = event.status === "failed" || event.status === "stopped" || event.status === "completed" ? event.status : "completed";
-      snapshots.set(id, { ...base, status });
-    } else {
-      snapshots.set(id, { ...base, status: "running" });
-    }
-  }
-
-  for (const [key, snapshot] of snapshots) {
-    if (
-      snapshot.kind === "subagent"
-      && snapshot.status === "running"
-      && snapshot.background !== true
-      && snapshot.turnId
-      && terminalTurnIds.has(snapshot.turnId)
-    ) {
-      const terminalSummary = "Parent turn ended before ADE received a final subagent status";
-      snapshots.set(key, {
-        ...snapshot,
-        status: "stopped",
-        summary: snapshot.summary && snapshot.summary !== snapshot.name ? snapshot.summary : terminalSummary,
-      });
-    }
-  }
-
-  return [...snapshots.values()];
-}
+import { subagentSnapshotsFromEvents } from "../../../desktop/src/shared/chatSubagents";
+export { subagentSnapshotsFromEvents };
 
 function isLaneWorktreeAvailable(lane: LaneSummary | null | undefined): boolean {
   const root = lane?.worktreePath?.trim();
diff --git a/apps/ade-cli/src/tuiClient/chatInfo.ts b/apps/ade-cli/src/tuiClient/chatInfo.ts
index 4bfe9a7b2..76cc9a780 100644
--- a/apps/ade-cli/src/tuiClient/chatInfo.ts
+++ b/apps/ade-cli/src/tuiClient/chatInfo.ts
@@ -1,11 +1,10 @@
 import type {
-  AgentChatEvent,
   AgentChatEventEnvelope,
   AgentChatSessionSummary,
 } from "../../../desktop/src/shared/types/chat";
+import { latestPlan } from "../../../desktop/src/shared/chatSubagents";
 import type {
   AdeCodeProvider,
-  ChatInfoPlan,
   ChatInfoSnapshot,
   SubagentSnapshot,
 } from "./types";
@@ -34,26 +33,6 @@ function tokenStatsSummary(stats: TokenStats | null): string | null {
   return parts.length ? parts.join(" ") : null;
 }
 
-function planFromEvent(event: Extract<AgentChatEvent, { type: "plan" }>): ChatInfoPlan {
-  const completed = event.steps.filter((step) => step.status === "completed").length;
-  const inProgress = event.steps.findIndex((step) => step.status === "in_progress");
-  const current = inProgress >= 0 ? inProgress + 1 : completed;
-  return {
-    current,
-    total: event.steps.length,
-    steps: event.steps.map((step) => ({ text: step.text, status: step.status })),
-    live: event.steps.some((step) => step.status === "in_progress"),
-  };
-}
-
-function latestPlan(events: AgentChatEventEnvelope[]): ChatInfoPlan {
-  for (let index = events.length - 1; index >= 0; index -= 1) {
-    const event = events[index]?.event;
-    if (event?.type === "plan") return planFromEvent(event);
-  }
-  return null;
-}
-
 export function deriveChatInfoSnapshot(args: {
   events: AgentChatEventEnvelope[];
   activeSession: AgentChatSessionSummary | null;
diff --git a/apps/ade-cli/src/tuiClient/subagentPane.ts b/apps/ade-cli/src/tuiClient/subagentPane.ts
index 5d4b77a5f..a6451cd5c 100644
--- a/apps/ade-cli/src/tuiClient/subagentPane.ts
+++ b/apps/ade-cli/src/tuiClient/subagentPane.ts
@@ -1,23 +1,20 @@
-import type {
-  AgentChatEvent,
-  AgentChatEventEnvelope,
-  AgentChatSessionSummary,
-} from "../../../desktop/src/shared/types/chat";
 import type { AdeCodeProvider, RightPaneContent, SubagentSnapshot } from "./types";
-import { workEventItemId, workEventParentItemId } from "./workEventIds";
-
-export type SubagentPaneSection = "main" | "subagents" | "teammates" | "background";
-
-export type SubagentPaneRow =
-  | { kind: "main"; key: "main"; section: "main"; label: string }
-  | { kind: "snapshot"; key: string; section: Exclude<SubagentPaneSection, "main">; snapshot: SubagentSnapshot };
-
-// Vertical offset of the first selectable roster row in the rendered chat-info
-// pane (header + status + plan + goal occupy the preceding lines). Used only by
-// the mouse-click → row mapper.
-const SUBAGENT_PANE_TABLE_START_LINE = 4;
-
-export type SubagentPaneContent = {
+import type { SubagentPaneContent as SharedSubagentPaneContent } from "../../../desktop/src/shared/chatSubagents";
+
+export {
+  buildSubagentPaneRows,
+  buildSubagentTranscriptEvents,
+  isLifecycleEventForSnapshot,
+  selectedSubagentSnapshot,
+  subagentIndexForPaneLine,
+  subagentPaneSelectableLineOffsets,
+} from "../../../desktop/src/shared/chatSubagents";
+export type {
+  SubagentPaneRow,
+  SubagentPaneSection,
+} from "../../../desktop/src/shared/chatSubagents";
+
+export type SubagentPaneContent = SharedSubagentPaneContent & {
   provider: AdeCodeProvider;
   snapshots: SubagentSnapshot[];
 };
@@ -31,237 +28,3 @@ export function subagentPaneContentFromRightPane(content: RightPaneContent): Sub
   }
   return null;
 }
-
-export function buildSubagentPaneRows(content: SubagentPaneContent): SubagentPaneRow[] {
-  const foregroundSubagents = content.snapshots.filter((snap) => (
-    snap.kind === "subagent"
-    && snap.background !== true
-  ));
-  const runningWeight = (snap: SubagentSnapshot): number => (snap.status === "running" ? 0 : 1);
-  const sortedForegroundSubagents = [...foregroundSubagents].sort(
-    (left, right) => runningWeight(left) - runningWeight(right),
-  );
-  const teammates = content.snapshots.filter((snap) => snap.kind === "teammate");
-  const background = content.snapshots.filter((snap) => snap.kind === "subagent" && snap.background === true);
-
-  return [
-    { kind: "main", key: "main", section: "main", label: "main" },
-    ...sortedForegroundSubagents.map((snapshot) => ({ kind: "snapshot" as const, key: snapshot.id, section: "subagents" as const, snapshot })),
-    ...teammates.map((snapshot) => ({ kind: "snapshot" as const, key: snapshot.id, section: "teammates" as const, snapshot })),
-    ...background.map((snapshot) => ({ kind: "snapshot" as const, key: snapshot.id, section: "background" as const, snapshot })),
-  ];
-}
-
-export function selectedSubagentSnapshot(
-  content: SubagentPaneContent,
-  selectedIndex: number,
-): SubagentSnapshot | null {
-  const row = buildSubagentPaneRows(content)[selectedIndex] ?? null;
-  return row?.kind === "snapshot" ? row.snapshot : null;
-}
-
-export function subagentPaneSelectableLineOffsets(
-  content: SubagentPaneContent,
-  selectedIndex = 0,
-): number[] {
-  const rows = buildSubagentPaneRows(content);
-  const offsets: number[] = [];
-  let line = SUBAGENT_PANE_TABLE_START_LINE;
-
-  for (let index = 0; index < rows.length; index += 1) {
-    const row = rows[index]!;
-    const previous = rows[index - 1];
-    const showSection = row.section !== "main" && previous?.section !== row.section;
-    if (showSection) line += 2;
-    offsets.push(line);
-    line += 1;
-    const selectedSnapshotHasDetail = row.kind === "snapshot"
-      && index === selectedIndex
-      && (row.snapshot.lastToolName || row.snapshot.summary);
-    if (row.kind === "main" || selectedSnapshotHasDetail) {
-      line += 1;
-    }
-  }
-
-  return offsets;
-}
-
-export function subagentIndexForPaneLine(
-  content: SubagentPaneContent,
-  line: number,
-  selectedIndex = 0,
-): number | null {
-  if (!Number.isFinite(line)) return null;
-  const offsets = subagentPaneSelectableLineOffsets(content, selectedIndex);
-  if (!offsets.length) return null;
-  const first = offsets[0]!;
-  const last = offsets[offsets.length - 1]!;
-  if (line < first - 1 || line > last + 1) return null;
-
-  let bestIndex = 0;
-  let bestDistance = Number.POSITIVE_INFINITY;
-  for (let index = 0; index < offsets.length; index += 1) {
-    const distance = Math.abs(line - offsets[index]!);
-    if (distance < bestDistance) {
-      bestIndex = index;
-      bestDistance = distance;
-    }
-  }
-  return bestIndex;
-}
-
-function textField(value: unknown): string | null {
-  return typeof value === "string" && value.trim().length > 0 ? value.trim() : null;
-}
-
-function eventType(event: AgentChatEvent): string {
-  return String((event as { type?: unknown }).type ?? "");
-}
-
-function eventSubagentIds(event: AgentChatEvent): string[] {
-  const record = event as { taskId?: unknown; agentId?: unknown };
-  const ids = [
-    textField(record.taskId),
-    textField(record.agentId),
-  ].filter((value): value is string => value != null);
-  return [...new Set(ids)];
-}
-
-function eventParentToolUseId(event: AgentChatEvent): string | null {
-  return textField((event as { parentToolUseId?: unknown }).parentToolUseId);
-}
-
-function isLifecycleEventForSnapshot(event: AgentChatEvent, snapshot: SubagentSnapshot): boolean {
-  const type = eventType(event);
-  if (snapshot.kind === "teammate") {
-    if (type === "teammate.idle" || type === "task.completed") {
-      const record = event as { teamName?: unknown; teammateName?: unknown };
-      const teamName = textField(record.teamName) ?? "";
-      const teammateName = textField(record.teammateName) ?? "";
-      return snapshot.id === `teammate:${teamName}:${teammateName}`;
-    }
-    return false;
-  }
-  if (
-    type !== "subagent_started"
-    && type !== "subagent_progress"
-    && type !== "subagent_result"
-    && type !== "subagent.started"
-    && type !== "subagent.progress"
-    && type !== "subagent.completed"
-  ) {
-    return false;
-  }
-  const explicitIds = eventSubagentIds(event);
-  if (explicitIds.length > 0) return explicitIds.includes(snapshot.id);
-  const parentToolUseId = eventParentToolUseId(event);
-  return Boolean(snapshot.parentToolUseId && parentToolUseId === snapshot.parentToolUseId);
-}
-
-function lifecycleText(event: AgentChatEvent, snapshot: SubagentSnapshot): string | null {
-  const type = eventType(event);
-  const record = event as {
-    description?: unknown;
-    summary?: unknown;
-    finalSummary?: unknown;
-    text?: unknown;
-    subject?: unknown;
-    status?: unknown;
-  };
-  if (type === "subagent_started" || type === "subagent.started") {
-    return "Started.";
-  }
-  if (type === "subagent_progress" || type === "subagent.progress") {
-    return textField(record.summary) ?? textField(record.text) ?? null;
-  }
-  if (type === "subagent_result" || type === "subagent.completed") {
-    const status = textField(record.status) ?? snapshot.status;
-    const summary = textField(record.finalSummary) ?? textField(record.summary) ?? snapshot.summary;
-    return `${status}: ${summary || snapshot.name}`;
-  }
-  if (type === "teammate.idle") {
-    return `Teammate idle: ${snapshot.name}`;
-  }
-  if (type === "task.completed") {
-    return `completed: ${textField(record.subject) ?? snapshot.summary ?? snapshot.name}`;
-  }
-  return null;
-}
-
-function syntheticTextEvent(
-  sessionId: string,
-  timestamp: string,
-  sequence: number,
-  turnId: string | null | undefined,
-  text: string,
-): AgentChatEventEnvelope {
-  return {
-    sessionId,
-    timestamp,
-    sequence,
-    event: {
-      type: "text",
-      text,
-      ...(turnId ? { turnId } : {}),
-    },
-  };
-}
-
-export function buildSubagentTranscriptEvents(args: {
-  events: AgentChatEventEnvelope[];
-  activeSession: AgentChatSessionSummary | null;
-  snapshot: SubagentSnapshot;
-}): AgentChatEventEnvelope[] {
-  const sessionId = args.activeSession?.sessionId ?? args.events[0]?.sessionId ?? "subagent";
-  const parentToolUseId = textField(args.snapshot.parentToolUseId);
-  const childItemIds = new Set<string>();
-
-  if (parentToolUseId) {
-    for (const envelope of args.events) {
-      const event = envelope.event;
-      const parentItemId = workEventParentItemId(event);
-      const itemId = workEventItemId(event);
-      if (parentItemId === parentToolUseId && itemId) {
-        childItemIds.add(itemId);
-      }
-    }
-  }
-
-  const transcript: AgentChatEventEnvelope[] = [
-    syntheticTextEvent(
-      sessionId,
-      args.snapshot.startedAt ?? args.events[0]?.timestamp ?? new Date(0).toISOString(),
-      -2,
-      args.snapshot.turnId,
-      `Viewing ${args.snapshot.kind === "teammate" ? "teammate" : args.snapshot.background ? "background agent" : "agent"} transcript. Select Main chat in Chat Info to return.\nTask: ${args.snapshot.name}`,
-    ),
-  ];
-
-  for (const envelope of args.events) {
-    const event = envelope.event;
-    if (isLifecycleEventForSnapshot(event, args.snapshot)) {
-      const text = lifecycleText(event, args.snapshot);
-      if (text) {
-        transcript.push(syntheticTextEvent(sessionId, envelope.timestamp, envelope.sequence ?? 0, args.snapshot.turnId, text));
-      }
-      continue;
-    }
-    const parentItemId = workEventParentItemId(event);
-    const itemId = workEventItemId(event);
-    if (parentToolUseId && (parentItemId === parentToolUseId || (itemId != null && childItemIds.has(itemId)))) {
-      transcript.push(envelope);
-    }
-  }
-
-  if (transcript.length === 1) {
-    transcript.push(syntheticTextEvent(
-      sessionId,
-      args.snapshot.endedAt ?? args.events.at(-1)?.timestamp ?? new Date(0).toISOString(),
-      -1,
-      args.snapshot.turnId,
-      args.snapshot.summary || "No detailed transcript rows were recorded for this agent.",
-    ));
-  }
-
-  return transcript;
-}
diff --git a/apps/ade-cli/src/tuiClient/types.ts b/apps/ade-cli/src/tuiClient/types.ts
index 7d63213f8..b8ae77f70 100644
--- a/apps/ade-cli/src/tuiClient/types.ts
+++ b/apps/ade-cli/src/tuiClient/types.ts
@@ -107,33 +107,8 @@ export type SetupPaneRow = {
   cyclable?: boolean;
 };
 
-export type SubagentSnapshot = {
-  id: string;
-  name: string;
-  kind: "subagent" | "teammate";
-  status: "running" | "completed" | "failed" | "stopped";
-  summary: string;
-  parentToolUseId?: string | null;
-  turnId?: string | null;
-  background?: boolean;
-  startedAt?: string | null;
-  endedAt?: string | null;
-  tokens?: number;
-  durationMs?: number;
-  lastToolName?: string;
-};
-
-export type ChatInfoPlanStep = {
-  text: string;
-  status: "pending" | "in_progress" | "completed" | "failed";
-};
-
-export type ChatInfoPlan = {
-  current: number;
-  total: number;
-  steps: ChatInfoPlanStep[];
-  live: boolean;
-} | null;
+export type { SubagentSnapshot, ChatInfoPlan, ChatInfoPlanStep } from "../../../desktop/src/shared/chatSubagents";
+import type { SubagentSnapshot, ChatInfoPlan } from "../../../desktop/src/shared/chatSubagents";
 
 export type ChatInfoSnapshot = {
   provider: AdeCodeProvider;
diff --git a/apps/desktop/scripts/dev.cjs b/apps/desktop/scripts/dev.cjs
index 5720f9eaf..cb3ab1026 100644
--- a/apps/desktop/scripts/dev.cjs
+++ b/apps/desktop/scripts/dev.cjs
@@ -207,7 +207,23 @@ async function ensureDevIcon() {
   }
 }
 
+async function ensureAdeCliBuild() {
+  const builder = path.join(__dirname, "ensure-ade-cli-build.cjs");
+  if (!fs.existsSync(builder)) return;
+  const result = cp.spawnSync(process.execPath, [builder], {
+    cwd: projectRoot,
+    stdio: "inherit",
+  });
+  if (result.error) {
+    throw result.error;
+  }
+  if (result.status !== 0) {
+    throw new Error(`ADE CLI build check failed with exit code ${result.status ?? "unknown"}`);
+  }
+}
+
 async function main() {
+  await ensureAdeCliBuild();
   await ensureDevIcon();
   const devPort = await choosePort(5173, 32);
   const devServerUrl = `http://localhost:${devPort}`;
diff --git a/apps/desktop/scripts/ensure-ade-cli-build.cjs b/apps/desktop/scripts/ensure-ade-cli-build.cjs
new file mode 100644
index 000000000..dfb9c3f5f
--- /dev/null
+++ b/apps/desktop/scripts/ensure-ade-cli-build.cjs
@@ -0,0 +1,88 @@
+#!/usr/bin/env node
+
+const cp = require("node:child_process");
+const fs = require("node:fs");
+const path = require("node:path");
+
+const desktopRoot = path.resolve(__dirname, "..");
+const repoRoot = path.resolve(desktopRoot, "..", "..");
+const cliRoot = path.join(repoRoot, "apps", "ade-cli");
+
+const distFiles = [
+  path.join(cliRoot, "dist", "cli.cjs"),
+  path.join(cliRoot, "dist", "bootstrap.cjs"),
+  path.join(cliRoot, "dist", "adeRpcServer.cjs"),
+  path.join(cliRoot, "dist", "tuiClient", "cli.mjs"),
+];
+
+const sourceEntries = [
+  path.join(cliRoot, "src"),
+  path.join(cliRoot, "package.json"),
+  path.join(cliRoot, "package-lock.json"),
+  path.join(cliRoot, "tsconfig.json"),
+  path.join(cliRoot, "tsup.config.ts"),
+];
+
+function newestMtimeMs(entryPath) {
+  let newest = 0;
+  const stack = [entryPath];
+  while (stack.length > 0) {
+    const current = stack.pop();
+    if (!current) continue;
+    let stat;
+    try {
+      stat = fs.statSync(current);
+    } catch {
+      continue;
+    }
+    newest = Math.max(newest, stat.mtimeMs);
+    if (!stat.isDirectory()) continue;
+    for (const child of fs.readdirSync(current)) {
+      if (child === "node_modules" || child === "dist" || child === ".turbo") continue;
+      stack.push(path.join(current, child));
+    }
+  }
+  return newest;
+}
+
+function oldestDistMtimeMs() {
+  let oldest = Number.POSITIVE_INFINITY;
+  for (const filePath of distFiles) {
+    let stat;
+    try {
+      stat = fs.statSync(filePath);
+    } catch {
+      return 0;
+    }
+    oldest = Math.min(oldest, stat.mtimeMs);
+  }
+  return oldest;
+}
+
+const newestSource = sourceEntries.reduce(
+  (newest, entryPath) => Math.max(newest, newestMtimeMs(entryPath)),
+  0,
+);
+const oldestDist = oldestDistMtimeMs();
+
+if (oldestDist >= newestSource) {
+  process.stdout.write("[ade] ADE CLI dist is up to date\n");
+  process.exit(0);
+}
+
+process.stdout.write("[ade] ADE CLI dist is stale; rebuilding before desktop dev launch\n");
+const result = cp.spawnSync(
+  "npm",
+  ["--prefix", path.join("..", "ade-cli"), "run", "build"],
+  {
+    cwd: desktopRoot,
+    stdio: "inherit",
+    shell: process.platform === "win32",
+  },
+);
+
+if (result.error) {
+  process.stderr.write(`[ade] failed to rebuild ADE CLI: ${result.error.message}\n`);
+  process.exit(1);
+}
+process.exit(result.status ?? 1);
diff --git a/apps/desktop/src/main/main.ts b/apps/desktop/src/main/main.ts
index d046efc9d..21a728d18 100644
--- a/apps/desktop/src/main/main.ts
+++ b/apps/desktop/src/main/main.ts
@@ -1081,6 +1081,7 @@ app.whenReady().then(async () => {
   const projectInitPromises = new Map<string, Promise<AppContext>>();
   const closeContextPromises = new Map<string, Promise<void>>();
   const windowProjectRoots = new Map<number, string | null>();
+  const windowProjectTabRoots = new Map<number, Set<string>>();
   const windowProjectBindings = new Map<number, OpenProjectBinding & { kind: "remote" }>();
   const ipcWindowScope = new AsyncLocalStorage<number | null>();
   const rpcSocketCleanupByRoot = new Map<string, () => void>();
@@ -1115,7 +1116,13 @@ app.whenReady().then(async () => {
   } else if (process.env.NODE_ENV === "test") {
     localRuntimePool.noteServiceInstallSkipped("Background service installation is skipped in tests.");
   }
-  const MAX_WARM_IDLE_PROJECT_CONTEXTS = 1;
+  // Soft cap for project contexts that have NO user work at all (no chats,
+  // no live PTYs, no active sessions/missions/tests). Anything with work is
+  // protected by `hasActiveProjectWorkloads` and is never evicted regardless
+  // of this number. The cap exists only as a safety valve against opening
+  // hundreds of empty projects in a long-running session — well above any
+  // realistic working set, so users effectively never hit it.
+  const MAX_WARM_IDLE_PROJECT_CONTEXTS = 100;
   const MOBILE_SYNC_HANDOFF_LEASE_MS = 60_000;
   let activeProjectRoot: string | null = null;
   let mobileSyncSelectedRoot: string | null = null;
@@ -1137,6 +1144,34 @@ app.whenReady().then(async () => {
     return projectContexts.get(projectRoot)?.project ?? null;
   };
 
+  const projectsForWindowTabs = (windowId: number | null): ProjectInfo[] => {
+    if (windowId == null) return [];
+    const roots = windowProjectTabRoots.get(windowId) ?? new Set<string>();
+    const projects: ProjectInfo[] = [];
+    for (const root of roots) {
+      const project = projectForRoot(root);
+      if (project) projects.push(project);
+    }
+    return projects;
+  };
+
+  const rememberWindowProjectTabs = (
+    windowId: number | null,
+    rootPaths: string[],
+  ): ProjectInfo[] => {
+    if (windowId == null) return [];
+    const roots = new Set<string>();
+    for (const rootPath of rootPaths) {
+      const normalized = rootPath.trim() ? normalizeProjectRoot(rootPath) : "";
+      if (normalized) roots.add(normalized);
+    }
+    const activeRoot = windowProjectRoots.get(windowId) ?? null;
+    if (activeRoot) roots.add(activeRoot);
+    windowProjectTabRoots.set(windowId, roots);
+    scheduleProjectContextRebalance();
+    return projectsForWindowTabs(windowId);
+  };
+
   const bindingForLocalProject = (project: ProjectInfo | null): OpenProjectBinding | null =>
     project && !shouldUseInProcessProjectRuntime()
       ? {
@@ -1152,6 +1187,9 @@ app.whenReady().then(async () => {
     for (const root of windowProjectRoots.values()) {
       if (root) roots.add(root);
     }
+    for (const tabRoots of windowProjectTabRoots.values()) {
+      for (const root of tabRoots) roots.add(root);
+    }
     return roots;
   };
 
@@ -1268,6 +1306,11 @@ app.whenReady().then(async () => {
     if (windowId != null) {
       windowProjectRoots.set(windowId, normalizedRoot);
       windowProjectBindings.delete(windowId);
+      if (normalizedRoot) {
+        const tabRoots = windowProjectTabRoots.get(windowId) ?? new Set<string>();
+        tabRoots.add(normalizedRoot);
+        windowProjectTabRoots.set(windowId, tabRoots);
+      }
     }
     if (options.foreground ?? true) {
       setForegroundProject(normalizedRoot);
@@ -1302,7 +1345,12 @@ app.whenReady().then(async () => {
       windowProjectRoots.set(windowId, null);
       windowProjectBindings.set(windowId, binding);
     }
-    setForegroundProject(null);
+    // Binding this window to a remote project must not tear down local
+    // foreground services that other windows depend on. Only drop the
+    // foreground if no other window is still working in a local project.
+    if (!activeProjectRoot || !rootsBoundToWindows().has(activeProjectRoot)) {
+      setForegroundProject(firstOpenWindowProjectRoot());
+    }
     emitProjectChangedToWindow(windowId, null);
     emitProjectBindingChangedToWindow(windowId, binding);
   };
@@ -1333,7 +1381,9 @@ app.whenReady().then(async () => {
   ): void => {
     const normalizedRoot = normalizeProjectRoot(projectRoot);
     for (const win of BrowserWindow.getAllWindows()) {
-      if (windowProjectRoots.get(win.id) !== normalizedRoot) continue;
+      const isActiveInWindow = windowProjectRoots.get(win.id) === normalizedRoot;
+      const isOpenTabInWindow = windowProjectTabRoots.get(win.id)?.has(normalizedRoot) === true;
+      if (!isActiveInWindow && !isOpenTabInWindow) continue;
       try {
         win.webContents.send(channel, payload);
       } catch {
@@ -1367,13 +1417,31 @@ app.whenReady().then(async () => {
     }
 
     try {
-      if (ctx.agentChatService?.hasActiveWorkloads()) {
+      // ANY chat session the user hasn't explicitly closed/deleted protects
+      // the project. The narrower hasActiveWorkloads check (mid-turn only) is
+      // not enough — a session sitting between turns still owns a live agent
+      // runtime that must survive a project switch so typing a new message
+      // does not cold-restart the agent.
+      if (
+        ctx.agentChatService?.hasRetainableSessions?.()
+        ?? ctx.agentChatService?.hasActiveWorkloads()
+      ) {
         return true;
       }
     } catch (error) {
       return keepAliveOnProbeFailure("agent_chats", error);
     }
 
+    try {
+      // Any live PTY (running CLI/shell/agent) means the user has work that
+      // would be killed by eviction. Don't evict.
+      if (ctx.ptyService?.hasLiveSessions?.()) {
+        return true;
+      }
+    } catch (error) {
+      return keepAliveOnProbeFailure("pty_sessions", error);
+    }
+
     try {
       if (ctx.missionService?.list({ status: "active", limit: 1 }).length > 0) {
         return true;
@@ -2784,8 +2852,21 @@ app.whenReady().then(async () => {
       getDirtyFileTextForPath: async (absPath: string) => {
         const trimmed = absPath.trim();
         if (!trimmed) return undefined;
+        const normalizedProjectRoot = normalizeProjectRoot(projectRoot);
+        const candidateWindows = BrowserWindow.getAllWindows().filter(
+          (candidate) =>
+            !candidate.isDestroyed()
+            && candidate.webContents
+            && !candidate.webContents.isDestroyed(),
+        );
         const win =
-          BrowserWindow.getFocusedWindow() ?? BrowserWindow.getAllWindows()[0];
+          candidateWindows.find(
+            (candidate) => windowProjectRoots.get(candidate.id) === normalizedProjectRoot,
+          )
+          ?? candidateWindows.find(
+            (candidate) => windowProjectTabRoots.get(candidate.id)?.has(normalizedProjectRoot) === true,
+          )
+          ?? null;
         if (!win?.webContents || win.webContents.isDestroyed())
           return undefined;
         try {
@@ -4970,6 +5051,31 @@ app.whenReady().then(async () => {
     try {
       const resolveStartedAt = Date.now();
       repoRoot = normalizeProjectRoot(await resolveRepoRoot(selectedPath)); // require a real git repo for onboarding.
+      // Kick off base-ref detection IN PARALLEL with the existing-context
+      // check and any recent-project bookkeeping. For a cold open this shaves
+      // 200-600ms off (git symbolic-ref + rev-parse run during work we'd be
+      // doing anyway). For the fast "context already warm" path we simply
+      // discard the in-flight promise.
+      const baseRefStartedAt = Date.now();
+      const baseRefPromise = detectDefaultBaseRef(repoRoot)
+        .then((value) => {
+          projectOpenLogger.info("project.open.base_ref_detected", {
+            selectedPath,
+            repoRoot,
+            baseRef: value,
+            durationMs: Date.now() - baseRefStartedAt,
+          });
+          return value;
+        })
+        .catch((error) => {
+          projectOpenLogger.warn("project.open.base_ref_failed", {
+            selectedPath,
+            repoRoot,
+            durationMs: Date.now() - baseRefStartedAt,
+            error: error instanceof Error ? error.message : String(error),
+          });
+          return "main";
+        });
       const isKnownRecentProject = (readGlobalState(globalStatePath).recentProjects ?? []).some((entry) => {
         if (typeof entry?.rootPath !== "string") return false;
         return normalizeProjectRoot(entry.rootPath) === repoRoot;
@@ -4988,6 +5094,10 @@ app.whenReady().then(async () => {
         });
         bindWindowToProject(currentIpcWindowId(), repoRoot, { emit: true, foreground: true });
         scheduleProjectContextRebalance();
+        // Drop the unused base-ref promise so it doesn't leak as an unhandled
+        // rejection if detectDefaultBaseRef threw between the .catch above
+        // and this point (already neutralized by .catch, but keep tidy).
+        void baseRefPromise;
         projectOpenLogger.info("project.open.done", {
           selectedPath,
           repoRoot,
@@ -5000,14 +5110,7 @@ app.whenReady().then(async () => {
       let initPromise = projectInitPromises.get(repoRoot);
       if (!initPromise) {
         initPromise = (async () => {
-          const baseRefStartedAt = Date.now();
-          const baseRef = await detectDefaultBaseRef(repoRoot!);
-          projectOpenLogger.info("project.open.base_ref_detected", {
-            selectedPath,
-            repoRoot,
-            baseRef,
-            durationMs: Date.now() - baseRefStartedAt,
-          });
+          const baseRef = await baseRefPromise;
           const initStartedAt = Date.now();
           const ctx = shouldUseInProcessProjectRuntime()
             ? await initContextForProjectRoot({
@@ -5072,11 +5175,15 @@ app.whenReady().then(async () => {
     const normalizedRoot = normalizeProjectRoot(projectRoot);
     const wasActive = activeProjectRoot === normalizedRoot;
     for (const [windowId, root] of windowProjectRoots) {
+      const tabRoots = windowProjectTabRoots.get(windowId);
+      tabRoots?.delete(normalizedRoot);
       if (root === normalizedRoot) {
-        windowProjectRoots.set(windowId, null);
+        const nextRoot = tabRoots?.values().next().value ?? null;
+        windowProjectRoots.set(windowId, nextRoot);
         windowProjectBindings.delete(windowId);
-        emitProjectChangedToWindow(windowId, null);
-        emitProjectBindingChangedToWindow(windowId, null);
+        const nextProject = projectForRoot(nextRoot);
+        emitProjectChangedToWindow(windowId, nextProject);
+        emitProjectBindingChangedToWindow(windowId, bindingForLocalProject(nextProject));
       }
     }
     await closeProjectContext(normalizedRoot);
@@ -5091,7 +5198,17 @@ app.whenReady().then(async () => {
     const previousRoot = current.project?.rootPath ?? "";
     const windowId = currentIpcWindowId();
     if (windowId != null) {
-      bindWindowToProject(windowId, null, { emit: true, foreground: true });
+      // Unbind this window without clobbering the global foreground project —
+      // other open windows may still be working in their own projects, and
+      // background services keyed to `activeProjectRoot` (mobile sync host,
+      // artifact dir, etc.) must keep pointing at a live root if one exists.
+      const tabRoots = windowProjectTabRoots.get(windowId);
+      if (previousRoot) tabRoots?.delete(normalizeProjectRoot(previousRoot));
+      const nextRoot = tabRoots?.values().next().value ?? null;
+      bindWindowToProject(windowId, nextRoot, { emit: true, foreground: false });
+      if (nextRoot == null && (activeProjectRoot === previousRoot || activeProjectRoot == null)) {
+        setForegroundProject(firstOpenWindowProjectRoot());
+      }
       dormantContext = createDormantProjectContext(previousRoot);
       scheduleProjectContextRebalance();
       return;
@@ -5099,7 +5216,7 @@ app.whenReady().then(async () => {
     if (activeProjectRoot) {
       await closeProjectContext(activeProjectRoot);
     }
-    setForegroundProject(null);
+    setForegroundProject(firstOpenWindowProjectRoot());
     dormantContext = createDormantProjectContext(previousRoot);
   };
 
@@ -5438,15 +5555,27 @@ app.whenReady().then(async () => {
   };
 
   const registerWindowSession = (win: BrowserWindow, projectRoot: string | null = null): void => {
-    windowProjectRoots.set(win.id, projectRoot ? normalizeProjectRoot(projectRoot) : null);
+    const normalizedRoot = projectRoot ? normalizeProjectRoot(projectRoot) : null;
+    windowProjectRoots.set(win.id, normalizedRoot);
+    windowProjectTabRoots.set(win.id, normalizedRoot ? new Set([normalizedRoot]) : new Set());
     windowProjectBindings.delete(win.id);
     win.on("focus", () => {
-      setForegroundProject(windowProjectRoots.get(win.id) ?? null);
+      const focusedRoot = windowProjectRoots.get(win.id) ?? null;
+      if (focusedRoot != null) {
+        setForegroundProject(focusedRoot);
+      } else if (!activeProjectRoot || !rootsBoundToWindows().has(activeProjectRoot)) {
+        // Focusing an unscoped window (e.g. a brand-new File > New Window) must
+        // not clobber the foreground project — that would tear down background
+        // services and break running work in other windows. Only re-derive the
+        // foreground when the current one is no longer bound to any window.
+        setForegroundProject(firstOpenWindowProjectRoot());
+      }
       builtInBrowserService.attachToWindow(win);
     });
     win.on("closed", () => {
       const previousRoot = windowProjectRoots.get(win.id) ?? null;
       windowProjectRoots.delete(win.id);
+      windowProjectTabRoots.delete(win.id);
       windowProjectBindings.delete(win.id);
       if (activeProjectRoot === previousRoot) {
         setForegroundProject(firstOpenWindowProjectRoot());
@@ -5455,18 +5584,24 @@ app.whenReady().then(async () => {
     });
   };
 
-  const getWindowSession = (windowId: number | null): { windowId: number | null; project: ProjectInfo | null; binding: OpenProjectBinding | null } => {
+  const getWindowSession = (windowId: number | null): { windowId: number | null; project: ProjectInfo | null; binding: OpenProjectBinding | null; openProjectTabs: ProjectInfo[] } => {
     if (windowId == null) {
       const project = projectForRoot(activeProjectRoot);
-      return { windowId: null, project, binding: bindingForLocalProject(project) };
+      return {
+        windowId: null,
+        project,
+        binding: bindingForLocalProject(project),
+        openProjectTabs: project ? [project] : [],
+      };
     }
     const remoteBinding = windowProjectBindings.get(windowId) ?? null;
-    if (remoteBinding) return { windowId, project: null, binding: remoteBinding };
+    if (remoteBinding) return { windowId, project: null, binding: remoteBinding, openProjectTabs: projectsForWindowTabs(windowId) };
     const project = projectForRoot(windowProjectRoots.get(windowId) ?? null);
     return {
       windowId,
       project,
       binding: bindingForLocalProject(project),
+      openProjectTabs: projectsForWindowTabs(windowId),
     };
   };
 
@@ -5615,6 +5750,7 @@ app.whenReady().then(async () => {
     runWithIpcWindow: (event, fn) =>
       ipcWindowScope.run(BrowserWindow.fromWebContents(event.sender)?.id ?? null, fn),
     getWindowSession,
+    setWindowProjectTabs: rememberWindowProjectTabs,
     bindRemoteProject: bindWindowToRemoteProject,
     localRuntimeConnectionPool: shouldUseInProcessProjectRuntime()
       ? null
diff --git a/apps/desktop/src/main/services/adeActions/registry.ts b/apps/desktop/src/main/services/adeActions/registry.ts
index b549cb507..4c9e2b9cb 100644
--- a/apps/desktop/src/main/services/adeActions/registry.ts
+++ b/apps/desktop/src/main/services/adeActions/registry.ts
@@ -769,7 +769,7 @@ export const ADE_ACTION_ALLOWLIST: Partial<Record<AdeActionDomain, readonly stri
     "stopStack",
   ],
   pty: ["create", "dispose", "resize", "sendToSession", "write"],
-  terminal: ["list", "read", "preview", "write", "resize", "signal", "activeForChat"],
+  terminal: ["list", "read", "preview", "write", "resize", "signal", "activeForChat", "reattachChatCli"],
   layout: ["get", "set"],
   tiling_tree: ["get", "set"],
   graph_state: ["get", "set"],
@@ -2677,10 +2677,11 @@ type TerminalDomainService = {
   list(args?: unknown): unknown;
   read(args?: unknown): Promise<unknown>;
   preview(args?: unknown): Promise<unknown>;
-  write(args?: unknown): unknown;
+  write(args?: unknown): Promise<unknown>;
   resize(args?: unknown): unknown;
   signal(args?: unknown): unknown;
   activeForChat(args?: unknown): unknown;
+  reattachChatCli(args?: unknown): Promise<unknown>;
 };
 
 const RUNTIME_FILE_WATCH_CLIENT_ID_FIELD = "__adeRuntimeClientId";
@@ -3578,8 +3579,8 @@ function buildTerminalDomainService(runtime: AdeRuntime): TerminalDomainService
     preview(args) {
       return runtime.ptyService.previewTerminal(args as Parameters<typeof runtime.ptyService.previewTerminal>[0]);
     },
-    write(args) {
-      return runtime.ptyService.writeTerminal(args as Parameters<typeof runtime.ptyService.writeTerminal>[0]);
+    async write(args) {
+      return await runtime.ptyService.writeTerminal(args as Parameters<typeof runtime.ptyService.writeTerminal>[0]);
     },
     resize(args) {
       return runtime.ptyService.resizeTerminal(args as Parameters<typeof runtime.ptyService.resizeTerminal>[0]);
@@ -3590,6 +3591,9 @@ function buildTerminalDomainService(runtime: AdeRuntime): TerminalDomainService
     activeForChat(args) {
       return runtime.ptyService.activeForChat(args as Parameters<typeof runtime.ptyService.activeForChat>[0]);
     },
+    async reattachChatCli(args) {
+      return await runtime.ptyService.reattachChatCli(args as Parameters<typeof runtime.ptyService.reattachChatCli>[0]);
+    },
   };
 }
 
diff --git a/apps/desktop/src/main/services/appControl/appControlService.ts b/apps/desktop/src/main/services/appControl/appControlService.ts
index eb065cbb4..4b26b8fd3 100644
--- a/apps/desktop/src/main/services/appControl/appControlService.ts
+++ b/apps/desktop/src/main/services/appControl/appControlService.ts
@@ -2015,10 +2015,10 @@ export function createAppControlService(args: CreateAppControlServiceArgs) {
     });
   };
 
-  const writeTerminal = (terminalArgs: { data?: string | null }): { ok: true } => {
+  const writeTerminal = async (terminalArgs: { data?: string | null }): Promise<{ ok: true }> => {
     const terminalId = requireTerminalSessionId();
     if (typeof terminalArgs?.data !== "string") throw new Error("App Control terminal write requires data.");
-    return args.ptyService!.writeTerminal({ terminalId, data: terminalArgs.data });
+    return await args.ptyService!.writeTerminal({ terminalId, data: terminalArgs.data });
   };
 
   const signalTerminal = (terminalArgs: { signal?: "SIGINT" | "SIGTERM" | "SIGKILL" | null } = {}): { ok: true } => {
diff --git a/apps/desktop/src/main/services/automations/automationPlannerService.ts b/apps/desktop/src/main/services/automations/automationPlannerService.ts
index bb3d7bc6c..051da18d2 100644
--- a/apps/desktop/src/main/services/automations/automationPlannerService.ts
+++ b/apps/desktop/src/main/services/automations/automationPlannerService.ts
@@ -753,6 +753,7 @@ function normalizeDraft(args: {
         ...(prompt ? { prompt } : {}),
         ...(safeTrim(action?.sessionTitle) ? { sessionTitle: safeTrim(action?.sessionTitle) } : {}),
         ...(actionModelConfig ? { modelConfig: actionModelConfig } : {}),
+        ...(typeof action?.codexFastMode === "boolean" ? { codexFastMode: action.codexFastMode } : {}),
         ...(actionPermissionConfig ? { permissionConfig: actionPermissionConfig } : {}),
       });
       continue;
@@ -867,6 +868,9 @@ function normalizeDraft(args: {
                   ...(safeTrim(requestedExecution.session?.reasoningEffort)
                     ? { reasoningEffort: safeTrim(requestedExecution.session?.reasoningEffort) }
                     : {}),
+                  ...(typeof requestedExecution.session?.codexFastMode === "boolean"
+                    ? { codexFastMode: requestedExecution.session.codexFastMode }
+                    : {}),
                 },
               }
             : {}),
diff --git a/apps/desktop/src/main/services/automations/automationService.test.ts b/apps/desktop/src/main/services/automations/automationService.test.ts
index 826c90447..195b6d90f 100644
--- a/apps/desktop/src/main/services/automations/automationService.test.ts
+++ b/apps/desktop/src/main/services/automations/automationService.test.ts
@@ -1295,6 +1295,83 @@ describe("automationService integration", () => {
     }
   });
 
+  it("passes Codex fast mode to rule-level agent-session automations", async () => {
+    const { db } = createInMemoryAdeDb();
+    const logger = createLogger();
+    const projectId = "proj";
+    const projectRoot = fs.mkdtempSync(path.join(os.tmpdir(), "ade-automation-fast-rule-"));
+    const createSession = vi.fn(async () => ({ id: "session-fast-rule" }));
+    const runSessionTurn = vi.fn(async () => ({ outputText: "ok" }));
+
+    const rule = {
+      id: "agent-fast-rule",
+      name: "Agent fast rule",
+      enabled: true,
+      mode: "review",
+      reviewProfile: "quick",
+      trigger: { type: "manual" as const },
+      triggers: [{ type: "manual" as const }],
+      executor: { mode: "automation-bot", targetId: null },
+      modelConfig: {
+        orchestratorModel: { modelId: "openai/gpt-5.5", thinkingLevel: "xhigh" as const },
+      },
+      permissionConfig: { providers: { codex: "default" as const } },
+      toolPalette: [] as const,
+      contextSources: [],
+      memory: { mode: "project" as const },
+      guardrails: { maxDurationMin: 5 },
+      outputs: { disposition: "comment-only" as const, createArtifact: true },
+      verification: { verifyBeforePublish: false, mode: "intervention" as const },
+      billingCode: "auto:test",
+      execution: {
+        kind: "agent-session" as const,
+        session: { codexFastMode: true, reasoningEffort: "xhigh" },
+      },
+      prompt: "Summarize the current state.",
+    };
+
+    const projectConfigService = {
+      get: () => ({
+        trust: { requiresSharedTrust: false },
+        effective: { automations: [rule], providerMode: "guest" }
+      })
+    } as any;
+
+    const laneService = {
+      list: async () => [{ id: "lane-1", laneType: "primary" }],
+      getLaneWorktreePath: () => projectRoot,
+      getLaneBaseAndBranch: () => ({ baseRef: "main", branchRef: "main", worktreePath: projectRoot })
+    } as any;
+
+    const service = createAutomationService({
+      db: db as any,
+      logger,
+      projectId,
+      projectRoot,
+      laneService,
+      projectConfigService,
+      agentChatService: {
+        createSession,
+        runSessionTurn,
+      } as any,
+    });
+
+    try {
+      const run = await service.triggerManually({ id: "agent-fast-rule" });
+      expect(run.status).toBe("succeeded");
+      expect(createSession).toHaveBeenCalledWith(expect.objectContaining({
+        modelId: "openai/gpt-5.5",
+        codexFastMode: true,
+        reasoningEffort: "xhigh",
+      }));
+      expect(runSessionTurn).toHaveBeenCalledWith(expect.objectContaining({
+        reasoningEffort: "xhigh",
+      }));
+    } finally {
+      fs.rmSync(projectRoot, { recursive: true, force: true });
+    }
+  });
+
   it("blocks agent-session automations when the budget cap rejects the run", async () => {
     const { db } = createInMemoryAdeDb();
     const logger = createLogger();
@@ -1537,8 +1614,9 @@ describe("automationService integration", () => {
               type: "agent-session" as const,
               prompt: "Summarize",
               sessionTitle: "Summary",
-              modelConfig: { modelId: "opencode/openai/gpt-5.4", thinkingLevel: "high" as const },
-              permissionConfig: { providers: { opencode: "full-auto" as const } },
+              modelConfig: { modelId: "openai/gpt-5.5", thinkingLevel: "high" as const },
+              codexFastMode: true,
+              permissionConfig: { providers: { codex: "full-auto" as const } },
             },
           ],
         },
@@ -1576,7 +1654,8 @@ describe("automationService integration", () => {
       const run = await service.triggerManually({ id: "action-model" });
       expect(run.status).toBe("succeeded");
       expect(createSession).toHaveBeenCalledWith(expect.objectContaining({
-        modelId: "opencode/openai/gpt-5.4",
+        modelId: "openai/gpt-5.5",
+        codexFastMode: true,
         reasoningEffort: "high",
         permissionMode: "full-auto",
       }));
diff --git a/apps/desktop/src/main/services/automations/automationService.ts b/apps/desktop/src/main/services/automations/automationService.ts
index 1d7d72e31..bef3b08a7 100644
--- a/apps/desktop/src/main/services/automations/automationService.ts
+++ b/apps/desktop/src/main/services/automations/automationService.ts
@@ -46,7 +46,7 @@ import { buildClaudeReadOnlyWorkerAllowedTools } from "../orchestrator/providerO
 import type { createWorkerHeartbeatService } from "../cto/workerHeartbeatService";
 import { isRecord, matchesGlob, normalizeSet, nowIso, resolvePathWithinRoot, safeJsonParse } from "../shared/utils";
 import { terminateProcessTree } from "../shared/processExecution";
-import { getDefaultModelDescriptor, getModelById, resolveChatProviderForDescriptor, resolveProviderGroupForModel } from "../../../shared/modelRegistry";
+import { getDefaultModelDescriptor, getModelById, modelSupportsFastMode, resolveChatProviderForDescriptor, resolveProviderGroupForModel } from "../../../shared/modelRegistry";
 
 type CronTask = {
   stop: () => void;
@@ -1876,6 +1876,9 @@ export function createAutomationService({
       const promptText = typeof interpolated === "string" ? interpolated : rawPrompt;
       const { modelId, modelDescriptor, providerGroup } = resolveAutomationModelDescriptor(rule, action);
       const resolvedChat = resolveChatProviderForDescriptor(modelDescriptor);
+      const codexFastMode = providerGroup === "codex"
+        && action.codexFastMode === true
+        && modelSupportsFastMode(modelDescriptor);
       const permissionConfig = buildPermissionConfig(rule, { publishPhase: false }, action);
       const permissionMode = resolveProviderPermissionMode(providerGroup, permissionConfig);
       const reasoningEffort = action.modelConfig?.thinkingLevel
@@ -1895,6 +1898,7 @@ export function createAutomationService({
           sessionProfile: "workflow",
           reasoningEffort,
           permissionMode,
+          ...(codexFastMode ? { codexFastMode: true } : {}),
           ...(providerGroup === "cursor" ? { cursorModeId: cursorModeIdForPermissionMode(permissionMode) } : {}),
           ...(providerGroup === "codex" && permissionConfig.providers?.codexSandbox
             ? { codexSandbox: permissionConfig.providers.codexSandbox }
@@ -2299,6 +2303,9 @@ export function createAutomationService({
       ? "plan"
       : resolveProviderPermissionMode(providerGroup, permissionConfig);
     const reasoningEffort = args.rule.execution?.session?.reasoningEffort ?? args.rule.modelConfig?.orchestratorModel?.thinkingLevel ?? null;
+    const codexFastMode = providerGroup === "codex"
+      && args.rule.execution?.session?.codexFastMode === true
+      && modelSupportsFastMode(modelDescriptor);
     const timeoutMs = Math.max(
       15_000,
       Math.floor((args.rule.guardrails.maxDurationMin ?? 10) * 60_000),
@@ -2315,6 +2322,7 @@ export function createAutomationService({
         sessionProfile: "workflow",
         reasoningEffort,
         permissionMode,
+        ...(codexFastMode ? { codexFastMode: true } : {}),
         ...(providerGroup === "cursor" ? { cursorModeId: cursorModeIdForPermissionMode(permissionMode) } : {}),
         ...(providerGroup === "codex" && !verificationRequired && !dryRun && permissionConfig.providers?.codexSandbox
           ? { codexSandbox: permissionConfig.providers.codexSandbox }
diff --git a/apps/desktop/src/main/services/builtInBrowser/builtInBrowserService.test.ts b/apps/desktop/src/main/services/builtInBrowser/builtInBrowserService.test.ts
index d063bb968..f3c9974d4 100644
--- a/apps/desktop/src/main/services/builtInBrowser/builtInBrowserService.test.ts
+++ b/apps/desktop/src/main/services/builtInBrowser/builtInBrowserService.test.ts
@@ -4,11 +4,27 @@ import { createBuiltInBrowserService } from "./builtInBrowserService";
 
 const fakes = vi.hoisted(() => {
   type DebuggerHandler = (...args: unknown[]) => void;
-  type WindowOpenHandler = (details: { url: string }) => { action: string };
+  type WindowOpenHandlerResponse = {
+    action: "allow" | "deny";
+    createWindow?: (options: Record<string, unknown>) => FakeWebContents;
+  };
+  type WindowOpenHandler = (details: { url: string }) => WindowOpenHandlerResponse;
   type BeforeSendHeadersHandler = (
     details: { requestHeaders: Record<string, string | string[] | undefined> },
     callback: (response: { requestHeaders: Record<string, string | string[] | undefined> }) => void,
   ) => void;
+  type PermissionCheckHandler = (
+    webContents: FakeWebContents | null,
+    permission: string,
+    requestingOrigin: string,
+    details: { requestingUrl?: string; embeddingOrigin?: string; securityOrigin?: string; isMainFrame: boolean },
+  ) => boolean;
+  type PermissionRequestHandler = (
+    webContents: FakeWebContents,
+    permission: string,
+    callback: (granted: boolean) => void,
+    details: { requestingUrl: string; isMainFrame: boolean; requestingOrigin?: string },
+  ) => void;
 
   class FakeDebugger {
     attached = false;
@@ -70,7 +86,7 @@ const fakes = vi.hoisted(() => {
     setWindowOpenHandler = (handler: WindowOpenHandler): void => {
       this.windowOpenHandler = handler;
     };
-    openWindow = (url: string): { action: string } | null => this.windowOpenHandler?.({ url }) ?? null;
+    openWindow = (url: string): WindowOpenHandlerResponse | null => this.windowOpenHandler?.({ url }) ?? null;
     on = (event: string, fn: (...args: unknown[]) => void): void => {
       (this.listeners[event] ??= []).push(fn);
     };
@@ -92,6 +108,8 @@ const fakes = vi.hoisted(() => {
   const debuggerInstances: FakeDebugger[] = [];
   const webContentsInstances: FakeWebContents[] = [];
   const beforeSendHeadersHandlers: BeforeSendHeadersHandler[] = [];
+  let permissionCheckHandler: PermissionCheckHandler | null = null;
+  let permissionRequestHandler: PermissionRequestHandler | null = null;
   const OriginalFakeDebugger = FakeDebugger;
   class TrackedFakeDebugger extends OriginalFakeDebugger {
     constructor() {
@@ -152,6 +170,44 @@ const fakes = vi.hoisted(() => {
     clearBeforeSendHeadersHandlers: () => {
       beforeSendHeadersHandlers.length = 0;
     },
+    setPermissionCheckHandler: (handler: PermissionCheckHandler | null) => {
+      permissionCheckHandler = handler;
+    },
+    setPermissionRequestHandler: (handler: PermissionRequestHandler | null) => {
+      permissionRequestHandler = handler;
+    },
+    dispatchPermissionCheck: (
+      permission: string,
+      requestingOrigin: string,
+      details: { requestingUrl?: string; embeddingOrigin?: string; securityOrigin?: string; isMainFrame?: boolean } = {},
+    ): boolean | null => {
+      return permissionCheckHandler?.(webContentsInstances[0] ?? null, permission, requestingOrigin, {
+        isMainFrame: details.isMainFrame ?? true,
+        requestingUrl: details.requestingUrl,
+        embeddingOrigin: details.embeddingOrigin,
+        securityOrigin: details.securityOrigin,
+      }) ?? null;
+    },
+    dispatchPermissionRequest: (
+      permission: string,
+      details: { requestingUrl: string; isMainFrame?: boolean; requestingOrigin?: string },
+    ): boolean | null => {
+      let granted: boolean | null = null;
+      const wc = webContentsInstances[0];
+      if (!wc || !permissionRequestHandler) return null;
+      permissionRequestHandler(wc, permission, (nextGranted) => {
+        granted = nextGranted;
+      }, {
+        requestingUrl: details.requestingUrl,
+        isMainFrame: details.isMainFrame ?? true,
+        requestingOrigin: details.requestingOrigin,
+      });
+      return granted;
+    },
+    clearPermissionHandlers: () => {
+      permissionCheckHandler = null;
+      permissionRequestHandler = null;
+    },
   };
 });
 
@@ -165,8 +221,12 @@ vi.mock("electron", () => ({
           fakes.beforeSendHeadersHandlers.push(handler as Parameters<typeof fakes.beforeSendHeadersHandlers.push>[0]);
         },
       },
-      setPermissionCheckHandler: () => {},
-      setPermissionRequestHandler: () => {},
+      setPermissionCheckHandler: (handler: unknown) => {
+        fakes.setPermissionCheckHandler(handler as Parameters<typeof fakes.setPermissionCheckHandler>[0]);
+      },
+      setPermissionRequestHandler: (handler: unknown) => {
+        fakes.setPermissionRequestHandler(handler as Parameters<typeof fakes.setPermissionRequestHandler>[0]);
+      },
     }),
   },
   shell: { openExternal: fakes.openExternal },
@@ -212,6 +272,7 @@ describe("createBuiltInBrowserService — bounds and status dedupe", () => {
     collector = captureStatusEvents();
     fakes.clearWebContentsInstances();
     fakes.clearBeforeSendHeadersHandlers();
+    fakes.clearPermissionHandlers();
     fakes.openExternal.mockClear();
   });
 
@@ -339,27 +400,65 @@ describe("createBuiltInBrowserService — bounds and status dedupe", () => {
     expect(fakes.openExternal).not.toHaveBeenCalled();
   });
 
-  it("uses a desktop Chrome user agent for ADE browser requests", async () => {
+  it("does not impersonate Chrome or rewrite browser request headers", async () => {
     const service = createBuiltInBrowserService({ onEvent: collector.onEvent });
     await service.createTab({ url: "https://example.test", activate: true });
 
     const wc = fakes.webContentsInstances[0];
-    expect(wc?.userAgentCalls.at(-1)).toMatch(/ Chrome\/\d+\.\d+\.\d+\.\d+ /);
-    expect(wc?.userAgentCalls.at(-1)).not.toMatch(/Electron|ADE/i);
-
-    const response = fakes.dispatchBeforeSendHeaders({
-      "User-Agent": "Electron/30",
-      "user-agent": "ADE/Electron",
-      "Sec-CH-UA": "\"Electron\";v=\"30\"",
-      "sec-ch-ua": "\"ADE\";v=\"1\"",
-    });
+    expect(wc?.userAgentCalls).toEqual([]);
+    expect(fakes.beforeSendHeadersHandlers).toHaveLength(0);
+    expect(fakes.dispatchBeforeSendHeaders({
+      "User-Agent": "Electron/41",
+      "Sec-CH-UA": "\"Chromium\";v=\"140\", \"Electron\";v=\"41\"",
+    })).toBeNull();
+  });
+
+  it("allows only narrow Google account auth permissions", async () => {
+    const service = createBuiltInBrowserService({ onEvent: collector.onEvent });
+    await service.createTab({ url: "https://example.test", activate: true });
 
-    expect(response?.requestHeaders["User-Agent"]).toMatch(/ Chrome\/\d+\.\d+\.\d+\.\d+ /);
-    expect(response?.requestHeaders["User-Agent"]).not.toMatch(/Electron|ADE/i);
-    expect(response?.requestHeaders["user-agent"]).toBeUndefined();
-    expect(response?.requestHeaders["Sec-CH-UA"]).toContain("Google Chrome");
-    expect(response?.requestHeaders["Sec-CH-UA"]).not.toContain("Electron");
-    expect(response?.requestHeaders["sec-ch-ua"]).toBeUndefined();
+    expect(fakes.dispatchPermissionCheck("storage-access", "https://accounts.google.com")).toBe(true);
+    expect(fakes.dispatchPermissionCheck("top-level-storage-access", "https://accounts.google.com")).toBe(true);
+    expect(fakes.dispatchPermissionCheck("hid", "https://accounts.google.com")).toBe(true);
+    expect(fakes.dispatchPermissionCheck("usb", "https://accounts.google.com")).toBe(true);
+    expect(fakes.dispatchPermissionCheck("serial", "https://accounts.google.com")).toBe(true);
+
+    expect(fakes.dispatchPermissionCheck("storage-access", "https://example.test")).toBe(false);
+    expect(fakes.dispatchPermissionCheck("media", "https://accounts.google.com")).toBe(false);
+
+    expect(fakes.dispatchPermissionRequest("storage-access", {
+      requestingUrl: "https://accounts.google.com/v3/signin/identifier",
+    })).toBe(true);
+    expect(fakes.dispatchPermissionRequest("top-level-storage-access", {
+      requestingUrl: "https://accounts.google.com/v3/signin/identifier",
+    })).toBe(true);
+    expect(fakes.dispatchPermissionRequest("media", {
+      requestingUrl: "https://accounts.google.com/v3/signin/identifier",
+    })).toBe(false);
+    expect(fakes.dispatchPermissionRequest("storage-access", {
+      requestingUrl: "https://example.test/login",
+    })).toBe(false);
+  });
+
+  it("opens popup requests as real ADE browser tabs", async () => {
+    const service = createBuiltInBrowserService({ onEvent: collector.onEvent });
+    await service.createTab({ url: "https://example.test", activate: true });
+    const firstTabId = service.getStatus().activeTabId;
+    const firstWc = fakes.webContentsInstances[0];
+
+    const response = firstWc?.openWindow("https://accounts.google.com/gsi/select");
+
+    expect(response?.action).toBe("allow");
+    expect(service.getStatus().tabs).toHaveLength(2);
+    expect(service.getStatus().activeTabId).not.toBe(firstTabId);
+    expect(response?.createWindow?.({})).toBe(fakes.webContentsInstances[1]);
+
+    const openEvent = collector.events.findLast((event) => event.type === "open-request");
+    expect(openEvent).toMatchObject({
+      type: "open-request",
+      url: "https://accounts.google.com/gsi/select",
+      tabId: service.getStatus().activeTabId,
+    });
   });
 
   it("emits an open request so the Work sidebar can reveal the browser panel", async () => {
@@ -416,6 +515,7 @@ describe("createBuiltInBrowserService — switchTab and navigate inspect/selecti
     fakes.clearDebuggerInstances();
     fakes.clearWebContentsInstances();
     fakes.clearBeforeSendHeadersHandlers();
+    fakes.clearPermissionHandlers();
     fakes.openExternal.mockClear();
   });
 
diff --git a/apps/desktop/src/main/services/builtInBrowser/builtInBrowserService.ts b/apps/desktop/src/main/services/builtInBrowser/builtInBrowserService.ts
index 62f6c8ad0..3b055aaae 100644
--- a/apps/desktop/src/main/services/builtInBrowser/builtInBrowserService.ts
+++ b/apps/desktop/src/main/services/builtInBrowser/builtInBrowserService.ts
@@ -25,10 +25,17 @@ const SCREENSHOT_TIMEOUT_MS = 3_000;
 const ELEMENT_SCREENSHOT_TIMEOUT_MS = 2_000;
 const DEBUGGER_TIMEOUT_MS = 3_000;
 const MAX_BROWSER_TABS = 10;
-const BROWSER_CHROME_VERSION = normalizeChromeVersion(process.versions.chrome);
-const BROWSER_CHROME_MAJOR_VERSION = BROWSER_CHROME_VERSION.split(".")[0] || "120";
-const BROWSER_USER_AGENT = buildDesktopChromeUserAgent(BROWSER_CHROME_VERSION, process.platform);
-const BROWSER_UA_PLATFORM = browserClientHintsPlatform(process.platform);
+const GOOGLE_AUTH_PERMISSION_CHECK_ALLOWLIST = new Set([
+  "hid",
+  "serial",
+  "storage-access",
+  "top-level-storage-access",
+  "usb",
+]);
+const GOOGLE_AUTH_PERMISSION_REQUEST_ALLOWLIST = new Set([
+  "storage-access",
+  "top-level-storage-access",
+]);
 
 type DebuggerMessageListener = (
   event: Electron.Event,
@@ -192,16 +199,13 @@ export function createBuiltInBrowserService(args: {
   const configureBrowserWebContents = (wc: WebContents): void => {
     if (configuredWebContents.has(wc)) return;
     configuredWebContents.add(wc);
-    try {
-      wc.setUserAgent(BROWSER_USER_AGENT);
-    } catch (error) {
-      logger()?.debug("built_in_browser.set_user_agent_failed", {
-        err: error instanceof Error ? error.message : String(error),
-      });
-    }
     wc.setWindowOpenHandler(({ url }) => {
-      void navigate({ url, newTab: true, openPanel: true }).catch(emitError);
-      return { action: "deny" };
+      const tab = createPopupTabState(url);
+      if (!tab) return { action: "deny" };
+      return {
+        action: "allow",
+        createWindow: () => tab.webContents,
+      };
     });
     wc.on("will-navigate", (event, url) => {
       if (isAllowedNavigationUrl(url)) return;
@@ -265,6 +269,26 @@ export function createBuiltInBrowserService(args: {
     };
   };
 
+  const createPopupTabState = (url: string): BrowserTabState | null => {
+    const popupUrl = stringOrNull(url) ?? "about:blank";
+    if (!isAllowedNavigationUrl(popupUrl)) {
+      emitError(new Error(`Blocked unsupported browser popup protocol: ${url}`));
+      return null;
+    }
+    if (tabs.length >= MAX_BROWSER_TABS) {
+      emitError(new Error(`ADE browser is limited to ${MAX_BROWSER_TABS} tabs. Close a tab before opening another.`));
+      return null;
+    }
+    const tab = createTabState();
+    tabs = [...tabs, tab];
+    activeTabId = tab.id;
+    clearSelectionInternal();
+    attachViewsToCurrentWindow();
+    requestOpenPanel({ url: popupUrl, tabId: tab.id });
+    emitStatus();
+    return tab;
+  };
+
   const ensureActiveTab = (): BrowserTabState => {
     const existing = activeTab();
     if (existing) return existing;
@@ -308,20 +332,35 @@ export function createBuiltInBrowserService(args: {
   const configureBrowserSession = (): void => {
     if (browserSessionConfigured) return;
     const browserSession = session.fromPartition(BROWSER_PARTITION);
-    browserSession.webRequest.onBeforeSendHeaders((details, callback) => {
-      callback({ requestHeaders: normalizeBrowserRequestHeaders(details.requestHeaders) });
-    });
-    browserSession.setPermissionCheckHandler((_webContents, permission, requestingOrigin) => {
+    browserSession.setPermissionCheckHandler((_webContents, permission, requestingOrigin, details) => {
+      if (shouldAllowGoogleAuthPermissionCheck(permission, requestingOrigin, details)) {
+        logger()?.debug("built_in_browser.permission_check_allowed", {
+          permission,
+          requestingOrigin,
+          requestingUrl: details.requestingUrl ?? null,
+        });
+        return true;
+      }
       logger()?.debug("built_in_browser.permission_check_denied", {
         permission,
         requestingOrigin,
+        requestingUrl: details.requestingUrl ?? null,
       });
       return false;
     });
     browserSession.setPermissionRequestHandler((_webContents, permission, callback, details) => {
+      if (shouldAllowGoogleAuthPermissionRequest(permission, details)) {
+        logger()?.debug("built_in_browser.permission_request_allowed", {
+          permission,
+          requestingUrl: stringOrNull(details.requestingUrl),
+        });
+        callback(true);
+        return;
+      }
       logger()?.debug("built_in_browser.permission_request_denied", {
         permission,
         requestingOrigin: "requestingOrigin" in details ? details.requestingOrigin : null,
+        requestingUrl: stringOrNull(details.requestingUrl),
       });
       callback(false);
     });
@@ -1070,58 +1109,41 @@ function emptyToNull(value: string): string | null {
   return trimmed.length ? trimmed : null;
 }
 
-function normalizeChromeVersion(version: string | undefined): string {
-  const match = (version ?? "").match(/^\d+(?:\.\d+){0,3}/);
-  const parts = (match?.[0] ?? "120.0.0.0").split(".");
-  while (parts.length < 4) parts.push("0");
-  return parts.slice(0, 4).join(".");
-}
-
-function buildDesktopChromeUserAgent(chromeVersion: string, platform: NodeJS.Platform): string {
-  let platformToken: string;
-  if (platform === "darwin") {
-    platformToken = "Macintosh; Intel Mac OS X 10_15_7";
-  } else if (platform === "win32") {
-    platformToken = "Windows NT 10.0; Win64; x64";
-  } else {
-    platformToken = "X11; Linux x86_64";
-  }
-  return `Mozilla/5.0 (${platformToken}) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/${chromeVersion} Safari/537.36`;
-}
-
-function browserClientHintsPlatform(platform: NodeJS.Platform): string {
-  if (platform === "darwin") return "macOS";
-  if (platform === "win32") return "Windows";
-  return "Linux";
-}
-
-function browserClientHintsBrands(): string {
-  return `"Google Chrome";v="${BROWSER_CHROME_MAJOR_VERSION}", "Chromium";v="${BROWSER_CHROME_MAJOR_VERSION}", "Not:A-Brand";v="24"`;
+function shouldAllowGoogleAuthPermissionCheck(
+  permission: string,
+  requestingOrigin: string,
+  details: Electron.PermissionCheckHandlerHandlerDetails,
+): boolean {
+  if (!GOOGLE_AUTH_PERMISSION_CHECK_ALLOWLIST.has(permission)) return false;
+  return (
+    isGoogleAccountsSurface(requestingOrigin)
+    || isGoogleAccountsSurface(details.requestingUrl)
+    || isGoogleAccountsSurface(details.embeddingOrigin)
+    || isGoogleAccountsSurface(details.securityOrigin)
+  );
 }
 
-type BrowserRequestHeaders = Record<string, string | string[]>;
-
-function setRequestHeader(headers: BrowserRequestHeaders, name: string, value: string): void {
-  for (const key of Object.keys(headers)) {
-    if (key.toLowerCase() === name.toLowerCase()) {
-      delete headers[key];
-    }
-  }
-  headers[name] = value;
+function shouldAllowGoogleAuthPermissionRequest(permission: string, details: unknown): boolean {
+  if (!GOOGLE_AUTH_PERMISSION_REQUEST_ALLOWLIST.has(permission)) return false;
+  if (!isRecord(details)) return false;
+  return (
+    isGoogleAccountsSurface(details.requestingUrl)
+    || isGoogleAccountsSurface(details.requestingOrigin)
+  );
 }
 
-function normalizeBrowserRequestHeaders(
-  headers: Record<string, string | string[] | undefined>,
-): BrowserRequestHeaders {
-  const next: BrowserRequestHeaders = {};
-  for (const [key, value] of Object.entries(headers)) {
-    if (value !== undefined) next[key] = value;
+function isGoogleAccountsSurface(value: unknown): boolean {
+  const text = stringOrNull(value);
+  if (!text) return false;
+  try {
+    const parsed = new URL(text);
+    return parsed.protocol === "https:" && (
+      parsed.hostname === "accounts.google.com"
+      || parsed.hostname.endsWith(".accounts.google.com")
+    );
+  } catch {
+    return false;
   }
-  setRequestHeader(next, "User-Agent", BROWSER_USER_AGENT);
-  setRequestHeader(next, "Sec-CH-UA", browserClientHintsBrands());
-  setRequestHeader(next, "Sec-CH-UA-Mobile", "?0");
-  setRequestHeader(next, "Sec-CH-UA-Platform", `"${BROWSER_UA_PLATFORM}"`);
-  return next;
 }
 
 function tabStatus(tab: BrowserTabState): BuiltInBrowserTab {
diff --git a/apps/desktop/src/main/services/chat/agentChatService.test.ts b/apps/desktop/src/main/services/chat/agentChatService.test.ts
index 8b0dddc60..c74437a5e 100644
--- a/apps/desktop/src/main/services/chat/agentChatService.test.ts
+++ b/apps/desktop/src/main/services/chat/agentChatService.test.ts
@@ -4098,6 +4098,227 @@ describe("createAgentChatService", () => {
     });
   });
 
+  // --------------------------------------------------------------------------
+  // Claude subagent name capture (Task tool input -> task_started envelope)
+  // --------------------------------------------------------------------------
+
+  describe("claude subagent name capture", () => {
+    it("attaches agentType from the Task tool input to subagent_* envelopes", async () => {
+      const events: AgentChatEventEnvelope[] = [];
+
+      let streamCall = 0;
+      let warmupComplete = false;
+      let turnDone: (() => void) | null = null;
+      const turnDonePromise = new Promise<void>((resolve) => { turnDone = resolve; });
+      const send = vi.fn().mockResolvedValue(undefined);
+      const setPermissionMode = vi.fn().mockResolvedValue(undefined);
+      const stream = vi.fn(() => (async function* () {
+        streamCall += 1;
+        if (streamCall === 1) {
+          yield { type: "system", subtype: "init", session_id: "sdk-name-1", slash_commands: [] };
+          warmupComplete = true;
+          yield { type: "result", usage: { input_tokens: 1, output_tokens: 1 } };
+          return;
+        }
+        // Assistant emits a Task tool_use block with subagent_type = "code-reviewer"
+        yield {
+          type: "assistant",
+          message: {
+            id: "msg-1",
+            content: [
+              {
+                type: "tool_use",
+                id: "toolu_task_1",
+                name: "Task",
+                input: {
+                  subagent_type: "code-reviewer",
+                  description: "Review the auth module",
+                  prompt: "Please review auth.ts for security gaps.",
+                },
+              },
+            ],
+            usage: { input_tokens: 1, output_tokens: 1 },
+          },
+        };
+        // SDK emits the canonical task lifecycle system messages referencing
+        // the same tool_use id via parent_tool_use_id.
+        yield {
+          type: "system",
+          subtype: "task_started",
+          task_id: "task-1",
+          parent_tool_use_id: "toolu_task_1",
+          description: "Review the auth module",
+        };
+        yield {
+          type: "system",
+          subtype: "task_progress",
+          task_id: "task-1",
+          parent_tool_use_id: "toolu_task_1",
+          summary: "Reading file…",
+          last_tool_name: "Read",
+        };
+        yield {
+          type: "system",
+          subtype: "task_notification",
+          task_id: "task-1",
+          parent_tool_use_id: "toolu_task_1",
+          status: "completed",
+          summary: "Found no issues",
+        };
+        await turnDonePromise;
+        yield { type: "result", usage: { input_tokens: 1, output_tokens: 1 } };
+      })());
+      vi.mocked(claudeSdkCreateSessionCompat).mockReturnValue({
+        send,
+        stream,
+        close: vi.fn(),
+        sessionId: "sdk-name-1",
+        setPermissionMode,
+      } as any);
+
+      const { service } = createService({
+        onEvent: (event: AgentChatEventEnvelope) => events.push(event),
+      });
+
+      const session = await service.createSession({
+        laneId: "lane-1",
+        provider: "claude",
+        model: "sonnet",
+      });
+
+      await vi.waitFor(() => {
+        expect(warmupComplete).toBe(true);
+      });
+
+      const sendPromise = service.sendMessage({
+        sessionId: session.id,
+        text: "Spawn a code-reviewer subagent.",
+      });
+
+      await waitForEvent(
+        events,
+        (e): e is AgentChatEventEnvelope =>
+          e.event.type === "subagent_result" && (e.event as any).taskId === "task-1",
+      );
+
+      const startEnvelope = events.find(
+        (e) => e.event.type === "subagent_started" && (e.event as any).taskId === "task-1",
+      );
+      const progressEnvelope = events.find(
+        (e) => e.event.type === "subagent_progress" && (e.event as any).taskId === "task-1",
+      );
+      const resultEnvelope = events.find(
+        (e) => e.event.type === "subagent_result" && (e.event as any).taskId === "task-1",
+      );
+
+      expect((startEnvelope?.event as any)?.agentType).toBe("code-reviewer");
+      expect((progressEnvelope?.event as any)?.agentType).toBe("code-reviewer");
+      expect((resultEnvelope?.event as any)?.agentType).toBe("code-reviewer");
+      expect((startEnvelope?.event as any)?.parentToolUseId).toBe("toolu_task_1");
+
+      turnDone!();
+      await expect(sendPromise).resolves.toBeUndefined();
+    });
+
+    it("falls back gracefully when Task tool has no subagent_type", async () => {
+      const events: AgentChatEventEnvelope[] = [];
+      let streamCall = 0;
+      let warmupComplete = false;
+      let turnDone: (() => void) | null = null;
+      const turnDonePromise = new Promise<void>((resolve) => { turnDone = resolve; });
+      const send = vi.fn().mockResolvedValue(undefined);
+      const setPermissionMode = vi.fn().mockResolvedValue(undefined);
+      const stream = vi.fn(() => (async function* () {
+        streamCall += 1;
+        if (streamCall === 1) {
+          yield { type: "system", subtype: "init", session_id: "sdk-name-2", slash_commands: [] };
+          warmupComplete = true;
+          yield { type: "result", usage: { input_tokens: 1, output_tokens: 1 } };
+          return;
+        }
+        // Task tool input lacks subagent_type (older models)
+        yield {
+          type: "assistant",
+          message: {
+            id: "msg-2",
+            content: [
+              {
+                type: "tool_use",
+                id: "toolu_task_2",
+                name: "Task",
+                input: {
+                  description: "Audit something",
+                  prompt: "Audit the change log.",
+                },
+              },
+            ],
+            usage: { input_tokens: 1, output_tokens: 1 },
+          },
+        };
+        yield {
+          type: "system",
+          subtype: "task_started",
+          task_id: "task-2",
+          parent_tool_use_id: "toolu_task_2",
+          description: "Audit something",
+        };
+        yield {
+          type: "system",
+          subtype: "task_notification",
+          task_id: "task-2",
+          parent_tool_use_id: "toolu_task_2",
+          status: "completed",
+          summary: "Done",
+        };
+        await turnDonePromise;
+        yield { type: "result", usage: { input_tokens: 1, output_tokens: 1 } };
+      })());
+      vi.mocked(claudeSdkCreateSessionCompat).mockReturnValue({
+        send,
+        stream,
+        close: vi.fn(),
+        sessionId: "sdk-name-2",
+        setPermissionMode,
+      } as any);
+
+      const { service } = createService({
+        onEvent: (event: AgentChatEventEnvelope) => events.push(event),
+      });
+
+      const session = await service.createSession({
+        laneId: "lane-1",
+        provider: "claude",
+        model: "sonnet",
+      });
+
+      await vi.waitFor(() => {
+        expect(warmupComplete).toBe(true);
+      });
+
+      const sendPromise = service.sendMessage({
+        sessionId: session.id,
+        text: "Run a subagent without an explicit type",
+      });
+
+      await waitForEvent(
+        events,
+        (e): e is AgentChatEventEnvelope =>
+          e.event.type === "subagent_started" && (e.event as any).taskId === "task-2",
+      );
+
+      const startEnvelope = events.find(
+        (e) => e.event.type === "subagent_started" && (e.event as any).taskId === "task-2",
+      );
+      expect(startEnvelope).toBeDefined();
+      // No agentType is fine — the renderer falls back to description.
+      expect((startEnvelope?.event as any)?.agentType).toBeUndefined();
+      expect((startEnvelope?.event as any)?.description).toBe("Audit something");
+
+      turnDone!();
+      await expect(sendPromise).resolves.toBeUndefined();
+    });
+  });
+
   // --------------------------------------------------------------------------
   // getSlashCommands
   // --------------------------------------------------------------------------
@@ -5508,6 +5729,28 @@ describe("createAgentChatService", () => {
     });
   });
 
+  describe("hasRetainableSessions", () => {
+    it("is true while any chat session is open and false after it is closed", async () => {
+      const { service } = createService();
+      expect(service.hasRetainableSessions()).toBe(false);
+
+      const session = await service.createSession({
+        laneId: "lane-1",
+        provider: "claude",
+        model: "sonnet",
+      });
+      // Idle session (no active turn, no pending input) — hasActiveWorkloads
+      // is narrow and returns false. hasRetainableSessions must still report
+      // true so project-context rebalancing keeps the agent runtime alive
+      // for an instant resume after a project switch.
+      expect(service.hasActiveWorkloads()).toBe(false);
+      expect(service.hasRetainableSessions()).toBe(true);
+
+      await service.dispose({ sessionId: session.id });
+      expect(service.hasRetainableSessions()).toBe(false);
+    });
+  });
+
   describe("dispose", () => {
     it("only writes the persisted chat summary when the session is explicitly disposed", async () => {
       vi.mocked(streamText).mockReturnValue({
@@ -7443,6 +7686,173 @@ describe("createAgentChatService", () => {
       ).toBe("completed");
     });
 
+    it("assigns Agent #N labels to Codex collab agents in turn-spawn order", 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: "Spawn two parallel agents.",
+      }, { awaitDispatch: true });
+      await waitForEvent(
+        events,
+        (event): event is AgentChatEventEnvelope =>
+          event.event.type === "status"
+          && event.event.turnStatus === "started"
+          && event.event.turnId === "turn-1",
+      );
+
+      mockState.emitCodexPayload({
+        jsonrpc: "2.0",
+        method: "item/started",
+        params: {
+          turnId: "turn-1",
+          item: {
+            id: "collab-1",
+            type: "collabAgentToolCall",
+            tool: "spawnAgent",
+            status: "inProgress",
+            senderThreadId: "thread-main",
+            receiverThreadIds: ["agent-thread-a"],
+            prompt: "Inspect the renderer",
+            agentsStates: {},
+          },
+        },
+      });
+
+      mockState.emitCodexPayload({
+        jsonrpc: "2.0",
+        method: "item/started",
+        params: {
+          turnId: "turn-1",
+          item: {
+            id: "collab-2",
+            type: "collabAgentToolCall",
+            tool: "spawnAgent",
+            status: "inProgress",
+            senderThreadId: "thread-main",
+            receiverThreadIds: ["agent-thread-b"],
+            prompt: "Inspect the main process",
+            agentsStates: {},
+          },
+        },
+      });
+
+      const startedEvents = events.filter((envelope) =>
+        envelope.event.type === "subagent_started"
+        && (envelope.event.taskId === "agent-thread-a" || envelope.event.taskId === "agent-thread-b"),
+      );
+
+      expect(startedEvents).toHaveLength(2);
+      expect(startedEvents[0]!.event).toMatchObject({
+        type: "subagent_started",
+        taskId: "agent-thread-a",
+        agentId: "agent-thread-a",
+        agentType: "Agent #1",
+      });
+      expect(startedEvents[1]!.event).toMatchObject({
+        type: "subagent_started",
+        taskId: "agent-thread-b",
+        agentId: "agent-thread-b",
+        agentType: "Agent #2",
+      });
+    });
+
+    it("filters codex parent stream by threadId when fetching subagent transcript", 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: "Run a parallel agent.",
+      }, { awaitDispatch: true });
+      await waitForEvent(
+        events,
+        (event): event is AgentChatEventEnvelope =>
+          event.event.type === "status"
+          && event.event.turnStatus === "started"
+          && event.event.turnId === "turn-1",
+      );
+
+      mockState.emitCodexPayload({
+        jsonrpc: "2.0",
+        method: "item/started",
+        params: {
+          turnId: "turn-1",
+          item: {
+            id: "collab-1",
+            type: "collabAgentToolCall",
+            tool: "spawnAgent",
+            status: "inProgress",
+            senderThreadId: "thread-main",
+            receiverThreadIds: ["agent-thread-filter"],
+            prompt: "Focused investigation",
+            agentsStates: {},
+          },
+        },
+      });
+
+      mockState.emitCodexPayload({
+        jsonrpc: "2.0",
+        method: "item/completed",
+        params: {
+          turnId: "turn-1",
+          item: {
+            id: "collab-2",
+            type: "collabAgentToolCall",
+            tool: "wait",
+            status: "completed",
+            senderThreadId: "thread-main",
+            receiverThreadIds: ["agent-thread-filter"],
+            agentsStates: {
+              "agent-thread-filter": {
+                status: "completed",
+                message: "Investigation complete.",
+              },
+            },
+          },
+        },
+      });
+
+      const transcript = await service.getSubagentTranscript({
+        sessionId: session.id,
+        agentId: "agent-thread-filter",
+      });
+      expect(transcript).not.toBeNull();
+      expect(transcript!.length).toBeGreaterThanOrEqual(2);
+      const types = transcript!.map((m) => (m.message as { type: string }).type);
+      expect(types).toContain("subagent_started");
+      expect(types).toContain("subagent_result");
+      // Filter must reject envelopes that don't carry this threadId.
+      expect(transcript!.every((m) => {
+        const event = m.message as { taskId?: string };
+        return event.taskId === "agent-thread-filter";
+      })).toBe(true);
+
+      // A different threadId returns an empty (but non-null) array.
+      const empty = await service.getSubagentTranscript({
+        sessionId: session.id,
+        agentId: "some-other-thread",
+      });
+      expect(empty).toEqual([]);
+    });
+
     it("coalesces Codex spawn placeholders when the app-server reveals the agent thread later", async () => {
       const events: AgentChatEventEnvelope[] = [];
       const { service } = createService({
diff --git a/apps/desktop/src/main/services/chat/agentChatService.ts b/apps/desktop/src/main/services/chat/agentChatService.ts
index bf7213668..bf16132fd 100644
--- a/apps/desktop/src/main/services/chat/agentChatService.ts
+++ b/apps/desktop/src/main/services/chat/agentChatService.ts
@@ -8,6 +8,7 @@ import readline from "node:readline";
 import {
   getSessionInfo as getClaudeSdkSessionInfo,
   getSessionMessages as getClaudeSdkSessionMessages,
+  getSubagentMessages as getClaudeSdkSubagentMessages,
   listSessions as listClaudeSdkSessions,
   query,
   renameSession as renameClaudeSession,
@@ -152,6 +153,8 @@ import type {
   AgentChatClaudeSessionListArgs,
   AgentChatClaudeSessionMessage,
   AgentChatClaudeSessionMessagesArgs,
+  AgentChatSubagentTranscriptArgs,
+  AgentChatSubagentTranscriptMessage,
   AgentChatSuggestLaneNameArgs,
   AgentChatCursorConfigOption,
   AgentChatCursorConfigValue,
@@ -479,6 +482,13 @@ type CodexRuntime = {
     background: boolean;
     parentToolUseId: string | null;
   }>;
+  /**
+   * Per-turn 1-based index assigned to each new codex collab agent threadId
+   * the first time it is announced (`subagent_started`). Used to surface
+   * `Agent #N` labels in the desktop subagent panel; the raw threadId still
+   * lives on the snapshot via `agentId`. Cleared at turn boundaries.
+   */
+  codexAgentIndexByTurn: Map<string, Map<string, number>>;
   interruptedTurnIds: Set<string>;
   ignoredTurnIds: Set<string>;
   terminalTurnIds: Set<string>;
@@ -538,6 +548,20 @@ type ClaudeRuntime = {
     parentToolUseId?: string | null;
     background?: boolean;
     finalSummary?: string;
+    agentType?: string;
+    agentId?: string;
+  }>;
+  /**
+   * Stash for Task-tool inputs captured at the assistant tool_use boundary,
+   * keyed by the Task tool_use_id. Lets the `system:task_*` system-message
+   * path enrich its envelopes with the `subagent_type` the model picked
+   * (e.g. "code-reviewer", "Explore") instead of falling back to "subagent".
+   */
+  taskToolInputByToolUseId: Map<string, {
+    subagentType?: string;
+    name?: string;
+    description?: string;
+    isBackground?: boolean;
   }>;
   slashCommands: Array<{ name: string; description: string; argumentHint?: string }>;
   busy: boolean;
@@ -2515,6 +2539,43 @@ function taskParentToolUseId(item: Record<string, unknown>): string | null {
     : null;
 }
 
+/**
+ * Extract the `subagent_type` / `name` / `description` from a Task-tool input.
+ * Returns null when the block is not a Task tool or input is malformed.
+ *
+ * Why: the Claude Agent SDK's Task tool is the canonical way users spawn a
+ * subagent. Its `input.subagent_type` (e.g. "code-reviewer", "Explore") is
+ * the only place at spawn time where the chosen agent's name surfaces in the
+ * stream — the SubagentStart hook also has it, but downstream `task_started`
+ * system messages do not. Stashing it lets us enrich those envelopes.
+ */
+function extractTaskToolInput(input: unknown): {
+  subagentType?: string;
+  name?: string;
+  description?: string;
+  isBackground?: boolean;
+} | null {
+  if (!input || typeof input !== "object") return null;
+  const record = input as Record<string, unknown>;
+  const subagentType = typeof record.subagent_type === "string" && record.subagent_type.trim().length
+    ? record.subagent_type.trim()
+    : undefined;
+  const name = typeof record.name === "string" && record.name.trim().length
+    ? record.name.trim()
+    : undefined;
+  const description = typeof record.description === "string" && record.description.trim().length
+    ? record.description.trim()
+    : undefined;
+  const isBackground = isBackgroundTask(record);
+  if (!subagentType && !name && !description && !isBackground) return null;
+  return {
+    ...(subagentType ? { subagentType } : {}),
+    ...(name ? { name } : {}),
+    ...(description ? { description } : {}),
+    ...(isBackground ? { isBackground } : {}),
+  };
+}
+
 function normalizePreview(text: string, maxChars = 220): string | null {
   const lines = text
     .split(/\r?\n/)
@@ -8040,6 +8101,7 @@ export function createAgentChatService(args: {
         });
       }
       runtime.approvals.clear();
+      runtime.codexAgentIndexByTurn.clear();
       if (shouldMarkInterrupted) {
         emitChatEvent(managed, {
           type: "system_notice",
@@ -8081,6 +8143,7 @@ export function createAgentChatService(args: {
       managed.runtime.warmQuery = null;
       managed.runtime.warmupDone = null;
       managed.runtime.activeSubagents.clear();
+      managed.runtime.taskToolInputByToolUseId.clear();
       for (const pending of managed.runtime.approvals.values()) {
         pending.resolve({ decision: "cancel" });
       }
@@ -9172,7 +9235,7 @@ export function createAgentChatService(args: {
     };
     const openClaudeToolUses = new Map<string, { toolName: string }>();
     const toolInputJsonByContentIndex = new Map<number, string>();
-    const toolUseMetaByContentIndex = new Map<number, { toolName: string; itemId: string }>();
+    const toolUseMetaByContentIndex = new Map<number, { toolName: string; itemId: string; toolUseId?: string }>();
     const emittedClaudeTodoIds = new Set<string>();
     const emitClaudeToolCompletion = (
       itemId: string,
@@ -9585,16 +9648,24 @@ export function createAgentChatService(args: {
           const existing = runtime.activeSubagents.get(taskId);
           const description = String(taskMsg.description ?? existing?.description ?? "");
           const parentToolUseId = taskParentToolUseId(taskMsg as Record<string, unknown>) ?? existing?.parentToolUseId ?? null;
+          const stashed = parentToolUseId ? runtime.taskToolInputByToolUseId.get(parentToolUseId) : undefined;
+          const agentType = existing?.agentType ?? stashed?.subagentType ?? stashed?.name;
+          const agentId = existing?.agentId
+            ?? (typeof taskMsg.agent_id === "string" && taskMsg.agent_id.trim().length ? taskMsg.agent_id.trim() : undefined);
           runtime.activeSubagents.set(taskId, {
             taskId,
             description,
             parentToolUseId,
             background: existing?.background,
             finalSummary: existing?.finalSummary,
+            ...(agentType ? { agentType } : {}),
+            ...(agentId ? { agentId } : {}),
           });
           emitChatEvent(managed, {
             type: "subagent_progress",
             taskId,
+            ...(agentId ? { agentId } : {}),
+            ...(agentType ? { agentType } : {}),
             parentToolUseId,
             description,
             summary: String(taskMsg.summary ?? ""),
@@ -9614,18 +9685,33 @@ export function createAgentChatService(args: {
           const taskMsg = msg as any;
           const taskId = String(taskMsg.task_id ?? randomUUID());
           const parentToolUseId = taskParentToolUseId(taskMsg as Record<string, unknown>);
+          const stashed = parentToolUseId ? runtime.taskToolInputByToolUseId.get(parentToolUseId) : undefined;
+          const description = String(
+            taskMsg.description
+              ?? stashed?.description
+              ?? "",
+          );
+          const agentType = stashed?.subagentType ?? stashed?.name;
+          const agentId = typeof taskMsg.agent_id === "string" && taskMsg.agent_id.trim().length
+            ? taskMsg.agent_id.trim()
+            : undefined;
+          const background = isBackgroundTask(taskMsg as Record<string, unknown>) || stashed?.isBackground === true;
           runtime.activeSubagents.set(taskId, {
             taskId,
-            description: String(taskMsg.description ?? ""),
+            description,
             parentToolUseId,
-            background: isBackgroundTask(taskMsg as Record<string, unknown>),
+            background,
+            ...(agentType ? { agentType } : {}),
+            ...(agentId ? { agentId } : {}),
           });
           emitChatEvent(managed, {
             type: "subagent_started",
             taskId,
+            ...(agentId ? { agentId } : {}),
+            ...(agentType ? { agentType } : {}),
             parentToolUseId,
-            description: String(taskMsg.description ?? ""),
-            background: isBackgroundTask(taskMsg as Record<string, unknown>),
+            description,
+            background,
             turnId,
           });
           continue;
@@ -9639,10 +9725,17 @@ export function createAgentChatService(args: {
           const existing = runtime.activeSubagents.get(taskId);
           const parentToolUseId = taskParentToolUseId(taskMsg as Record<string, unknown>) ?? existing?.parentToolUseId ?? null;
           const summary = String(taskMsg.summary ?? existing?.finalSummary ?? "");
+          const stashed = parentToolUseId ? runtime.taskToolInputByToolUseId.get(parentToolUseId) : undefined;
+          const agentType = existing?.agentType ?? stashed?.subagentType ?? stashed?.name;
+          const agentId = existing?.agentId
+            ?? (typeof taskMsg.agent_id === "string" && taskMsg.agent_id.trim().length ? taskMsg.agent_id.trim() : undefined);
           runtime.activeSubagents.delete(taskId);
+          if (parentToolUseId) runtime.taskToolInputByToolUseId.delete(parentToolUseId);
           emitChatEvent(managed, {
             type: "subagent_result",
             taskId,
+            ...(agentId ? { agentId } : {}),
+            ...(agentType ? { agentType } : {}),
             parentToolUseId,
             status: taskMsg.status === "completed" ? "completed" : taskMsg.status === "stopped" ? "stopped" : "failed",
             summary,
@@ -9743,6 +9836,12 @@ export function createAgentChatService(args: {
                 if (!emittedClaudeToolIds.has(itemId)) {
                   emittedClaudeToolIds.add(itemId);
                   openClaudeToolUses.set(itemId, { toolName });
+                  // Stash Task-tool input so the system:task_* envelopes that
+                  // arrive later can be enriched with agentType.
+                  if (toolName === "Task" && typeof block.id === "string" && block.id.length) {
+                    const taskInput = extractTaskToolInput(block.input);
+                    if (taskInput) runtime.taskToolInputByToolUseId.set(block.id, taskInput);
+                  }
                   emitChatEvent(managed, {
                     type: "activity",
                     activity: nextActivity.activity,
@@ -9898,7 +9997,12 @@ export function createAgentChatService(args: {
                       ? JSON.stringify(block.input)
                       : "";
                   toolInputJsonByContentIndex.set(contentIndex, initial);
-                  toolUseMetaByContentIndex.set(contentIndex, { toolName, itemId });
+                  const toolUseId = typeof block.id === "string" && block.id.length ? block.id : undefined;
+                  toolUseMetaByContentIndex.set(contentIndex, {
+                    toolName,
+                    itemId,
+                    ...(toolUseId ? { toolUseId } : {}),
+                  });
                 }
               }
             }
@@ -9918,6 +10022,13 @@ export function createAgentChatService(args: {
                     parsed = {};
                   }
                 }
+                // Stash Task-tool input so the system:task_* envelopes that
+                // arrive later can be enriched with agentType. Stream-event
+                // path: input arrives via input_json_delta and lands in `raw`.
+                if (meta.toolName === "Task" && meta.toolUseId) {
+                  const taskInput = extractTaskToolInput(parsed);
+                  if (taskInput) runtime.taskToolInputByToolUseId.set(meta.toolUseId, taskInput);
+                }
                 const syntheticResult = maybeSyntheticToolResult(meta.toolName, parsed, meta.itemId, turnId);
                 if (syntheticResult && !emittedSyntheticItemIds.has(meta.itemId)) {
                   emittedSyntheticItemIds.add(meta.itemId);
@@ -10972,12 +11083,15 @@ export function createAgentChatService(args: {
             const ensureSubagentStarted = (): void => {
               if (runtime.subagentSessionIds.has(childKey)) return;
               runtime.subagentSessionIds.add(childKey);
+              // We intentionally do NOT set `agentType` here. OpenCode encodes
+              // the human-readable identity in `session.title`, which we surface
+              // as `description`. The renderer prefers `agentType` when present,
+              // so omitting it lets the description drive the row label.
               emitChatEvent(managed, {
                 type: "subagent_started",
                 taskId: childKey,
                 parentToolUseId: null,
                 description: childDescription,
-                agentType: "opencode-subagent",
                 turnId,
               });
             };
@@ -11992,6 +12106,31 @@ export function createAgentChatService(args: {
     summary: string;
   };
 
+  /**
+   * Assigns (and remembers) a 1-based codex collab-agent index for the given
+   * threadId within the given turn. The Codex app-server wire format does not
+   * carry a human-friendly name for parallel agents — we surface them as
+   * `Agent #N` to mirror the official codex desktop reference and keep the raw
+   * threadId in the snapshot's agentId for filtering / drill-in.
+   */
+  const assignCodexAgentLabel = (
+    runtime: CodexRuntime,
+    turnId: string | null | undefined,
+    threadId: string,
+  ): string => {
+    const key = typeof turnId === "string" && turnId.length ? turnId : "__no_turn__";
+    let perTurn = runtime.codexAgentIndexByTurn.get(key);
+    if (!perTurn) {
+      perTurn = new Map<string, number>();
+      runtime.codexAgentIndexByTurn.set(key, perTurn);
+    }
+    const existing = perTurn.get(threadId);
+    if (existing !== undefined) return `Agent #${existing}`;
+    const next = perTurn.size + 1;
+    perTurn.set(threadId, next);
+    return `Agent #${next}`;
+  };
+
   const normalizeCodexCollabToolName = (value: unknown): string => {
     const raw = typeof value === "string" ? value.trim() : "";
     const compact = raw.replace(/[_-]/g, "").toLowerCase();
@@ -12340,9 +12479,14 @@ export function createAgentChatService(args: {
             background,
             parentToolUseId: itemId,
           });
+          const agentType = receiverIds.length
+            ? assignCodexAgentLabel(runtime, turnId, taskId)
+            : undefined;
           emitChatEvent(managed, {
             type: "subagent_started",
             taskId,
+            ...(receiverIds.length ? { agentId: taskId } : {}),
+            ...(agentType ? { agentType } : {}),
             parentToolUseId: itemId,
             description: prompt.slice(0, 120) || "Parallel agent",
             background,
@@ -12393,9 +12537,12 @@ export function createAgentChatService(args: {
                 taskId,
                 parentToolUseId: placeholder.parentToolUseId ?? itemId,
               });
+              const agentType = assignCodexAgentLabel(runtime, turnId, taskId);
               emitChatEvent(managed, {
                 type: "subagent_started",
                 taskId,
+                agentId: taskId,
+                agentType,
                 parentToolUseId: placeholder.parentToolUseId ?? itemId,
                 description: placeholder.description,
                 background: placeholder.background,
@@ -12782,6 +12929,7 @@ export function createAgentChatService(args: {
       runtime.webSearchActionsByItemId.clear();
       runtime.itemTurnIdByItemId.clear();
       runtime.agentMessageScopeByTurn.clear();
+      runtime.codexAgentIndexByTurn.delete(turnId);
       runtime.agentMessageTextByTurn.clear();
       runtime.recentNotificationKeys.clear();
       const usage = normalizeUsagePayload(turn?.usage ?? turn?.totalUsage);
@@ -13367,6 +13515,7 @@ export function createAgentChatService(args: {
       planningApprovalGuardByTurnId: new Map<string, boolean>(),
       pendingTurnPlanningApprovalGuarded: null,
       activeSubagents: new Map(),
+      codexAgentIndexByTurn: new Map<string, Map<string, number>>(),
       interruptedTurnIds: new Set<string>(),
       ignoredTurnIds: new Set<string>(),
       terminalTurnIds: new Set<string>(managed.codexTerminalTurnIds),
@@ -14596,6 +14745,7 @@ export function createAgentChatService(args: {
       warmupCancel: null,
       warmupCancelled: false,
       activeSubagents: new Map(),
+      taskToolInputByToolUseId: new Map(),
       slashCommands: [],
       busy: false,
       activeTurnId: null,
@@ -19394,6 +19544,19 @@ export function createAgentChatService(args: {
     return false;
   };
 
+  // Broader than hasActiveWorkloads: a session that's between turns still
+  // owns a live agent runtime (Claude SDK client, Codex app-server, etc.) the
+  // user expects to keep using after switching away and back. Project context
+  // rebalancing must NOT evict a project that has any such session — losing
+  // the runtime forces a cold-start the next time the user types.
+  const hasRetainableSessions = (): boolean => {
+    for (const managed of managedSessions.values()) {
+      if (managed.closed || managed.deleted) continue;
+      return true;
+    }
+    return false;
+  };
+
   const ensureIdentitySession = async (args: {
     identityKey: AgentChatIdentityKey;
     laneId: string;
@@ -21263,6 +21426,158 @@ export function createAgentChatService(args: {
     });
   };
 
+  /**
+   * Fetch the transcript of a subagent run within an existing chat session.
+   *
+   * Dispatch by runtime kind:
+   *
+   * - **Claude / ade-code**: SDK `getSubagentMessages` reads the per-subagent
+   *   JSONL at `~/.claude/projects/<projectDir>/<sessionId>/subagents/agent-<agentId>.jsonl`.
+   * - **OpenCode**: child session id is the agentId; we call
+   *   `runtime.handle.client.session.messages({ path: { id }, query: { directory }})`
+   *   and translate the returned `{info, parts}[]` rows into the renderer's
+   *   transcript message shape.
+   * - **Codex**: codex's app-server never streams per-thread activity into the
+   *   parent session, so the transcript is the subset of parent envelopes whose
+   *   `subagent_*` event carries `taskId === threadId` (the codex agentId).
+   * - **Cursor**: SDK `task` events tag every lifecycle envelope with the
+   *   subagent's `agentId`; we filter the parent stream by that value.
+   * - **Everything else (droid, lmstudio, …)**: `null`.
+   */
+  const getSubagentTranscript = async ({
+    sessionId,
+    agentId,
+    laneId,
+    limit,
+    offset,
+  }: AgentChatSubagentTranscriptArgs): Promise<AgentChatSubagentTranscriptMessage[] | null> => {
+    const normalizedSessionId = sessionId.trim();
+    const normalizedAgentId = agentId.trim();
+    if (!normalizedSessionId.length) throw new Error("sessionId is required.");
+    if (!normalizedAgentId.length) throw new Error("agentId is required.");
+    const managed = managedSessions.get(normalizedSessionId);
+    const runtimeKind = managed?.runtime?.kind ?? null;
+    const provider = managed?.session.provider ?? null;
+
+    const normalizedLimit = typeof limit === "number" && Number.isFinite(limit) && limit > 0
+      ? Math.min(Math.trunc(limit), 500)
+      : undefined;
+    const normalizedOffset = typeof offset === "number" && Number.isFinite(offset) && offset > 0
+      ? Math.trunc(offset)
+      : undefined;
+
+    if (runtimeKind === "opencode" && managed?.runtime?.kind === "opencode") {
+      try {
+        const response = await managed.runtime.handle.client.session.messages({
+          path: { id: normalizedAgentId },
+          query: { directory: managed.runtime.handle.directory },
+        });
+        const rows = (response as { data?: Array<{ info: unknown; parts: unknown }> }).data
+          ?? (response as unknown as Array<{ info: unknown; parts: unknown }>);
+        if (!Array.isArray(rows)) return [];
+        const mapped = rows.map((row): AgentChatSubagentTranscriptMessage | null => {
+          const info = row?.info && typeof row.info === "object"
+            ? (row.info as Record<string, unknown>)
+            : null;
+          if (!info) return null;
+          const role = typeof info.role === "string" ? info.role : "";
+          const messageType: AgentChatSubagentTranscriptMessage["type"] =
+            role === "user" ? "user" : role === "assistant" ? "assistant" : "system";
+          const id = typeof info.id === "string" ? info.id : "";
+          const sId = typeof info.sessionID === "string" ? info.sessionID : normalizedAgentId;
+          const parts = Array.isArray(row.parts) ? row.parts : [];
+          const textBlocks: string[] = [];
+          for (const part of parts) {
+            if (!part || typeof part !== "object") continue;
+            const block = part as { type?: unknown; text?: unknown };
+            if (typeof block.text === "string" && block.text.length
+                && (block.type === "text" || block.type === "reasoning")) {
+              textBlocks.push(block.text);
+            }
+          }
+          const text = textBlocks.join("");
+          return {
+            type: messageType,
+            uuid: id,
+            sessionId: sId,
+            parentToolUseId: null,
+            message: { info, parts },
+            ...(text.length ? { text } : {}),
+          };
+        }).filter((entry): entry is AgentChatSubagentTranscriptMessage => entry !== null);
+        const sliced = normalizedOffset !== undefined ? mapped.slice(normalizedOffset) : mapped;
+        return normalizedLimit !== undefined ? sliced.slice(0, normalizedLimit) : sliced;
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new Error(`OpenCode session.messages failed for ${normalizedAgentId}: ${message}`);
+      }
+    }
+
+    if (runtimeKind === "codex" || runtimeKind === "cursor") {
+      const envelopes = eventHistoryBySession.get(normalizedSessionId) ?? [];
+      const matchKey = runtimeKind === "codex" ? "taskId" : "agentId";
+      const matched: AgentChatSubagentTranscriptMessage[] = [];
+      for (const envelope of envelopes) {
+        const event = envelope.event as Record<string, unknown> & { type: string };
+        const candidate = event[matchKey];
+        if (typeof candidate !== "string" || candidate !== normalizedAgentId) continue;
+        const text = (() => {
+          if (typeof event.summary === "string" && event.summary.length) return event.summary;
+          if (typeof event.description === "string" && event.description.length) return event.description;
+          if (typeof event.text === "string" && event.text.length) return event.text;
+          return "";
+        })();
+        const role: AgentChatSubagentTranscriptMessage["type"] =
+          event.type === "subagent_result" || event.type === "subagent.completed"
+            ? "assistant"
+            : "system";
+        matched.push({
+          type: role,
+          uuid: `${envelope.sequence ?? envelope.timestamp}:${event.type}`,
+          sessionId: normalizedSessionId,
+          parentToolUseId: typeof event.parentToolUseId === "string" ? event.parentToolUseId : null,
+          message: event,
+          ...(text.length ? { text } : {}),
+        });
+      }
+      const sliced = normalizedOffset !== undefined ? matched.slice(normalizedOffset) : matched;
+      return normalizedLimit !== undefined ? sliced.slice(0, normalizedLimit) : sliced;
+    }
+
+    if (provider !== "claude" && provider !== null) {
+      // Droid, LM Studio, and any provider without subagent semantics.
+      return null;
+    }
+
+    // Resolve the on-disk Claude session id and project dir the same way
+    // getClaudeSessionMessages does — works whether the chat is live or
+    // resolved purely from the persisted pointer.
+    const claudeSessionId = managed?.runtime?.kind === "claude"
+      ? (managed.runtime.sdkSessionId ?? normalizedSessionId)
+      : normalizedSessionId;
+    const pointer = sessionService.getClaudeSessionPointer(claudeSessionId);
+    const laneFallback = await resolveClaudeSessionLaneFallback(
+      laneId ?? pointer?.laneId ?? managed?.session.laneId ?? null,
+    );
+    const messages = await getClaudeSdkSubagentMessages(claudeSessionId, normalizedAgentId, {
+      ...(laneFallback.dir ? { dir: laneFallback.dir } : {}),
+      ...(normalizedLimit !== undefined ? { limit: normalizedLimit } : {}),
+      ...(normalizedOffset !== undefined ? { offset: normalizedOffset } : {}),
+    });
+    return messages.map((message: ClaudeSdkSessionMessage) => {
+      const parentToolUseId = (message as unknown as { parent_tool_use_id?: unknown }).parent_tool_use_id;
+      const text = extractClaudeSessionMessageText(message.message);
+      return {
+        type: message.type,
+        uuid: message.uuid,
+        sessionId: message.session_id,
+        parentToolUseId: typeof parentToolUseId === "string" ? parentToolUseId : null,
+        message: message.message,
+        ...(text ? { text } : {}),
+      };
+    });
+  };
+
   const normalizeClaudeContextUsage = (
     usage: SDKControlGetContextUsageResponse,
   ): AgentChatContextUsage => {
@@ -21869,6 +22184,7 @@ export function createAgentChatService(args: {
     listSessions,
     getSessionSummary,
     hasActiveWorkloads,
+    hasRetainableSessions,
     getChatTranscript,
     getCodexResumeContext,
     getChatEventHistory,
@@ -21886,6 +22202,7 @@ export function createAgentChatService(args: {
     listClaudeSessions,
     getClaudeSessionInfo,
     getClaudeSessionMessages,
+    getSubagentTranscript,
     getContextUsage,
     rewindFiles,
     codexFuzzyFileSearch,
diff --git a/apps/desktop/src/main/services/config/projectConfigService.automationExecution.test.ts b/apps/desktop/src/main/services/config/projectConfigService.automationExecution.test.ts
index e9dba7be9..dcfef0fd2 100644
--- a/apps/desktop/src/main/services/config/projectConfigService.automationExecution.test.ts
+++ b/apps/desktop/src/main/services/config/projectConfigService.automationExecution.test.ts
@@ -71,6 +71,7 @@ describe("projectConfigService automation execution normalization", () => {
               laneMode: "nope",
               laneNamePreset: "issue-title",
               laneNameTemplate: "Should be dropped",
+              session: { codexFastMode: true },
             },
           },
           {
@@ -89,6 +90,24 @@ describe("projectConfigService automation execution normalization", () => {
               laneMode: "prompt-at-run",
             },
           },
+          {
+            id: "built-in-agent-rule",
+            trigger: { type: "manual" },
+            execution: {
+              kind: "built-in",
+              builtIn: {
+                actions: [
+                  {
+                    type: "agent-session",
+                    prompt: "Summarize",
+                    modelConfig: { modelId: "openai/gpt-5.5", thinkingLevel: "high" },
+                    codexFastMode: true,
+                    permissionConfig: { providers: { codex: "full-auto", codexSandbox: "danger-full-access" } },
+                  },
+                ],
+              },
+            },
+          },
         ],
       }),
       "utf8",
@@ -102,7 +121,7 @@ describe("projectConfigService automation execution normalization", () => {
       logger: makeLogger(),
     });
 
-    const [customRule, presetRule, requireTriggerLaneRule, legacyPromptAtRunRule] = service.get().effective.automations;
+    const [customRule, presetRule, requireTriggerLaneRule, legacyPromptAtRunRule, builtInAgentRule] = service.get().effective.automations;
 
     expect(customRule.execution).toMatchObject({
       kind: "mission",
@@ -115,6 +134,7 @@ describe("projectConfigService automation execution normalization", () => {
       kind: "agent-session",
       laneMode: "reuse",
       laneNamePreset: "issue-title",
+      session: { codexFastMode: true },
     });
     expect(presetRule.execution?.laneNameTemplate).toBeUndefined();
     expect(requireTriggerLaneRule.execution).toMatchObject({
@@ -125,6 +145,19 @@ describe("projectConfigService automation execution normalization", () => {
       kind: "agent-session",
       laneMode: "require-on-trigger",
     });
+    expect(builtInAgentRule.execution).toMatchObject({
+      kind: "built-in",
+      builtIn: {
+        actions: [
+          {
+            type: "agent-session",
+            modelConfig: { modelId: "openai/gpt-5.5", thinkingLevel: "high" },
+            codexFastMode: true,
+            permissionConfig: { providers: { codex: "full-auto", codexSandbox: "danger-full-access" } },
+          },
+        ],
+      },
+    });
   });
 
   it("flags fixed target lanes on require-on-trigger automation execution", () => {
diff --git a/apps/desktop/src/main/services/config/projectConfigService.ts b/apps/desktop/src/main/services/config/projectConfigService.ts
index e145c7762..13397306a 100644
--- a/apps/desktop/src/main/services/config/projectConfigService.ts
+++ b/apps/desktop/src/main/services/config/projectConfigService.ts
@@ -58,6 +58,7 @@ import type {
   ProviderMode,
   LinearAutoDispatchAction,
   LinearSyncConfig,
+  ModelConfig,
   MissionModelConfig,
   MissionPermissionConfig,
   NotificationsConfig,
@@ -468,6 +469,17 @@ function coerceAutomationActiveHours(value: unknown): AutomationActiveHours | un
   return { start, end, timezone };
 }
 
+function coerceModelConfig(value: unknown): ModelConfig | undefined {
+  if (!isRecord(value)) return undefined;
+  const modelId = asString(value.modelId)?.trim();
+  if (!modelId) return undefined;
+  return {
+    ...(asString(value.provider)?.trim() ? { provider: asString(value.provider)!.trim() as ModelConfig["provider"] } : {}),
+    modelId,
+    ...(asString(value.thinkingLevel)?.trim() ? { thinkingLevel: asString(value.thinkingLevel)!.trim() as ModelConfig["thinkingLevel"] } : {}),
+  };
+}
+
 function coerceAutomationAction(value: unknown): AutomationAction | null {
   if (!isRecord(value)) return null;
   const typeRaw = asString(value.type)?.trim() ?? "";
@@ -488,6 +500,9 @@ function coerceAutomationAction(value: unknown): AutomationAction | null {
   const adeAction = coerceRunAdeActionConfig(value.adeAction);
   const prompt = asString(value.prompt);
   const sessionTitle = asString(value.sessionTitle);
+  const modelConfig = coerceModelConfig(value.modelConfig);
+  const codexFastMode = asBool(value.codexFastMode);
+  const permissionConfig = coerceMissionPermissionConfig(value.permissionConfig);
 
   if (targetLaneId) out.targetLaneId = targetLaneId;
   if (suiteId != null) out.suiteId = suiteId;
@@ -500,6 +515,9 @@ function coerceAutomationAction(value: unknown): AutomationAction | null {
   if (adeAction != null) out.adeAction = adeAction;
   if (prompt != null) out.prompt = prompt;
   if (sessionTitle != null) out.sessionTitle = sessionTitle;
+  if (modelConfig != null) out.modelConfig = modelConfig;
+  if (codexFastMode != null) out.codexFastMode = codexFastMode;
+  if (permissionConfig != null) out.permissionConfig = permissionConfig;
 
   return out;
 }
@@ -557,6 +575,7 @@ function coerceAutomationExecution(value: unknown): AutomationExecution | undefi
           ...(asString(value.session.reasoningEffort)?.trim()
             ? { reasoningEffort: asString(value.session.reasoningEffort)!.trim() }
             : {}),
+          ...(asBool(value.session.codexFastMode) != null ? { codexFastMode: asBool(value.session.codexFastMode) } : {}),
         }
       : undefined;
     return {
diff --git a/apps/desktop/src/main/services/ipc/registerIpc.ts b/apps/desktop/src/main/services/ipc/registerIpc.ts
index 37ee8f84a..52ca5f9ae 100644
--- a/apps/desktop/src/main/services/ipc/registerIpc.ts
+++ b/apps/desktop/src/main/services/ipc/registerIpc.ts
@@ -237,6 +237,8 @@ import type {
   AgentChatClaudeSessionListArgs,
   AgentChatClaudeSessionMessage,
   AgentChatClaudeSessionMessagesArgs,
+  AgentChatSubagentTranscriptArgs,
+  AgentChatSubagentTranscriptMessage,
   AgentChatClaudeOutputStyle,
   AgentChatClaudeOutputStylesArgs,
   AgentChatClaudePlugin,
@@ -341,6 +343,7 @@ import type {
   ChatTerminalListArgs,
   ChatTerminalPreviewArgs,
   ChatTerminalReadArgs,
+  ChatTerminalReattachArgs,
   ChatTerminalSignalArgs,
   ChatTerminalWriteArgs,
   ReparentLaneArgs,
@@ -1768,6 +1771,7 @@ export function registerIpc({
   resolveSyncService,
   runWithIpcWindow,
   getWindowSession,
+  setWindowProjectTabs,
   bindRemoteProject,
   localRuntimeConnectionPool,
   createWindow,
@@ -1782,7 +1786,8 @@ export function registerIpc({
   getSyncService?: () => ReturnType<typeof createSyncService> | null | undefined;
   resolveSyncService?: () => Promise<ReturnType<typeof createSyncService> | null | undefined>;
   runWithIpcWindow?: <T>(event: { sender: Electron.WebContents }, fn: () => T | Promise<T>) => T | Promise<T>;
-  getWindowSession?: (windowId: number | null) => { windowId: number | null; project: ProjectInfo | null; binding: OpenProjectBinding | null };
+  getWindowSession?: (windowId: number | null) => { windowId: number | null; project: ProjectInfo | null; binding: OpenProjectBinding | null; openProjectTabs?: ProjectInfo[] };
+  setWindowProjectTabs?: (windowId: number | null, rootPaths: string[]) => ProjectInfo[];
   bindRemoteProject?: (windowId: number | null, binding: OpenProjectBinding & { kind: "remote" }) => void;
   localRuntimeConnectionPool?: LocalRuntimeConnectionPool | null;
   createWindow?: (args?: { projectRoot?: string | null }) => Promise<{ windowId: number | null; project: ProjectInfo | null }>;
@@ -3106,6 +3111,17 @@ export function registerIpc({
     return { chatSessionId };
   };
 
+  const parseTerminalReattachArgs = (value: unknown): ChatTerminalReattachArgs => {
+    const record = terminalRecord(value);
+    const chatSessionId = optionalTerminalString(record, "chatSessionId", 128);
+    if (!chatSessionId) throw new Error("Invalid terminal payload: chatSessionId is required");
+    const rawCols = record["cols"];
+    const rawRows = record["rows"];
+    const cols = typeof rawCols === "number" && Number.isFinite(rawCols) ? rawCols : null;
+    const rows = typeof rawRows === "number" && Number.isFinite(rawRows) ? rawRows : null;
+    return { chatSessionId, cols, rows };
+  };
+
   const resolveComputerUseOwnerSnapshotArgs = async (
     _ctx: AppContext,
     args: ComputerUseOwnerSnapshotArgs,
@@ -3264,9 +3280,21 @@ export function registerIpc({
           displayName: ctx.project.displayName,
         }
         : null,
+      openProjectTabs: ctx.hasUserSelectedProject ? [ctx.project] : [],
     };
   });
 
+  ipcMain.handle(IPC.appSetWindowProjectTabs, async (event, arg: { rootPaths?: string[] } = {}) => {
+    const windowId = BrowserWindow.fromWebContents(event.sender)?.id ?? null;
+    const rootPaths = Array.isArray(arg?.rootPaths)
+      ? arg.rootPaths.filter((rootPath): rootPath is string => typeof rootPath === "string")
+      : [];
+    const openProjectTabs = setWindowProjectTabs
+      ? setWindowProjectTabs(windowId, rootPaths)
+      : [];
+    return { openProjectTabs };
+  });
+
   ipcMain.handle(IPC.appNewWindow, async () => {
     if (!createWindow) return { windowId: null };
     const result = await createWindow({ projectRoot: null });
@@ -6584,7 +6612,7 @@ export function registerIpc({
     const ctx = getCtx();
     const session = ctx.sessionService.get(arg.sessionId);
     if (!session) return "";
-    const maxBytes = typeof arg.maxBytes === "number" ? Math.max(1024, Math.min(2_000_000, arg.maxBytes)) : 160_000;
+    const maxBytes = typeof arg.maxBytes === "number" ? Math.max(1024, Math.min(16_000_000, arg.maxBytes)) : 160_000;
     const raw = arg.raw === true;
     return ctx.ptyService.readTranscriptTail({
       sessionId: session.id,
@@ -6763,6 +6791,11 @@ export function registerIpc({
     return ctx.agentChatService.getClaudeSessionMessages(arg);
   });
 
+  ipcMain.handle(IPC.agentChatGetSubagentTranscript, async (_event, arg: AgentChatSubagentTranscriptArgs): Promise<AgentChatSubagentTranscriptMessage[] | null> => {
+    const ctx = getCtx();
+    return ctx.agentChatService.getSubagentTranscript(arg);
+  });
+
   ipcMain.handle(IPC.agentChatGetContextUsage, async (_event, arg: AgentChatContextUsageArgs): Promise<AgentChatContextUsage | null> => {
     const ctx = getCtx();
     return ctx.agentChatService.getContextUsage(arg);
@@ -7565,7 +7598,7 @@ export function registerIpc({
   );
 
   ipcMain.handle(IPC.terminalWrite, async (_event, arg) =>
-    getCtx().ptyService.writeTerminal(parseTerminalWriteArgs(arg)),
+    await getCtx().ptyService.writeTerminal(parseTerminalWriteArgs(arg)),
   );
 
   ipcMain.handle(IPC.terminalSignal, async (_event, arg) =>
@@ -7576,6 +7609,10 @@ export function registerIpc({
     getCtx().ptyService.activeForChat(parseTerminalActiveForChatArgs(arg)),
   );
 
+  ipcMain.handle(IPC.terminalReattachChatCli, async (_event, arg) =>
+    await getCtx().ptyService.reattachChatCli(parseTerminalReattachArgs(arg)),
+  );
+
   ipcMain.handle(IPC.diffGetChanges, async (_event, arg: GetDiffChangesArgs) => {
     const ctx = getCtx();
     return await withIpcTiming(ctx, "diff.getChanges", async () => await ctx.diffService.getChanges(arg.laneId), {
@@ -8241,32 +8278,43 @@ export function registerIpc({
 
   const ensurePrPolling = () => {
     const ctx = getCtx();
+    // PR services are only attached to fully-initialised project contexts. When
+    // the renderer fires PR queries for an unscoped window (e.g. a brand-new
+    // File > New Window before a project is chosen) or during a transition,
+    // ctx is dormant and these services are null. Return null so callers can
+    // hand back empty results instead of throwing into IPC.
+    if (!ctx.prPollingService || !ctx.prService) return null;
     ctx.prPollingService.start();
     return ctx;
   };
 
   ipcMain.handle(IPC.prsGetForLane, async (_event, arg: { laneId: string }): Promise<PrSummary | null> => {
     const ctx = getCtx();
+    if (!ctx.prService) return null;
     return ctx.prService.getForLane(arg.laneId);
   });
 
   ipcMain.handle(IPC.prsListAll, async (): Promise<PrSummary[]> => {
     const ctx = ensurePrPolling();
+    if (!ctx) return [];
     return ctx.prService.listAll();
   });
 
   ipcMain.handle(IPC.prsListOpenForRepo, async (): Promise<BranchPullRequest[]> => {
     const ctx = ensurePrPolling();
+    if (!ctx) return [];
     return await ctx.prService.listOpenPullRequests();
   });
 
   ipcMain.handle(IPC.prsRefresh, async (_event, arg: { prId?: string; prIds?: string[] } = {}): Promise<PrSummary[]> => {
     const ctx = ensurePrPolling();
+    if (!ctx) return [];
     return await ctx.prService.refresh(arg);
   });
 
   ipcMain.handle(IPC.prsGetStatus, async (_event, arg: { prId: string }): Promise<PrStatus | null> => {
     const ctx = ensurePrPolling();
+    if (!ctx) return null;
     try {
       return await ctx.prService.getStatus(arg.prId);
     } catch (err) {
@@ -8278,6 +8326,7 @@ export function registerIpc({
 
   ipcMain.handle(IPC.prsGetChecks, async (_event, arg: { prId: string }): Promise<PrCheck[]> => {
     const ctx = ensurePrPolling();
+    if (!ctx) return [];
     try {
       return await ctx.prService.getChecks(arg.prId);
     } catch (err) {
@@ -8288,6 +8337,7 @@ export function registerIpc({
 
   ipcMain.handle(IPC.prsGetComments, async (_event, arg: { prId: string }): Promise<PrComment[]> => {
     const ctx = ensurePrPolling();
+    if (!ctx) return [];
     try {
       return await ctx.prService.getComments(arg.prId);
     } catch (err) {
@@ -8298,6 +8348,7 @@ export function registerIpc({
 
   ipcMain.handle(IPC.prsGetReviews, async (_event, arg: { prId: string }): Promise<PrReview[]> => {
     const ctx = ensurePrPolling();
+    if (!ctx) return [];
     try {
       return await ctx.prService.getReviews(arg.prId);
     } catch (err) {
@@ -8308,6 +8359,7 @@ export function registerIpc({
 
   ipcMain.handle(IPC.prsGetReviewThreads, async (_event, arg: { prId: string }): Promise<PrReviewThread[]> => {
     const ctx = ensurePrPolling();
+    if (!ctx) return [];
     try {
       return await ctx.prService.getReviewThreads(arg.prId);
     } catch (err) {
@@ -8381,22 +8433,34 @@ export function registerIpc({
     getCtx().prService.getMergeContexts(Array.isArray(arg?.prIds) ? arg.prIds : [])
   );
 
-  ipcMain.handle(IPC.prsListWithConflicts, async (_event, arg?: { includeConflictAnalysis?: boolean }) =>
-    ensurePrPolling().prService.listWithConflicts({
+  ipcMain.handle(IPC.prsListWithConflicts, async (_event, arg?: { includeConflictAnalysis?: boolean }) => {
+    const ctx = ensurePrPolling();
+    if (!ctx) return [];
+    return ctx.prService.listWithConflicts({
       includeConflictAnalysis: arg?.includeConflictAnalysis === true,
-    })
-  );
+    });
+  });
 
   ipcMain.handle(IPC.prsListSnapshots, async (_event, arg?: { prId?: string }) =>
     getCtx().prService.listSnapshots({ prId: typeof arg?.prId === "string" ? arg.prId : undefined })
   );
 
-  ipcMain.handle(IPC.prsGetGitHubSnapshot, async (_event, arg?: { force?: boolean; includeExternalClosed?: boolean }): Promise<GitHubPrSnapshot> =>
-    await ensurePrPolling().prService.getGithubSnapshot({
+  ipcMain.handle(IPC.prsGetGitHubSnapshot, async (_event, arg?: { force?: boolean; includeExternalClosed?: boolean }): Promise<GitHubPrSnapshot> => {
+    const ctx = ensurePrPolling();
+    if (!ctx) {
+      return {
+        repo: null,
+        viewerLogin: null,
+        repoPullRequests: [],
+        externalPullRequests: [],
+        syncedAt: new Date(0).toISOString(),
+      };
+    }
+    return await ctx.prService.getGithubSnapshot({
       force: arg?.force === true,
       includeExternalClosed: arg?.includeExternalClosed === true,
-    })
-  );
+    });
+  });
 
   ipcMain.handle(IPC.prsCreateQueue, async (_event, arg: CreateQueuePrsArgs): Promise<CreateQueuePrsResult> => {
     const ctx = getCtx();
diff --git a/apps/desktop/src/main/services/ipc/runtimeBridge.ts b/apps/desktop/src/main/services/ipc/runtimeBridge.ts
index 4e82cdaaf..39987c253 100644
--- a/apps/desktop/src/main/services/ipc/runtimeBridge.ts
+++ b/apps/desktop/src/main/services/ipc/runtimeBridge.ts
@@ -44,6 +44,7 @@ type RuntimeBridgeArgs = {
     windowId: number | null;
     project: ProjectInfo | null;
     binding: OpenProjectBinding | null;
+    openProjectTabs?: ProjectInfo[];
   };
   bindRemoteProject?: (
     windowId: number | null,
diff --git a/apps/desktop/src/main/services/jobs/jobEngine.test.ts b/apps/desktop/src/main/services/jobs/jobEngine.test.ts
index decc34c74..f5b128b95 100644
--- a/apps/desktop/src/main/services/jobs/jobEngine.test.ts
+++ b/apps/desktop/src/main/services/jobs/jobEngine.test.ts
@@ -1,10 +1,6 @@
 import { describe, expect, it, vi } from "vitest";
 import { createJobEngine } from "./jobEngine";
 
-function flush(): Promise<void> {
-  return new Promise((resolve) => setTimeout(resolve, 0));
-}
-
 describe("jobEngine deterministic refresh", () => {
   it("queues lane refresh hooks without pack refresh side effects", async () => {
     const logger = { debug: vi.fn(), info: vi.fn(), warn: vi.fn(), error: vi.fn() } as any;
@@ -14,9 +10,6 @@ describe("jobEngine deterministic refresh", () => {
     });
 
     engine.onSessionEnded({ laneId: "lane-1", sessionId: "session-1" });
-    await flush();
-    await flush();
-    await flush();
 
     expect(logger.info).toHaveBeenCalledWith(
       "jobs.refresh_lane.begin",
@@ -26,6 +19,7 @@ describe("jobEngine deterministic refresh", () => {
       "jobs.refresh_lane.done",
       expect.objectContaining({ laneId: "lane-1", sessionId: "session-1", reason: "session_end" })
     );
+    engine.dispose();
   });
 
   it("skips periodic full conflict prediction by default in dev stability mode", async () => {
diff --git a/apps/desktop/src/main/services/localRuntime/localRuntimeConnectionPool.test.ts b/apps/desktop/src/main/services/localRuntime/localRuntimeConnectionPool.test.ts
index 37638c68c..5d838063c 100644
--- a/apps/desktop/src/main/services/localRuntime/localRuntimeConnectionPool.test.ts
+++ b/apps/desktop/src/main/services/localRuntime/localRuntimeConnectionPool.test.ts
@@ -357,7 +357,7 @@ describe("local runtime connection pool", () => {
     }
   }, 45_000);
 
-  it("restarts a stale local daemon before attaching", async () => {
+  it("refuses a stale local daemon without shutting down active work", async () => {
     const adeCliRoot = path.resolve(process.cwd(), "../ade-cli");
     const cliPath = path.join(adeCliRoot, "src", "cli.ts");
     const tsxLoaderPath = path.join(adeCliRoot, "node_modules", "tsx", "dist", "loader.mjs");
@@ -366,7 +366,6 @@ describe("local runtime connection pool", () => {
 
     const adeHome = fs.mkdtempSync(path.join(os.tmpdir(), "ade-local-runtime-version-"));
     const projectRoot = fs.mkdtempSync(path.join(os.tmpdir(), "ade-local-runtime-version-project-"));
-    const expectedProjectRoot = fs.realpathSync.native(projectRoot);
     const socketPath = path.join(adeHome, "sock", "ade.sock");
     const originalEnv = {
       ADE_CLI_JS: process.env.ADE_CLI_JS,
@@ -405,10 +404,11 @@ describe("local runtime connection pool", () => {
       process.env.NODE_OPTIONS = baseEnv.NODE_OPTIONS;
 
       pool = new LocalRuntimeConnectionPool("2.0.0", logger as never, { disableSync: true });
-      const registered = await pool.ensureProject(projectRoot);
+      await expect(pool.ensureProject(projectRoot)).rejects.toThrow(
+        /does not match desktop version 2\.0\.0/,
+      );
 
-      expect(registered.rootPath).toBe(expectedProjectRoot);
-      expect(logger.info).toHaveBeenCalledWith("local_runtime.version_mismatch_restart", expect.objectContaining({
+      expect(logger.info).toHaveBeenCalledWith("local_runtime.version_mismatch_blocked", expect.objectContaining({
         runtimeVersion: "1.0.0",
         appVersion: "2.0.0",
       }));
@@ -423,7 +423,7 @@ describe("local runtime connection pool", () => {
         });
         expect(initialized).toMatchObject({
           runtimeInfo: {
-            version: "2.0.0",
+            version: "1.0.0",
           },
         });
       } finally {
@@ -444,7 +444,79 @@ describe("local runtime connection pool", () => {
     }
   }, 45_000);
 
-  it("restarts a same-version local daemon when the packaged runtime build changed", async () => {
+  it("accepts a dev placeholder-version daemon when the runtime build hash matches", async () => {
+    const adeCliRoot = path.resolve(process.cwd(), "../ade-cli");
+    const cliPath = path.join(adeCliRoot, "src", "cli.ts");
+    const tsxLoaderPath = path.join(adeCliRoot, "node_modules", "tsx", "dist", "loader.mjs");
+    expect(fs.existsSync(cliPath)).toBe(true);
+    expect(fs.existsSync(tsxLoaderPath)).toBe(true);
+
+    const adeHome = fs.mkdtempSync(path.join(os.tmpdir(), "ade-local-runtime-dev-version-"));
+    const projectRoot = fs.mkdtempSync(path.join(os.tmpdir(), "ade-local-runtime-dev-version-project-"));
+    const socketPath = path.join(adeHome, "sock", "ade.sock");
+    const expectedBuildHash = computeLocalRuntimeBuildHash(cliPath);
+    expect(expectedBuildHash).toBeTruthy();
+    const originalEnv = {
+      ADE_CLI_JS: process.env.ADE_CLI_JS,
+      ADE_HOME: process.env.ADE_HOME,
+      ADE_RUNTIME_SOCKET_PATH: process.env.ADE_RUNTIME_SOCKET_PATH,
+      NODE_OPTIONS: process.env.NODE_OPTIONS,
+    };
+    const baseEnv = {
+      ...process.env,
+      ADE_HOME: adeHome,
+      ADE_RUNTIME_SOCKET_PATH: socketPath,
+      NODE_OPTIONS: withTsxNodeOptions(originalEnv.NODE_OPTIONS, tsxLoaderPath),
+    };
+    const devDaemon = startServeProcess({
+      cliPath,
+      cwd: adeCliRoot,
+      env: {
+        ...baseEnv,
+        ADE_CLI_VERSION: "0.0.0",
+        ADE_RUNTIME_BUILD_HASH: expectedBuildHash!,
+      },
+      socketPath,
+    });
+    const logger = {
+      debug: vi.fn(),
+      info: vi.fn(),
+      warn: vi.fn(),
+      error: vi.fn(),
+    };
+    let pool: LocalRuntimeConnectionPool | null = null;
+
+    try {
+      await waitForRuntimeSocket(socketPath);
+      process.env.ADE_CLI_JS = cliPath;
+      process.env.ADE_HOME = adeHome;
+      process.env.ADE_RUNTIME_SOCKET_PATH = socketPath;
+      process.env.NODE_OPTIONS = baseEnv.NODE_OPTIONS;
+
+      pool = new LocalRuntimeConnectionPool("1.0.0-beta.1", logger as never, { disableSync: true });
+      const registered = await pool.ensureProject(projectRoot);
+
+      expect(fs.realpathSync(registered.rootPath)).toBe(fs.realpathSync(projectRoot));
+      expect(logger.info).not.toHaveBeenCalledWith(
+        "local_runtime.version_mismatch_blocked",
+        expect.anything(),
+      );
+    } finally {
+      pool?.dispose();
+      await shutdownRuntime(socketPath);
+      if (!devDaemon.killed) devDaemon.kill();
+      if (originalEnv.ADE_CLI_JS === undefined) delete process.env.ADE_CLI_JS;
+      else process.env.ADE_CLI_JS = originalEnv.ADE_CLI_JS;
+      if (originalEnv.ADE_HOME === undefined) delete process.env.ADE_HOME;
+      else process.env.ADE_HOME = originalEnv.ADE_HOME;
+      if (originalEnv.ADE_RUNTIME_SOCKET_PATH === undefined) delete process.env.ADE_RUNTIME_SOCKET_PATH;
+      else process.env.ADE_RUNTIME_SOCKET_PATH = originalEnv.ADE_RUNTIME_SOCKET_PATH;
+      if (originalEnv.NODE_OPTIONS === undefined) delete process.env.NODE_OPTIONS;
+      else process.env.NODE_OPTIONS = originalEnv.NODE_OPTIONS;
+    }
+  }, 45_000);
+
+  it("refuses a same-version local daemon when the packaged runtime build changed", async () => {
     const adeCliRoot = path.resolve(process.cwd(), "../ade-cli");
     const cliPath = path.join(adeCliRoot, "src", "cli.ts");
     const tsxLoaderPath = path.join(adeCliRoot, "node_modules", "tsx", "dist", "loader.mjs");
@@ -453,7 +525,6 @@ describe("local runtime connection pool", () => {
 
     const adeHome = fs.mkdtempSync(path.join(os.tmpdir(), "ade-local-runtime-build-"));
     const projectRoot = fs.mkdtempSync(path.join(os.tmpdir(), "ade-local-runtime-build-project-"));
-    const expectedProjectRoot = fs.realpathSync.native(projectRoot);
     const socketPath = path.join(adeHome, "sock", "ade.sock");
     const originalEnv = {
       ADE_CLI_JS: process.env.ADE_CLI_JS,
@@ -495,10 +566,11 @@ describe("local runtime connection pool", () => {
       const expectedBuildHash = computeLocalRuntimeBuildHash(cliPath);
       expect(expectedBuildHash).toBeTruthy();
       pool = new LocalRuntimeConnectionPool("1.0.0", logger as never, { disableSync: true });
-      const registered = await pool.ensureProject(projectRoot);
+      await expect(pool.ensureProject(projectRoot)).rejects.toThrow(
+        /build does not match the packaged desktop runtime/,
+      );
 
-      expect(registered.rootPath).toBe(expectedProjectRoot);
-      expect(logger.info).toHaveBeenCalledWith("local_runtime.build_mismatch_restart", expect.objectContaining({
+      expect(logger.info).toHaveBeenCalledWith("local_runtime.build_mismatch_blocked", expect.objectContaining({
         runtimeBuildHash: "old-build",
         expectedBuildHash,
       }));
@@ -514,7 +586,7 @@ describe("local runtime connection pool", () => {
         expect(initialized).toMatchObject({
           runtimeInfo: {
             version: "1.0.0",
-            buildHash: expectedBuildHash,
+            buildHash: "old-build",
           },
         });
       } finally {
diff --git a/apps/desktop/src/main/services/localRuntime/localRuntimeConnectionPool.ts b/apps/desktop/src/main/services/localRuntime/localRuntimeConnectionPool.ts
index 9aeef3ba7..21bd739f5 100644
--- a/apps/desktop/src/main/services/localRuntime/localRuntimeConnectionPool.ts
+++ b/apps/desktop/src/main/services/localRuntime/localRuntimeConnectionPool.ts
@@ -61,6 +61,7 @@ type LocalRuntimeNodePathOptions = {
 const LOCAL_RUNTIME_PROJECT_TIMEOUT_MS = 3_000;
 const LOCAL_RUNTIME_FILE_ACTION_TIMEOUT_MS = 8_000;
 const LOCAL_RUNTIME_EVENT_POLL_TIMEOUT_MS = 2_000;
+const PLACEHOLDER_RUNTIME_VERSION = "0.0.0";
 
 export function buildLocalRuntimeServeArgs(
   cliPath: string,
@@ -217,17 +218,34 @@ export function computeLocalRuntimeBuildHash(cliPath = resolveCliScriptPath()):
   }
 }
 
-async function shutdownRuntimeClient(client: RuntimeRpcClient): Promise<void> {
-  try {
-    await client.call("shutdown", {});
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    if (!message.includes("socket closed")) throw error;
-  } finally {
-    try { client.close(); } catch {}
+function isCompatibleRuntimeVersion(args: {
+  runtimeVersion: string | null;
+  appVersion: string;
+  runtimeBuildHash: string | null;
+  expectedBuildHash: string | null;
+}): boolean {
+  if (!args.runtimeVersion) return true;
+  if (args.runtimeVersion === args.appVersion) return true;
+  return (
+    args.runtimeVersion === PLACEHOLDER_RUNTIME_VERSION &&
+    args.expectedBuildHash != null &&
+    args.runtimeBuildHash === args.expectedBuildHash
+  );
+}
+
+class LocalRuntimeCompatibilityError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = "LocalRuntimeCompatibilityError";
   }
 }
 
+function closeRuntimeClient(client: RuntimeRpcClient): void {
+  try {
+    client.close();
+  } catch {}
+}
+
 async function waitForSocket(socketPath: string, timeoutMs = 10_000): Promise<void> {
   const startedAt = Date.now();
   let lastError: Error | null = null;
@@ -651,6 +669,9 @@ export class LocalRuntimeConnectionPool {
     try {
       return await this.connectClient(socketPath);
     } catch (error) {
+      if (error instanceof LocalRuntimeCompatibilityError) {
+        throw error;
+      }
       this.logger.debug("local_runtime.connect_existing_failed", {
         socketPath,
         error: error instanceof Error ? error.message : String(error),
@@ -662,26 +683,43 @@ export class LocalRuntimeConnectionPool {
   private async connectClient(socketPath: string): Promise<RuntimeRpcClient> {
     const transport = await openSocketTransport(socketPath);
     const client = new RuntimeRpcClient(transport);
-    const initializeResult = await client.initialize("ade-desktop-local", this.appVersion);
+    let initializeResult: unknown;
+    try {
+      initializeResult = await client.initialize("ade-desktop-local", this.appVersion);
+    } catch (error) {
+      closeRuntimeClient(client);
+      throw error;
+    }
     const runtimeInfo = readRuntimeInfo(initializeResult);
-    if (runtimeInfo.version && runtimeInfo.version !== this.appVersion) {
-      this.logger.info("local_runtime.version_mismatch_restart", {
+    const expectedBuildHash = computeLocalRuntimeBuildHash();
+    if (!isCompatibleRuntimeVersion({
+      runtimeVersion: runtimeInfo.version,
+      appVersion: this.appVersion,
+      runtimeBuildHash: runtimeInfo.buildHash,
+      expectedBuildHash,
+    })) {
+      this.logger.info("local_runtime.version_mismatch_blocked", {
         socketPath,
         runtimeVersion: runtimeInfo.version,
         appVersion: this.appVersion,
+        runtimeBuildHash: runtimeInfo.buildHash,
+        expectedBuildHash,
       });
-      await shutdownRuntimeClient(client);
-      throw new Error(`ADE service version ${runtimeInfo.version} does not match desktop version ${this.appVersion}.`);
+      closeRuntimeClient(client);
+      throw new LocalRuntimeCompatibilityError(
+        `ADE service version ${runtimeInfo.version} does not match desktop version ${this.appVersion}. The existing ADE service was left running to preserve active work.`,
+      );
     }
-    const expectedBuildHash = computeLocalRuntimeBuildHash();
     if (expectedBuildHash && runtimeInfo.buildHash !== expectedBuildHash) {
-      this.logger.info("local_runtime.build_mismatch_restart", {
+      this.logger.info("local_runtime.build_mismatch_blocked", {
         socketPath,
         runtimeBuildHash: runtimeInfo.buildHash,
         expectedBuildHash,
       });
-      await shutdownRuntimeClient(client);
-      throw new Error("ADE service build does not match the packaged desktop runtime.");
+      closeRuntimeClient(client);
+      throw new LocalRuntimeCompatibilityError(
+        "ADE service build does not match the packaged desktop runtime. The existing ADE service was left running to preserve active work.",
+      );
     }
     this.activeClient = client;
     client.onDisconnect((error) => {
diff --git a/apps/desktop/src/main/services/pty/ptyService.test.ts b/apps/desktop/src/main/services/pty/ptyService.test.ts
index beea9fd12..17b935069 100644
--- a/apps/desktop/src/main/services/pty/ptyService.test.ts
+++ b/apps/desktop/src/main/services/pty/ptyService.test.ts
@@ -2912,7 +2912,7 @@ describe("ptyService", () => {
         chatSessionId: "chat-write",
       });
 
-      const result = service.writeTerminal({ chatSessionId: "chat-write", data: "y\n" });
+      const result = await service.writeTerminal({ chatSessionId: "chat-write", data: "y\n" });
       expect(result).toEqual({ ok: true });
       expect(mockPty.write).toHaveBeenCalledWith("y\n");
     });
@@ -2956,7 +2956,7 @@ describe("ptyService", () => {
       await expect(service.readTerminal({ chatSessionId: "no-such-chat" })).rejects.toThrow(
         /terminal\.read requires/,
       );
-      expect(() => service.writeTerminal({ chatSessionId: "no-such-chat", data: "x" })).toThrow(
+      await expect(service.writeTerminal({ chatSessionId: "no-such-chat", data: "x" })).rejects.toThrow(
         /terminal\.write requires/,
       );
       expect(() => service.signalTerminal({ chatSessionId: "no-such-chat", signal: "SIGINT" })).toThrow(
@@ -2964,5 +2964,249 @@ describe("ptyService", () => {
       );
       expect(service.activeForChat({ chatSessionId: "no-such-chat" })).toBeNull();
     });
+
+    describe("reattachChatCli", () => {
+      it("returns the existing live PTY when one is already bound", async () => {
+        const { service } = createChatHarness();
+        // Use the same sessionId for chat session and terminal session, mirroring chat-CLI tracking
+        const created = await service.create({
+          sessionId: "chat-existing",
+          allowNewSessionId: true,
+          laneId: "lane-1",
+          title: "Claude Chat",
+          cols: 80,
+          rows: 24,
+          chatSessionId: "chat-existing",
+          tracked: true,
+          toolType: "claude-chat",
+          startupCommand: "claude --resume target",
+        });
+
+        const result = await service.reattachChatCli({ chatSessionId: "chat-existing" });
+
+        expect(result.relaunched).toBe(false);
+        expect(result.terminalId).toBe(created.sessionId);
+        expect(result.ptyId).toBe(created.ptyId);
+      });
+
+      it("relaunches a new PTY for a disposed chat-CLI session", async () => {
+        const { service, loadPty, sessionStore } = createChatHarness();
+        const created = await service.create({
+          sessionId: "chat-relaunch",
+          allowNewSessionId: true,
+          laneId: "lane-1",
+          title: "Claude Chat",
+          cols: 80,
+          rows: 24,
+          chatSessionId: "chat-relaunch",
+          tracked: true,
+          toolType: "claude-chat",
+          startupCommand: "claude --resume target",
+        });
+
+        // Persist a resume command on the session record so reattach can build a startup command.
+        const record = sessionStore.get("chat-relaunch");
+        if (record) {
+          record.resumeCommand = "claude --resume target";
+        }
+
+        // Dispose the live PTY entry to simulate a dead session after ADE crash/restart.
+        service.dispose({ ptyId: created.ptyId, sessionId: created.sessionId });
+
+        // Wire a fresh mock PTY for the relaunch.
+        const freshMockPty = createMockPty();
+        const freshSpawn = vi.fn(() => freshMockPty);
+        loadPty.mockImplementationOnce(() => ({ spawn: freshSpawn as any }));
+
+        const result = await service.reattachChatCli({ chatSessionId: "chat-relaunch" });
+
+        expect(result.relaunched).toBe(true);
+        expect(result.terminalId).toBe(created.sessionId);
+        expect(result.ptyId).not.toBe(created.ptyId);
+        expect(freshSpawn).toHaveBeenCalled();
+      });
+
+      it("throws when the chat-CLI session record is missing", async () => {
+        const { service } = createChatHarness();
+        await expect(service.reattachChatCli({ chatSessionId: "missing" })).rejects.toThrow(
+          /was not found/,
+        );
+      });
+
+      it("throws when the session is not a persisted chat tool type", async () => {
+        const { service } = createChatHarness();
+        await service.create({
+          sessionId: "plain-shell",
+          allowNewSessionId: true,
+          laneId: "lane-1",
+          title: "Shell",
+          cols: 80,
+          rows: 24,
+          tracked: true,
+          toolType: "shell",
+        });
+        // The activeTerminalByChatSession bypass key is the chatSessionId, which is null for shell sessions,
+        // so reattachChatCli falls through to the session-lookup branch directly even with a live PTY.
+
+        await expect(service.reattachChatCli({ chatSessionId: "plain-shell" })).rejects.toThrow(
+          /not a chat CLI session/,
+        );
+      });
+
+      it("throws when the chat-CLI session is untracked", async () => {
+        const { service, sessionStore } = createChatHarness();
+        const created = await service.create({
+          sessionId: "untracked-chat",
+          allowNewSessionId: true,
+          laneId: "lane-1",
+          title: "Claude",
+          cols: 80,
+          rows: 24,
+          chatSessionId: "untracked-chat",
+          toolType: "claude-chat",
+          tracked: false,
+        });
+        // Force tracked = false on the stored record (the chat harness defaults to tracked: true).
+        const record = sessionStore.get("untracked-chat");
+        if (record) {
+          record.tracked = false;
+        }
+        // Dispose the live PTY so reattachChatCli must take the lookup-and-relaunch path.
+        service.dispose({ ptyId: created.ptyId, sessionId: created.sessionId });
+
+        await expect(service.reattachChatCli({ chatSessionId: "untracked-chat" })).rejects.toThrow(
+          /not tracked/,
+        );
+      });
+
+      it("throws when the chat-CLI session has no resume command or metadata", async () => {
+        const { service, sessionStore } = createChatHarness();
+        const created = await service.create({
+          sessionId: "no-resume",
+          allowNewSessionId: true,
+          laneId: "lane-1",
+          title: "Claude",
+          cols: 80,
+          rows: 24,
+          chatSessionId: "no-resume",
+          tracked: true,
+          toolType: "claude-chat",
+        });
+
+        // Wipe out the resume hints so reattach has nothing to launch with.
+        const record = sessionStore.get("no-resume");
+        if (record) {
+          record.resumeCommand = null;
+          record.resumeMetadata = null;
+        }
+
+        service.dispose({ ptyId: created.ptyId, sessionId: created.sessionId });
+
+        await expect(service.reattachChatCli({ chatSessionId: "no-resume" })).rejects.toThrow(
+          /no resume command available/,
+        );
+      });
+
+      it("throws when called with an empty chatSessionId", async () => {
+        const { service } = createChatHarness();
+        await expect(service.reattachChatCli({ chatSessionId: "" })).rejects.toThrow(
+          /requires chatSessionId/,
+        );
+      });
+
+      it("dedupes concurrent reattach calls for the same chatSessionId to a single relaunch", async () => {
+        const { service, loadPty, sessionStore } = createChatHarness();
+        const created = await service.create({
+          sessionId: "chat-dedup",
+          allowNewSessionId: true,
+          laneId: "lane-1",
+          title: "Claude Chat",
+          cols: 80,
+          rows: 24,
+          chatSessionId: "chat-dedup",
+          tracked: true,
+          toolType: "claude-chat",
+          startupCommand: "claude --resume target",
+        });
+        const record = sessionStore.get("chat-dedup");
+        if (record) record.resumeCommand = "claude --resume target";
+        service.dispose({ ptyId: created.ptyId, sessionId: created.sessionId });
+
+        // Only one fresh spawn should happen even if multiple callers race.
+        const freshMockPty = createMockPty();
+        const freshSpawn = vi.fn(() => freshMockPty);
+        loadPty.mockImplementation(() => ({ spawn: freshSpawn as any }));
+
+        const [a, b, c] = await Promise.all([
+          service.reattachChatCli({ chatSessionId: "chat-dedup" }),
+          service.reattachChatCli({ chatSessionId: "chat-dedup" }),
+          service.reattachChatCli({ chatSessionId: "chat-dedup" }),
+        ]);
+
+        // All three resolve to the same new PTY; only one spawn happened.
+        expect(a.ptyId).toBe(b.ptyId);
+        expect(b.ptyId).toBe(c.ptyId);
+        expect(freshSpawn).toHaveBeenCalledTimes(1);
+      });
+    });
+
+    describe("writeTerminal auto-reattach", () => {
+      it("auto-reattaches a dead chat-CLI session when writing by chatSessionId", async () => {
+        const { service, loadPty, sessionStore } = createChatHarness();
+        const created = await service.create({
+          sessionId: "chat-auto",
+          allowNewSessionId: true,
+          laneId: "lane-1",
+          title: "Claude Chat",
+          cols: 80,
+          rows: 24,
+          chatSessionId: "chat-auto",
+          tracked: true,
+          toolType: "claude-chat",
+          startupCommand: "claude --resume target",
+        });
+
+        // Seed a resume command so the auto-reattach can launch.
+        const record = sessionStore.get("chat-auto");
+        if (record) {
+          record.resumeCommand = "claude --resume target";
+        }
+
+        // Simulate the PTY being dead (ADE crashed or quit).
+        service.dispose({ ptyId: created.ptyId, sessionId: created.sessionId });
+
+        // Wire a fresh PTY for the relaunch and capture its write calls.
+        const freshMockPty = createMockPty();
+        const freshSpawn = vi.fn(() => freshMockPty);
+        loadPty.mockImplementationOnce(() => ({ spawn: freshSpawn as any }));
+
+        const result = await service.writeTerminal({ chatSessionId: "chat-auto", data: "hello\n" });
+
+        expect(result).toEqual({ ok: true });
+        expect(freshSpawn).toHaveBeenCalled();
+        expect(freshMockPty.write).toHaveBeenCalledWith("hello\n");
+      });
+
+      it("still throws when called with a stale explicit ptyId", async () => {
+        const { service } = createChatHarness();
+        const created = await service.create({
+          sessionId: "chat-stale-pty",
+          allowNewSessionId: true,
+          laneId: "lane-1",
+          title: "Claude Chat",
+          cols: 80,
+          rows: 24,
+          chatSessionId: "chat-stale-pty",
+          tracked: true,
+          toolType: "claude-chat",
+        });
+
+        service.dispose({ ptyId: created.ptyId, sessionId: created.sessionId });
+
+        await expect(
+          service.writeTerminal({ ptyId: created.ptyId, data: "x" }),
+        ).rejects.toThrow(/Terminal PTY '.*' is not running/);
+      });
+    });
   });
 });
diff --git a/apps/desktop/src/main/services/pty/ptyService.ts b/apps/desktop/src/main/services/pty/ptyService.ts
index 44106863b..9c3a01261 100644
--- a/apps/desktop/src/main/services/pty/ptyService.ts
+++ b/apps/desktop/src/main/services/pty/ptyService.ts
@@ -27,6 +27,8 @@ import type {
   ChatTerminalListArgs,
   ChatTerminalReadArgs,
   ChatTerminalReadResult,
+  ChatTerminalReattachArgs,
+  ChatTerminalReattachResult,
   ChatTerminalResizeArgs,
   ChatTerminalSession,
   ChatTerminalSignalArgs,
@@ -615,6 +617,9 @@ export function createPtyService({
   const missingResumeTargetBackfillFailures = new Map<string, { toolType: TerminalToolType | null; checkedAtMs: number }>();
   const claudeTitleCaptureKeys = new Set<string>();
   const resumeRuntimeFlights = new Map<string, Promise<PtyCreateResult>>();
+  // Dedup concurrent reattachChatCli calls for the same chatSessionId so we
+  // never spawn two PTYs racing to `claude --resume <same-id>`.
+  const reattachChatCliFlights = new Map<string, Promise<ChatTerminalReattachResult>>();
   /** Timers for auto-closing tool-typed PTYs when the CLI tool exits back to shell prompt */
   const toolAutoCloseTimers = new Map<string, ReturnType<typeof setTimeout>>();
   let ptyDataSummaryTimer: ReturnType<typeof setTimeout> | null = null;
@@ -3015,6 +3020,95 @@ export function createPtyService({
       return session ? terminalSessionFromSummary(session) : null;
     },
 
+    async reattachChatCli(args: ChatTerminalReattachArgs): Promise<ChatTerminalReattachResult> {
+      const chatSessionId = cleanOptionalId(args?.chatSessionId);
+      if (!chatSessionId) throw new Error("terminal.reattachChatCli requires chatSessionId.");
+
+      // Fast path: an existing live PTY is already bound. Skip the dedup map to
+      // keep the no-op cost low.
+      const activeTerminalId = activeTerminalByChatSession.get(chatSessionId) ?? null;
+      if (activeTerminalId) {
+        const liveActive = liveEntryBySessionId(activeTerminalId);
+        if (liveActive) {
+          return {
+            terminalId: activeTerminalId,
+            ptyId: liveActive[0],
+            pid: liveActive[1].pty.pid ?? null,
+            relaunched: false,
+          };
+        }
+      }
+
+      // Single-flight dedup: concurrent callers (chat composer + App Control,
+      // rapid sends, etc.) must not each launch a fresh `claude --resume` PTY.
+      // Whoever wins the create wins; everyone else awaits the same Promise.
+      const existing = reattachChatCliFlights.get(chatSessionId);
+      if (existing) return existing;
+
+      const flight = (async (): Promise<ChatTerminalReattachResult> => {
+        // For chat-CLI sessions the chat session id and terminal session id are the same.
+        const session = sessionService.get(chatSessionId);
+        if (!session) {
+          throw new Error(`Chat CLI session '${chatSessionId}' was not found.`);
+        }
+        if (!session.tracked) {
+          throw new Error(`Chat CLI session '${chatSessionId}' is not tracked and cannot be reattached.`);
+        }
+        if (!isPersistedChatToolType(session.toolType)) {
+          throw new Error(`Session '${chatSessionId}' is not a chat CLI session.`);
+        }
+
+        const resumeCommand = session.resumeMetadata
+          ? buildTrackedCliResumeCommand(session.resumeMetadata, {
+            model: null,
+            reasoningEffort: null,
+            permissionMode: null,
+          })
+          : normalizeResumeCommand(session.resumeCommand, session.toolType);
+        if (!resumeCommand) {
+          throw new Error(`Chat CLI session '${chatSessionId}' has no resume command available.`);
+        }
+
+        const { cols, rows } = clampDims(
+          typeof args.cols === "number" ? args.cols : PTY_SEND_DEFAULT_COLS,
+          typeof args.rows === "number" ? args.rows : PTY_SEND_DEFAULT_ROWS,
+        );
+
+        const created = await service.create({
+          sessionId: chatSessionId,
+          laneId: session.laneId,
+          chatSessionId,
+          cols,
+          rows,
+          title: session.title || session.goal || "Chat CLI",
+          tracked: true,
+          toolType: session.toolType,
+          startupCommand: resumeCommand,
+        });
+
+        logger.info("pty.reattach_chat_cli", {
+          chatSessionId,
+          toolType: session.toolType,
+        });
+
+        return {
+          terminalId: created.sessionId,
+          ptyId: created.ptyId,
+          pid: created.pid,
+          relaunched: true,
+        };
+      })();
+
+      reattachChatCliFlights.set(chatSessionId, flight);
+      try {
+        return await flight;
+      } finally {
+        if (reattachChatCliFlights.get(chatSessionId) === flight) {
+          reattachChatCliFlights.delete(chatSessionId);
+        }
+      }
+    },
+
     async readTerminal(args: ChatTerminalReadArgs = {}): Promise<ChatTerminalReadResult> {
       const terminalId = resolveTerminalId(args);
       if (!terminalId) throw new Error("terminal.read requires terminalId or an active chat terminal.");
@@ -3092,21 +3186,45 @@ export function createPtyService({
       };
     },
 
-    writeTerminal(args: ChatTerminalWriteArgs): { ok: true } {
+    async writeTerminal(args: ChatTerminalWriteArgs): Promise<{ ok: true }> {
       if (!args || typeof args.data !== "string") {
         throw new Error("terminal.write requires string data.");
       }
       const ptyId = cleanOptionalId(args.ptyId);
       let entry: PtyEntry | null = null;
       if (ptyId) {
+        // Explicit ptyId: never auto-reattach by ptyId; preserve the throw if the entry is missing.
         const candidate = ptys.get(ptyId);
         if (!candidate || candidate.disposed) throw new Error(`Terminal PTY '${ptyId}' is not running.`);
         entry = candidate;
       } else {
         const terminalId = resolveTerminalId(args);
-        if (!terminalId) throw new Error("terminal.write requires terminalId, ptyId, or an active chat terminal.");
-        const live = liveEntryBySessionId(terminalId);
-        if (!live) throw new Error(`Terminal session '${terminalId}' is not running.`);
+        const chatSessionId = cleanOptionalId(args.chatSessionId);
+        let live = terminalId ? liveEntryBySessionId(terminalId) : null;
+        if (!live) {
+          // The PTY is gone. If this is a chat-CLI session and we have a chatSessionId or a terminalId that
+          // matches a chat-CLI tracked session record, auto-reattach via reattachChatCli.
+          const reattachKey = chatSessionId ?? terminalId ?? null;
+          if (reattachKey) {
+            const session = sessionService.get(reattachKey);
+            if (
+              session
+              && session.tracked
+              && isPersistedChatToolType(session.toolType)
+            ) {
+              const created = await service.reattachChatCli({ chatSessionId: reattachKey });
+              live = liveEntryBySessionId(created.terminalId);
+            }
+          }
+        }
+        if (!live) {
+          if (!terminalId) {
+            // No live terminal could be resolved from args and no chat-CLI auto-reattach applies.
+            // Preserve the historical contract for callers that pass chatSessionId without a live target.
+            throw new Error("terminal.write requires terminalId, ptyId, or an active chat terminal.");
+          }
+          throw new Error(`Terminal session '${terminalId}' is not running.`);
+        }
         entry = live[1];
       }
       entry.pty.write(args.data);
@@ -3405,6 +3523,16 @@ export function createPtyService({
       return count;
     },
 
+    // Used by project-context rebalancing to decide whether a project still
+    // has user work that would be destroyed by eviction. ANY live PTY (running
+    // CLI, shell, agent process) protects the whole context.
+    hasLiveSessions(): boolean {
+      for (const entry of ptys.values()) {
+        if (!entry.disposed) return true;
+      }
+      return false;
+    },
+
     onData(listener: PtyDataListener): () => void {
       dataListeners.add(listener);
       return () => {
diff --git a/apps/desktop/src/main/services/updates/autoUpdateService.ts b/apps/desktop/src/main/services/updates/autoUpdateService.ts
index 19160961e..0c0ab37ff 100644
--- a/apps/desktop/src/main/services/updates/autoUpdateService.ts
+++ b/apps/desktop/src/main/services/updates/autoUpdateService.ts
@@ -1,6 +1,5 @@
 import fs from "node:fs";
 import path from "node:path";
-import type { ProgressInfo } from "builder-util-runtime";
 import { autoUpdater, type UpdateInfo } from "electron-updater";
 import type { AutoUpdateSnapshot, RecentlyInstalledUpdate } from "../../../shared/types";
 import type { Logger } from "../logging/logger";
@@ -34,6 +33,13 @@ type UpdateCheckResultLike = {
   downloadPromise?: Promise<unknown> | null;
 };
 
+type ProgressInfo = {
+  percent: number;
+  bytesPerSecond: number;
+  transferred: number;
+  total: number;
+};
+
 export function createEmptyAutoUpdateSnapshot(): AutoUpdateSnapshot {
   return {
     status: "idle",
diff --git a/apps/desktop/src/preload/global.d.ts b/apps/desktop/src/preload/global.d.ts
index 48427074a..3f43f17dc 100644
--- a/apps/desktop/src/preload/global.d.ts
+++ b/apps/desktop/src/preload/global.d.ts
@@ -103,6 +103,8 @@ import type {
   AgentChatClaudeSessionListArgs,
   AgentChatClaudeSessionMessage,
   AgentChatClaudeSessionMessagesArgs,
+  AgentChatSubagentTranscriptArgs,
+  AgentChatSubagentTranscriptMessage,
   AgentChatContextUsage,
   AgentChatContextUsageArgs,
   AgentChatRewindFilesArgs,
@@ -735,6 +737,8 @@ import type {
   ChatTerminalPreviewResult,
   ChatTerminalReadArgs,
   ChatTerminalReadResult,
+  ChatTerminalReattachArgs,
+  ChatTerminalReattachResult,
   ChatTerminalSession,
   ChatTerminalSignalArgs,
   ChatTerminalWriteArgs,
@@ -758,7 +762,11 @@ declare global {
           windowId: number | null;
           project: ProjectInfo | null;
           binding: OpenProjectBinding | null;
+          openProjectTabs: ProjectInfo[];
         }>;
+        setWindowProjectTabs: (
+          rootPaths: string[],
+        ) => Promise<{ openProjectTabs: ProjectInfo[] }>;
         newWindow: () => Promise<{ windowId: number | null }>;
         openProjectInNewWindow: (
           rootPath: string,
@@ -1525,6 +1533,9 @@ declare global {
         getClaudeSessionMessages: (
           args: AgentChatClaudeSessionMessagesArgs,
         ) => Promise<AgentChatClaudeSessionMessage[]>;
+        getSubagentTranscript: (
+          args: AgentChatSubagentTranscriptArgs,
+        ) => Promise<AgentChatSubagentTranscriptMessage[] | null>;
         getContextUsage: (
           args: AgentChatContextUsageArgs,
         ) => Promise<AgentChatContextUsage | null>;
@@ -1762,6 +1773,9 @@ declare global {
         activeForChat: (
           args: ChatTerminalActiveForChatArgs,
         ) => Promise<ChatTerminalSession | null>;
+        reattachChatCli: (
+          args: ChatTerminalReattachArgs,
+        ) => Promise<ChatTerminalReattachResult>;
       };
       localhost: {
         probePort: (port: number) => Promise<boolean>;
diff --git a/apps/desktop/src/preload/preload.test.ts b/apps/desktop/src/preload/preload.test.ts
index 927625af1..ef71543ca 100644
--- a/apps/desktop/src/preload/preload.test.ts
+++ b/apps/desktop/src/preload/preload.test.ts
@@ -79,6 +79,53 @@ describe("preload OAuth bridge", () => {
     expect(removeListener).toHaveBeenCalledWith(IPC.lanesOAuthEvent, listener);
   });
 
+  it("exposes per-window project tab session IPC", async () => {
+    const project = { rootPath: "/repo/a", displayName: "A", baseRef: "main" };
+    const openProjectTabs = [
+      project,
+      { rootPath: "/repo/b", displayName: "B", baseRef: "main" },
+    ];
+    const invoke = vi.fn(async (channel: string) => {
+      if (channel === IPC.appGetWindowSession) {
+        return { windowId: 7, project, binding: null, openProjectTabs };
+      }
+      if (channel === IPC.appSetWindowProjectTabs) {
+        return { openProjectTabs: [openProjectTabs[1]] };
+      }
+      return undefined;
+    });
+    const on = vi.fn();
+    const removeListener = vi.fn();
+    const exposeInMainWorld = vi.fn((name: string, value: unknown) => {
+      (globalThis as any).__bridgeName = name;
+      (globalThis as any).__adeBridge = value;
+    });
+
+    vi.doMock("electron", () => ({
+      contextBridge: { exposeInMainWorld },
+      ipcRenderer: { invoke, on, removeListener },
+      webFrame: {
+        getZoomLevel: vi.fn(() => 0),
+        setZoomLevel: vi.fn(),
+        getZoomFactor: vi.fn(() => 1),
+      },
+    }));
+
+    await import("./preload");
+
+    const bridge = (globalThis as any).__adeBridge;
+    await expect(bridge.app.getWindowSession()).resolves.toEqual({
+      windowId: 7,
+      project,
+      binding: null,
+      openProjectTabs,
+    });
+    await expect(bridge.app.setWindowProjectTabs(["/repo/b"])).resolves.toEqual({
+      openProjectTabs: [openProjectTabs[1]],
+    });
+    expect(invoke).toHaveBeenCalledWith(IPC.appSetWindowProjectTabs, { rootPaths: ["/repo/b"] });
+  });
+
   it("exposes review IPC methods and cleans up listeners", async () => {
     const invoke = vi.fn(async () => undefined);
     const on = vi.fn();
diff --git a/apps/desktop/src/preload/preload.ts b/apps/desktop/src/preload/preload.ts
index 8d4762e95..e4a85c98b 100644
--- a/apps/desktop/src/preload/preload.ts
+++ b/apps/desktop/src/preload/preload.ts
@@ -312,6 +312,8 @@ import type {
   AgentChatClaudeSessionListArgs,
   AgentChatClaudeSessionMessage,
   AgentChatClaudeSessionMessagesArgs,
+  AgentChatSubagentTranscriptArgs,
+  AgentChatSubagentTranscriptMessage,
   AgentChatContextUsage,
   AgentChatContextUsageArgs,
   AgentChatRewindFilesArgs,
@@ -747,6 +749,8 @@ import type {
   ChatTerminalPreviewResult,
   ChatTerminalReadArgs,
   ChatTerminalReadResult,
+  ChatTerminalReattachArgs,
+  ChatTerminalReattachResult,
   ChatTerminalSession,
   ChatTerminalSignalArgs,
   ChatTerminalWriteArgs,
@@ -2604,15 +2608,21 @@ contextBridge.exposeInMainWorld("ade", {
       windowId: number | null;
       project: ProjectInfo | null;
       binding: OpenProjectBinding | null;
+      openProjectTabs: ProjectInfo[];
     }> => {
       const session = (await ipcRenderer.invoke(IPC.appGetWindowSession)) as {
         windowId: number | null;
         project: ProjectInfo | null;
         binding: OpenProjectBinding | null;
+        openProjectTabs?: ProjectInfo[];
       };
       rememberProjectBinding(session.binding);
-      return session;
+      return { ...session, openProjectTabs: session.openProjectTabs ?? [] };
     },
+    setWindowProjectTabs: async (
+      rootPaths: string[],
+    ): Promise<{ openProjectTabs: ProjectInfo[] }> =>
+      ipcRenderer.invoke(IPC.appSetWindowProjectTabs, { rootPaths }),
     newWindow: async (): Promise<{ windowId: number | null }> =>
       ipcRenderer.invoke(IPC.appNewWindow),
     openProjectInNewWindow: async (
@@ -5370,6 +5380,12 @@ contextBridge.exposeInMainWorld("ade", {
       callProjectRuntimeActionOr("chat", "getClaudeSessionMessages", { args }, () =>
         ipcRenderer.invoke(IPC.agentChatGetClaudeSessionMessages, args),
       ),
+    getSubagentTranscript: async (
+      args: AgentChatSubagentTranscriptArgs,
+    ): Promise<AgentChatSubagentTranscriptMessage[] | null> =>
+      callProjectRuntimeActionOr("chat", "getSubagentTranscript", { args }, () =>
+        ipcRenderer.invoke(IPC.agentChatGetSubagentTranscript, args),
+      ),
     getContextUsage: async (
       args: AgentChatContextUsageArgs,
     ): Promise<AgentChatContextUsage | null> =>
@@ -6052,6 +6068,19 @@ contextBridge.exposeInMainWorld("ade", {
         ? runtime.result
         : ipcRenderer.invoke(IPC.terminalActiveForChat, args);
     },
+    reattachChatCli: async (
+      args: ChatTerminalReattachArgs,
+    ): Promise<ChatTerminalReattachResult> => {
+      const runtime =
+        await callProjectRuntimeActionIfBound<ChatTerminalReattachResult>(
+          "terminal",
+          "reattachChatCli",
+          { args },
+        );
+      return runtime.handled
+        ? runtime.result
+        : ipcRenderer.invoke(IPC.terminalReattachChatCli, args);
+    },
   },
   localhost: {
     probePort: async (port: number): Promise<boolean> =>
diff --git a/apps/desktop/src/renderer/browserMock.ts b/apps/desktop/src/renderer/browserMock.ts
index 225833f4a..62ac0b616 100644
--- a/apps/desktop/src/renderer/browserMock.ts
+++ b/apps/desktop/src/renderer/browserMock.ts
@@ -2818,7 +2818,9 @@ if (typeof window !== "undefined" && shouldInstallBrowserMock(window)) {
           rootPath: MOCK_PROJECT.rootPath,
           displayName: MOCK_PROJECT.name,
         },
+        openProjectTabs: [MOCK_PROJECT],
       }),
+      setWindowProjectTabs: resolved({ openProjectTabs: [MOCK_PROJECT] }),
       newWindow: resolved({ windowId: 2 }),
       openProjectInNewWindow: resolvedArg({
         windowId: 2,
@@ -4504,6 +4506,7 @@ if (typeof window !== "undefined" && shouldInstallBrowserMock(window)) {
       listClaudeSessions: resolvedArg([]),
       getClaudeSessionInfo: resolvedArg(null),
       getClaudeSessionMessages: resolvedArg([]),
+      getSubagentTranscript: resolvedArg(null),
       getContextUsage: resolvedArg(null),
       rewindFiles: resolvedArg({
         canRewind: false,
diff --git a/apps/desktop/src/renderer/components/app/App.tsx b/apps/desktop/src/renderer/components/app/App.tsx
index 22423af5e..6dbe59001 100644
--- a/apps/desktop/src/renderer/components/app/App.tsx
+++ b/apps/desktop/src/renderer/components/app/App.tsx
@@ -3,12 +3,12 @@ import {
   BrowserRouter,
   HashRouter,
   Navigate,
-  Outlet,
   Route,
   Routes,
   useLocation,
   useNavigate
 } from "react-router-dom";
+import { useShallow } from "zustand/react/shallow";
 
 import { AppShell } from "./AppShell";
 import { RunPage } from "../run/RunPage";
@@ -54,11 +54,17 @@ const CtoPage = React.lazy(() =>
   import("../cto/CtoPage").then((m) => ({ default: m.CtoPage }))
 );
 
-import { useAppStore } from "../../state/appStore";
+import {
+  AppStoreProvider,
+  createProjectAppStore,
+  hydrateProjectAppStore,
+  useAppStore,
+  type AppStoreApi,
+} from "../../state/appStore";
 import { getDirtyFileTextForWindow } from "../../lib/dirtyWorkspaceBuffers";
 import { getAiStatusCached } from "../../lib/aiDiscoveryCache";
 import { dispatchWorkSurfaceRevealed } from "../terminals/workSurfaceVisibility";
-import type { AppNavigationRequest } from "../../../shared/types";
+import type { AppNavigationRequest, ProjectInfo } from "../../../shared/types";
 
 // Use path-based routes on http(s) (Vite in Chrome, Cursor Simple Browser, etc.).
 // Use hash routes for non-http(s) surfaces (e.g. packaged Electron `file://`) where
@@ -156,67 +162,210 @@ function PageErrorBoundary({ children }: { children: React.ReactNode }) {
   );
 }
 
-export function RequireProject({ children }: { children: React.ReactElement }): React.ReactElement {
-  const projectHydrated = useAppStore((s) => s.projectHydrated);
-  const showWelcome = useAppStore((s) => s.showWelcome);
-  const project = useAppStore((s) => s.project);
-  const location = useLocation();
+const LazyFallback = GuardLoadingFallback;
 
-  if (!projectHydrated) {
-    return GuardLoadingFallback;
+function isWorkRoutePath(pathname: string): boolean {
+  return pathname === "/work" || pathname.startsWith("/work/");
+}
+
+const PROJECT_ROUTE_STORAGE_PREFIX = "ade:project-route:";
+const WARM_PROJECT_SURFACE_LIMIT = 8;
+const EMPTY_PROJECT_TAB_ROOTS: string[] = [];
+const EMPTY_PROJECT_INFO_BY_ROOT: Record<string, ProjectInfo> = {};
+
+function projectRouteStorageKey(projectRoot: string): string {
+  return `${PROJECT_ROUTE_STORAGE_PREFIX}${projectRoot}`;
+}
+
+function serializeProjectRoute(location: ReturnType<typeof useLocation>): string | null {
+  const pathname = location.pathname || "/work";
+  const allowedRoots = [
+    "/project",
+    "/lanes",
+    "/files",
+    "/work",
+    "/graph",
+    "/prs",
+    "/review",
+    "/history",
+    "/automations",
+    "/missions",
+    "/cto",
+    "/settings",
+    "/onboarding",
+  ];
+  if (!allowedRoots.some((root) => pathname === root || pathname.startsWith(`${root}/`))) {
+    return null;
   }
+  return `${pathname}${location.search ?? ""}${location.hash ?? ""}`;
+}
 
-  const hasActiveProject = Boolean(project?.rootPath);
-  if (
-    (!hasActiveProject || showWelcome) &&
-    location.pathname !== "/work" &&
-    location.pathname !== "/project" &&
-    location.pathname !== "/onboarding"
-  ) {
-    return <Navigate to="/work" replace />;
+function readStoredProjectRoute(projectRoot: string): string | null {
+  try {
+    const value = window.localStorage.getItem(projectRouteStorageKey(projectRoot));
+    return value?.startsWith("/") ? value : null;
+  } catch {
+    return null;
   }
+}
 
-  return children;
+function writeStoredProjectRoute(projectRoot: string, route: string): void {
+  try {
+    window.localStorage.setItem(projectRouteStorageKey(projectRoot), route);
+  } catch {
+    // localStorage can be unavailable in private/test environments.
+  }
 }
 
-const LazyFallback = GuardLoadingFallback;
+function ProjectRouteContent({ active, route }: { active: boolean; route: string }) {
+  const workSurfaceRef = React.useRef<HTMLDivElement | null>(null);
+  const isWorkRoute = isWorkRoutePath(route.split(/[?#]/, 1)[0] || "/work");
+  const [workRoute, setWorkRoute] = React.useState(() => isWorkRoute ? route : "/work");
+  const [workMounted, setWorkMounted] = React.useState(isWorkRoute);
+  const routeProps = { active } as { active?: boolean };
+  const shouldRenderWork = workMounted || isWorkRoute;
+  const visibleWorkRoute = isWorkRoute ? route : workRoute;
 
-function guarded(element: React.ReactElement): React.ReactElement {
-  return (
-    <RequireProject>
-      <PageErrorBoundary>{element}</PageErrorBoundary>
-    </RequireProject>
-  );
-}
+  React.useEffect(() => {
+    if (!isWorkRoute) return;
+    setWorkRoute(route);
+    setWorkMounted(true);
+  }, [isWorkRoute, route]);
+
+  React.useEffect(() => {
+    const node = workSurfaceRef.current;
+    if (!node) return;
+    if (isWorkRoute) node.removeAttribute("inert");
+    else node.setAttribute("inert", "");
+  }, [isWorkRoute, shouldRenderWork]);
+
+  const workSurface = shouldRenderWork ? (
+    <Routes location={visibleWorkRoute}>
+      <Route path="/work/*" element={
+        <div
+          ref={workSurfaceRef}
+          className="h-full min-h-0 w-full"
+          aria-hidden={!isWorkRoute}
+          style={!isWorkRoute
+            ? {
+              position: "absolute",
+              inset: 0,
+              zIndex: -1,
+              opacity: 0,
+              pointerEvents: "none",
+            }
+            : undefined}
+        >
+          <PageErrorBoundary>
+            <React.Suspense fallback={LazyFallback}>
+              <TerminalsPage active={active && isWorkRoute} />
+            </React.Suspense>
+          </PageErrorBoundary>
+        </div>
+      } />
+    </Routes>
+  ) : null;
 
-function guardedLazy(element: React.ReactElement): React.ReactElement {
   return (
-    <RequireProject>
-      <PageErrorBoundary>
-        <React.Suspense fallback={LazyFallback}>{element}</React.Suspense>
-      </PageErrorBoundary>
-    </RequireProject>
+    <div className="relative h-full min-h-0 w-full">
+      {workSurface}
+      {!isWorkRoute ? (
+        <Routes location={route}>
+          <Route path="/" element={<Navigate to="/work" replace />} />
+          <Route path="/project" element={<PageErrorBoundary><RunPage /></PageErrorBoundary>} />
+          <Route path="/onboarding" element={<PageErrorBoundary><ProjectSetupPage /></PageErrorBoundary>} />
+          <Route path="/glossary" element={<PageErrorBoundary><GlossaryPage /></PageErrorBoundary>} />
+          <Route path="/lanes" element={
+            <PageErrorBoundary>
+              <React.Suspense fallback={LazyFallback}>{React.createElement(LanesPage as React.ComponentType<{ active?: boolean }>, routeProps)}</React.Suspense>
+            </PageErrorBoundary>
+          } />
+          <Route path="/files" element={
+            <PageErrorBoundary>
+              <React.Suspense fallback={LazyFallback}>{React.createElement(FilesPage as React.ComponentType<{ active?: boolean }>, routeProps)}</React.Suspense>
+            </PageErrorBoundary>
+          } />
+          <Route path="/graph" element={
+            <PageErrorBoundary>
+              <React.Suspense fallback={LazyFallback}>{React.createElement(WorkspaceGraphPage as React.ComponentType<{ active?: boolean }>, routeProps)}</React.Suspense>
+            </PageErrorBoundary>
+          } />
+          <Route path="/prs" element={
+            <PageErrorBoundary>
+              <React.Suspense fallback={LazyFallback}>{React.createElement(PRsPage as React.ComponentType<{ active?: boolean }>, routeProps)}</React.Suspense>
+            </PageErrorBoundary>
+          } />
+          <Route path="/review" element={
+            <PageErrorBoundary>
+              <React.Suspense fallback={LazyFallback}>{React.createElement(ReviewPage as React.ComponentType<{ active?: boolean }>, routeProps)}</React.Suspense>
+            </PageErrorBoundary>
+          } />
+          <Route path="/history" element={
+            <PageErrorBoundary>
+              <React.Suspense fallback={LazyFallback}>{React.createElement(HistoryPage as React.ComponentType<{ active?: boolean }>, routeProps)}</React.Suspense>
+            </PageErrorBoundary>
+          } />
+          <Route path="/automations" element={
+            <PageErrorBoundary>
+              <React.Suspense fallback={LazyFallback}>{React.createElement(AutomationsPage as React.ComponentType<{ active?: boolean }>, routeProps)}</React.Suspense>
+            </PageErrorBoundary>
+          } />
+          <Route path="/automations/templates" element={
+            <PageErrorBoundary>
+              <React.Suspense fallback={LazyFallback}>{React.createElement(AutomationsTemplatesPage as React.ComponentType<{ active?: boolean }>, routeProps)}</React.Suspense>
+            </PageErrorBoundary>
+          } />
+          <Route path="/missions" element={
+            <PageErrorBoundary>
+              <React.Suspense fallback={LazyFallback}>{React.createElement(MissionsPage as React.ComponentType<{ active?: boolean }>, routeProps)}</React.Suspense>
+            </PageErrorBoundary>
+          } />
+          <Route path="/cto" element={
+            <PageErrorBoundary>
+              <React.Suspense fallback={LazyFallback}>{React.createElement(CtoPage as React.ComponentType<{ active?: boolean }>, routeProps)}</React.Suspense>
+            </PageErrorBoundary>
+          } />
+          <Route path="/settings" element={
+            <PageErrorBoundary>
+              <React.Suspense fallback={LazyFallback}>{React.createElement(SettingsPage as React.ComponentType<{ active?: boolean }>, routeProps)}</React.Suspense>
+            </PageErrorBoundary>
+          } />
+          <Route path="*" element={<Navigate to="/work" replace />} />
+        </Routes>
+      ) : null}
+    </div>
   );
 }
 
-function isWorkRoutePath(pathname: string): boolean {
-  return pathname === "/work" || pathname.startsWith("/work/");
-}
+function ProjectSurface({
+  active,
+  project,
+  route,
+  store,
+}: {
+  active: boolean;
+  project: ProjectInfo;
+  route: string;
+  store: AppStoreApi;
+}) {
+  const surfaceRef = React.useRef<HTMLDivElement | null>(null);
 
-function PersistentWorkSurface({ active }: { active: boolean }) {
-  const projectHydrated = useAppStore((s) => s.projectHydrated);
-  const showWelcome = useAppStore((s) => s.showWelcome);
-  const project = useAppStore((s) => s.project);
-  const workSurfaceRef = React.useRef<HTMLDivElement | null>(null);
+  React.useEffect(() => {
+    hydrateProjectAppStore(store, {
+      project,
+      projectBinding: {
+        kind: "local",
+        key: `local:${project.rootPath}`,
+        rootPath: project.rootPath,
+        displayName: project.displayName,
+      },
+      projectHydrated: true,
+      showWelcome: false,
+    });
+  }, [project, store]);
 
-  // Only fire the reveal once the surface is *actually* mounted with a
-  // project. On a cold `/work` boot the route renders before `projectHydrated`
-  // / `project.rootPath` settle; firing the reveal here would notify
-  // listeners about a surface that's still showing the loading fallback.
-  const hasActiveProject = Boolean(project?.rootPath);
-  const shouldReveal = active && projectHydrated && hasActiveProject && !showWelcome;
   React.useEffect(() => {
-    if (!shouldReveal) return;
+    if (!active || !isWorkRoutePath(route.split(/[?#]/, 1)[0] || "/work")) return;
     const raf = window.requestAnimationFrame(() => {
       dispatchWorkSurfaceRevealed();
     });
@@ -227,66 +376,208 @@ function PersistentWorkSurface({ active }: { active: boolean }) {
       window.cancelAnimationFrame(raf);
       window.clearTimeout(settleTimer);
     };
-  }, [shouldReveal]);
+  }, [active, route]);
 
   React.useEffect(() => {
-    const node = workSurfaceRef.current;
-    // The `<div ref={workSurfaceRef}>` below is gated by the `projectHydrated`
-    // / `hasActiveProject` / `showWelcome` early returns, so on a cold `/work`
-    // boot the ref is null on the first run when `active` flips true. Re-run
-    // once those guards settle so the inert state lands on the real node.
+    if (!active) return;
+    const state = store.getState();
+    if (state.lanes.length === 0 && !state.lanesLoading) {
+      void state.refreshLanes({ includeStatus: false }).catch(() => {});
+    }
+    if (!state.keybindings) {
+      void state.refreshKeybindings().catch(() => {});
+    }
+    void state.refreshProviderMode().catch(() => {});
+  }, [active, store]);
+
+  React.useEffect(() => {
+    const node = surfaceRef.current;
     if (!node) return;
-    if (active) {
-      node.removeAttribute("inert");
-    } else {
-      node.setAttribute("inert", "");
+    if (active) node.removeAttribute("inert");
+    else node.setAttribute("inert", "");
+  }, [active]);
+
+  return (
+    <AppStoreProvider store={store}>
+      <div
+        ref={surfaceRef}
+        className="h-full min-h-0 w-full"
+        aria-hidden={!active}
+        data-project-root={project.rootPath}
+        style={!active
+          ? {
+            position: "absolute",
+            inset: 0,
+            zIndex: -1,
+            opacity: 0,
+            pointerEvents: "none",
+          }
+          : undefined}
+      >
+        <ProjectRouteContent active={active} route={route} />
+      </div>
+    </AppStoreProvider>
+  );
+}
+
+function ProjectTabHost() {
+  const location = useLocation();
+  const navigate = useNavigate();
+  const activeProject = useAppStore((s) => s.project);
+  const projectHydrated = useAppStore((s) => s.projectHydrated);
+  const showWelcome = useAppStore((s) => s.showWelcome);
+  const openProjectTabRoots = useAppStore((s) => s.openProjectTabRoots ?? EMPTY_PROJECT_TAB_ROOTS);
+  const projectInfoByRoot = useAppStore((s) => s.projectInfoByRoot ?? EMPTY_PROJECT_INFO_BY_ROOT);
+  const rootPrefs = useAppStore(useShallow((s) => ({
+    theme: s.theme,
+    terminalPreferences: s.terminalPreferences,
+    codeBlockCopyButtonPosition: s.codeBlockCopyButtonPosition,
+    agentTurnCompletionSound: s.agentTurnCompletionSound,
+    agentTurnCompletionSoundVolume: s.agentTurnCompletionSoundVolume,
+    agentTurnCompletionSoundQuietWhenFocused: s.agentTurnCompletionSoundQuietWhenFocused,
+    chatFontSizePx: s.chatFontSizePx,
+    chatUserMinimapEnabled: s.chatUserMinimapEnabled,
+    chatTranscriptDensity: s.chatTranscriptDensity,
+    chatChromeTint: s.chatChromeTint,
+    chatShellGeometry: s.chatShellGeometry,
+    smartTooltipsEnabled: s.smartTooltipsEnabled,
+    onboardingEnabled: s.onboardingEnabled,
+    didYouKnowEnabled: s.didYouKnowEnabled,
+  })));
+  const storesRef = React.useRef(new Map<string, AppStoreApi>());
+  const lruRef = React.useRef<string[]>([]);
+  const [routesByRoot, setRoutesByRoot] = React.useState<Record<string, string>>({});
+  const activeRoot = !showWelcome && activeProject?.rootPath ? activeProject.rootPath : null;
+  const previousActiveRootRef = React.useRef<string | null>(null);
+  const pendingNavigationRef = React.useRef<{ root: string; route: string } | null>(null);
+
+  React.useEffect(() => {
+    for (const store of storesRef.current.values()) {
+      hydrateProjectAppStore(store, rootPrefs);
+    }
+  }, [rootPrefs]);
+
+  React.useEffect(() => {
+    if (!activeRoot) return;
+    lruRef.current = [activeRoot, ...lruRef.current.filter((root) => root !== activeRoot)];
+  }, [activeRoot]);
+
+  React.useEffect(() => {
+    const previousRoot = previousActiveRootRef.current;
+    if (previousRoot === activeRoot) return;
+    const currentRoute = serializeProjectRoute(location);
+    if (previousRoot && currentRoute) {
+      writeStoredProjectRoute(previousRoot, currentRoute);
+      setRoutesByRoot((prev) => ({ ...prev, [previousRoot]: currentRoute }));
+    }
+    previousActiveRootRef.current = activeRoot;
+    if (!activeRoot) return;
+    const shouldKeepInitialRoute =
+      currentRoute &&
+      currentRoute !== "/project" &&
+      currentRoute !== "/onboarding";
+    if (!previousRoot && shouldKeepInitialRoute) {
+      writeStoredProjectRoute(activeRoot, currentRoute);
+      setRoutesByRoot((prev) => (prev[activeRoot] === currentRoute ? prev : { ...prev, [activeRoot]: currentRoute }));
+      return;
+    }
+    const nextRoute = routesByRoot[activeRoot] ?? readStoredProjectRoute(activeRoot) ?? "/work";
+    pendingNavigationRef.current = { root: activeRoot, route: nextRoute };
+    if (currentRoute !== nextRoute) {
+      navigate(nextRoute, { replace: true });
+    }
+  }, [activeRoot, location, navigate, routesByRoot]);
+
+  React.useEffect(() => {
+    if (!activeRoot) return;
+    const route = serializeProjectRoute(location);
+    if (!route) return;
+    const pending = pendingNavigationRef.current;
+    if (pending?.root === activeRoot && pending.route !== route) return;
+    if (pending?.root === activeRoot && pending.route === route) {
+      pendingNavigationRef.current = null;
+    }
+    writeStoredProjectRoute(activeRoot, route);
+    setRoutesByRoot((prev) => (prev[activeRoot] === route ? prev : { ...prev, [activeRoot]: route }));
+  }, [activeRoot, location]);
+
+  const projects = React.useMemo(() => {
+    const roots = openProjectTabRoots.length > 0
+      ? openProjectTabRoots
+      : activeProject?.rootPath
+        ? [activeProject.rootPath]
+        : [];
+    return roots
+      .map((root) => projectInfoByRoot[root] ?? (activeProject?.rootPath === root ? activeProject : null))
+      .filter((project): project is ProjectInfo => project != null);
+  }, [activeProject, openProjectTabRoots, projectInfoByRoot]);
+
+  const mountedProjects = React.useMemo(() => {
+    const lru = lruRef.current;
+    const openSet = new Set(projects.map((project) => project.rootPath));
+    const ordered = [...projects].sort((left, right) => {
+      const leftIndex = lru.indexOf(left.rootPath);
+      const rightIndex = lru.indexOf(right.rootPath);
+      return (leftIndex < 0 ? Number.MAX_SAFE_INTEGER : leftIndex)
+        - (rightIndex < 0 ? Number.MAX_SAFE_INTEGER : rightIndex);
+    });
+    const warm = ordered.slice(0, WARM_PROJECT_SURFACE_LIMIT);
+    if (activeProject && openSet.has(activeProject.rootPath) && !warm.some((project) => project.rootPath === activeProject.rootPath)) {
+      warm.pop();
+      warm.unshift(activeProject);
+    }
+    return warm;
+  }, [activeProject, projects]);
+
+  for (const project of mountedProjects) {
+    if (!storesRef.current.has(project.rootPath)) {
+      storesRef.current.set(project.rootPath, createProjectAppStore(project));
     }
-  }, [active, projectHydrated, hasActiveProject, showWelcome]);
+  }
 
-  if (!projectHydrated && !hasActiveProject) {
-    return active ? GuardLoadingFallback : null;
+  React.useEffect(() => {
+    const mountedRoots = new Set(mountedProjects.map((project) => project.rootPath));
+    for (const root of storesRef.current.keys()) {
+      if (!mountedRoots.has(root)) storesRef.current.delete(root);
+    }
+  }, [mountedProjects]);
+
+  if (!projectHydrated && !activeProject) {
+    return GuardLoadingFallback;
   }
 
-  if (!hasActiveProject || showWelcome) {
-    return active ? (
+  if (!activeProject || showWelcome || mountedProjects.length === 0) {
+    return (
       <PageErrorBoundary>
         <RunPage />
       </PageErrorBoundary>
-    ) : null;
+    );
   }
 
   return (
-    <div
-      ref={workSurfaceRef}
-      className="h-full min-h-0 w-full"
-      aria-hidden={!active}
-      style={!active
-        ? {
-          position: "absolute",
-          inset: 0,
-          zIndex: -1,
-          opacity: 0,
-          pointerEvents: "none",
-        }
-        : undefined}
-    >
-      <PageErrorBoundary>
-        <React.Suspense fallback={LazyFallback}>
-          <TerminalsPage active={active} />
-        </React.Suspense>
-      </PageErrorBoundary>
+    <div className="relative h-full min-h-0 w-full">
+      {mountedProjects.map((project) => {
+        const store = storesRef.current.get(project.rootPath);
+        if (!store) return null;
+        const route = routesByRoot[project.rootPath] ?? readStoredProjectRoute(project.rootPath) ?? "/work";
+        return (
+          <ProjectSurface
+            key={project.rootPath}
+            active={project.rootPath === activeRoot}
+            project={project}
+            route={route}
+            store={store}
+          />
+        );
+      })}
     </div>
   );
 }
 
 function ShellLayout() {
-  const location = useLocation();
-  const isWorkRoute = isWorkRoutePath(location.pathname);
-
   return (
     <AppShell>
-      <PersistentWorkSurface active={isWorkRoute} />
-      {isWorkRoute ? null : <Outlet />}
+      <ProjectTabHost />
     </AppShell>
   );
 }
@@ -399,25 +690,7 @@ export function App() {
         {usesBrowserRouter ? <BrowserHashRouteBridge /> : null}
         <Routes>
           <Route path="/startup" element={<Navigate to="/work" replace />} />
-          <Route element={<ShellLayout />}>
-            <Route path="/" element={<Navigate to="/work" replace />} />
-            <Route path="/project" element={guarded(<RunPage />)} />
-            <Route path="/onboarding" element={guarded(<ProjectSetupPage />)} />
-            <Route path="/glossary" element={<PageErrorBoundary><GlossaryPage /></PageErrorBoundary>} />
-            <Route path="/lanes" element={guardedLazy(<LanesPage />)} />
-            <Route path="/files" element={guardedLazy(<FilesPage />)} />
-            <Route path="/work" element={null} />
-            <Route path="/graph" element={guardedLazy(<WorkspaceGraphPage />)} />
-            <Route path="/prs" element={guardedLazy(<PRsPage />)} />
-            <Route path="/review" element={guardedLazy(<ReviewPage />)} />
-            <Route path="/history" element={guardedLazy(<HistoryPage />)} />
-            <Route path="/automations" element={guardedLazy(<AutomationsPage />)} />
-            <Route path="/automations/templates" element={guardedLazy(<AutomationsTemplatesPage />)} />
-            <Route path="/missions" element={guardedLazy(<MissionsPage />)} />
-            <Route path="/cto" element={guardedLazy(<CtoPage />)} />
-            <Route path="/settings" element={guardedLazy(<SettingsPage />)} />
-            <Route path="*" element={<Navigate to="/work" replace />} />
-          </Route>
+          <Route path="*" element={<ShellLayout />} />
         </Routes>
       </div>
     </Router>
diff --git a/apps/desktop/src/renderer/components/app/App.workKeepAlive.test.tsx b/apps/desktop/src/renderer/components/app/App.workKeepAlive.test.tsx
index 755acdfbc..75312a158 100644
--- a/apps/desktop/src/renderer/components/app/App.workKeepAlive.test.tsx
+++ b/apps/desktop/src/renderer/components/app/App.workKeepAlive.test.tsx
@@ -16,11 +16,43 @@ const appStoreState = vi.hoisted(() => ({
   showWelcome: false,
   project: { rootPath: "/fake/project" },
   theme: "dark",
+  openProjectTabRoots: [] as string[],
+  projectInfoByRoot: {} as Record<string, { rootPath: string }>,
 }));
 
-vi.mock("../../state/appStore", () => ({
-  useAppStore: vi.fn((selector: (state: typeof appStoreState) => unknown) => selector(appStoreState)),
-}));
+vi.mock("../../state/appStore", async () => {
+  const ReactModule = await vi.importActual("react") as typeof ReactNamespace;
+  const createScopedState = (project = appStoreState.project) => ({
+    ...appStoreState,
+    project,
+    lanes: [],
+    lanesLoading: false,
+    keybindings: null,
+    refreshLanes: vi.fn(async () => undefined),
+    refreshKeybindings: vi.fn(async () => undefined),
+    refreshProviderMode: vi.fn(async () => undefined),
+  });
+  return {
+    useAppStore: vi.fn((selector: (state: typeof appStoreState) => unknown) => selector(appStoreState)),
+    createProjectAppStore: vi.fn((project) => {
+      let state = createScopedState(project);
+      return {
+        getState: () => state,
+        setState: (partial: unknown) => {
+          state = {
+            ...state,
+            ...(typeof partial === "function" ? (partial as (prev: typeof state) => Partial<typeof state>)(state) : partial as Partial<typeof state>),
+          };
+        },
+        subscribe: vi.fn(() => () => {}),
+      };
+    }),
+    hydrateProjectAppStore: vi.fn((store, partial) => {
+      store.setState(partial);
+    }),
+    AppStoreProvider: ({ children }: { children: React.ReactNode }) => ReactModule.createElement(ReactModule.Fragment, null, children),
+  };
+});
 
 vi.mock("../../lib/debugLog", () => ({
   logRendererDebugEvent: vi.fn(),
@@ -107,6 +139,9 @@ describe("App Work route keep-alive", () => {
     appStoreState.showWelcome = false;
     appStoreState.project = { rootPath: "/fake/project" };
     appStoreState.theme = "dark";
+    appStoreState.openProjectTabRoots = [];
+    appStoreState.projectInfoByRoot = {};
+    window.localStorage.clear();
     (window as Window & { __adeBrowserMock?: boolean }).__adeBrowserMock = true;
     window.history.replaceState({}, "", "/work");
   });
@@ -196,6 +231,19 @@ describe("App Work route keep-alive", () => {
     expect(workLifecycle.mounts).toBe(0);
   });
 
+  it("enters the project surface instead of preserving the project picker route", async () => {
+    window.history.replaceState({}, "", "/project");
+    const { App } = await import("./App");
+
+    render(<App />);
+
+    await screen.findByTestId("work-page");
+    await waitFor(() => {
+      expect(window.location.pathname).toBe("/work");
+    });
+    expect(screen.queryByTestId("project-page")).toBeNull();
+  });
+
   it("does not render the Work surface on non-Work routes when the project is missing", async () => {
     appStoreState.project = { rootPath: "" };
     window.history.replaceState({}, "", "/files");
@@ -203,8 +251,8 @@ describe("App Work route keep-alive", () => {
 
     render(<App />);
 
-    // RequireProject on the /files route navigates to /project; the inactive
-    // PersistentWorkSurface must NOT also navigate (would race) or mount Work.
+    // The project host should route missing projects to the picker; the
+    // inactive Work surface must NOT also navigate (would race) or mount Work.
     await screen.findByTestId("project-page");
     expect(screen.queryByTestId("work-page")).toBeNull();
     expect(workLifecycle.mounts).toBe(0);
diff --git a/apps/desktop/src/renderer/components/app/AppShell.tsx b/apps/desktop/src/renderer/components/app/AppShell.tsx
index d088b1b61..639fc532e 100644
--- a/apps/desktop/src/renderer/components/app/AppShell.tsx
+++ b/apps/desktop/src/renderer/components/app/AppShell.tsx
@@ -92,15 +92,6 @@ function serializeLocationRoute(location: ReturnType<typeof useLocation>): strin
   return route;
 }
 
-function readStoredProjectRoute(projectRoot: string): string | null {
-  try {
-    const value = window.localStorage.getItem(projectRouteStorageKey(projectRoot));
-    return value?.startsWith("/") ? value : null;
-  } catch {
-    return null;
-  }
-}
-
 function writeStoredProjectRoute(projectRoot: string, route: string): void {
   try {
     window.localStorage.setItem(projectRouteStorageKey(projectRoot), route);
@@ -345,7 +336,6 @@ export function AppShell({ children }: { children: React.ReactNode }) {
   );
   const [projectMissing, setProjectMissing] = useState(false);
   const [feedbackGenerating, setFeedbackGenerating] = useState(false);
-  const previousProjectRootRef = useRef<string | null | undefined>(undefined);
   const lastRouteSaveProjectRootRef = useRef<string | null | undefined>(undefined);
   const githubStatusProjectRootRef = useRef<string | null>(null);
   const githubBannerDismissedRef = useRef(false);
@@ -786,25 +776,6 @@ 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 (previousProjectRoot === nextProjectRoot) return;
-    // First attach of a project (null → /path) must not restore localStorage, or we
-    // clobber a deep link / address-bar route (e.g. Vite, Cursor Simple Browser) with
-    // the last tab the user had for that project — often /graph.
-    if (previousProjectRoot == null) return;
-    if (previousProjectRoot) {
-      const previousRoute = serializeLocationRoute(location);
-      if (previousRoute) writeStoredProjectRoute(previousProjectRoot, previousRoute);
-    }
-    navigate(readStoredProjectRoute(nextProjectRoot) ?? "/work", { replace: true });
-  }, [location, navigate, project?.rootPath, showWelcome]);
-
   useEffect(() => {
     const projectRoot = project?.rootPath ?? null;
     if (!projectRoot || showWelcome) return;
diff --git a/apps/desktop/src/renderer/components/app/SettingsPage.tsx b/apps/desktop/src/renderer/components/app/SettingsPage.tsx
index a133ec802..65de47f0c 100644
--- a/apps/desktop/src/renderer/components/app/SettingsPage.tsx
+++ b/apps/desktop/src/renderer/components/app/SettingsPage.tsx
@@ -1,6 +1,6 @@
 import React, { useState, useCallback, useEffect } from "react";
 import { useSearchParams, useLocation } from "react-router-dom";
-import { Brain, GearSix, Stack, Database, FolderSimple, Plus, Plugs, Palette, DeviceMobile } from "@phosphor-icons/react";
+import { Brain, GearSix, Stack, Database, FolderSimple, Plugs, Palette, DeviceMobile } from "@phosphor-icons/react";
 import { GeneralSection } from "../settings/GeneralSection";
 import { AppearanceSection } from "../settings/AppearanceSection";
 import { LaneTemplatesSection } from "../settings/LaneTemplatesSection";
@@ -10,10 +10,7 @@ import { AiSettingsSection } from "../settings/AiSettingsSection";
 import { WorkspaceSettingsSection } from "../settings/WorkspaceSettingsSection";
 import { IntegrationsSettingsSection } from "../settings/IntegrationsSettingsSection";
 import { MobilePushPanel } from "../settings/MobilePushPanel";
-import { COLORS, MONO_FONT, SANS_FONT, LABEL_STYLE, cardStyle, outlineButton, primaryButton, dangerButton } from "../lanes/laneDesignTokens";
-import { ConfirmDialog, PromptDialog, useConfirmDialog, usePromptDialog } from "../shared/InlineDialogs";
-import type { PhaseProfile, PhaseCard } from "../../../shared/types";
-import { PhaseCardEditor } from "../missions/PhaseCardEditor";
+import { COLORS, SANS_FONT, LABEL_STYLE } from "../lanes/laneDesignTokens";
 import { useAppStore } from "../../state/appStore";
 
 const SECTIONS = [
@@ -50,402 +47,9 @@ function padIndex(i: number): string {
   return String(i + 1).padStart(2, "0");
 }
 
-/* ──────────────── Phase Profiles Section ──────────────── */
-
-const SECTION_LABEL: React.CSSProperties = {
-  ...LABEL_STYLE,
-  fontFamily: SANS_FONT,
-  fontSize: 11,
-  marginBottom: 10,
-};
-
-const SETTINGS_INPUT: React.CSSProperties = {
-  height: 28,
-  width: "100%",
-  background: "color-mix(in srgb, var(--color-fg) 4%, transparent)",
-  border: "1px solid color-mix(in srgb, var(--color-border) 65%, transparent)",
-  padding: "0 8px",
-  fontSize: 11,
-  color: COLORS.textPrimary,
-  fontFamily: MONO_FONT,
-  borderRadius: 8,
-  outline: "none",
-};
-
-const FIELD_LABEL: React.CSSProperties = {
-  fontSize: 9,
-  fontWeight: 700,
-  fontFamily: SANS_FONT,
-  textTransform: "uppercase" as const,
-  letterSpacing: "1px",
-  color: COLORS.textMuted,
-};
-
-function PhaseProfileSettingsCard({
-  profile,
-  busy,
-  onAction,
-}: {
-  profile: PhaseProfile;
-  busy: boolean;
-  onAction: (action: "clone" | "export" | "delete" | "save", payload?: { name: string; description: string; phases: PhaseCard[] }) => Promise<void>;
-}) {
-  const [expanded, setExpanded] = useState(false);
-  const [editName, setEditName] = useState(profile.name);
-  const [editDescription, setEditDescription] = useState(profile.description);
-  const [editPhases, setEditPhases] = useState<PhaseCard[]>(profile.phases);
-  const [dirty, setDirty] = useState(false);
-  const [expandedPhaseIds, setExpandedPhaseIds] = useState<Record<string, boolean>>({});
-
-  const isReadOnly = profile.isBuiltIn;
-
-  return (
-    <div style={{ ...cardStyle({ padding: 12 }), marginBottom: 8, background: "color-mix(in srgb, var(--color-fg) 4%, transparent)", backdropFilter: "blur(20px)", WebkitBackdropFilter: "blur(20px)", border: "1px solid color-mix(in srgb, var(--color-border) 55%, transparent)", borderRadius: 16 }}>
-      <div style={{ display: "flex", alignItems: "center", gap: 8 }}>
-        <div style={{ flex: 1, minWidth: 0 }}>
-          <div style={{ fontSize: 12, fontFamily: SANS_FONT, fontWeight: 600, color: COLORS.textPrimary }}>
-            {profile.isBuiltIn && <span style={{ color: COLORS.accent, marginRight: 4 }}>{"\u25CF"}</span>}
-            {profile.name}
-            {profile.isDefault && <span style={{ fontSize: 9, fontWeight: 600, color: "#22C55E", marginLeft: 6, fontFamily: MONO_FONT }}>DEFAULT</span>}
-          </div>
-          <div style={{ fontSize: 10, color: COLORS.textMuted, fontFamily: MONO_FONT, marginTop: 2, overflow: "hidden", textOverflow: "ellipsis", whiteSpace: "nowrap" as const }}>
-            {profile.description || profile.phases.map((p) => p.name).join(" \u2192 ")}
-          </div>
-          <div style={{ fontSize: 9, color: COLORS.textDim, fontFamily: MONO_FONT, marginTop: 2 }}>
-            {profile.phases.length} phase{profile.phases.length !== 1 ? "s" : ""} · {profile.isBuiltIn ? "Built-in (read-only)" : "Custom"}
-          </div>
-        </div>
-        <button
-          style={outlineButton()}
-          disabled={busy}
-          onClick={() => {
-            if (!expanded) {
-              setEditName(profile.name);
-              setEditDescription(profile.description);
-              setEditPhases(profile.phases);
-              setDirty(false);
-              setExpandedPhaseIds({});
-            }
-            setExpanded(!expanded);
-          }}
-        >
-          {expanded ? "HIDE" : isReadOnly ? "VIEW" : "EDIT"}
-        </button>
-        <button style={outlineButton()} disabled={busy} onClick={() => onAction("clone")}>CLONE</button>
-        <button style={outlineButton()} disabled={busy} onClick={() => onAction("export")}>EXPORT</button>
-        {!profile.isBuiltIn && (
-          <button style={dangerButton()} disabled={busy} onClick={() => onAction("delete")}>DELETE</button>
-        )}
-      </div>
-
-      {expanded && (
-        <div style={{ marginTop: 12, paddingTop: 12, borderTop: "1px solid color-mix(in srgb, var(--color-border) 55%, transparent)" }}>
-          {!isReadOnly && (
-            <div style={{ display: "grid", gridTemplateColumns: "1fr 1fr", gap: 8, marginBottom: 8 }}>
-              <label>
-                <div style={FIELD_LABEL}>PROFILE NAME</div>
-                <input value={editName} onChange={(e) => { setEditName(e.target.value); setDirty(true); }} style={{ ...SETTINGS_INPUT, marginTop: 2 }} />
-              </label>
-              <label>
-                <div style={FIELD_LABEL}>DESCRIPTION</div>
-                <input value={editDescription} onChange={(e) => { setEditDescription(e.target.value); setDirty(true); }} placeholder="Describe this profile" style={{ ...SETTINGS_INPUT, marginTop: 2 }} />
-              </label>
-            </div>
-          )}
-
-          <div style={{ marginBottom: 4 }}>
-            <div style={FIELD_LABEL}>PHASES ({editPhases.length})</div>
-          </div>
-
-          {editPhases.map((phase, idx) => (
-            <div key={phase.id} style={{ marginBottom: 4 }}>
-              <PhaseCardEditor
-                phase={phase}
-                index={idx}
-                totalCount={editPhases.length}
-                expanded={expandedPhaseIds[phase.id] === true}
-                readOnly={isReadOnly}
-                onToggleExpand={() => setExpandedPhaseIds((prev) => ({ ...prev, [phase.id]: !prev[phase.id] }))}
-                onUpdate={(updated) => {
-                  setEditPhases((prev) => prev.map((p) => p.id === updated.id ? updated : p));
-                  setDirty(true);
-                }}
-                onMoveUp={() => {
-                  if (idx === 0) return;
-                  setEditPhases((prev) => {
-                    const next = [...prev];
-                    const moved = next[idx]!;
-                    next.splice(idx, 1);
-                    next.splice(idx - 1, 0, moved);
-                    return next.map((p, i) => ({ ...p, position: i }));
-                  });
-                  setDirty(true);
-                }}
-                onMoveDown={() => {
-                  setEditPhases((prev) => {
-                    if (idx >= prev.length - 1) return prev;
-                    const next = [...prev];
-                    const moved = next[idx]!;
-                    next.splice(idx, 1);
-                    next.splice(idx + 1, 0, moved);
-                    return next.map((p, i) => ({ ...p, position: i }));
-                  });
-                  setDirty(true);
-                }}
-                onRemove={phase.isCustom && !isReadOnly ? () => {
-                  setEditPhases((prev) => prev.filter((p) => p.id !== phase.id).map((p, i) => ({ ...p, position: i })));
-                  setDirty(true);
-                } : undefined}
-                labelStyle={FIELD_LABEL}
-                inputStyle={SETTINGS_INPUT}
-              />
-            </div>
-          ))}
-
-          {!isReadOnly && (
-            <button
-              type="button"
-              style={outlineButton({ marginTop: 4 })}
-              onClick={() => {
-                const now = new Date().toISOString();
-                setEditPhases((prev) => [
-                  ...prev,
-                  {
-                    id: `custom:${Date.now()}`,
-                    phaseKey: `custom_${prev.length + 1}`,
-                    name: `Custom Phase ${prev.length + 1}`,
-                    description: "",
-                    instructions: "",
-                    model: { provider: "claude", modelId: "claude-sonnet-4-6", thinkingLevel: "medium" },
-                    budget: {},
-                    orderingConstraints: {},
-                    askQuestions: { enabled: false },
-                    validationGate: { tier: "none", required: false },
-                    isBuiltIn: false,
-                    isCustom: true,
-                    position: prev.length,
-                    createdAt: now,
-                    updatedAt: now,
-                  }
-                ]);
-                setDirty(true);
-              }}
-            >
-              <Plus size={10} weight="bold" /> ADD PHASE
-            </button>
-          )}
-
-          {dirty && !isReadOnly && (
-            <div style={{ display: "flex", alignItems: "center", gap: 8, marginTop: 8 }}>
-              <button
-                style={primaryButton()}
-                disabled={busy || !editName.trim()}
-                onClick={() => onAction("save", { name: editName.trim(), description: editDescription.trim(), phases: editPhases })}
-              >
-                SAVE
-              </button>
-              <button
-                style={outlineButton()}
-                onClick={() => {
-                  setEditName(profile.name);
-                  setEditDescription(profile.description);
-                  setEditPhases(profile.phases);
-                  setDirty(false);
-                }}
-              >
-                REVERT
-              </button>
-            </div>
-          )}
-        </div>
-      )}
-    </div>
-  );
-}
-
-function PhaseProfilesSection() {
-  const [profiles, setProfiles] = useState<PhaseProfile[]>([]);
-  const [loading, setLoading] = useState(true);
-  const [busy, setBusy] = useState(false);
-  const [notice, setNotice] = useState<string | null>(null);
-  const [error, setError] = useState<string | null>(null);
-  const deleteConfirm = useConfirmDialog();
-  const createPrompt = usePromptDialog();
-  const importPrompt = usePromptDialog();
-
-  const refresh = useCallback(async () => {
-    try {
-      const result = await window.ade.missions.listPhaseProfiles({});
-      setProfiles(result);
-      setError(null);
-    } catch (err) {
-      setError(err instanceof Error ? err.message : String(err));
-    } finally {
-      setLoading(false);
-    }
-  }, []);
-
-  useEffect(() => { void refresh(); }, [refresh]);
-
-  const handleAction = useCallback(async (
-    profileId: string,
-    action: "clone" | "export" | "delete" | "save",
-    payload?: { name: string; description: string; phases: PhaseCard[] }
-  ) => {
-    setNotice(null);
-    setError(null);
-    setBusy(true);
-    try {
-      if (action === "clone") {
-        await window.ade.missions.clonePhaseProfile({ profileId });
-        await refresh();
-        setNotice("Profile cloned.");
-      } else if (action === "export") {
-        const exported = await window.ade.missions.exportPhaseProfile({ profileId });
-        setNotice(exported.savedPath ? `Exported: ${exported.savedPath}` : "Profile exported.");
-      } else if (action === "delete") {
-        const profile = profiles.find((p) => p.id === profileId);
-        const ok = await deleteConfirm.confirmAsync({
-          title: "Delete Phase Profile",
-          message: `Delete phase profile "${profile?.name ?? profileId}"?`,
-          confirmLabel: "DELETE",
-          danger: true,
-        });
-        if (!ok) {
-          setBusy(false);
-          return;
-        }
-        await window.ade.missions.deletePhaseProfile({ profileId });
-        await refresh();
-        setNotice("Profile deleted.");
-      } else if (action === "save" && payload) {
-        await window.ade.missions.savePhaseProfile({
-          profile: {
-            id: profileId,
-            name: payload.name,
-            description: payload.description,
-            phases: payload.phases,
-          }
-        });
-        await refresh();
-        setNotice("Profile saved.");
-      }
-    } catch (err) {
-      setError(err instanceof Error ? err.message : String(err));
-    } finally {
-      setBusy(false);
-    }
-  }, [profiles, refresh]);
-
-  if (loading) {
-    return (
-      <div style={{ color: COLORS.textMuted, fontFamily: MONO_FONT, fontSize: 12, padding: 20 }}>
-        Loading phase profiles...
-      </div>
-    );
-  }
-
-  return (
-    <div style={{ maxWidth: 720 }}>
-      <ConfirmDialog state={deleteConfirm.state} onClose={deleteConfirm.close} />
-      <PromptDialog state={createPrompt.state} onClose={createPrompt.close} />
-      <PromptDialog state={importPrompt.state} onClose={importPrompt.close} />
-      <div style={SECTION_LABEL}>PHASE PROFILES</div>
-
-      <div style={{ fontSize: 11, color: COLORS.textMuted, fontFamily: MONO_FONT, marginBottom: 12 }}>
-        Phase profiles define the sequence of work phases for missions. Built-in profiles can be viewed but not edited. Clone or create custom profiles to customize phase descriptions, custom instructions, models, and Planning question behavior.
-      </div>
-
-      <div style={{ display: "flex", gap: 8, marginBottom: 16 }}>
-        <button
-          style={outlineButton()}
-          disabled={busy}
-          onClick={async () => {
-            const name = await createPrompt.promptAsync({
-              title: "Create Phase Profile",
-              message: "Enter a name for the new phase profile.",
-              defaultValue: "Custom Profile",
-              confirmLabel: "CREATE",
-            });
-            if (!name || !name.trim()) return;
-            const fallback = profiles.find((p) => p.isDefault) ?? profiles[0] ?? null;
-            const phases = fallback?.phases ?? [];
-            if (!phases.length) { setError("No base profile found to derive phases from."); return; }
-            setBusy(true);
-            try {
-              await window.ade.missions.savePhaseProfile({
-                profile: { name: name.trim(), description: "Created from Settings", phases }
-              });
-              await refresh();
-              setNotice("Phase profile created.");
-            } catch (err) {
-              setError(err instanceof Error ? err.message : String(err));
-            } finally {
-              setBusy(false);
-            }
-          }}
-        >
-          <Plus size={12} weight="bold" /> CREATE PROFILE
-        </button>
-        <button
-          style={outlineButton()}
-          disabled={busy}
-          onClick={async () => {
-            const filePath = await importPrompt.promptAsync({
-              title: "Import Phase Profile",
-              message: "Enter the path to the phase profile JSON file.",
-              placeholder: "/path/to/profile.json",
-              confirmLabel: "IMPORT",
-            });
-            if (!filePath || !filePath.trim()) return;
-            setBusy(true);
-            try {
-              await window.ade.missions.importPhaseProfile({ filePath: filePath.trim() });
-              await refresh();
-              setNotice("Profile imported.");
-            } catch (err) {
-              setError(err instanceof Error ? err.message : String(err));
-            } finally {
-              setBusy(false);
-            }
-          }}
-        >
-          IMPORT
-        </button>
-      </div>
-
-      {notice && (
-        <div style={{ padding: "6px 10px", marginBottom: 8, fontSize: 11, border: "1px solid color-mix(in srgb, var(--color-success) 30%, transparent)", background: "color-mix(in srgb, var(--color-success) 15%, transparent)", color: COLORS.success, borderRadius: 8 }}>
-          {notice}
-        </div>
-      )}
-      {error && (
-        <div style={{ padding: "6px 10px", marginBottom: 8, fontSize: 11, border: "1px solid color-mix(in srgb, var(--color-error) 30%, transparent)", background: "color-mix(in srgb, var(--color-error) 15%, transparent)", color: COLORS.danger, borderRadius: 8 }}>
-          {error}
-        </div>
-      )}
-
-      {profiles.map((profile) => (
-        <PhaseProfileSettingsCard
-          key={profile.id}
-          profile={profile}
-          busy={busy}
-          onAction={(action, payload) => handleAction(profile.id, action, payload)}
-        />
-      ))}
-
-      {profiles.length === 0 && !loading && (
-        <div style={{ padding: 16, fontSize: 11, color: COLORS.textDim, fontFamily: MONO_FONT, textAlign: "center" as const }}>
-          No phase profiles found. Create one or import from a JSON file.
-        </div>
-      )}
-    </div>
-  );
-}
-
 /* ──────────────── Main Settings Page ──────────────── */
 
-export function SettingsPage() {
+export function SettingsPage({ active = true }: { active?: boolean } = {}) {
   const location = useLocation();
   const [searchParams, setSearchParams] = useSearchParams();
   const projectBinding = useAppStore((s) => s.projectBinding);
@@ -466,20 +70,22 @@ export function SettingsPage() {
 
   // Sync from URL when ?tab= changes
   useEffect(() => {
+    if (!active) return;
     if (validTab && validTab !== section) {
       setSection(validTab);
     }
     if (!memoryAvailable && section === "memory") {
       setSection("general");
     }
-  }, [memoryAvailable, validTab, section]);
+  }, [active, memoryAvailable, validTab, section]);
 
   useEffect(() => {
+    if (!active) return;
     if (!tabParam || !canonicalTab || tabParam === canonicalTab) return;
     const nextParams = new URLSearchParams(searchParams);
     nextParams.set("tab", canonicalTab);
     setSearchParams(nextParams, { replace: true });
-  }, [canonicalTab, searchParams, setSearchParams, tabParam]);
+  }, [active, canonicalTab, searchParams, setSearchParams, tabParam]);
 
   const navigateToSection = useCallback((next: SectionId) => {
     setSection(next);
@@ -489,12 +95,13 @@ export function SettingsPage() {
   }, [searchParams, setSearchParams]);
 
   useEffect(() => {
+    if (!active) return;
     if (section !== "ai" || location.hash !== "#ai-providers") return;
     const id = window.requestAnimationFrame(() => {
       document.getElementById("ai-providers")?.scrollIntoView({ block: "start", behavior: "smooth" });
     });
     return () => window.cancelAnimationFrame(id);
-  }, [section, location.hash]);
+  }, [active, section, location.hash]);
 
   return (
     <div style={{ display: "flex", height: "100%", overflow: "hidden" }}>
diff --git a/apps/desktop/src/renderer/components/app/TabNav.test.tsx b/apps/desktop/src/renderer/components/app/TabNav.test.tsx
index 1b9656f15..6704aebf8 100644
--- a/apps/desktop/src/renderer/components/app/TabNav.test.tsx
+++ b/apps/desktop/src/renderer/components/app/TabNav.test.tsx
@@ -33,16 +33,24 @@ describe("TabNav", () => {
 
   beforeEach(() => {
     resetStore();
-    globalThis.window.ade = {
-      app: {
-        revealPath: async () => undefined,
-        getInfo: async () => ({ isPackaged: false }) as any,
+    Object.defineProperty(globalThis.window, "ade", {
+      configurable: true,
+      writable: true,
+      value: {
+        app: {
+          revealPath: async () => undefined,
+          getInfo: async () => ({ isPackaged: false }) as any,
+        },
       },
-    } as any;
+    });
   });
 
   afterEach(() => {
-    globalThis.window.ade = originalAde;
+    Object.defineProperty(globalThis.window, "ade", {
+      configurable: true,
+      writable: true,
+      value: originalAde,
+    });
   });
 
   it("places Review directly below PRs in the sidebar", () => {
@@ -57,4 +65,3 @@ describe("TabNav", () => {
     expect(prs.nextElementSibling).toBe(review);
   });
 });
-
diff --git a/apps/desktop/src/renderer/components/app/TopBar.test.tsx b/apps/desktop/src/renderer/components/app/TopBar.test.tsx
index 8e72cf7f0..6b72d880f 100644
--- a/apps/desktop/src/renderer/components/app/TopBar.test.tsx
+++ b/apps/desktop/src/renderer/components/app/TopBar.test.tsx
@@ -163,7 +163,8 @@ describe("TopBar", () => {
     resetStore();
     globalThis.window.ade = {
       app: {
-        getWindowSession: vi.fn(async () => ({ windowId: 1, project: useAppStore.getState().project })),
+        getWindowSession: vi.fn(async () => ({ windowId: 1, project: useAppStore.getState().project, openProjectTabs: [] })),
+        setWindowProjectTabs: vi.fn(async () => ({ openProjectTabs: [] })),
         newWindow: vi.fn(async () => ({ windowId: 2 })),
         openProjectInNewWindow: vi.fn(async (rootPath: string) => ({
           windowId: 2,
diff --git a/apps/desktop/src/renderer/components/app/TopBar.tsx b/apps/desktop/src/renderer/components/app/TopBar.tsx
index fff9b6ea4..da9725197 100644
--- a/apps/desktop/src/renderer/components/app/TopBar.tsx
+++ b/apps/desktop/src/renderer/components/app/TopBar.tsx
@@ -646,7 +646,8 @@ export function TopBar() {
     useState<RemoteRuntimeConnectionSnapshot | null>(null);
   const [feedbackOpen, setFeedbackOpen] = useState(false);
   const [publishOpen, setPublishOpen] = useState(false);
-  const [openProjectTabRoots, setOpenProjectTabRoots] = useState<string[]>([]);
+  const openProjectTabRoots = useAppStore((s) => s.openProjectTabRoots);
+  const setOpenProjectTabRoots = useAppStore((s) => s.setOpenProjectTabRoots);
   const [openRemoteProjectTabs, setOpenRemoteProjectTabs] = useState<
     RemoteProjectTab[]
   >([]);
@@ -699,6 +700,10 @@ export function TopBar() {
     openProjectTabRootsRef.current = openProjectTabRoots;
   }, [openProjectTabRoots]);
 
+  useEffect(() => {
+    window.ade.app.setWindowProjectTabs(openProjectTabRoots).catch(() => {});
+  }, [openProjectTabRoots]);
+
   useEffect(() => {
     openRemoteProjectTabsRef.current = openRemoteProjectTabs;
   }, [openRemoteProjectTabs]);
@@ -800,7 +805,14 @@ export function TopBar() {
     window.ade.app
       .getWindowSession()
       .then((session) => {
-        if (!cancelled) setWindowId(session.windowId);
+        if (cancelled) return;
+        setWindowId(session.windowId);
+        if (session.openProjectTabs.length > 0) {
+          for (const tabProject of session.openProjectTabs) {
+            useAppStore.getState().rememberProjectInfo(tabProject);
+          }
+          setOpenProjectTabRoots(session.openProjectTabs.map((entry) => entry.rootPath));
+        }
       })
       .catch(() => {
         if (!cancelled) setWindowId(null);
@@ -808,7 +820,7 @@ export function TopBar() {
     return () => {
       cancelled = true;
     };
-  }, []);
+  }, [setOpenProjectTabRoots]);
 
   useEffect(() => {
     if (!phoneSyncOpen) return;
diff --git a/apps/desktop/src/renderer/components/automations/ActionRow.tsx b/apps/desktop/src/renderer/components/automations/ActionRow.tsx
index 90bb43507..f8e5119b0 100644
--- a/apps/desktop/src/renderer/components/automations/ActionRow.tsx
+++ b/apps/desktop/src/renderer/components/automations/ActionRow.tsx
@@ -44,6 +44,7 @@ export type ActionRowValue = {
   prompt?: string;
   sessionTitle?: string;
   modelConfig?: ModelConfig;
+  codexFastMode?: boolean;
   permissionConfig?: MissionPermissionConfig;
   // Create lane
   laneNameTemplate?: string;
@@ -114,6 +115,14 @@ export function ActionRow({
     if ("continueOnFailure" in patch && !patch.continueOnFailure) delete next.continueOnFailure;
     onChange(next);
   };
+  const setCodexFastMode = (enabled: boolean) => {
+    if (enabled) {
+      onChange({ ...value, codexFastMode: true });
+      return;
+    }
+    const { codexFastMode: _codexFastMode, ...rest } = value;
+    onChange(rest);
+  };
 
   return (
     <div
@@ -233,6 +242,8 @@ export function ActionRow({
                   onChange={(modelConfig) => onChange({ ...value, modelConfig })}
                   compact
                   onOpenAiSettings={onOpenAiSettings}
+                  fastModeActive={value.codexFastMode === true}
+                  onFastModeToggle={setCodexFastMode}
                 />
               </div>
               <label className="block space-y-1.5">
diff --git a/apps/desktop/src/renderer/components/automations/AutomationsPage.tsx b/apps/desktop/src/renderer/components/automations/AutomationsPage.tsx
index 2189e86e9..02d3b4a1d 100644
--- a/apps/desktop/src/renderer/components/automations/AutomationsPage.tsx
+++ b/apps/desktop/src/renderer/components/automations/AutomationsPage.tsx
@@ -3,7 +3,7 @@ import { useLocation, useNavigate } from "react-router-dom";
 import type { AutomationRuleDraft } from "../../../shared/types";
 import { RulesTab } from "./RulesTab";
 
-export function AutomationsPage() {
+export function AutomationsPage({ active = true }: { active?: boolean } = {}) {
   const navigate = useNavigate();
   const location = useLocation();
   const [pendingDraft, setPendingDraft] = useState<AutomationRuleDraft | null>(null);
@@ -14,6 +14,7 @@ export function AutomationsPage() {
   }, []);
 
   useEffect(() => {
+    if (!active) return;
     let cancelled = false;
     window.ade.app.getInfo().then(
       (info) => {
@@ -26,22 +27,24 @@ export function AutomationsPage() {
     return () => {
       cancelled = true;
     };
-  }, []);
+  }, [active]);
 
   // Templates screen navigates here with { draft } in location state to seed a new rule.
   useEffect(() => {
+    if (!active) return;
     const state = location.state as { draft?: AutomationRuleDraft } | null;
     if (state?.draft) {
       setPendingDraft(state.draft);
       // Clear state so refresh doesn't re-seed.
       navigate(location.pathname, { replace: true, state: null });
     }
-  }, [location.pathname, location.state, navigate]);
+  }, [active, location.pathname, location.state, navigate]);
 
   return (
     <div className="flex h-full w-full flex-col overflow-hidden bg-bg text-fg" data-testid="automations-page">
       <div className="flex-1 min-h-0 overflow-hidden">
         <RulesTab
+          active={active}
           pendingDraft={pendingDraft}
           onDraftConsumed={() => setPendingDraft(null)}
           missionsEnabled={missionsEnabled}
diff --git a/apps/desktop/src/renderer/components/automations/AutomationsTemplatesPage.tsx b/apps/desktop/src/renderer/components/automations/AutomationsTemplatesPage.tsx
index 5edefa641..b45d9d9b6 100644
--- a/apps/desktop/src/renderer/components/automations/AutomationsTemplatesPage.tsx
+++ b/apps/desktop/src/renderer/components/automations/AutomationsTemplatesPage.tsx
@@ -5,11 +5,12 @@ import type { AutomationRuleDraft } from "../../../shared/types";
 import { Button } from "../ui/Button";
 import { TemplatesTab } from "./TemplatesTab";
 
-export function AutomationsTemplatesPage() {
+export function AutomationsTemplatesPage({ active = true }: { active?: boolean } = {}) {
   const navigate = useNavigate();
   const [missionsEnabled, setMissionsEnabled] = useState(true);
 
   useEffect(() => {
+    if (!active) return;
     let cancelled = false;
     window.ade.app.getInfo().then(
       (info) => {
@@ -22,7 +23,7 @@ export function AutomationsTemplatesPage() {
     return () => {
       cancelled = true;
     };
-  }, []);
+  }, [active]);
 
   return (
     <div className="flex h-full w-full flex-col overflow-hidden bg-bg text-fg" data-testid="automations-templates-page">
diff --git a/apps/desktop/src/renderer/components/automations/RulesTab.tsx b/apps/desktop/src/renderer/components/automations/RulesTab.tsx
index c885e9f85..5675d5c5e 100644
--- a/apps/desktop/src/renderer/components/automations/RulesTab.tsx
+++ b/apps/desktop/src/renderer/components/automations/RulesTab.tsx
@@ -123,6 +123,7 @@ function toDraftFromRule(rule: AutomationRuleSummary): AutomationRuleDraft {
         type: action.type,
         ...runtimeActionFields(action),
         ...(action.modelConfig ? { modelConfig: structuredClone(action.modelConfig) } : {}),
+        ...(action.codexFastMode === true ? { codexFastMode: true } : {}),
         ...(action.permissionConfig ? { permissionConfig: structuredClone(action.permissionConfig) } : {}),
         ...(action.prompt ? { prompt: action.prompt } : {}),
         ...(action.sessionTitle ? { sessionTitle: action.sessionTitle } : {}),
@@ -309,11 +310,13 @@ function RuleListRow({
 type DetailView = "editor" | "history";
 
 export function RulesTab({
+  active = true,
   pendingDraft,
   onDraftConsumed,
   onOpenTemplates,
   missionsEnabled,
 }: {
+  active?: boolean;
   pendingDraft: AutomationRuleDraft | null;
   onDraftConsumed: () => void;
   onOpenTemplates: () => void;
@@ -392,6 +395,7 @@ export function RulesTab({
   loadRef.current = refresh;
 
   useEffect(() => {
+    if (!active) return;
     void refresh();
     const unsubscribe = window.ade.automations.onEvent(() => {
       void loadRef.current?.();
@@ -403,9 +407,10 @@ export function RulesTab({
         // ignore
       }
     };
-  }, [refresh]);
+  }, [active, refresh]);
 
   useEffect(() => {
+    if (!active) return;
     if (!pendingDraft) return;
     setSelectedRuleId(null);
     setDraft(pendingDraft);
@@ -416,7 +421,7 @@ export function RulesTab({
     setRequiredConfirmations([]);
     setAcceptedConfirmations(new Set());
     onDraftConsumed();
-  }, [onDraftConsumed, pendingDraft]);
+  }, [active, onDraftConsumed, pendingDraft]);
 
   useEffect(() => {
     if (selectedRuleId == null) return;
diff --git a/apps/desktop/src/renderer/components/automations/components/RuleEditorPanel.tsx b/apps/desktop/src/renderer/components/automations/components/RuleEditorPanel.tsx
index d49c90bb2..59ad9b518 100644
--- a/apps/desktop/src/renderer/components/automations/components/RuleEditorPanel.tsx
+++ b/apps/desktop/src/renderer/components/automations/components/RuleEditorPanel.tsx
@@ -387,6 +387,7 @@ function draftToActionRows(draft: AutomationRuleDraft): ActionRowValue[] {
       kind: "agent-session",
       prompt: draft.prompt ?? "",
       sessionTitle: execution.session?.title ?? "",
+      codexFastMode: execution.session?.codexFastMode === true,
     });
   } else if (execution?.kind === "mission") {
     rows.push({
@@ -417,6 +418,7 @@ function draftToActionRows(draft: AutomationRuleDraft): ActionRowValue[] {
           prompt: action.prompt ?? "",
           sessionTitle: action.sessionTitle ?? "",
           modelConfig: action.modelConfig,
+          codexFastMode: action.codexFastMode === true,
           permissionConfig: action.permissionConfig,
           ...actionRuntimeOptions(action),
         });
@@ -437,12 +439,21 @@ function applyActionRowsToDraft(draft: AutomationRuleDraft, rows: ActionRowValue
 
   if (soloAgent) {
     const first = rowsForSave[0]!;
+    const previousSession = draft.execution?.kind === "agent-session"
+      ? draft.execution.session ?? {}
+      : {};
+    const previousSessionWithoutFastMode = { ...previousSession };
+    delete previousSessionWithoutFastMode.codexFastMode;
     return {
       ...draft,
       execution: {
         ...(draft.execution ?? { kind: "agent-session" }),
         kind: "agent-session",
-        session: { ...(draft.execution?.kind === "agent-session" ? draft.execution.session : {}), title: first.sessionTitle || null },
+        session: {
+          ...previousSessionWithoutFastMode,
+          title: first.sessionTitle || null,
+          ...(first.codexFastMode === true ? { codexFastMode: true } : {}),
+        },
       },
       ...(first.modelConfig ? { modelConfig: { orchestratorModel: first.modelConfig } } : {}),
       ...(first.permissionConfig ? { permissionConfig: first.permissionConfig } : {}),
@@ -516,6 +527,7 @@ function rowToAutomationAction(row: ActionRowValue): AutomationAction {
         type: "agent-session",
         ...rowRuntimeOptions(row),
         ...(row.modelConfig ? { modelConfig: row.modelConfig } : {}),
+        ...(row.codexFastMode === true ? { codexFastMode: true } : {}),
         ...(row.permissionConfig ? { permissionConfig: row.permissionConfig } : {}),
         ...(row.prompt ? { prompt: row.prompt } : {}),
         ...(row.sessionTitle ? { sessionTitle: row.sessionTitle } : {}),
@@ -563,6 +575,7 @@ function automationActionToDraftAction(
         type: "agent-session",
         ...rowRuntimeOptions(actionToRow(action)),
         ...(action.modelConfig ? { modelConfig: action.modelConfig } : {}),
+        ...(action.codexFastMode === true ? { codexFastMode: true } : {}),
         ...(action.permissionConfig ? { permissionConfig: action.permissionConfig } : {}),
         ...(action.prompt ? { prompt: action.prompt } : {}),
         ...(action.sessionTitle ? { sessionTitle: action.sessionTitle } : {}),
@@ -633,6 +646,8 @@ export function RuleEditorPanel({
   const currentPermission = permissionMeta
     ? draft.permissionConfig?.providers?.[permissionMeta.key] ?? ""
     : "";
+  const ruleFastModeActive = draft.execution?.kind === "agent-session"
+    && draft.execution.session?.codexFastMode === true;
 
   // laneMode resolution: missing → "reuse" (server-side migration handles
   // legacy create-lane-as-first-action collapse).
@@ -681,6 +696,20 @@ export function RuleEditorPanel({
     const nextDraft = { ...draft, execution: next };
     setDraft(isRequireLaneAtRunTimeMode(next.laneMode) ? stripActionTargetLaneIdsFromDraft(nextDraft) : nextDraft);
   };
+  const setRuleCodexFastMode = (enabled: boolean) => {
+    const current = draft.execution ?? { kind: "agent-session" as const };
+    if (current.kind !== "agent-session") return;
+    setDraft({
+      ...draft,
+      execution: {
+        ...current,
+        session: {
+          ...(current.session ?? {}),
+          codexFastMode: enabled,
+        },
+      },
+    });
+  };
 
   // Smart defaults: when the trigger event changes and the user hasn't yet
   // manually adjusted lane mode/preset, snap to a sensible default. We key on
@@ -974,6 +1003,8 @@ export function RuleEditorPanel({
                       })
                     }
                     onOpenAiSettings={openAiSettings}
+                    fastModeActive={ruleFastModeActive}
+                    onFastModeToggle={draft.execution?.kind === "agent-session" ? setRuleCodexFastMode : undefined}
                   />
                 </div>
                 {permissionMeta ? (
diff --git a/apps/desktop/src/renderer/components/chat/AgentChatComposer.tsx b/apps/desktop/src/renderer/components/chat/AgentChatComposer.tsx
index b484f21e3..249f336dd 100644
--- a/apps/desktop/src/renderer/components/chat/AgentChatComposer.tsx
+++ b/apps/desktop/src/renderer/components/chat/AgentChatComposer.tsx
@@ -651,43 +651,6 @@ function PendingSteerItem({
   );
 }
 
-function CodexFastModeToggle({
-  active,
-  disabled,
-  onToggle,
-}: {
-  active: boolean;
-  disabled?: boolean;
-  onToggle?: (next: boolean) => void;
-}) {
-  return (
-    <SmartTooltip
-      content={{
-        label: "Fast mode",
-        description: active ? "Fast mode is on for the next turn." : "Use Fast mode for supported runtime models.",
-        effect: active ? "Next turn uses the fast service tier." : "Standard mode is selected.",
-      }}
-    >
-      <button
-        type="button"
-        aria-label="Fast mode"
-        aria-pressed={active}
-        disabled={disabled || !onToggle}
-        onClick={() => onToggle?.(!active)}
-        className={cn(
-          "inline-flex h-8 min-h-8 shrink-0 items-center gap-1.5 rounded-md border px-2.5 font-sans text-[length:calc(var(--chat-font-size)*11/14)] font-semibold transition-colors disabled:cursor-not-allowed disabled:opacity-45",
-          active
-            ? "border-amber-300/30 bg-amber-400/12 text-amber-100 shadow-[0_0_0_1px_rgba(251,191,36,0.08)]"
-            : "border-white/[0.07] bg-white/[0.025] text-muted-fg/60 hover:bg-white/[0.06] hover:text-fg/80",
-        )}
-      >
-        <Lightning size={13} weight="fill" />
-        <span>Fast</span>
-      </button>
-    </SmartTooltip>
-  );
-}
-
 function LinearIssueContextDialog({
   open,
   selectedIssue,
@@ -1779,7 +1742,6 @@ export function AgentChatComposer({
     parallelChatMode && parallelConfiguringIndex != null
       ? parallelModelSlots[parallelConfiguringIndex]?.codexFastMode === true
       : codexFastMode === true;
-  const fastModeToggleDisabled = parallelChatMode ? parallelLaunchBusy : modelSelectionLocked;
 
   const claudeSelectionMode = cpmUse === "plan" || im === "plan"
     ? "plan"
@@ -3414,6 +3376,9 @@ export function AgentChatComposer({
                   {...(onOpenAiSettings ? { onOpenSignIn: onOpenAiSettings } : {})}
                   disabled={parallelLaunchBusy}
                   compact
+                  fastModeActive={fastModeActive}
+                  fastModeSupported={fastModeSupported}
+                  onFastModeToggle={(next) => onParallelSlotCodexFastModeChange?.(parallelConfiguringIndex, next)}
                 />
                 <ReasoningEffortPicker
                   modelId={parallelModelSlots[parallelConfiguringIndex]!.modelId}
@@ -3424,13 +3389,6 @@ export function AgentChatComposer({
                 />
               </>
             ) : null}
-            {parallelChatMode && parallelConfiguringIndex != null && fastModeSupported ? (
-              <CodexFastModeToggle
-                active={fastModeActive}
-                disabled={fastModeToggleDisabled}
-                onToggle={(next) => onParallelSlotCodexFastModeChange?.(parallelConfiguringIndex, next)}
-              />
-            ) : null}
             {!parallelChatMode ? (
               <>
                 <ModelPicker
@@ -3441,6 +3399,9 @@ export function AgentChatComposer({
                   {...(onOpenAiSettings ? { onOpenSignIn: onOpenAiSettings } : {})}
                   disabled={modelSelectionLocked}
                   compact
+                  fastModeActive={fastModeActive}
+                  fastModeSupported={fastModeSupported}
+                  onFastModeToggle={onCodexFastModeChange}
                 />
                 <ReasoningEffortPicker
                   modelId={modelId}
@@ -3451,13 +3412,6 @@ export function AgentChatComposer({
                 />
               </>
             ) : null}
-            {!parallelChatMode && fastModeSupported ? (
-              <CodexFastModeToggle
-                active={fastModeActive}
-                disabled={fastModeToggleDisabled}
-                onToggle={onCodexFastModeChange}
-              />
-            ) : null}
           </div>
 
           {!parallelChatMode && sessionProvider === "codex" && codexTokenUsage ? (
diff --git a/apps/desktop/src/renderer/components/chat/AgentChatMessageList.test.tsx b/apps/desktop/src/renderer/components/chat/AgentChatMessageList.test.tsx
index e2297e299..d0a18118a 100644
--- a/apps/desktop/src/renderer/components/chat/AgentChatMessageList.test.tsx
+++ b/apps/desktop/src/renderer/components/chat/AgentChatMessageList.test.tsx
@@ -363,6 +363,29 @@ describe("AgentChatMessageList transcript rendering", () => {
     });
   });
 
+  it("wraps long rendered assistant output instead of clipping it in narrow panes", () => {
+    const longToken = "cto-output-" + "x".repeat(180);
+    const rendered = renderMessageList([
+      {
+        sessionId: "session-1",
+        timestamp: "2026-03-17T10:00:00.000Z",
+        event: {
+          type: "text",
+          text: `Long rendered output ${longToken} with inline \`${longToken}\`.`,
+          itemId: "text-long-output",
+          turnId: "turn-1",
+        },
+      },
+    ]);
+
+    const prose = rendered.container.querySelector(".ade-prose-themed");
+    expect(prose?.className).toContain("break-words");
+    expect(prose?.className).toContain("prose-p:break-words");
+    const inlineCode = rendered.container.querySelector("code");
+    expect(inlineCode?.className).toContain("break-all");
+    expect(inlineCode?.className).toContain("whitespace-normal");
+  });
+
   it("shows and collapses long grouped tool results", async () => {
     const longResult = `${"x".repeat(520)}THE_END`;
     renderMessageList([
@@ -1109,6 +1132,103 @@ describe("AgentChatMessageList transcript rendering", () => {
     expect(updated.offsetTop).toBeGreaterThan(baseline.offsetTop);
   });
 
+  it("does not vertically clip virtualized transcript rows while heights settle", () => {
+    const originalResizeObserver = globalThis.ResizeObserver;
+    class ResizeObserverStub {
+      observe() {}
+      disconnect() {}
+    }
+    Object.defineProperty(globalThis, "ResizeObserver", {
+      configurable: true,
+      value: ResizeObserverStub,
+    });
+
+    try {
+      const rendered = renderMessageList(
+        Array.from({ length: 65 }, (_, index): AgentChatEventEnvelope => ({
+          sessionId: "session-1",
+          timestamp: `2026-03-17T10:${String(index).padStart(2, "0")}:00.000Z`,
+          event: {
+            type: "user_message",
+            text: `message ${index}`,
+            messageId: `user-${index}`,
+            turnId: `turn-${index}`,
+          },
+        })),
+      );
+
+      const contentWrapper = rendered.container.querySelector(".ade-chat-timeline-pane > div");
+      const measuredRow = rendered.container.querySelector('[data-chat-virtualized-row="true"]');
+
+      expect(contentWrapper?.className).toContain("overflow-visible");
+      expect(measuredRow?.className).toContain("overflow-visible");
+      expect(measuredRow?.className).not.toContain("overflow-hidden");
+    } finally {
+      if (originalResizeObserver === undefined) {
+        delete (globalThis as any).ResizeObserver;
+      } else {
+        Object.defineProperty(globalThis, "ResizeObserver", {
+          configurable: true,
+          value: originalResizeObserver,
+        });
+      }
+    }
+  });
+
+  it("measures virtualized transcript rows on mount before resize observer callbacks", async () => {
+    const originalResizeObserver = globalThis.ResizeObserver;
+    const originalOffsetHeight = Object.getOwnPropertyDescriptor(HTMLElement.prototype, "offsetHeight");
+    class ResizeObserverStub {
+      observe() {}
+      disconnect() {}
+    }
+    Object.defineProperty(globalThis, "ResizeObserver", {
+      configurable: true,
+      value: ResizeObserverStub,
+    });
+    Object.defineProperty(HTMLElement.prototype, "offsetHeight", {
+      configurable: true,
+      get() {
+        return this instanceof HTMLElement && this.dataset.chatVirtualizedRow === "true" ? 220 : 0;
+      },
+    });
+
+    try {
+      const rendered = renderMessageList(
+        Array.from({ length: 65 }, (_, index): AgentChatEventEnvelope => ({
+          sessionId: "session-1",
+          timestamp: `2026-03-17T10:${String(index).padStart(2, "0")}:00.000Z`,
+          event: {
+            type: "user_message",
+            text: `message ${index}`,
+            messageId: `user-${index}`,
+            turnId: `turn-${index}`,
+          },
+        })),
+      );
+
+      await waitFor(() => {
+        const virtualSizer = Array.from(rendered.container.querySelectorAll("div"))
+          .find((el) => el.style.position === "relative" && el.style.height);
+        expect(Number.parseFloat(virtualSizer?.style.height ?? "0")).toBeGreaterThan(6_200);
+      });
+    } finally {
+      if (originalOffsetHeight) {
+        Object.defineProperty(HTMLElement.prototype, "offsetHeight", originalOffsetHeight);
+      } else {
+        delete (HTMLElement.prototype as any).offsetHeight;
+      }
+      if (originalResizeObserver === undefined) {
+        delete (globalThis as any).ResizeObserver;
+      } else {
+        Object.defineProperty(globalThis, "ResizeObserver", {
+          configurable: true,
+          value: originalResizeObserver,
+        });
+      }
+    }
+  });
+
   it("keeps the current viewport anchored when rows above it grow", () => {
     const adjusted = reconcileMeasuredScrollTop({
       index: 2,
diff --git a/apps/desktop/src/renderer/components/chat/AgentChatMessageList.tsx b/apps/desktop/src/renderer/components/chat/AgentChatMessageList.tsx
index 13440619d..0615886f8 100644
--- a/apps/desktop/src/renderer/components/chat/AgentChatMessageList.tsx
+++ b/apps/desktop/src/renderer/components/chat/AgentChatMessageList.tsx
@@ -37,6 +37,7 @@ import type {
   AgentChatEvent,
   AgentChatEventEnvelope,
   AgentChatNoticeDetail,
+  AgentChatSubagentTranscriptMessage,
   ChatSurfaceChipTone,
   FilesWorkspace,
   ChatSurfaceProfile,
@@ -856,12 +857,12 @@ const MarkdownBlock = React.memo(function MarkdownBlock({
   return (
     <div
       className={cn(
-        "ade-prose-themed prose prose-invert min-w-0 max-w-full text-[length:calc(var(--chat-font-size)*13/14)] leading-[1.8]",
+        "ade-prose-themed prose prose-invert min-w-0 max-w-full break-words text-[length:calc(var(--chat-font-size)*13/14)] leading-[1.8]",
         neu
           ? "text-white/92 prose-headings:text-white/95 prose-p:text-white/88 prose-li:text-white/86 prose-strong:text-white prose-blockquote:text-white/76"
           : "text-fg/96 prose-headings:text-fg prose-p:text-fg/88 prose-li:text-fg/86 prose-strong:text-fg prose-blockquote:text-fg/76",
         "prose-headings:mb-3 prose-headings:mt-6 prose-headings:font-sans prose-headings:font-semibold prose-headings:tracking-tight",
-        "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-p:my-3 prose-p:break-words prose-ul:my-3 prose-ul:pl-5 prose-ol:my-3 prose-ol:pl-5 prose-li:my-1.5 prose-li:break-words prose-li:pl-1",
         "prose-blockquote:border-l-2 prose-blockquote:border-l-white/20 prose-blockquote:pl-4 prose-hr:my-5 prose-hr:border-white/[0.08]",
       )}
     >
@@ -948,8 +949,8 @@ const MarkdownBlock = React.memo(function MarkdownBlock({
               <code
                 className={
                   neu
-                    ? "rounded-md border border-white/[0.1] bg-black/30 px-1.5 py-0.5 font-mono text-[length:calc(var(--chat-font-size)*11/14)] text-white/90"
-                    : "rounded-md border border-white/[0.08] bg-black/30 px-1.5 py-0.5 font-mono text-[length:calc(var(--chat-font-size)*11/14)] text-fg/90"
+                    ? "break-all whitespace-normal rounded-md border border-white/[0.1] bg-black/30 px-1.5 py-0.5 font-mono text-[length:calc(var(--chat-font-size)*11/14)] text-white/90"
+                    : "break-all whitespace-normal rounded-md border border-white/[0.08] bg-black/30 px-1.5 py-0.5 font-mono text-[length:calc(var(--chat-font-size)*11/14)] text-fg/90"
                 }
               >
                 {children}
@@ -3490,18 +3491,38 @@ const MeasuredEventRow = React.memo(function MeasuredEventRow({
   useLayoutEffect(() => {
     const el = rowRef.current;
     if (!el) return;
+    let raf: number | null = null;
+    const measureNow = (fallbackHeight = 0) => {
+      const height = Math.max(el.offsetHeight, el.getBoundingClientRect().height, fallbackHeight);
+      if (height > 0) onMeasure(index, height);
+    };
+
+    measureNow();
+    raf = requestAnimationFrame(() => measureNow());
+
+    if (typeof ResizeObserver === "undefined") {
+      return () => {
+        if (raf !== null) cancelAnimationFrame(raf);
+      };
+    }
+
     const observer = new ResizeObserver((entries) => {
       const entry = entries[0];
       if (!entry) return;
-      const height = entry.target instanceof HTMLElement ? entry.target.offsetHeight : entry.contentRect.height;
-      if (height > 0) onMeasure(index, height);
+      const measuredHeight = entry.target instanceof HTMLElement
+        ? Math.max(entry.target.offsetHeight, entry.target.getBoundingClientRect().height, entry.contentRect.height)
+        : entry.contentRect.height;
+      measureNow(measuredHeight);
     });
     observer.observe(el);
-    return () => observer.disconnect();
+    return () => {
+      if (raf !== null) cancelAnimationFrame(raf);
+      observer.disconnect();
+    };
   }, [index, onMeasure]);
 
   return (
-    <div ref={rowRef} className="min-w-0 max-w-full overflow-hidden">
+    <div ref={rowRef} data-chat-virtualized-row="true" className="min-w-0 max-w-full overflow-visible">
       <EventRow {...rest} />
     </div>
   );
@@ -3626,7 +3647,125 @@ export function reconcileMeasuredScrollTop({
   return scrollTop;
 }
 
-export function AgentChatMessageList({
+function extractSubagentMessageText(
+  message: import("../../../shared/types").AgentChatSubagentTranscriptMessage,
+): string {
+  if (typeof message.text === "string" && message.text.trim().length > 0) return message.text;
+  const raw = message.message;
+  if (raw && typeof raw === "object") {
+    const content = (raw as { content?: unknown }).content;
+    if (typeof content === "string") return content;
+    if (Array.isArray(content)) {
+      const parts: string[] = [];
+      for (const part of content) {
+        if (part && typeof part === "object") {
+          const text = (part as { text?: unknown }).text;
+          if (typeof text === "string") parts.push(text);
+          const toolName = (part as { name?: unknown }).name;
+          const toolUse = (part as { type?: unknown }).type;
+          if (typeof toolUse === "string" && toolUse === "tool_use" && typeof toolName === "string") {
+            parts.push(`tool: ${toolName}`);
+          }
+        }
+      }
+      if (parts.length) return parts.join("\n");
+    }
+  }
+  return "";
+}
+
+function SubagentTranscriptView({
+  snapshotName,
+  messages,
+  loading,
+  unsupported,
+  className,
+}: {
+  snapshotName: string;
+  messages: import("../../../shared/types").AgentChatSubagentTranscriptMessage[] | null;
+  loading: boolean;
+  unsupported: boolean;
+  className?: string;
+}) {
+  if (unsupported || messages === null) {
+    return (
+      <div className={cn("flex min-h-0 flex-1 flex-col px-8 pt-12 font-sans", className)}>
+        <p className="text-[13.5px] leading-6 text-fg/70">
+          Transcript not available for this provider yet.
+        </p>
+        {snapshotName ? (
+          <p className="mt-2 max-w-md text-[12px] leading-5 text-fg/40">
+            Activity for{" "}
+            <span className="text-fg/60">{snapshotName}</span>{" "}
+            still streams to the side panel — open it from the toolbar to follow along.
+          </p>
+        ) : null}
+      </div>
+    );
+  }
+
+  if (messages.length === 0) {
+    return (
+      <div className={cn("flex min-h-0 flex-1 flex-col px-8 pt-12 font-sans", className)}>
+        <p className="text-[13.5px] leading-6 text-fg/55">
+          {loading ? "Listening for the first message…" : "No messages from this subagent yet."}
+        </p>
+      </div>
+    );
+  }
+
+  return (
+    <div
+      className={cn(
+        "flex min-h-0 flex-1 flex-col overflow-y-auto font-sans",
+        className,
+      )}
+    >
+      <ol className="mx-auto w-full max-w-3xl px-6 pb-10 pt-6">
+        {messages.map((message, index) => {
+          const text = extractSubagentMessageText(message);
+          const role: string = message.type;
+          const isUser = role === "user";
+          const isSystem = role === "system";
+          const roleLabel = isUser ? "you" : isSystem ? "system" : "agent";
+          const accentClass = isUser
+            ? "text-fg/65"
+            : isSystem
+              ? "text-fg/40"
+              : "text-[color:var(--color-accent-bright,#C4B5FD)]";
+
+          return (
+            <li
+              key={message.uuid ?? `${index}-${role}`}
+              className="grid grid-cols-[88px_minmax(0,1fr)] gap-x-5 border-b border-white/[0.03] py-3 last:border-b-0"
+            >
+              <div className="pt-1 text-right">
+                <span
+                  className={cn(
+                    "text-[10.5px] font-medium tracking-[0.04em]",
+                    accentClass,
+                  )}
+                >
+                  {roleLabel}
+                </span>
+              </div>
+              <div
+                className={cn(
+                  "min-w-0 whitespace-pre-wrap break-words text-[13px] leading-[1.6]",
+                  isSystem ? "text-fg/55" : "text-fg/85",
+                )}
+              >
+                {text || <span className="text-fg/35">No content recorded.</span>}
+              </div>
+            </li>
+          );
+        })}
+      </ol>
+    </div>
+  );
+}
+
+function AgentChatMessageListMain({
   events,
   showStreamingIndicator = false,
     className,
@@ -3808,6 +3947,15 @@ export function AgentChatMessageList({
     stickToBottomRef.current = stickToBottom;
   }, [stickToBottom]);
 
+  const measureScrollContainerHeight = useCallback(() => {
+    const el = scrollRef.current;
+    if (!el) return;
+    const nextHeight = el.clientHeight;
+    setContainerHeight((current) => (
+      Math.abs(current - nextHeight) >= 1 ? nextHeight : current
+    ));
+  }, []);
+
   // Unified stick-to-bottom autoscroll:
   // - scrollToBottomSoon coalesces every scroll-to-bottom request into a
   //   single rAF per frame so rapid streaming updates can't produce
@@ -3886,21 +4034,32 @@ export function AgentChatMessageList({
     if (!el) return;
     if (typeof ResizeObserver === "undefined") {
       // Fallback for test environments / old browsers
-      setContainerHeight(el.clientHeight);
+      measureScrollContainerHeight();
       return;
     }
     const ro = new ResizeObserver((entries) => {
-      for (const entry of entries) {
-        setContainerHeight(entry.contentRect.height);
-      }
+      const entry = entries[0];
+      const nextHeight = Math.max(entry?.contentRect.height ?? 0, el.clientHeight);
+      setContainerHeight((current) => (
+        Math.abs(current - nextHeight) >= 1 ? nextHeight : current
+      ));
     });
     ro.observe(el);
-    setContainerHeight(el.clientHeight);
+    measureScrollContainerHeight();
     return () => ro.disconnect();
-  }, []);
+  }, [measureScrollContainerHeight]);
 
   const shouldVirtualize = groupedRows.length >= VIRTUALIZATION_THRESHOLD;
 
+  useLayoutEffect(() => {
+    measureScrollContainerHeight();
+    const raf = requestAnimationFrame(() => {
+      measureScrollContainerHeight();
+      if (stickToBottomRef.current) scrollToBottomSoon(2);
+    });
+    return () => cancelAnimationFrame(raf);
+  }, [groupedRows.length, measureScrollContainerHeight, scrollToBottomSoon, shouldVirtualize]);
+
   /** Returns the best-known height for a given row index. */
   const rowHeight = useCallback((index: number) => {
     return measuredHeights.current.get(index) ?? ESTIMATED_ROW_HEIGHT;
@@ -4200,7 +4359,7 @@ export function AgentChatMessageList({
         className="ade-chat-timeline-pane h-full min-h-0 min-w-0 overflow-x-hidden overflow-y-auto pl-[length:var(--chat-timeline-pad-x)] pr-[length:var(--chat-timeline-pad-x)] pt-[length:var(--chat-timeline-pad-top)] pb-[length:var(--chat-timeline-pad-bottom)]"
         onScroll={handleScroll}
       >
-        <div ref={contentWrapperRef} className="min-w-0 max-w-full overflow-hidden">
+        <div ref={contentWrapperRef} className="min-w-0 max-w-full overflow-visible">
           {rows.length === 0 && !streamingIndicator ? (
             null
           ) : shouldVirtualize ? (
@@ -4244,3 +4403,30 @@ export function AgentChatMessageList({
     </div>
   );
 }
+
+type AgentChatMessageListMainProps = Parameters<typeof AgentChatMessageListMain>[0];
+
+export function AgentChatMessageList(
+  props: AgentChatMessageListMainProps & {
+    subagentTranscript?: {
+      messages: AgentChatSubagentTranscriptMessage[] | null;
+      loading: boolean;
+      unsupported: boolean;
+      snapshotName: string;
+    };
+  },
+) {
+  if (props.subagentTranscript) {
+    return (
+      <SubagentTranscriptView
+        snapshotName={props.subagentTranscript.snapshotName}
+        messages={props.subagentTranscript.messages}
+        loading={props.subagentTranscript.loading}
+        unsupported={props.subagentTranscript.unsupported}
+        className={props.className}
+      />
+    );
+  }
+  const { subagentTranscript: _subagentTranscript, ...mainProps } = props;
+  return <AgentChatMessageListMain {...mainProps} />;
+}
diff --git a/apps/desktop/src/renderer/components/chat/AgentChatPane.tsx b/apps/desktop/src/renderer/components/chat/AgentChatPane.tsx
index 5aaa37a31..894094142 100644
--- a/apps/desktop/src/renderer/components/chat/AgentChatPane.tsx
+++ b/apps/desktop/src/renderer/components/chat/AgentChatPane.tsx
@@ -21,6 +21,7 @@ import {
   type AiProviderConnectionStatus,
   type AiRuntimeConnectionStatus,
   type AgentChatSession,
+  type AgentChatSubagentTranscriptMessage,
   type AgentChatOpenCodePermissionMode,
   type AgentChatPermissionMode,
   type AgentChatParallelLaunchState,
@@ -1623,6 +1624,15 @@ export function AgentChatPane({
   const [iosSimulatorAvailable, setIosSimulatorAvailable] = useState(isLikelyMacRenderer);
   const [cursorCloudPaneOpen, setCursorCloudPaneOpen] = useState(false);
   const [subagentPaneOpen, setSubagentPaneOpen] = useState(false);
+  // Subagent drill-in: when set, the chat surface renders the named subagent's
+  // transcript instead of the parent stream and the composer is disabled.
+  const [subagentView, setSubagentView] = useState<{
+    taskId: string;
+    agentId: string | null;
+    agentType: string | null;
+    status: "running" | "completed" | "failed" | "stopped";
+    background: boolean;
+  } | null>(null);
   const [rewindConfirmDialog, setRewindConfirmDialog] = useState<RewindFilesConfirmDialogState | null>(null);
   const [cursorCloudLaunchModeOpen, setCursorCloudLaunchModeOpen] = useState(false);
   const cursorCloudPanelRef = useRef<ChatCursorCloudPanelHandle | null>(null);
@@ -1992,6 +2002,89 @@ export function AgentChatPane({
   // events for delegation and collabToolCall items (spawn_agent, etc.) just
   // like Claude. Gate on whether we actually have snapshots to display.
   const selectedSubagentPaneAvailable = selectedSubagentSnapshots.length > 0;
+  // Latest snapshot for the currently drilled-in subagent — keeps the
+  // breadcrumb status in sync as the agent transitions running → completed.
+  const subagentViewSnapshot = useMemo(() => {
+    if (!subagentView) return null;
+    return selectedSubagentSnapshots.find((s) => s.taskId === subagentView.taskId) ?? null;
+  }, [subagentView, selectedSubagentSnapshots]);
+  // Indicates at least one background subagent is currently running; used to
+  // surface a small dot on the panel toggle when the panel is collapsed.
+  const hasRunningBackgroundSubagent = useMemo(
+    () => selectedSubagentSnapshots.some((s) => s.background === true && s.status === "running"),
+    [selectedSubagentSnapshots],
+  );
+  // Auto-clear the subagent view when the underlying snapshot disappears
+  // (e.g. session switch). Updating status is fine and stays in view.
+  useEffect(() => {
+    if (subagentView && !subagentViewSnapshot) {
+      setSubagentView(null);
+    }
+  }, [subagentView, subagentViewSnapshot]);
+
+  // Subagent transcript fetched via IPC for the drill-in view. `null` means
+  // the runtime doesn't support transcript retrieval (LM Studio/Droid). `[]`
+  // means we tried but the agent has not produced any messages yet.
+  const [subagentTranscript, setSubagentTranscript] = useState<
+    AgentChatSubagentTranscriptMessage[] | null
+  >(null);
+  const [subagentTranscriptLoading, setSubagentTranscriptLoading] = useState(false);
+  const [subagentTranscriptUnsupported, setSubagentTranscriptUnsupported] = useState(false);
+
+  useEffect(() => {
+    if (!subagentView || !selectedSessionId) {
+      setSubagentTranscript(null);
+      setSubagentTranscriptLoading(false);
+      setSubagentTranscriptUnsupported(false);
+      return;
+    }
+
+    const fetchTranscript = window.ade?.agentChat?.getSubagentTranscript;
+    if (typeof fetchTranscript !== "function") {
+      setSubagentTranscript(null);
+      setSubagentTranscriptUnsupported(true);
+      return;
+    }
+
+    let cancelled = false;
+    const isRunning = subagentViewSnapshot?.status === "running";
+
+    const tick = async () => {
+      try {
+        setSubagentTranscriptLoading(true);
+        const result = await fetchTranscript({
+          sessionId: selectedSessionId,
+          agentId: subagentView.agentId ?? subagentView.taskId,
+          taskId: subagentView.taskId,
+        });
+        if (cancelled) return;
+        if (result === null) {
+          setSubagentTranscriptUnsupported(true);
+          setSubagentTranscript(null);
+        } else {
+          setSubagentTranscriptUnsupported(false);
+          setSubagentTranscript(result);
+        }
+      } catch (error) {
+        // Log so debugging is possible; surface as empty transcript rather than
+        // crashing the drill-in view. Polling tick will retry on the next
+        // interval if the subagent is still running.
+        // eslint-disable-next-line no-console
+        console.error("agentChat.getSubagentTranscript failed", error);
+        if (!cancelled) setSubagentTranscript([]);
+      } finally {
+        if (!cancelled) setSubagentTranscriptLoading(false);
+      }
+    };
+
+    void tick();
+    const intervalId = isRunning ? window.setInterval(() => { void tick(); }, 1500) : null;
+
+    return () => {
+      cancelled = true;
+      if (intervalId !== null) window.clearInterval(intervalId);
+    };
+  }, [subagentView, subagentViewSnapshot?.status, selectedSessionId]);
   const selectedTurnDiffSummaries = useMemo(() => deriveTurnDiffSummaries(selectedEvents), [selectedEvents]);
   const selectedTodoItems = useMemo(() => deriveTodoItems(selectedEvents), [selectedEvents]);
   const pendingInput = selectedSessionId ? (pendingInputsBySession[selectedSessionId]?.[0] ?? null) : null;
@@ -5659,6 +5752,16 @@ export function AgentChatPane({
       onInterruptTurn={turnActive ? () => { void interrupt(); } : undefined}
       variant="pane"
       onClose={() => setSubagentPaneOpen(false)}
+      onSelectSubagent={(selection) => {
+        setSubagentView({
+          taskId: selection.taskId,
+          agentId: selection.agentId,
+          agentType: selection.agentType,
+          status: selection.status,
+          background: selection.background,
+        });
+      }}
+      selectedTaskId={subagentView?.taskId ?? null}
     />
   ) : null;
   const cursorCloudPanelContent = (
@@ -5925,6 +6028,16 @@ export function AgentChatPane({
                 <span className="absolute -right-1 -top-1 inline-flex h-[13px] min-w-[13px] items-center justify-center rounded-full border border-black/30 bg-amber-400/85 px-0.5 font-mono text-[8px] font-bold text-black">
                   {selectedSubagentSnapshots.length}
                 </span>
+                {!subagentPaneOpen && hasRunningBackgroundSubagent ? (
+                  <span
+                    aria-hidden
+                    className={cn(
+                      "absolute -bottom-0.5 -right-0.5 h-[7px] w-[7px] rounded-full",
+                      "bg-[color:var(--color-accent,#A78BFA)] ring-2 ring-[color:var(--color-bg,#0c0b10)]",
+                      "motion-safe:ade-glow-pulse",
+                    )}
+                  />
+                ) : null}
               </button>
             </SmartTooltip>
           ) : null}
@@ -6667,6 +6780,42 @@ export function AgentChatPane({
       />
   );
 
+  // Composer placeholder shown when the chat is drilled in to a subagent
+  // transcript. Replies always go to the parent session, so disabling input
+  // here matches user expectations and the wireframe brief.
+  const subagentComposerLock = subagentView ? (
+    <div
+      data-chat-appearance-root
+      style={chatAppearanceRootStyle}
+      className={cn(
+        compactShell ? "min-w-0 w-full" : undefined,
+        "flex items-center gap-3 px-4 py-3 font-sans text-[12px]",
+        "border-t border-white/[0.05] bg-white/[0.012]",
+      )}
+    >
+      <span
+        aria-hidden
+        className="inline-flex h-5 w-5 items-center justify-center rounded-full text-fg/30"
+      >
+        <span className="block h-px w-2.5 bg-fg/30" />
+      </span>
+      <span className="min-w-0 flex-1 text-fg/55">
+        Composer paused — viewing a subagent transcript.
+      </span>
+      <button
+        type="button"
+        onClick={() => setSubagentView(null)}
+        className={cn(
+          "shrink-0 rounded-full px-2.5 py-1 text-[11px] font-medium",
+          "text-[color:var(--color-accent-bright,#C4B5FD)]",
+          "transition-colors hover:bg-[color:var(--color-accent,#A78BFA)]/10",
+        )}
+      >
+        Return to main chat
+      </button>
+    </div>
+  ) : null;
+
   const composerWithTypographyRoot = (
     <div
       data-chat-appearance-root
@@ -6749,7 +6898,9 @@ export function AgentChatPane({
         shellGeometry={chatShellGeometry}
         className={compactShell ? cn("border-0 shadow-none rounded-none bg-transparent") : undefined}
         header={compactShell ? undefined : shellHeader}
-        footer={isEmptyState || appPanelOpen ? undefined : composerWithTypographyRoot}
+        footer={isEmptyState || appPanelOpen
+          ? undefined
+          : subagentComposerLock ?? composerWithTypographyRoot}
         footerClassName={compactShell ? "px-0 pb-0 pt-0" : undefined}
         bodyClassName="flex min-h-0 flex-col overflow-hidden"
       >
@@ -6851,10 +7002,69 @@ export function AgentChatPane({
                         }}
                       />
                     ) : null}
+                    {subagentView ? (
+                      <button
+                        type="button"
+                        onClick={() => setSubagentView(null)}
+                        title="Return to main chat"
+                        className={cn(
+                          "group flex shrink-0 items-center gap-2.5 px-5 py-2 text-left font-sans text-[11.5px]",
+                          "border-b border-white/[0.05] bg-white/[0.012]",
+                          "transition-colors hover:bg-white/[0.025]",
+                        )}
+                      >
+                        <span
+                          aria-hidden
+                          className="inline-flex h-4 w-4 items-center justify-center rounded-full text-fg/35 transition-colors group-hover:bg-white/[0.05] group-hover:text-fg/70"
+                        >
+                          {"←"}
+                        </span>
+                        <span className="text-fg/45 group-hover:text-fg/65">Main</span>
+                        <span aria-hidden className="text-fg/20">{"•"}</span>
+                        <span className="truncate font-medium tracking-[0.005em] text-fg/85">
+                          {subagentView.agentType
+                            ?? subagentViewSnapshot?.description
+                            ?? subagentView.agentId
+                            ?? subagentView.taskId}
+                        </span>
+                        {subagentView.background ? (
+                          <span className="text-[10.5px] tracking-[0.01em] text-fg/30">bg</span>
+                        ) : null}
+                        <span aria-hidden className="text-fg/20">{"•"}</span>
+                        <span
+                          className={cn(
+                            "text-[10.5px] tracking-[0.005em]",
+                            (subagentViewSnapshot?.status ?? subagentView.status) === "running"
+                              && "text-[color:var(--color-accent-bright,#C4B5FD)]",
+                            (subagentViewSnapshot?.status ?? subagentView.status) === "completed"
+                              && "text-emerald-300/75",
+                            (subagentViewSnapshot?.status ?? subagentView.status) === "failed"
+                              && "text-rose-300/80",
+                            (subagentViewSnapshot?.status ?? subagentView.status) === "stopped"
+                              && "text-amber-200/75",
+                          )}
+                        >
+                          {subagentViewSnapshot?.status ?? subagentView.status}
+                        </span>
+                        <span className="ml-auto hidden text-[10px] text-fg/25 group-hover:inline">
+                          press to return
+                        </span>
+                      </button>
+                    ) : null}
                     <AgentChatMessageList
-                      key={selectedSessionId ?? "chat-draft"}
+                      key={subagentView ? `subagent-${subagentView.taskId}` : selectedSessionId ?? "chat-draft"}
                       events={selectedEventsForDisplay}
-                      showStreamingIndicator={turnActive && selectedSession?.status !== "ended"}
+                      subagentTranscript={subagentView ? {
+                        messages: subagentTranscript,
+                        loading: subagentTranscriptLoading,
+                        unsupported: subagentTranscriptUnsupported,
+                        snapshotName:
+                          subagentView.agentType
+                          ?? subagentViewSnapshot?.description
+                          ?? subagentView.agentId
+                          ?? subagentView.taskId,
+                      } : undefined}
+                      showStreamingIndicator={!subagentView && turnActive && selectedSession?.status !== "ended"}
                       sessionEnded={selectedSession?.status === "ended"}
                       className="min-h-0 border-0"
                       surfaceMode={surfaceMode}
diff --git a/apps/desktop/src/renderer/components/chat/ChatSubagentsPanel.test.tsx b/apps/desktop/src/renderer/components/chat/ChatSubagentsPanel.test.tsx
index 7c5f1623e..4dfe7c31d 100644
--- a/apps/desktop/src/renderer/components/chat/ChatSubagentsPanel.test.tsx
+++ b/apps/desktop/src/renderer/components/chat/ChatSubagentsPanel.test.tsx
@@ -5,7 +5,7 @@ import type * as React from "react";
 import { afterEach, describe, expect, it, vi } from "vitest";
 import type { AgentChatEventEnvelope } from "../../../shared/types";
 import type { ChatSubagentSnapshot } from "./chatExecutionSummary";
-import { ChatSubagentsPanel } from "./ChatSubagentsPanel";
+import { ChatSubagentsPanel, type SubagentSelection } from "./ChatSubagentsPanel";
 
 vi.mock("motion/react", () => ({
   AnimatePresence: ({ children }: { children: React.ReactNode }) => <>{children}</>,
@@ -14,9 +14,10 @@ vi.mock("motion/react", () => ({
   },
 }));
 
-const snapshot: ChatSubagentSnapshot = {
+const baseSnapshot: ChatSubagentSnapshot = {
   taskId: "task-1",
   description: "Audit chat renderer",
+  agentType: "code-reviewer",
   status: "running",
   startedAt: "2026-05-12T00:00:00.000Z",
   updatedAt: "2026-05-12T00:00:10.000Z",
@@ -26,107 +27,117 @@ const snapshot: ChatSubagentSnapshot = {
   usage: { durationMs: 10_000, toolUses: 2, totalTokens: 1234 },
 };
 
-function buildTimelineEvents(count = 0): AgentChatEventEnvelope[] {
-  const events: AgentChatEventEnvelope[] = [{
+function buildPlanEvent(): AgentChatEventEnvelope {
+  return {
     sessionId: "session-1",
     timestamp: "2026-05-12T00:00:00.000Z",
     event: {
-      type: "subagent_started",
-      taskId: "task-1",
-      description: "Audit chat renderer",
-      background: true,
+      type: "plan",
+      steps: [
+        { text: "Map theme plumbing", status: "completed" },
+        { text: "Identify glass styling", status: "completed" },
+        { text: "Implement appearance mode", status: "in_progress" },
+        { text: "Apply glass styling app-wide", status: "pending" },
+        { text: "Run focused checks", status: "pending" },
+      ],
     },
-  }];
-
-  for (let index = 0; index < count; index += 1) {
-    events.push({
-      sessionId: "session-1",
-      timestamp: `2026-05-12T00:00:${String(index + 1).padStart(2, "0")}.000Z`,
-      event: {
-        type: "subagent_progress",
-        taskId: "task-1",
-        summary: `Progress ${index}`,
-        lastToolName: "rg",
-      },
-    });
-  }
-
-  return events;
+  } as AgentChatEventEnvelope;
 }
 
-describe("ChatSubagentsPanel", () => {
+describe("ChatSubagentsPanel (pane variant)", () => {
   afterEach(() => {
     cleanup();
     vi.restoreAllMocks();
   });
 
-  it("toggles the drawer, opens detail, and returns to the list", () => {
+  it("renders the Progress section with bar, counter, and checklist", () => {
     render(
       <ChatSubagentsPanel
-        snapshots={[snapshot]}
-        events={buildTimelineEvents(2)}
+        snapshots={[]}
+        events={[buildPlanEvent()]}
+        variant="pane"
       />,
     );
 
-    const trigger = screen.getByRole("button", { name: /Subagents/i });
-    expect(trigger.getAttribute("aria-expanded")).toBe("false");
+    expect(screen.getByText("Progress")).toBeTruthy();
+    expect(screen.getByText("2/5 · 40%")).toBeTruthy();
+    expect(screen.getByText("Map theme plumbing")).toBeTruthy();
+    expect(screen.getByText("Implement appearance mode")).toBeTruthy();
+    expect(screen.getByText("Run focused checks")).toBeTruthy();
+  });
 
-    fireEvent.click(trigger);
-    expect(trigger.getAttribute("aria-expanded")).toBe("true");
-    // With only background snapshots, the single non-empty tab auto-resolves
-    // to "background" — the tab strip collapses into a section header so the
-    // background list renders directly without clicking a tab.
-    expect(screen.getByTitle("Audit chat renderer")).toBeTruthy();
+  it("splits foreground subagents and background tasks into separate sections", () => {
+    const foregroundSnapshot: ChatSubagentSnapshot = {
+      ...baseSnapshot,
+      taskId: "task-2",
+      description: "Inspect codex flow",
+      agentType: "Explore",
+      background: false,
+    };
 
-    fireEvent.click(screen.getByTitle("Audit chat renderer"));
-    expect(screen.getByText("task-1")).toBeTruthy();
+    render(
+      <ChatSubagentsPanel
+        snapshots={[baseSnapshot, foregroundSnapshot]}
+        events={[]}
+        variant="pane"
+      />,
+    );
 
-    fireEvent.click(screen.getByRole("button", { name: /Back/i }));
-    expect(screen.getByTitle("Audit chat renderer")).toBeTruthy();
+    expect(screen.getByText("Subagents")).toBeTruthy();
+    expect(screen.getByText("Background tasks")).toBeTruthy();
+    expect(screen.getByText("Explore")).toBeTruthy();
+    // Background row gets a "bg" suffix (no parentheses in the redesign).
+    expect(screen.getByText("bg")).toBeTruthy();
   });
 
-  it("shows hidden timeline events and copies the subagent id", () => {
-    const writeText = vi.fn().mockResolvedValue(undefined);
-    Object.defineProperty(navigator, "clipboard", {
-      configurable: true,
-      value: { writeText },
-    });
+  it("calls onSelectSubagent with the snapshot identity when a row is clicked", () => {
+    const onSelectSubagent = vi.fn<[SubagentSelection], void>();
 
     render(
       <ChatSubagentsPanel
-        snapshots={[snapshot]}
-        events={buildTimelineEvents(25)}
+        snapshots={[baseSnapshot]}
+        events={[]}
+        variant="pane"
+        onSelectSubagent={onSelectSubagent}
       />,
     );
 
-    fireEvent.click(screen.getByRole("button", { name: /Subagents/i }));
     fireEvent.click(screen.getByTitle("Audit chat renderer"));
+    expect(onSelectSubagent).toHaveBeenCalledTimes(1);
+    const arg = onSelectSubagent.mock.calls[0]![0];
+    expect(arg.taskId).toBe("task-1");
+    expect(arg.agentType).toBe("code-reviewer");
+    expect(arg.status).toBe("running");
+    expect(arg.background).toBe(true);
+  });
 
-    expect(screen.queryByText("Progress 0")).toBeNull();
-    fireEvent.click(screen.getByRole("button", { name: /Show .* earlier events/i }));
-    expect(screen.getByText("Progress 0")).toBeTruthy();
+  it("renders the single-agent empty state when no plan and no subagents are present", () => {
+    render(
+      <ChatSubagentsPanel snapshots={[]} events={[]} variant="pane" />,
+    );
 
-    fireEvent.click(screen.getByRole("button", { name: /Copy id/i }));
-    expect(writeText).toHaveBeenCalledWith("task-1");
+    // The redesign splits the empty state onto two lines.
+    expect(
+      screen.getByText(/No agent activity for this chat\./i),
+    ).toBeTruthy();
+    expect(
+      screen.getByText(/Single-agent mode\./i),
+    ).toBeTruthy();
   });
 
-  it("renders the tab strip when more than one category is non-empty", () => {
-    const foregroundSnapshot: ChatSubagentSnapshot = {
-      ...snapshot,
-      taskId: "task-2",
-      description: "Inspect codex flow",
-      background: false,
-    };
+  it("surfaces an interrupt action when at least one subagent is running", () => {
+    const onInterruptTurn = vi.fn();
     render(
       <ChatSubagentsPanel
-        snapshots={[snapshot, foregroundSnapshot]}
-        events={buildTimelineEvents(0)}
+        snapshots={[baseSnapshot]}
+        events={[]}
+        variant="pane"
+        onInterruptTurn={onInterruptTurn}
       />,
     );
 
-    fireEvent.click(screen.getByRole("button", { name: /Subagents/i }));
-    // With both background and non-background snapshots present, both tabs
-    // should be clickable.
-    expect(screen.getAllByRole("button", { name: /Background/i }).length).toBeGreaterThan(0);
+    const stop = screen.getByRole("button", { name: /Stop running agents/i });
+    fireEvent.click(stop);
+    expect(onInterruptTurn).toHaveBeenCalledTimes(1);
   });
 });
diff --git a/apps/desktop/src/renderer/components/chat/ChatSubagentsPanel.tsx b/apps/desktop/src/renderer/components/chat/ChatSubagentsPanel.tsx
index e2a540d6f..cccd06fea 100644
--- a/apps/desktop/src/renderer/components/chat/ChatSubagentsPanel.tsx
+++ b/apps/desktop/src/renderer/components/chat/ChatSubagentsPanel.tsx
@@ -1,17 +1,17 @@
-import { useCallback, useMemo, useState } from "react";
+import { useMemo, useState } from "react";
 import {
-  ArrowLeft,
-  CheckCircle,
-  ClockCounterClockwise,
-  Copy,
-  X,
-  XCircle,
+  Check,
+  Circle,
+  CircleHalf,
+  CircleNotch,
+  StopCircle,
   TreeStructure,
+  X,
 } from "@phosphor-icons/react";
 import { cn } from "../ui/cn";
-import { ChatStatusGlyph } from "./chatStatusVisuals";
-import type { ChatSubagentSnapshot, SubagentTimelineEntry } from "./chatExecutionSummary";
-import { deriveSubagentTimeline } from "./chatExecutionSummary";
+import type { ChatSubagentSnapshot } from "./chatExecutionSummary";
+import { derivePlan } from "./chatExecutionSummary";
+import type { ChatInfoPlanStep } from "../../../shared/chatSubagents";
 import type { AgentChatEventEnvelope } from "../../../shared/types";
 import { BottomDrawerSection } from "./BottomDrawerSection";
 
@@ -30,249 +30,196 @@ function formatDurationMs(value: number | null | undefined): string | null {
   return `${Math.max(1, Math.round(value / 1000))}s`;
 }
 
-function summarizeRuntime(snapshot: ChatSubagentSnapshot): string | null {
+function runtimeText(snapshot: ChatSubagentSnapshot): string | null {
   const elapsedMs = snapshot.usage?.durationMs
     ?? Math.max(0, Date.parse(snapshot.updatedAt) - Date.parse(snapshot.startedAt));
-  const tokenText = formatTokenCount(snapshot.usage?.totalTokens);
   const durationText = formatDurationMs(elapsedMs);
-  const parts = [
-    tokenText ? `${tokenText} tok` : null,
-    durationText,
-    snapshot.usage?.toolUses ? `${snapshot.usage.toolUses} tool${snapshot.usage.toolUses === 1 ? "" : "s"}` : null,
-  ].filter((part): part is string => Boolean(part));
-  return parts.length ? parts.join(" \u00b7 ") : null;
+  const tokenText = formatTokenCount(snapshot.usage?.totalTokens);
+  const parts = [snapshot.lastToolName, durationText, tokenText ? `${tokenText} tok` : null]
+    .filter((part): part is string => Boolean(part));
+  return parts.length ? parts.join(" · ") : null;
 }
 
-function formatTime(iso: string): string {
-  try {
-    return new Date(iso).toLocaleTimeString([], { hour: "2-digit", minute: "2-digit", second: "2-digit" });
-  } catch {
-    return "";
+/* ── Glyphs (12 px monoline, single visual family) ──
+ *
+ * One stroke weight, one diameter, one baseline. Color shifts only on
+ * completion; everything else stays in the fg ramp so the panel reads as a
+ * single calm surface.
+ */
+
+const GLYPH_SIZE = 12;
+
+function StatusGlyph({ status }: { status: ChatSubagentSnapshot["status"] }) {
+  if (status === "running") {
+    return (
+      <CircleNotch
+        aria-hidden
+        size={GLYPH_SIZE}
+        weight="bold"
+        className="text-[color:var(--color-accent,#A78BFA)] motion-safe:animate-spin [animation-duration:2.4s]"
+      />
+    );
+  }
+  if (status === "completed") {
+    return <Check aria-hidden size={GLYPH_SIZE} weight="bold" className="text-emerald-300/85" />;
   }
+  if (status === "failed") {
+    return <X aria-hidden size={GLYPH_SIZE} weight="bold" className="text-rose-300/80" />;
+  }
+  return <Circle aria-hidden size={GLYPH_SIZE} weight="regular" className="text-fg/30" />;
 }
 
-/* ── Status helpers ── */
+function PlanGlyph({ status }: { status: ChatInfoPlanStep["status"] }) {
+  if (status === "completed") {
+    return <Check aria-hidden size={GLYPH_SIZE} weight="bold" className="text-emerald-300/85" />;
+  }
+  if (status === "in_progress") {
+    return (
+      <CircleHalf
+        aria-hidden
+        size={GLYPH_SIZE}
+        weight="fill"
+        className="text-[color:var(--color-accent,#A78BFA)] motion-safe:ade-glow-pulse"
+      />
+    );
+  }
+  if (status === "failed") {
+    return <X aria-hidden size={GLYPH_SIZE} weight="bold" className="text-rose-300/80" />;
+  }
+  return <Circle aria-hidden size={GLYPH_SIZE} weight="regular" className="text-fg/25" />;
+}
 
-function statusMeta(status: ChatSubagentSnapshot["status"]): {
+/* ── Section header — sentence case, paper-section feel ── */
+
+function SectionHeader({
+  label,
+  hint,
+}: {
   label: string;
-  chipClassName: string;
-  icon: JSX.Element;
-} {
-  switch (status) {
-    case "completed":
-      return {
-        label: "Done",
-        chipClassName: "border-emerald-400/15 text-emerald-300/90",
-        icon: <CheckCircle size={12} weight="fill" className="text-emerald-400" />,
-      };
-    case "failed":
-      return {
-        label: "Failed",
-        chipClassName: "border-red-500/20 text-red-300/90",
-        icon: <XCircle size={12} weight="fill" className="text-red-400" />,
-      };
-    case "stopped":
-      return {
-        label: "Stopped",
-        chipClassName: "border-amber-400/20 text-amber-300/90",
-        icon: <ClockCounterClockwise size={12} weight="bold" className="text-amber-400" />,
-      };
-    default:
-      return {
-        label: "Running",
-        chipClassName: "border-emerald-400/20 text-emerald-300",
-        icon: <ChatStatusGlyph status="working" size={12} className="ade-glow-pulse" />,
-      };
-  }
+  hint?: string;
+}) {
+  return (
+    <div className="flex items-baseline justify-between px-4 pb-2 pt-3.5">
+      <span className="font-sans text-[11.5px] font-medium tracking-[0.005em] text-fg/55">
+        {label}
+      </span>
+      {hint ? (
+        <span className="font-sans text-[11px] tabular-nums text-fg/35">
+          {hint}
+        </span>
+      ) : null}
+    </div>
+  );
 }
 
-/* ── Timeline detail view ── */
+/* ── Progress bar — 1 px hairline rule ── */
 
-const MAX_VISIBLE_TIMELINE = 20;
+function ProgressBar({ percent }: { percent: number }) {
+  const clamped = Math.max(0, Math.min(100, percent));
+  return (
+    <div className="mx-4 mb-1 h-px rounded-full bg-white/[0.05]">
+      <div
+        className="h-px rounded-full bg-[color:var(--color-accent,#A78BFA)]/55 transition-[width] duration-500 ease-out"
+        style={{ width: `${clamped}%` }}
+      />
+    </div>
+  );
+}
 
-function SubagentDetailView({
+/* ── Row ──
+ *
+ * One line per row. Glyph sits in a fixed 12 px column at x=16 so every
+ * section shares the same left rail. Hover wash is 2.5 %; selected rows get a
+ * 1 px accent rail in the left padding gutter (no chip, no card chrome).
+ */
+
+// Some runtimes stamp a placeholder agentType on the wire (e.g. legacy OpenCode
+// envelopes emitted before the description-first fix). Treat those as absent
+// so the more meaningful description takes the row label.
+const GENERIC_AGENT_TYPES = new Set(["opencode-subagent", "subagent"]);
+
+function meaningfulName(snapshot: ChatSubagentSnapshot): string {
+  const type = snapshot.agentType?.trim() ?? "";
+  if (type.length && !GENERIC_AGENT_TYPES.has(type.toLowerCase())) return type;
+  const description = snapshot.description?.trim();
+  if (description) return description;
+  return snapshot.agentId ?? snapshot.taskId;
+}
+
+function SubagentRow({
   snapshot,
-  timeline,
-  onBack,
-  onInterruptTurn,
+  selected,
+  onClick,
 }: {
   snapshot: ChatSubagentSnapshot;
-  timeline: SubagentTimelineEntry[];
-  onBack: () => void;
-  onInterruptTurn?: () => void;
+  selected: boolean;
+  onClick: () => void;
 }) {
-  const meta = statusMeta(snapshot.status);
-  const runtimeSummary = summarizeRuntime(snapshot);
-  const [showAll, setShowAll] = useState(false);
-  const [copied, setCopied] = useState(false);
-  const copyId = snapshot.agentId ?? snapshot.taskId;
-
-  const visibleTimeline = showAll ? timeline : timeline.slice(-MAX_VISIBLE_TIMELINE);
-  const hiddenCount = timeline.length - visibleTimeline.length;
-
-  const handleCopy = useCallback(() => {
-    if (typeof navigator !== "undefined" && navigator.clipboard) {
-      void navigator.clipboard.writeText(copyId);
-      setCopied(true);
-      setTimeout(() => setCopied(false), 1500);
-    }
-  }, [copyId]);
+  const runtime = runtimeText(snapshot);
+  const name = meaningfulName(snapshot);
+  const isRunning = snapshot.status === "running";
+  const isMuted = snapshot.status === "completed" || snapshot.status === "stopped";
+  const isFailed = snapshot.status === "failed";
 
   return (
-    <div className="flex flex-col">
-      {/* Back button + header */}
-      <div className="flex items-center gap-2.5 px-3 py-2 border-b border-white/[0.06]">
-        <button
-          type="button"
-          className="inline-flex items-center gap-1 rounded-md px-1.5 py-0.5 text-[12px] text-fg/40 transition-colors hover:bg-white/[0.04] hover:text-fg/70"
-          onClick={onBack}
-        >
-          <ArrowLeft size={12} weight="bold" />
-          Back
-        </button>
-        <span className="min-w-0 flex-1 truncate text-[13px] text-fg/70">
-          {snapshot.description}
-        </span>
-        <span className={cn(
-          "ade-chat-status-pill rounded-full border px-2 py-0.5 text-[10px] font-semibold uppercase tracking-wider",
-          meta.chipClassName,
-        )}>
-          {meta.label}
+    <button
+      type="button"
+      onClick={onClick}
+      title={snapshot.description}
+      data-selected={selected || undefined}
+      className={cn(
+        "group relative flex w-full items-center gap-3 px-4 py-1.5 text-left",
+        "transition-colors duration-150",
+        "hover:bg-white/[0.025]",
+        "data-[selected=true]:bg-white/[0.035]",
+        selected
+          && "before:absolute before:left-0 before:top-1/2 before:h-3 before:w-px before:-translate-y-1/2 before:bg-[color:var(--color-accent,#A78BFA)]/55",
+      )}
+    >
+      <span className="flex h-3 w-3 shrink-0 items-center justify-center">
+        <StatusGlyph status={snapshot.status} />
+      </span>
+      <span
+        className={cn(
+          "min-w-0 flex-1 truncate font-sans text-[12.5px] leading-5",
+          isRunning && "text-[color:var(--color-accent-bright,#C4B5FD)]",
+          isFailed && "text-rose-200/85",
+          isMuted && "text-fg/45",
+          !isRunning && !isFailed && !isMuted && "text-fg/70",
+        )}
+      >
+        {name}
+        {snapshot.background ? (
+          <span className="ml-1.5 font-sans text-[10.5px] tracking-[0.01em] text-fg/30">
+            bg
+          </span>
+        ) : null}
+      </span>
+      {runtime ? (
+        <span className="shrink-0 truncate font-sans text-[10.5px] tabular-nums text-fg/30 group-hover:text-fg/45">
+          {runtime}
         </span>
-      </div>
-
-      {/* Runtime stats */}
-      {runtimeSummary || snapshot.background || snapshot.agentType ? (
-        <div className="flex items-center gap-2 px-3 py-1.5">
-          {snapshot.agentType ? (
-            <span className="rounded border border-white/[0.06] bg-white/[0.03] px-1.5 py-0.5 font-mono text-[9px] text-fg/35">
-              {snapshot.agentType}
-            </span>
-          ) : null}
-          {snapshot.background ? (
-            <span className="rounded border border-sky-400/12 bg-sky-500/[0.06] px-1.5 py-0.5 text-[9px] font-semibold uppercase tracking-wider text-sky-300/55">
-              bg
-            </span>
-          ) : null}
-          {runtimeSummary ? (
-            <span className="text-[11px] text-fg/40">{runtimeSummary}</span>
-          ) : null}
-        </div>
-      ) : null}
-
-      {snapshot.finalSummary ? (
-        <div className="mx-3 mt-2 rounded-md border border-emerald-400/10 bg-emerald-500/[0.035] px-2.5 py-2 text-[12px] text-emerald-100/65">
-          {snapshot.finalSummary}
-        </div>
       ) : null}
-
-      {/* Activity timeline */}
-      <div className="flex-1 overflow-y-auto px-3 py-2">
-        {hiddenCount > 0 && (
-          <button
-            type="button"
-            className="mb-2 text-[11px] text-fg/30 transition-colors hover:text-fg/50"
-            onClick={() => setShowAll(true)}
-          >
-            Show {hiddenCount} earlier event{hiddenCount !== 1 ? "s" : ""}
-          </button>
-        )}
-
-        {visibleTimeline.length === 0 ? (
-          <div className="py-4 text-center text-[12px] text-fg/25">
-            No activity recorded yet
-          </div>
-        ) : (
-          <div className="space-y-0.5 border-l border-white/[0.06] ml-1 pl-3">
-            {visibleTimeline.map((entry, index) => (
-              <div key={`${entry.timestamp}-${index}`} className="flex items-start gap-2 py-0.5 relative before:absolute before:-left-3 before:top-[9px] before:h-px before:w-2 before:bg-white/[0.06]">
-                <span className="shrink-0 font-mono text-[11px] text-fg/20 pt-px">
-                  {formatTime(entry.timestamp)}
-                </span>
-                {entry.type === "started" ? (
-                  <span className="text-[12px] text-fg/40">Started</span>
-                ) : entry.type === "result" ? (
-                  <div className="min-w-0 flex-1">
-                    <span className={cn(
-                      "text-[12px] font-medium",
-                      entry.status === "completed" ? "text-emerald-300/70" :
-                      entry.status === "failed" ? "text-red-300/70" :
-                      "text-amber-300/70",
-                    )}>
-                      {entry.status === "completed" ? "Completed" : entry.status === "failed" ? "Failed" : "Stopped"}
-                    </span>
-                    {entry.summary ? (
-                      <p className="mt-0.5 truncate text-[12px] text-fg/45">{entry.summary}</p>
-                    ) : null}
-                  </div>
-                ) : (
-                  <div className="min-w-0 flex-1">
-                    {entry.lastToolName ? (
-                      <span className="font-mono text-[12px] text-fg/45">{entry.lastToolName}</span>
-                    ) : null}
-                    {entry.summary ? (
-                      <p className={cn(
-                        "truncate text-[12px] text-fg/35",
-                        entry.lastToolName && "mt-0.5",
-                      )}>
-                        {entry.summary}
-                      </p>
-                    ) : null}
-                    {!entry.lastToolName && !entry.summary ? (
-                      <span className="text-[12px] text-fg/25">Working...</span>
-                    ) : null}
-                  </div>
-                )}
-              </div>
-            ))}
-          </div>
-        )}
-      </div>
-
-      {/* Footer */}
-      <div className="flex items-center gap-2 border-t border-white/[0.06] px-3 py-1.5">
-        <span className="select-all font-mono text-[10px] text-fg/20">{copyId}</span>
-        <div className="ml-auto flex items-center gap-1.5">
-          <button
-            type="button"
-            className="inline-flex items-center gap-1 rounded-md border border-white/[0.06] px-2 py-0.5 text-[11px] text-fg/30 transition-all hover:border-white/[0.12] hover:text-fg/55"
-            onClick={handleCopy}
-            title="Copy agent id"
-          >
-            <Copy size={10} />
-            {copied ? "Copied" : "Copy id"}
-          </button>
-          {snapshot.status === "running" && onInterruptTurn ? (
-            <button
-              type="button"
-              className="inline-flex items-center gap-1 rounded-md border border-red-500/15 bg-red-500/[0.04] px-2 py-0.5 text-[11px] text-red-300/70 transition-all hover:bg-red-500/[0.08] hover:text-red-200"
-              onClick={onInterruptTurn}
-            >
-              <XCircle size={10} />
-              Stop
-            </button>
-          ) : null}
-        </div>
-      </div>
-    </div>
+    </button>
   );
 }
 
 /* ── Main component ── */
 
-type SubagentPanelTab = "subagents" | "teammates" | "background";
-
-function tabLabel(tab: SubagentPanelTab): string {
-  if (tab === "subagents") return "Subagents";
-  if (tab === "teammates") return "Teammates";
-  if (tab === "background") return "Background";
-  return "Subagents";
-}
+export type SubagentSelection = {
+  taskId: string;
+  agentId: string | null;
+  agentType: string | null;
+  status: ChatSubagentSnapshot["status"];
+  background: boolean;
+};
 
 export function ChatSubagentsPanel({
   snapshots,
   events,
   onInterruptTurn,
+  onSelectSubagent,
+  selectedTaskId,
   className,
   variant = "drawer",
   onClose,
@@ -280,224 +227,208 @@ export function ChatSubagentsPanel({
   snapshots: ChatSubagentSnapshot[];
   events: AgentChatEventEnvelope[];
   onInterruptTurn?: () => void;
+  onSelectSubagent?: (selection: SubagentSelection) => void;
+  selectedTaskId?: string | null;
   className?: string;
   variant?: "drawer" | "pane";
   onClose?: () => void;
 }) {
   const [expanded, setExpanded] = useState(false);
-  const [view, setView] = useState<{ mode: "list" } | { mode: "detail"; taskId: string }>({ mode: "list" });
-  const [selectedTab, setSelectedTab] = useState<SubagentPanelTab>("subagents");
 
-  const { activeCount, completedCount, failedCount, stoppedCount, backgroundRunningCount, tabCounts } = useMemo(() => {
-    let active = 0;
+  const plan = useMemo(() => derivePlan(events), [events]);
+
+  const { foreground, background, runningCount, completedCount, bgRunningCount } = useMemo(() => {
+    const fg: ChatSubagentSnapshot[] = [];
+    const bg: ChatSubagentSnapshot[] = [];
+    let running = 0;
     let completed = 0;
-    let failed = 0;
-    let stopped = 0;
     let bgRunning = 0;
-    for (const s of snapshots) {
-      if (s.status === "running") {
-        active++;
-        if (s.background) bgRunning++;
-      } else if (s.status === "completed") completed++;
-      else if (s.status === "stopped") stopped++;
-      else if (s.status === "failed") failed++;
+    for (const snap of snapshots) {
+      if (snap.background) {
+        bg.push(snap);
+        if (snap.status === "running") bgRunning += 1;
+      } else {
+        fg.push(snap);
+      }
+      if (snap.status === "running") running += 1;
+      else if (snap.status === "completed") completed += 1;
     }
+    const orderRunning = (snap: ChatSubagentSnapshot) => (snap.status === "running" ? 0 : 1);
+    fg.sort((a, b) => orderRunning(a) - orderRunning(b));
+    bg.sort((a, b) => orderRunning(a) - orderRunning(b));
     return {
-      activeCount: active,
+      foreground: fg,
+      background: bg,
+      runningCount: running,
       completedCount: completed,
-      failedCount: failed,
-      stoppedCount: stopped,
-      backgroundRunningCount: bgRunning,
-      tabCounts: {
-        subagents: snapshots.filter((s) => !s.background).length,
-        teammates: 0,
-        background: snapshots.filter((s) => s.background).length,
-      },
+      bgRunningCount: bgRunning,
     };
   }, [snapshots]);
 
-  const summaryText = useMemo(() => {
-    const plural = (count: number, word: string) => `${count} ${word}${count === 1 ? "" : "s"}`;
-    const parts: string[] = [plural(activeCount, "active")];
-    if (backgroundRunningCount > 0) parts.push(`${backgroundRunningCount} bg`);
-    if (completedCount > 0) parts.push(`${completedCount} done`);
-    if (stoppedCount > 0) parts.push(`${stoppedCount} stopped`);
-    if (failedCount > 0) parts.push(`${failedCount} failed`);
-    return parts.join(" \u00b7 ");
-  }, [activeCount, backgroundRunningCount, completedCount, failedCount, stoppedCount]);
-
-  const detailSnapshot = useMemo(() => {
-    if (view.mode !== "detail") return null;
-    return snapshots.find((s) => s.taskId === view.taskId) ?? null;
-  }, [view, snapshots]);
-
-  const detailTimeline = useMemo(() => {
-    if (view.mode !== "detail") return [];
-    return deriveSubagentTimeline(events, view.taskId);
-  }, [view, events]);
-
-  if (!snapshots.length) return null;
-
-  // When only one category has content (e.g. Codex never emits Teammates and
-  // often only emits non-background subagents), drop the tab strip so the
-  // panel reads as a single labeled section instead of one lit-up tab next
-  // to two empty ones.
-  const nonEmptyTabs = (["subagents", "teammates", "background"] as SubagentPanelTab[])
-    .filter((tab) => tabCounts[tab] > 0);
-  const singleNonEmptyTab = nonEmptyTabs.length === 1 ? nonEmptyTabs[0] : null;
-  const activeTab = singleNonEmptyTab ?? selectedTab;
-  const visibleSnapshots = snapshots.filter((snapshot) => {
-    if (activeTab === "subagents") return !snapshot.background;
-    if (activeTab === "teammates") return false;
-    if (activeTab === "background") return snapshot.background === true;
-    return true;
-  });
-
-  const tabs: SubagentPanelTab[] = ["subagents", "teammates", "background"];
-  const tabControls = singleNonEmptyTab ? (
-    <div className="flex shrink-0 items-center gap-2 border-b border-white/[0.06] px-3 py-2 text-[11px] font-medium text-fg/65">
-      <span>{tabLabel(singleNonEmptyTab)}</span>
-      <span className="rounded-full bg-white/[0.04] px-1.5 py-px font-mono text-[9px] text-fg/45">
-        {tabCounts[singleNonEmptyTab]}
-      </span>
-    </div>
-  ) : (
-    <div className="flex shrink-0 items-center gap-1 border-b border-white/[0.06] px-2 py-1.5">
-      {tabs.map((tab) => (
-        <button
-          key={tab}
-          type="button"
-          className={cn(
-            "inline-flex h-7 items-center gap-1.5 rounded-md px-2 text-[11px] font-medium transition-colors",
-            activeTab === tab
-              ? "bg-white/[0.075] text-fg/78"
-              : "text-fg/35 hover:bg-white/[0.04] hover:text-fg/58",
-          )}
-          onClick={() => {
-            setSelectedTab(tab);
-            setView({ mode: "list" });
-          }}
-        >
-          <span>{tabLabel(tab)}</span>
-          <span className={cn(
-            "rounded-full px-1.5 py-px font-mono text-[9px]",
-            activeTab === tab ? "bg-black/20 text-fg/55" : "bg-white/[0.04] text-fg/28",
-          )}>
-            {tabCounts[tab]}
-          </span>
-        </button>
-      ))}
-    </div>
-  );
+  const headerSummary = useMemo(() => {
+    const parts: string[] = [];
+    if (runningCount) parts.push(`${runningCount} running`);
+    if (bgRunningCount) parts.push(`${bgRunningCount} bg`);
+    if (completedCount) parts.push(`${completedCount} done`);
+    if (!parts.length && snapshots.length) parts.push(`${snapshots.length} tracked`);
+    if (!parts.length) parts.push("idle");
+    return parts.join(" · ");
+  }, [runningCount, bgRunningCount, completedCount, snapshots.length]);
+
+  const handleSelect = (snap: ChatSubagentSnapshot) => {
+    if (!onSelectSubagent) return;
+    onSelectSubagent({
+      taskId: snap.taskId,
+      agentId: snap.agentId ?? null,
+      agentType: snap.agentType ?? null,
+      status: snap.status,
+      background: snap.background === true,
+    });
+  };
+
+  const planComplete = plan?.steps.filter((step) => step.status === "completed").length ?? 0;
+  const planTotal = plan?.steps.length ?? 0;
+  const planPercent = planTotal > 0 ? Math.round((planComplete / planTotal) * 100) : 0;
+
+  const hasAnything = Boolean(plan) || foreground.length > 0 || background.length > 0;
+
+  const body = (
+    <div className="flex min-h-0 flex-1 flex-col font-sans">
+      {/* ── Progress ─────────────────────────────────────────────── */}
+      {plan && plan.steps.length > 0 ? (
+        <section className="pb-3">
+          <SectionHeader
+            label="Progress"
+            hint={`${planComplete}/${planTotal} · ${planPercent}%`}
+          />
+          <ProgressBar percent={planPercent} />
+          <ul className="px-4 pt-2">
+            {plan.steps.map((step, index) => {
+              const isCompleted = step.status === "completed";
+              const isInProgress = step.status === "in_progress";
+              const isFailed = step.status === "failed";
+              return (
+                <li
+                  key={`${index}-${step.text}`}
+                  className={cn(
+                    "flex items-start gap-2.5 py-[3px] text-[12.5px] leading-5",
+                    isCompleted && "text-fg/40",
+                    isInProgress && "text-[color:var(--color-accent-bright,#C4B5FD)]",
+                    !isCompleted && !isInProgress && !isFailed && "text-fg/55",
+                    isFailed && "text-rose-200/85",
+                  )}
+                >
+                  <span className="mt-[3px] flex h-3 w-3 shrink-0 items-center justify-center">
+                    <PlanGlyph status={step.status} />
+                  </span>
+                  <span className="min-w-0 flex-1 break-words">{step.text}</span>
+                </li>
+              );
+            })}
+          </ul>
+        </section>
+      ) : null}
+
+      {/* ── Subagents ────────────────────────────────────────────── */}
+      <section
+        className={cn(
+          "pb-2",
+          (plan || background.length) && "border-t border-white/[0.04]",
+        )}
+      >
+        <SectionHeader
+          label="Subagents"
+          hint={foreground.length ? `${foreground.length}` : undefined}
+        />
+        {foreground.length ? (
+          <div className="pb-1">
+            {foreground.map((snap) => (
+              <SubagentRow
+                key={snap.taskId}
+                snapshot={snap}
+                selected={selectedTaskId === snap.taskId}
+                onClick={() => handleSelect(snap)}
+              />
+            ))}
+          </div>
+        ) : (
+          <p className="px-4 pb-2 text-[11.5px] text-fg/30">
+            None active.
+          </p>
+        )}
+      </section>
+
+      {/* ── Background tasks ─────────────────────────────────────── */}
+      {background.length ? (
+        <section className="border-t border-white/[0.04] pb-2">
+          <SectionHeader label="Background tasks" hint={`${background.length}`} />
+          <div className="pb-1">
+            {background.map((snap) => (
+              <SubagentRow
+                key={snap.taskId}
+                snapshot={snap}
+                selected={selectedTaskId === snap.taskId}
+                onClick={() => handleSelect(snap)}
+              />
+            ))}
+          </div>
+        </section>
+      ) : null}
 
-  const listContent = (
-    <div className={cn(
-      "space-y-1.5 px-1.5 py-1.5",
-      variant === "pane" && "min-h-0 flex-1 overflow-y-auto px-2.5 py-2.5",
-    )}>
-      {visibleSnapshots.length ? visibleSnapshots.map((snapshot) => {
-        const meta = statusMeta(snapshot.status);
-        const runtimeSummary = summarizeRuntime(snapshot);
-        const agentName = snapshot.agentType || snapshot.agentId || snapshot.taskId;
-        const description = snapshot.description && snapshot.description !== agentName ? snapshot.description : null;
-
-        return (
+      {/* ── Single-agent empty state ─────────────────────────────── */}
+      {!hasAnything ? (
+        <div className="px-4 py-6 text-[12px] leading-5 text-fg/40">
+          No agent activity for this chat.
+          <span className="block pt-0.5 text-fg/25">Single-agent mode.</span>
+        </div>
+      ) : null}
+
+      {/* ── Interrupt action — ghost button, no chip ─────────────── */}
+      {onInterruptTurn && runningCount > 0 ? (
+        <div className="mt-auto px-4 pb-3 pt-2">
           <button
-            key={snapshot.taskId}
             type="button"
+            onClick={onInterruptTurn}
             className={cn(
-              "ade-chat-subagent-card group flex w-full items-center gap-2.5 rounded-xl px-3.5 py-3 text-left",
-              snapshot.status === "running" && "ade-chat-subagent-card-active",
+              "group inline-flex items-center gap-1.5 rounded-full px-2.5 py-1",
+              "text-[11px] font-medium text-fg/45",
+              "transition-colors hover:text-rose-200/85",
             )}
-            onClick={() => setView({ mode: "detail", taskId: snapshot.taskId })}
-            title={snapshot.description}
           >
-            <span className="flex h-4 w-4 shrink-0 items-center justify-center">
-              {meta.icon}
-            </span>
-            <span className="min-w-0 flex-1">
-              <span className="block truncate text-[13px] text-fg/65 group-hover:text-fg/85">
-                {agentName}
-              </span>
-              {description ? (
-                <span className="mt-0.5 block truncate text-[11px] text-fg/35">
-                  {description}
-                </span>
-              ) : null}
-              {snapshot.finalSummary ? (
-                <span className="mt-1 block truncate text-[11px] text-emerald-200/55">
-                  ┊ {snapshot.finalSummary}
-                </span>
-              ) : snapshot.summary ? (
-                <span className="mt-1 block truncate text-[11px] text-fg/32">
-                  ▎ {snapshot.summary}
-                </span>
-              ) : null}
-            </span>
-            {snapshot.agentType ? (
-              <span className="rounded border border-white/[0.06] bg-white/[0.03] px-1.5 py-0.5 font-mono text-[9px] text-fg/35">
-                {snapshot.agentType}
-              </span>
-            ) : null}
-            {snapshot.background ? (
-              <span className="rounded border border-sky-400/12 bg-sky-500/[0.06] px-1.5 py-0.5 text-[9px] font-semibold uppercase tracking-wider text-sky-300/55">
-                bg
-              </span>
-            ) : null}
-            {runtimeSummary ? (
-              <span className="text-[11px] text-fg/40 group-hover:text-fg/50">
-                {runtimeSummary}
-              </span>
-            ) : null}
-            <span className={cn("ade-chat-status-pill rounded-full border px-2 py-0.5 text-[10px] font-semibold uppercase tracking-wider", meta.chipClassName)}>
-              {meta.label}
-            </span>
+            <StopCircle size={12} weight="regular" className="text-fg/40 group-hover:text-rose-300/80" />
+            Stop running agents
           </button>
-        );
-      }) : (
-        <div className="flex h-24 items-center justify-center rounded-lg border border-white/[0.05] bg-white/[0.02] text-[12px] text-fg/28">
-          {activeTab === "teammates" ? "No team active" : `No ${tabLabel(activeTab).toLowerCase()} subagents`}
         </div>
-      )}
+      ) : null}
     </div>
   );
 
-  const body = view.mode === "detail" && detailSnapshot ? (
-    <SubagentDetailView
-      snapshot={detailSnapshot}
-      timeline={detailTimeline}
-      onBack={() => setView({ mode: "list" })}
-      onInterruptTurn={detailSnapshot.status === "running" ? onInterruptTurn : undefined}
-    />
-  ) : (
-    <>
-      {tabControls}
-      {listContent}
-    </>
-  );
-
   if (variant === "pane") {
     return (
-      <div className={cn("flex h-full min-h-0 flex-col", className)}>
-        <div className="flex shrink-0 items-center gap-3 border-b border-white/[0.06] px-4 py-2.5">
-          <TreeStructure size={14} className="text-fg/45" />
-          <div className="min-w-0 flex-1">
-            <div className="font-sans text-[12px] font-medium text-fg/80">Subagents</div>
-            <div className="truncate text-[10px] text-fg/32">{summaryText}</div>
-          </div>
+      <div className={cn("flex h-full min-h-0 flex-col font-sans", className)}>
+        {/* Single-line header: "Work" + dimmed summary clause + close.
+            The TreeStructure icon moved into the toggle button where it
+            actually means something. */}
+        <div className="flex shrink-0 items-baseline gap-3 px-4 pb-2.5 pt-3.5">
+          <span className="text-[12.5px] font-medium tracking-[0.005em] text-fg/80">
+            Work
+          </span>
+          <span className="min-w-0 flex-1 truncate text-[11px] text-fg/35">
+            {headerSummary}
+          </span>
           {onClose ? (
             <button
               type="button"
-              className="inline-flex h-7 w-7 items-center justify-center rounded-md border border-white/[0.06] bg-white/[0.03] text-fg/45 transition-colors hover:text-fg/80"
+              className="-mr-1 inline-flex h-6 w-6 items-center justify-center rounded text-fg/35 transition-colors hover:bg-white/[0.04] hover:text-fg/70"
               onClick={onClose}
-              title="Close subagents panel"
-              aria-label="Close subagents panel"
+              title="Close work panel"
+              aria-label="Close work panel"
             >
-              <X size={12} weight="bold" />
+              <X size={11} weight="bold" />
             </button>
           ) : null}
         </div>
-        <div className="flex min-h-0 flex-1 flex-col">
+        <div className="min-h-0 flex-1 overflow-y-auto border-t border-white/[0.04]">
           {body}
         </div>
       </div>
@@ -508,12 +439,9 @@ export function ChatSubagentsPanel({
     <BottomDrawerSection
       label="Subagents"
       icon={TreeStructure}
-      summary={summaryText}
+      summary={headerSummary}
       expanded={expanded}
-      onToggle={() => {
-        setExpanded((v) => !v);
-        if (expanded) setView({ mode: "list" });
-      }}
+      onToggle={() => setExpanded((v) => !v)}
       className={className}
     >
       {body}
diff --git a/apps/desktop/src/renderer/components/chat/chatExecutionSummary.ts b/apps/desktop/src/renderer/components/chat/chatExecutionSummary.ts
index 4fe5e01c1..5c8dcc2d3 100644
--- a/apps/desktop/src/renderer/components/chat/chatExecutionSummary.ts
+++ b/apps/desktop/src/renderer/components/chat/chatExecutionSummary.ts
@@ -1,4 +1,15 @@
 import type { AgentChatEventEnvelope, TurnDiffSummary } from "../../../shared/types";
+import { latestPlan, type ChatInfoPlan } from "../../../shared/chatSubagents";
+
+export type { ChatInfoPlan, ChatInfoPlanStep } from "../../../shared/chatSubagents";
+
+/**
+ * Latest plan snapshot derived from the event stream. Returns null when the
+ * provider has not emitted a plan event for this chat.
+ */
+export function derivePlan(events: AgentChatEventEnvelope[]): ChatInfoPlan {
+  return latestPlan(events);
+}
 
 export type ChatSubagentSnapshot = {
   taskId: string;
diff --git a/apps/desktop/src/renderer/components/chat/codex/CodexImageGenerationCard.test.tsx b/apps/desktop/src/renderer/components/chat/codex/CodexImageGenerationCard.test.tsx
index 4132b36b1..f93261430 100644
--- a/apps/desktop/src/renderer/components/chat/codex/CodexImageGenerationCard.test.tsx
+++ b/apps/desktop/src/renderer/components/chat/codex/CodexImageGenerationCard.test.tsx
@@ -24,18 +24,26 @@ describe("CodexImageGenerationCard", () => {
   beforeEach(() => {
     openPath = vi.fn(async () => undefined);
     originalAde = (window as { ade?: unknown }).ade as typeof window.ade;
-    (window as unknown as { ade: { app: { openPath: typeof openPath } } }).ade = {
-      ...(originalAde ?? {}),
-      app: {
-        ...(originalAde?.app ?? {}),
-        openPath,
+    Object.defineProperty(window, "ade", {
+      configurable: true,
+      writable: true,
+      value: {
+        ...(originalAde ?? {}),
+        app: {
+          ...(originalAde?.app ?? {}),
+          openPath,
+        },
       },
-    } as never;
+    });
   });
 
   afterEach(() => {
     cleanup();
-    (window as unknown as { ade: typeof originalAde }).ade = originalAde;
+    Object.defineProperty(window, "ade", {
+      configurable: true,
+      writable: true,
+      value: originalAde,
+    });
   });
 
   it("renders the Open button only when savedPath is set, and triggers window.ade.app.openPath on click", () => {
diff --git a/apps/desktop/src/renderer/components/cto/CtoPage.tsx b/apps/desktop/src/renderer/components/cto/CtoPage.tsx
index 294320a75..106a41810 100644
--- a/apps/desktop/src/renderer/components/cto/CtoPage.tsx
+++ b/apps/desktop/src/renderer/components/cto/CtoPage.tsx
@@ -73,7 +73,7 @@ function statusDotCls(status: AgentStatus): string {
 
 /* ── Main Page ── */
 
-export function CtoPage() {
+export function CtoPage({ active = true }: { active?: boolean } = {}) {
   const lanes = useAppStore((s) => s.lanes);
 
   const [activeTab, setActiveTab] = useState<TabId>("chat");
@@ -86,6 +86,7 @@ export function CtoPage() {
   const [sessionLogs, setSessionLogs] = useState<CtoSessionLogEntry[]>([]);
 
   useEffect(() => {
+    if (!active) return;
     const onTourTab = (event: Event) => {
       const tab = (event as CustomEvent<TabId>).detail;
       if (tab === "chat" || tab === "team" || tab === "workflows" || tab === "settings") {
@@ -94,7 +95,7 @@ export function CtoPage() {
     };
     window.addEventListener("ade:tour-cto-tab", onTourTab);
     return () => window.removeEventListener("ade:tour-cto-tab", onTourTab);
-  }, []);
+  }, [active]);
 
   // Onboarding state
   const [onboardingState, setOnboardingState] = useState<CtoOnboardingState | null>(null);
@@ -206,15 +207,18 @@ export function CtoPage() {
   }, [budgetLoading, budgetSnapshot]);
 
   useEffect(() => {
+    if (!active) return;
     void loadCtoSummary();
-  }, [loadCtoSummary]);
+  }, [active, loadCtoSummary]);
 
   useEffect(() => {
+    if (!active) return;
     if (!onboardingState || needsOnboarding) return;
     void loadAgents();
-  }, [loadAgents, needsOnboarding, onboardingState]);
+  }, [active, loadAgents, needsOnboarding, onboardingState]);
 
   useEffect(() => {
+    if (!active) return;
     if (!onboardingState || needsOnboarding) return;
     if (activeTab !== "team" && activeTab !== "settings") return;
     let cancelled = false;
@@ -227,22 +231,25 @@ export function CtoPage() {
       cancelled = true;
       window.clearTimeout(timer);
     };
-  }, [activeTab, loadBudgetSnapshot, needsOnboarding, onboardingState]);
+  }, [active, activeTab, loadBudgetSnapshot, needsOnboarding, onboardingState]);
 
   useEffect(() => {
+    if (!active) return;
     if ((activeTab !== "team" && activeTab !== "settings") || ctoHistoryLoadedRef.current) return;
     void loadCtoHistory();
-  }, [activeTab, loadCtoHistory]);
+  }, [active, activeTab, loadCtoHistory]);
 
   // Load revisions when worker selected
   useEffect(() => {
+    if (!active) return;
     if (!window.ade?.cto || !selectedAgentId) { setRevisions([]); return; }
     if (activeTab !== "team") return;
     void window.ade.cto.listAgentRevisions({ agentId: selectedAgentId, limit: 20 }).then(setRevisions).catch(() => setRevisions([]));
-  }, [activeTab, selectedAgentId]);
+  }, [active, activeTab, selectedAgentId]);
 
   // Load worker details when selected
   useEffect(() => {
+    if (!active) return;
     if (!window.ade?.cto || !selectedAgentId) {
       setWorkerCoreMemory(null); setWorkerSessionLogs([]); setWorkerRuns([]);
       setWorkerOpsError(null); setWorkerWakeStatus(null); setWorkerWakeError(null);
@@ -263,10 +270,11 @@ export function CtoPage() {
       setWorkerCoreMemory(null); setWorkerSessionLogs([]); setWorkerRuns([]);
     });
     return () => { cancelled = true; };
-  }, [activeTab, selectedAgentId]);
+  }, [active, activeTab, selectedAgentId]);
 
   // Establish chat session
   useEffect(() => {
+    if (!active) return;
     if (activeTab !== "chat") {
       setLoading(false);
       return;
@@ -293,10 +301,11 @@ export function CtoPage() {
       .catch((err) => { if (!cancelled) { setError(err instanceof Error ? err.message : String(err)); setSession(null); } })
       .finally(() => { if (!cancelled) setLoading(false); });
     return () => { cancelled = true; };
-  }, [activeTab, needsOnboarding, onboardingState, primaryLaneId, selectedAgentId, showOnboarding]);
+  }, [active, activeTab, needsOnboarding, onboardingState, primaryLaneId, selectedAgentId, showOnboarding]);
 
   // Deep links for guided setup flows
   useEffect(() => {
+    if (!active) return;
     const syncHash = () => {
       const hash = window.location.hash.toLowerCase();
       if (hash.includes("linear-sync")) {
@@ -308,7 +317,7 @@ export function CtoPage() {
     syncHash();
     window.addEventListener("hashchange", syncHash);
     return () => window.removeEventListener("hashchange", syncHash);
-  }, []);
+  }, [active]);
 
   useEffect(() => {
     console.info(`renderer.tab_change ${JSON.stringify({
@@ -674,14 +683,14 @@ export function CtoPage() {
               </div>
             )}
 
-            <div
-              className="min-h-0 flex-1 overflow-hidden rounded-[24px] border border-white/[0.07]"
-              style={{
-                background: "radial-gradient(circle at top left, rgba(167,139,250,0.08), transparent 26%), linear-gradient(180deg, rgba(13,18,27,0.88), rgba(9,12,18,0.94))",
-              }}
-            >
+            <div className="min-h-0 flex-1 overflow-hidden">
               {showOnboarding || needsOnboarding ? (
-                <div className="flex h-full items-center justify-center p-6 text-center">
+                <div
+                  className="flex h-full items-center justify-center rounded-[24px] border border-white/[0.07] p-6 text-center"
+                  style={{
+                    background: "radial-gradient(circle at top left, rgba(167,139,250,0.08), transparent 26%), linear-gradient(180deg, rgba(13,18,27,0.88), rgba(9,12,18,0.94))",
+                  }}
+                >
                   <div className="max-w-sm space-y-3">
                     <div className="text-sm font-semibold text-fg">Complete setup to unlock the CTO session</div>
                     <div className="text-[12px] leading-6 text-muted-fg/42">
@@ -693,7 +702,12 @@ export function CtoPage() {
                   </div>
                 </div>
               ) : !session ? (
-                <div className="flex h-full items-center justify-center p-6 text-center">
+                <div
+                  className="flex h-full items-center justify-center rounded-[24px] border border-white/[0.07] p-6 text-center"
+                  style={{
+                    background: "radial-gradient(circle at top left, rgba(167,139,250,0.08), transparent 26%), linear-gradient(180deg, rgba(13,18,27,0.88), rgba(9,12,18,0.94))",
+                  }}
+                >
                   <div className="space-y-2">
                     <div className="text-sm font-medium text-fg/70">Connecting the persistent session…</div>
                     <div className="text-[12px] leading-6 text-muted-fg/40">
diff --git a/apps/desktop/src/renderer/components/cto/ctoUi.test.tsx b/apps/desktop/src/renderer/components/cto/ctoUi.test.tsx
index 352752787..217762f33 100644
--- a/apps/desktop/src/renderer/components/cto/ctoUi.test.tsx
+++ b/apps/desktop/src/renderer/components/cto/ctoUi.test.tsx
@@ -11,7 +11,116 @@ import {
 import { CtoSettingsPanel } from "./CtoSettingsPanel";
 import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
 import { render, screen, fireEvent, waitFor, cleanup } from "@testing-library/react";
+import { MemoryRouter } from "react-router-dom";
 import { resolveCtoPrimaryLaneId } from "./ctoSessionViewState";
+import { CtoPage } from "./CtoPage";
+import { useAppStore } from "../../state/appStore";
+
+const agentChatPaneProps = vi.hoisted(() => ({
+  latest: null as null | Record<string, unknown>,
+}));
+
+vi.mock("../chat/AgentChatPane", () => ({
+  AgentChatPane: (props: Record<string, unknown>) => {
+    agentChatPaneProps.latest = props;
+    return <div data-testid="cto-agent-chat-pane" />;
+  },
+}));
+
+describe("CtoPage chat layout", () => {
+  const originalAde = globalThis.window.ade;
+
+  beforeEach(() => {
+    agentChatPaneProps.latest = null;
+    useAppStore.setState({
+      lanes: [
+        {
+          id: "lane-primary",
+          name: "Primary",
+          laneType: "primary",
+        } as any,
+      ],
+      lanesLoading: false,
+    });
+    globalThis.window.ade = {
+      ...(originalAde ?? {}),
+      cto: {
+        ...(originalAde?.cto ?? {}),
+        getState: vi.fn().mockResolvedValue({
+          identity: {
+            version: 2,
+            persona: "Senior CTO",
+            personality: "strategic",
+            customPersonality: null,
+            modelPreferences: {
+              provider: "anthropic",
+              model: "claude-sonnet-4-6",
+              reasoningEffort: null,
+            },
+          },
+          coreMemory: {
+            projectSummary: "Project brief",
+            criticalConventions: [],
+            userPreferences: [],
+            activeFocus: [],
+            notes: [],
+          },
+          recentSessions: [],
+        }),
+        getOnboardingState: vi.fn().mockResolvedValue({
+          completedAt: "2026-05-01T00:00:00.000Z",
+          completedSteps: ["identity"],
+          dismissedAt: null,
+        }),
+        listAgents: vi.fn().mockResolvedValue([]),
+        ensureSession: vi.fn().mockResolvedValue({
+          id: "cto-session",
+          laneId: "lane-primary",
+          provider: "anthropic",
+          model: "claude-sonnet-4-6",
+          modelId: "anthropic/claude-sonnet-4-6",
+          sessionProfile: "persistent_identity",
+          reasoningEffort: null,
+          executionMode: null,
+          identityKey: "cto",
+          capabilityMode: "full_tooling",
+          status: "idle",
+          createdAt: "2026-05-01T00:00:00.000Z",
+          lastActivityAt: "2026-05-01T00:00:00.000Z",
+          threadId: "thread-1",
+        }),
+      },
+    } as any;
+  });
+
+  afterEach(() => {
+    cleanup();
+    vi.clearAllMocks();
+    useAppStore.setState({ lanes: [], lanesLoading: false });
+    if (originalAde === undefined) {
+      delete (globalThis.window as any).ade;
+    } else {
+      globalThis.window.ade = originalAde;
+    }
+  });
+
+  it("embeds the persistent CTO chat in the full-height chat host instead of an extra clipped card", async () => {
+    render(
+      <MemoryRouter>
+        <CtoPage />
+      </MemoryRouter>,
+    );
+
+    const pane = await screen.findByTestId("cto-agent-chat-pane");
+    expect(agentChatPaneProps.latest?.laneId).toBe("lane-primary");
+    expect(agentChatPaneProps.latest?.lockSessionId).toBe("cto-session");
+    expect(agentChatPaneProps.latest?.hideSessionTabs).toBe(true);
+
+    const host = pane.parentElement;
+    expect(host?.className).toBe("min-h-0 flex-1 overflow-hidden");
+    expect(host?.className).not.toContain("rounded");
+  });
+});
 
 describe("CtoSettingsPanel (file group)", () => {
   vi.mock("./IdentityEditor", () => ({
diff --git a/apps/desktop/src/renderer/components/files/FilesPage.tsx b/apps/desktop/src/renderer/components/files/FilesPage.tsx
index 2b29347cc..3259833b3 100644
--- a/apps/desktop/src/renderer/components/files/FilesPage.tsx
+++ b/apps/desktop/src/renderer/components/files/FilesPage.tsx
@@ -524,9 +524,11 @@ function FilePreviewSurface({ tab }: { tab: OpenTab }) {
 export function FilesPage({
   preferredLaneId = null,
   embedded = false,
+  active = true,
 }: {
   preferredLaneId?: string | null;
   embedded?: boolean;
+  active?: boolean;
 } = {}) {
   const navigate = useNavigate();
   const location = useLocation();
@@ -668,7 +670,7 @@ export function FilesPage({
   const activeTabPreviewKind = getFilePreviewKind(activeTab);
   const activeTabIsText = isTextTab(activeTab);
   const canEdit = Boolean(activeWorkspace) && (!activeWorkspace?.isReadOnlyByDefault || allowPrimaryEdit);
-  const liveWatchEnabled = Boolean(workspaceId);
+  const liveWatchEnabled = active && Boolean(workspaceId);
 
   useEffect(() => {
     if (!activeWorkspace?.rootPath) return;
@@ -893,6 +895,7 @@ export function FilesPage({
 
   useEffect(() => {
     const st = (location.state as FilesPageNavState | null) ?? null;
+    if (!active) return;
     const openFilePath = st?.openFilePath?.trim();
     if (!openFilePath) return;
     if (typeof st?.startLine === "number" && st.startLine > 0) {
@@ -912,7 +915,7 @@ export function FilesPage({
       startLine: st?.startLine,
       startColumn: st?.startColumn,
     };
-  }, [location.key, location.state]);
+  }, [active, location.key, location.state]);
 
   const refreshTreeNow = useCallback(async (parentPath?: string) => {
     if (!workspaceId) return;
@@ -1096,6 +1099,7 @@ export function FilesPage({
   }, [workspaceId, workspaceComparisonRoot, nodeByComparablePath]);
 
   useEffect(() => {
+    if (!active) return;
     const pending = pendingOpenRef.current;
     if (!pending) return;
     if (!workspaces.length) return;
@@ -1150,7 +1154,7 @@ export function FilesPage({
       cancelled = true;
       if (pendingTimer !== null) clearTimeout(pendingTimer);
     };
-  }, [workspaces, workspaceId, switchWorkspace, openFile, navigate, location.pathname, revealPendingLocation]);
+  }, [active, workspaces, workspaceId, switchWorkspace, openFile, navigate, location.pathname, revealPendingLocation]);
 
   const closeTab = useCallback((filePath: string) => {
     setOpenTabs((prev) => {
@@ -1283,6 +1287,7 @@ export function FilesPage({
   }, [canEdit, workspaceId, requestTextInput, refreshTree]);
 
   useEffect(() => {
+    if (!active) return;
     const startedAt = performance.now();
     logRendererDebugEvent("renderer.files.list_workspaces.begin");
     window.ade.files.listWorkspaces()
@@ -1311,7 +1316,7 @@ export function FilesPage({
       });
     // Workspaces are listed once on mount; lane changes are reconciled by the effect below.
     // eslint-disable-next-line react-hooks/exhaustive-deps
-  }, []);
+  }, [active]);
 
   // Reconcile the active workspace when the preferred lane changes (without refetching).
   useEffect(() => {
@@ -1338,6 +1343,7 @@ export function FilesPage({
   }, [selectedLaneId, unavailableWorkspaceIds, workspaceId, workspaces]);
 
   useEffect(() => {
+    if (!active) return;
     if (!workspaceId) return;
     logRendererDebugEvent("renderer.files.workspace_effect.begin", {
       workspaceId,
@@ -1348,7 +1354,7 @@ export function FilesPage({
     treeRefreshStateRef.current.queuedFull = false;
     treeRefreshStateRef.current.queuedParents.clear();
     void refreshTree();
-  }, [workspaceId, refreshTree]);
+  }, [active, workspaceId, refreshTree]);
 
   useEffect(() => {
     if (!workspaceId) return;
@@ -1528,12 +1534,13 @@ export function FilesPage({
   }, [hasUnsavedTabs]);
 
   useEffect(() => {
+    if (!active) return;
     const onWindowPointerDown = () => {
       if (contextMenu) setContextMenu(null);
     };
     window.addEventListener("pointerdown", onWindowPointerDown);
     return () => window.removeEventListener("pointerdown", onWindowPointerDown);
-  }, [contextMenu]);
+  }, [active, contextMenu]);
 
   useLayoutEffect(() => {
     if (!contextMenu) {
@@ -1563,6 +1570,7 @@ export function FilesPage({
   }, [contextMenu]);
 
   useEffect(() => {
+    if (!active) return;
     const onKeyDown = (e: KeyboardEvent) => {
       const isMac = navigator.platform.toLowerCase().includes("mac");
       const mod = isMac ? e.metaKey : e.ctrlKey;
@@ -1613,9 +1621,10 @@ export function FilesPage({
 
     window.addEventListener("keydown", onKeyDown);
     return () => window.removeEventListener("keydown", onKeyDown);
-  }, [saveActive, activeTabPath, closeTab, selectedNodePath, showQuickOpen, showContentSearch, openInMenuOpen]);
+  }, [active, saveActive, activeTabPath, closeTab, selectedNodePath, showQuickOpen, showContentSearch, openInMenuOpen]);
 
   useEffect(() => {
+    if (!active) return;
     if (!quickOpen.trim()) {
       setQuickOpenResults([]);
       return;
@@ -1635,18 +1644,20 @@ export function FilesPage({
       cancelled = true;
       window.clearTimeout(timer);
     };
-  }, [quickOpen, workspaceId, showQuickOpen]);
+  }, [active, quickOpen, workspaceId, showQuickOpen]);
 
   useEffect(() => {
+    if (!active) return;
     if (!showContentSearch) return;
     const frame = window.requestAnimationFrame(() => {
       contentSearchInputRef.current?.focus();
       contentSearchInputRef.current?.select();
     });
     return () => window.cancelAnimationFrame(frame);
-  }, [showContentSearch]);
+  }, [active, showContentSearch]);
 
   useEffect(() => {
+    if (!active) return;
     if (!showContentSearch || !contentSearchQuery.trim()) {
       setContentSearchResults([]);
       return;
@@ -1657,7 +1668,7 @@ export function FilesPage({
         .catch(() => setContentSearchResults([]));
     }, 150);
     return () => clearTimeout(timer);
-  }, [contentSearchQuery, workspaceId, showContentSearch]);
+  }, [active, contentSearchQuery, workspaceId, showContentSearch]);
 
   useEffect(() => {
     if (!activeTab) return;
@@ -2048,7 +2059,7 @@ export function FilesPage({
               </div>
             ) : mode === "diff" ? (
               laneIdForDiff && activeTabPath ? (
-                <FilesDiffPanel laneId={laneIdForDiff} path={activeTabPath} theme={editorTheme} diffViewRef={diffViewRef} />
+                <FilesDiffPanel laneId={laneIdForDiff} path={activeTabPath} theme={editorTheme} diffViewRef={diffViewRef} active={active} />
               ) : (
                 <div style={{ padding: 16, fontFamily: MONO_FONT, fontSize: 12, color: COLORS.textMuted }}>
                   DIFF MODE REQUIRES A LANE WORKSPACE AND AN OPEN FILE.
@@ -2694,11 +2705,13 @@ export function FilesPage({
 }
 
 function FilesDiffPanel({
+  active = true,
   laneId,
   path,
   theme,
   diffViewRef,
 }: {
+  active?: boolean;
   laneId: string;
   path: string;
   theme: EditorThemeMode;
@@ -2712,6 +2725,7 @@ function FilesDiffPanel({
   const [compareRef, setCompareRef] = useState<string>("");
 
   useEffect(() => {
+    if (!active) return;
     let cancelled = false;
     setCompareRef("");
     window.ade.git.listRecentCommits({ laneId, limit: 30 })
@@ -2728,9 +2742,10 @@ function FilesDiffPanel({
     return () => {
       cancelled = true;
     };
-  }, [laneId]);
+  }, [active, laneId]);
 
   useEffect(() => {
+    if (!active) return;
     let cancelled = false;
     setError(null);
 
@@ -2773,7 +2788,7 @@ function FilesDiffPanel({
     return () => {
       cancelled = true;
     };
-  }, [laneId, path, mode, compareRef]);
+  }, [active, laneId, path, mode, compareRef]);
 
   return (
     <div className="flex h-full flex-col" style={{ background: COLORS.cardBg, backdropFilter: "blur(20px)", WebkitBackdropFilter: "blur(20px)", borderRadius: 12 }}>
diff --git a/apps/desktop/src/renderer/components/graph/WorkspaceGraphPage.tsx b/apps/desktop/src/renderer/components/graph/WorkspaceGraphPage.tsx
index 506ec7c06..a5cb762d8 100644
--- a/apps/desktop/src/renderer/components/graph/WorkspaceGraphPage.tsx
+++ b/apps/desktop/src/renderer/components/graph/WorkspaceGraphPage.tsx
@@ -119,7 +119,7 @@ const MERGE_SUCCESS_ANIMATION_MS = 1200;
 const GRAPH_ACTIVITY_SESSION_LIMIT = 150;
 const GRAPH_ACTIVITY_OPERATION_LIMIT = 150;
 
-function GraphInner() {
+function GraphInner({ active = true }: { active?: boolean }) {
   const navigate = useNavigate();
   const [searchParams, setSearchParams] = useSearchParams();
   const reactFlow = useReactFlow<Node<GraphNodeData>, Edge<GraphEdgeData>>();
@@ -363,8 +363,9 @@ function GraphInner() {
   }, [viewMode]);
 
   React.useEffect(() => {
+    if (!active) return;
     void refreshEnvironmentMappings();
-  }, [project?.rootPath, refreshEnvironmentMappings]);
+  }, [active, project?.rootPath, refreshEnvironmentMappings]);
 
   const riskRefreshTimerRef = React.useRef<number | null>(null);
   const dragOriginRef = React.useRef<Map<string, { x: number; y: number }>>(new Map());
@@ -686,8 +687,9 @@ function GraphInner() {
         return;
       }
       const includeOperations = options?.includeOperations ?? true;
+      const projectRoot = project?.rootPath ?? null;
       const [sessions, operations] = await Promise.all([
-        listSessionsCached({ limit: GRAPH_ACTIVITY_SESSION_LIMIT }).then((rows) =>
+        listSessionsCached({ limit: GRAPH_ACTIVITY_SESSION_LIMIT }, { projectRoot }).then((rows) =>
           rows.filter((session) => !isRunOwnedSession(session)),
         ),
         includeOperations
@@ -738,7 +740,7 @@ function GraphInner() {
     } catch {
       // ignore
     }
-  }, []);
+  }, [project?.rootPath]);
 
   const scheduleRefreshActivity = React.useCallback((delayMs = 700, options?: { includeOperations?: boolean }) => {
     if (options?.includeOperations !== false) {
@@ -768,6 +770,7 @@ function GraphInner() {
   }, [refreshActivity]);
 
   React.useEffect(() => {
+    if (!active) return;
     if (!project?.rootPath) return;
     let cancelled = false;
     let riskTimer: number | null = null;
@@ -814,9 +817,10 @@ function GraphInner() {
       if (syncTimer != null) window.clearTimeout(syncTimer);
       if (autoRebaseTimer != null) window.clearTimeout(autoRebaseTimer);
     };
-  }, [project?.rootPath, refreshAutoRebaseStatuses, refreshGraphLanes, refreshLaneSyncStatuses, refreshRiskBatch, reportGraphIssue, scheduleRefreshActivity]);
+  }, [active, project?.rootPath, refreshAutoRebaseStatuses, refreshGraphLanes, refreshLaneSyncStatuses, refreshRiskBatch, reportGraphIssue, scheduleRefreshActivity]);
 
   React.useEffect(() => {
+    if (!active) return;
     let cancelled = false;
     const initialPrTimer = window.setTimeout(() => {
       if (cancelled || document.visibilityState !== "visible") return;
@@ -842,13 +846,15 @@ function GraphInner() {
         // noop
       }
     };
-  }, [refreshPrs, reportGraphIssue, scheduleRefreshPrs]);
+  }, [active, refreshPrs, reportGraphIssue, scheduleRefreshPrs]);
 
   React.useEffect(() => {
+    if (!active) return;
     void refreshIntegrationProposals();
-  }, [lanesKey, refreshIntegrationProposals]);
+  }, [active, lanesKey, refreshIntegrationProposals]);
 
   React.useEffect(() => {
+    if (!active) return;
     let unsub = () => {};
     try {
       unsub = window.ade.prs.onEvent((event) => {
@@ -870,9 +876,10 @@ function GraphInner() {
         // noop
       }
     };
-  }, [refreshIntegrationProposals, reportGraphIssue]);
+  }, [active, refreshIntegrationProposals, reportGraphIssue]);
 
   React.useEffect(() => {
+    if (!active) return;
     if (!project?.rootPath) {
       setLoadedGraphPreferences(false);
       skipNextGraphPreferencePersistRootRef.current = null;
@@ -904,16 +911,17 @@ function GraphInner() {
     return () => {
       cancelled = true;
     };
-  }, [project?.rootPath]);
+  }, [active, project?.rootPath]);
 
   React.useEffect(() => {
+    if (!active) return;
     if (!project?.rootPath || !loadedGraphPreferences) return;
     if (skipNextGraphPreferencePersistRootRef.current === project.rootPath) {
       skipNextGraphPreferencePersistRootRef.current = null;
       return;
     }
     void window.ade.graphState.set(project.rootPath, createGraphPreferences(viewMode)).catch(() => {});
-  }, [loadedGraphPreferences, project?.rootPath, viewMode]);
+  }, [active, loadedGraphPreferences, project?.rootPath, viewMode]);
 
   React.useEffect(() => {
     if (!undoToast) return;
@@ -1088,6 +1096,7 @@ function GraphInner() {
   }, [selectedLaneIds]);
 
   React.useEffect(() => {
+    if (!active) return;
     let unsubConflict = () => {};
     let unsubPtyData = () => {};
     let unsubPtyExit = () => {};
@@ -1187,7 +1196,7 @@ function GraphInner() {
         prRefreshTimerRef.current = null;
       }
     };
-  }, [project?.rootPath, refreshLaneSyncStatuses, refreshGraphLanes, refreshRiskBatch, refreshAutoRebaseStatuses, reportGraphIssue, scheduleRefreshActivity, scheduleRefreshPrs]);
+  }, [active, project?.rootPath, refreshLaneSyncStatuses, refreshGraphLanes, refreshRiskBatch, refreshAutoRebaseStatuses, reportGraphIssue, scheduleRefreshActivity, scheduleRefreshPrs]);
 
   const baseGraph = React.useMemo(() => {
     if (!loadedGraphPreferences) {
@@ -1518,6 +1527,7 @@ function GraphInner() {
   ]);
 
   React.useEffect(() => {
+    if (!active) return;
     if (!loadedGraphPreferences) return;
     if (nodeDragActiveRef.current) return;
     const edgeVisualState = (edgeId: string, source: string, target: string) => {
@@ -2663,7 +2673,7 @@ function GraphInner() {
       void reactFlow.fitView({ duration: 500, padding: 0.2 });
     }, 0);
     return () => window.clearTimeout(timer);
-  }, [activeSnapshot.updatedAt, edges.length, loadedGraphPreferences, nodes.length, reactFlow, viewMode]);
+  }, [active, activeSnapshot.updatedAt, edges.length, loadedGraphPreferences, nodes.length, reactFlow, viewMode]);
 
   const hoveredTooltipLane = nodeTooltip ? laneById.get(nodeTooltip.laneId) ?? null : null;
   const activeViewMeta = VIEW_MODE_META[viewMode];
@@ -4500,11 +4510,11 @@ function GraphInner() {
   );
 }
 
-export function WorkspaceGraphPage() {
+export function WorkspaceGraphPage({ active = true }: { active?: boolean } = {}) {
   return (
     <div className="h-full">
       <ReactFlowProvider>
-        <GraphInner />
+        <GraphInner active={active} />
       </ReactFlowProvider>
     </div>
   );
diff --git a/apps/desktop/src/renderer/components/history/HistoryPage.tsx b/apps/desktop/src/renderer/components/history/HistoryPage.tsx
index 22d09494d..dccbd3069 100644
--- a/apps/desktop/src/renderer/components/history/HistoryPage.tsx
+++ b/apps/desktop/src/renderer/components/history/HistoryPage.tsx
@@ -1,4 +1,4 @@
-import React, { Suspense, useEffect, useCallback } from "react";
+import React, { Suspense, useEffect, useCallback, useRef } from "react";
 import { useNavigate, useSearchParams } from "react-router-dom";
 import { Clock } from "@phosphor-icons/react";
 import { useAppStore } from "../../state/appStore";
@@ -11,7 +11,12 @@ import {
 import { TimelineToolbar } from "./TimelineToolbar";
 import { TimelineListView } from "./TimelineListView";
 import { TimelineCompactView } from "./TimelineCompactView";
-import { useTimelineStore } from "./useTimelineStore";
+import {
+  TimelineStoreProvider,
+  createTimelineStore,
+  useTimelineStore,
+  type TimelineStoreApi,
+} from "./useTimelineStore";
 import type { TimelineEvent } from "./timelineTypes";
 
 const TimelineGraph = React.lazy(async () => {
@@ -34,7 +39,19 @@ const HISTORY_TILING_TREE: PaneSplit = {
   ],
 };
 
-export function HistoryPage() {
+export function HistoryPage({ active = true }: { active?: boolean } = {}) {
+  const storeRef = useRef<TimelineStoreApi | null>(null);
+  if (!storeRef.current) {
+    storeRef.current = createTimelineStore();
+  }
+  return (
+    <TimelineStoreProvider store={storeRef.current}>
+      <HistoryPageContent active={active} />
+    </TimelineStoreProvider>
+  );
+}
+
+function HistoryPageContent({ active = true }: { active?: boolean } = {}) {
   const navigate = useNavigate();
   const [searchParams, setSearchParams] = useSearchParams();
 
@@ -55,11 +72,13 @@ export function HistoryPage() {
 
   // ── Initial fetch & auto-refresh ───────────────────────────
   useEffect(() => {
+    if (!active) return;
     void fetchEvents();
-  }, [fetchEvents]);
+  }, [active, fetchEvents]);
 
   // Auto-refresh while operations are actively running, but keep it quiet.
   useEffect(() => {
+    if (!active) return;
     const hasRunning = events.some((e) => e.status === "running");
     if (!hasRunning) return;
     const refresh = () => {
@@ -76,9 +95,10 @@ export function HistoryPage() {
       window.removeEventListener("focus", onFocus);
       document.removeEventListener("visibilitychange", onVisibilityChange);
     };
-  }, [events, fetchEvents]);
+  }, [active, events, fetchEvents]);
 
   useEffect(() => {
+    if (!active) return;
     const refresh = () => {
       if (document.visibilityState !== "visible") return;
       void fetchEvents({ silent: true });
@@ -89,7 +109,7 @@ export function HistoryPage() {
       window.removeEventListener("focus", refresh);
       document.removeEventListener("visibilitychange", refresh);
     };
-  }, [fetchEvents]);
+  }, [active, fetchEvents]);
 
   // ── URL sync: read selectedEventId from search params ──────
   useEffect(() => {
diff --git a/apps/desktop/src/renderer/components/history/useTimelineStore.ts b/apps/desktop/src/renderer/components/history/useTimelineStore.ts
index 3586f04d2..dc4abc29f 100644
--- a/apps/desktop/src/renderer/components/history/useTimelineStore.ts
+++ b/apps/desktop/src/renderer/components/history/useTimelineStore.ts
@@ -1,4 +1,7 @@
-import { create } from "zustand";
+import React, { createContext, useContext, type ReactNode } from "react";
+import { useStore } from "zustand";
+import { createStore, type StoreApi } from "zustand/vanilla";
+import type { StateCreator } from "zustand";
 import type { OperationRecord } from "../../../shared/types";
 import type {
   ColumnConfig,
@@ -109,7 +112,7 @@ function passesFilters(
 
 // ── Store Type ───────────────────────────────────────────────────
 
-type TimelineStore = {
+export type TimelineStore = {
   // ── Raw data ────────────────────────────────────────────────
   rawEvents: OperationRecord[];
   /** Enriched + filtered events ready for rendering */
@@ -183,7 +186,7 @@ const DEFAULT_VISIBILITY: LaneVisibility = {
 
 // ── Store ────────────────────────────────────────────────────────
 
-export const useTimelineStore = create<TimelineStore>((set, get) => {
+const createTimelineState: StateCreator<TimelineStore> = (set, get) => {
   /** Re-derive filtered events from raw data + current filters. */
   function refilter() {
     const { rawEvents, filters, visibility, scope } = get();
@@ -335,4 +338,39 @@ export const useTimelineStore = create<TimelineStore>((set, get) => {
       refilter();
     },
   };
-});
+};
+
+export type TimelineStoreApi = StoreApi<TimelineStore>;
+
+const rootTimelineStore = createStore<TimelineStore>()(createTimelineState);
+const TimelineStoreContext = createContext<TimelineStoreApi | null>(null);
+
+export function createTimelineStore(): TimelineStoreApi {
+  return createStore<TimelineStore>()(createTimelineState);
+}
+
+export function TimelineStoreProvider({
+  store,
+  children,
+}: {
+  store: TimelineStoreApi;
+  children: ReactNode;
+}) {
+  return React.createElement(TimelineStoreContext.Provider, { value: store }, children);
+}
+
+type TimelineStoreHook = {
+  <T>(selector: (state: TimelineStore) => T): T;
+  getState: TimelineStoreApi["getState"];
+  setState: TimelineStoreApi["setState"];
+  subscribe: TimelineStoreApi["subscribe"];
+};
+
+export const useTimelineStore = ((selector: (state: TimelineStore) => unknown) => {
+  const store = useContext(TimelineStoreContext) ?? rootTimelineStore;
+  return useStore(store, selector);
+}) as TimelineStoreHook;
+
+useTimelineStore.getState = rootTimelineStore.getState;
+useTimelineStore.setState = rootTimelineStore.setState;
+useTimelineStore.subscribe = rootTimelineStore.subscribe;
diff --git a/apps/desktop/src/renderer/components/lanes/LanesPage.tsx b/apps/desktop/src/renderer/components/lanes/LanesPage.tsx
index 1d81c7e66..a116da212 100644
--- a/apps/desktop/src/renderer/components/lanes/LanesPage.tsx
+++ b/apps/desktop/src/renderer/components/lanes/LanesPage.tsx
@@ -3,7 +3,7 @@ import { useClickOutside } from "../../hooks/useClickOutside";
 import { useLocation, useNavigate, useSearchParams } from "react-router-dom";
 import { Group, Panel } from "react-resizable-panels";
 import { Check, CaretDown, FileCode, GitBranch, GitPullRequest, House, Stack, Link, ArrowsOutSimple, ArrowsInSimple, PushPin, Plus, MagnifyingGlass, Terminal, X, ArrowSquareOut, Info, ArrowCounterClockwise, UsersThree, CircleNotch } from "@phosphor-icons/react";
-import { useAppStore, type LaneInspectorTab } from "../../state/appStore";
+import { useAppStore, useAppStoreApi, type LaneInspectorTab } from "../../state/appStore";
 import { buildIntegrationSourcesByLaneId } from "../../lib/integrationLanes";
 import { EmptyState } from "../ui/EmptyState";
 import { Button } from "../ui/Button";
@@ -247,7 +247,8 @@ function laneTilingLayoutIds(laneId: string): string[] {
 
 /* ---- Component ---- */
 
-export function LanesPage() {
+export function LanesPage({ active = true }: { active?: boolean } = {}) {
+  const appStore = useAppStoreApi();
   const [params] = useSearchParams();
   const location = useLocation();
   const navigate = useNavigate();
@@ -412,6 +413,7 @@ export function LanesPage() {
   }, []);
 
   useEffect(() => {
+    if (!active) return;
     const projectRoot = project?.rootPath ?? null;
     const previousProjectRoot = deleteProgressProjectRootRef.current;
     deleteProgressProjectRootRef.current = projectRoot;
@@ -665,7 +667,7 @@ export function LanesPage() {
     // — otherwise lane A's branches linger when the user switches to lane B
     // before the new fetch resolves.
     setLaneBranches([]);
-    if (!branchLane || !branchDropdownOpen) return;
+    if (!active || !branchLane || !branchDropdownOpen) return;
     let cancelled = false;
     setLaneBranchesLoading(true);
     window.ade.git.listBranches({ laneId: branchLane.id })
@@ -673,14 +675,14 @@ export function LanesPage() {
       .catch(() => { if (!cancelled) setLaneBranches([]); })
       .finally(() => { if (!cancelled) setLaneBranchesLoading(false); });
     return () => { cancelled = true; };
-  }, [branchDropdownOpen, branchLane?.id]);
+  }, [active, branchDropdownOpen, branchLane?.id]);
 
   useEffect(() => {
-    if (!branchLane) return;
+    if (!active || !branchLane) return;
     const current = laneBranches.find((branch) => branch.isCurrent && !branch.isRemote)?.name ?? null;
     if (!current || current === branchLane.branchRef) return;
     refreshLanes().catch(() => {});
-  }, [laneBranches, branchLane?.id, branchLane?.branchRef, refreshLanes]);
+  }, [active, laneBranches, branchLane?.id, branchLane?.branchRef, refreshLanes]);
 
   useEffect(() => {
     if (branchDropdownOpen) {
@@ -721,33 +723,33 @@ export function LanesPage() {
 
   const refreshLanePrTags = useCallback(async () => {
     const requestId = ++lanePrTagsRequestRef.current;
-    const startedRoot = useAppStore.getState().project?.rootPath ?? null;
+    const startedRoot = appStore.getState().project?.rootPath ?? null;
     try {
       const prs = await window.ade.prs.listAll();
       if (requestId !== lanePrTagsRequestRef.current) return;
-      if ((useAppStore.getState().project?.rootPath ?? null) !== startedRoot) return;
+      if ((appStore.getState().project?.rootPath ?? null) !== startedRoot) return;
       setLanePrTags(prs);
     } catch {
       if (requestId !== lanePrTagsRequestRef.current) return;
-      if ((useAppStore.getState().project?.rootPath ?? null) !== startedRoot) return;
+      if ((appStore.getState().project?.rootPath ?? null) !== startedRoot) return;
       setLanePrTags([]);
     }
-  }, []);
+  }, [appStore]);
 
   const refreshLaneGithubPrTags = useCallback(async (options?: { force?: boolean }) => {
     const requestId = ++laneGithubPrTagsRequestRef.current;
-    const startedRoot = useAppStore.getState().project?.rootPath ?? null;
+    const startedRoot = appStore.getState().project?.rootPath ?? null;
     try {
       const snapshot = await window.ade.prs.getGitHubSnapshot({ force: options?.force === true });
       if (requestId !== laneGithubPrTagsRequestRef.current) return;
-      if ((useAppStore.getState().project?.rootPath ?? null) !== startedRoot) return;
+      if ((appStore.getState().project?.rootPath ?? null) !== startedRoot) return;
       setLaneGithubPrTags(snapshot.repoPullRequests);
     } catch {
       if (requestId !== laneGithubPrTagsRequestRef.current) return;
-      if ((useAppStore.getState().project?.rootPath ?? null) !== startedRoot) return;
+      if ((appStore.getState().project?.rootPath ?? null) !== startedRoot) return;
       // Keep the last usable GitHub snapshot visible on transient refresh failures.
     }
-  }, []);
+  }, [appStore]);
 
   const pushConflictChips = useCallback((chips: ConflictChip[]) => {
     if (chips.length === 0) return;
@@ -822,6 +824,7 @@ export function LanesPage() {
   useEffect(() => { manageOpenRef.current = manageOpen; }, [manageOpen]);
 
   useEffect(() => {
+    if (!active) return;
     const unsubscribe = window.ade.lanes.onDeleteEvent((event) => {
       const { laneId, overallStatus } = event.progress;
       setDeleteProgressByLaneId((prev) => {
@@ -870,9 +873,10 @@ export function LanesPage() {
       queueLaneDeleteRefresh([laneId]);
     });
     return unsubscribe;
-  }, [clearLaneInspectorTab, queueLaneDeleteRefresh, selectLane, setDeleteProgressByLaneId]);
+  }, [active, clearLaneInspectorTab, queueLaneDeleteRefresh, selectLane, setDeleteProgressByLaneId]);
 
   useEffect(() => {
+    if (!active) return;
     const unsubscribe = window.ade.conflicts.onEvent((event) => {
       if (event.type !== "prediction-complete") return;
       // Only refresh conflict statuses — avoid a full refreshLanes() which fires
@@ -881,37 +885,40 @@ export function LanesPage() {
         const conflictByLaneId = new Map(
           assessment.lanes.map((entry) => [entry.laneId, entry] as const),
         );
-        const prev = useAppStore.getState().laneSnapshots;
+        const prev = appStore.getState().laneSnapshots;
         const next = prev.map((snapshot) => {
           const updated = conflictByLaneId.get(snapshot.lane.id) ?? null;
           return updated !== snapshot.conflictStatus
             ? { ...snapshot, conflictStatus: updated }
             : snapshot;
         });
-        useAppStore.setState({ laneSnapshots: next });
+        appStore.setState({ laneSnapshots: next });
       }).catch((err) => { console.error("getBatchAssessment failed:", err); });
       pushConflictChips(event.chips);
     });
     return unsubscribe;
-  }, [pushConflictChips]);
+  }, [active, appStore, pushConflictChips]);
 
   useEffect(() => {
+    if (!active) return;
     const unsubscribe = window.ade.lanes.onRebaseSuggestionsEvent((event) => {
       if (event.type !== "rebase-suggestions-updated") return;
       void refreshLanes().catch(() => {});
     });
     return unsubscribe;
-  }, [refreshLanes]);
+  }, [active, refreshLanes]);
 
   useEffect(() => {
+    if (!active) return;
     const unsubscribe = window.ade.lanes.onAutoRebaseEvent((event) => {
       if (event.type !== "auto-rebase-updated") return;
       void refreshLanes().catch(() => {});
     });
     return unsubscribe;
-  }, [refreshLanes]);
+  }, [active, refreshLanes]);
 
   useEffect(() => {
+    if (!active) return;
     const unsubscribe = window.ade.lanes.rebaseSubscribe((event) => {
       if (event.type !== "rebase-run-updated") return;
       if (event.run.state !== "failed" || !event.run.failedLaneId) return;
@@ -919,28 +926,30 @@ export function LanesPage() {
       setRebaseSuggestionError(`Rebase needs attention for ${failedLane}. ${event.run.error ?? ""}`.trim());
     });
     return unsubscribe;
-  }, [lanesById]);
+  }, [active, lanesById]);
 
   useEffect(() => {
+    if (!active) return;
     const timer = window.setTimeout(() => {
       void refreshAutoRebaseEnabled();
     }, 120);
     return () => window.clearTimeout(timer);
-  }, [refreshAutoRebaseEnabled]);
+  }, [active, refreshAutoRebaseEnabled]);
 
   useEffect(() => {
+    if (!active) return;
     const timer = window.setTimeout(() => {
       void refreshIntegrationProposals();
     }, 140);
     return () => window.clearTimeout(timer);
-  }, [refreshIntegrationProposals, project?.rootPath]);
+  }, [active, refreshIntegrationProposals, project?.rootPath]);
 
   useEffect(() => {
     lanePrTagsRequestRef.current += 1;
     laneGithubPrTagsRequestRef.current += 1;
     setLanePrTags([]);
     setLaneGithubPrTags([]);
-    if (!project?.rootPath) {
+    if (!active || !project?.rootPath) {
       return;
     }
     const timer = window.setTimeout(() => {
@@ -952,9 +961,10 @@ export function LanesPage() {
       laneGithubPrTagsRequestRef.current += 1;
       window.clearTimeout(timer);
     };
-  }, [refreshLanePrTags, refreshLaneGithubPrTags, project?.rootPath, lanePrBranchSignature]);
+  }, [active, refreshLanePrTags, refreshLaneGithubPrTags, project?.rootPath, lanePrBranchSignature]);
 
   useEffect(() => {
+    if (!active) return;
     return window.ade.prs.onEvent((event) => {
       if (event.type === "prs-updated") {
         lanePrTagsRequestRef.current += 1;
@@ -966,9 +976,10 @@ export function LanesPage() {
         void refreshLaneGithubPrTags({ force: true });
       }
     });
-  }, [refreshLanePrTags, refreshLaneGithubPrTags]);
+  }, [active, refreshLanePrTags, refreshLaneGithubPrTags]);
 
   useEffect(() => {
+    if (!active) return;
     let timer: ReturnType<typeof setTimeout> | null = null;
     const refreshRuntimeOnly = () =>
       refreshLanes({
@@ -1020,7 +1031,7 @@ export function LanesPage() {
       }
       window.clearInterval(intervalId);
     };
-  }, [project?.rootPath, refreshLanes]);
+  }, [active, project?.rootPath, refreshLanes]);
 
   useEffect(() => {
     hasActiveLaneRuntimeRef.current = laneSnapshots.some((snapshot) =>
@@ -1029,6 +1040,7 @@ export function LanesPage() {
   }, [laneSnapshots]);
 
   useEffect(() => {
+    if (!active) return;
     const onFocus = () => { void refreshAutoRebaseEnabled(); };
     const onVisibilityChange = () => {
       if (document.visibilityState === "visible") void refreshAutoRebaseEnabled();
@@ -1039,7 +1051,7 @@ export function LanesPage() {
       window.removeEventListener("focus", onFocus);
       document.removeEventListener("visibilitychange", onVisibilityChange);
     };
-  }, [refreshAutoRebaseEnabled]);
+  }, [active, refreshAutoRebaseEnabled]);
 
   useEffect(() => {
     const pendingLaneDeleteRefreshIds = pendingLaneDeleteRefreshIdsRef.current;
@@ -1437,7 +1449,7 @@ export function LanesPage() {
     if (hydratedLaneDeleteProgressProjectRef.current === projectRoot) return;
     hydratedLaneDeleteProgressProjectRef.current = projectRoot;
     let cancelled = false;
-    const getStoredActiveLaneIds = () => Object.values(useAppStore.getState().laneDeleteProgressByLaneId)
+    const getStoredActiveLaneIds = () => Object.values(appStore.getState().laneDeleteProgressByLaneId)
       .filter(isLaneDeleteProgressActive)
       .map((progress) => progress.laneId);
     const recoverStoredActiveLaneDeletes = () => {
@@ -1489,7 +1501,7 @@ export function LanesPage() {
     return () => {
       cancelled = true;
     };
-  }, [project?.rootPath, moveAwayFromDeletingLanes, queueLaneDeleteRefresh, setDeleteProgressByLaneId]);
+  }, [active, appStore, project?.rootPath, moveAwayFromDeletingLanes, queueLaneDeleteRefresh, setDeleteProgressByLaneId]);
 
   const deleteManagedLanes = async () => {
     const targets = isBatchManage ? managedLanes : managedLane ? [managedLane] : [];
@@ -1802,45 +1814,45 @@ export function LanesPage() {
   }, [lanesById, navigate, refreshLanes, requestPushSelection, requestRebaseScope]);
 
   const hideRebaseSuggestionLocally = useCallback((laneId: string) => {
-    useAppStore.setState((prev) => ({
+    appStore.setState((prev) => ({
       laneSnapshots: prev.laneSnapshots.map((snapshot) =>
         snapshot.lane.id === laneId ? { ...snapshot, rebaseSuggestion: null } : snapshot
       ),
     }));
-  }, []);
+  }, [appStore]);
 
   const hideAutoRebaseStatusLocally = useCallback((laneId: string) => {
-    useAppStore.setState((prev) => ({
+    appStore.setState((prev) => ({
       laneSnapshots: prev.laneSnapshots.map((snapshot) =>
         snapshot.lane.id === laneId ? { ...snapshot, autoRebaseStatus: null } : snapshot
       ),
     }));
-  }, []);
+  }, [appStore]);
 
   const restoreRebaseSuggestionLocally = useCallback((laneId: string, suggestion: LaneListSnapshot["rebaseSuggestion"]) => {
     if (!suggestion) return;
-    useAppStore.setState((prev) => ({
+    appStore.setState((prev) => ({
       laneSnapshots: prev.laneSnapshots.map((snapshot) =>
         snapshot.lane.id === laneId && snapshot.rebaseSuggestion == null
           ? { ...snapshot, rebaseSuggestion: suggestion }
           : snapshot
       ),
     }));
-  }, []);
+  }, [appStore]);
 
   const restoreAutoRebaseStatusLocally = useCallback((laneId: string, status: LaneListSnapshot["autoRebaseStatus"]) => {
     if (!status) return;
-    useAppStore.setState((prev) => ({
+    appStore.setState((prev) => ({
       laneSnapshots: prev.laneSnapshots.map((snapshot) =>
         snapshot.lane.id === laneId && snapshot.autoRebaseStatus == null
           ? { ...snapshot, autoRebaseStatus: status }
           : snapshot
       ),
     }));
-  }, []);
+  }, [appStore]);
 
   const dismissRebaseSuggestion = async (laneId: string) => {
-    const previous = useAppStore.getState().laneSnapshots.find((snapshot) => snapshot.lane.id === laneId)?.rebaseSuggestion ?? null;
+    const previous = appStore.getState().laneSnapshots.find((snapshot) => snapshot.lane.id === laneId)?.rebaseSuggestion ?? null;
     setRebaseSuggestionError(null);
     hideRebaseSuggestionLocally(laneId);
     try {
@@ -1852,7 +1864,7 @@ export function LanesPage() {
   };
 
   const dismissAutoRebaseStatus = async (laneId: string) => {
-    const previous = useAppStore.getState().laneSnapshots.find((snapshot) => snapshot.lane.id === laneId)?.autoRebaseStatus ?? null;
+    const previous = appStore.getState().laneSnapshots.find((snapshot) => snapshot.lane.id === laneId)?.autoRebaseStatus ?? null;
     setRebaseSuggestionError(null);
     hideAutoRebaseStatusLocally(laneId);
     try {
diff --git a/apps/desktop/src/renderer/components/lanes/useLaneWorkSessions.ts b/apps/desktop/src/renderer/components/lanes/useLaneWorkSessions.ts
index 3277bd594..ace2a24b3 100644
--- a/apps/desktop/src/renderer/components/lanes/useLaneWorkSessions.ts
+++ b/apps/desktop/src/renderer/components/lanes/useLaneWorkSessions.ts
@@ -142,7 +142,7 @@ export function useLaneWorkSessions(laneId: string | null) {
       try {
         const rows = await listSessionsCached(
           { laneId, limit: 200 },
-          options.force ? { force: true } : undefined,
+          { force: Boolean(options.force), projectRoot },
         );
         setSessions(rows.filter((session) => !isRunOwnedSession(session)));
         hasLoadedOnceRef.current = true;
@@ -161,7 +161,7 @@ export function useLaneWorkSessions(laneId: string | null) {
         }
       }
     },
-    [laneId],
+    [laneId, projectRoot],
   );
 
   const scheduleBackgroundRefresh = useCallback((delayMs = 300) => {
diff --git a/apps/desktop/src/renderer/components/missions/InterventionPanel.tsx b/apps/desktop/src/renderer/components/missions/InterventionPanel.tsx
index dbe44cbb6..d5ac314f7 100644
--- a/apps/desktop/src/renderer/components/missions/InterventionPanel.tsx
+++ b/apps/desktop/src/renderer/components/missions/InterventionPanel.tsx
@@ -2,7 +2,7 @@ import { useMemo, useState, useCallback, useEffect } from "react";
 import { Clock, WarningCircle, Check, X, Copy, Eye } from "@phosphor-icons/react";
 import type { MissionIntervention, ClarificationQuestion } from "../../../shared/types";
 import { COLORS, MONO_FONT, SANS_FONT, primaryButton, outlineButton } from "../lanes/laneDesignTokens";
-import { useMissionsStore } from "./useMissionsStore";
+import { useMissionsStore, useMissionsStoreApi } from "./useMissionsStore";
 import { getMissionInterventionOwnerLabel, isRecord } from "./missionHelpers";
 import { relativeWhen } from "../../lib/format";
 import { routeMissionIntervention } from "./missionInterventionRouting";
@@ -75,6 +75,7 @@ export { isQuizIntervention, isBlockingManualInputIntervention };
  * Replaces modal auto-open for a better inline UX. (VAL-UX-005)
  */
 export function InterventionPanel({ compact }: { compact: boolean }) {
+  const missionsStore = useMissionsStoreApi();
   const selectedMission = useMissionsStore((s) => s.selectedMission);
   const steerBusy = useMissionsStore((s) => s.steerBusy);
   const activeInterventionId = useMissionsStore((s) => s.activeInterventionId);
@@ -109,7 +110,7 @@ export function InterventionPanel({ compact }: { compact: boolean }) {
 
   const handleResolve = useCallback(
     async (interventionId: string) => {
-      const s = useMissionsStore.getState();
+      const s = missionsStore.getState();
       if (!s.selectedMission) return;
       const intervention = s.selectedMission.interventions.find((entry) => entry.id === interventionId) ?? null;
       if (isQuizIntervention(intervention)) {
@@ -139,12 +140,12 @@ export function InterventionPanel({ compact }: { compact: boolean }) {
         s.setSteerBusy(false);
       }
     },
-    [responseText, setActiveInterventionId],
+    [missionsStore, responseText, setActiveInterventionId],
   );
 
   const handleDismiss = useCallback(
     async (interventionId: string) => {
-      const s = useMissionsStore.getState();
+      const s = missionsStore.getState();
       if (!s.selectedMission) return;
       s.setSteerBusy(true);
       try {
@@ -163,7 +164,7 @@ export function InterventionPanel({ compact }: { compact: boolean }) {
         s.setSteerBusy(false);
       }
     },
-    [],
+    [missionsStore],
   );
 
   if (!selectedMission || !primaryIntervention) return null;
@@ -207,6 +208,7 @@ function InterventionCard({
   busy: boolean;
   remainingOpenCount: number;
 }) {
+  const missionsStore = useMissionsStoreApi();
   const isBlocking = isBlockingManualInputIntervention(intervention);
   const isSystemLaunchFailure = isSystemLaunchFailureIntervention(intervention);
   const borderColor = isBlocking ? COLORS.warning : COLORS.accentBorder;
@@ -225,9 +227,9 @@ function InterventionCard({
   const typeLabel = intervention.interventionType.replace(/_/g, " ");
 
   const handleViewDetails = useCallback(() => {
-    const s = useMissionsStore.getState();
+    const s = missionsStore.getState();
     routeMissionIntervention(s, intervention);
-  }, [intervention]);
+  }, [intervention, missionsStore]);
 
   const handleCopyError = useCallback(async () => {
     const parts = [
diff --git a/apps/desktop/src/renderer/components/missions/MissionActiveContext.tsx b/apps/desktop/src/renderer/components/missions/MissionActiveContext.tsx
new file mode 100644
index 000000000..bd991144d
--- /dev/null
+++ b/apps/desktop/src/renderer/components/missions/MissionActiveContext.tsx
@@ -0,0 +1,21 @@
+import React, { createContext, useContext } from "react";
+
+const MissionActiveContext = createContext(true);
+
+export function MissionActiveProvider({
+  active,
+  children,
+}: {
+  active: boolean;
+  children: React.ReactNode;
+}) {
+  return (
+    <MissionActiveContext.Provider value={active}>
+      {children}
+    </MissionActiveContext.Provider>
+  );
+}
+
+export function useMissionPageActive(): boolean {
+  return useContext(MissionActiveContext);
+}
diff --git a/apps/desktop/src/renderer/components/missions/MissionChatV2.tsx b/apps/desktop/src/renderer/components/missions/MissionChatV2.tsx
index 692d6fbeb..4e78b5a05 100644
--- a/apps/desktop/src/renderer/components/missions/MissionChatV2.tsx
+++ b/apps/desktop/src/renderer/components/missions/MissionChatV2.tsx
@@ -24,8 +24,9 @@ import { ChatInput } from "./ChatInput";
 import { ChatSurfaceShell } from "../chat/ChatSurfaceShell";
 import { buildChatAppearanceRootStyle } from "../chat/chatAppearance";
 import { useAppStore } from "../../state/appStore";
-import { useMissionsStore } from "./useMissionsStore";
+import { useMissionsStoreApi } from "./useMissionsStore";
 import { resolveWorkerThreadChannelStatus } from "./missionChatChannelModel";
+import { useMissionPageActive } from "./MissionActiveContext";
 
 const BG_PAGE = COLORS.pageBg;
 const THREAD_MESSAGE_PAGE_SIZE = 100;
@@ -133,6 +134,8 @@ type MissionChatV2Props = {
 export const MissionChatV2 = React.memo(function MissionChatV2({
   missionId, missionStatus, runId, runStatus, runMetadata, runView = null, interventions, jumpTarget, onJumpHandled, onOpenIntervention,
 }: MissionChatV2Props) {
+  const missionsStore = useMissionsStoreApi();
+  const active = useMissionPageActive();
   // ── State ──
   const [threads, setThreads] = useState<OrchestratorChatThread[]>([]);
   const [threadMessages, setThreadMessages] = useState<OrchestratorChatMessage[]>([]);
@@ -297,26 +300,28 @@ export const MissionChatV2 = React.memo(function MissionChatV2({
   }, [missionId]);
 
   useEffect(() => {
+    if (!active) return;
     void refreshThreads();
     void refreshWorkers();
-  }, [refreshThreads, refreshWorkers]);
+  }, [active, refreshThreads, refreshWorkers]);
   useEffect(() => {
+    if (!active) return;
     void refreshSelectedMessages();
-  }, [refreshSelectedMessages]);
+  }, [active, refreshSelectedMessages]);
   useMissionPolling(
     useCallback(() => {
       void refreshThreads();
       void refreshWorkers();
     }, [refreshThreads, refreshWorkers]),
     15_000,
-    true,
+    active,
   );
   useMissionPolling(
     useCallback(() => {
       void refreshSelectedMessages();
     }, [refreshSelectedMessages]),
     12_000,
-    Boolean(selectedChannel && selectedChannel.kind !== "global"),
+    active && Boolean(selectedChannel && selectedChannel.kind !== "global"),
   );
 
   // ── Real-time events ──
@@ -326,6 +331,7 @@ export const MissionChatV2 = React.memo(function MissionChatV2({
   useEffect(() => { refreshThreadMessagesRef.current = refreshThreadMessages; }, [refreshThreadMessages]);
 
   useEffect(() => {
+    if (!active) return;
     const unsub = window.ade.orchestrator.onThreadEvent((event) => {
       if (event.missionId !== missionId) return;
       if (event.type === "thread_updated" || event.type === "message_appended" || event.type === "message_updated" || event.type === "worker_replay") {
@@ -344,7 +350,7 @@ export const MissionChatV2 = React.memo(function MissionChatV2({
       }
     });
     return () => { unsub(); if (threadRefreshTimerRef.current !== null) window.clearTimeout(threadRefreshTimerRef.current); if (messageRefreshTimerRef.current !== null) window.clearTimeout(messageRefreshTimerRef.current); };
-  }, [missionId]);
+  }, [active, missionId]);
 
   // ── Jump target handling ──
   useEffect(() => {
@@ -449,11 +455,11 @@ export const MissionChatV2 = React.memo(function MissionChatV2({
   }, [refreshThreadMessages, refreshThreads, selectedChannel]);
 
   const refreshMissionWorkspace = useCallback(async () => {
-    const store = useMissionsStore.getState();
+    const store = missionsStore.getState();
     await store.refreshMissionList({ preserveSelection: true, silent: true });
     await store.loadMissionDetail(missionId);
     await store.loadOrchestratorGraph(missionId);
-  }, [missionId]);
+  }, [missionId, missionsStore]);
 
   const handleRunControl = useCallback(async (action: "pause" | "resume" | "cancel") => {
     if (!runId || runActionBusy) return;
diff --git a/apps/desktop/src/renderer/components/missions/MissionHeader.tsx b/apps/desktop/src/renderer/components/missions/MissionHeader.tsx
index f1f3585a3..f9f3c6a6b 100644
--- a/apps/desktop/src/renderer/components/missions/MissionHeader.tsx
+++ b/apps/desktop/src/renderer/components/missions/MissionHeader.tsx
@@ -30,9 +30,10 @@ import {
   getMissionStatusBadgeConfig,
   usagePercentColor,
 } from "./missionHelpers";
-import { useMissionsStore, type MissionsStore } from "./useMissionsStore";
+import { useMissionsStore, useMissionsStoreApi, type MissionsStore } from "./useMissionsStore";
 import { LaneAccentDot } from "../lanes/LaneAccentDot";
 import { useShallow } from "zustand/react/shallow";
+import { useMissionPageActive } from "./MissionActiveContext";
 
 const TERMINAL_RUN_STATUSES = new Set(["succeeded", "failed", "canceled"]);
 
@@ -55,6 +56,7 @@ const selectHeaderMissionSummary = (s: MissionsStore) => {
 /* ════════════════════ MISSION HEADER ════════════════════ */
 
 export function MissionHeader({ runView }: { runView: MissionRunView | null }) {
+  const missionsStore = useMissionsStoreApi();
   /* ── Grouped selector for render data (VAL-ARCH-008) ── */
   const {
     selectedMission,
@@ -126,15 +128,15 @@ export function MissionHeader({ runView }: { runView: MissionRunView | null }) {
 
   /* ── Actions (access store imperatively to avoid extra subscriptions) ── */
   const openManageMissionDialog = useCallback((mission: MissionSummary) => {
-    const s = useMissionsStore.getState();
+    const s = missionsStore.getState();
     s.setManageMission(mission);
     s.setManageMissionCleanupLanes(false);
     s.setManageMissionError(null);
     s.setManageMissionOpen(true);
-  }, []);
+  }, [missionsStore]);
 
   const handleStartRun = useCallback(async () => {
-    const s = useMissionsStore.getState();
+    const s = missionsStore.getState();
     if (!s.selectedMission) return;
     s.setRunBusy(true);
     try {
@@ -173,10 +175,10 @@ export function MissionHeader({ runView }: { runView: MissionRunView | null }) {
     } finally {
       s.setRunBusy(false);
     }
-  }, []);
+  }, [missionsStore]);
 
   const handlePauseRun = useCallback(async () => {
-    const s = useMissionsStore.getState();
+    const s = missionsStore.getState();
     if (!s.runGraph || !s.selectedMission) return;
     s.setRunBusy(true);
     try {
@@ -188,10 +190,10 @@ export function MissionHeader({ runView }: { runView: MissionRunView | null }) {
     } finally {
       s.setRunBusy(false);
     }
-  }, []);
+  }, [missionsStore]);
 
   const handleCancelRun = useCallback(async () => {
-    const s = useMissionsStore.getState();
+    const s = missionsStore.getState();
     if (!s.runGraph || !s.selectedMission) return;
     s.setRunBusy(true);
     try {
@@ -203,10 +205,10 @@ export function MissionHeader({ runView }: { runView: MissionRunView | null }) {
     } finally {
       s.setRunBusy(false);
     }
-  }, []);
+  }, [missionsStore]);
 
   const handleResumeRun = useCallback(async () => {
-    const s = useMissionsStore.getState();
+    const s = missionsStore.getState();
     if (!s.runGraph || !s.selectedMission) return;
     s.setRunBusy(true);
     try {
@@ -218,10 +220,10 @@ export function MissionHeader({ runView }: { runView: MissionRunView | null }) {
     } finally {
       s.setRunBusy(false);
     }
-  }, []);
+  }, [missionsStore]);
 
   const handleArchiveMission = useCallback(async () => {
-    const s = useMissionsStore.getState();
+    const s = missionsStore.getState();
     if (!s.selectedMission) return;
     if (!TERMINAL_MISSION_STATUSES.has(s.selectedMission.status)) return;
     if (!window.confirm("Archive this mission? This will remove it from the active list.")) return;
@@ -248,7 +250,7 @@ export function MissionHeader({ runView }: { runView: MissionRunView | null }) {
     } finally {
       s.setCleanupBusy(false);
     }
-  }, []);
+  }, [missionsStore]);
 
   if (!selectedMission) return null;
   const statusBadgeConfig = getMissionStatusBadgeConfig(
@@ -403,11 +405,13 @@ export function MissionProgressBar({ pct }: { pct: number }) {
 /* ────────── Compact Usage Meter (VAL-USAGE-001, VAL-USAGE-004, VAL-USAGE-005) ────────── */
 
 function CompactUsageMeter() {
+  const active = useMissionPageActive();
   const [snapshot, setSnapshot] = useState<UsageSnapshot | null>(null);
   const selectedMission = useMissionsStore((s) => s.selectedMission);
   const [perMissionCost, setPerMissionCost] = useState<number>(0);
 
   useEffect(() => {
+    if (!active) return;
     if (!window.ade?.usage) return;
     // Initial load
     window.ade.usage.getSnapshot().then(setSnapshot).catch(() => {});
@@ -421,10 +425,11 @@ function CompactUsageMeter() {
       window.clearInterval(timer);
       try { unsub(); } catch { /* ignore */ }
     };
-  }, []);
+  }, [active]);
 
   // Per-mission cost sourced from missionBudgetService (VAL-USAGE-005 scrutiny fix)
   useEffect(() => {
+    if (!active) return;
     if (!selectedMission?.id) { setPerMissionCost(0); return; }
     let cancelled = false;
     const fetchBudget = () => {
@@ -440,7 +445,7 @@ function CompactUsageMeter() {
     fetchBudget();
     const timer = window.setInterval(fetchBudget, 120_000);
     return () => { cancelled = true; window.clearInterval(timer); };
-  }, [selectedMission?.id]);
+  }, [active, selectedMission?.id]);
 
   if (!snapshot || snapshot.windows.length === 0) return null;
 
diff --git a/apps/desktop/src/renderer/components/missions/MissionLogsTab.tsx b/apps/desktop/src/renderer/components/missions/MissionLogsTab.tsx
index 59820c40d..51bb38781 100644
--- a/apps/desktop/src/renderer/components/missions/MissionLogsTab.tsx
+++ b/apps/desktop/src/renderer/components/missions/MissionLogsTab.tsx
@@ -2,6 +2,7 @@ import React, { useCallback, useEffect, useMemo, useRef, useState } from "react"
 import type { MissionLogChannel, MissionLogEntry } from "../../../shared/types";
 import { COLORS, MONO_FONT, outlineButton } from "../lanes/laneDesignTokens";
 import { useMissionPolling } from "./useMissionPolling";
+import { useMissionPageActive } from "./MissionActiveContext";
 
 type MissionLogsTabProps = {
   missionId: string;
@@ -56,6 +57,7 @@ export const MissionLogsTab = React.memo(function MissionLogsTab({
   focusInterventionId,
   onFocusHandled,
 }: MissionLogsTabProps) {
+  const active = useMissionPageActive();
   const [selectedChannels, setSelectedChannels] = useState<MissionLogChannel[]>(CHANNELS);
   const [entries, setEntries] = useState<MissionLogEntry[]>([]);
   const [nextCursor, setNextCursor] = useState<string | null>(null);
@@ -98,23 +100,25 @@ export const MissionLogsTab = React.memo(function MissionLogsTab({
   }, [missionId, runId, selectedChannels]);
 
   useEffect(() => {
+    if (!active) return;
     void loadLogs(null);
-  }, [loadLogs, channelKey, missionId, runId]);
+  }, [active, loadLogs, channelKey, missionId, runId]);
 
   useMissionPolling(
     () => {
       void loadLogs(null);
     },
     3_000,
-    Boolean(missionId),
+    active && Boolean(missionId),
   );
 
   useEffect(() => {
+    if (!active) return;
     if (!focusInterventionId) return;
     setSelectedChannels(["interventions"]);
     setHighlightedInterventionId(focusInterventionId);
     onFocusHandled?.();
-  }, [focusInterventionId, onFocusHandled]);
+  }, [active, focusInterventionId, onFocusHandled]);
 
   useEffect(() => {
     focusedEntryRef.current?.scrollIntoView({
diff --git a/apps/desktop/src/renderer/components/missions/MissionTabContainer.test.tsx b/apps/desktop/src/renderer/components/missions/MissionTabContainer.test.tsx
index fb0920b12..a23de7a31 100644
--- a/apps/desktop/src/renderer/components/missions/MissionTabContainer.test.tsx
+++ b/apps/desktop/src/renderer/components/missions/MissionTabContainer.test.tsx
@@ -2,10 +2,14 @@
 
 import React from "react";
 import { fireEvent, render, screen } from "@testing-library/react";
-import { beforeEach, describe, expect, it } from "vitest";
+import { beforeEach, describe, expect, it, vi } from "vitest";
 import { MissionTabNavigation } from "./MissionTabContainer";
 import { initialMissionsState, useMissionsStore } from "./useMissionsStore";
 
+vi.mock("./MissionChatV2", () => ({
+  MissionChatV2: () => null,
+}));
+
 describe("MissionTabNavigation", () => {
   beforeEach(() => {
     useMissionsStore.setState({ ...initialMissionsState, activeTab: "chat" });
diff --git a/apps/desktop/src/renderer/components/missions/MissionTabContainer.tsx b/apps/desktop/src/renderer/components/missions/MissionTabContainer.tsx
index 29458fa61..175c64174 100644
--- a/apps/desktop/src/renderer/components/missions/MissionTabContainer.tsx
+++ b/apps/desktop/src/renderer/components/missions/MissionTabContainer.tsx
@@ -12,7 +12,7 @@ import type {
 import { cn } from "../ui/cn";
 import { COLORS, MONO_FONT, SANS_FONT } from "../lanes/laneDesignTokens";
 import { type WorkspaceTab, isRecord } from "./missionHelpers";
-import { useMissionsStore, type MissionsStore } from "./useMissionsStore";
+import { useMissionsStore, useMissionsStoreApi, type MissionsStore } from "./useMissionsStore";
 import { useShallow } from "zustand/react/shallow";
 
 /* ── Imported tab content components ── */
@@ -115,6 +115,7 @@ const selectPromptInspectorData = (s: MissionsStore) => ({
 /* ════════════════════ TAB CONTENT ════════════════════ */
 
 export function MissionTabContent({ runView }: { runView: MissionRunView | null }) {
+  const missionsStore = useMissionsStoreApi();
   /* ── Grouped selectors (VAL-ARCH-008) ── */
   const {
     selectedMissionId,
@@ -201,7 +202,7 @@ export function MissionTabContent({ runView }: { runView: MissionRunView | null
 
   /* ── Prompt inspectors (imperative store access to avoid extra subscriptions) ── */
   const loadCoordinatorPromptInspector = async () => {
-    const s = useMissionsStore.getState();
+    const s = missionsStore.getState();
     if (!s.runGraph) return;
     s.setCoordinatorPromptLoading(true);
     s.setCoordinatorPromptError(null);
@@ -219,7 +220,7 @@ export function MissionTabContent({ runView }: { runView: MissionRunView | null
   };
 
   const loadWorkerPromptInspector = async (stepId: string) => {
-    const s = useMissionsStore.getState();
+    const s = missionsStore.getState();
     if (!s.runGraph) return;
     s.setWorkerPromptLoading(true);
     s.setWorkerPromptError(null);
@@ -239,7 +240,7 @@ export function MissionTabContent({ runView }: { runView: MissionRunView | null
 
   /* ── Intervention handling (imperative store access) ── */
   const handleOpenIntervention = (interventionId: string) => {
-    const s = useMissionsStore.getState();
+    const s = missionsStore.getState();
     routeMissionIntervention(s, interventionId);
   };
 
@@ -301,10 +302,10 @@ export function MissionTabContent({ runView }: { runView: MissionRunView | null
                 Review the planner summary, milestone or feature groupings, dependency graph, and phase-by-phase work breakdown below. Selected step details stay visible here instead of living in a separate split pane.
               </div>
             </div>
-            <StepDetailPanel step={selectedStep} attempts={selectedStepAttempts} allSteps={runSteps} claims={runClaims} onOpenWorkerThread={(target) => { useMissionsStore.getState().setChatJumpTarget(target); useMissionsStore.getState().setActiveTab("chat"); }} onInspectPrompt={(stepId) => void loadWorkerPromptInspector(stepId)} />
+            <StepDetailPanel step={selectedStep} attempts={selectedStepAttempts} allSteps={runSteps} claims={runClaims} onOpenWorkerThread={(target) => { missionsStore.getState().setChatJumpTarget(target); missionsStore.getState().setActiveTab("chat"); }} onInspectPrompt={(stepId) => void loadWorkerPromptInspector(stepId)} />
             {selectedStep ? <PromptInspectorCard inspector={workerPromptInspector} loading={workerPromptLoading} error={workerPromptError} title="Selected step effective prompt" /> : null}
             <div className="min-h-0 min-w-0 overflow-auto">
-              <PlanTab mission={selectedMission} runGraph={runGraph} attemptsByStep={attemptsByStep} selectedStepId={selectedStepId} onStepSelect={(id) => useMissionsStore.getState().setSelectedStepId(id)} />
+              <PlanTab mission={selectedMission} runGraph={runGraph} attemptsByStep={attemptsByStep} selectedStepId={selectedStepId} onStepSelect={(id) => missionsStore.getState().setSelectedStepId(id)} />
             </div>
           </div>
         )}
@@ -349,7 +350,7 @@ export function MissionTabContent({ runView }: { runView: MissionRunView | null
                     missionId={selectedMission.id}
                     runId={runGraph?.run.id ?? null}
                     focusInterventionId={logsFocusInterventionId}
-                    onFocusHandled={() => useMissionsStore.getState().setLogsFocusInterventionId(null)}
+                    onFocusHandled={() => missionsStore.getState().setLogsFocusInterventionId(null)}
                   />
                 ) : null}
               </div>
@@ -368,7 +369,7 @@ export function MissionTabContent({ runView }: { runView: MissionRunView | null
               runView={runView}
               interventions={selectedMission?.interventions ?? []}
               jumpTarget={chatJumpTarget}
-              onJumpHandled={() => useMissionsStore.getState().setChatJumpTarget(null)}
+              onJumpHandled={() => missionsStore.getState().setChatJumpTarget(null)}
               onOpenIntervention={handleOpenIntervention}
             />
           </div>
diff --git a/apps/desktop/src/renderer/components/missions/MissionThreadMessageList.test.ts b/apps/desktop/src/renderer/components/missions/MissionThreadMessageList.test.ts
index d62219dbe..deeaf25f4 100644
--- a/apps/desktop/src/renderer/components/missions/MissionThreadMessageList.test.ts
+++ b/apps/desktop/src/renderer/components/missions/MissionThreadMessageList.test.ts
@@ -336,15 +336,23 @@ describe("MissionThreadMessageList usage", () => {
     agentListLifecycle.mounts = 0;
     agentListLifecycle.unmounts = 0;
     (useMissionPolling as unknown as Mock).mockClear();
-    globalThis.window.ade = {
-      sessions: {
-        readTranscriptTail: vi.fn(() => Promise.resolve("")),
+    Object.defineProperty(globalThis.window, "ade", {
+      configurable: true,
+      writable: true,
+      value: {
+        sessions: {
+          readTranscriptTail: vi.fn(() => Promise.resolve("")),
+        },
       },
-    } as any;
+    });
   });
 
   afterEach(() => {
-    globalThis.window.ade = originalAde;
+    Object.defineProperty(globalThis.window, "ade", {
+      configurable: true,
+      writable: true,
+      value: originalAde,
+    });
   });
 
   it("passes mission-feed mode when no session is selected", () => {
@@ -365,11 +373,15 @@ describe("MissionThreadMessageList usage", () => {
 
   it("does not read raw transcript tails for closed mission history threads", async () => {
     const readTranscriptTail = vi.fn(() => Promise.resolve(""));
-    globalThis.window.ade = {
-      sessions: {
-        readTranscriptTail,
+    Object.defineProperty(globalThis.window, "ade", {
+      configurable: true,
+      writable: true,
+      value: {
+        sessions: {
+          readTranscriptTail,
+        },
       },
-    } as any;
+    });
 
     render(React.createElement(MissionThreadMessageList, {
       messages: [],
diff --git a/apps/desktop/src/renderer/components/missions/MissionsPage.tsx b/apps/desktop/src/renderer/components/missions/MissionsPage.tsx
index 14bb33de7..c9125c943 100644
--- a/apps/desktop/src/renderer/components/missions/MissionsPage.tsx
+++ b/apps/desktop/src/renderer/components/missions/MissionsPage.tsx
@@ -16,7 +16,14 @@ import { useAppStore } from "../../state/appStore";
 import { MONO_FONT } from "../lanes/laneDesignTokens";
 
 /* ── Store & extracted components ── */
-import { useMissionsStore, type MissionsStore } from "./useMissionsStore";
+import {
+  MissionsStoreProvider,
+  createMissionsStore,
+  useMissionsStore,
+  useMissionsStoreApi,
+  type MissionsStore,
+  type MissionsStoreApi,
+} from "./useMissionsStore";
 import { MissionSidebar } from "./MissionSidebar";
 import { MissionDetailView } from "./MissionDetailView";
 import { ManageMissionDialog, MissionContextMenu } from "./ManageMissionDialog";
@@ -25,6 +32,7 @@ import { MissionSettingsDialog } from "./MissionSettingsDialog";
 import { useMissionPolling } from "./useMissionPolling";
 import { useMissionRunView } from "./useMissionRunView";
 import { filterExecutionSteps } from "./missionHelpers";
+import { MissionActiveProvider } from "./MissionActiveContext";
 
 import type { CreateDraft, CreateMissionDefaults } from "./CreateMissionDialog";
 import { buildMissionLaunchRequest, prewarmCreateMissionDialogCache } from "./CreateMissionDialog";
@@ -123,10 +131,11 @@ function ProductionMissionsComingSoon() {
   );
 }
 
-function MissionsProductionGate({ children }: { children: React.ReactElement }) {
+function MissionsProductionGate({ active = true, children }: { active?: boolean; children: React.ReactElement }) {
   const [state, setState] = useState<AppPackagingState>("checking");
 
   useEffect(() => {
+    if (!active) return;
     let cancelled = false;
     window.ade.app.getInfo().then(
       (info) => {
@@ -139,7 +148,7 @@ function MissionsProductionGate({ children }: { children: React.ReactElement })
     return () => {
       cancelled = true;
     };
-  }, []);
+  }, [active]);
 
   if (state === "checking") {
     return (
@@ -197,8 +206,9 @@ const selectPageData = (s: MissionsStore) => ({
 
 /* ════════════════════ MAIN COMPONENT ════════════════════ */
 
-function MissionsWorkspace() {
+function MissionsWorkspace({ active = true }: { active?: boolean } = {}) {
   const [searchParams] = useSearchParams();
+  const missionsStore = useMissionsStoreApi();
   const lanes = useAppStore((s) => s.lanes);
   const mappedLanes = useMemo(() => lanes.map((l) => ({ id: l.id, name: l.name })), [lanes]);
   const appliedQueryMissionIdRef = useRef<string | null>(null);
@@ -229,8 +239,9 @@ function MissionsWorkspace() {
 
   /* ── Initial data load ── */
   useEffect(() => {
+    if (!active) return;
     let cancelled = false;
-    const store = useMissionsStore.getState();
+    const store = missionsStore.getState();
     void store.refreshMissionList({ preserveSelection: true });
     const dashboardTimer = window.setTimeout(() => {
       if (cancelled) return;
@@ -240,35 +251,38 @@ function MissionsWorkspace() {
       cancelled = true;
       window.clearTimeout(dashboardTimer);
     };
-  }, []);
+  }, [active, missionsStore]);
 
   useEffect(() => {
+    if (!active) return;
     let cancelled = false;
     const timer = window.setTimeout(() => {
       if (cancelled) return;
-      void useMissionsStore.getState().loadMissionSettings();
+      void missionsStore.getState().loadMissionSettings();
     }, 900);
     return () => {
       cancelled = true;
       window.clearTimeout(timer);
     };
-  }, []);
+  }, [active, missionsStore]);
 
   useEffect(() => {
+    if (!active) return;
     let cancelled = false;
     const timer = window.setTimeout(() => {
       window.ade.orchestrator.getModelCapabilities().then(
-        (result) => { if (!cancelled) useMissionsStore.getState().setModelCapabilities(result); },
-        () => { if (!cancelled) useMissionsStore.getState().setModelCapabilities(null); },
+        (result) => { if (!cancelled) missionsStore.getState().setModelCapabilities(result); },
+        () => { if (!cancelled) missionsStore.getState().setModelCapabilities(null); },
       );
     }, 1_200);
     return () => {
       cancelled = true;
       window.clearTimeout(timer);
     };
-  }, []);
+  }, [active, missionsStore]);
 
   useEffect(() => {
+    if (!active) return;
     let cancelled = false;
     const timer = window.setTimeout(() => {
       if (cancelled) return;
@@ -290,21 +304,24 @@ function MissionsWorkspace() {
       cancelled = true;
       window.clearTimeout(timer);
     };
-  }, []);
+  }, [active]);
 
   /* ── Event subscriptions — delegated to store (VAL-ARCH-007) ── */
   useEffect(() => {
-    const cleanup = useMissionsStore.getState().initEventSubscriptions();
+    if (!active) return;
+    const cleanup = missionsStore.getState().initEventSubscriptions();
     return cleanup;
-  }, []);
+  }, [active, missionsStore]);
 
   /* ── Selection change via consolidated getFullMissionView (VAL-ARCH-004) ── */
   const selectedMissionId = useMissionsStore((s) => s.selectedMissionId);
   useEffect(() => {
-    void useMissionsStore.getState().selectMission(selectedMissionId);
-  }, [selectedMissionId]);
+    if (!active) return;
+    void missionsStore.getState().selectMission(selectedMissionId);
+  }, [active, missionsStore, selectedMissionId]);
 
   useEffect(() => {
+    if (!active) return;
     const missionParam = (searchParams.get("missionId") ?? "").trim();
     if (!missionParam) {
       appliedQueryMissionIdRef.current = null;
@@ -312,33 +329,35 @@ function MissionsWorkspace() {
     }
     if (appliedQueryMissionIdRef.current === missionParam) return;
     appliedQueryMissionIdRef.current = missionParam;
-    void useMissionsStore.getState().selectMission(missionParam);
-  }, [searchParams]);
+    void missionsStore.getState().selectMission(missionParam);
+  }, [active, missionsStore, searchParams]);
 
   /* ── Checkpoint polling via shared coordinator ── */
   const runGraph = useMissionsStore((s) => s.runGraph);
-  const { runView } = useMissionRunView(selectedMissionId, runGraph?.run.id ?? null);
-  const checkpointPollEnabled = Boolean(runGraph && !TERMINAL_RUN_STATUSES.has(runGraph.run.status));
+  const { runView } = useMissionRunView(selectedMissionId, runGraph?.run.id ?? null, active);
+  const checkpointPollEnabled = active && Boolean(runGraph && !TERMINAL_RUN_STATUSES.has(runGraph.run.status));
   const checkpointRunId = runGraph?.run.id ?? null;
   const refreshCheckpointStatus = useCallback(() => {
-    const store = useMissionsStore.getState();
+    const store = missionsStore.getState();
     if (!checkpointRunId) { store.setCheckpointStatus(null); return; }
     void window.ade.orchestrator.getCheckpointStatus({ runId: checkpointRunId }).then(
       (next) => store.setCheckpointStatus(next),
       () => store.setCheckpointStatus(null),
     );
-  }, [checkpointRunId]);
+  }, [checkpointRunId, missionsStore]);
   useMissionPolling(refreshCheckpointStatus, 10_000, checkpointPollEnabled);
   useEffect(() => {
-    if (!checkpointPollEnabled) useMissionsStore.getState().setCheckpointStatus(null);
-  }, [checkpointPollEnabled]);
+    if (!active) return;
+    if (!checkpointPollEnabled) missionsStore.getState().setCheckpointStatus(null);
+  }, [active, checkpointPollEnabled, missionsStore]);
 
   /* ── Step selection reconciliation ── */
   useEffect(() => {
+    if (!active) return;
     const steps = runGraph?.steps ?? [];
     const selectableSteps = filterExecutionSteps(steps);
     const selectionPool = selectableSteps.length > 0 ? selectableSteps : steps;
-    const store = useMissionsStore.getState();
+    const store = missionsStore.getState();
     const currentStepId = store.selectedStepId;
     if (!steps.length) {
       if (currentStepId !== null) store.setSelectedStepId(null);
@@ -347,12 +366,13 @@ function MissionsWorkspace() {
     if (currentStepId && selectionPool.some((s) => s.id === currentStepId)) return;
     const running = selectionPool.find((s) => s.status === "running");
     store.setSelectedStepId((running ?? selectionPool[0]).id);
-  }, [runGraph]);
+  }, [active, missionsStore, runGraph]);
 
   useEffect(() => {
-    useMissionsStore.getState().setCoordinatorPromptInspector(null);
-    useMissionsStore.getState().setWorkerPromptInspector(null);
-  }, [selectedMissionId]);
+    if (!active) return;
+    missionsStore.getState().setCoordinatorPromptInspector(null);
+    missionsStore.getState().setWorkerPromptInspector(null);
+  }, [active, missionsStore, selectedMissionId]);
 
   /* ── Attention toast notifications (timers owned by store, VAL-ARCH-007) ── */
   const selectedMission = useMissionsStore((s) => s.selectedMission);
@@ -360,6 +380,7 @@ function MissionsWorkspace() {
   const prevOpenInterventionCountRef = useRef<number>(0);
 
   useEffect(() => {
+    if (!active) return;
     if (!selectedMission) {
       prevMissionStatusRef.current = null;
       prevOpenInterventionCountRef.current = 0;
@@ -373,7 +394,7 @@ function MissionsWorkspace() {
     prevOpenInterventionCountRef.current = currentOpenCount;
     if (prevStatus === null) return;
 
-    const store = useMissionsStore.getState();
+    const store = missionsStore.getState();
     if (currentStatus === "intervention_required" && prevStatus !== "intervention_required") {
       store.addAttentionToast("Mission requires intervention", "warning", selectedMission.title, selectedMission.id);
     } else if (currentStatus === "failed" && prevStatus !== "failed") {
@@ -386,11 +407,11 @@ function MissionsWorkspace() {
         selectedMission.id,
       );
     }
-  }, [selectedMission?.status, selectedMission?.openInterventions, selectedMission?.id, selectedMission?.title, selectedMission]);
+  }, [active, missionsStore, selectedMission?.status, selectedMission?.openInterventions, selectedMission?.id, selectedMission?.title, selectedMission]);
 
   useEffect(() => {
-    return () => useMissionsStore.getState().cleanupToastTimers();
-  }, []);
+    return () => missionsStore.getState().cleanupToastTimers();
+  }, [missionsStore]);
 
   /* ── Responsive sidebar collapse (VAL-UX-010) ── */
   const [collapsed, setCollapsed] = useState(false);
@@ -407,7 +428,7 @@ function MissionsWorkspace() {
   /* ── Mission launch handler ── */
   const handleLaunchMission = useCallback(
     async (draft: CreateDraft) => {
-      const store = useMissionsStore.getState();
+      const store = missionsStore.getState();
       const prompt = draft.prompt.trim();
       if (!prompt) { store.setError("Mission prompt is required."); return; }
       try {
@@ -428,7 +449,7 @@ function MissionsWorkspace() {
         throw err instanceof Error ? err : new Error(message);
       }
     },
-    [defaultCreateLaneId],
+    [defaultCreateLaneId, missionsStore],
   );
 
   /* ── Loading screen ── */
@@ -507,11 +528,11 @@ function MissionsWorkspace() {
           open={missionSettingsOpen}
           onClose={() => {
             if (missionSettingsBusy) return;
-            useMissionsStore.getState().setMissionSettingsOpen(false);
+            missionsStore.getState().setMissionSettingsOpen(false);
           }}
           draft={missionSettingsDraft}
-          onDraftChange={(update) => useMissionsStore.getState().setMissionSettingsDraft((prev) => ({ ...prev, ...update }))}
-          onSave={() => void useMissionsStore.getState().saveMissionSettings()}
+          onDraftChange={(update) => missionsStore.getState().setMissionSettingsDraft((prev) => ({ ...prev, ...update }))}
+          onSave={() => void missionsStore.getState().saveMissionSettings()}
           busy={missionSettingsBusy}
           error={missionSettingsError}
           notice={missionSettingsNotice}
@@ -522,11 +543,19 @@ function MissionsWorkspace() {
 }
 
 /* Re-export for compatibility: the page was previously a named export */
-export default function MissionsPage() {
+export default function MissionsPage({ active = true }: { active?: boolean } = {}) {
+  const storeRef = useRef<MissionsStoreApi | null>(null);
+  if (!storeRef.current) {
+    storeRef.current = createMissionsStore();
+  }
   return (
-    <MissionsProductionGate>
-      <MissionsWorkspace />
-    </MissionsProductionGate>
+    <MissionsStoreProvider store={storeRef.current}>
+      <MissionActiveProvider active={active}>
+        <MissionsProductionGate active={active}>
+          <MissionsWorkspace active={active} />
+        </MissionsProductionGate>
+      </MissionActiveProvider>
+    </MissionsStoreProvider>
   );
 }
 
diff --git a/apps/desktop/src/renderer/components/missions/ModelSelector.tsx b/apps/desktop/src/renderer/components/missions/ModelSelector.tsx
index 4b0235e55..289d23937 100644
--- a/apps/desktop/src/renderer/components/missions/ModelSelector.tsx
+++ b/apps/desktop/src/renderer/components/missions/ModelSelector.tsx
@@ -14,6 +14,9 @@ type ModelSelectorProps = {
   onOpenAiSettings?: () => void;
   /** Stable id used by the picker to remember per-surface defaults. */
   surfaceKey?: string;
+  fastModeActive?: boolean;
+  onFastModeToggle?: (next: boolean) => void;
+  fastModeSupported?: boolean;
 };
 
 function providerFromFamily(modelId: string): ModelProvider | undefined {
@@ -42,6 +45,9 @@ export function ModelSelector({
   availableModelIds,
   onOpenAiSettings,
   surfaceKey = "missions/phase-or-action",
+  fastModeActive,
+  onFastModeToggle,
+  fastModeSupported,
 }: ModelSelectorProps) {
   const resolvedModelId = useMemo(() => normalizeModelId(value.modelId), [value.modelId]);
   const selectedDescriptor = useMemo(() => getModelById(resolvedModelId), [resolvedModelId]);
@@ -76,6 +82,9 @@ export function ModelSelector({
         compact={compact ?? false}
         {...(availableModelIds ? { availableModelIds } : {})}
         {...(onOpenAiSettings ? { onOpenSignIn: onOpenAiSettings } : {})}
+        {...(fastModeActive !== undefined ? { fastModeActive } : {})}
+        {...(onFastModeToggle ? { onFastModeToggle } : {})}
+        {...(fastModeSupported !== undefined ? { fastModeSupported } : {})}
       />
       <ReasoningEffortPicker
         modelId={effectiveModelId}
diff --git a/apps/desktop/src/renderer/components/missions/OrchestratorActivityFeed.tsx b/apps/desktop/src/renderer/components/missions/OrchestratorActivityFeed.tsx
index 316c5e253..ffcf4d230 100644
--- a/apps/desktop/src/renderer/components/missions/OrchestratorActivityFeed.tsx
+++ b/apps/desktop/src/renderer/components/missions/OrchestratorActivityFeed.tsx
@@ -2,6 +2,7 @@ import React, { useEffect, useRef, useState, useCallback, useMemo } from "react"
 import type { OrchestratorTimelineEvent } from "../../../shared/types";
 import { cn } from "../ui/cn";
 import { NOISY_EVENT_TYPES, classifyErrorSource, ERROR_SOURCE_COLORS, collapseFeedMessages, type CollapsedFeedMessage } from "./missionHelpers";
+import { useMissionPageActive } from "./MissionActiveContext";
 
 type Props = {
   runId: string;
@@ -132,6 +133,7 @@ function collapseTimelineEvents(events: OrchestratorTimelineEvent[]): CollapsedF
 }
 
 export const OrchestratorActivityFeed = React.memo(function OrchestratorActivityFeed({ runId, initialTimeline }: Props) {
+  const active = useMissionPageActive();
   const [events, setEvents] = useState<OrchestratorTimelineEvent[]>(() => sortTimeline(initialTimeline));
   const [category, setCategory] = useState("All Events");
   const [severity, setSeverity] = useState<Severity>("all");
@@ -183,12 +185,14 @@ export const OrchestratorActivityFeed = React.memo(function OrchestratorActivity
   }, [refreshTimeline]);
 
   useEffect(() => {
+    if (!active) return;
     refreshTokenRef.current += 1;
     setEvents(sortTimeline(initialTimeline));
     void refreshTimeline();
-  }, [initialTimeline, refreshTimeline]);
+  }, [active, initialTimeline, refreshTimeline]);
 
   useEffect(() => {
+    if (!active) return;
     const unsub = window.ade.orchestrator.onEvent((ev) => {
       if (ev.runId !== runId) return;
       scheduleTimelineRefresh();
@@ -196,14 +200,15 @@ export const OrchestratorActivityFeed = React.memo(function OrchestratorActivity
     return () => {
       unsub();
     };
-  }, [runId, scheduleTimelineRefresh]);
+  }, [active, runId, scheduleTimelineRefresh]);
 
   useEffect(() => {
+    if (!active) return;
     const interval = window.setInterval(() => {
       void refreshTimeline();
     }, 12_000);
     return () => window.clearInterval(interval);
-  }, [refreshTimeline]);
+  }, [active, refreshTimeline]);
 
   useEffect(() => {
     return () => {
diff --git a/apps/desktop/src/renderer/components/missions/useMissionRunView.ts b/apps/desktop/src/renderer/components/missions/useMissionRunView.ts
index 635aa932b..d2af559e4 100644
--- a/apps/desktop/src/renderer/components/missions/useMissionRunView.ts
+++ b/apps/desktop/src/renderer/components/missions/useMissionRunView.ts
@@ -28,7 +28,7 @@ function getRunViewCoalesced(args: {
   return request;
 }
 
-export function useMissionRunView(missionId: string | null, runId: string | null) {
+export function useMissionRunView(missionId: string | null, runId: string | null, active = true) {
   const [runView, setRunView] = useState<MissionRunView | null>(null);
   const [loading, setLoading] = useState(false);
   const [error, setError] = useState<string | null>(null);
@@ -98,10 +98,11 @@ export function useMissionRunView(missionId: string | null, runId: string | null
       void refresh();
     },
     RUN_VIEW_SAFETY_POLL_MS,
-    Boolean(resolvedMissionId.length),
+    active && Boolean(resolvedMissionId.length),
   );
 
   useEffect(() => {
+    if (!active) return;
     if (!resolvedMissionId.length) return;
     const subscriptionKey = requestKey;
     const unsubscribe = window.ade.missions.subscribeRunView(
@@ -117,7 +118,7 @@ export function useMissionRunView(missionId: string | null, runId: string | null
       pendingRefreshRef.current = false;
       unsubscribe();
     };
-  }, [requestKey, resolvedMissionId, runId]);
+  }, [active, requestKey, resolvedMissionId, runId]);
 
   return { runView, loading, error, refresh };
 }
diff --git a/apps/desktop/src/renderer/components/missions/useMissionsStore.ts b/apps/desktop/src/renderer/components/missions/useMissionsStore.ts
index 2957a79d4..cff50b76e 100644
--- a/apps/desktop/src/renderer/components/missions/useMissionsStore.ts
+++ b/apps/desktop/src/renderer/components/missions/useMissionsStore.ts
@@ -1,4 +1,7 @@
-import { create } from "zustand";
+import React, { createContext, useContext, type ReactNode } from "react";
+import { useStore } from "zustand";
+import { createStore, type StoreApi } from "zustand/vanilla";
+import type { StateCreator } from "zustand";
 import type {
   MissionDetail,
   MissionSummary,
@@ -261,10 +264,6 @@ function isRendererVisible(): boolean {
   return typeof document === "undefined" || document.visibilityState === "visible";
 }
 
-/* ── Toast timer registry (module-scoped, not per-render) ── */
-const toastTimers = new Map<string, number>();
-let missionSelectionRequestSeq = 0;
-
 function buildClearedSelectionState(): Partial<MissionsState> {
   return {
     selectedMissionId: null,
@@ -283,7 +282,11 @@ function buildClearedSelectionState(): Partial<MissionsState> {
 
 /* ════════════════════ STORE CREATION ════════════════════ */
 
-export const useMissionsStore = create<MissionsStore>((set, get) => ({
+const createMissionsState: StateCreator<MissionsStore> = (set, get) => {
+  const toastTimers = new Map<string, number>();
+  let missionSelectionRequestSeq = 0;
+
+  return ({
   ...initialMissionsState,
 
   /* ── Simple setters ── */
@@ -705,7 +708,47 @@ export const useMissionsStore = create<MissionsStore>((set, get) => ({
 
   /* ── Selection reset ── */
   clearSelection: () => set(buildClearedSelectionState()),
-}));
+  });
+};
+
+export type MissionsStoreApi = StoreApi<MissionsStore>;
+
+const rootMissionsStore = createStore<MissionsStore>()(createMissionsState);
+const MissionsStoreContext = createContext<MissionsStoreApi | null>(null);
+
+export function createMissionsStore(): MissionsStoreApi {
+  return createStore<MissionsStore>()(createMissionsState);
+}
+
+export function MissionsStoreProvider({
+  store,
+  children,
+}: {
+  store: MissionsStoreApi;
+  children: ReactNode;
+}) {
+  return React.createElement(MissionsStoreContext.Provider, { value: store }, children);
+}
+
+export function useMissionsStoreApi(): MissionsStoreApi {
+  return useContext(MissionsStoreContext) ?? rootMissionsStore;
+}
+
+type MissionsStoreHook = {
+  <T>(selector: (state: MissionsStore) => T): T;
+  getState: MissionsStoreApi["getState"];
+  setState: MissionsStoreApi["setState"];
+  subscribe: MissionsStoreApi["subscribe"];
+};
+
+export const useMissionsStore = ((selector: (state: MissionsStore) => unknown) => {
+  const store = useMissionsStoreApi();
+  return useStore(store, selector);
+}) as MissionsStoreHook;
+
+useMissionsStore.getState = rootMissionsStore.getState;
+useMissionsStore.setState = rootMissionsStore.setState;
+useMissionsStore.subscribe = rootMissionsStore.subscribe;
 
 /* ════════════════════ FINE-GRAINED SELECTORS ════════════════════ */
 
diff --git a/apps/desktop/src/renderer/components/prs/PRsPage.tsx b/apps/desktop/src/renderer/components/prs/PRsPage.tsx
index 52d2c7aab..c654601c6 100644
--- a/apps/desktop/src/renderer/components/prs/PRsPage.tsx
+++ b/apps/desktop/src/renderer/components/prs/PRsPage.tsx
@@ -491,13 +491,13 @@ function PRsPageInner() {
   );
 }
 
-export function PRsPage() {
+export function PRsPage({ active = true }: { active?: boolean } = {}) {
   const providerKey = useAppStore((state) =>
     state.projectBinding?.key ?? state.project?.rootPath ?? "__no_project__"
   );
 
   return (
-    <PrsProvider key={providerKey}>
+    <PrsProvider key={providerKey} active={active}>
       <PRsPageInner />
     </PrsProvider>
   );
diff --git a/apps/desktop/src/renderer/components/prs/shared/PrMarkdown.tsx b/apps/desktop/src/renderer/components/prs/shared/PrMarkdown.tsx
index 974e300d6..a8c99c0cf 100644
--- a/apps/desktop/src/renderer/components/prs/shared/PrMarkdown.tsx
+++ b/apps/desktop/src/renderer/components/prs/shared/PrMarkdown.tsx
@@ -13,7 +13,6 @@ import rehypeRaw from "rehype-raw";
 import rehypeSanitize, { defaultSchema } from "rehype-sanitize";
 import remarkGfm from "remark-gfm";
 import { findAndReplace } from "mdast-util-find-and-replace";
-import type { Root } from "mdast";
 import { CaretRight, ArrowSquareOut } from "@phosphor-icons/react";
 
 import {
@@ -24,6 +23,7 @@ import { HighlightedCode } from "../../chat/CodeHighlighter";
 import { COLORS } from "../../lanes/laneDesignTokens";
 
 type PrMarkdownTone = "neutral" | "sky" | "amber";
+type MarkdownRoot = Parameters<typeof findAndReplace>[0];
 
 export type PrMarkdownProps = {
   children: string;
@@ -92,7 +92,7 @@ function remarkPrAutolinks({
   repoOwner: string;
   repoName: string;
 }) {
-  return (tree: Root) => {
+  return (tree: MarkdownRoot) => {
     findAndReplace(
       tree,
       [
diff --git a/apps/desktop/src/renderer/components/prs/state/PrsContext.tsx b/apps/desktop/src/renderer/components/prs/state/PrsContext.tsx
index 9059a7e40..04b07d312 100644
--- a/apps/desktop/src/renderer/components/prs/state/PrsContext.tsx
+++ b/apps/desktop/src/renderer/components/prs/state/PrsContext.tsx
@@ -419,7 +419,7 @@ function diffPrIds(prev: PrWithConflicts[], next: PrWithConflicts[]): string[] {
   return [...new Set(changed)];
 }
 
-export function PrsProvider({ children }: { children: React.ReactNode }) {
+export function PrsProvider({ active = true, children }: { active?: boolean; children: React.ReactNode }) {
   const projectRoot = useAppStore((state) => state.project?.rootPath ?? null);
   const cacheKey = prsContextCacheKey(projectRoot);
   const warmCache = useMemo(() => readPrsContextWarmCache(projectRoot), [projectRoot]);
@@ -724,6 +724,7 @@ export function PrsProvider({ children }: { children: React.ReactNode }) {
   const initialLoadDone = React.useRef(Boolean(warmCache));
 
   const refreshQueueStates = useCallback(async (groupIds: string[]) => {
+    if (!active) return;
     const uniqueGroupIds = [...new Set(groupIds.map((groupId) => String(groupId ?? "").trim()).filter(Boolean))];
     if (uniqueGroupIds.length === 0) return;
     await Promise.all(uniqueGroupIds.map(async (groupId) => {
@@ -738,7 +739,7 @@ export function PrsProvider({ children }: { children: React.ReactNode }) {
         console.warn("[PrsContext] Failed to refresh queue state for group:", groupId, err);
       }
     }));
-  }, []);
+  }, [active]);
 
   // Core refresh (guarded against concurrent calls).
   // If a refresh is requested while one is already in flight, we set a
@@ -748,6 +749,7 @@ export function PrsProvider({ children }: { children: React.ReactNode }) {
     includeWorkflowDiagnostics?: boolean;
     forceRebaseDiagnostics?: boolean;
   } = {}) => {
+    if (!active) return;
     const shouldLoadWorkflowState = activeTabRef.current !== "normal";
     const shouldLoadRebaseState = (options.includeWorkflowDiagnostics ?? true)
       && (options.forceRebaseDiagnostics === true || shouldLoadWorkflowState || selectedPrIdRef.current !== null);
@@ -807,9 +809,10 @@ export function PrsProvider({ children }: { children: React.ReactNode }) {
       }
       void refreshQueueStates([...affectedQueueGroupIds]);
     }
-  }, [refreshMergeContexts, refreshQueueStates]);
+  }, [active, refreshMergeContexts, refreshQueueStates]);
 
   const refreshCore = useCallback(async (options: RefreshCoreOptions = {}) => {
+    if (!active) return;
     if (refreshInFlight.current) {
       refreshPending.current = mergeRefreshCoreOptions(refreshPending.current, options);
       return;
@@ -883,17 +886,18 @@ export function PrsProvider({ children }: { children: React.ReactNode }) {
         void refreshCore(pendingRefresh);
       }
     }
-  }, [applyLocalPrState]);
+  }, [active, applyLocalPrState]);
 
   // Initial load
   useEffect(() => {
+    if (!active) return;
     const shouldRefreshFromGithub =
       activeTabRef.current !== "normal" || selectedPrIdRef.current !== null;
     void refreshCore({
       skipFreshWarmCache: true,
       githubRefreshMode: shouldRefreshFromGithub ? "background" : undefined,
     });
-  }, [refreshCore]);
+  }, [active, refreshCore]);
 
   // Silently refresh detail data for the given PR (no loading state).
   // Returns early if a fetch is already in progress or the PR is no longer selected.
@@ -1028,6 +1032,7 @@ export function PrsProvider({ children }: { children: React.ReactNode }) {
   // Reset rate-limit backoff on each mount / PR change so stale backoff
   // from a previous session doesn't block the first fetch.
   useEffect(() => {
+    if (!active) return;
     // Reset rate-limit backoff whenever the selected PR changes (including
     // on remount) so stale backoff from a previous session is cleared.
     rateLimitedUntilRef.current = 0;
@@ -1268,23 +1273,23 @@ export function PrsProvider({ children }: { children: React.ReactNode }) {
       // Reset rate-limit backoff on cleanup so remounts start fresh
       rateLimitedUntilRef.current = 0;
     };
-  }, [selectedPrId, refreshDetailSilently]);
+  }, [active, selectedPrId, refreshDetailSilently]);
 
   useEffect(() => {
-    if (!selectedPrId) return;
+    if (!active || !selectedPrId) return;
     if (mergeContextByPrId[selectedPrId]) return;
     void refreshMergeContexts([selectedPrId]);
-  }, [mergeContextByPrId, refreshMergeContexts, selectedPrId]);
+  }, [active, mergeContextByPrId, refreshMergeContexts, selectedPrId]);
 
   useEffect(() => {
-    if (activeTab === "normal") return;
+    if (!active || activeTab === "normal") return;
     const prIds = prsRef.current.map((pr) => pr.id);
     if (prIds.length === 0) return;
     void refreshMergeContexts(prIds);
-  }, [activeTab, prs, refreshMergeContexts]);
+  }, [active, activeTab, prs, refreshMergeContexts]);
 
   useEffect(() => {
-    if (activeTab === "normal") return;
+    if (!active || activeTab === "normal") return;
     let cancelled = false;
     window.ade.prs.listQueueStates({ includeCompleted: true, limit: 50 })
       .then((states) => {
@@ -1300,10 +1305,11 @@ export function PrsProvider({ children }: { children: React.ReactNode }) {
     return () => {
       cancelled = true;
     };
-  }, [activeTab]);
+  }, [active, activeTab]);
 
   // Subscribe to PR events
   useEffect(() => {
+    if (!active) return;
     const unsub = window.ade.prs.onEvent((event: PrEventPayload) => {
       if (event.type === "prs-updated") {
         const previous = prsRef.current;
@@ -1359,24 +1365,25 @@ export function PrsProvider({ children }: { children: React.ReactNode }) {
     return () => {
       unsub();
     };
-  }, [refreshDetailSilently, refreshMergeContexts, refreshQueueStates]);
+  }, [active, refreshDetailSilently, refreshMergeContexts, refreshQueueStates]);
 
   // Subscribe to rebase events
   useEffect(() => {
+    if (!active) return;
     const unsub = window.ade.rebase.onEvent((event: RebaseEventPayload) => {
       if (event.type === "rebase-needs-updated") {
         setRebaseNeeds(event.needs);
       }
     });
     return unsub;
-  }, []);
+  }, [active]);
 
   // Periodic rebase needs scan (cancelled flag guards against setState after unmount).
   // The plain GitHub PR list does not render rebase workflow state, so avoid
   // doing that git work until a workflow tab or selected PR detail can use it.
   useEffect(() => {
     let cancelled = false;
-    if (activeTab === "normal" && selectedPrId == null) {
+    if (!active || (activeTab === "normal" && selectedPrId == null)) {
       return () => {
         cancelled = true;
       };
@@ -1394,20 +1401,21 @@ export function PrsProvider({ children }: { children: React.ReactNode }) {
       cancelled = true;
       clearInterval(timer);
     };
-  }, [activeTab, selectedPrId]);
+  }, [active, activeTab, selectedPrId]);
 
   // Subscribe to auto-rebase events
   useEffect(() => {
+    if (!active) return;
     const unsub = window.ade.lanes.onAutoRebaseEvent((event: AutoRebaseEventPayload) => {
       if (event.type === "auto-rebase-updated") {
         setAutoRebaseStatuses(event.statuses);
       }
     });
     return unsub;
-  }, []);
+  }, [active]);
 
   useEffect(() => {
-    if (activeTab === "normal" && selectedPrId == null) return;
+    if (!active || (activeTab === "normal" && selectedPrId == null)) return;
     let cancelled = false;
     window.ade.lanes.listAutoRebaseStatuses().then((statuses) => {
       if (!cancelled) setAutoRebaseStatuses(statuses);
@@ -1417,7 +1425,7 @@ export function PrsProvider({ children }: { children: React.ReactNode }) {
     return () => {
       cancelled = true;
     };
-  }, [activeTab, selectedPrId]);
+  }, [active, activeTab, selectedPrId]);
 
   useEffect(() => {
     if (PRS_CONTEXT_CACHE_DISABLED) return;
diff --git a/apps/desktop/src/renderer/components/review/ReviewPage.tsx b/apps/desktop/src/renderer/components/review/ReviewPage.tsx
index b1368e4f1..d2365f363 100644
--- a/apps/desktop/src/renderer/components/review/ReviewPage.tsx
+++ b/apps/desktop/src/renderer/components/review/ReviewPage.tsx
@@ -549,7 +549,7 @@ function buildTargetConfig(
   };
 }
 
-export function ReviewPage() {
+export function ReviewPage({ active = true }: { active?: boolean } = {}) {
   const navigate = useNavigate();
   const location = useLocation();
   const [, setSearchParams] = useSearchParams();
@@ -698,18 +698,22 @@ export function ReviewPage() {
   }, []);
 
   React.useEffect(() => {
+    if (!active) return;
     void refreshLaunchContext();
-  }, [refreshLaunchContext]);
+  }, [active, refreshLaunchContext]);
 
   React.useEffect(() => {
+    if (!active) return;
     void refreshRuns();
-  }, [refreshRuns]);
+  }, [active, refreshRuns]);
 
   React.useEffect(() => {
+    if (!active) return;
     void loadDetail(selectedRunId);
-  }, [loadDetail, selectedRunId]);
+  }, [active, loadDetail, selectedRunId]);
 
   React.useEffect(() => {
+    if (!active) return;
     const unsub = onReviewEvent((event) => {
       if (event.type === "suppressions-updated") return;
       void refreshRuns();
@@ -725,7 +729,7 @@ export function ReviewPage() {
         // ignore bridge teardown issues
       }
     };
-  }, [loadDetail, refreshRuns, selectedRunId]);
+  }, [active, loadDetail, refreshRuns, selectedRunId]);
 
   React.useEffect(() => {
     if (!launchContext?.defaultLaneId || launchDraft.laneId) return;
diff --git a/apps/desktop/src/renderer/components/terminals/TerminalView.test.tsx b/apps/desktop/src/renderer/components/terminals/TerminalView.test.tsx
index 740c53ade..afe5af161 100644
--- a/apps/desktop/src/renderer/components/terminals/TerminalView.test.tsx
+++ b/apps/desktop/src/renderer/components/terminals/TerminalView.test.tsx
@@ -146,6 +146,7 @@ import {
   __resetTerminalRuntimesForTests,
   disposeTerminalRuntimesForProjectChange,
   getTerminalRuntimeSnapshot,
+  stripFullScreenRedrawSequences,
 } from "./TerminalView";
 import { WORK_SURFACE_REVEALED_EVENT } from "./workSurfaceVisibility";
 
@@ -172,6 +173,7 @@ function installWindowAde() {
     },
     sessions: {
       readTranscriptTail: vi.fn().mockResolvedValue(""),
+      get: vi.fn().mockResolvedValue(null),
     },
     terminal: {
       preview: vi.fn().mockResolvedValue({
@@ -182,6 +184,11 @@ function installWindowAde() {
         transcript: null,
         capturedAt: new Date().toISOString(),
       }),
+      read: vi.fn().mockResolvedValue({
+        terminalId: "session",
+        data: "",
+        nextSince: 0,
+      }),
     },
   };
 }
@@ -1718,4 +1725,275 @@ describe("TerminalView", () => {
       rows: 42,
     });
   });
+
+  it("replays the full transcript for disposed chat-CLI sessions with scrollback enlarged", async () => {
+    const previewMock = window.ade.terminal.preview as unknown as ReturnType<typeof vi.fn>;
+    const sessionsGetMock = window.ade.sessions.get as unknown as ReturnType<typeof vi.fn>;
+    const readTranscriptTailMock = window.ade.sessions.readTranscriptTail as unknown as ReturnType<typeof vi.fn>;
+
+    sessionsGetMock.mockResolvedValue({
+      id: "session-replay",
+      laneId: "lane",
+      laneName: "Lane",
+      ptyId: null,
+      tracked: true,
+      pinned: false,
+      goal: null,
+      toolType: "claude-chat",
+      title: "claude",
+      status: "disposed",
+      startedAt: new Date().toISOString(),
+      endedAt: new Date().toISOString(),
+      exitCode: 0,
+      transcriptPath: "/tmp/session-replay.log",
+      headShaStart: null,
+      headShaEnd: null,
+      lastOutputPreview: null,
+      summary: null,
+      runtimeState: "killed",
+      resumeCommand: null,
+    });
+    // terminal.preview must NOT be required for chat-CLI sessions (it throws in
+    // production); the replay path should fire purely off sessions.get. Make
+    // preview reject here so we'd fail loudly if the code regressed.
+    previewMock.mockRejectedValue(new Error("agent chat session, not a terminal"));
+
+    const transcript =
+      "\x1b[?1049h\x1b[2J\x1b[31mHello\x1b[0m\nuser: hi\n\x1b[32massistant: hello!\x1b[0m\n\x1b[?1049l";
+    readTranscriptTailMock.mockResolvedValue(transcript);
+
+    render(<TerminalView ptyId="pty-replay" sessionId="session-replay" isActive />);
+    await flushAllTimers();
+
+    const terminal = mockState.terminalInstances.at(-1) as {
+      write: ReturnType<typeof vi.fn>;
+      options: Record<string, unknown>;
+    } | undefined;
+    expect(terminal).toBeTruthy();
+
+    expect(readTranscriptTailMock).toHaveBeenCalledWith({
+      sessionId: "session-replay",
+      maxBytes: 8_000_000,
+      raw: true,
+    });
+    const writes = terminal?.write.mock.calls.map(([value]) => String(value)) ?? [];
+    const replayWrite = writes.find((value) => value.includes("assistant: hello!"));
+    expect(replayWrite).toBeTruthy();
+    // Alt-screen + clear-screen sequences are stripped; SGR colors and text
+    // survive untouched so the replay matches the live ANSI render.
+    expect(replayWrite).not.toContain("\x1b[?1049h");
+    expect(replayWrite).not.toContain("\x1b[?1049l");
+    expect(replayWrite).not.toContain("\x1b[2J");
+    expect(replayWrite).toContain("\x1b[31mHello\x1b[0m");
+    expect(replayWrite).toContain("\x1b[32massistant: hello!\x1b[0m");
+    // Scrollback is enlarged so the entire conversation stays scrollable.
+    expect(terminal?.options.scrollback).toBe(100_000);
+  });
+
+  it("falls back to snapshot hydration when transcript.read returns no data for a disposed session", async () => {
+    const previewMock = window.ade.terminal.preview as unknown as ReturnType<typeof vi.fn>;
+    const sessionsGetMock = window.ade.sessions.get as unknown as ReturnType<typeof vi.fn>;
+    const readTranscriptTailMock = window.ade.sessions.readTranscriptTail as unknown as ReturnType<typeof vi.fn>;
+
+    sessionsGetMock.mockResolvedValue({
+      id: "session-replay-empty",
+      laneId: "lane",
+      laneName: "Lane",
+      ptyId: null,
+      tracked: true,
+      pinned: false,
+      goal: null,
+      toolType: "claude",
+      title: "claude",
+      status: "disposed",
+      startedAt: new Date().toISOString(),
+      endedAt: new Date().toISOString(),
+      exitCode: 1,
+      transcriptPath: "/tmp/session-replay-empty.log",
+      headShaStart: null,
+      headShaEnd: null,
+      lastOutputPreview: null,
+      summary: null,
+      runtimeState: "exited",
+      resumeCommand: null,
+    });
+    previewMock.mockResolvedValue({
+      terminalId: "session-replay-empty",
+      session: {
+        terminalId: "session-replay-empty",
+        ptyId: null,
+        chatSessionId: null,
+        laneId: "lane",
+        laneName: "Lane",
+        title: "claude",
+        toolType: "claude",
+        goal: null,
+        status: "disposed",
+        runtimeState: "exited",
+        active: false,
+        startedAt: new Date().toISOString(),
+        endedAt: new Date().toISOString(),
+        exitCode: 1,
+        pid: null,
+        resumeCommand: null,
+        resumeMetadata: null,
+        lastOutputPreview: null,
+        summary: null,
+      },
+      source: "snapshot",
+      snapshot: {
+        version: 1,
+        terminalId: "session-replay-empty",
+        cols: 12,
+        rows: 1,
+        capturedAt: new Date().toISOString(),
+        status: "disposed",
+        runtimeState: "exited",
+        bufferType: "normal",
+        cursorX: 0,
+        cursorY: 0,
+        baseY: 0,
+        viewportY: 0,
+        serialized: "",
+        visibleRows: [
+          {
+            text: "Snapshot tail",
+            wrapped: false,
+            cells: "Snapshot tail".split("").map((text) => ({
+              text,
+              fg: null,
+              bg: null,
+              fgMode: "default" as const,
+              bgMode: "default" as const,
+            })),
+          },
+        ],
+      },
+      transcript: null,
+      capturedAt: new Date().toISOString(),
+    });
+    // Empty transcript on the replay path forces the snapshot fallback.
+    readTranscriptTailMock.mockResolvedValue("");
+
+    render(<TerminalView ptyId="pty-replay-empty" sessionId="session-replay-empty" isActive />);
+    await flushAllTimers();
+
+    const terminal = mockState.terminalInstances.at(-1) as {
+      write: ReturnType<typeof vi.fn>;
+      options: Record<string, unknown>;
+    } | undefined;
+    const writes = terminal?.write.mock.calls.map(([value]) => String(value)) ?? [];
+    expect(writes.some((value) => value.includes("Snapshot tail"))).toBe(true);
+    // No transcript = no replay-mode scrollback bump.
+    expect(terminal?.options.scrollback).toBe(10_000);
+  });
+
+  it("preserves live-session behavior and does not trigger replay transcript reads while the PTY is running", async () => {
+    const previewMock = window.ade.terminal.preview as unknown as ReturnType<typeof vi.fn>;
+    const sessionsGetMock = window.ade.sessions.get as unknown as ReturnType<typeof vi.fn>;
+    const readTranscriptTailMock = window.ade.sessions.readTranscriptTail as unknown as ReturnType<typeof vi.fn>;
+
+    sessionsGetMock.mockResolvedValue({
+      id: "session-live-running",
+      laneId: "lane",
+      laneName: "Lane",
+      ptyId: "pty-live-running",
+      tracked: true,
+      pinned: false,
+      goal: null,
+      toolType: "claude",
+      title: "claude",
+      status: "running",
+      startedAt: new Date().toISOString(),
+      endedAt: null,
+      exitCode: null,
+      transcriptPath: "/tmp/session-live-running.log",
+      headShaStart: null,
+      headShaEnd: null,
+      lastOutputPreview: null,
+      summary: null,
+      runtimeState: "running",
+      resumeCommand: null,
+    });
+    previewMock.mockResolvedValue({
+      terminalId: "session-live-running",
+      session: {
+        terminalId: "session-live-running",
+        ptyId: "pty-live-running",
+        chatSessionId: null,
+        laneId: "lane",
+        laneName: "Lane",
+        title: "claude",
+        toolType: "claude",
+        goal: null,
+        status: "running",
+        runtimeState: "running",
+        active: true,
+        startedAt: new Date().toISOString(),
+        endedAt: null,
+        exitCode: null,
+        pid: 1234,
+        resumeCommand: null,
+        resumeMetadata: null,
+        lastOutputPreview: null,
+        summary: null,
+      },
+      source: "empty",
+      snapshot: null,
+      transcript: null,
+      capturedAt: new Date().toISOString(),
+    });
+
+    render(<TerminalView ptyId="pty-live-running" sessionId="session-live-running" isActive />);
+    await flushAllTimers();
+
+    // No call to readTranscriptTail with the replay-sized cap (8 MB) means the
+    // replay path stayed off. Hydration backfills may still call it with the
+    // ordinary HYDRATE_TAIL_BYTES cap, so we assert by maxBytes.
+    const replaySized = readTranscriptTailMock.mock.calls.some(
+      ([call]) => (call as { maxBytes?: number })?.maxBytes === 8_000_000,
+    );
+    expect(replaySized).toBe(false);
+  });
+});
+
+describe("stripFullScreenRedrawSequences", () => {
+  it("strips alt-screen enter/leave sequences (1049 + the older 47 variant)", () => {
+    expect(
+      stripFullScreenRedrawSequences("before\x1b[?1049hmiddle\x1b[?1049lafter"),
+    ).toBe("beforemiddleafter");
+    expect(
+      stripFullScreenRedrawSequences("\x1b[?47h<TUI body>\x1b[?47l"),
+    ).toBe("<TUI body>");
+  });
+
+  it("strips clear-screen / hard-reset sequences that would erase prior content", () => {
+    expect(stripFullScreenRedrawSequences("keep\x1b[2Jdrop")).toBe("keepdrop");
+    expect(stripFullScreenRedrawSequences("keep\x1b[3Jdrop")).toBe("keepdrop");
+    expect(stripFullScreenRedrawSequences("keep\x1bcdrop")).toBe("keepdrop");
+    // The compound \x1b[H\x1b[2J ("home + erase") is stripped wholesale so a
+    // bare cursor-home doesn't linger and snap subsequent output to row 1.
+    expect(stripFullScreenRedrawSequences("keep\x1b[H\x1b[2Jdrop")).toBe(
+      "keepdrop",
+    );
+    // A bare cursor-home outside the compound is preserved (general layout).
+    expect(stripFullScreenRedrawSequences("keep\x1b[Hdrop")).toBe("keep\x1b[Hdrop");
+  });
+
+  it("preserves ordinary ANSI color (SGR) and OSC sequences verbatim", () => {
+    const input = "\x1b[31mred\x1b[0m \x1b[1;38;2;200;100;50mtrue-color\x1b[0m";
+    expect(stripFullScreenRedrawSequences(input)).toBe(input);
+
+    const osc = "\x1b]0;title text\x07rest of line";
+    expect(stripFullScreenRedrawSequences(osc)).toBe(osc);
+  });
+
+  it("preserves cursor-position sequences so per-line layout is unchanged", () => {
+    const input = "\x1b[5;10HHello\x1b[7;1Hsecond line";
+    expect(stripFullScreenRedrawSequences(input)).toBe(input);
+  });
+
+  it("returns the empty string unchanged", () => {
+    expect(stripFullScreenRedrawSequences("")).toBe("");
+  });
 });
diff --git a/apps/desktop/src/renderer/components/terminals/TerminalView.tsx b/apps/desktop/src/renderer/components/terminals/TerminalView.tsx
index 4616e9a49..b566d41f6 100644
--- a/apps/desktop/src/renderer/components/terminals/TerminalView.tsx
+++ b/apps/desktop/src/renderer/components/terminals/TerminalView.tsx
@@ -12,7 +12,7 @@ import {
 } from "../../state/appStore";
 import { WORK_SURFACE_REVEALED_EVENT } from "./workSurfaceVisibility";
 import { openUrlInAdeBrowser } from "../../lib/openExternal";
-import type { TerminalSerializedSnapshot, TerminalSnapshotCell, TerminalSnapshotRow } from "../../../shared/types";
+import type { TerminalSerializedSnapshot, TerminalSnapshotCell, TerminalSnapshotRow, TerminalSessionStatus } from "../../../shared/types";
 
 type XtermTheme = NonNullable<ConstructorParameters<typeof Terminal>[0]>["theme"];
 type TerminalRendererMode = "webgl" | "dom";
@@ -93,9 +93,17 @@ type CachedRuntime = {
   pendingWebGLRestore: boolean;
   invalidFitRetryTimer: ReturnType<typeof setTimeout> | null;
   fitWarningLogged: boolean;
+  replayMode: boolean;
 };
 
 const HYDRATE_TAIL_BYTES = 2_000_000;
+// Maximum transcript bytes loaded when replaying a disposed chat-CLI session
+// (~200k lines of typical CLI output). Bounded to keep replay-mode allocations
+// well under the main-process MAX_TRANSCRIPT_BYTES cap (64 MB).
+const REPLAY_TRANSCRIPT_MAX_BYTES = 8_000_000;
+// Scrollback override for replay-mode runtimes so the entire flattened
+// transcript stays scrollable in the chat pane.
+const REPLAY_SCROLLBACK_LINES = 100_000;
 const HYDRATION_BACKFILL_RETRY_MS = 250;
 const HYDRATION_VISIBLE_BLANK_BACKFILL_RETRY_MS = 100;
 const HYDRATION_BACKFILL_MAX_ATTEMPTS = 120;
@@ -113,6 +121,14 @@ const TERMINAL_CTRL_V = "\x16";
 const TERMINAL_LINK_PATTERN = /(?:https?:\/\/[^\s<>"'`]+|(?:localhost|127\.0\.0\.1|\[::1\])(?::\d+)?(?:\/[^\s<>"'`]*)?)/gi;
 const TERMINAL_MOUSE_TRACKING_EVENT_MODES = new Set([1000, 1002, 1003]);
 const runtimeCache = new Map<string, CachedRuntime>();
+
+function terminalRuntimeKey(args: {
+  sessionId: string;
+  ptyId?: string | null;
+  projectRoot?: string | null;
+}): string {
+  return `${args.projectRoot ?? "<no-project>"}::${args.sessionId}::${args.ptyId ?? "<no-pty>"}`;
+}
 let parkedRoot: HTMLDivElement | null = null;
 
 const terminalThemes: Record<"light" | "dark", XtermTheme> = {
@@ -213,7 +229,7 @@ type TerminalDims = {
 };
 
 type InitialHydrationData = {
-  source: "snapshot" | "transcript" | "empty";
+  source: "snapshot" | "transcript" | "replay" | "empty";
   text: string;
 };
 
@@ -250,6 +266,26 @@ function trimToLikelyTerminalFrameBoundary(raw: string): string {
   return raw.slice(idx);
 }
 
+// Flatten a transcript that contains repeated TUI redraws into a linear stream
+// the user can scroll through. We strip the alt-screen enter/leave toggles and
+// the "clear screen" sequences so each redraw of a Codex/Claude chat surface
+// appends to the main buffer's scrollback instead of clobbering it. Ordinary
+// SGR (color), cursor-position, and OSC sequences are preserved verbatim so
+// the ANSI colors and text layout match the live render.
+export function stripFullScreenRedrawSequences(raw: string): string {
+  if (!raw.length) return raw;
+  return raw
+    // Alt-screen enter/leave (1049 + the older 47 variant). Removing these
+    // forces xterm to stay in the main buffer for the whole replay so the
+    // scrollback captures every redraw.
+    .replace(/\x1b\[\?(?:1049|47)[hl]/g, "")
+    // Hard resets and full-screen erases that would otherwise wipe the buffer
+    // mid-replay.
+    .replace(/\x1b\[H\x1b\[2J/g, "")
+    .replace(/\x1b\[[23]J/g, "")
+    .replace(/\x1bc/g, "");
+}
+
 function hasRenderableTerminalText(data: string): boolean {
   if (!data.length) return false;
   const withoutControlSequences = data
@@ -425,7 +461,11 @@ function applyRuntimeVisualOptions(
     runtime.term.options.fontFamily = args.preferences.fontFamily || DEFAULT_TERMINAL_FONT_FAMILY;
     runtime.term.options.fontSize = args.preferences.fontSize;
     runtime.term.options.lineHeight = args.preferences.lineHeight;
-    runtime.term.options.scrollback = args.preferences.scrollback;
+    // Replay mode owns its own scrollback budget so the flattened transcript
+    // stays available; ordinary preference updates must not clobber it.
+    runtime.term.options.scrollback = runtime.replayMode
+      ? Math.max(args.preferences.scrollback, REPLAY_SCROLLBACK_LINES)
+      : args.preferences.scrollback;
   } catch {
     // ignore updates after disposal
   }
@@ -507,11 +547,8 @@ function disposeStaleRuntimes(activeProjectRoot: string | null, activeProjectRev
       continue;
     }
 
-    if (
-      !isLiveRuntime
-      && (runtime.projectRoot !== activeProjectRoot || runtime.projectRevision !== activeProjectRevision)
-    ) {
-      teardownRuntime(runtime);
+    if (!isLiveRuntime && runtime.refs === 0 && runtime.projectRoot === activeProjectRoot && runtime.projectRevision !== activeProjectRevision) {
+      scheduleRuntimeDispose(runtime, EXITED_RUNTIME_KEEPALIVE_MS);
     }
   }
 }
@@ -933,9 +970,12 @@ function scheduleFrameWriteFlush(runtime: CachedRuntime) {
 function flushHydrationData(
   runtime: CachedRuntime,
   tail: string,
-  options: { appendPending?: boolean } = {},
+  options: { appendPending?: boolean; replay?: boolean } = {},
 ) {
-  const stabilizedTail = trimToLikelyTerminalFrameBoundary(tail);
+  // Replay mode already stripped alt-screen/clear-screen sequences before this
+  // point, so the entire transcript should be written verbatim. Trimming to a
+  // frame boundary here would discard everything before the last redraw.
+  const stabilizedTail = options.replay ? tail : trimToLikelyTerminalFrameBoundary(tail);
   const shouldAppendPending = options.appendPending ?? true;
   const pending = shouldAppendPending ? runtime.pendingHydrationChunks.join("") : "";
   runtime.pendingHydrationChunks.length = 0;
@@ -989,10 +1029,89 @@ async function readPreviewHydrationData(
   return { source: "empty", text: "" };
 }
 
+async function readReplayHydrationData(runtime: CachedRuntime): Promise<InitialHydrationData> {
+  // Use sessions.readTranscriptTail (not terminal.read) so this works for chat-CLI
+  // tool types — terminal.read/preview throws for isPersistedChatToolType sessions.
+  const data = await window.ade.sessions.readTranscriptTail({
+    sessionId: runtime.sessionId,
+    maxBytes: REPLAY_TRANSCRIPT_MAX_BYTES,
+    raw: true,
+  });
+  if (!data) return { source: "empty", text: "" };
+  return { source: "replay", text: stripFullScreenRedrawSequences(data) };
+}
+
+async function tryReadReplay(
+  runtime: CachedRuntime,
+  exitCodeHint: number | null,
+): Promise<InitialHydrationData | null> {
+  try {
+    const replay = await readReplayHydrationData(runtime);
+    if (replay.text) {
+      runtime.replayMode = true;
+      if (runtime.exitCode == null) {
+        runtime.exitCode = exitCodeHint ?? 0;
+      }
+      return replay;
+    }
+  } catch {
+    // Fall through; caller will try other paths.
+  }
+  return null;
+}
+
 async function readInitialHydrationData(runtime: CachedRuntime): Promise<InitialHydrationData> {
+  // Determine disposed-ness via sessions.get so we work for chat-CLI sessions
+  // too (terminal.preview rejects isPersistedChatToolType records and would
+  // otherwise force us into the snapshot/transcript fallback).
+  let sessionStatus: TerminalSessionStatus | null = null;
+  let sessionExitCode: number | null = null;
   try {
-    const previewData = await readPreviewHydrationData(runtime);
-    if (previewData.text) return previewData;
+    const detail = await window.ade.sessions.get(runtime.sessionId);
+    sessionStatus = detail?.status ?? null;
+    sessionExitCode = detail?.exitCode ?? null;
+  } catch {
+    // Best-effort; non-fatal.
+  }
+  const sessionDisposed = sessionStatus !== null && sessionStatus !== "running";
+
+  // Prefer replay for disposed sessions BEFORE attempting terminal.preview —
+  // preview throws for chat-CLI tool types and the throw would swallow the
+  // replay opportunity.
+  if (sessionDisposed && !runtime.displayedLiveDataBeforeHydration) {
+    const replay = await tryReadReplay(runtime, sessionExitCode);
+    if (replay) return replay;
+  }
+
+  try {
+    const preview = await window.ade.terminal.preview({
+      terminalId: runtime.sessionId,
+      maxBytes: HYDRATE_TAIL_BYTES,
+    });
+    const previewSessionStatus = preview?.session?.status ?? sessionStatus;
+    const previewSessionExitCode = preview?.session?.exitCode ?? sessionExitCode;
+
+    // Some surfaces hit this path without a prior sessions.get hit (e.g. when
+    // the renderer can't reach sessions.get but terminal.preview succeeds).
+    // Retry the replay opportunity from the preview-derived status.
+    if (
+      !sessionDisposed
+      && previewSessionStatus
+      && previewSessionStatus !== "running"
+      && !runtime.displayedLiveDataBeforeHydration
+    ) {
+      const replay = await tryReadReplay(runtime, previewSessionExitCode);
+      if (replay) return replay;
+    }
+
+    if (preview?.snapshot) {
+      const visibleRows = serializeSnapshotVisibleRows(preview.snapshot);
+      if (visibleRows) return { source: "snapshot", text: visibleRows };
+      if (preview.snapshot.serialized) {
+        return { source: "snapshot", text: preview.snapshot.serialized };
+      }
+    }
+    if (preview?.transcript) return { source: "transcript", text: preview.transcript };
   } catch {
     // Fall back to the transcript tail below.
   }
@@ -1049,6 +1168,31 @@ function startHydration(runtime: CachedRuntime) {
 
   const finalizeHydration = (data: InitialHydrationData) => {
     if (runtime.disposed) return;
+    if (data.source === "replay") {
+      // Replay mode: enlarge scrollback so the full transcript stays
+      // scrollable, then write the stripped bytes in one pass. There is no
+      // live PTY by definition, so pending live chunks (if any) are dropped.
+      runtime.replayMode = true;
+      runtime.pendingHydrationChunks.length = 0;
+      runtime.pendingHydrationBytes = 0;
+      discardScheduledFrameWrites(runtime);
+      try {
+        runtime.term.options.scrollback = REPLAY_SCROLLBACK_LINES;
+      } catch {
+        // ignore options assignment failures after disposal
+      }
+      flushHydrationData(runtime, data.text, { appendPending: false, replay: true });
+      runtime.hydrationCompleted = true;
+      // Surface the exited badge for disposed sessions that never fire
+      // pty.onExit (the PTY is already gone before this view mounted).
+      // readInitialHydrationData already pre-populated runtime.exitCode from
+      // the session record when entering replay mode; notify listeners so the
+      // local "exited N" state catches up.
+      notifyRuntime(runtime);
+      scheduleFit(runtime, true);
+      // Disposed sessions never receive live PTY data, so no backfill polling.
+      return;
+    }
     const preferLivePending = runtime.displayedLiveDataBeforeHydration && data.source !== "snapshot";
     if (preferLivePending) {
       runtime.pendingHydrationChunks.length = 0;
@@ -1247,7 +1391,7 @@ function createRuntime(args: {
     : null;
 
   const runtime: CachedRuntime = {
-    key: args.sessionId,
+    key: terminalRuntimeKey(args),
     ptyId: args.ptyId,
     sessionId: args.sessionId,
     projectRoot: args.projectRoot,
@@ -1300,7 +1444,8 @@ function createRuntime(args: {
     shiftMouseCleanup: null,
     pendingWebGLRestore: false,
     invalidFitRetryTimer: null,
-    fitWarningLogged: false
+    fitWarningLogged: false,
+    replayMode: false
   };
 
   // Capture-phase paste listener on host: intercepts ALL paste sources (Cmd+V,
@@ -1474,7 +1619,8 @@ function ensureRuntime(args: {
   theme: XtermTheme;
   preferences: TerminalRenderPreferences;
 }): CachedRuntime {
-  const existing = runtimeCache.get(args.sessionId);
+  const key = terminalRuntimeKey(args);
+  const existing = runtimeCache.get(key);
   if (existing && !existing.disposed) {
     if (
       existing.ptyId === args.ptyId
@@ -1492,12 +1638,12 @@ function ensureRuntime(args: {
   }
 
   const runtime = createRuntime(args);
-  runtimeCache.set(args.sessionId, runtime);
+  runtimeCache.set(key, runtime);
   return runtime;
 }
 
 export function getTerminalRuntimeSnapshot(sessionId: string): RuntimeSnapshot | null {
-  const runtime = runtimeCache.get(sessionId);
+  const runtime = Array.from(runtimeCache.values()).find((entry) => entry.sessionId === sessionId);
   if (!runtime || runtime.disposed) return null;
   return {
     exitCode: runtime.exitCode,
@@ -1783,7 +1929,7 @@ export function TerminalView({
   }, [runtimeProjectRevision, runtimeProjectRoot, ptyId, sessionId]);
 
   useEffect(() => {
-    const runtime = runtimeRef.current ?? runtimeCache.get(sessionId);
+    const runtime = runtimeRef.current;
     if (!runtime || runtime.disposed) return;
 
     const wrapper = wrapperRef.current;
@@ -1844,7 +1990,7 @@ export function TerminalView({
   }, [isActive, isVisible, runtimeProjectRoot, sessionId]);
 
   useEffect(() => {
-    const runtime = runtimeRef.current ?? runtimeCache.get(sessionId);
+    const runtime = runtimeRef.current;
     if (!runtime || runtime.disposed) return;
     const id = requestAnimationFrame(() => {
       applyRuntimeVisualOptions(runtime, {
@@ -1860,7 +2006,7 @@ export function TerminalView({
   // When this terminal becomes the active tab, force fit + focus + scroll
   useEffect(() => {
     if (!isActive) return;
-    const runtime = runtimeRef.current ?? runtimeCache.get(sessionId);
+    const runtime = runtimeRef.current;
     if (!runtime || runtime.disposed) return;
 
     const raf = requestAnimationFrame(() => {
diff --git a/apps/desktop/src/renderer/components/terminals/cliLaunch.test.ts b/apps/desktop/src/renderer/components/terminals/cliLaunch.test.ts
index ee3455824..4a6b44f0e 100644
--- a/apps/desktop/src/renderer/components/terminals/cliLaunch.test.ts
+++ b/apps/desktop/src/renderer/components/terminals/cliLaunch.test.ts
@@ -150,15 +150,24 @@ describe("buildTrackedCliStartupCommand", () => {
     it("adds supported workspace-write defaults for default", () => {
       const command = buildTrackedCliStartupCommand({ provider: "codex", permissionMode: "default" });
       expect(command).toContain("codex --no-alt-screen --sandbox workspace-write --ask-for-approval on-request");
-      expect(command).toContain("-c mcp_servers.linear.enabled=false");
+      expect(command).not.toContain("mcp_servers.linear");
       expect(command).toContain("only normal reason to skip ADE CLI");
     });
 
+    it("does not synthesize Codex MCP server config for any permission preset", () => {
+      const modes = ["default", "plan", "edit", "full-auto", "config-toml"] as const;
+      for (const permissionMode of modes) {
+        const launch = buildTrackedCliLaunchCommand({ provider: "codex", permissionMode });
+        expect(launch.args.join("\n")).not.toContain("mcp_servers.");
+        expect(launch.startupCommand).not.toContain("mcp_servers.");
+      }
+    });
+
     it("passes no extra flags for config-toml", () => {
       const command = buildTrackedCliStartupCommand({ provider: "codex", permissionMode: "config-toml" });
       expect(command).toContain("codex --no-alt-screen");
       expect(command).not.toContain("--full-auto");
-      expect(command).not.toContain("mcp_servers.linear.enabled=false");
+      expect(command).not.toContain("mcp_servers.linear");
       expect(command).toContain("only normal reason to skip ADE CLI");
     });
 
diff --git a/apps/desktop/src/renderer/components/terminals/useWorkSessions.test.ts b/apps/desktop/src/renderer/components/terminals/useWorkSessions.test.ts
index 2a5edab3b..dddbba190 100644
--- a/apps/desktop/src/renderer/components/terminals/useWorkSessions.test.ts
+++ b/apps/desktop/src/renderer/components/terminals/useWorkSessions.test.ts
@@ -28,6 +28,7 @@ function resetFakeAppStoreState() {
     refreshLanes: refreshLanesSpy.mockResolvedValue(undefined),
     workViewByProject: {},
     setWorkViewState: setWorkViewStateSpy,
+    sessionsCacheByProject: {},
   };
   routerLocation.pathname = "/work";
   routerLocation.search = "";
@@ -90,11 +91,31 @@ vi.mock("react-router-dom", () => ({
   useSearchParams: useSearchParamsMock,
 }));
 
-vi.mock("../../state/appStore", () => ({
-  useAppStore: vi.fn((selector: (state: Record<string, unknown>) => unknown) => {
+vi.mock("../../state/appStore", () => {
+  const useAppStore = vi.fn((selector: (state: Record<string, unknown>) => unknown) => {
     return selector(fakeAppStoreState);
-  }),
-}));
+  }) as unknown as {
+    (selector: (state: Record<string, unknown>) => unknown): unknown;
+    getState: () => Record<string, unknown>;
+    setState: (
+      partial:
+        | Record<string, unknown>
+        | ((prev: Record<string, unknown>) => Record<string, unknown>),
+    ) => void;
+  };
+  useAppStore.getState = () => fakeAppStoreState;
+  useAppStore.setState = (partial) => {
+    const next = typeof partial === "function" ? partial(fakeAppStoreState) : partial;
+    Object.assign(fakeAppStoreState, next);
+  };
+  const appStoreApi = {
+    getState: useAppStore.getState,
+    setState: useAppStore.setState,
+    subscribe: vi.fn(() => () => {}),
+  };
+  const useAppStoreApi = () => appStoreApi;
+  return { useAppStore, useAppStoreApi };
+});
 
 // ---------------------------------------------------------------------------
 // Import the hook under test (after mocks are declared)
@@ -353,7 +374,7 @@ describe("useWorkSessions — refresh-before-focus ordering", () => {
       });
     });
 
-    expect(listSessionsCachedMock).toHaveBeenCalledWith({ limit: 500 }, { force: true });
+    expect(listSessionsCachedMock).toHaveBeenCalledWith({ limit: 500 }, { force: true, projectRoot: "/fake/project" });
     expect(result.current.sessions).toEqual([
       expect.objectContaining({
         id: "new-pty-session",
@@ -512,7 +533,7 @@ describe("useWorkSessions — refresh-before-focus ordering", () => {
     await waitFor(() => {
       expect(listSessionsCachedMock).toHaveBeenCalled();
     });
-    expect(listSessionsCachedMock).toHaveBeenLastCalledWith({ limit: 500 }, undefined);
+    expect(listSessionsCachedMock).toHaveBeenLastCalledWith({ limit: 500 }, { projectRoot: "/fake/project" });
   });
 
   it("setActiveItemId leaves the selected lane alone in grid mode", async () => {
@@ -1143,7 +1164,7 @@ describe("useWorkSessions — refresh-before-focus ordering", () => {
       await new Promise((r) => setTimeout(r, 120));
     });
 
-    expect(listSessionsCachedMock).toHaveBeenCalledWith({ limit: 500 }, undefined);
+    expect(listSessionsCachedMock).toHaveBeenCalledWith({ limit: 500 }, { projectRoot: "/fake/project" });
     expect(invalidateSessionListCache).toHaveBeenCalled();
   });
 
@@ -1163,7 +1184,7 @@ describe("useWorkSessions — refresh-before-focus ordering", () => {
     });
 
     expect(invalidateSessionListCache).toHaveBeenCalled();
-    expect(listSessionsCachedMock).toHaveBeenCalledWith({ limit: 500 }, undefined);
+    expect(listSessionsCachedMock).toHaveBeenCalledWith({ limit: 500 }, { projectRoot: "/fake/project" });
   });
 
   it("does not subscribe or refresh while the kept-alive Work surface is inactive", async () => {
@@ -1212,7 +1233,7 @@ describe("useWorkSessions — refresh-before-focus ordering", () => {
     });
 
     expect(invalidateSessionListCache).toHaveBeenCalled();
-    expect(listSessionsCachedMock).toHaveBeenCalledWith({ limit: 500 }, undefined);
+    expect(listSessionsCachedMock).toHaveBeenCalledWith({ limit: 500 }, { projectRoot: "/fake/project" });
   });
 });
 
diff --git a/apps/desktop/src/renderer/components/terminals/useWorkSessions.ts b/apps/desktop/src/renderer/components/terminals/useWorkSessions.ts
index 4bbaa3a2c..5ed29f859 100644
--- a/apps/desktop/src/renderer/components/terminals/useWorkSessions.ts
+++ b/apps/desktop/src/renderer/components/terminals/useWorkSessions.ts
@@ -3,6 +3,7 @@ import { useLocation, useNavigate, useSearchParams } from "react-router-dom";
 import type { AgentChatSession, LaneSummary, TerminalSessionSummary } from "../../../shared/types";
 import {
   useAppStore,
+  useAppStoreApi,
   type WorkDraftKind,
   type WorkProjectViewState,
   type WorkSidebarTab,
@@ -318,6 +319,7 @@ export function useWorkSessions({ active = true }: UseWorkSessionsOptions = {})
   const navigate = useNavigate();
   const location = useLocation();
   const [searchParams] = useSearchParams();
+  const appStore = useAppStoreApi();
   const projectRoot = useAppStore((s) => s.project?.rootPath ?? null);
   const lanes = useAppStore((s) => s.lanes);
   const focusSession = useAppStore((s) => s.focusSession);
@@ -734,7 +736,9 @@ export function useWorkSessions({ active = true }: UseWorkSessionsOptions = {})
       const rows = (
         await listSessionsCached(
           { limit: 500 },
-          options.force ? { force: true } : undefined,
+          options.force
+            ? { force: true, projectRoot: requestedProjectRoot }
+            : { projectRoot: requestedProjectRoot },
         )
       ).filter((session) => !isRunOwnedSession(session));
       if (projectRootRef.current !== requestedProjectRoot) {
@@ -791,21 +795,44 @@ export function useWorkSessions({ active = true }: UseWorkSessionsOptions = {})
   }, [isWorkRoute, refresh]);
 
   useEffect(() => {
-    invalidateSessionListCache();
-    setSessions([]);
+    // Apply the per-project sessions cache immediately so switching back to a
+    // warm project does NOT blank the chat tabs / terminal grid. Without this
+    // we wipe `sessions` to `[]`, which unmounts every chat and terminal pane
+    // until the IPC refresh returns — that's the "page goes blank for a
+    // couple seconds" the user sees. The underlying IPC cache
+    // (sessionListCache) is already keyed per project, so DON'T invalidate it
+    // either — leave each project's hot cache alone.
+    const cachedSessions =
+      (projectRoot ? (appStore.getState().sessionsCacheByProject[projectRoot] as TerminalSessionSummary[] | undefined) : undefined) ?? null;
+    setSessions(cachedSessions ?? []);
     setLoading(false);
     if (refreshQueuedRef.current) {
       refreshQueuedRef.current.deferred.reject(new Error("projectRoot changed"));
       refreshQueuedRef.current = null;
     }
-    hasLoadedOnceRef.current = false;
-    hasRunningSessionsRef.current = false;
+    // If we already have cached sessions, treat this as a "loaded" state so the
+    // upcoming refresh runs silently in the background (no spinner).
+    hasLoadedOnceRef.current = Boolean(cachedSessions && cachedSessions.length >= 0);
+    hasRunningSessionsRef.current = (cachedSessions ?? []).some((s) => s.status === "running");
     laneRecoveryRefreshProjectRef.current = null;
     appliedQuerySessionIdRef.current = null;
     appliedUrlFilterKeyRef.current = null;
     partiallyAppliedUrlFilterKeyRef.current = null;
     pendingOptimisticSessionsRef.current.clear();
-  }, [projectRoot]);
+  }, [appStore, projectRoot]);
+
+  // Mirror the locally-fetched sessions into the per-project cache in the
+  // global store. The next time the user switches BACK to this project the
+  // effect above can render these sessions instantly instead of blanking.
+  useEffect(() => {
+    if (!projectRoot) return;
+    appStore.setState((prev) => ({
+      sessionsCacheByProject: {
+        ...prev.sessionsCacheByProject,
+        [projectRoot]: sessions,
+      },
+    }));
+  }, [appStore, sessions, projectRoot]);
 
   useEffect(() => {
     if (!projectRoot || !isWorkRoute) return;
diff --git a/apps/desktop/src/renderer/lib/sessionListCache.ts b/apps/desktop/src/renderer/lib/sessionListCache.ts
index cfed0c277..f1688062f 100644
--- a/apps/desktop/src/renderer/lib/sessionListCache.ts
+++ b/apps/desktop/src/renderer/lib/sessionListCache.ts
@@ -49,9 +49,15 @@ function sliceRows(rows: TerminalSessionSummary[], limit: number | null): Termin
 
 export async function listSessionsCached(
   args?: ListSessionsArgs,
-  options?: { force?: boolean; ttlMs?: number },
+  options?: { force?: boolean; ttlMs?: number; projectRoot?: string | null },
 ): Promise<TerminalSessionSummary[]> {
-  const key = cacheKey(args);
+  const key = options?.projectRoot == null
+    ? cacheKey(args)
+    : JSON.stringify({
+        projectRoot: options.projectRoot?.trim() || null,
+        laneId: normalizeArgs(args).laneId ?? null,
+        status: normalizeArgs(args).status ?? null,
+      });
   const ttlMs = options?.ttlMs ?? DEFAULT_SESSION_LIST_TTL_MS;
   const limit = requestedLimit(args);
   const now = Date.now();
diff --git a/apps/desktop/src/renderer/state/appStore.test.ts b/apps/desktop/src/renderer/state/appStore.test.ts
index cae0e60a6..948c5a71b 100644
--- a/apps/desktop/src/renderer/state/appStore.test.ts
+++ b/apps/desktop/src/renderer/state/appStore.test.ts
@@ -71,8 +71,13 @@ function resetStore() {
     laneInspectorTabs: {},
     workViewByProject: {},
     laneWorkViewByScope: {},
+    laneSelectionByProject: {},
+    laneCacheByProject: {},
+    sessionsCacheByProject: {},
     dismissedMissingAiBannerRoots: {},
     dismissedGithubBannerRoots: {},
+    openProjectTabRoots: [],
+    projectInfoByRoot: {},
   });
 }
 
@@ -531,11 +536,35 @@ describe("appStore", () => {
       expect(useAppStore.getState().selectedLaneId).toBe("lane-42");
     });
 
+    it("selectLane records the choice in laneSelectionByProject when a project is active", () => {
+      useAppStore.setState({ project: { rootPath: "/p/a" } as any });
+      useAppStore.getState().selectLane("lane-42");
+      expect(useAppStore.getState().laneSelectionByProject["/p/a"]).toEqual({
+        laneId: "lane-42",
+        sessionId: null,
+      });
+    });
+
+    it("selectLane does not write laneSelectionByProject when there is no project", () => {
+      useAppStore.getState().selectLane("lane-42");
+      expect(useAppStore.getState().laneSelectionByProject).toEqual({});
+    });
+
     it("focusSession updates focusedSessionId", () => {
       useAppStore.getState().focusSession("session-abc");
       expect(useAppStore.getState().focusedSessionId).toBe("session-abc");
     });
 
+    it("focusSession records the choice in laneSelectionByProject without clobbering laneId", () => {
+      useAppStore.setState({ project: { rootPath: "/p/a" } as any });
+      useAppStore.getState().selectLane("lane-7");
+      useAppStore.getState().focusSession("session-abc");
+      expect(useAppStore.getState().laneSelectionByProject["/p/a"]).toEqual({
+        laneId: "lane-7",
+        sessionId: "session-abc",
+      });
+    });
+
     it("clearProjectTransitionError clears project action errors", () => {
       useAppStore.setState({ projectTransitionError: "Switch failed" });
       useAppStore.getState().clearProjectTransitionError();
@@ -765,6 +794,126 @@ describe("appStore", () => {
       expect(useAppStore.getState().projectTransitionError).toBeNull();
     });
 
+    it("stashes the outgoing project's lane/session selection and restores the incoming project's on switch", async () => {
+      // Seed: user is on project A with lane-A1 and session-A1 selected.
+      useAppStore.setState({
+        project: { rootPath: "/p/a", displayName: "A", baseRef: "main" } as any,
+        selectedLaneId: "lane-A1",
+        focusedSessionId: "session-A1",
+        // Project B has prior selection saved.
+        laneSelectionByProject: {
+          "/p/b": { laneId: "lane-B2", sessionId: "session-B2" },
+        },
+      });
+
+      const projectB = { rootPath: "/p/b", displayName: "B", baseRef: "main" } as any;
+      (window.ade.project.switchToPath as any).mockResolvedValueOnce(projectB);
+
+      await useAppStore.getState().switchProjectToPath("/p/b");
+
+      // Outgoing /p/a stashed.
+      expect(useAppStore.getState().laneSelectionByProject["/p/a"]).toEqual({
+        laneId: "lane-A1",
+        sessionId: "session-A1",
+      });
+      // Incoming /p/b restored.
+      expect(useAppStore.getState().selectedLaneId).toBe("lane-B2");
+      expect(useAppStore.getState().focusedSessionId).toBe("session-B2");
+    });
+
+    it("restores null selection when switching to a project that has no saved selection", async () => {
+      useAppStore.setState({
+        project: { rootPath: "/p/a", displayName: "A", baseRef: "main" } as any,
+        selectedLaneId: "lane-A1",
+        focusedSessionId: "session-A1",
+      });
+
+      const projectFresh = { rootPath: "/p/fresh", displayName: "Fresh", baseRef: "main" } as any;
+      (window.ade.project.switchToPath as any).mockResolvedValueOnce(projectFresh);
+
+      await useAppStore.getState().switchProjectToPath("/p/fresh");
+
+      expect(useAppStore.getState().selectedLaneId).toBeNull();
+      expect(useAppStore.getState().focusedSessionId).toBeNull();
+    });
+
+    it("applies cached lanes immediately on switch back to a warm project (no loading flicker)", async () => {
+      const cachedLanes = [{ id: "lane-A1", name: "Primary", status: "idle" }] as any[];
+      const cachedSnapshots = [{ lane: cachedLanes[0] }] as any[];
+      useAppStore.setState({
+        project: { rootPath: "/p/a", displayName: "A", baseRef: "main" } as any,
+        laneCacheByProject: {
+          "/p/b": { lanes: cachedLanes, laneSnapshots: cachedSnapshots },
+        },
+      });
+
+      const projectB = { rootPath: "/p/b", displayName: "B", baseRef: "main" } as any;
+      (window.ade.project.switchToPath as any).mockResolvedValueOnce(projectB);
+
+      await useAppStore.getState().switchProjectToPath("/p/b");
+
+      // Cached lanes applied immediately — no empty state, no spinner.
+      expect(useAppStore.getState().lanes).toBe(cachedLanes);
+      expect(useAppStore.getState().laneSnapshots).toBe(cachedSnapshots);
+      expect(useAppStore.getState().lanesLoading).toBe(false);
+    });
+
+    it("activates a warm project tab before the backend switch round trip finishes", async () => {
+      const projectA = { rootPath: "/p/a", displayName: "A", baseRef: "main" } as any;
+      const projectB = { rootPath: "/p/b", displayName: "B", baseRef: "main" } as any;
+      let resolveSwitch!: (project: typeof projectB) => void;
+      (window.ade.project.switchToPath as any).mockReturnValueOnce(
+        new Promise((resolve) => {
+          resolveSwitch = resolve;
+        }),
+      );
+      useAppStore.setState({
+        project: projectA,
+        selectedLaneId: "lane-A1",
+        focusedSessionId: "session-A1",
+        openProjectTabRoots: ["/p/a", "/p/b"],
+        projectInfoByRoot: {
+          "/p/a": projectA,
+          "/p/b": projectB,
+        },
+        laneSelectionByProject: {
+          "/p/b": { laneId: "lane-B2", sessionId: "session-B2" },
+        },
+      });
+
+      const pending = useAppStore.getState().switchProjectToPath("/p/b");
+
+      expect(useAppStore.getState().project).toEqual(projectB);
+      expect(useAppStore.getState().projectTransition).toBeNull();
+      expect(useAppStore.getState().projectBinding).toEqual(
+        expect.objectContaining({ kind: "local", rootPath: "/p/b" }),
+      );
+      expect(useAppStore.getState().selectedLaneId).toBe("lane-B2");
+      expect(useAppStore.getState().focusedSessionId).toBe("session-B2");
+      expect(useAppStore.getState().laneSelectionByProject["/p/a"]).toEqual({
+        laneId: "lane-A1",
+        sessionId: "session-A1",
+      });
+
+      resolveSwitch(projectB);
+      await pending;
+    });
+
+    it("shows the loading spinner only when switching to a cold project (no cache)", async () => {
+      useAppStore.setState({
+        project: { rootPath: "/p/a", displayName: "A", baseRef: "main" } as any,
+        laneCacheByProject: {},
+      });
+
+      const projectFresh = { rootPath: "/p/fresh", displayName: "Fresh", baseRef: "main" } as any;
+      (window.ade.project.switchToPath as any).mockResolvedValueOnce(projectFresh);
+
+      await useAppStore.getState().switchProjectToPath("/p/fresh");
+
+      expect(useAppStore.getState().lanes).toEqual([]);
+      expect(useAppStore.getState().lanesLoading).toBe(true);
+    });
+
     it("stores a friendly timeout error when switching projects fails", async () => {
       (window.ade.project.switchToPath as any).mockRejectedValueOnce(
         new Error("IPC handler for 'ade.project.switchToPath' timed out after 30000ms (callId=51)"),
diff --git a/apps/desktop/src/renderer/state/appStore.ts b/apps/desktop/src/renderer/state/appStore.ts
index b256c7df0..d7cb62a9e 100644
--- a/apps/desktop/src/renderer/state/appStore.ts
+++ b/apps/desktop/src/renderer/state/appStore.ts
@@ -1,4 +1,7 @@
-import { create } from "zustand";
+import React, { createContext, useContext, type ReactNode } from "react";
+import { useStore } from "zustand";
+import { createStore, type StoreApi } from "zustand/vanilla";
+import type { StateCreator } from "zustand";
 import type { KeybindingsSnapshot, LaneDeleteProgress, LaneListSnapshot, LaneSummary, OpenProjectBinding, ProjectInfo, ProviderMode } from "../../shared/types";
 import { MODEL_REGISTRY, type ModelDescriptor } from "../../shared/modelRegistry";
 import { extractError } from "../lib/format";
@@ -541,6 +544,8 @@ export type AppState = {
   project: ProjectInfo | null;
   projectBinding: OpenProjectBinding | null;
   projectHydrated: boolean;
+  openProjectTabRoots: string[];
+  projectInfoByRoot: Record<string, ProjectInfo>;
   /** True when the user removed all projects — forces welcome screen even though backend still has a project loaded. */
   showWelcome: boolean;
   projectTransition:
@@ -580,11 +585,40 @@ export type AppState = {
   didYouKnowEnabled: boolean;
   workViewByProject: Record<string, WorkProjectViewState>;
   laneWorkViewByScope: Record<string, WorkProjectViewState>;
+  /**
+   * Per-project lane / chat selection. Switching projects stashes the current
+   * selection here keyed by project root so switching BACK restores the same
+   * lane and chat instead of resetting to "first lane". This is what makes
+   * a project tab feel like a real workspace tab — you come back to exactly
+   * what you left.
+   */
+  laneSelectionByProject: Record<string, { laneId: string | null; sessionId: string | null }>;
+  /**
+   * Per-project lane list cache. On project switch we apply the cached lanes
+   * IMMEDIATELY (no loading flicker, no chat-pane unmount) and refresh in the
+   * background. Without this, every switch wipes `lanes` to `[]`, which
+   * unmounts the chat UI even though the agent runtime is still alive on the
+   * backend — making it look like the chat closed.
+   */
+  laneCacheByProject: Record<string, { lanes: LaneSummary[]; laneSnapshots: LaneListSnapshot[] }>;
+  /**
+   * Per-project sessions list cache (chats, terminals, CLI runs). Same
+   * stale-while-revalidate pattern as `laneCacheByProject`. Without this,
+   * useWorkSessions wipes `sessions` to `[]` on every projectRoot change,
+   * which blanks the work view's chat tabs and terminals for several
+   * seconds until the IPC fetch returns. With this, the cached sessions
+   * render instantly and the refresh runs silently in the background.
+   */
+  sessionsCacheByProject: Record<string, unknown[]>;
   /** Session-scoped banner dismissals. Pruned when a project is closed/switched so the maps don't leak. */
   dismissedMissingAiBannerRoots: SessionDismissMap;
   dismissedGithubBannerRoots: SessionDismissMap;
 
   setProject: (project: ProjectInfo | null) => void;
+  setOpenProjectTabRoots: (
+    next: string[] | ((prev: string[]) => string[])
+  ) => void;
+  rememberProjectInfo: (project: ProjectInfo) => void;
   setProjectBinding: (binding: OpenProjectBinding | null) => void;
   setProjectHydrated: (hydrated: boolean) => void;
   setShowWelcome: (show: boolean) => void;
@@ -666,15 +700,6 @@ type LaneRefreshRequest = {
   includeAutoRebaseStatus: boolean;
 };
 
-let warmupTimer: number | null = null;
-/** Monotonic counter incremented before each lane refresh request.
- *  Slower responses whose token doesn't match the latest value are discarded. */
-let laneRefreshVersion = 0;
-let laneRefreshInFlight: Promise<void> | null = null;
-let activeLaneRefreshProjectKey: string | null = null;
-let activeLaneRefreshRequest: LaneRefreshRequest | null = null;
-let pendingLaneRefreshRequest: LaneRefreshRequest | null = null;
-
 function normalizeLaneRefreshRequest(options?: {
   includeStatus?: boolean;
   includeSnapshots?: boolean;
@@ -714,25 +739,6 @@ function withPreservedLaneStatus(
     : lane;
 }
 
-function scheduleProjectHydration(get: () => AppState) {
-  if (warmupTimer != null) {
-    window.clearTimeout(warmupTimer);
-  }
-  const delay = Math.max(1_200, 1_800);
-  warmupTimer = window.setTimeout(() => {
-    warmupTimer = null;
-    void get().refreshLanes({
-      includeStatus: true,
-      includeConflictStatus: false,
-      includeRebaseSuggestions: false,
-      includeAutoRebaseStatus: false,
-    }).catch((err) => {
-      console.debug("Scheduled lane refresh failed:", err);
-    });
-    void get().refreshProviderMode();
-  }, delay);
-}
-
 function formatProjectTransitionError(
   kind: "opening" | "switching" | "closing",
   error: unknown,
@@ -750,10 +756,41 @@ function formatProjectTransitionError(
   return raw.length > 0 ? raw : "Project action failed.";
 }
 
-export const useAppStore = create<AppState>((set, get) => ({
+const createAppState: StateCreator<AppState> = (set, get) => {
+  let warmupTimer: number | null = null;
+  /** Monotonic counter incremented before each lane refresh request.
+   *  Slower responses whose token doesn't match the latest value are discarded. */
+  let laneRefreshVersion = 0;
+  let laneRefreshInFlight: Promise<void> | null = null;
+  let activeLaneRefreshProjectKey: string | null = null;
+  let activeLaneRefreshRequest: LaneRefreshRequest | null = null;
+  let pendingLaneRefreshRequest: LaneRefreshRequest | null = null;
+
+  const scheduleProjectHydration = () => {
+    if (warmupTimer != null) {
+      window.clearTimeout(warmupTimer);
+    }
+    const delay = Math.max(1_200, 1_800);
+    warmupTimer = window.setTimeout(() => {
+      warmupTimer = null;
+      void get().refreshLanes({
+        includeStatus: true,
+        includeConflictStatus: false,
+        includeRebaseSuggestions: false,
+        includeAutoRebaseStatus: false,
+      }).catch((err) => {
+        console.debug("Scheduled lane refresh failed:", err);
+      });
+      void get().refreshProviderMode();
+    }, delay);
+  };
+
+  return ({
   project: null,
   projectBinding: null,
   projectHydrated: false,
+  openProjectTabRoots: [],
+  projectInfoByRoot: {},
   showWelcome: true,
   projectTransition: null,
   projectTransitionError: null,
@@ -786,6 +823,9 @@ export const useAppStore = create<AppState>((set, get) => ({
   didYouKnowEnabled: initialUserPreferences.didYouKnowEnabled,
   workViewByProject: initialPersistedWorkViews.workViewByProject,
   laneWorkViewByScope: initialPersistedWorkViews.laneWorkViewByScope,
+  laneSelectionByProject: {},
+  laneCacheByProject: {},
+  sessionsCacheByProject: {},
   dismissedMissingAiBannerRoots: {},
   dismissedGithubBannerRoots: {},
 
@@ -795,6 +835,15 @@ export const useAppStore = create<AppState>((set, get) => ({
       const nextProjectRoot = project?.rootPath ?? null;
       return {
         project,
+        projectInfoByRoot: project
+          ? {
+              ...prev.projectInfoByRoot,
+              [project.rootPath]: project,
+            }
+          : prev.projectInfoByRoot,
+        openProjectTabRoots: project && !prev.openProjectTabRoots.includes(project.rootPath)
+          ? [...prev.openProjectTabRoots, project.rootPath]
+          : prev.openProjectTabRoots,
         projectBinding: project
           ? {
             kind: "local",
@@ -809,6 +858,18 @@ export const useAppStore = create<AppState>((set, get) => ({
           previousProjectRoot !== nextProjectRoot ? {} : prev.laneDeleteProgressByLaneId,
       };
     }),
+  setOpenProjectTabRoots: (next) =>
+    set((prev) => ({
+      openProjectTabRoots:
+        typeof next === "function" ? next(prev.openProjectTabRoots) : next,
+    })),
+  rememberProjectInfo: (project) =>
+    set((prev) => ({
+      projectInfoByRoot: {
+        ...prev.projectInfoByRoot,
+        [project.rootPath]: project,
+      },
+    })),
   setProjectBinding: (projectBinding) => set({ projectBinding }),
   setProjectHydrated: (projectHydrated) => set({ projectHydrated }),
   setShowWelcome: (showWelcome) => set({ showWelcome }),
@@ -819,7 +880,20 @@ export const useAppStore = create<AppState>((set, get) => ({
       laneDeleteProgressByLaneId:
         typeof next === "function" ? next(prev.laneDeleteProgressByLaneId) : next,
     })),
-  selectLane: (laneId) => set({ selectedLaneId: laneId }),
+  selectLane: (laneId) =>
+    set((prev) => {
+      const projectRoot = prev.project?.rootPath ?? null;
+      if (!projectRoot) return { selectedLaneId: laneId };
+      const previousSelection =
+        prev.laneSelectionByProject[projectRoot] ?? { laneId: null, sessionId: null };
+      return {
+        selectedLaneId: laneId,
+        laneSelectionByProject: {
+          ...prev.laneSelectionByProject,
+          [projectRoot]: { ...previousSelection, laneId },
+        },
+      };
+    }),
   setLaneInspectorTab: (laneId, tab) =>
     set((prev) => ({
       laneInspectorTabs: {
@@ -832,7 +906,20 @@ export const useAppStore = create<AppState>((set, get) => ({
       const { [laneId]: _, ...rest } = prev.laneInspectorTabs;
       return { laneInspectorTabs: rest };
     }),
-  focusSession: (sessionId) => set({ focusedSessionId: sessionId }),
+  focusSession: (sessionId) =>
+    set((prev) => {
+      const projectRoot = prev.project?.rootPath ?? null;
+      if (!projectRoot) return { focusedSessionId: sessionId };
+      const previousSelection =
+        prev.laneSelectionByProject[projectRoot] ?? { laneId: null, sessionId: null };
+      return {
+        focusedSessionId: sessionId,
+        laneSelectionByProject: {
+          ...prev.laneSelectionByProject,
+          [projectRoot]: { ...previousSelection, sessionId },
+        },
+      };
+    }),
   setTheme: (theme) =>
     set((prev) => {
       const next = { ...prev, theme };
@@ -1071,6 +1158,15 @@ export const useAppStore = create<AppState>((set, get) => ({
           workViewByProject: prev.workViewByProject,
           laneWorkViewByScope: nextLaneWorkViews,
         });
+        // Cache the lane list per project root so the next switch back to this
+        // project can apply lanes immediately (no flicker, no chat unmount).
+        const activeProjectRoot = get().project?.rootPath ?? null;
+        const nextLaneCache = activeProjectRoot
+          ? {
+              ...prev.laneCacheByProject,
+              [activeProjectRoot]: { lanes, laneSnapshots: nextSnapshots },
+            }
+          : prev.laneCacheByProject;
         return {
           laneSnapshots: nextSnapshots,
           lanes,
@@ -1078,11 +1174,18 @@ export const useAppStore = create<AppState>((set, get) => ({
           selectedLaneId: nextSelected,
           laneInspectorTabs: nextTabs,
           laneWorkViewByScope: nextLaneWorkViews,
+          laneCacheByProject: nextLaneCache,
         };
       });
     };
 
-    set({ lanesLoading: true });
+    // Only show a loading spinner when there's nothing to display. If we
+    // already have cached lanes (stale-while-revalidate after a project
+    // switch), keep `lanesLoading: false` so the chat pane + lane list stay
+    // visually stable while we refresh silently in the background.
+    if (get().lanes.length === 0) {
+      set({ lanesLoading: true });
+    }
 
     if (laneRefreshInFlight) {
       const activeRequest = activeLaneRefreshRequest;
@@ -1183,31 +1286,36 @@ export const useAppStore = create<AppState>((set, get) => ({
         return null;
       }
       get().setProject(project);
-      set((prev) => ({
-        projectHydrated: true,
-        showWelcome: false,
-        projectTransition: null,
-        projectTransitionError: null,
-        isNewTabOpen: false,
-        laneSnapshots: [],
-        lanes: [],
-        lanesLoading: true,
-        laneDeleteProgressByLaneId: {},
-        selectedLaneId: null,
-        focusedSessionId: null,
-        laneInspectorTabs: {},
-        keybindings: null,
-        terminalAttention: EMPTY_TERMINAL_ATTENTION,
-        dismissedMissingAiBannerRoots: pickDismissMapForRoots(prev.dismissedMissingAiBannerRoots, [project.rootPath]),
-        dismissedGithubBannerRoots: pickDismissMapForRoots(prev.dismissedGithubBannerRoots, [project.rootPath]),
-      }));
+      set((prev) => {
+        const restoredSelection =
+          prev.laneSelectionByProject[project.rootPath] ?? { laneId: null, sessionId: null };
+        const cachedLanes = prev.laneCacheByProject[project.rootPath];
+        return {
+          projectHydrated: true,
+          showWelcome: false,
+          projectTransition: null,
+          projectTransitionError: null,
+          isNewTabOpen: false,
+          laneSnapshots: cachedLanes?.laneSnapshots ?? [],
+          lanes: cachedLanes?.lanes ?? [],
+          lanesLoading: !cachedLanes,
+          laneDeleteProgressByLaneId: {},
+          selectedLaneId: restoredSelection.laneId,
+          focusedSessionId: restoredSelection.sessionId,
+          laneInspectorTabs: {},
+          keybindings: null,
+          terminalAttention: EMPTY_TERMINAL_ATTENTION,
+          dismissedMissingAiBannerRoots: pickDismissMapForRoots(prev.dismissedMissingAiBannerRoots, [project.rootPath]),
+          dismissedGithubBannerRoots: pickDismissMapForRoots(prev.dismissedGithubBannerRoots, [project.rootPath]),
+        };
+      });
       invalidateAiDiscoveryCache(project.rootPath);
       invalidateProjectConfigCache(project.rootPath);
       void Promise.allSettled([
         get().refreshLanes({ includeStatus: false }),
         get().refreshKeybindings()
       ]);
-      scheduleProjectHydration(get);
+      scheduleProjectHydration();
       return project;
     } catch (error) {
       set({
@@ -1223,47 +1331,109 @@ export const useAppStore = create<AppState>((set, get) => ({
     // Invalidate in-flight lane refreshes before the async switch so stale
     // responses from the previous project are discarded immediately.
     ++laneRefreshVersion;
+    // Stash the OUTGOING project's lane/session selection so switching back
+    // restores it instead of falling through to "first lane".
+    const outgoingProjectRoot = get().project?.rootPath ?? null;
+    const outgoingSelection = {
+      laneId: get().selectedLaneId,
+      sessionId: get().focusedSessionId,
+    };
+    const cachedProject = get().projectInfoByRoot[rootPath] ?? null;
+    const isWarmTabSwitch =
+      cachedProject != null && get().openProjectTabRoots.includes(rootPath);
+    if (isWarmTabSwitch && cachedProject) {
+      get().setProject(cachedProject);
+    }
+    const restoredWarmSelection =
+      cachedProject != null
+        ? get().laneSelectionByProject[cachedProject.rootPath] ?? { laneId: null, sessionId: null }
+        : { laneId: null, sessionId: null };
     set({
-      projectTransition: {
-        kind: "switching",
-        rootPath,
-        startedAtMs: Date.now(),
-      },
+      projectTransition: isWarmTabSwitch
+        ? null
+        : {
+            kind: "switching",
+            rootPath,
+            startedAtMs: Date.now(),
+          },
       projectTransitionError: null,
-      projectBinding: null,
+      projectBinding: isWarmTabSwitch && cachedProject
+        ? {
+            kind: "local",
+            key: `local:${cachedProject.rootPath}`,
+            rootPath: cachedProject.rootPath,
+            displayName: cachedProject.displayName,
+          }
+        : null,
+      ...(isWarmTabSwitch
+        ? {
+            projectHydrated: true,
+            showWelcome: false,
+            isNewTabOpen: false,
+            selectedLaneId: restoredWarmSelection.laneId,
+            focusedSessionId: restoredWarmSelection.sessionId,
+          }
+        : {}),
+      ...(outgoingProjectRoot
+        ? {
+            laneSelectionByProject: {
+              ...get().laneSelectionByProject,
+              [outgoingProjectRoot]: outgoingSelection,
+            },
+          }
+        : {}),
     });
     try {
       const project = await window.ade.project.switchToPath(rootPath);
       get().setProject(project);
+      const restoredSelection =
+        get().laneSelectionByProject[project.rootPath] ?? { laneId: null, sessionId: null };
+      // Stale-while-revalidate: if we have cached lanes for the destination
+      // project, apply them IMMEDIATELY so the chat pane and terminal stay
+      // mounted across the switch (their `lockSessionId` keeps the agent
+      // runtime attached). Then refreshLanes runs in the background and
+      // replaces the cache when fresh data arrives.
+      const cachedLanes = get().laneCacheByProject[project.rootPath];
       // Banner-dismiss pruning happens in the second `set` call below, after recents are fetched,
       // so we can retain dismissals for the active project + all recent projects in one pass.
-      set({
-        projectHydrated: true,
-        showWelcome: false,
-        projectTransition: null,
-        projectTransitionError: null,
-        isNewTabOpen: false,
-        laneSnapshots: [],
-        lanes: [],
-        lanesLoading: true,
-        laneDeleteProgressByLaneId: {},
-        selectedLaneId: null,
-        focusedSessionId: null,
-        laneInspectorTabs: {},
-        keybindings: null,
-        terminalAttention: EMPTY_TERMINAL_ATTENTION,
-      });
+      set(isWarmTabSwitch
+        ? {
+            projectTransition: null,
+            projectTransitionError: null,
+            projectHydrated: true,
+            showWelcome: false,
+            isNewTabOpen: false,
+          }
+        : {
+            projectHydrated: true,
+            showWelcome: false,
+            projectTransition: null,
+            projectTransitionError: null,
+            isNewTabOpen: false,
+            laneSnapshots: cachedLanes?.laneSnapshots ?? [],
+            lanes: cachedLanes?.lanes ?? [],
+            lanesLoading: !cachedLanes,
+            laneDeleteProgressByLaneId: {},
+            selectedLaneId: restoredSelection.laneId,
+            focusedSessionId: restoredSelection.sessionId,
+            laneInspectorTabs: {},
+            keybindings: null,
+            terminalAttention: EMPTY_TERMINAL_ATTENTION,
+          });
       invalidateAiDiscoveryCache(rootPath);
       invalidateProjectConfigCache(rootPath);
       void Promise.allSettled([
         get().refreshLanes({ includeStatus: false }),
         get().refreshKeybindings()
       ]);
-      scheduleProjectHydration(get);
+      scheduleProjectHydration();
 
       const hasProjectScopedStateToPrune =
         Object.keys(get().workViewByProject).length > 1 ||
         Object.keys(get().laneWorkViewByScope).length > 0 ||
+        Object.keys(get().laneSelectionByProject).length > 1 ||
+        Object.keys(get().laneCacheByProject).length > 1 ||
+        Object.keys(get().sessionsCacheByProject).length > 1 ||
         Object.keys(get().dismissedMissingAiBannerRoots).length > 1 ||
         Object.keys(get().dismissedGithubBannerRoots).length > 1;
       if (!hasProjectScopedStateToPrune) return;
@@ -1276,6 +1446,9 @@ export const useAppStore = create<AppState>((set, get) => ({
           set((prev) => {
             const nextWorkViews: Record<string, WorkProjectViewState> = {};
             const nextLaneWorkViews: Record<string, WorkProjectViewState> = {};
+            const nextLaneSelections: Record<string, { laneId: string | null; sessionId: string | null }> = {};
+            const nextLaneCache: Record<string, { lanes: LaneSummary[]; laneSnapshots: LaneListSnapshot[] }> = {};
+            const nextSessionsCache: Record<string, unknown[]> = {};
             for (const [key, value] of Object.entries(prev.workViewByProject)) {
               if (key === activeRoot || recentRoots.has(key)) nextWorkViews[key] = value;
             }
@@ -1283,6 +1456,15 @@ export const useAppStore = create<AppState>((set, get) => ({
               const projectKey = scopeKey.split("::")[0];
               if (projectKey === activeRoot || recentRoots.has(projectKey)) nextLaneWorkViews[scopeKey] = value;
             }
+            for (const [key, value] of Object.entries(prev.laneSelectionByProject)) {
+              if (key === activeRoot || recentRoots.has(key)) nextLaneSelections[key] = value;
+            }
+            for (const [key, value] of Object.entries(prev.laneCacheByProject)) {
+              if (key === activeRoot || recentRoots.has(key)) nextLaneCache[key] = value;
+            }
+            for (const [key, value] of Object.entries(prev.sessionsCacheByProject)) {
+              if (key === activeRoot || recentRoots.has(key)) nextSessionsCache[key] = value;
+            }
             persistWorkViewState({
               workViewByProject: nextWorkViews,
               laneWorkViewByScope: nextLaneWorkViews,
@@ -1290,6 +1472,9 @@ export const useAppStore = create<AppState>((set, get) => ({
             return {
               workViewByProject: nextWorkViews,
               laneWorkViewByScope: nextLaneWorkViews,
+              laneSelectionByProject: nextLaneSelections,
+              laneCacheByProject: nextLaneCache,
+              sessionsCacheByProject: nextSessionsCache,
               dismissedMissingAiBannerRoots: pickDismissMapForRoots(prev.dismissedMissingAiBannerRoots, retainedRoots),
               dismissedGithubBannerRoots: pickDismissMapForRoots(prev.dismissedGithubBannerRoots, retainedRoots),
             };
@@ -1386,6 +1571,7 @@ export const useAppStore = create<AppState>((set, get) => ({
         laneInspectorTabs: {},
         keybindings: null,
         terminalAttention: EMPTY_TERMINAL_ATTENTION,
+        openProjectTabRoots: [],
         // No active project: drop every dismiss entry so reopening the same project later starts with a clean slate.
         dismissedMissingAiBannerRoots: {},
         dismissedGithubBannerRoots: {},
@@ -1399,4 +1585,92 @@ export const useAppStore = create<AppState>((set, get) => ({
       throw error;
     }
   }
-}));
+  });
+};
+
+export type AppStoreApi = StoreApi<AppState>;
+
+const rootAppStore = createStore<AppState>()(createAppState);
+const AppStoreContext = createContext<AppStoreApi | null>(null);
+
+export function createProjectAppStore(project: ProjectInfo): AppStoreApi {
+  const store = createStore<AppState>()(createAppState);
+  const rootState = rootAppStore.getState();
+  store.setState({
+    project,
+    projectBinding: {
+      kind: "local",
+      key: `local:${project.rootPath}`,
+      rootPath: project.rootPath,
+      displayName: project.displayName,
+    },
+    projectHydrated: true,
+    showWelcome: false,
+    isNewTabOpen: false,
+    theme: rootState.theme,
+    terminalPreferences: rootState.terminalPreferences,
+    codeBlockCopyButtonPosition: rootState.codeBlockCopyButtonPosition,
+    agentTurnCompletionSound: rootState.agentTurnCompletionSound,
+    agentTurnCompletionSoundVolume: rootState.agentTurnCompletionSoundVolume,
+    agentTurnCompletionSoundQuietWhenFocused: rootState.agentTurnCompletionSoundQuietWhenFocused,
+    chatFontSizePx: rootState.chatFontSizePx,
+    chatUserMinimapEnabled: rootState.chatUserMinimapEnabled,
+    chatTranscriptDensity: rootState.chatTranscriptDensity,
+    chatChromeTint: rootState.chatChromeTint,
+    chatShellGeometry: rootState.chatShellGeometry,
+    smartTooltipsEnabled: rootState.smartTooltipsEnabled,
+    onboardingEnabled: rootState.onboardingEnabled,
+    didYouKnowEnabled: rootState.didYouKnowEnabled,
+    setTheme: rootState.setTheme,
+    setTerminalPreferences: rootState.setTerminalPreferences,
+    setCodeBlockCopyButtonPosition: rootState.setCodeBlockCopyButtonPosition,
+    setAgentTurnCompletionSound: rootState.setAgentTurnCompletionSound,
+    setAgentTurnCompletionSoundVolume: rootState.setAgentTurnCompletionSoundVolume,
+    setAgentTurnCompletionSoundQuietWhenFocused: rootState.setAgentTurnCompletionSoundQuietWhenFocused,
+    setChatFontSizePx: rootState.setChatFontSizePx,
+    setChatUserMinimapEnabled: rootState.setChatUserMinimapEnabled,
+    setChatTranscriptDensity: rootState.setChatTranscriptDensity,
+    setChatChromeTint: rootState.setChatChromeTint,
+    setChatShellGeometry: rootState.setChatShellGeometry,
+    resetThemeAndChatFontDefaults: rootState.resetThemeAndChatFontDefaults,
+    setSmartTooltipsEnabled: rootState.setSmartTooltipsEnabled,
+    setOnboardingEnabled: rootState.setOnboardingEnabled,
+    setDidYouKnowEnabled: rootState.setDidYouKnowEnabled,
+  });
+  return store;
+}
+
+export function hydrateProjectAppStore(store: AppStoreApi, state: Partial<AppState>): void {
+  store.setState(state);
+}
+
+export function useAppStoreApi(): AppStoreApi {
+  return useContext(AppStoreContext) ?? rootAppStore;
+}
+
+export function AppStoreProvider({
+  store,
+  children,
+}: {
+  store: AppStoreApi;
+  children: ReactNode;
+}): React.ReactElement {
+  return React.createElement(AppStoreContext.Provider, { value: store }, children);
+}
+
+type UseAppStore = {
+  <T>(selector: (state: AppState) => T): T;
+  getState: AppStoreApi["getState"];
+  setState: AppStoreApi["setState"];
+  subscribe: AppStoreApi["subscribe"];
+};
+
+export const useAppStore = Object.assign(
+  (<T,>(selector: (state: AppState) => T): T =>
+    useStore(useContext(AppStoreContext) ?? rootAppStore, selector)) as UseAppStore,
+  {
+    getState: rootAppStore.getState,
+    setState: rootAppStore.setState,
+    subscribe: rootAppStore.subscribe,
+  },
+);
diff --git a/apps/desktop/src/shared/chatSubagents.ts b/apps/desktop/src/shared/chatSubagents.ts
new file mode 100644
index 000000000..bc0f06d44
--- /dev/null
+++ b/apps/desktop/src/shared/chatSubagents.ts
@@ -0,0 +1,487 @@
+import type {
+  AgentChatEvent,
+  AgentChatEventEnvelope,
+  AgentChatSessionSummary,
+} from "./types/chat";
+
+export type SubagentSnapshot = {
+  id: string;
+  name: string;
+  kind: "subagent" | "teammate";
+  status: "running" | "completed" | "failed" | "stopped";
+  summary: string;
+  parentToolUseId?: string | null;
+  turnId?: string | null;
+  background?: boolean;
+  startedAt?: string | null;
+  endedAt?: string | null;
+  tokens?: number;
+  durationMs?: number;
+  lastToolName?: string;
+};
+
+export type ChatInfoPlanStep = {
+  text: string;
+  status: "pending" | "in_progress" | "completed" | "failed";
+};
+
+export type ChatInfoPlan = {
+  current: number;
+  total: number;
+  steps: ChatInfoPlanStep[];
+  live: boolean;
+} | null;
+
+export type SubagentPaneSection = "main" | "subagents" | "teammates" | "background";
+
+export type SubagentPaneRow =
+  | { kind: "main"; key: "main"; section: "main"; label: string }
+  | { kind: "snapshot"; key: string; section: Exclude<SubagentPaneSection, "main">; snapshot: SubagentSnapshot };
+
+export type SubagentPaneContent = {
+  snapshots: SubagentSnapshot[];
+};
+
+// Vertical offset of the first selectable roster row in the rendered chat-info
+// pane (header + status + plan + goal occupy the preceding lines). Used only by
+// the mouse-click → row mapper.
+const SUBAGENT_PANE_TABLE_START_LINE = 4;
+
+function textField(value: unknown): string | null {
+  return typeof value === "string" && value.trim().length > 0 ? value.trim() : null;
+}
+
+function eventType(event: AgentChatEvent): string {
+  return String((event as { type?: unknown }).type ?? "");
+}
+
+function eventSubagentIds(event: AgentChatEvent): string[] {
+  const record = event as { taskId?: unknown; agentId?: unknown };
+  const ids = [
+    textField(record.taskId),
+    textField(record.agentId),
+  ].filter((value): value is string => value != null);
+  return [...new Set(ids)];
+}
+
+function eventParentToolUseId(event: AgentChatEvent): string | null {
+  return textField((event as { parentToolUseId?: unknown }).parentToolUseId);
+}
+
+export function workEventItemId(event: AgentChatEvent): string | null {
+  if (event.type !== "tool_call" && event.type !== "tool_result" && event.type !== "command" && event.type !== "file_change") {
+    return null;
+  }
+  return textField((event as { itemId?: unknown }).itemId);
+}
+
+export function workEventParentItemId(event: AgentChatEvent): string | null {
+  if (event.type !== "tool_call" && event.type !== "tool_result") {
+    return null;
+  }
+  return textField((event as { parentItemId?: unknown }).parentItemId);
+}
+
+export function planFromEvent(event: Extract<AgentChatEvent, { type: "plan" }>): ChatInfoPlan {
+  const completed = event.steps.filter((step) => step.status === "completed").length;
+  const inProgress = event.steps.findIndex((step) => step.status === "in_progress");
+  const current = inProgress >= 0 ? inProgress + 1 : completed;
+  return {
+    current,
+    total: event.steps.length,
+    steps: event.steps.map((step) => ({ text: step.text, status: step.status })),
+    live: event.steps.some((step) => step.status === "in_progress"),
+  };
+}
+
+export function latestPlan(events: AgentChatEventEnvelope[]): ChatInfoPlan {
+  for (let index = events.length - 1; index >= 0; index -= 1) {
+    const event = events[index]?.event;
+    if (event?.type === "plan") return planFromEvent(event);
+  }
+  return null;
+}
+
+function buildResolvedSubagentIdsByParent(events: AgentChatEventEnvelope[]): Map<string, Set<string>> {
+  const idsByParent = new Map<string, Set<string>>();
+  for (const envelope of events) {
+    const event = envelope.event as Record<string, unknown>;
+    const type = typeof event.type === "string" ? event.type : "";
+    if (!type.startsWith("subagent")) continue;
+    const parent = typeof event.parentToolUseId === "string" && event.parentToolUseId.trim()
+      ? event.parentToolUseId.trim()
+      : null;
+    if (!parent) continue;
+    const taskId = typeof event.taskId === "string" && event.taskId.trim() ? event.taskId.trim() : null;
+    const agentId = typeof event.agentId === "string" && event.agentId.trim() ? event.agentId.trim() : null;
+    const id = agentId ?? taskId;
+    if (!id || id === parent) continue;
+    const ids = idsByParent.get(parent) ?? new Set<string>();
+    ids.add(id);
+    idsByParent.set(parent, ids);
+  }
+  return idsByParent;
+}
+
+function isParentSubagentPlaceholder(snapshot: SubagentSnapshot | undefined, parentToolUseId: string): snapshot is SubagentSnapshot {
+  return Boolean(
+    snapshot
+      && snapshot.id === parentToolUseId
+      && snapshot.parentToolUseId === parentToolUseId,
+  );
+}
+
+export function subagentSnapshotsFromEvents(events: AgentChatEventEnvelope[]): SubagentSnapshot[] {
+  const snapshots = new Map<string, SubagentSnapshot>();
+  const terminalTurnIds = new Set<string>();
+  const resolvedIdsByParent = buildResolvedSubagentIdsByParent(events);
+
+  for (const envelope of events) {
+    const event = envelope.event as Record<string, unknown>;
+    const turnId = typeof event.turnId === "string" ? event.turnId : null;
+    if (!turnId) continue;
+    const isDone = event.type === "done";
+    const isTerminalStatus = event.type === "status" && event.turnStatus !== "started";
+    if (isDone || isTerminalStatus) terminalTurnIds.add(turnId);
+  }
+
+  for (const envelope of events) {
+    const event = envelope.event as Record<string, unknown>;
+    const type = typeof event.type === "string" ? event.type : "";
+
+    if (type === "teammate.idle") {
+      const teamName = typeof event.teamName === "string" ? event.teamName : "";
+      const teammateName = typeof event.teammateName === "string" ? event.teammateName : "";
+      if (!teammateName) continue;
+      const id = `teammate:${teamName}:${teammateName}`;
+      const existing = snapshots.get(id);
+      snapshots.set(id, {
+        id,
+        name: teamName ? `${teamName}/${teammateName}` : teammateName,
+        kind: "teammate",
+        status: "running",
+        summary: existing?.summary ?? "idle",
+        turnId: typeof event.turnId === "string" ? event.turnId : existing?.turnId,
+        startedAt: existing?.startedAt ?? envelope.timestamp,
+        tokens: existing?.tokens,
+        durationMs: existing?.durationMs,
+        lastToolName: existing?.lastToolName,
+      });
+      continue;
+    }
+
+    if (type === "task.completed") {
+      const teamName = typeof event.teamName === "string" ? event.teamName : "";
+      const teammateName = typeof event.teammateName === "string" ? event.teammateName : "";
+      const subject = typeof event.subject === "string" ? event.subject : "";
+      if (!teammateName) continue;
+      const id = `teammate:${teamName}:${teammateName}`;
+      const existing = snapshots.get(id);
+      snapshots.set(id, {
+        id,
+        name: existing?.name ?? (teamName ? `${teamName}/${teammateName}` : teammateName),
+        kind: "teammate",
+        status: "completed",
+        summary: subject || existing?.summary || "",
+        turnId: typeof event.turnId === "string" ? event.turnId : existing?.turnId,
+        startedAt: existing?.startedAt ?? envelope.timestamp,
+        endedAt: envelope.timestamp,
+        tokens: existing?.tokens,
+        durationMs: existing?.durationMs,
+        lastToolName: existing?.lastToolName,
+      });
+      continue;
+    }
+
+    if (!type.startsWith("subagent")) continue;
+    const taskId = typeof event.taskId === "string" && event.taskId.trim() ? event.taskId.trim() : null;
+    const agentId = typeof event.agentId === "string" && event.agentId.trim() ? event.agentId.trim() : null;
+    const id = agentId ?? taskId;
+    if (!id) continue;
+    const incomingParentToolUseId = typeof event.parentToolUseId === "string" && event.parentToolUseId.trim()
+      ? event.parentToolUseId.trim()
+      : null;
+    const parentPlaceholder = incomingParentToolUseId ? snapshots.get(incomingParentToolUseId) : undefined;
+    const parentResolvedIds = incomingParentToolUseId ? resolvedIdsByParent.get(incomingParentToolUseId) : undefined;
+    const parentIsPlaceholder = Boolean(
+      incomingParentToolUseId
+        && isParentSubagentPlaceholder(parentPlaceholder, incomingParentToolUseId),
+    );
+    const canAdoptParentPlaceholder = parentIsPlaceholder
+      && parentResolvedIds?.size === 1
+      && parentResolvedIds.has(id);
+    const taskAlias = taskId && taskId !== id ? snapshots.get(taskId) : undefined;
+    const existing = snapshots.get(id) ?? taskAlias ?? (canAdoptParentPlaceholder ? parentPlaceholder : undefined);
+    if (taskId && id !== taskId) snapshots.delete(taskId);
+    if (
+      incomingParentToolUseId
+      && parentIsPlaceholder
+      && (canAdoptParentPlaceholder || (parentResolvedIds && parentResolvedIds.size > 1))
+    ) {
+      snapshots.delete(incomingParentToolUseId);
+    }
+    const agentType = typeof event.agentType === "string" ? event.agentType : "subagent";
+    const usage = event.usage && typeof event.usage === "object" ? event.usage as Record<string, unknown> : {};
+    const parentToolUseId = incomingParentToolUseId ?? existing?.parentToolUseId ?? null;
+    const startedAt = existing?.startedAt ?? envelope.timestamp;
+    const endedAt = type === "subagent_result" || type === "subagent.completed" ? envelope.timestamp : existing?.endedAt;
+    const parsedDurationMs = endedAt && startedAt ? Date.parse(endedAt) - Date.parse(startedAt) : Number.NaN;
+    const fallbackDurationMs = Number.isFinite(parsedDurationMs) ? Math.max(0, parsedDurationMs) : existing?.durationMs;
+    const summaryFromEvent = [event.summary, event.finalSummary, event.text, event.description]
+      .find((value): value is string => typeof value === "string" && value.trim().length > 0);
+    const summary = summaryFromEvent ?? existing?.summary ?? "";
+    const base: SubagentSnapshot = {
+      id,
+      name: typeof event.description === "string" ? event.description : existing?.name ?? agentType,
+      kind: "subagent",
+      status: existing?.status ?? "running",
+      summary,
+      parentToolUseId,
+      turnId: typeof event.turnId === "string" ? event.turnId : existing?.turnId ?? null,
+      background: event.background === true || existing?.background === true,
+      startedAt,
+      endedAt,
+      tokens: typeof usage.totalTokens === "number" ? usage.totalTokens : typeof event.tokens === "number" ? event.tokens : existing?.tokens,
+      durationMs: typeof usage.durationMs === "number" ? usage.durationMs : fallbackDurationMs,
+      lastToolName: typeof event.lastToolName === "string" ? event.lastToolName : existing?.lastToolName,
+    };
+    if (type === "subagent_result" || type === "subagent.completed") {
+      const status = event.status === "failed" || event.status === "stopped" || event.status === "completed" ? event.status : "completed";
+      snapshots.set(id, { ...base, status });
+    } else {
+      snapshots.set(id, { ...base, status: "running" });
+    }
+  }
+
+  for (const [key, snapshot] of snapshots) {
+    if (
+      snapshot.kind === "subagent"
+      && snapshot.status === "running"
+      && snapshot.background !== true
+      && snapshot.turnId
+      && terminalTurnIds.has(snapshot.turnId)
+    ) {
+      const terminalSummary = "Parent turn ended before ADE received a final subagent status";
+      snapshots.set(key, {
+        ...snapshot,
+        status: "stopped",
+        summary: snapshot.summary && snapshot.summary !== snapshot.name ? snapshot.summary : terminalSummary,
+      });
+    }
+  }
+
+  return [...snapshots.values()];
+}
+
+export function buildSubagentPaneRows(content: SubagentPaneContent): SubagentPaneRow[] {
+  const foregroundSubagents = content.snapshots.filter((snap) => (
+    snap.kind === "subagent"
+    && snap.background !== true
+  ));
+  const runningWeight = (snap: SubagentSnapshot): number => (snap.status === "running" ? 0 : 1);
+  const sortedForegroundSubagents = [...foregroundSubagents].sort(
+    (left, right) => runningWeight(left) - runningWeight(right),
+  );
+  const teammates = content.snapshots.filter((snap) => snap.kind === "teammate");
+  const background = content.snapshots.filter((snap) => snap.kind === "subagent" && snap.background === true);
+
+  return [
+    { kind: "main", key: "main", section: "main", label: "main" },
+    ...sortedForegroundSubagents.map((snapshot) => ({ kind: "snapshot" as const, key: snapshot.id, section: "subagents" as const, snapshot })),
+    ...teammates.map((snapshot) => ({ kind: "snapshot" as const, key: snapshot.id, section: "teammates" as const, snapshot })),
+    ...background.map((snapshot) => ({ kind: "snapshot" as const, key: snapshot.id, section: "background" as const, snapshot })),
+  ];
+}
+
+export function selectedSubagentSnapshot(
+  content: SubagentPaneContent,
+  selectedIndex: number,
+): SubagentSnapshot | null {
+  const row = buildSubagentPaneRows(content)[selectedIndex] ?? null;
+  return row?.kind === "snapshot" ? row.snapshot : null;
+}
+
+export function subagentPaneSelectableLineOffsets(
+  content: SubagentPaneContent,
+  selectedIndex = 0,
+): number[] {
+  const rows = buildSubagentPaneRows(content);
+  const offsets: number[] = [];
+  let line = SUBAGENT_PANE_TABLE_START_LINE;
+
+  for (let index = 0; index < rows.length; index += 1) {
+    const row = rows[index]!;
+    const previous = rows[index - 1];
+    const showSection = row.section !== "main" && previous?.section !== row.section;
+    if (showSection) line += 2;
+    offsets.push(line);
+    line += 1;
+    const selectedSnapshotHasDetail = row.kind === "snapshot"
+      && index === selectedIndex
+      && (row.snapshot.lastToolName || row.snapshot.summary);
+    if (row.kind === "main" || selectedSnapshotHasDetail) {
+      line += 1;
+    }
+  }
+
+  return offsets;
+}
+
+export function subagentIndexForPaneLine(
+  content: SubagentPaneContent,
+  line: number,
+  selectedIndex = 0,
+): number | null {
+  if (!Number.isFinite(line)) return null;
+  const offsets = subagentPaneSelectableLineOffsets(content, selectedIndex);
+  if (!offsets.length) return null;
+  const first = offsets[0]!;
+  const last = offsets[offsets.length - 1]!;
+  if (line < first - 1 || line > last + 1) return null;
+
+  let bestIndex = 0;
+  let bestDistance = Number.POSITIVE_INFINITY;
+  for (let index = 0; index < offsets.length; index += 1) {
+    const distance = Math.abs(line - offsets[index]!);
+    if (distance < bestDistance) {
+      bestIndex = index;
+      bestDistance = distance;
+    }
+  }
+  return bestIndex;
+}
+
+export function isLifecycleEventForSnapshot(event: AgentChatEvent, snapshot: SubagentSnapshot): boolean {
+  const type = eventType(event);
+  if (snapshot.kind === "teammate") {
+    if (type === "teammate.idle" || type === "task.completed") {
+      const record = event as { teamName?: unknown; teammateName?: unknown };
+      const teamName = textField(record.teamName) ?? "";
+      const teammateName = textField(record.teammateName) ?? "";
+      return snapshot.id === `teammate:${teamName}:${teammateName}`;
+    }
+    return false;
+  }
+  if (
+    type !== "subagent_started"
+    && type !== "subagent_progress"
+    && type !== "subagent_result"
+    && type !== "subagent.started"
+    && type !== "subagent.progress"
+    && type !== "subagent.completed"
+  ) {
+    return false;
+  }
+  const explicitIds = eventSubagentIds(event);
+  if (explicitIds.length > 0) return explicitIds.includes(snapshot.id);
+  const parentToolUseId = eventParentToolUseId(event);
+  return Boolean(snapshot.parentToolUseId && parentToolUseId === snapshot.parentToolUseId);
+}
+
+function lifecycleText(event: AgentChatEvent, snapshot: SubagentSnapshot): string | null {
+  const type = eventType(event);
+  const record = event as {
+    description?: unknown;
+    summary?: unknown;
+    finalSummary?: unknown;
+    text?: unknown;
+    subject?: unknown;
+    status?: unknown;
+  };
+  if (type === "subagent_started" || type === "subagent.started") {
+    return "Started.";
+  }
+  if (type === "subagent_progress" || type === "subagent.progress") {
+    return textField(record.summary) ?? textField(record.text) ?? null;
+  }
+  if (type === "subagent_result" || type === "subagent.completed") {
+    const status = textField(record.status) ?? snapshot.status;
+    const summary = textField(record.finalSummary) ?? textField(record.summary) ?? snapshot.summary;
+    return `${status}: ${summary || snapshot.name}`;
+  }
+  if (type === "teammate.idle") {
+    return `Teammate idle: ${snapshot.name}`;
+  }
+  if (type === "task.completed") {
+    return `completed: ${textField(record.subject) ?? snapshot.summary ?? snapshot.name}`;
+  }
+  return null;
+}
+
+function syntheticTextEvent(
+  sessionId: string,
+  timestamp: string,
+  sequence: number,
+  turnId: string | null | undefined,
+  text: string,
+): AgentChatEventEnvelope {
+  return {
+    sessionId,
+    timestamp,
+    sequence,
+    event: {
+      type: "text",
+      text,
+      ...(turnId ? { turnId } : {}),
+    },
+  };
+}
+
+export function buildSubagentTranscriptEvents(args: {
+  events: AgentChatEventEnvelope[];
+  activeSession: AgentChatSessionSummary | null;
+  snapshot: SubagentSnapshot;
+}): AgentChatEventEnvelope[] {
+  const sessionId = args.activeSession?.sessionId ?? args.events[0]?.sessionId ?? "subagent";
+  const parentToolUseId = textField(args.snapshot.parentToolUseId);
+  const childItemIds = new Set<string>();
+
+  if (parentToolUseId) {
+    for (const envelope of args.events) {
+      const event = envelope.event;
+      const parentItemId = workEventParentItemId(event);
+      const itemId = workEventItemId(event);
+      if (parentItemId === parentToolUseId && itemId) {
+        childItemIds.add(itemId);
+      }
+    }
+  }
+
+  const transcript: AgentChatEventEnvelope[] = [
+    syntheticTextEvent(
+      sessionId,
+      args.snapshot.startedAt ?? args.events[0]?.timestamp ?? new Date(0).toISOString(),
+      -2,
+      args.snapshot.turnId,
+      `Viewing ${args.snapshot.kind === "teammate" ? "teammate" : args.snapshot.background ? "background agent" : "agent"} transcript. Select Main chat in Chat Info to return.\nTask: ${args.snapshot.name}`,
+    ),
+  ];
+
+  for (const envelope of args.events) {
+    const event = envelope.event;
+    if (isLifecycleEventForSnapshot(event, args.snapshot)) {
+      const text = lifecycleText(event, args.snapshot);
+      if (text) {
+        transcript.push(syntheticTextEvent(sessionId, envelope.timestamp, envelope.sequence ?? 0, args.snapshot.turnId, text));
+      }
+      continue;
+    }
+    const parentItemId = workEventParentItemId(event);
+    const itemId = workEventItemId(event);
+    if (parentToolUseId && (parentItemId === parentToolUseId || (itemId != null && childItemIds.has(itemId)))) {
+      transcript.push(envelope);
+    }
+  }
+
+  if (transcript.length === 1) {
+    transcript.push(syntheticTextEvent(
+      sessionId,
+      args.snapshot.endedAt ?? args.events.at(-1)?.timestamp ?? new Date(0).toISOString(),
+      -1,
+      args.snapshot.turnId,
+      args.snapshot.summary || "No detailed transcript rows were recorded for this agent.",
+    ));
+  }
+
+  return transcript;
+}
diff --git a/apps/desktop/src/shared/cliLaunch.ts b/apps/desktop/src/shared/cliLaunch.ts
index b346c6dc7..c32e8a68e 100644
--- a/apps/desktop/src/shared/cliLaunch.ts
+++ b/apps/desktop/src/shared/cliLaunch.ts
@@ -58,11 +58,6 @@ const LAUNCH_PROFILE_TOOL_TYPES: Record<LaunchProfile, readonly TerminalToolType
   shell: ["shell", "run-shell"],
 };
 
-const ADE_CODEX_STARTUP_CONFIG_FLAGS = [
-  "-c",
-  "mcp_servers.linear.enabled=false",
-] as const;
-
 export function isLaunchProfile(value: string | null | undefined): value is LaunchProfile {
   return typeof value === "string" && (LAUNCH_PROFILES as readonly string[]).includes(value);
 }
@@ -200,16 +195,11 @@ export function buildTrackedCliLaunchCommand(args: {
   }
 
   if (args.provider === "codex") {
-    // ADE has native Linear surfaces and context attachment. Do not let a
-    // stale user-level Linear MCP OAuth/handshake block the Codex TUI's
-    // first paint inside Work. Skip when the user opted into raw config-toml.
-    const codexStartupConfigFlags = args.permissionMode === "config-toml" ? [] : ADE_CODEX_STARTUP_CONFIG_FLAGS;
     const commandArgs: string[] = [
       "--no-alt-screen",
       ...modelToCliFlag(args.model),
       ...codexReasoningEffortFlags(args.reasoningEffort),
       ...permissionModeToCodexFlags(args.permissionMode),
-      ...codexStartupConfigFlags,
       workTabCliPrompt(initialPrompt, skillRoots),
     ];
     return {
diff --git a/apps/desktop/src/shared/ipc.ts b/apps/desktop/src/shared/ipc.ts
index a986aed12..0e5b7b0b1 100644
--- a/apps/desktop/src/shared/ipc.ts
+++ b/apps/desktop/src/shared/ipc.ts
@@ -3,6 +3,7 @@ export const IPC = {
   appGetInfo: "ade.app.getInfo",
   appGetProject: "ade.app.getProject",
   appGetWindowSession: "ade.app.getWindowSession",
+  appSetWindowProjectTabs: "ade.app.setWindowProjectTabs",
   appNewWindow: "ade.app.newWindow",
   appOpenProjectInNewWindow: "ade.app.openProjectInNewWindow",
   appCloseWindow: "ade.app.closeWindow",
@@ -207,6 +208,7 @@ export const IPC = {
   agentChatListClaudeSessions: "ade.agentChat.claudeSessions.list",
   agentChatGetClaudeSessionInfo: "ade.agentChat.claudeSessions.info",
   agentChatGetClaudeSessionMessages: "ade.agentChat.claudeSessions.messages",
+  agentChatGetSubagentTranscript: "ade.agentChat.getSubagentTranscript",
   agentChatGetContextUsage: "ade.agentChat.getContextUsage",
   agentChatRewindFiles: "ade.agentChat.rewindFiles",
   agentChatFileSearch: "ade.agentChat.fileSearch",
@@ -307,6 +309,7 @@ export const IPC = {
   terminalWrite: "ade.terminal.write",
   terminalSignal: "ade.terminal.signal",
   terminalActiveForChat: "ade.terminal.activeForChat",
+  terminalReattachChatCli: "ade.terminal.reattachChatCli",
   diffGetChanges: "ade.diff.getChanges",
   diffGetFile: "ade.diff.getFile",
   diffGetFilePatch: "ade.diff.getFilePatch",
diff --git a/apps/desktop/src/shared/types/automations.ts b/apps/desktop/src/shared/types/automations.ts
index 1e441da0d..061a7e4c9 100644
--- a/apps/desktop/src/shared/types/automations.ts
+++ b/apps/desktop/src/shared/types/automations.ts
@@ -238,6 +238,7 @@ export type AutomationDraftAction =
       sessionTitle?: string;
       targetLaneId?: string | null;
       modelConfig?: ModelConfig;
+      codexFastMode?: boolean;
       permissionConfig?: MissionPermissionConfig;
     })
   | (AutomationDraftActionBase & { type: "ade-action"; adeAction: RunAdeActionConfig })
diff --git a/apps/desktop/src/shared/types/chat.ts b/apps/desktop/src/shared/types/chat.ts
index 7c3962669..9dba2368c 100644
--- a/apps/desktop/src/shared/types/chat.ts
+++ b/apps/desktop/src/shared/types/chat.ts
@@ -950,6 +950,24 @@ export type AgentChatClaudeSessionMessage = {
   text?: string | null;
 };
 
+export type AgentChatSubagentTranscriptArgs = {
+  sessionId: string;
+  agentId: string;
+  /** Optional task id from the legacy `system:task_*` path; the SDK keys on agentId. */
+  taskId?: string | null;
+  laneId?: string | null;
+  limit?: number | null;
+  offset?: number | null;
+};
+
+/**
+ * One subagent transcript entry. Shape mirrors AgentChatClaudeSessionMessage
+ * (the SDK's `SessionMessage` is identical for parent sessions and subagent
+ * transcripts). Returns null for runtimes that don't surface subagent
+ * transcripts (LM Studio, Droid).
+ */
+export type AgentChatSubagentTranscriptMessage = AgentChatClaudeSessionMessage;
+
 export type AgentChatModelInfo = {
   id: string;
   displayName: string;
diff --git a/apps/desktop/src/shared/types/config.ts b/apps/desktop/src/shared/types/config.ts
index 585981009..93c6b97f9 100644
--- a/apps/desktop/src/shared/types/config.ts
+++ b/apps/desktop/src/shared/types/config.ts
@@ -731,6 +731,8 @@ export type AutomationAction = {
   retry?: number;
   /** Optional model override for agent-session actions inside a built-in chain. */
   modelConfig?: ModelConfig;
+  /** Optional Codex fast-mode override for agent-session actions inside a built-in chain. */
+  codexFastMode?: boolean;
   /** Optional permission override for agent-session actions inside a built-in chain. */
   permissionConfig?: MissionPermissionConfig;
   /** Configuration payload for actions of kind `ade-action`. */
@@ -786,6 +788,7 @@ export type AutomationExecution = {
   session?: {
     title?: string | null;
     reasoningEffort?: string | null;
+    codexFastMode?: boolean;
   };
   /**
    * Mission-specific launch hints reused by the automation mission launcher.
diff --git a/apps/desktop/src/shared/types/sessions.ts b/apps/desktop/src/shared/types/sessions.ts
index 30cefb33e..fd2f43fa8 100644
--- a/apps/desktop/src/shared/types/sessions.ts
+++ b/apps/desktop/src/shared/types/sessions.ts
@@ -227,6 +227,19 @@ export type ChatTerminalActiveForChatArgs = {
   chatSessionId: string;
 };
 
+export type ChatTerminalReattachArgs = {
+  chatSessionId: string;
+  cols?: number | null;
+  rows?: number | null;
+};
+
+export type ChatTerminalReattachResult = {
+  terminalId: string;
+  ptyId: string;
+  pid: number | null;
+  relaunched: boolean; // false when the existing PTY was already live
+};
+
 export type TerminalSnapshotCell = {
   text: string;
   fg: number | null;
diff --git a/apps/desktop/src/test/setup.ts b/apps/desktop/src/test/setup.ts
index 9f99f2fc0..e3ba6455b 100644
--- a/apps/desktop/src/test/setup.ts
+++ b/apps/desktop/src/test/setup.ts
@@ -1,7 +1,7 @@
 import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
-import { afterAll } from "vitest";
+import { afterAll, afterEach, beforeEach } from "vitest";
 
 type TestTempTrackerState = {
   installed: boolean;
@@ -100,6 +100,25 @@ if (typeof window !== "undefined" && typeof window.matchMedia !== "function") {
   })) as typeof window.matchMedia;
 }
 
+function ensureWritableWindowAde(): void {
+  if (typeof window === "undefined") return;
+  const descriptor = Object.getOwnPropertyDescriptor(window, "ade");
+  if (!descriptor || descriptor.writable !== false || descriptor.configurable !== true) return;
+  Object.defineProperty(window, "ade", {
+    configurable: true,
+    writable: true,
+    value: descriptor.value,
+  });
+}
+
+beforeEach(() => {
+  ensureWritableWindowAde();
+});
+
+afterEach(() => {
+  ensureWritableWindowAde();
+});
+
 // nwsapi (jsdom's CSS selector engine) throws on Tailwind arbitrary-value
 // class names like `rounded-[8px]` because `[` opens an attribute selector.
 // Patch querySelector/querySelectorAll to swallow the SYNTAX_ERR (code 12)
diff --git a/apps/ios/ADE/Services/SyncService.swift b/apps/ios/ADE/Services/SyncService.swift
index 8f03ad235..88806d6f1 100644
--- a/apps/ios/ADE/Services/SyncService.swift
+++ b/apps/ios/ADE/Services/SyncService.swift
@@ -1430,6 +1430,12 @@ final class SyncService: ObservableObject {
       if hadLiveSocket {
         teardownSocket(reason: "Switching project.")
       }
+      // Drop chat/terminal subscriptions tied to the previous project so we do
+      // not resubscribe to stale session ids after reconnecting to the new
+      // project. Stale subs cause foreign chat events to leak into the new
+      // project's view and may collide with new session ids on the host.
+      resetChatEventState(clearHistory: false)
+      resetTerminalSubscriptionState(clearHistory: true)
       connectionState = .connecting
       setDomainStatus(SyncDomain.allCases, phase: .syncingInitialData)
       Task { @MainActor [weak self] in
@@ -1487,6 +1493,12 @@ final class SyncService: ObservableObject {
       keychain.saveToken(resolvedToken, hostKey: profileStorageKey(profile))
       saveProfile(profile)
       teardownSocket(reason: "Switching project.")
+      // Drop chat/terminal subscriptions tied to the previous project so we do
+      // not resubscribe to stale session ids after reconnecting to the new
+      // project. Stale subs cause foreign chat events to leak into the new
+      // project's view and may collide with new session ids on the host.
+      resetChatEventState(clearHistory: false)
+      resetTerminalSubscriptionState(clearHistory: true)
       let connectedEndpoint = try await connectUsingProfile(
         profile,
         token: resolvedToken,
@@ -6099,13 +6111,18 @@ final class SyncService: ObservableObject {
     case "chat_subscribe":
       if supportsChatStreaming,
          let dict = payload as? [String: Any],
-         let snapshot = try? decode(dict, as: SyncChatSubscribeSnapshotPayload.self) {
+         let snapshot = try? decode(dict, as: SyncChatSubscribeSnapshotPayload.self),
+         subscribedChatSessionIds.contains(snapshot.sessionId) {
         mergeChatEventHistory(sessionId: snapshot.sessionId, events: snapshot.events)
       }
     case "chat_event":
       if supportsChatStreaming,
          let dict = payload as? [String: Any],
-         let envelope = try? decode(dict, as: AgentChatEventEnvelope.self) {
+         let envelope = try? decode(dict, as: AgentChatEventEnvelope.self),
+         subscribedChatSessionIds.contains(envelope.sessionId) {
+        // Gate chat events on the current subscription set so events from a
+        // previous project (still streaming on the host) do not leak into the
+        // newly-active project's view after a quick switch.
         recordChatEventEnvelope(envelope)
       }
     case "terminal_data":
diff --git a/docs/ARCHITECTURE.md b/docs/ARCHITECTURE.md
index 568a7ac13..7be7987e4 100644
--- a/docs/ARCHITECTURE.md
+++ b/docs/ARCHITECTURE.md
@@ -419,7 +419,8 @@ ade.updates.*
 - Every handler is wrapped with a timeout — 30 seconds by default, with explicit longer budgets for known long operations such as direct lane delete, iOS Simulator launch/control, macOS VM provisioning/control, App Control, and built-in browser actions. Runtime-dispatched actions use the runtime-call channel budget; the timeout wrapper no longer inspects the action payload to give `lane.delete` a special runtime-dispatch override.
 - Every handler emits structured tracing: `ipc.invoke.begin`, `ipc.invoke.done`, `ipc.invoke.failed` with call ID, channel, window ID, duration, and summarized args/results.
 - `AppContext` indirection: handlers close over a context pointer that swaps atomically on project switch, so IPC channels remain registered across project transitions.
-- **Multi-window shell** — the app can host multiple `BrowserWindow` instances (for example when opening another project in a dedicated window). Handler tracing already carries **window ID** so logs and diagnostics distinguish which renderer surface invoked a channel; `main.ts` ties each window to its project context before routing into services.
+- **Multi-window shell** — the app can host multiple `BrowserWindow` instances (for example when opening another project in a dedicated window). Handler tracing already carries **window ID** so logs and diagnostics distinguish which renderer surface invoked a channel; `main.ts` ties each window to its **set** of open project roots before routing into services. Two maps in `main.ts` drive this: `windowProjectRoots` tracks the active foreground project per window, and `windowProjectTabRoots` tracks every project root that window currently has open as a tab. Project-scoped event broadcasts (`emitToProjectWindows`) deliver to any window whose active **or** open-tab set contains the project, so background tabs keep receiving live updates. `ade.app.getWindowSession` returns `{ project, binding, openProjectTabs }` for the requesting window; the renderer mirrors its open-tab list back to main with `ade.app.setWindowProjectTabs({ rootPaths })` so the main process can keep those project contexts warm and clean up on window close.
+- **Project context retention.** `MAX_WARM_IDLE_PROJECT_CONTEXTS = 100` is a soft cap for project contexts with no user work. `hasActiveProjectWorkloads(ctx)` protects any context that has live chat sessions (via `agentChatService.hasRetainableSessions()` — any session the user hasn't explicitly closed or deleted, not just mid-turn ones), live PTYs (`ptyService.hasLiveSessions()`), active missions, or queued tests. Eviction is best-effort and never tears down a context with work; the cap exists only as a safety valve against opening hundreds of empty projects in a long session.
 
 ### 5.4 Event subscriptions (push, not poll)
 
@@ -532,17 +533,21 @@ Electron renderer runtime does **not** wrap the app in `React.StrictMode`. Brows
 
 ### 7.2 Global store
 
-`apps/desktop/src/renderer/state/appStore.ts` (~1,325 lines) — Zustand store holding project, lanes, selected lane, theme, provider mode, keybindings, per-project work-view state. Patterns:
+`apps/desktop/src/renderer/state/appStore.ts` — Zustand store holding project, lanes, selected lane, theme, provider mode, keybindings, per-project work-view state. Built as a `createStore<AppState>()(createAppState)` factory so multiple stores can be instantiated; the module exposes a default `rootAppStore` plus a per-project factory and React context:
 
+- `createProjectAppStore(project)` returns a fresh per-project store pre-hydrated with the project binding + a copy of root-store user preferences. Setters for theme/terminal/chat preferences point at the root store so user preferences mutate in one place and are then mirrored into every project store via `hydrateProjectAppStore` whenever `rootPrefs` change in `ProjectTabHost`. This is what lets two open project tabs share a theme even though they have independent lane/chat state.
+- `AppStoreProvider` + `AppStoreContext` scope the active store to a `ProjectSurface` subtree. The `useAppStore` hook reads from `useContext(AppStoreContext) ?? rootAppStore`, and `useAppStoreApi()` returns the bare `StoreApi` for components that want imperative `getState()` access without subscribing. `useAppStore.getState / setState / subscribe` still point at the root store so code that needs cross-window globals (recent projects, user preferences, the root binding) can continue to call it directly.
 - Narrow selectors on components to minimize re-renders.
 - `refreshLanes` accepts independent lane-status and lane-snapshot flags. Callers can refresh cheap runtime snapshot decorations without recomputing git status, or update git status without rebuilding conflict/rebase/auto-rebase overlays; statusless refreshes preserve the previous `LaneStatus`/`parentStatus` in store so the UI does not flicker to unknown git state.
 - Per-project work-view state keyed by project root (`WorkProjectViewState`). Includes the right-edge Work sidebar fields `workSidebarOpen`, `workSidebarTab` (`"git" | "files" | "ios" | "app-control" | "browser"`), and `workSidebarWidthPct` (clamped 26–55) — persisted alongside the rest of the work-view state under `ade.workViewState.v1`. The sidebar consolidates lane-scoped tools that were previously split across separate floating panes; per-chat iOS / App Control drawers still exist on `AgentChatPane` but are suppressed when the chat is mounted as a Work tile so the sidebar owns those surfaces at lane scope. The `browser` tab is the only sidebar tab that is not lane-scoped — the built-in browser is one shared instance per app.
+- Project tab bookkeeping. `openProjectTabRoots: string[]` is the LRU-ordered list of project roots open in the window (mirrored to the main process via `ade.app.setWindowProjectTabs` so background services keep those projects warm); `projectInfoByRoot: Record<string, ProjectInfo>` caches the `ProjectInfo` payload for tab favicons and offline tab rendering. `setProject` is the only path that mutates either map.
+- Stale-while-revalidate switch caches. `laneSelectionByProject` remembers the `{ laneId, sessionId }` selection per project root so switching tabs lands on the lane/chat the user last had open instead of "first lane". `laneCacheByProject` mirrors the last good `{ lanes, laneSnapshots }` per root; `switchProjectToPath` applies the cached entry immediately on switch (no spinner, no chat-pane unmount) and refreshes silently in the background. `sessionsCacheByProject` does the same for `useWorkSessions` so the chat tabs / terminal grid don't blank during a tab swap. All three caches are pruned to active + recent-projects when a project actually changes.
 - Store-owned event subscriptions for high-frequency streams (e.g., missions).
 - `projectRevision` is a monotonically incrementing counter bumped inside `setProject` whenever the active project root actually changes. Long-lived renderer-side caches (most notably the module-level xterm runtime cache in `TerminalView.tsx`) subscribe to it and tear down any entries whose `projectRoot`/`projectRevision` no longer match, so PTYs never bleed between projects. All project-transition paths (`refreshProject`, `openRepo`, `switchProjectToPath`, `closeProject`) go through `setProject` to keep the counter honest.
 
-Domain stores co-located with their pages:
+Domain stores co-located with their pages follow the same factory + context pattern when they need per-page isolation:
 
-- `useMissionsStore` (`components/missions/useMissionsStore.ts`, ~596 lines) — mission list, selected mission, debounced event handling, store-owned timers.
+- `useMissionsStore` (`components/missions/useMissionsStore.ts`) — mission list, selected mission, debounced event handling, store-owned timers. Exposes `createMissionsStore()`, `MissionsStoreProvider`, and `useMissionsStoreApi()`; `MissionsPage` instantiates its own store inside a `MissionsStoreProvider` so a missions surface in one project tab doesn't leak selection / chat-jump-target / prompt-inspector state into another. Components that previously called `useMissionsStore.getState()` now read through `useMissionsStoreApi()` to hit the scoped store. The companion `MissionActiveContext` carries the `active` prop down so `MissionsWorkspace`, `MissionsProductionGate`, `MissionHeader`, `MissionChatV2`, and `CompactUsageMeter` can gate their polling / event subscriptions on whether the missions surface is the foreground tab.
 - `chatDraftStore.ts` — draft messages per chat session.
 
 ### 7.3 Component organization
@@ -576,7 +581,10 @@ Design tokens have been intentionally trimmed. The CTO design tokens at `apps/de
 - `PaneTilingLayout` — recursive pane trees for high-density workspaces, backed by pure ops in `paneTreeOps.ts` (`reconcilePaneTree`, `splitPaneAtEdge`, `swapPanes`, `detectDropEdge`). Trees persist per `layoutId` via `window.ade.tilingTree`; panel sizes persist separately via `DockLayoutState` and are reset whenever the tree mutates.
 - `SplitPane` / resizable panels — structured 2/3-pane views.
 - Work view's grid mode is `PaneTilingLayout` seeded by `buildWorkSessionTilingTree(sessionIds)` (in `renderer/components/terminals/workSessionTiling.ts`); every session becomes a `FloatingPane` leaf with `grid-tile` chrome.
-- The Work surface mounts persistently: `App.tsx`'s `PersistentWorkSurface` keeps `WorkViewArea` in the tree across tab swaps so terminals never tear down on navigation. While inactive the surface is positioned absolute, `inert`, `aria-hidden`, opacity-0, `pointer-events: none`, and pushed behind via `z-index: -1` (the older `hidden` attribute was dropping xterm dimensions on reveal). When it goes back to active, it dispatches the `WORK_SURFACE_REVEALED_EVENT` window event on the next animation frame and again 120 ms later so terminal tiles can clear their texture atlas, force-fit, and refocus.
+- Project tab hosting: `App.tsx`'s `ProjectTabHost` mounts one persistent `ProjectSurface` per open project tab inside a single window. Each `ProjectSurface` owns its own zustand store instance (`createProjectAppStore(project)`), pre-hydrated with the project binding plus a copy of root-store user preferences (theme, terminal preferences, chat font, sound, density, etc.). User-preference setters point at the **root** store, so changes flow to one place and are then mirrored into every project store on the next `rootPrefs` change. A LRU sorts mounted surfaces and caps the warm-mounted set at `WARM_PROJECT_SURFACE_LIMIT = 8`; surfaces beyond that limit are dropped from the React tree (their store entry is GC'd) but the persisted lane/chat caches in the root store keep their data live so a re-mount is cheap.
+- Per-project routing: each surface remembers its own route (`/work`, `/lanes`, `/files`, `/prs`, `/cto`, `/automations`, `/missions`, `/settings`, …) under `ade:project-route:<projectRoot>` in `localStorage`. `ProjectTabHost` swaps which surface is `active` based on the foreground project tab, stashing the outgoing route and replaying the incoming surface's last route via `navigate(..., { replace: true })`. Inactive surfaces stay in the tree (`aria-hidden`, `inert`, absolutely positioned at `z-index: -1`, opacity 0, pointer-events none) so chats / terminals / live polling don't tear down on tab swap.
+- Work-surface reveal: `ProjectRouteContent` keeps the `/work` route mounted lazily inside each project surface. When the surface itself becomes active **and** the route is a work route, it dispatches the `WORK_SURFACE_REVEALED_EVENT` window event so terminal tiles can clear their texture atlas, force-fit, and refocus.
+- Page-level active gating: lazy feature pages (`LanesPage`, `FilesPage`, `WorkspaceGraphPage`, `PRsPage`, `ReviewPage`, `HistoryPage`, `AutomationsPage`, `AutomationsTemplatesPage`, `MissionsPage`, `CtoPage`, `SettingsPage`) accept an `active?: boolean` prop and gate every `useEffect` that fires IPC polling, event subscriptions, or initial data fetches behind it. Inactive surfaces in background project tabs render their last state but don't poll — the project's runtime is still alive, so the freshness is restored on the next refresh when the user returns.
 - The desktop TopBar project tab strip resolves a per-project favicon via `window.ade.project.resolveIcon(rootPath)` and caches the result in a module-local `Map`. Tabs without an icon (or a missing project root) fall back to the `Folder` Phosphor glyph; the same component drives the loading-pulse animation when a tab is being switched into or closed.
 - Layout state persists to SQLite (`layout`, `tilingTree`, `graphState` domains via the `kv` table).
 
diff --git a/docs/features/automations/README.md b/docs/features/automations/README.md
index 2251e6110..fe19e1da8 100644
--- a/docs/features/automations/README.md
+++ b/docs/features/automations/README.md
@@ -55,7 +55,7 @@ Each `AutomationRule` carries:
 - `triggers` — one or more trigger descriptors (see `triggers-and-actions.md`). Normalized to a single primary trigger for legacy compatibility.
 - `execution` — which surface launches. `AutomationExecution`:
   - `{ kind: "mission", targetLaneId?, mission? }` — launches the full mission runtime.
-  - `{ kind: "agent-session", targetLaneId?, session? }` — launches a scoped AI chat thread, recorded as an automation-only chat.
+  - `{ kind: "agent-session", targetLaneId?, session? }` — launches a scoped AI chat thread, recorded as an automation-only chat. `session` carries optional `title`, `reasoningEffort`, and `codexFastMode` (boolean); `codexFastMode` is forwarded to the chat service only when the resolved provider is Codex and the model supports fast mode, so it is safe to set on a rule that may later switch models.
   - `{ kind: "built-in", targetLaneId?, builtIn: { actions: [...] } }` — runs ADE-native deterministic actions (`AutomationAction[]`).
 - `executor` — always `{ mode: "automation-bot" }` (the automation system identifies itself that way in logs and memory).
 - `reviewProfile` — `quick` | `incremental` | `full` | `security` | `release-risk` | `cross-repo-contract`. Drives confidence base and output expectations.
diff --git a/docs/features/automations/triggers-and-actions.md b/docs/features/automations/triggers-and-actions.md
index 74311ca6e..162dcdbad 100644
--- a/docs/features/automations/triggers-and-actions.md
+++ b/docs/features/automations/triggers-and-actions.md
@@ -134,6 +134,7 @@ Baseline tools (always available) come from `buildClaudeReadOnlyWorkerAllowedToo
 - Per-action overrides (apply on top of `execution.*` defaults):
   - `targetLaneId` — overrides the lane this action runs against. Resolves through `getConfiguredTargetLaneId(rule, action)` → `execution.targetLaneId` → trigger lane → primary lane.
   - `modelConfig` (`agent-session` only) — `{ modelId, thinkingLevel? }` overriding the rule's orchestrator model for this step. `thinkingLevel` also feeds the agent-session reasoning effort.
+  - `codexFastMode` (`agent-session` only) — boolean that enables Codex Fast Mode for this step. Only applied when the resolved provider group is `codex` AND the resolved model descriptor supports fast mode (`modelSupportsFastMode`); silently ignored otherwise. Forwarded to the chat service as `codexFastMode: true` on the session create, which causes Codex `thread/start` + `turn/start` JSON-RPC calls to carry `serviceTier: "fast"`. Mirrors the rule-level `execution.session.codexFastMode` toggle and stacks the same way as `modelConfig` / `permissionConfig`.
   - `permissionConfig` (`agent-session` only) — `MissionPermissionConfig` whose `cli`/`providers`/`inProcess` fields are merged onto the rule's permission config; `providers.allowedTools` and `cli.allowedTools` extend (not replace) the rule's allow-list. The `cursor` provider key is supported alongside `claude`/`codex`/`opencode`.
 - Action-specific config on the same object (`command`, `cwd`, `suiteId`, `adeAction`, `prompt`, `sessionTitle`, `laneNameTemplate`, `laneDescriptionTemplate`, `parentLaneId`).
 
diff --git a/docs/features/chat/README.md b/docs/features/chat/README.md
index 347bb3d9c..567667030 100644
--- a/docs/features/chat/README.md
+++ b/docs/features/chat/README.md
@@ -14,7 +14,7 @@ machinery layered on top.
 | `apps/desktop/src/main/services/chat/agentChatService.ts` | Main service: session lifecycle, turn dispatch, event emission, provider adapters, steer queue, handoff, auto-title, prompt-derived lane-name suggestions for auto-created / parallel lanes, event-history snapshots, and active-workload detection used by project/window close guards. Lane naming runs through the session-intelligence prompt path, retries the requested/configured/default title models, then falls back to a prompt slug with an optional temporary suffix for uniqueness. Tracks Codex Fast Mode (`codexFastMode: boolean`) per session and forwards it as `serviceTier: "fast" \| null` on every Codex `thread/start` and `turn/start` JSON-RPC call (see [Agent Routing](agent-routing.md#codex-service-tiers-fast-mode)). Builds ADE guidance from the active lane worktree so bundled Agent Skills roots are lane-scoped in persistent system/developer prompts and any provider fallback injection. Spawns Claude/Codex agent runtimes with `buildAgentRuntimeEnv(managed)` so every agent process inherits `ADE_CHAT_SESSION_ID`, `ADE_LANE_ID`, `ADE_PROJECT_ROOT`, and `ADE_WORKSPACE_ROOT` (used by the agent guidance to call `ade --socket app-control logs` / `terminal read --chat-session "$ADE_CHAT_SESSION_ID"` without resolving the chat ID itself). Claude SDK sessions also resolve the executable through `claudeCodeExecutable.ts` and pass `pathToClaudeCodeExecutable` so packaged builds can prefer the bundled native binary before PATH/auth fallbacks; interrupted Claude turns call `stopTask` for active subagents before emitting stopped subagent results. Large orchestrator file. |
 | `apps/desktop/src/main/services/chat/runtimeEvents.ts` | Canonical cross-runtime event vocabulary (`turn.*`, `content.delta`, `tool.*`, `subagent.*`, teammate/task events, compaction boundaries) plus shims between legacy `AgentChatEvent` rows and the canonical runtime envelope. Claude emits canonical subagent events alongside the legacy rows while the other adapters migrate. |
 | `apps/ade-cli/src/tuiClient/` | Terminal **Work** chat TUI (Ink + React): same action/RPC contracts as desktop, **attached** (socket) or **embedded** (headless runtime via `ade-cli`). See [ADE Code](../ade-code/README.md). |
-| `apps/desktop/src/main/services/builtInBrowser/builtInBrowserService.ts` | Main-process broker for the in-app web browser. Owns a single `persist:ade-browser` partition, multiple `WebContentsView` tabs (cap 10), bounds + visibility against the renderer-supplied frame, debugger-protocol attachment for inspect-mode hit tests, screenshot capture, and emission of `BuiltInBrowserContextItem`s for selected page elements. Spoofs a desktop Chrome `User-Agent` and the matching `Sec-CH-UA*` client hints on every request through `webRequest.onBeforeSendHeaders` so external sign-in flows (Google, etc.) treat the embedded view as a normal desktop Chrome instead of refusing to load — the previous "open Google sign-in in the system browser" branch was removed because the spoofed UA stops Google from blocking the page in the first place. Window-open requests are forwarded into a fresh tab with `openPanel: true` so the Work sidebar Browser tab pops automatically. Backs the `ade.builtInBrowser.*` IPC surface and is consumed by both `ChatBuiltInBrowserPanel` (sidebar Browser tab) and `openExternal.ts` (links inside the renderer route through the built-in browser when the protocol is `http`/`https`/`about:blank`). |
+| `apps/desktop/src/main/services/builtInBrowser/builtInBrowserService.ts` | Main-process broker for the in-app web browser. Owns a single `persist:ade-browser` partition, multiple `WebContentsView` tabs (cap 10), bounds + visibility against the renderer-supplied frame, debugger-protocol attachment for inspect-mode hit tests, screenshot capture, and emission of `BuiltInBrowserContextItem`s for selected page elements. Window-open requests from a page are handled via `setWindowOpenHandler` returning `action: "allow"` + a `createWindow` factory: a new internal tab is created and its `webContents` is returned to Chromium so the popup keeps its real `window.opener` relationship with the opener tab (important for OAuth flows that postMessage back to the parent). The browser session runs with the standard Electron Chrome UA — no header rewriting — but its permission handlers allow a narrow set of Google sign-in capabilities (`hid`, `serial`, `usb`, `storage-access`, `top-level-storage-access`) for requests that originate at `accounts.google.com` so the Google flow's WebAuthn / storage-access probes do not bounce. All other permissions are denied. Backs the `ade.builtInBrowser.*` IPC surface and is consumed by both `ChatBuiltInBrowserPanel` (sidebar Browser tab) and `openExternal.ts` (links inside the renderer route through the built-in browser when the protocol is `http`/`https`/`about:blank`). |
 | `apps/desktop/src/shared/types/builtInBrowser.ts` | Cross-process types for the built-in browser: `BuiltInBrowserStatus`, `BuiltInBrowserTab`, `BuiltInBrowserContextItem` (`kind: "built_in_browser_element" | "built_in_browser_capture"`), `BuiltInBrowserSelectResult`, `BuiltInBrowserScreenshot`, `BuiltInBrowserOpenPanelArgs`, and the `BuiltInBrowserEventPayload` union (`status`, `open-request`, `selection`, `selection-cleared`, `error`). Navigate / create-tab / switch-tab args carry an optional `openPanel: boolean` so callers can ask for the Work sidebar Browser tab to flip open atomically with the navigation. |
 | `apps/desktop/src/main/services/chat/buildClaudeV2Message.ts` | Builds Claude SDK user messages for the `query()` input stream. Handles base64 image content blocks and MIME inference. |
 | `apps/desktop/src/main/services/chat/claudeInputPump.ts` | Async iterable input pump that feeds live user turns into the Claude Agent SDK `query()` stream. |
@@ -38,6 +38,7 @@ machinery layered on top.
 | `apps/desktop/src/main/services/opencode/openCodeBinaryManager.ts` | Resolves the OpenCode CLI: PATH first, then the bundled `node_modules/.bin/opencode`. Cache entries are re-validated with `canRunBinaryCandidate` on every lookup so user installs after launch are picked up; missing-binary lookups are intentionally not cached. `clearOpenCodeBinaryCache()` is wired into the AI integration's full cache reset. |
 | `apps/desktop/src/main/services/opencode/openCodeInventory.ts` | OpenCode provider/model probe. Now classifies model variants into `reasoningTiers` + `serviceTiers` (alias map covering `minimal`/`mini`/`med`/`xhigh`/`extra-high`), reads `capabilities` (tools/vision/reasoning) into descriptor capabilities, and tracks both `modelIds` (connected providers only) and `catalogModelIds` (the full browseable catalog). `OpenCodeProviderInfo.availableModelCount` exposes the connected count separately from `modelCount`. |
 | `apps/desktop/src/shared/chatTranscript.ts` | Pure JSON-lines parser for `AgentChatEventEnvelope` values. Used by both the main process and the renderer. |
+| `apps/desktop/src/shared/chatSubagents.ts` | Cross-target subagent helpers: `buildSubagentPaneRows`, `selectedSubagentSnapshot`, `subagentIndexForPaneLine`, `subagentPaneSelectableLineOffsets`, `buildSubagentTranscriptEvents`, `isLifecycleEventForSnapshot`, plus the `latestPlan` derivation. Both the desktop `ChatSubagentsPanel` and the `apps/ade-cli/src/tuiClient/subagentPane.ts` / `chatInfo.ts` modules re-export from here so the desktop pane and the terminal TUI render the same roster, transcript filter, and plan summary. |
 | `apps/desktop/src/shared/types/chat.ts` | All chat types: `AgentChatSession`, `AgentChatEvent` union, `AgentChatEventHistorySnapshot` (with optional `sessionFound` for stale-session detection), permission modes, pending input, completion reports, `PARALLEL_CHAT_MAX_ATTACHMENTS`, and parallel launch state DTOs. |
 | `apps/desktop/src/renderer/components/chat/AgentChatPane.tsx` | Top-level renderer surface: state derivation, IPC wiring, composer mount, message-list mount, End/Delete chat controls in the header, parallel multi-model lane launch orchestration, transient-lane cleanup, and multi-lane deep-link navigation. Mounts `AgentQuestionModal` when the active pending input is a question/structured-question. Resolves the surface accent colour through `providerChatAccent(provider)` so Claude/Codex/Cursor stay visually consistent regardless of model variant. Visible Work grid tiles flush user/lifecycle/live events immediately and poll-recover active transcripts when IPC misses an event, even when the tile is not focused. Event-history snapshots with `sessionFound: false` clear stale locked-pane state instead of rendering a dead transcript. During project transitions the pane blocks send/model/permission mutations and shows a "Project is switching..." composer placeholder so chat calls do not hit the wrong runtime binding. On macOS, polls `ade.iosSimulator.getStatus` and renders the iOS Simulator drawer toggle in the header when the platform is supported (see [iOS Simulator feature](../ios-simulator/README.md)); selecting elements inside the drawer flows back through the pane as `IosElementContextItem` chips on the composer. Polls `ade.appControl.getStatus` and exposes the App Control drawer toggle when the platform is supported, mounting `ChatAppControlPanel`; selections become `AppControlContextItem` chips + attachments on the composer. See [App Control](../computer-use/app-control.md). When mounted as a Work tile (`SessionSurface` passes `hideLaneToolDrawers={true}`) the iOS, App Control, and chat terminal drawer toggles are suppressed because the Work right-edge sidebar owns those lane-scoped drawers; hidden lane-tool mode also skips App Control status polling and terminal listing. The pane still listens on `ade:agent-chat:add-attachment` / `add-ios-context` / `add-app-control-context` / `add-builtin-browser-context` / `insert-draft` window events so selections from the sidebar flow into the active chat composer when the sidebar's `attachChatSessionId` matches. Work-tab CLI launches pass the active lane worktree into the shared launcher so the spawned CLI sees lane-aware ADE skill roots. Proof remains chat-scoped and stays on the chat header. |
 | `apps/desktop/src/renderer/components/chat/AgentChatMessageList.tsx` | Virtualized transcript renderer. Coalesces resize / measurement updates and, while sticky-to-bottom is active, follows height changes across multiple animation frames so streamed output and late row measurements do not leave the user above the newest message. Programmatic scroll writes are tracked by target scroll position, not a stale counter, so browser-coalesced scroll events do not swallow the next real user gesture. |
@@ -155,11 +156,18 @@ render them, but neither one *runs* them.
   The Work right-edge sidebar's `browser` tab renders this surface
   through `ChatBuiltInBrowserPanel`; any URL clicked elsewhere in the
   renderer routes through `openUrlInAdeBrowser()` so it opens inside
-  the sidebar instead of the system browser. The browser broker spoofs
-  a desktop Chrome User-Agent (with matching `Sec-CH-UA*` headers) so
-  third-party sign-in flows treat the embedded view as desktop Chrome
-  — the older "Google sign-in opens in the system browser" carve-out is
-  gone. Navigation, tab create, switch-tab, and the new dedicated
+  the sidebar instead of the system browser. The broker uses
+  Electron's stock Chrome User-Agent — header rewriting is gone. Pages
+  that call `window.open()` are honoured via `setWindowOpenHandler`
+  returning `action: "allow"` with a `createWindow` factory that
+  produces a new internal tab and hands its `webContents` back to
+  Chromium; this preserves `window.opener` for OAuth `postMessage`
+  callbacks instead of denying the popup and re-navigating in the
+  background. A narrow Google sign-in permission carve-out
+  (`hid`, `serial`, `usb`, `storage-access`,
+  `top-level-storage-access`) is allowed when the requesting URL
+  resolves to `accounts.google.com`; everything else is denied.
+  Navigation, tab create, switch-tab, and the dedicated
   `built_in_browser.showPanel` / `ade.builtInBrowser.showPanel` IPC
   channel each accept `openPanel: true|false`; `true` emits an
   `open-request` event that `TerminalsPage` listens for to flip the
@@ -270,9 +278,15 @@ with reason `"shutdown"`.
 chat counts as active when its session is active, it has a live pending
 input, or its runtime still has work in flight (turn ids, approvals,
 queued steers, subagents, Codex plan follow-ups, Cursor cloud runs,
-etc.). Project/window close probes fail closed: if the chat workload
-probe throws, ADE keeps the project alive instead of closing over a
-possibly running agent.
+etc.). The companion `hasRetainableSessions()` is broader: it returns
+true for **any** managed session that the user has not explicitly
+closed or deleted, including sessions sitting between turns. The
+project-context rebalancer in `main.ts` checks `hasRetainableSessions`
+first so a project context isn't evicted just because every chat
+happens to be idle — the runtime stays warm so the next turn doesn't
+cold-start. Project/window close probes still fail closed: if the chat
+workload probe throws, ADE keeps the project alive instead of closing
+over a possibly running agent.
 
 ## IPC surface
 
@@ -307,7 +321,8 @@ handlers live in `apps/desktop/src/main/services/ipc/registerIpc.ts`.
 | `ade.agentChat.claudeSessions.list` / `.info` / `.messages` | invoke | Claude-only: enumerate SDK sessions, fetch session info, and stream messages for `forkSession` handoff and resume flows. |
 | `ade.agentChat.fileSearch` | invoke | Debounced attachment picker backend. |
 | `ade.agentChat.saveTempAttachment` | invoke | Write pasted/dropped image bytes to a temp file (10 MB cap). Native clipboard image paste prefers `ade.app.saveClipboardImageAttachment` so Electron can save the clipboard PNG directly and return a compact preview. |
-| `ade.agentChat.listSubagents` | invoke | Claude subagent snapshot list. Snapshots are re-keyed on `agentId + parentToolUseId` (not just `taskId`) so multiple subagents spawned from the same parent tool call don't collide, and the renderer panel separates them into three tabs: Subagents, Teammates, and Background. |
+| `ade.agentChat.listSubagents` | invoke | Claude subagent snapshot list. Snapshots are re-keyed on `agentId + parentToolUseId` (not just `taskId`) so multiple subagents spawned from the same parent tool call don't collide, and the renderer panel separates them into three tabs: Subagents, Teammates, and Background. Claude `subagent_*` envelopes are enriched with `agentType` (e.g. `code-reviewer`, `Explore`) by stashing the Task tool's `subagent_type` input at the assistant `tool_use` boundary and joining on `parentToolUseId` when the system-message `task_*` envelope arrives. Codex parallel-agent events carry an `Agent #N` label assigned at first announcement (1-based, per-turn) plus the raw threadId as `agentId`. |
+| `ade.agentChat.getSubagentTranscript` | invoke | Fetch the transcript of one subagent run within a chat session. Dispatch by runtime kind: Claude/ade-code reads the SDK's per-subagent JSONL at `~/.claude/projects/<projectDir>/<sessionId>/subagents/agent-<agentId>.jsonl`; OpenCode pulls the child session's messages over the OpenCode HTTP client (the child session id is the agentId); Codex returns the subset of parent envelopes whose `subagent_*` event matches `taskId === threadId`; Cursor filters the parent stream by the SDK-tagged `agentId`; LM Studio / Droid return `null`. Returns `AgentChatSubagentTranscriptMessage[]` (same shape as `AgentChatClaudeSessionMessage`). |
 | `ade.agentChat.models` | invoke | `{ provider, activateRuntime? }`. For OpenCode `activateRuntime: true` is required to *launch* a probe server; otherwise the main process only returns the cached inventory (via `peekOpenCodeInventoryCache`) and an empty list until a real probe has been run. The renderer cache (`aiDiscoveryCache.ts`) keys on `(projectRoot, provider, activateRuntime)` so passive and active reads don't collide. |
 | `ade.agentChat.modelCatalog` | invoke | `{ mode?, refreshProvider? }` → `AgentChatModelCatalog`. Returns the full provider-grouped catalog (claude / codex / cursor / droid / opencode plus the local `ollama` / `lmstudio` groups when OpenCode-routed) for the desktop and TUI ModelPickers. `mode: "cached"` returns the in-memory snapshot, `"refresh-stale"` reuses the cache but optionally re-probes the named runtime when its per-provider freshness TTL is expired, and `"force"` re-probes unconditionally. `refreshProvider` is one of `"opencode" | "cursor" | "droid" | "lmstudio" | "ollama"`. The catalog carries an optional `stale: true` flag and per-model `connected` / `requiresConfiguration` / `sourceRuntime` / `providerId` / `providerName` annotations that the renderer/TUI use to render auth gates. |
 | `ade.agentChat.getSessionCapabilities` | invoke | Discover supported subagent/review features. |
diff --git a/docs/features/chat/composer-and-ui.md b/docs/features/chat/composer-and-ui.md
index 2f9946d9f..6e9a00e9a 100644
--- a/docs/features/chat/composer-and-ui.md
+++ b/docs/features/chat/composer-and-ui.md
@@ -386,8 +386,35 @@ sibling Codex subagents distinct when they share a `parentToolUseId`:
 it pre-scans every envelope to count the resolved subagent ids per
 parent, only adopts the placeholder parent row when exactly one
 sibling resolves under that parent, and otherwise creates separate
-snapshots keyed by `agentId ?? taskId`. The TUI mirrors this in
-`subagentSnapshotsFromEvents`.
+snapshots keyed by `agentId ?? taskId`. The TUI now imports the same
+pure helpers from `apps/desktop/src/shared/chatSubagents.ts`
+(`buildSubagentPaneRows`, `selectedSubagentSnapshot`,
+`subagentIndexForPaneLine`, `subagentPaneSelectableLineOffsets`,
+`buildSubagentTranscriptEvents`, `isLifecycleEventForSnapshot`,
+`latestPlan`) — `apps/ade-cli/src/tuiClient/subagentPane.ts` and
+`chatInfo.ts` re-export them so desktop and TUI never drift.
+
+Subagent envelopes carry both an `agentId` (raw runtime id) and an
+`agentType` label that's used as the row title when present. The label
+sources differ per runtime:
+
+- **Claude / ade-code.** `agentType` comes from the Task tool's
+  `input.subagent_type` (e.g. `code-reviewer`, `Explore`). The service
+  stashes that input at the assistant `tool_use` boundary
+  (`runtime.taskToolInputByToolUseId`, keyed by `tool_use_id`) and
+  joins it onto the later `system:task_started` / `task_progress` /
+  `task_completed` envelopes via `parentToolUseId`. Stale entries are
+  cleared at turn boundaries and on subagent completion.
+- **Codex parallel agents.** The Codex wire format has no
+  human-friendly name for collab agents, so the service assigns
+  `Agent #N` labels via `assignCodexAgentLabel`: 1-based, per-turn,
+  remembered in `runtime.codexAgentIndexByTurn` (a
+  `Map<turnId, Map<threadId, index>>`), and cleared when the turn
+  ends. The raw threadId is kept on the snapshot as `agentId`.
+- **OpenCode subagents.** OpenCode encodes the agent's identity in
+  `session.title`, which already flows through as `description`; the
+  service intentionally does NOT set `agentType` so the renderer falls
+  back to that description for the row label.
 
 ## Terminal drawer
 
diff --git a/docs/features/chat/transcript-and-turns.md b/docs/features/chat/transcript-and-turns.md
index 1a8ab8fb6..e403bcaaf 100644
--- a/docs/features/chat/transcript-and-turns.md
+++ b/docs/features/chat/transcript-and-turns.md
@@ -80,7 +80,7 @@ Two helpers summarise a parsed stream:
 | `done` | Final turn marker with model, model id, usage, cost. Also clears non-question pending inputs when status is not `completed`. |
 | `activity` | Ephemeral UI hint (thinking, searching, running_command). Hidden from the transcript. |
 | `todo_update` | Task-list snapshot; consumed by `ChatTasksPanel`. |
-| `subagent_started` / `subagent_progress` / `subagent_result` | Legacy Claude background subagent lifecycle. The service also emits canonical `subagent.started` / `subagent.progress` / `subagent.completed` rows from `runtimeEvents.ts` so all runtimes can converge on the same envelope. |
+| `subagent_started` / `subagent_progress` / `subagent_result` | Legacy Claude background subagent lifecycle. Each envelope carries `taskId`, `parentToolUseId`, `description`, and optional `agentId` + `agentType`: for Claude / ade-code `agentType` is the Task tool's `subagent_type` (stashed at the `tool_use` boundary and joined on `parentToolUseId`); for Codex parallel agents it is a per-turn `Agent #N` label assigned at first announcement and the raw threadId is mirrored as `agentId`; for OpenCode subagents `agentType` is omitted so the row falls back to the `description` (taken from `session.title`). The service also emits canonical `subagent.started` / `subagent.progress` / `subagent.completed` rows from `runtimeEvents.ts` so all runtimes can converge on the same envelope. |
 | `tool_use_start` / `tool_use_complete` / `tool_use_summary` | Claude SDK tool lifecycle tracking (see [Claude tool-use tracking](#claude-tool-use-tracking)). |
 | `step_boundary` | Mission step boundary marker. |
 | `system_notice` | Non-transcript chrome: auth errors, rate limits, memory notices, file persistence hints. |
diff --git a/docs/features/missions/README.md b/docs/features/missions/README.md
index 0ac540af8..349fc975d 100644
--- a/docs/features/missions/README.md
+++ b/docs/features/missions/README.md
@@ -58,7 +58,7 @@ All under `apps/desktop/src/renderer/components/missions/`:
 - `MissionChatV2.tsx`, `ChatChannelList.tsx`, `ChatMessageArea.tsx`, `ChatInput.tsx`, `MissionThreadMessageList.tsx`, `chatFilters.ts`, `missionChatChannelModel.ts` — conversations tab. Channel rows expose accessible names through `formatChannelAccessibleName` (e.g. `"Orchestrator, orchestrator channel"`); legacy badge/badge-color props were removed in favor of the accessible label.
 - `PlanTab.tsx`, `PhaseCardEditor.tsx`, `missionPhaseDefaults.ts` — plan review and phase-card editing surface (validation gate evidence checklist, phase key editing for custom phases). Display-only task records are filtered out of executable step lists so task-planning rows do not inflate phase progress.
 - `missionControlViewModel.ts`, `missionFeedPresentation.ts`, `missionThreadEventAdapter.ts`, `missionInterventionRouting.ts`, `missionWorkerPresentation.ts`, `missionHelpers.ts`, `chatFilters.ts` — pure derivations consumed by the UI.
-- `useMissionRunView.ts`, `useMissionPolling.ts`, `useMissionsStore.ts`, `missionDialogDataCache.ts`, `missionCreateDialogStore.ts` — store + hooks. `MissionTabContent` now receives `runView` as a prop (computed once at the page level via `useMissionRunView`) instead of subscribing locally, so the panels share one polling source.
+- `useMissionRunView.ts`, `useMissionPolling.ts`, `useMissionsStore.ts`, `missionDialogDataCache.ts`, `missionCreateDialogStore.ts`, `MissionActiveContext.tsx` — store + hooks. `MissionTabContent` receives `runView` as a prop (computed once at the page level via `useMissionRunView`) instead of subscribing locally, so the panels share one polling source. The store is built with `createStore<MissionsStore>()(createMissionsState)` and `MissionsPage` instantiates its own copy via `createMissionsStore()` inside a `MissionsStoreProvider`, so multiple project tabs each get their own missions selection / chat-jump / prompt-inspector state. Components reach the scoped store via `useMissionsStoreApi()` for imperative `getState()` access; `useMissionsStore(selector)` reads from whichever store the surrounding provider holds (falling back to a module-level root store for any callers outside a provider). `MissionActiveContext` carries the page-level `active?: boolean` down so `MissionsWorkspace`, `MissionsProductionGate`, `MissionHeader`, `MissionChatV2`, `CompactUsageMeter`, `InterventionPanel`, and `OrchestratorActivityFeed` can short-circuit every polling / event-subscription effect when the missions surface is not the foreground project tab.
 - `apps/desktop/src/renderer/components/chat/missionControlTextTools.ts` — coordinator-side rewrite that turns ADE mission-control text-tool envelopes into rendered tool events for `MissionThreadMessageList`. `isMissionControlToolName(name)` is the canonical predicate; the `mission-thread` presentation mode auto-rewrites events on mount via `rewriteMissionControlTextToolEvents`.
 
 ### Validation contract
diff --git a/docs/features/onboarding-and-settings/README.md b/docs/features/onboarding-and-settings/README.md
index 2eff75d7d..2fb733072 100644
--- a/docs/features/onboarding-and-settings/README.md
+++ b/docs/features/onboarding-and-settings/README.md
@@ -289,8 +289,19 @@ the General settings tab via `AdeCliSection`:
 1. Bring up the runtime daemon. The pool tries to attach to
    `~/.ade/sock/ade.sock`; if that fails it spawns
    `ade serve --socket <path>` from the bundled CLI and waits for the
-   socket. A version mismatch between the running daemon and the desktop
-   build forces a clean restart.
+   socket. Compatibility is checked at `initialize` time using both the
+   reported version and a SHA-256 build hash of the CLI script
+   (`ADE_RUNTIME_BUILD_HASH` is set by `apps/ade-cli/src/cli.ts` before
+   spawning the daemon, and `LocalRuntimeConnectionPool.connectClient`
+   compares the runtime's `buildHash` against the desktop's expected
+   value). A dev build that reports the placeholder version `0.0.0` is
+   accepted when its build hash matches the bundled CLI. Mismatches
+   are surfaced as a `LocalRuntimeCompatibilityError` and the **existing
+   daemon is left running** so the user's active work is preserved —
+   the previous behaviour of force-shutting the daemon and reconnecting
+   has been retired because it killed live PTYs / chats during a stale
+   reattach window. The desktop reports the incompatibility back to the
+   user instead.
 2. Register the runtime as a per-user login service so it survives
    reboots. `installServiceBestEffort()` runs `ade serve --install-service`
    once per session; the implementation lives in
diff --git a/docs/features/sync-and-multi-device/ios-companion.md b/docs/features/sync-and-multi-device/ios-companion.md
index 03160450f..0b33c21c1 100644
--- a/docs/features/sync-and-multi-device/ios-companion.md
+++ b/docs/features/sync-and-multi-device/ios-companion.md
@@ -646,6 +646,14 @@ existing pairing credentials to reconnect against the now-active host.
 If the host is offline at switch time, it still records the requested
 project as active and the phone reconnects when the host returns.
 
+Before tearing down the old socket on a project switch, `SyncService`
+calls `resetChatEventState(clearHistory: false)` and
+`resetTerminalSubscriptionState(clearHistory: true)` so chat /
+terminal subscriptions bound to the previous project's session ids
+are dropped. Without this reset, the phone would resubscribe to stale
+ids after reconnect and either leak foreign chat events into the new
+project view or collide with newly-assigned session ids on the host.
+
 Rather than reconstructing lane detail surfaces client-side from
 primitive rows, the iOS app persists richer projections the host
 sends:
diff --git a/docs/features/terminals-and-sessions/pty-and-processes.md b/docs/features/terminals-and-sessions/pty-and-processes.md
index e641723da..1cd7f1ab8 100644
--- a/docs/features/terminals-and-sessions/pty-and-processes.md
+++ b/docs/features/terminals-and-sessions/pty-and-processes.md
@@ -243,6 +243,59 @@ the same session with `terminal_subscribe`; unsubscribed
 mobile terminal control tied to the visible Work surface instead of
 making a bare session id sufficient to drive a shell.
 
+### Chat-CLI auto-reattach (`reattachChatCli` + `writeTerminal`)
+
+`ptyService.reattachChatCli({ chatSessionId, cols?, rows? })` is the
+single entry point for "spin a chat-CLI session back up because the
+user wants to send a message". It only accepts tracked chat-typed
+sessions (`isPersistedChatToolType(toolType)`) — non-chat sessions and
+untracked rows are rejected with a clear error.
+
+Behaviour:
+
+- Fast path: if a live PTY is already bound to the chat session, the
+  call returns `{ terminalId, ptyId, pid, relaunched: false }` without
+  any further work.
+- Otherwise resolve the resume command from `session.resumeMetadata`
+  (via `buildTrackedCliResumeCommand`, no overrides) or
+  `session.resumeCommand`, then `service.create({ sessionId, laneId,
+  chatSessionId, cols, rows, toolType, startupCommand })` to spawn a
+  fresh PTY in the same row and return `{ ..., relaunched: true }`.
+- Concurrent callers are deduped through `reattachChatCliFlights`
+  (one in-flight reattach per `chatSessionId`) so a chat composer +
+  App Control + a rapid send burst can't each race a separate
+  `claude --resume <same-id>` PTY into existence.
+
+`writeTerminal` was made async and now auto-reattaches before
+writing when:
+
+1. The caller did NOT pass an explicit `ptyId` (explicit `ptyId`
+   keeps the original "PTY not running" throw to surface programmer
+   errors), and
+2. `terminalId` / `chatSessionId` resolves to a tracked chat-CLI
+   session whose PTY is missing.
+
+In that case the service calls `reattachChatCli({ chatSessionId })`
+and writes to the freshly attached PTY. Any other "no live PTY"
+case still throws — the auto-reattach is intentionally scoped to
+chat CLIs so an active App Control terminal, a shell, or a non-chat
+agent CLI doesn't silently resurrect after the user stopped it.
+
+A new IPC channel `ade.terminal.reattachChatCli` exposes the
+service method to the renderer (consumed by `AgentChatPane` and the
+chat composer when sending into a chat whose PTY has been
+evicted), the `ade-cli` socket surface, and the ADE Action
+registry under `terminal.reattachChatCli`.
+
+### Live-session detection
+
+`ptyService.hasLiveSessions()` walks the PTY map and returns true if
+any entry is not disposed. `main.ts`'s
+`hasActiveProjectWorkloads(ctx)` calls it (alongside
+`agentChatService.hasRetainableSessions()` and the mission active-list
+check) so a project context with running CLIs / agents / shells is
+never evicted by the warm-idle cap.
+
 ### Send-or-continue (`sendToSession`)
 
 `ptyService.sendToSession({ sessionId, text, cols?, rows?, model?,
diff --git a/docs/features/terminals-and-sessions/ui-surfaces.md b/docs/features/terminals-and-sessions/ui-surfaces.md
index 9817194be..02b7cfa83 100644
--- a/docs/features/terminals-and-sessions/ui-surfaces.md
+++ b/docs/features/terminals-and-sessions/ui-surfaces.md
@@ -358,14 +358,18 @@ chat-scoped and stays on the chat header.
 ## Terminal renderer: `TerminalView.tsx`
 
 Thin wrapper over xterm.js + `FitAddon`. Caches `Terminal` instances in
-a module-level map keyed by `(ptyId, sessionId)` so a remount does not
-rebuild the emulator. Each cached entry also records the
-`(projectRoot, projectRevision)` it was created under; on mount,
-`disposeStaleRuntimes(activeProjectRoot, activeProjectRevision)` tears
-down any entries whose project context no longer matches, which is how
-terminal cache state gets cleared on project switch or close without
-ever leaking PTYs between projects. The `projectRevision` counter
-lives in `useAppStore` and is bumped on every real project change.
+a module-level map keyed by `(projectRoot, sessionId, ptyId)` (via
+`terminalRuntimeKey`) so a remount does not rebuild the emulator and so
+two different project tabs can each cache their own runtime against the
+same chat session id without colliding. Each cached entry also records
+the `(projectRoot, projectRevision)` it was created under; on mount,
+`disposeStaleRuntimes(activeProjectRoot, activeProjectRevision)` clears
+out-of-date entries. With multi-project tab hosting in `App.tsx`,
+project switching no longer evicts another project's terminals: an
+entry is only torn down (or scheduled for keepalive teardown) when its
+own project context has aged out, **not** when a different project
+becomes active. The `projectRevision` counter lives in `useAppStore`
+and is bumped on every real project change.
 
 Renderer strategy: WebGL-first, fall back to the DOM renderer on any
 init failure or context loss. Canvas renderer is intentionally skipped
@@ -413,17 +417,29 @@ Key behaviors:
   `ade.terminal.preview` (serialized snapshot of the visible rows
   rebuilt as SGR-bracketed ANSI through `serializeSnapshotVisibleRows`,
   falling back to the snapshot's `serialized` scrollback) and only uses
-  the transcript tail when no snapshot is available. The runtime
-  tracks `hasAppliedTerminalContent` and
-  `displayedLiveDataBeforeHydration`; if hydration returns nothing
+  the transcript tail when no snapshot is available. Before either path
+  runs, the runtime calls `sessions.get(sessionId)` to find out whether
+  the session is disposed; for any disposed session that hasn't
+  displayed live data yet, hydration first tries **replay mode** via
+  `sessions.readTranscriptTail({ raw: true })` (capped at
+  `REPLAY_TRANSCRIPT_MAX_BYTES = 8 MB`) and feeds the result through
+  `stripFullScreenRedrawSequences()` before writing. The strip removes
+  alt-screen enter/leave (`?1049h/l`, `?47h/l`), hard resets (`\x1bc`),
+  and full-screen erases (`\x1b[2J`, `\x1b[3J`, `\x1b[H\x1b[2J`) so each
+  TUI redraw appends to the main buffer's scrollback instead of
+  clobbering it. Replay-mode runtimes set `replayMode: true`, get
+  `REPLAY_SCROLLBACK_LINES = 100_000` scrollback regardless of user
+  preference, and skip the usual `trimToLikelyTerminalFrameBoundary`
+  hydration trim so the whole transcript stays scrollable. This is
+  what makes a disposed Claude / Codex chat session render as a
+  scrollable transcript instead of "the last alt-screen frame" or
+  "ANSI escape soup". The runtime tracks `hasAppliedTerminalContent`
+  and `displayedLiveDataBeforeHydration`; if hydration returns nothing
   renderable while live PTY data is already on screen,
   `scheduleHydrationBackfill` retries the preview every ~100 ms (up to
-  120 attempts) until the DOM reports renderable text. This is the fix
-  that keeps the Work-tab terminal from showing a blank black pane with
-  an orange cursor after sending a first prompt to a fast TUI like
-  Codex or Claude. The backfill also re-arms whenever the tile becomes
-  visible but the xterm rows are empty (e.g. after a webgl→dom
-  fallback).
+  120 attempts) until the DOM reports renderable text. The backfill
+  also re-arms whenever the tile becomes visible but the xterm rows
+  are empty (e.g. after a webgl→dom fallback).
 - **Mouse tracking forwarding** — `TerminalView` tracks DECSET 1000 /
   1002 / 1003 (SGR mouse modes) by scanning every PTY data chunk via
   `updateTerminalMouseTrackingModes`. When the embedded TUI has mouse
@@ -493,12 +509,10 @@ Launch commands are built by `apps/desktop/src/shared/cliLaunch.ts`:
     alias caused the TUI to drop straight into auto-approval and was
     surprising in the Work tab). `full-auto` keeps the explicit
     `--dangerously-bypass-approvals-and-sandbox` flag, and `config-toml`
-    mode defers to `.codex/config.toml`. Fresh Codex launches also
-    pass `-c mcp_servers.linear.enabled=false` (see
-    `ADE_CODEX_STARTUP_CONFIG_FLAGS` in `cliLaunch.ts`) to keep a stale
-    user-level Linear MCP OAuth handshake from blocking the TUI's
-    first paint — ADE has its own Linear surfaces, so the MCP wiring
-    is intentionally suppressed for the in-app launch.
+    mode defers to `.codex/config.toml`. ADE does not rewrite
+    `mcp_servers` for Codex CLI launches; Codex config remains
+    host-owned so ADE does not synthesize partial MCP tables that the
+    CLI rejects during config validation.
   - **Cursor** → `--mode plan|ask` for read-only modes and `--force`
     for full-auto. Sessions pre-allocate a chat id with
     `cursor-agent create-chat` so `--resume <id>` is always known.