From d7e2ab44371ea9f44a85eef9ddaa29c3a6c4627a Mon Sep 17 00:00:00 2001
From: Mohamed Boudra <boudra.moha@gmail.com>
Date: Sat, 21 Feb 2026 22:09:48 +0700
Subject: [PATCH] feat: add thinking option support and autonomous run handling

---
 CLAUDE.md                                     |   20 +
 CLAUDE_PROVIDER_REDESIGN_PLAN.md              |  112 ++
 app.json                                      |    5 +
 packages/app/src/contexts/session-context.tsx |    8 +-
 .../src/screens/agent/draft-agent-screen.tsx  |   36 +-
 packages/cli/src/cli.ts                       |   28 +-
 packages/cli/src/commands/agent/index.ts      |    2 +
 packages/cli/src/commands/agent/inspect.ts    |   16 +-
 packages/cli/src/commands/agent/ls.ts         |   67 +-
 packages/cli/src/commands/agent/run.ts        |   13 +
 packages/cli/src/commands/daemon/index.ts     |    2 +
 .../src/commands/daemon/runtime-toolchain.ts  |  131 ++
 packages/cli/src/commands/daemon/status.ts    |  204 ++-
 packages/cli/src/commands/daemon/update.ts    |  105 ++
 packages/cli/src/commands/provider/index.ts   |    1 +
 packages/cli/src/commands/provider/models.ts  |   34 +-
 .../relay/src/dist-handshake-parity.test.ts   |   21 +
 packages/relay/src/encrypted-channel.ts       |   30 +-
 .../src/server/agent/agent-manager.test.ts    |  241 +++
 .../server/src/server/agent/agent-manager.ts  |  115 +-
 .../src/server/agent/agent-projections.ts     |   25 +
 .../src/server/agent/agent-sdk-types.ts       |    1 +
 .../server/src/server/agent/agent-storage.ts  |    1 +
 ...agent.interrupt-restart-regression.test.ts |  840 +++++++--
 .../providers/claude-agent.redesign.test.ts   |  800 +++++++++
 .../server/agent/providers/claude-agent.ts    | 1504 +++++++++++++----
 .../claude/tool-call-detail-parser.ts         |    6 +
 .../providers/claude/tool-call-mapper.test.ts |   19 +
 .../providers/claude/tool-call-mapper.ts      |    2 +
 .../agent/providers/codex-app-server-agent.ts |   28 +-
 .../providers/tool-call-detail-primitives.ts  |    1 +
 .../claude-autonomous-wake.real.e2e.test.ts   |  811 +++++++++
 packages/server/src/server/relay-transport.ts |   24 +-
 packages/server/src/server/session.ts         |   38 +-
 packages/server/src/shared/messages.ts        |    3 +
 35 files changed, 4701 insertions(+), 593 deletions(-)
 create mode 100644 CLAUDE_PROVIDER_REDESIGN_PLAN.md
 create mode 100644 app.json
 create mode 100644 packages/cli/src/commands/daemon/runtime-toolchain.ts
 create mode 100644 packages/cli/src/commands/daemon/update.ts
 create mode 100644 packages/relay/src/dist-handshake-parity.test.ts
 create mode 100644 packages/server/src/server/agent/providers/claude-agent.redesign.test.ts
 create mode 100644 packages/server/src/server/daemon-e2e/claude-autonomous-wake.real.e2e.test.ts

diff --git a/CLAUDE.md b/CLAUDE.md
index 5cd372179..0c2280a8b 100644
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -56,6 +56,26 @@ Use `npm run cli` to run the local CLI (instead of the globally linked `paseo` w
 
 Use `--host <host:port>` to point the CLI at a different daemon (e.g., `--host localhost:7777`).
 
+### Relay build sync (important)
+
+When changing `packages/relay/src/*`, rebuild relay before running/debugging the daemon:
+
+```bash
+npm run build --workspace=@getpaseo/relay
+```
+
+Reason: Node daemon imports `@getpaseo/relay` from `packages/relay/dist/*` (`node` export path), not directly from `src/*`.
+
+### Server build sync for CLI (important)
+
+When changing `packages/server/src/client/*` (especially `daemon-client.ts`) or shared WS protocol types, rebuild server before running/debugging CLI commands:
+
+```bash
+npm run build --workspace=@getpaseo/server
+```
+
+Reason: local CLI imports `@getpaseo/server` via package exports that resolve to `packages/server/dist/*` first. If `dist` is stale, CLI can speak an old protocol (for example, sending `session` before `hello`) and fail with handshake warnings/timeouts.
+
 ### Quick reference CLI commands
 
 ```bash
diff --git a/CLAUDE_PROVIDER_REDESIGN_PLAN.md b/CLAUDE_PROVIDER_REDESIGN_PLAN.md
new file mode 100644
index 000000000..d0c79a0b3
--- /dev/null
+++ b/CLAUDE_PROVIDER_REDESIGN_PLAN.md
@@ -0,0 +1,112 @@
+# Claude Provider Redesign Plan
+
+## Goal
+Eliminate dropped/misrouted Claude messages and stuck lifecycle transitions under foreground/autonomous interleaving by replacing heuristics with an explicit state machine and deterministic routing.
+
+## Non-Negotiable Constraints
+1. Single-owner SDK consumption: only one internal pump calls `query.next()`.
+2. Task notifications are metadata only, never lifecycle correctness dependencies.
+3. Interrupt must work when lifecycle is `running`, even with no foreground `pendingRun`.
+4. Public API semantics unchanged:
+   - `stream`, `streamHistory`, `interrupt` signatures remain.
+   - `waitForFinish` remains status-based (`running -> idle/error/permission/timeout`).
+
+## Final Architecture
+
+### 1) Session Turn Ownership State
+`turnState`: `idle | foreground | autonomous`
+
+Transitions:
+1. `idle -> foreground` on user `stream()` send.
+2. `foreground -> idle` on foreground terminal event.
+3. `idle -> autonomous` on first routable autonomous SDK event.
+4. `autonomous -> idle` when autonomous run(s) terminal.
+5. `autonomous -> foreground` must be atomic:
+   - interrupt autonomous
+   - await teardown
+   - start foreground
+
+### 2) Run Lifecycle Tracking
+Per-run state (tracked independently from timeline):
+`queued | awaiting_response | streaming | finalizing | completed | interrupted | error`
+
+Session status derives from runs:
+- `running` iff any run is in `queued|awaiting_response|streaming|finalizing`
+- `permission` iff permission pending
+- `error` iff errored
+- `idle` otherwise
+
+### 3) Deterministic Event Routing (single decision point)
+In the query pump, normalize each SDK event, then route by this order:
+
+1. If `turnState=foreground`: route all non-metadata events to foreground run queue.
+2. Else route by identifiers:
+   - `task_id`
+   - `parent_message_id`
+   - `message_id`
+   - fallback: create autonomous run
+3. If no route: metadata-only event.
+
+No timestamp windows. No suppression/diversion heuristics.
+
+### 4) Timeline Assembly Decoupled from Run Ownership
+Timeline is assembled from normalized message events keyed by `message_id`, independent of run ownership:
+
+1. `message_start` -> create/update timeline entry
+2. `message_delta` -> append
+3. `message_stop` -> finalize
+4. Support out-of-order events (placeholder then reconcile)
+
+Guarantee: assistant messages cannot be dropped from timeline due routing ambiguity.
+
+## Refactor Sequence (Low-Risk Migration)
+1. Introduce explicit types:
+   - `TurnState`
+   - `RunTracker` (run map + lifecycle)
+   - `TimelineAssembler` (message-id based)
+2. Refactor pump flow to:
+   - normalize event
+   - route via single decision point
+   - update run tracker
+   - always feed timeline assembler
+3. Implement atomic `autonomous -> foreground` transition.
+4. Remove old heuristics:
+   - suppression windows
+   - pre-prompt diversion/grace logic
+   - task-notification lifecycle branching
+5. Keep manager/provider external contracts unchanged.
+
+## Correctness Invariants
+1. Only query pump calls `query.next()`.
+2. Foreground exclusivity: while `turnState=foreground`, non-metadata SDK events cannot route to autonomous path.
+3. Lifecycle correctness: `running` emitted when any run active; terminal transitions settle back to `idle`.
+4. Interrupt correctness: `cancelAgentRun()` works for autonomous running with no foreground `pendingRun`.
+5. Timeline completeness: every assistant `message_start/delta/stop` appears in timeline.
+
+## Test Plan
+
+### Unit Tests
+1. Deterministic routing by identifier priority.
+2. Foreground exclusivity under interleaving events.
+3. Run lifecycle transitions (success, interrupt, error).
+4. Timeline assembler out-of-order robustness.
+5. Manager autonomous cancel path without foreground `pendingRun`.
+
+### Real Claude E2E Gates
+1. `repro: do-it-again + immediate hello can hang after autonomous wake under churn`
+   - acceptance: autonomous `running` transition observed within timeout each cycle.
+2. `repro: transcript/timeline parity after do-it-again + hello race`
+   - acceptance: assistant messages present in transcript (including HELLO and autonomous completion) are present in timeline.
+
+## Rollout / Risk Controls
+1. Add temporary structured debug logs for:
+   - turn state transitions
+   - routing decisions (`event -> run`)
+   - run lifecycle transitions
+   - timeline assembly (`message_id`)
+2. Keep clear rollback boundaries by incremental commits:
+   - types + scaffolding
+   - routing replacement
+   - heuristic removal
+   - test hardening
+3. Run `npm run -w packages/server typecheck` and targeted test suites after each stage.
diff --git a/app.json b/app.json
new file mode 100644
index 000000000..81b32f17c
--- /dev/null
+++ b/app.json
@@ -0,0 +1,5 @@
+{
+  "android": {
+    "package": "com.moboudra.paseo"
+  }
+}
diff --git a/packages/app/src/contexts/session-context.tsx b/packages/app/src/contexts/session-context.tsx
index 005c62e01..014b70729 100644
--- a/packages/app/src/contexts/session-context.tsx
+++ b/packages/app/src/contexts/session-context.tsx
@@ -150,11 +150,9 @@ function SessionProviderWithClient({
   client,
 }: SessionProviderClientProps) {
   return (
-    <SessionProviderInternal
-      children={children}
-      serverId={serverId}
-      client={client}
-    />
+    <SessionProviderInternal serverId={serverId} client={client}>
+      {children}
+    </SessionProviderInternal>
   );
 }
 
diff --git a/packages/app/src/screens/agent/draft-agent-screen.tsx b/packages/app/src/screens/agent/draft-agent-screen.tsx
index 2cb8522c7..b19bbeef8 100644
--- a/packages/app/src/screens/agent/draft-agent-screen.tsx
+++ b/packages/app/src/screens/agent/draft-agent-screen.tsx
@@ -378,13 +378,7 @@ function DraftAgentScreenContent({
   const sessionClient = runtimeClient
   const trimmedWorkingDir = workingDir.trim()
   const shouldInspectRepo = trimmedWorkingDir.length > 0
-  const daemonAvailabilityError =
-    !selectedServerId || !isHostOnline ? 'Host is offline' : null
-  const repoAvailabilityError =
-    shouldInspectRepo && !isHostOnline
-      ? (daemonAvailabilityError ??
-        'Repository details will load automatically once the selected host is back online.')
-      : null
+  const canQuerySelectedHost = Boolean(selectedServerId) && Boolean(sessionClient) && isHostOnline
 
   const checkoutStatusQuery = useQuery({
     queryKey: checkoutStatusQueryKey(selectedServerId ?? '', trimmedWorkingDir),
@@ -395,12 +389,7 @@ function DraftAgentScreenContent({
       }
       return await client.getCheckoutStatus(trimmedWorkingDir)
     },
-    enabled:
-      Boolean(selectedServerId) &&
-      Boolean(trimmedWorkingDir) &&
-      !repoAvailabilityError &&
-      Boolean(sessionClient) &&
-      isHostOnline,
+    enabled: Boolean(trimmedWorkingDir) && canQuerySelectedHost,
     retry: false,
     staleTime: CHECKOUT_STATUS_STALE_TIME,
     refetchOnMount: 'always',
@@ -424,8 +413,8 @@ function DraftAgentScreenContent({
 
   const repoInfoStatus: 'idle' | 'loading' | 'ready' | 'error' = !shouldInspectRepo
     ? 'idle'
-    : repoAvailabilityError
-      ? 'error'
+    : !canQuerySelectedHost
+      ? 'idle'
       : checkoutStatusQuery.isPending || checkoutStatusQuery.isFetching
         ? 'loading'
         : checkoutStatusQuery.isError || Boolean(checkoutPayloadError)
@@ -435,9 +424,7 @@ function DraftAgentScreenContent({
             : 'idle'
 
   const repoInfoError =
-    repoAvailabilityError ??
-    (checkoutStatusQuery.isError ? checkoutQueryError : null) ??
-    checkoutPayloadError
+    (checkoutStatusQuery.isError ? checkoutQueryError : null) ?? checkoutPayloadError
   const isCreateWorktree = worktreeMode === 'create'
   const isAttachWorktree = worktreeMode === 'attach'
 
@@ -461,9 +448,7 @@ function DraftAgentScreenContent({
     enabled:
       isGitDirectory &&
       Boolean(worktreeListRoot) &&
-      !repoAvailabilityError &&
-      Boolean(sessionClient) &&
-      isHostOnline &&
+      canQuerySelectedHost &&
       !isNonGitDirectory,
     retry: false,
     staleTime: 0,
@@ -526,9 +511,7 @@ function DraftAgentScreenContent({
       isGitDirectory &&
       !isNonGitDirectory &&
       Boolean(trimmedWorkingDir) &&
-      !repoAvailabilityError &&
-      Boolean(sessionClient) &&
-      isHostOnline,
+      canQuerySelectedHost,
     retry: false,
     staleTime: 15_000,
   })
@@ -558,10 +541,7 @@ function DraftAgentScreenContent({
     },
     enabled:
       Boolean(debouncedWorkingDirSearchQuery) &&
-      Boolean(selectedServerId) &&
-      !daemonAvailabilityError &&
-      Boolean(sessionClient) &&
-      isHostOnline,
+      canQuerySelectedHost,
     retry: false,
     staleTime: 15_000,
   })
diff --git a/packages/cli/src/cli.ts b/packages/cli/src/cli.ts
index 7a7cc77c9..fede55476 100644
--- a/packages/cli/src/cli.ts
+++ b/packages/cli/src/cli.ts
@@ -9,6 +9,7 @@ import { createWorktreeCommand } from './commands/worktree/index.js'
 import { startCommand as daemonStartCommand } from './commands/daemon/start.js'
 import { runStatusCommand as runDaemonStatusCommand } from './commands/daemon/status.js'
 import { runRestartCommand as runDaemonRestartCommand } from './commands/daemon/restart.js'
+import { runDaemonUpdateCommandOrExit } from './commands/daemon/update.js'
 import { runLsCommand } from './commands/agent/ls.js'
 import { runRunCommand } from './commands/agent/run.js'
 import { runLogsCommand } from './commands/agent/logs.js'
@@ -17,7 +18,6 @@ import { runSendCommand } from './commands/agent/send.js'
 import { runInspectCommand } from './commands/agent/inspect.js'
 import { runWaitCommand } from './commands/agent/wait.js'
 import { runAttachCommand } from './commands/agent/attach.js'
-import { runUpdateCommand } from './commands/agent/update.js'
 import { withOutput } from './output/index.js'
 import { onboardCommand } from './commands/onboard.js'
 
@@ -63,6 +63,7 @@ export function createCli(): Command {
     .option('-a, --all', 'Include archived agents')
     .option('-g, --global', 'Legacy no-op (kept for compatibility)')
     .option('--label <key=value>', 'Filter by label (can be used multiple times)', collectMultiple, [])
+    .option('--thinking <id>', 'Filter by thinking option ID')
     .option('--json', 'Output in JSON format')
     .option('--host <host>', 'Daemon host:port (default: localhost:6767)')
     .action(withOutput(runLsCommand))
@@ -75,6 +76,7 @@ export function createCli(): Command {
     .option('--name <name>', 'Assign a name/title to the agent')
     .option('--provider <provider>', 'Agent provider: claude | codex | opencode', 'claude')
     .option('--model <model>', 'Model to use (e.g., claude-sonnet-4-20250514, claude-3-5-haiku-20241022)')
+    .option('--thinking <id>', 'Thinking option ID to use for this run')
     .option('--mode <mode>', 'Provider-specific mode (e.g., plan, default, bypass)')
     .option('--worktree <name>', 'Create agent in a new git worktree')
     .option('--base <branch>', 'Base branch for worktree (default: current branch)')
@@ -143,25 +145,19 @@ export function createCli(): Command {
     .option('--host <host>', 'Daemon host:port (default: localhost:6767)')
     .action(withOutput(runWaitCommand))
 
-  program
-    .command('update')
-    .description('Update an agent (alias for "paseo agent update")')
-    .argument('<id>', 'Agent ID (or prefix)')
-    .option('--name <name>', "Update the agent's display name")
-    .option(
-      '--label <label>',
-      'Add/set label(s) on the agent (can be used multiple times or comma-separated)',
-      collectMultiple,
-      []
-    )
-    .option('--json', 'Output in JSON format')
-    .option('--host <host>', 'Daemon host:port (default: localhost:6767)')
-    .action(withOutput(runUpdateCommand))
-
   // Top-level local daemon shortcuts
   program.addCommand(onboardCommand())
   program.addCommand(daemonStartCommand())
 
+  program
+    .command('update')
+    .description('Update local daemon package (alias for "paseo daemon update")')
+    .option('--home <path>', 'Paseo home directory (default: ~/.paseo)')
+    .option('-y, --yes', 'Restart automatically after update')
+    .action(async (options: { home?: string; yes?: boolean }) => {
+      await runDaemonUpdateCommandOrExit(options)
+    })
+
   program
     .command('status')
     .description('Show local daemon status (alias for "paseo daemon status")')
diff --git a/packages/cli/src/commands/agent/index.ts b/packages/cli/src/commands/agent/index.ts
index c87a0a0db..6eb47d968 100644
--- a/packages/cli/src/commands/agent/index.ts
+++ b/packages/cli/src/commands/agent/index.ts
@@ -27,6 +27,7 @@ export function createAgentCommand(): Command {
     .option('-a, --all', 'Include archived agents')
     .option('-g, --global', 'Legacy no-op (kept for compatibility)')
     .option('--label <key=value>', 'Filter by label (can be used multiple times)', collectMultiple, [])
+    .option('--thinking <id>', 'Filter by thinking option ID')
     .option('--json', 'Output in JSON format')
     .option('--host <host>', 'Daemon host:port (default: localhost:6767)')
     .action(withOutput(runLsCommand))
@@ -39,6 +40,7 @@ export function createAgentCommand(): Command {
     .option('--name <name>', 'Assign a name/title to the agent')
     .option('--provider <provider>', 'Agent provider: claude | codex | opencode', 'claude')
     .option('--model <model>', 'Model to use (e.g., claude-sonnet-4-20250514, claude-3-5-haiku-20241022)')
+    .option('--thinking <id>', 'Thinking option ID to use for this run')
     .option('--mode <mode>', 'Provider-specific mode (e.g., plan, default, bypass)')
     .option('--cwd <path>', 'Working directory (default: current)')
     .option('--label <key=value>', 'Add label(s) to the agent (can be used multiple times)', collectMultiple, [])
diff --git a/packages/cli/src/commands/agent/inspect.ts b/packages/cli/src/commands/agent/inspect.ts
index 5fd9c470e..c6f19ccfa 100644
--- a/packages/cli/src/commands/agent/inspect.ts
+++ b/packages/cli/src/commands/agent/inspect.ts
@@ -9,6 +9,7 @@ interface AgentInspect {
   Name: string
   Provider: string
   Model: string
+  Thinking: string
   Status: string
   Mode: string
   Cwd: string
@@ -84,6 +85,17 @@ function formatCost(costUsd: number): string {
   return `$${costUsd.toFixed(2)}`
 }
 
+function normalizeModelId(value: string | null | undefined): string | null {
+  if (typeof value !== 'string') return null
+  const normalized = value.trim()
+  if (!normalized || normalized.toLowerCase() === 'default') return null
+  return normalized
+}
+
+function resolveModel(snapshot: AgentSnapshotPayload): string | null {
+  return normalizeModelId(snapshot.runtimeInfo?.model) ?? normalizeModelId(snapshot.model)
+}
+
 /** Convert agent snapshot to inspection data */
 function toInspectData(snapshot: AgentSnapshotPayload): AgentInspect {
   const lastUsage = snapshot.lastUsage
@@ -112,7 +124,8 @@ function toInspectData(snapshot: AgentSnapshotPayload): AgentInspect {
     Id: snapshot.id,
     Name: snapshot.title ?? '-',
     Provider: snapshot.provider,
-    Model: snapshot.model ?? '-',
+    Model: resolveModel(snapshot) ?? '-',
+    Thinking: snapshot.effectiveThinkingOptionId ?? 'auto',
     Status: snapshot.status,
     Mode: snapshot.currentModeId ?? 'default',
     Cwd: snapshot.cwd,
@@ -139,6 +152,7 @@ function toInspectRows(agent: AgentInspect): InspectRow[] {
     { key: 'Name', value: agent.Name },
     { key: 'Provider', value: agent.Provider },
     { key: 'Model', value: agent.Model },
+    { key: 'Thinking', value: agent.Thinking },
     { key: 'Status', value: agent.Status },
     { key: 'Mode', value: agent.Mode },
     { key: 'Cwd', value: shortenPath(agent.Cwd) },
diff --git a/packages/cli/src/commands/agent/ls.ts b/packages/cli/src/commands/agent/ls.ts
index 5fa5586b0..57d043913 100644
--- a/packages/cli/src/commands/agent/ls.ts
+++ b/packages/cli/src/commands/agent/ls.ts
@@ -9,6 +9,7 @@ export interface AgentListItem {
   shortId: string
   name: string
   provider: string
+  thinking: string
   status: string
   cwd: string
   created: string
@@ -35,6 +36,13 @@ function shortenPath(path: string): string {
   return path
 }
 
+function normalizeModelId(modelId: string | null | undefined): string | null {
+  if (typeof modelId !== 'string') return null
+  const normalized = modelId.trim()
+  if (!normalized || normalized.toLowerCase() === 'default') return null
+  return normalized
+}
+
 /** Schema for agent ls output */
 export const agentLsSchema: OutputSchema<AgentListItem> = {
   idField: 'shortId',
@@ -42,6 +50,7 @@ export const agentLsSchema: OutputSchema<AgentListItem> = {
     { header: 'AGENT ID', field: 'shortId', width: 12 },
     { header: 'NAME', field: 'name', width: 20 },
     { header: 'PROVIDER', field: 'provider', width: 15 },
+    { header: 'THINKING', field: 'thinking', width: 12 },
     {
       header: 'STATUS',
       field: 'status',
@@ -60,11 +69,13 @@ export const agentLsSchema: OutputSchema<AgentListItem> = {
 
 /** Transform agent snapshot to AgentListItem */
 function toListItem(agent: AgentSnapshotPayload): AgentListItem {
+  const model = normalizeModelId(agent.runtimeInfo?.model) ?? normalizeModelId(agent.model)
   return {
     id: agent.id,
     shortId: agent.id.slice(0, 7),
     name: agent.title ?? '-',
-    provider: agent.model ? `${agent.provider}/${agent.model}` : agent.provider,
+    provider: model ? `${agent.provider}/${model}` : agent.provider,
+    thinking: agent.effectiveThinkingOptionId ?? 'auto',
     status: agent.status,
     cwd: shortenPath(agent.cwd),
     created: relativeTime(agent.createdAt),
@@ -84,6 +95,8 @@ export interface AgentLsOptions extends CommandOptions {
   cwd?: string
   /** Filter by labels (key=value format) */
   label?: string[]
+  /** Filter by thinking option ID */
+  thinking?: string
 }
 
 /**
@@ -111,8 +124,45 @@ export async function runLsCommand(
   }
 
   try {
+    const normalizedThinkingOptionId = options.thinking?.trim()
+    if (options.thinking !== undefined && !normalizedThinkingOptionId) {
+      const error: CommandError = {
+        code: 'INVALID_THINKING_OPTION',
+        message: '--thinking cannot be empty',
+      }
+      throw error
+    }
+
+    // Parse --label filters (key=value).
+    const labelFilters: Record<string, string> = {}
+    if (options.label) {
+      for (const labelStr of options.label) {
+        const eqIndex = labelStr.indexOf('=')
+        if (eqIndex !== -1) {
+          const key = labelStr.slice(0, eqIndex)
+          const value = labelStr.slice(eqIndex + 1)
+          labelFilters[key] = value
+        }
+      }
+    }
+
+    const daemonFilter: {
+      includeArchived?: boolean
+      labels?: Record<string, string>
+      thinkingOptionId?: string
+    } = {}
+    if (options.all) {
+      daemonFilter.includeArchived = true
+    }
+    if (Object.keys(labelFilters).length > 0) {
+      daemonFilter.labels = labelFilters
+    }
+    if (normalizedThinkingOptionId) {
+      daemonFilter.thinkingOptionId = normalizedThinkingOptionId
+    }
+
     const fetchPayload = await client.fetchAgents({
-      filter: options.all ? { includeArchived: true } : undefined,
+      filter: Object.keys(daemonFilter).length > 0 ? daemonFilter : undefined,
     })
     let agents = fetchPayload.entries.map((entry) => entry.agent)
 
@@ -135,19 +185,6 @@ export async function runLsCommand(
       })
     }
 
-    // Parse --label filters (key=value).
-    const labelFilters: Record<string, string> = {}
-    if (options.label) {
-      for (const labelStr of options.label) {
-        const eqIndex = labelStr.indexOf('=')
-        if (eqIndex !== -1) {
-          const key = labelStr.slice(0, eqIndex)
-          const value = labelStr.slice(eqIndex + 1)
-          labelFilters[key] = value
-        }
-      }
-    }
-
     // Apply label filtering only when explicitly requested.
     if (Object.keys(labelFilters).length > 0) {
       agents = agents.filter((a) => {
diff --git a/packages/cli/src/commands/agent/run.ts b/packages/cli/src/commands/agent/run.ts
index 77496b6f5..436d68a62 100644
--- a/packages/cli/src/commands/agent/run.ts
+++ b/packages/cli/src/commands/agent/run.ts
@@ -36,6 +36,7 @@ export interface AgentRunOptions extends CommandOptions {
   name?: string
   provider?: string
   model?: string
+  thinking?: string
   mode?: string
   worktree?: string
   base?: string
@@ -219,6 +220,16 @@ export async function runRunCommand(
   try {
     // Resolve working directory
     const cwd = options.cwd ?? process.cwd()
+    const thinkingOptionId = options.thinking?.trim()
+    if (options.thinking !== undefined && !thinkingOptionId) {
+      const error: CommandError = {
+        code: 'INVALID_THINKING_OPTION',
+        message: '--thinking cannot be empty',
+        details:
+          'Provide a thinking option ID. Use "paseo provider models <provider> --thinking" to list valid IDs.',
+      }
+      throw error
+    }
 
     // Process images if provided
     let images: Array<{ data: string; mimeType: string }> | undefined
@@ -290,6 +301,7 @@ export async function runRunCommand(
             title: options.name,
             modeId: options.mode,
             model: options.model,
+            thinkingOptionId,
             initialPrompt: structuredPrompt,
             images,
             git,
@@ -387,6 +399,7 @@ export async function runRunCommand(
       title: options.name,
       modeId: options.mode,
       model: options.model,
+      thinkingOptionId,
       initialPrompt: prompt,
       images,
       git,
diff --git a/packages/cli/src/commands/daemon/index.ts b/packages/cli/src/commands/daemon/index.ts
index 5f207044b..965b0d076 100644
--- a/packages/cli/src/commands/daemon/index.ts
+++ b/packages/cli/src/commands/daemon/index.ts
@@ -4,6 +4,7 @@ import { runStatusCommand } from './status.js'
 import { runStopCommand } from './stop.js'
 import { runRestartCommand } from './restart.js'
 import { pairCommand } from './pair.js'
+import { updateCommand } from './update.js'
 import { withOutput } from '../../output/index.js'
 
 export function createDaemonCommand(): Command {
@@ -11,6 +12,7 @@ export function createDaemonCommand(): Command {
 
   daemon.addCommand(startCommand())
   daemon.addCommand(pairCommand())
+  daemon.addCommand(updateCommand())
 
   daemon
     .command('status')
diff --git a/packages/cli/src/commands/daemon/runtime-toolchain.ts b/packages/cli/src/commands/daemon/runtime-toolchain.ts
new file mode 100644
index 000000000..e4406b7f4
--- /dev/null
+++ b/packages/cli/src/commands/daemon/runtime-toolchain.ts
@@ -0,0 +1,131 @@
+import { spawnSync } from 'node:child_process'
+import { existsSync } from 'node:fs'
+import path from 'node:path'
+
+export type NodePathSource = 'daemon_pid' | 'current_process'
+
+export interface NodePathResolution {
+  nodePath: string
+  source: NodePathSource
+  note?: string
+}
+
+export interface NodePathFromPidResult {
+  nodePath: string | null
+  error?: string
+}
+
+export interface NpmInvocation {
+  nodePath: string
+  npmPath: string
+  command: string
+  argsPrefix: string[]
+}
+
+function normalizeError(error: unknown): string {
+  if (error instanceof Error) {
+    return error.message
+  }
+  return String(error)
+}
+
+export function resolveNodePathFromPid(pid: number): NodePathFromPidResult {
+  const result = spawnSync('ps', ['-o', 'comm=', '-p', String(pid)], {
+    encoding: 'utf8',
+    stdio: ['ignore', 'pipe', 'pipe'],
+  })
+
+  if (result.error) {
+    return {
+      nodePath: null,
+      error: `ps failed: ${normalizeError(result.error)}`,
+    }
+  }
+
+  if ((result.status ?? 1) !== 0) {
+    const details = result.stderr?.trim()
+    return {
+      nodePath: null,
+      error: details ? `ps failed: ${details}` : `ps exited with code ${result.status ?? 1}`,
+    }
+  }
+
+  const resolved = result.stdout.trim()
+  if (!resolved) {
+    return {
+      nodePath: null,
+      error: 'ps returned an empty command path',
+    }
+  }
+
+  return { nodePath: resolved }
+}
+
+export function resolvePreferredNodePath(args: {
+  daemonPid?: number | null
+  fallbackNodePath?: string
+}): NodePathResolution {
+  const fallback = args.fallbackNodePath ?? process.execPath
+  const daemonPid = args.daemonPid
+
+  if (typeof daemonPid === 'number' && Number.isInteger(daemonPid) && daemonPid > 0) {
+    const fromPid = resolveNodePathFromPid(daemonPid)
+    if (fromPid.nodePath) {
+      return {
+        nodePath: fromPid.nodePath,
+        source: 'daemon_pid',
+      }
+    }
+
+    return {
+      nodePath: fallback,
+      source: 'current_process',
+      note: `Could not resolve node from daemon PID ${daemonPid}; using current process node (${fromPid.error ?? 'unknown error'})`,
+    }
+  }
+
+  return {
+    nodePath: fallback,
+    source: 'current_process',
+  }
+}
+
+export function resolveNpmInvocationFromNode(nodePath: string): NpmInvocation {
+  const binDir = path.dirname(nodePath)
+  const prefix = path.dirname(binDir)
+  const npmBinary = path.join(binDir, process.platform === 'win32' ? 'npm.cmd' : 'npm')
+
+  if (existsSync(npmBinary)) {
+    return {
+      nodePath,
+      npmPath: npmBinary,
+      command: npmBinary,
+      argsPrefix: [],
+    }
+  }
+
+  const npmCliCandidates = [
+    path.join(prefix, 'lib', 'node_modules', 'npm', 'bin', 'npm-cli.js'),
+    path.join(prefix, 'node_modules', 'npm', 'bin', 'npm-cli.js'),
+  ]
+
+  for (const candidate of npmCliCandidates) {
+    if (existsSync(candidate)) {
+      return {
+        nodePath,
+        npmPath: candidate,
+        command: nodePath,
+        argsPrefix: [candidate],
+      }
+    }
+  }
+
+  throw new Error(`Unable to resolve npm for node executable: ${nodePath}`)
+}
+
+export function formatNpmInvocation(invocation: NpmInvocation): string {
+  if (invocation.argsPrefix.length === 0) {
+    return invocation.command
+  }
+  return `${invocation.command} ${invocation.argsPrefix.join(' ')}`
+}
diff --git a/packages/cli/src/commands/daemon/status.ts b/packages/cli/src/commands/daemon/status.ts
index 3b52a95d7..7f051fc1e 100644
--- a/packages/cli/src/commands/daemon/status.ts
+++ b/packages/cli/src/commands/daemon/status.ts
@@ -1,7 +1,15 @@
 import type { Command } from 'commander'
+import { spawnSync } from 'node:child_process'
+import { createRequire } from 'node:module'
 import { tryConnectToDaemon } from '../../utils/client.js'
 import type { CommandOptions, ListResult, OutputSchema } from '../../output/index.js'
 import { resolveLocalDaemonState, resolveTcpHostFromListen } from './local-daemon.js'
+import {
+  formatNpmInvocation,
+  resolveNpmInvocationFromNode,
+  resolvePreferredNodePath,
+  type NpmInvocation,
+} from './runtime-toolchain.js'
 
 interface DaemonStatus {
   status: 'running' | 'stopped' | 'unresponsive'
@@ -13,6 +21,11 @@ interface DaemonStatus {
   logPath: string
   runningAgents: number | null
   idleAgents: number | null
+  runtimeNode: string
+  runtimeNpm: string
+  cliVersion: string
+  latestCliVersion: string
+  updateStatus: string
   note?: string
 }
 
@@ -21,6 +34,140 @@ interface StatusRow {
   value: string
 }
 
+type CliPackageJson = {
+  version?: unknown
+}
+
+type LatestCliVersionResult = {
+  version: string | null
+  note?: string
+}
+
+const require = createRequire(import.meta.url)
+const CLI_UPDATE_CHECK_TIMEOUT_MS = 3000
+
+function normalizeError(error: unknown): string {
+  if (error instanceof Error) {
+    return error.message
+  }
+  return String(error)
+}
+
+function shortenMessage(message: string, max = 120): string {
+  const normalized = message.replace(/\s+/g, ' ').trim()
+  if (normalized.length <= max) {
+    return normalized
+  }
+  return `${normalized.slice(0, max - 3)}...`
+}
+
+function appendNote(current: string | undefined, next: string | undefined): string | undefined {
+  if (!next) return current
+  if (!current) return next
+  return `${current}; ${next}`
+}
+
+function resolveCliVersion(): string {
+  try {
+    const packageJson = require('../../../package.json') as CliPackageJson
+    if (typeof packageJson.version === 'string' && packageJson.version.trim().length > 0) {
+      return packageJson.version.trim()
+    }
+  } catch {
+    // Fall through.
+  }
+  return 'unknown'
+}
+
+function parseVersionFromNpmOutput(raw: string): string | null {
+  const trimmed = raw.trim()
+  if (!trimmed) {
+    return null
+  }
+
+  try {
+    const parsed = JSON.parse(trimmed) as unknown
+    if (typeof parsed === 'string' && parsed.trim().length > 0) {
+      return parsed.trim()
+    }
+  } catch {
+    // Fall back to plain output.
+  }
+
+  return trimmed.replace(/^"+|"+$/g, '').trim() || null
+}
+
+function parseSemver(version: string): [number, number, number] | null {
+  const match = version.trim().match(/^v?(\d+)\.(\d+)\.(\d+)(?:[-+].*)?$/)
+  if (!match) {
+    return null
+  }
+
+  const major = Number(match[1])
+  const minor = Number(match[2])
+  const patch = Number(match[3])
+  if (![major, minor, patch].every((part) => Number.isInteger(part) && part >= 0)) {
+    return null
+  }
+
+  return [major, minor, patch]
+}
+
+function compareSemver(left: string, right: string): number | null {
+  const leftParts = parseSemver(left)
+  const rightParts = parseSemver(right)
+  if (!leftParts || !rightParts) {
+    return null
+  }
+
+  for (let index = 0; index < leftParts.length; index += 1) {
+    if (leftParts[index]! < rightParts[index]!) return -1
+    if (leftParts[index]! > rightParts[index]!) return 1
+  }
+
+  return 0
+}
+
+function fetchLatestCliVersion(npm: NpmInvocation): LatestCliVersionResult {
+  const result = spawnSync(
+    npm.command,
+    [...npm.argsPrefix, 'view', '@getpaseo/cli', 'version', '--json'],
+    {
+      encoding: 'utf8',
+      stdio: ['ignore', 'pipe', 'pipe'],
+      env: process.env,
+      timeout: CLI_UPDATE_CHECK_TIMEOUT_MS,
+    }
+  )
+
+  if (result.error) {
+    return {
+      version: null,
+      note: `update check failed: ${shortenMessage(normalizeError(result.error))}`,
+    }
+  }
+
+  if ((result.status ?? 1) !== 0) {
+    const stderr = result.stderr?.trim()
+    return {
+      version: null,
+      note: stderr
+        ? `update check failed: ${shortenMessage(stderr)}`
+        : `update check failed: npm exited with code ${result.status ?? 1}`,
+    }
+  }
+
+  const version = parseVersionFromNpmOutput(result.stdout)
+  if (!version) {
+    return {
+      version: null,
+      note: 'update check failed: empty npm response',
+    }
+  }
+
+  return { version }
+}
+
 function createStatusSchema(status: DaemonStatus): OutputSchema<StatusRow> {
   return {
     idField: 'key',
@@ -56,6 +203,11 @@ function toStatusRows(status: DaemonStatus): StatusRow[] {
     { key: 'Started', value: status.startedAt ?? '-' },
     { key: 'Owner', value: status.owner ?? '-' },
     { key: 'Logs', value: status.logPath },
+    { key: 'Node', value: status.runtimeNode },
+    { key: 'npm', value: status.runtimeNpm },
+    { key: 'CLI', value: status.cliVersion },
+    { key: 'Latest CLI', value: status.latestCliVersion },
+    { key: 'Update', value: status.updateStatus },
   ]
 
   if (status.runningAgents !== null && status.idleAgents !== null) {
@@ -96,14 +248,22 @@ export async function runStatusCommand(
   const state = resolveLocalDaemonState({ home })
 
   const owner = resolveOwnerLabel(state.pidInfo?.uid, state.pidInfo?.hostname)
+  const resolvedNode = resolvePreferredNodePath({
+    daemonPid: state.running ? state.pidInfo?.pid : null,
+    fallbackNodePath: process.execPath,
+  })
   let status: DaemonStatus['status'] = state.running ? 'running' : 'stopped'
   let runningAgents: number | null = null
   let idleAgents: number | null = null
   let note: string | undefined
+  let runtimeNpm = '-'
+  let latestCliVersion = 'unknown'
+  let updateStatus = 'unknown'
 
   if (!state.running && state.stalePidFile && state.pidInfo) {
     note = `Stale PID file found for PID ${state.pidInfo.pid}`
   }
+  note = appendNote(note, resolvedNode.note)
 
   if (state.running) {
     const host = resolveTcpHostFromListen(state.listen)
@@ -117,19 +277,52 @@ export async function runStatusCommand(
           idleAgents = agents.filter(a => a.status === 'idle').length
         } catch {
           status = 'unresponsive'
-          note = `Daemon PID is running but API requests to ${host} failed`
+          note = appendNote(note, `Daemon PID is running but API requests to ${host} failed`)
         } finally {
           await client.close().catch(() => {})
         }
       } else {
         status = 'unresponsive'
-        note = `Daemon PID is running but websocket at ${host} is not reachable`
+        note = appendNote(note, `Daemon PID is running but websocket at ${host} is not reachable`)
       }
     } else {
-      note = 'Daemon is configured for unix socket listen; API probe skipped'
+      note = appendNote(note, 'Daemon is configured for unix socket listen; API probe skipped')
     }
   }
 
+  let npmInvocation: NpmInvocation | null = null
+  try {
+    npmInvocation = resolveNpmInvocationFromNode(resolvedNode.nodePath)
+    runtimeNpm = formatNpmInvocation(npmInvocation)
+  } catch (err) {
+    runtimeNpm = `unresolved (${shortenMessage(normalizeError(err))})`
+  }
+
+  const cliVersion = resolveCliVersion()
+  if (npmInvocation) {
+    const latest = fetchLatestCliVersion(npmInvocation)
+    if (latest.version) {
+      latestCliVersion = latest.version
+      if (cliVersion === 'unknown') {
+        updateStatus = 'unknown (local CLI version unavailable)'
+      } else {
+        const comparison = compareSemver(cliVersion, latest.version)
+        if (comparison === null) {
+          updateStatus = 'unknown (version format not comparable)'
+        } else if (comparison < 0) {
+          updateStatus = `update available (${cliVersion} -> ${latest.version})`
+        } else {
+          updateStatus = 'up to date'
+        }
+      }
+    } else {
+      latestCliVersion = 'unknown'
+      updateStatus = latest.note ?? 'unknown'
+    }
+  } else {
+    updateStatus = 'unknown (npm unresolved)'
+  }
+
   const daemonStatus: DaemonStatus = {
     status,
     home: state.home,
@@ -140,6 +333,11 @@ export async function runStatusCommand(
     logPath: state.logPath,
     runningAgents,
     idleAgents,
+    runtimeNode: `${resolvedNode.nodePath} (${resolvedNode.source})`,
+    runtimeNpm,
+    cliVersion,
+    latestCliVersion,
+    updateStatus,
     note,
   }
 
diff --git a/packages/cli/src/commands/daemon/update.ts b/packages/cli/src/commands/daemon/update.ts
new file mode 100644
index 000000000..5fc46d768
--- /dev/null
+++ b/packages/cli/src/commands/daemon/update.ts
@@ -0,0 +1,105 @@
+import { confirm, isCancel } from '@clack/prompts'
+import { spawn } from 'node:child_process'
+import { Command } from 'commander'
+import chalk from 'chalk'
+import { runRestartCommand } from './restart.js'
+import { resolveLocalDaemonState } from './local-daemon.js'
+import {
+  resolveNpmInvocationFromNode,
+  resolvePreferredNodePath,
+  type NpmInvocation,
+} from './runtime-toolchain.js'
+import { getErrorMessage } from '../../utils/errors.js'
+
+export interface DaemonUpdateOptions {
+  home?: string
+  yes?: boolean
+}
+
+function runCommand(command: string, args: string[]): Promise<number> {
+  return new Promise((resolve, reject) => {
+    const child = spawn(command, args, {
+      stdio: 'inherit',
+      env: process.env,
+    })
+
+    child.once('error', reject)
+    child.once('exit', (code, signal) => {
+      if (signal) {
+        reject(new Error(`Command exited via signal ${signal}`))
+        return
+      }
+      resolve(code ?? 1)
+    })
+  })
+}
+
+export async function runDaemonUpdateCommand(options: DaemonUpdateOptions): Promise<void> {
+  const daemonState = resolveLocalDaemonState({ home: options.home })
+  const resolvedNode = resolvePreferredNodePath({
+    daemonPid: daemonState.running ? daemonState.pidInfo?.pid : null,
+    fallbackNodePath: process.execPath,
+  })
+  const npm: NpmInvocation = resolveNpmInvocationFromNode(resolvedNode.nodePath)
+  const args = [...npm.argsPrefix, 'install', '-g', '@getpaseo/cli@latest']
+
+  const exitCode = await runCommand(npm.command, args)
+  if (exitCode !== 0) {
+    throw new Error(`Update command failed with exit code ${exitCode}`)
+  }
+
+  let shouldRestart = options.yes === true
+  if (!shouldRestart) {
+    if (!process.stdin.isTTY || !process.stdout.isTTY) {
+      console.log(chalk.yellow('Update complete. Restart skipped (non-interactive terminal).'))
+      console.log(chalk.dim('Run `paseo daemon restart` when ready.'))
+      return
+    }
+
+    console.log(
+      chalk.yellow(
+        'Restart will stop running agents, but they can continue from persisted state after restart.'
+      )
+    )
+    const answer = await confirm({
+      message: 'Restart daemon now?',
+      active: 'Restart now',
+      inactive: 'Later',
+      initialValue: true,
+    })
+
+    if (isCancel(answer)) {
+      console.log(chalk.yellow('Update complete. Restart skipped.'))
+      return
+    }
+
+    shouldRestart = answer
+  }
+
+  if (!shouldRestart) {
+    console.log(chalk.yellow('Update complete. Restart skipped.'))
+    return
+  }
+
+  const restartResult = await runRestartCommand({ home: options.home }, new Command())
+  console.log(chalk.green(restartResult.data.message))
+}
+
+export async function runDaemonUpdateCommandOrExit(options: DaemonUpdateOptions): Promise<void> {
+  try {
+    await runDaemonUpdateCommand(options)
+  } catch (err) {
+    console.error(chalk.red(`Failed to update daemon: ${getErrorMessage(err)}`))
+    process.exit(1)
+  }
+}
+
+export function updateCommand(): Command {
+  return new Command('update')
+    .description('Update local daemon package')
+    .option('--home <path>', 'Paseo home directory (default: ~/.paseo)')
+    .option('-y, --yes', 'Restart automatically after update')
+    .action(async (options: DaemonUpdateOptions) => {
+      await runDaemonUpdateCommandOrExit(options)
+    })
+}
diff --git a/packages/cli/src/commands/provider/index.ts b/packages/cli/src/commands/provider/index.ts
index 1f226831e..04a219824 100644
--- a/packages/cli/src/commands/provider/index.ts
+++ b/packages/cli/src/commands/provider/index.ts
@@ -17,6 +17,7 @@ export function createProviderCommand(): Command {
     .command('models')
     .description('List models for a provider')
     .argument('<provider>', 'Provider name (claude, codex, opencode)')
+    .option('--thinking', 'Include thinking option IDs for each model')
     .option('--json', 'Output in JSON format')
     .option('--host <host>', 'Daemon host:port (default: localhost:6767)')
     .action(withOutput(runModelsCommand))
diff --git a/packages/cli/src/commands/provider/models.ts b/packages/cli/src/commands/provider/models.ts
index 62637b881..5d66e887d 100644
--- a/packages/cli/src/commands/provider/models.ts
+++ b/packages/cli/src/commands/provider/models.ts
@@ -7,10 +7,11 @@ export interface ModelListItem {
   model: string
   id: string
   description: string
+  thinkingOptionIds: string[]
+  defaultThinkingOptionId: string | null
+  thinkingOptions: string
 }
 
-const VALID_PROVIDERS = ['claude', 'codex', 'opencode']
-
 /** Schema for provider models output */
 export const providerModelsSchema: OutputSchema<ModelListItem> = {
   idField: 'id',
@@ -21,10 +22,25 @@ export const providerModelsSchema: OutputSchema<ModelListItem> = {
   ],
 }
 
+const providerModelsWithThinkingSchema: OutputSchema<ModelListItem> = {
+  idField: 'id',
+  columns: [
+    { header: 'ID', field: 'id', width: 30 },
+    { header: 'MODEL', field: 'model', width: 30 },
+    { header: 'THINKING IDS', field: 'thinkingOptions', width: 40 },
+    {
+      header: 'DEFAULT THINKING',
+      field: (item) => item.defaultThinkingOptionId ?? 'auto',
+      width: 18,
+    },
+  ],
+}
+
 export type ProviderModelsResult = ListResult<ModelListItem>
 
 export interface ProviderModelsOptions extends CommandOptions {
   host?: string
+  thinking?: boolean
 }
 
 export async function runModelsCommand(
@@ -34,14 +50,6 @@ export async function runModelsCommand(
 ): Promise<ProviderModelsResult> {
   const normalizedProvider = provider.toLowerCase()
 
-  if (!VALID_PROVIDERS.includes(normalizedProvider)) {
-    throw {
-      code: 'UNKNOWN_PROVIDER',
-      message: `Unknown provider: ${provider}`,
-      details: `Valid providers: ${VALID_PROVIDERS.join(', ')}`,
-    }
-  }
-
   const client = await connectToDaemon({ host: options.host })
   try {
     const result = await client.listProviderModels(normalizedProvider)
@@ -57,12 +65,16 @@ export async function runModelsCommand(
       model: m.label,
       id: m.id,
       description: m.description ?? '',
+      thinkingOptionIds: (m.thinkingOptions ?? []).map((option) => option.id),
+      defaultThinkingOptionId: m.defaultThinkingOptionId ?? null,
+      thinkingOptions:
+        (m.thinkingOptions ?? []).map((option) => option.id).join(', ') || 'none',
     }))
 
     return {
       type: 'list',
       data: models,
-      schema: providerModelsSchema,
+      schema: options.thinking ? providerModelsWithThinkingSchema : providerModelsSchema,
     }
   } finally {
     await client.close()
diff --git a/packages/relay/src/dist-handshake-parity.test.ts b/packages/relay/src/dist-handshake-parity.test.ts
new file mode 100644
index 000000000..af25cc77a
--- /dev/null
+++ b/packages/relay/src/dist-handshake-parity.test.ts
@@ -0,0 +1,21 @@
+import { readFileSync } from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { describe, expect, it } from "vitest";
+
+const THIS_DIR = path.dirname(fileURLToPath(import.meta.url));
+const DIST_ENCRYPTED_CHANNEL_PATH = path.resolve(THIS_DIR, "../dist/encrypted-channel.js");
+
+describe("relay dist handshake parity", () => {
+  it("keeps Node dist handshake message types in sync with src", () => {
+    const distCode = readFileSync(DIST_ENCRYPTED_CHANNEL_PATH, "utf8");
+
+    expect(distCode).toContain('type: "e2ee_hello"');
+    expect(distCode).toContain('type: "e2ee_ready"');
+
+    // Guard against accidentally shipping the legacy hello/ready protocol.
+    expect(distCode).not.toMatch(/\btype:\s*"hello"\b/);
+    expect(distCode).not.toMatch(/\btype:\s*"ready"\b/);
+  });
+});
+
diff --git a/packages/relay/src/encrypted-channel.ts b/packages/relay/src/encrypted-channel.ts
index 9b298ba12..4f86fc90b 100644
--- a/packages/relay/src/encrypted-channel.ts
+++ b/packages/relay/src/encrypted-channel.ts
@@ -56,6 +56,23 @@ interface E2EEReadyMessage {
   type: "e2ee_ready";
 }
 
+function buildInvalidHelloError(rawText: string, parsed?: unknown): Error {
+  const parsedRecord =
+    parsed && typeof parsed === "object"
+      ? (parsed as Record<string, unknown>)
+      : null;
+  const rawType = parsedRecord?.type;
+  const receivedType =
+    typeof rawType === "string" ? rawType : rawType === undefined ? "undefined" : typeof rawType;
+  const hasKey =
+    typeof parsedRecord?.key === "string" && parsedRecord.key.trim().length > 0;
+  const compact = rawText.replace(/\s+/g, " ").trim();
+  const preview = compact.length > 160 ? `${compact.slice(0, 157)}...` : compact;
+  return new Error(
+    `Invalid hello message (receivedType=${receivedType}, hasKey=${hasKey}, preview=${JSON.stringify(preview)})`
+  );
+}
+
 const HANDSHAKE_RETRY_MS = 1000;
 const MAX_PENDING_SENDS = 200;
 
@@ -154,9 +171,16 @@ export async function createDaemonChannel(
         const helloText =
           typeof data === "string" ? data : new TextDecoder().decode(data);
 
-        const msg = JSON.parse(helloText) as E2EEHelloMessage;
-        if (msg.type !== "e2ee_hello" || !msg.key) {
-          throw new Error("Invalid hello message");
+        let parsed: unknown;
+        try {
+          parsed = JSON.parse(helloText);
+        } catch {
+          throw buildInvalidHelloError(helloText);
+        }
+
+        const msg = parsed as Partial<E2EEHelloMessage>;
+        if (msg.type !== "e2ee_hello" || typeof msg.key !== "string" || !msg.key.trim()) {
+          throw buildInvalidHelloError(helloText, parsed);
         }
 
         // Buffer any subsequent messages that arrive while we're doing async
diff --git a/packages/server/src/server/agent/agent-manager.test.ts b/packages/server/src/server/agent/agent-manager.test.ts
index d5d01d4de..7d9d14677 100644
--- a/packages/server/src/server/agent/agent-manager.test.ts
+++ b/packages/server/src/server/agent/agent-manager.test.ts
@@ -1004,6 +1004,86 @@ describe("AgentManager", () => {
     expect(lifecycleUpdates).toContain("idle");
   });
 
+  test("cancelAgentRun can interrupt autonomous running state without a foreground pendingRun", async () => {
+    const workdir = mkdtempSync(join(tmpdir(), "agent-manager-live-cancel-"));
+    const storagePath = join(workdir, "agents");
+    const storage = new AgentStorage(storagePath, logger);
+    const liveEvents = new EventPushable<AgentStreamEvent>();
+
+    class LiveInterruptSession extends TestAgentSession {
+      public interruptCount = 0;
+
+      async *streamLiveEvents(): AsyncGenerator<AgentStreamEvent> {
+        for await (const event of liveEvents) {
+          yield event;
+        }
+      }
+
+      override async interrupt(): Promise<void> {
+        this.interruptCount += 1;
+      }
+
+      override async close(): Promise<void> {
+        liveEvents.end();
+      }
+    }
+
+    class LiveInterruptClient extends TestAgentClient {
+      lastSession: LiveInterruptSession | null = null;
+
+      override async createSession(config: AgentSessionConfig): Promise<AgentSession> {
+        const session = new LiveInterruptSession(config);
+        this.lastSession = session;
+        return session;
+      }
+    }
+
+    const client = new LiveInterruptClient();
+    const manager = new AgentManager({
+      clients: {
+        codex: client,
+      },
+      registry: storage,
+      logger,
+      idFactory: () => "00000000-0000-4000-8000-000000000129",
+    });
+
+    const snapshot = await manager.createAgent({
+      provider: "codex",
+      cwd: workdir,
+    });
+
+    await new Promise<void>((resolve) => {
+      const unsubscribe = manager.subscribe(
+        (event) => {
+          if (event.type !== "agent_state") {
+            return;
+          }
+          if (event.agent.id !== snapshot.id) {
+            return;
+          }
+          if (event.agent.lifecycle !== "running") {
+            return;
+          }
+          unsubscribe();
+          resolve();
+        },
+        { agentId: snapshot.id, replayState: false }
+      );
+      liveEvents.push({ type: "turn_started", provider: "codex" });
+    });
+
+    const beforeCancel = manager.getAgent(snapshot.id);
+    expect(beforeCancel?.lifecycle).toBe("running");
+    expect(Boolean(beforeCancel && "pendingRun" in beforeCancel && beforeCancel.pendingRun)).toBe(
+      false
+    );
+
+    const cancelled = await manager.cancelAgentRun(snapshot.id);
+    expect(cancelled).toBe(true);
+    expect(client.lastSession?.interruptCount).toBe(1);
+  });
+
   test("waitForAgentEvent waitForActive resolves for autonomous live-event run", async () => {
     const workdir = mkdtempSync(join(tmpdir(), "agent-manager-live-wait-"));
     const storagePath = join(workdir, "agents");
@@ -1050,6 +1130,167 @@ describe("AgentManager", () => {
     expect(result.status).toBe("idle");
   });
 
+  test("buffers autonomous live events during foreground run and flushes after run settles", async () => {
+    const workdir = mkdtempSync(join(tmpdir(), "agent-manager-live-buffer-"));
+    const storagePath = join(workdir, "agents");
+    const storage = new AgentStorage(storagePath, logger);
+    const liveEvents = new EventPushable<AgentStreamEvent>();
+    const releaseForeground = deferred<void>();
+
+    class BufferedLiveSession extends TestAgentSession {
+      override async *stream(): AsyncGenerator<AgentStreamEvent> {
+        yield { type: "turn_started", provider: this.provider };
+        await releaseForeground.promise;
+        yield { type: "turn_completed", provider: this.provider };
+      }
+
+      async *streamLiveEvents(): AsyncGenerator<AgentStreamEvent> {
+        for await (const event of liveEvents) {
+          yield event;
+        }
+      }
+
+      override async close(): Promise<void> {
+        liveEvents.end();
+      }
+    }
+
+    class BufferedLiveClient extends TestAgentClient {
+      override async createSession(config: AgentSessionConfig): Promise<AgentSession> {
+        return new BufferedLiveSession(config);
+      }
+    }
+
+    const manager = new AgentManager({
+      clients: {
+        codex: new BufferedLiveClient(),
+      },
+      registry: storage,
+      logger,
+      idFactory: () => "00000000-0000-4000-8000-000000000127",
+    });
+
+    const snapshot = await manager.createAgent({
+      provider: "codex",
+      cwd: workdir,
+    });
+
+    const foreground = manager.streamAgent(snapshot.id, "foreground run");
+    const consumeForeground = (async () => {
+      for await (const _event of foreground) {
+        // Drain foreground stream.
+      }
+    })();
+
+    await manager.waitForAgentRunStart(snapshot.id);
+
+    liveEvents.push({ type: "turn_started", provider: "codex" });
+    liveEvents.push({
+      type: "timeline",
+      provider: "codex",
+      item: { type: "assistant_message", text: "AUTONOMOUS_DURING_FOREGROUND" },
+    });
+    liveEvents.push({ type: "turn_completed", provider: "codex" });
+
+    releaseForeground.resolve();
+    await consumeForeground;
+
+    const updated = manager.getAgent(snapshot.id);
+    expect(updated?.lifecycle).toBe("idle");
+    expect(manager.getTimeline(snapshot.id)).toContainEqual({
+      type: "assistant_message",
+      text: "AUTONOMOUS_DURING_FOREGROUND",
+    });
+  });
+
+  test("restarts live event pump after iterator failure", async () => {
+    const workdir = mkdtempSync(join(tmpdir(), "agent-manager-live-restart-"));
+    const storagePath = join(workdir, "agents");
+    const storage = new AgentStorage(storagePath, logger);
+    const liveEvents = new EventPushable<AgentStreamEvent>();
+
+    class FlakyLiveSession extends TestAgentSession {
+      private attempts = 0;
+
+      async *streamLiveEvents(): AsyncGenerator<AgentStreamEvent> {
+        this.attempts += 1;
+        if (this.attempts === 1) {
+          throw new Error("simulated live iterator failure");
+        }
+        for await (const event of liveEvents) {
+          yield event;
+        }
+      }
+
+      override async close(): Promise<void> {
+        liveEvents.end();
+      }
+    }
+
+    class FlakyLiveClient extends TestAgentClient {
+      override async createSession(config: AgentSessionConfig): Promise<AgentSession> {
+        return new FlakyLiveSession(config);
+      }
+    }
+
+    const manager = new AgentManager({
+      clients: {
+        codex: new FlakyLiveClient(),
+      },
+      registry: storage,
+      logger,
+      idFactory: () => "00000000-0000-4000-8000-000000000128",
+    });
+
+    const snapshot = await manager.createAgent({
+      provider: "codex",
+      cwd: workdir,
+    });
+
+    // Give the first failed stream a chance to restart.
+    await new Promise((resolve) => setTimeout(resolve, 350));
+
+    const assistantSeen = new Promise<void>((resolve, reject) => {
+      const timeout = setTimeout(() => {
+        unsubscribe();
+        reject(new Error("Timed out waiting for restarted live event"));
+      }, 2_000);
+      const unsubscribe = manager.subscribe(
+        (event) => {
+          if (event.type !== "agent_stream" || event.agentId !== snapshot.id) {
+            return;
+          }
+          if (
+            event.event.type === "timeline" &&
+            event.event.item.type === "assistant_message" &&
+            event.event.item.text === "AUTONOMOUS_AFTER_RESTART"
+          ) {
+            clearTimeout(timeout);
+            unsubscribe();
+            resolve();
+          }
+        },
+        { agentId: snapshot.id, replayState: false }
+      );
+    });
+
+    liveEvents.push({ type: "turn_started", provider: "codex" });
+    liveEvents.push({
+      type: "timeline",
+      provider: "codex",
+      item: { type: "assistant_message", text: "AUTONOMOUS_AFTER_RESTART" },
+    });
+    liveEvents.push({ type: "turn_completed", provider: "codex" });
+
+    await assistantSeen;
+    const result = await manager.waitForAgentEvent(snapshot.id);
+    expect(result.status).toBe("idle");
+    expect(manager.getTimeline(snapshot.id)).toContainEqual({
+      type: "assistant_message",
+      text: "AUTONOMOUS_AFTER_RESTART",
+    });
+  });
+
   test("keeps updatedAt monotonic when user message and run start happen in the same millisecond", async () => {
     const workdir = mkdtempSync(join(tmpdir(), "agent-manager-test-"));
     const storagePath = join(workdir, "agents");
diff --git a/packages/server/src/server/agent/agent-manager.ts b/packages/server/src/server/agent/agent-manager.ts
index aea05ce2e..d653664fb 100644
--- a/packages/server/src/server/agent/agent-manager.ts
+++ b/packages/server/src/server/agent/agent-manager.ts
@@ -296,6 +296,7 @@ export class AgentManager {
   private readonly previousStatuses = new Map<string, AgentLifecycleStatus>();
   private readonly backgroundTasks = new Set<Promise<void>>();
   private readonly liveEventPumps = new Map<string, Promise<void>>();
+  private readonly liveEventBacklog = new Map<string, AgentStreamEvent[]>();
   private onAgentAttention?: AgentAttentionCallback;
   private logger: Logger;
 
@@ -743,6 +744,7 @@ export class AgentManager {
     // Remove the existing agent entry before swapping sessions
     this.agents.delete(agentId);
     this.liveEventPumps.delete(agentId);
+    this.liveEventBacklog.delete(agentId);
     try {
       await existing.session.close();
     } catch (error) {
@@ -773,6 +775,7 @@ export class AgentManager {
     const agent = this.requireAgent(agentId);
     this.agents.delete(agentId);
     this.liveEventPumps.delete(agentId);
+    this.liveEventBacklog.delete(agentId);
     // Clean up previousStatus to prevent memory leak
     this.previousStatuses.delete(agentId);
     const session = agent.session;
@@ -1004,6 +1007,7 @@ export class AgentManager {
         );
       }
       this.emitState(mutableAgent);
+      this.flushLiveEventBacklog(mutableAgent);
     };
 
     const self = this;
@@ -1147,7 +1151,11 @@ export class AgentManager {
   async cancelAgentRun(agentId: string): Promise<boolean> {
     const agent = this.requireAgent(agentId);
     const pendingRun = agent.pendingRun;
-    if (!pendingRun || typeof pendingRun.return !== "function") {
+    const hasForegroundPendingRun =
+      Boolean(pendingRun) && typeof pendingRun?.return === "function";
+    const isAutonomousRunning = agent.lifecycle === "running" && !hasForegroundPendingRun;
+
+    if (!hasForegroundPendingRun && !isAutonomousRunning) {
       return false;
     }
 
@@ -1160,16 +1168,18 @@ export class AgentManager {
       );
     }
 
-    try {
-      // Await the generator's .return() to ensure the finally block runs
-      // and pendingRun is properly cleared before we return.
-      await pendingRun.return(undefined as unknown as AgentStreamEvent);
-    } catch (error) {
-      this.logger.error(
-        { err: error, agentId },
-        "Failed to cancel run"
-      );
-      throw error;
+    if (hasForegroundPendingRun && pendingRun) {
+      try {
+        // Await the generator's .return() to ensure the finally block runs
+        // and pendingRun is properly cleared before we return.
+        await pendingRun.return(undefined as unknown as AgentStreamEvent);
+      } catch (error) {
+        this.logger.error(
+          { err: error, agentId },
+          "Failed to cancel run"
+        );
+        throw error;
+      }
     }
 
     // Clear any pending permissions that weren't cleaned up by handleStreamEvent.
@@ -1564,6 +1574,7 @@ export class AgentManager {
       const newInfo = await agent.session.getRuntimeInfo();
       const changed =
         newInfo.model !== agent.runtimeInfo?.model ||
+        newInfo.thinkingOptionId !== agent.runtimeInfo?.thinkingOptionId ||
         newInfo.sessionId !== agent.runtimeInfo?.sessionId ||
         newInfo.modeId !== agent.runtimeInfo?.modeId;
       agent.runtimeInfo = newInfo;
@@ -1926,29 +1937,54 @@ export class AgentManager {
     if (!supportsLiveEventStream(agent.session)) {
       return;
     }
-    const liveSession = agent.session;
     if (this.liveEventPumps.has(agent.id)) {
       return;
     }
     const pump = (async () => {
-      try {
-        for await (const event of liveSession.streamLiveEvents()) {
-          const current = this.agents.get(agent.id);
-          if (!current) {
-            break;
+      while (true) {
+        const current = this.agents.get(agent.id);
+        if (!current) {
+          return;
+        }
+        if (!supportsLiveEventStream(current.session)) {
+          return;
+        }
+
+        try {
+          for await (const event of current.session.streamLiveEvents()) {
+            const latest = this.agents.get(agent.id);
+            if (!latest) {
+              return;
+            }
+            // Keep consuming provider events even during an active foreground run,
+            // then replay them immediately once that run settles.
+            if (latest.pendingRun) {
+              this.enqueueLiveEvent(latest.id, event);
+              continue;
+            }
+            this.flushLiveEventBacklog(latest);
+            this.handleStreamEvent(latest, event);
           }
-          // Foreground streamAgent owns live prompt events while running.
-          // Background live-event tailing is for autonomous activity while idle.
-          if (current.pendingRun) {
-            continue;
-          }
-          this.handleStreamEvent(current, event);
+          this.logger.warn(
+            { agentId: agent.id },
+            "Live event pump stream ended; restarting"
+          );
+        } catch (error) {
+          this.logger.warn(
+            { err: error, agentId: agent.id },
+            "Live event pump failed"
+          );
+        }
+
+        // Keep pump alive unless the agent is gone.
+        await new Promise((resolve) => setTimeout(resolve, 250));
+        const latest = this.agents.get(agent.id);
+        if (!latest) {
+          return;
+        }
+        if (!latest.pendingRun) {
+          this.flushLiveEventBacklog(latest);
         }
-      } catch (error) {
-        this.logger.warn(
-          { err: error, agentId: agent.id },
-          "Live event pump failed"
-        );
       }
     })();
     this.liveEventPumps.set(agent.id, pump);
@@ -1959,4 +1995,27 @@ export class AgentManager {
       }
     });
   }
+
+  private enqueueLiveEvent(agentId: string, event: AgentStreamEvent): void {
+    const existing = this.liveEventBacklog.get(agentId);
+    if (existing) {
+      existing.push(event);
+      return;
+    }
+    this.liveEventBacklog.set(agentId, [event]);
+  }
+
+  private flushLiveEventBacklog(agent: ActiveManagedAgent): void {
+    if (agent.pendingRun) {
+      return;
+    }
+    const pending = this.liveEventBacklog.get(agent.id);
+    if (!pending || pending.length === 0) {
+      return;
+    }
+    this.liveEventBacklog.delete(agent.id);
+    for (const event of pending) {
+      this.handleStreamEvent(agent, event);
+    }
+  }
 }
diff --git a/packages/server/src/server/agent/agent-projections.ts b/packages/server/src/server/agent/agent-projections.ts
index 542bbf766..f86aa5559 100644
--- a/packages/server/src/server/agent/agent-projections.ts
+++ b/packages/server/src/server/agent/agent-projections.ts
@@ -24,6 +24,23 @@ type ProjectionOptions = {
   internal?: boolean;
 };
 
+function normalizeThinkingOptionId(value: string | null | undefined): string | null {
+  if (typeof value !== "string") return null;
+  const normalized = value.trim();
+  return normalized.length > 0 ? normalized : null;
+}
+
+export function resolveEffectiveThinkingOptionId(options: {
+  runtimeInfo?: AgentRuntimeInfo | null;
+  configuredThinkingOptionId?: string | null;
+}): string | null {
+  const runtimeInfo = options.runtimeInfo;
+  if (runtimeInfo && "thinkingOptionId" in runtimeInfo) {
+    return normalizeThinkingOptionId(runtimeInfo.thinkingOptionId);
+  }
+  return normalizeThinkingOptionId(options.configuredThinkingOptionId);
+}
+
 export function toStoredAgentRecord(
   agent: ManagedAgent,
   options?: ProjectionOptions
@@ -67,6 +84,10 @@ export function toAgentPayload(
 ): AgentSnapshotPayload {
   const runtimeInfo = sanitizeRuntimeInfo(agent.runtimeInfo);
   const thinkingOptionId = agent.config.thinkingOptionId ?? null;
+  const effectiveThinkingOptionId = resolveEffectiveThinkingOptionId({
+    runtimeInfo,
+    configuredThinkingOptionId: thinkingOptionId,
+  });
 
   const payload: AgentSnapshotPayload = {
     id: agent.id,
@@ -74,6 +95,7 @@ export function toAgentPayload(
     cwd: agent.cwd,
     model: agent.config.model ?? null,
     thinkingOptionId,
+    effectiveThinkingOptionId,
     runtimeInfo,
     createdAt: agent.createdAt.toISOString(),
     updatedAt: agent.updatedAt.toISOString(),
@@ -287,6 +309,9 @@ function sanitizeRuntimeInfo(
   if (runtimeInfo.model !== undefined) {
     sanitized.model = runtimeInfo.model;
   }
+  if (runtimeInfo.thinkingOptionId !== undefined) {
+    sanitized.thinkingOptionId = runtimeInfo.thinkingOptionId;
+  }
   if (runtimeInfo.modeId !== undefined) {
     sanitized.modeId = runtimeInfo.modeId;
   }
diff --git a/packages/server/src/server/agent/agent-sdk-types.ts b/packages/server/src/server/agent/agent-sdk-types.ts
index eb6882a77..15900de4e 100644
--- a/packages/server/src/server/agent/agent-sdk-types.ts
+++ b/packages/server/src/server/agent/agent-sdk-types.ts
@@ -278,6 +278,7 @@ export type AgentRuntimeInfo = {
   provider: AgentProvider;
   sessionId: string | null;
   model?: string | null;
+  thinkingOptionId?: string | null;
   modeId?: string | null;
   extra?: AgentMetadata;
 };
diff --git a/packages/server/src/server/agent/agent-storage.ts b/packages/server/src/server/agent/agent-storage.ts
index 94f9e1462..fa9cbfff7 100644
--- a/packages/server/src/server/agent/agent-storage.ts
+++ b/packages/server/src/server/agent/agent-storage.ts
@@ -49,6 +49,7 @@ const STORED_AGENT_SCHEMA = z.object({
       provider: z.string(),
       sessionId: z.string().nullable(),
       model: z.string().nullable().optional(),
+      thinkingOptionId: z.string().nullable().optional(),
       modeId: z.string().nullable().optional(),
       extra: z.record(z.unknown()).optional(),
     })
diff --git a/packages/server/src/server/agent/providers/claude-agent.interrupt-restart-regression.test.ts b/packages/server/src/server/agent/providers/claude-agent.interrupt-restart-regression.test.ts
index 424c19aa5..797b39a7d 100644
--- a/packages/server/src/server/agent/providers/claude-agent.interrupt-restart-regression.test.ts
+++ b/packages/server/src/server/agent/providers/claude-agent.interrupt-restart-regression.test.ts
@@ -1,7 +1,4 @@
 import { afterEach, beforeEach, describe, expect, test, vi } from "vitest";
-import { appendFileSync, mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import path from "node:path";
 
 import { createTestLogger } from "../../../test-utils/test-logger.js";
 import { ClaudeAgentClient } from "./claude-agent.js";
@@ -295,7 +292,7 @@ describe("ClaudeAgentSession interrupt restart regression", () => {
     const secondTurnEvents = await secondTurnPromise;
     const secondAssistantText = collectAssistantText(secondTurnEvents);
 
-    expect(sdkMocks.query).toHaveBeenCalledTimes(2);
+    expect(sdkMocks.query.mock.calls.length).toBeGreaterThanOrEqual(2);
     expect(secondAssistantText).toContain("NEW_TURN_RESPONSE");
     expect(secondAssistantText).not.toContain("OLD_TURN_RESPONSE");
 
@@ -430,6 +427,299 @@ describe("ClaudeAgentSession interrupt restart regression", () => {
     await session.close();
   });
 
+  test("ignores stale task-notification message_start bursts before prompt replay", async () => {
+    const logger = createTestLogger();
+
+    sdkMocks.query.mockImplementation(({ prompt }: { prompt: AsyncIterable<unknown> }) => {
+      const readPromptUuid = createPromptUuidReader(prompt);
+      let step = 0;
+      return {
+        next: vi.fn(async () => {
+          if (step === 0) {
+            step += 1;
+            return {
+              done: false,
+              value: {
+                type: "system",
+                subtype: "init",
+                session_id: "task-notification-message-start-session",
+                permissionMode: "default",
+                model: "opus",
+              },
+            };
+          }
+          if (step === 1) {
+            step += 1;
+            return {
+              done: false,
+              value: {
+                type: "system",
+                subtype: "task_notification",
+                task_id: "task-msg-start-1",
+                status: "completed",
+                output_file: "/tmp/task-msg-start-1.txt",
+                summary: "Background task finished",
+                session_id: "task-notification-message-start-session",
+                uuid: "task-msg-start-note-1",
+              },
+            };
+          }
+          if (step === 2) {
+            step += 1;
+            return {
+              done: false,
+              value: {
+                type: "stream_event",
+                parent_tool_use_id: null,
+                event: {
+                  type: "message_start",
+                  message: {
+                    id: "stale-msg-start-1",
+                    role: "assistant",
+                    model: "opus",
+                    usage: { input_tokens: 1, output_tokens: 0 },
+                  },
+                },
+              },
+            };
+          }
+          if (step === 3) {
+            step += 1;
+            return {
+              done: false,
+              value: {
+                type: "assistant",
+                message: {
+                  content: "STALE_MESSAGE_START_RESPONSE",
+                },
+              },
+            };
+          }
+          if (step === 4) {
+            step += 1;
+            return {
+              done: false,
+              value: {
+                type: "result",
+                subtype: "success",
+                usage: buildUsage(),
+                total_cost_usd: 0,
+              },
+            };
+          }
+          if (step === 5) {
+            step += 1;
+            const promptUuid = (await readPromptUuid()) ?? "missing-prompt-uuid";
+            return {
+              done: false,
+              value: {
+                type: "user",
+                message: { role: "user", content: "current prompt" },
+                parent_tool_use_id: null,
+                uuid: promptUuid,
+                session_id: "task-notification-message-start-session",
+                isReplay: true,
+              },
+            };
+          }
+          if (step === 6) {
+            step += 1;
+            return {
+              done: false,
+              value: {
+                type: "assistant",
+                message: {
+                  content: "CURRENT_AFTER_MESSAGE_START",
+                },
+              },
+            };
+          }
+          if (step === 7) {
+            step += 1;
+            return {
+              done: false,
+              value: {
+                type: "result",
+                subtype: "success",
+                usage: buildUsage(),
+                total_cost_usd: 0,
+              },
+            };
+          }
+          return { done: true, value: undefined };
+        }),
+        interrupt: vi.fn(async () => undefined),
+        return: vi.fn(async () => undefined),
+        setPermissionMode: vi.fn(async () => undefined),
+        setModel: vi.fn(async () => undefined),
+        supportedModels: vi.fn(async () => [{ value: "opus", displayName: "Opus" }]),
+        supportedCommands: vi.fn(async () => []),
+        rewindFiles: vi.fn(async () => ({ canRewind: true })),
+      } satisfies QueryMock;
+    });
+
+    const client = new ClaudeAgentClient({ logger });
+    const session = await client.createSession({
+      provider: "claude",
+      cwd: process.cwd(),
+    });
+
+    const events = await collectUntilTerminal(session.stream("current prompt"));
+    const assistantText = collectAssistantText(events);
+
+    expect(assistantText).toContain("CURRENT_AFTER_MESSAGE_START");
+    expect(assistantText).not.toContain("STALE_MESSAGE_START_RESPONSE");
+
+    await session.close();
+  });
+
+  test("ignores stale user-shaped task-notification message_start bursts before prompt replay", async () => {
+    const logger = createTestLogger();
+
+    sdkMocks.query.mockImplementation(({ prompt }: { prompt: AsyncIterable<unknown> }) => {
+      const readPromptUuid = createPromptUuidReader(prompt);
+      let step = 0;
+      return {
+        next: vi.fn(async () => {
+          if (step === 0) {
+            step += 1;
+            return {
+              done: false,
+              value: {
+                type: "system",
+                subtype: "init",
+                session_id: "task-notification-user-message-start-session",
+                permissionMode: "default",
+                model: "opus",
+              },
+            };
+          }
+          if (step === 1) {
+            step += 1;
+            return {
+              done: false,
+              value: {
+                type: "user",
+                message: {
+                  role: "user",
+                  content:
+                    "<task-notification>\n<task-id>task-msg-start-user-1</task-id>\n</task-notification>",
+                },
+                parent_tool_use_id: null,
+                uuid: "task-msg-start-user-1",
+                session_id: "task-notification-user-message-start-session",
+              },
+            };
+          }
+          if (step === 2) {
+            step += 1;
+            return {
+              done: false,
+              value: {
+                type: "stream_event",
+                parent_tool_use_id: null,
+                event: {
+                  type: "message_start",
+                  message: {
+                    id: "stale-user-msg-start-1",
+                    role: "assistant",
+                    model: "opus",
+                    usage: { input_tokens: 1, output_tokens: 0 },
+                  },
+                },
+              },
+            };
+          }
+          if (step === 3) {
+            step += 1;
+            return {
+              done: false,
+              value: {
+                type: "assistant",
+                message: {
+                  content: "STALE_USER_TASK_NOTIFICATION_RESPONSE",
+                },
+              },
+            };
+          }
+          if (step === 4) {
+            step += 1;
+            return {
+              done: false,
+              value: {
+                type: "result",
+                subtype: "success",
+                usage: buildUsage(),
+                total_cost_usd: 0,
+              },
+            };
+          }
+          if (step === 5) {
+            step += 1;
+            const promptUuid = (await readPromptUuid()) ?? "missing-prompt-uuid";
+            return {
+              done: false,
+              value: {
+                type: "user",
+                message: { role: "user", content: "current prompt" },
+                parent_tool_use_id: null,
+                uuid: promptUuid,
+                session_id: "task-notification-user-message-start-session",
+                isReplay: true,
+              },
+            };
+          }
+          if (step === 6) {
+            step += 1;
+            return {
+              done: false,
+              value: {
+                type: "assistant",
+                message: {
+                  content: "CURRENT_AFTER_USER_MESSAGE_START",
+                },
+              },
+            };
+          }
+          if (step === 7) {
+            step += 1;
+            return {
+              done: false,
+              value: {
+                type: "result",
+                subtype: "success",
+                usage: buildUsage(),
+                total_cost_usd: 0,
+              },
+            };
+          }
+          return { done: true, value: undefined };
+        }),
+        interrupt: vi.fn(async () => undefined),
+        return: vi.fn(async () => undefined),
+        setPermissionMode: vi.fn(async () => undefined),
+        setModel: vi.fn(async () => undefined),
+        supportedModels: vi.fn(async () => [{ value: "opus", displayName: "Opus" }]),
+        supportedCommands: vi.fn(async () => []),
+        rewindFiles: vi.fn(async () => ({ canRewind: true })),
+      } satisfies QueryMock;
+    });
+
+    const client = new ClaudeAgentClient({ logger });
+    const session = await client.createSession({
+      provider: "claude",
+      cwd: process.cwd(),
+    });
+
+    const events = await collectUntilTerminal(session.stream("current prompt"));
+    const assistantText = collectAssistantText(events);
+
+    expect(assistantText).toContain("CURRENT_AFTER_USER_MESSAGE_START");
+    expect(assistantText).not.toContain("STALE_USER_TASK_NOTIFICATION_RESPONSE");
+
+    await session.close();
+  });
+
   test("does not terminate the current prompt on a stale pre-prompt result event", async () => {
     const logger = createTestLogger();
 
@@ -528,156 +818,408 @@ describe("ClaudeAgentSession interrupt restart regression", () => {
     await session.close();
   });
 
-  test("emits autonomous live events from history tail when Claude wakes itself", async () => {
+  test("emits autonomous live events from SDK stream when Claude wakes itself", async () => {
     const logger = createTestLogger();
-    const projectDir = mkdtempSync(path.join(tmpdir(), "claude-live-tail-project-"));
-    const configDir = mkdtempSync(path.join(tmpdir(), "claude-live-tail-config-"));
-    const previousClaudeConfigDir = process.env.CLAUDE_CONFIG_DIR;
-    process.env.CLAUDE_CONFIG_DIR = configDir;
+    let queryCreateCount = 0;
+    let localPromptUuid: string | null = null;
 
-    sdkMocks.query.mockImplementation(() => {
-      let step = 0;
-      return {
-        next: vi.fn(async () => {
-          if (step === 0) {
-            step += 1;
-            return {
-              done: false,
-              value: {
-                type: "system",
-                subtype: "init",
-                session_id: "live-autonomous-session",
-                permissionMode: "default",
-                model: "opus",
-              },
-            };
-          }
-          if (step === 1) {
-            step += 1;
-            return {
-              done: false,
-              value: {
-                type: "result",
-                subtype: "success",
-                usage: buildUsage(),
-                total_cost_usd: 0,
-              },
-            };
-          }
-          return { done: true, value: undefined };
-        }),
-        interrupt: vi.fn(async () => undefined),
-        return: vi.fn(async () => undefined),
-        setPermissionMode: vi.fn(async () => undefined),
-        setModel: vi.fn(async () => undefined),
-        supportedModels: vi.fn(async () => [{ value: "opus", displayName: "Opus" }]),
-        supportedCommands: vi.fn(async () => []),
-        rewindFiles: vi.fn(async () => ({ canRewind: true })),
-      } satisfies QueryMock;
+    sdkMocks.query.mockImplementation(
+      ({ prompt }: { prompt: AsyncIterable<unknown> }) => {
+        queryCreateCount += 1;
+        if (queryCreateCount === 1) {
+          const readPromptUuid = createPromptUuidReader(prompt);
+          let step = 0;
+          return {
+            next: vi.fn(async () => {
+              if (step === 0) {
+                step += 1;
+                return {
+                  done: false,
+                  value: {
+                    type: "system",
+                    subtype: "init",
+                    session_id: "live-autonomous-session",
+                    permissionMode: "default",
+                    model: "opus",
+                  },
+                };
+              }
+              if (step === 1) {
+                step += 1;
+                localPromptUuid = (await readPromptUuid()) ?? "missing-prompt-uuid";
+                return {
+                  done: false,
+                  value: {
+                    type: "user",
+                    message: { role: "user", content: "seed prompt" },
+                    parent_tool_use_id: null,
+                    uuid: localPromptUuid,
+                    session_id: "live-autonomous-session",
+                    isReplay: true,
+                  },
+                };
+              }
+              if (step === 2) {
+                step += 1;
+                return {
+                  done: false,
+                  value: {
+                    type: "assistant",
+                    message: { content: "SEED_DONE" },
+                  },
+                };
+              }
+              if (step === 3) {
+                step += 1;
+                return {
+                  done: false,
+                  value: {
+                    type: "result",
+                    subtype: "success",
+                    usage: buildUsage(),
+                    total_cost_usd: 0,
+                  },
+                };
+              }
+              return { done: true, value: undefined };
+            }),
+            interrupt: vi.fn(async () => undefined),
+            return: vi.fn(async () => undefined),
+            setPermissionMode: vi.fn(async () => undefined),
+            setModel: vi.fn(async () => undefined),
+            supportedModels: vi.fn(async () => [{ value: "opus", displayName: "Opus" }]),
+            supportedCommands: vi.fn(async () => []),
+            rewindFiles: vi.fn(async () => ({ canRewind: true })),
+          } satisfies QueryMock;
+        }
+
+        let step = 0;
+        return {
+          next: vi.fn(async () => {
+            if (step === 0) {
+              step += 1;
+              return {
+                done: false,
+                value: {
+                  type: "user",
+                  message: {
+                    role: "user",
+                    content:
+                      "<task-notification>\n<task-id>bg-1</task-id>\n<status>completed</status>\n</task-notification>",
+                  },
+                  parent_tool_use_id: null,
+                  uuid: "task-note-user-1",
+                  session_id: "live-autonomous-session",
+                },
+              };
+            }
+            if (step === 1) {
+              step += 1;
+              return {
+                done: false,
+                value: {
+                  type: "assistant",
+                  message: { content: "AUTONOMOUS_WAKE_RESPONSE" },
+                },
+              };
+            }
+            if (step === 2) {
+              step += 1;
+              return {
+                done: false,
+                value: {
+                  type: "result",
+                  subtype: "success",
+                  usage: buildUsage(),
+                  total_cost_usd: 0,
+                },
+              };
+            }
+            return { done: true, value: undefined };
+          }),
+          interrupt: vi.fn(async () => undefined),
+          return: vi.fn(async () => undefined),
+          setPermissionMode: vi.fn(async () => undefined),
+          setModel: vi.fn(async () => undefined),
+          supportedModels: vi.fn(async () => [{ value: "opus", displayName: "Opus" }]),
+          supportedCommands: vi.fn(async () => []),
+          rewindFiles: vi.fn(async () => ({ canRewind: true })),
+        } satisfies QueryMock;
+      }
+    );
+
+    const client = new ClaudeAgentClient({ logger });
+    const session = await client.createSession({
+      provider: "claude",
+      cwd: process.cwd(),
     });
 
-    try {
-      const client = new ClaudeAgentClient({ logger });
-      const session = await client.createSession({
-        provider: "claude",
-        cwd: projectDir,
-      });
-
-      await collectUntilTerminal(session.stream("seed prompt"));
-      expect(session.describePersistence()?.sessionId).toBe(
-        "live-autonomous-session"
-      );
-
-      const sanitizedCwd = projectDir.replace(/[\\/\.]/g, "-").replace(/_/g, "-");
-      const historyDir = path.join(configDir, "projects", sanitizedCwd);
-      mkdirSync(historyDir, { recursive: true });
-      const historyPath = path.join(historyDir, "live-autonomous-session.jsonl");
-      writeFileSync(historyPath, "", "utf8");
-
-      const liveIterator = (
-        session as unknown as {
-          streamLiveEvents: () => AsyncGenerator<AgentStreamEvent>;
-        }
-      ).streamLiveEvents();
-      const timedReader = createTimedIteratorReader({ iterator: liveIterator });
-      const appendAutonomousBurst = (suffix: string) => {
-        appendFileSync(
-          historyPath,
-          `${JSON.stringify({
-            type: "system",
-            subtype: "task_notification",
-            task_id: `task-${suffix}`,
-            status: "completed",
-            output_file: "/tmp/out.txt",
-            summary: "Background task finished",
-            uuid: `task-note-uuid-${suffix}`,
-            session_id: "live-autonomous-session",
-          })}\n`
-        );
-        appendFileSync(
-          historyPath,
-          `${JSON.stringify({
-            type: "assistant",
-            message: { content: "AUTONOMOUS_WAKE_RESPONSE" },
-            uuid: `assistant-uuid-${suffix}`,
-            session_id: "live-autonomous-session",
-          })}\n`
-        );
-        appendFileSync(
-          historyPath,
-          `${JSON.stringify({
-            type: "result",
-            subtype: "success",
-            usage: buildUsage(),
-            total_cost_usd: 0,
-            uuid: `result-uuid-${suffix}`,
-            session_id: "live-autonomous-session",
-          })}\n`
-        );
-      };
-
-      const liveEvents: AgentStreamEvent[] = [];
-      let completed = false;
-      for (let attempt = 0; attempt < 4 && !completed; attempt += 1) {
-        appendAutonomousBurst(String(attempt));
-        while (liveEvents.length < 12) {
-          let next: IteratorResult<AgentStreamEvent>;
-          try {
-            next = await timedReader.nextWithTimeout(2_000);
-          } catch {
-            break;
-          }
-          if (next.done) {
-            break;
-          }
-          liveEvents.push(next.value);
-          if (next.value.type === "turn_completed") {
-            completed = true;
-            break;
-          }
-        }
+    await collectUntilTerminal(session.stream("seed prompt"));
+    expect(localPromptUuid).toBeTruthy();
+    expect(session.describePersistence()?.sessionId).toBe("live-autonomous-session");
+    for (let attempt = 0; attempt < 80; attempt += 1) {
+      const activeTurnPromise = (
+        session as unknown as { activeTurnPromise?: Promise<void> | null }
+      ).activeTurnPromise;
+      if (!activeTurnPromise) {
+        break;
       }
-
-      expect(liveEvents.some((event) => event.type === "turn_started")).toBe(true);
-      expect(
-        liveEvents.some(
-          (event) =>
-            event.type === "timeline" &&
-            event.item.type === "assistant_message" &&
-            event.item.text.includes("AUTONOMOUS_WAKE_RESPONSE")
-        )
-      ).toBe(true);
-      expect(liveEvents.some((event) => event.type === "turn_completed")).toBe(true);
-
-      await session.close();
-    } finally {
-      if (previousClaudeConfigDir === undefined) {
-        delete process.env.CLAUDE_CONFIG_DIR;
-      } else {
-        process.env.CLAUDE_CONFIG_DIR = previousClaudeConfigDir;
-      }
-      rmSync(projectDir, { recursive: true, force: true });
-      rmSync(configDir, { recursive: true, force: true });
+      await new Promise((resolve) => setTimeout(resolve, 25));
     }
+    expect(
+      (session as unknown as { activeTurnPromise?: Promise<void> | null })
+        .activeTurnPromise ?? null
+    ).toBeNull();
+
+    const liveIterator = (
+      session as unknown as {
+        streamLiveEvents: () => AsyncGenerator<AgentStreamEvent>;
+      }
+    ).streamLiveEvents();
+    const timedReader = createTimedIteratorReader({ iterator: liveIterator });
+    const liveEvents: AgentStreamEvent[] = [];
+
+    for (let attempt = 0; attempt < 8; attempt += 1) {
+      const next = await timedReader.nextWithTimeout(5_000);
+      if (next.done) {
+        break;
+      }
+      liveEvents.push(next.value);
+      if (next.value.type === "turn_completed") {
+        break;
+      }
+    }
+
+    expect(liveEvents.some((event) => event.type === "turn_started")).toBe(true);
+    expect(
+      liveEvents.some(
+        (event) =>
+          event.type === "timeline" &&
+          event.item.type === "assistant_message" &&
+          event.item.text.includes("AUTONOMOUS_WAKE_RESPONSE")
+      )
+    ).toBe(true);
+    expect(liveEvents.some((event) => event.type === "turn_completed")).toBe(true);
+
+    await liveIterator.return?.();
+    await session.close();
+  });
+
+  test("releases local-turn suppression when task notifications arrive as user payloads", async () => {
+    const logger = createTestLogger();
+    let queryCreateCount = 0;
+    let localPromptUuid: string | null = null;
+
+    sdkMocks.query.mockImplementation(
+      ({ prompt }: { prompt: AsyncIterable<unknown> }) => {
+        queryCreateCount += 1;
+        if (queryCreateCount === 1) {
+          const readPromptUuid = createPromptUuidReader(prompt);
+          let step = 0;
+          return {
+            next: vi.fn(async () => {
+              if (step === 0) {
+                step += 1;
+                return {
+                  done: false,
+                  value: {
+                    type: "system",
+                    subtype: "init",
+                    session_id: "live-task-user-session",
+                    permissionMode: "default",
+                    model: "opus",
+                  },
+                };
+              }
+              if (step === 1) {
+                step += 1;
+                localPromptUuid = (await readPromptUuid()) ?? "missing-prompt-uuid";
+                return {
+                  done: false,
+                  value: {
+                    type: "user",
+                    message: { role: "user", content: "seed prompt" },
+                    parent_tool_use_id: null,
+                    uuid: localPromptUuid,
+                    session_id: "live-task-user-session",
+                    isReplay: true,
+                  },
+                };
+              }
+              if (step === 2) {
+                step += 1;
+                return {
+                  done: false,
+                  value: {
+                    type: "assistant",
+                    message: { content: "SEED_DONE" },
+                  },
+                };
+              }
+              if (step === 3) {
+                step += 1;
+                return {
+                  done: false,
+                  value: {
+                    type: "result",
+                    subtype: "success",
+                    usage: buildUsage(),
+                    total_cost_usd: 0,
+                  },
+                };
+              }
+              return { done: true, value: undefined };
+            }),
+            interrupt: vi.fn(async () => undefined),
+            return: vi.fn(async () => undefined),
+            setPermissionMode: vi.fn(async () => undefined),
+            setModel: vi.fn(async () => undefined),
+            supportedModels: vi.fn(async () => [{ value: "opus", displayName: "Opus" }]),
+            supportedCommands: vi.fn(async () => []),
+            rewindFiles: vi.fn(async () => ({ canRewind: true })),
+          } satisfies QueryMock;
+        }
+
+        let step = 0;
+        return {
+          next: vi.fn(async () => {
+            if (step === 0) {
+              step += 1;
+              return {
+                done: false,
+                value: {
+                  type: "user",
+                  message: { role: "user", content: "seed prompt" },
+                  parent_tool_use_id: null,
+                  uuid: localPromptUuid ?? "missing-prompt-uuid",
+                  session_id: "live-task-user-session",
+                  isReplay: true,
+                },
+              };
+            }
+            if (step === 1) {
+              step += 1;
+              return {
+                done: false,
+                value: {
+                  type: "assistant",
+                  message: { content: "SHOULD_STAY_SUPPRESSED" },
+                },
+              };
+            }
+            if (step === 2) {
+              step += 1;
+              return {
+                done: false,
+                value: {
+                  type: "user",
+                  message: {
+                    role: "user",
+                    content:
+                      "<task-notification>\n<task-id>bg-1</task-id>\n<status>completed</status>\n</task-notification>",
+                  },
+                  parent_tool_use_id: null,
+                  uuid: "task-note-user-1",
+                  session_id: "live-task-user-session",
+                },
+              };
+            }
+            if (step === 3) {
+              step += 1;
+              return {
+                done: false,
+                value: {
+                  type: "assistant",
+                  message: { content: "AUTONOMOUS_AFTER_TASK_NOTIFICATION" },
+                },
+              };
+            }
+            if (step === 4) {
+              step += 1;
+              return {
+                done: false,
+                value: {
+                  type: "result",
+                  subtype: "success",
+                  usage: buildUsage(),
+                  total_cost_usd: 0,
+                },
+              };
+            }
+            return { done: true, value: undefined };
+          }),
+          interrupt: vi.fn(async () => undefined),
+          return: vi.fn(async () => undefined),
+          setPermissionMode: vi.fn(async () => undefined),
+          setModel: vi.fn(async () => undefined),
+          supportedModels: vi.fn(async () => [{ value: "opus", displayName: "Opus" }]),
+          supportedCommands: vi.fn(async () => []),
+          rewindFiles: vi.fn(async () => ({ canRewind: true })),
+        } satisfies QueryMock;
+      }
+    );
+
+    const client = new ClaudeAgentClient({ logger });
+    const session = await client.createSession({
+      provider: "claude",
+      cwd: process.cwd(),
+    });
+
+    await collectUntilTerminal(session.stream("seed prompt"));
+    expect(localPromptUuid).toBeTruthy();
+    expect(session.describePersistence()?.sessionId).toBe("live-task-user-session");
+    for (let attempt = 0; attempt < 80; attempt += 1) {
+      const activeTurnPromise = (
+        session as unknown as { activeTurnPromise?: Promise<void> | null }
+      ).activeTurnPromise;
+      if (!activeTurnPromise) {
+        break;
+      }
+      await new Promise((resolve) => setTimeout(resolve, 25));
+    }
+    expect(
+      (session as unknown as { activeTurnPromise?: Promise<void> | null })
+        .activeTurnPromise ?? null
+    ).toBeNull();
+
+    const liveIterator = (
+      session as unknown as {
+        streamLiveEvents: () => AsyncGenerator<AgentStreamEvent>;
+      }
+    ).streamLiveEvents();
+    const timedReader = createTimedIteratorReader({ iterator: liveIterator });
+    const liveEvents: AgentStreamEvent[] = [];
+
+    for (let attempt = 0; attempt < 12; attempt += 1) {
+      const next = await timedReader.nextWithTimeout(5_000);
+      if (next.done) {
+        break;
+      }
+      liveEvents.push(next.value);
+      if (next.value.type === "turn_completed") {
+        break;
+      }
+    }
+
+    expect(
+      liveEvents.some(
+        (event) =>
+          event.type === "timeline" &&
+          event.item.type === "assistant_message" &&
+          event.item.text.includes("SHOULD_STAY_SUPPRESSED")
+      )
+    ).toBe(false);
+    expect(liveEvents.some((event) => event.type === "turn_started")).toBe(true);
+    expect(
+      liveEvents.some(
+        (event) =>
+          event.type === "timeline" &&
+          event.item.type === "assistant_message" &&
+          event.item.text.includes("AUTONOMOUS_AFTER_TASK_NOTIFICATION")
+      )
+    ).toBe(true);
+
+    await liveIterator.return?.();
+    await session.close();
   });
 });
diff --git a/packages/server/src/server/agent/providers/claude-agent.redesign.test.ts b/packages/server/src/server/agent/providers/claude-agent.redesign.test.ts
new file mode 100644
index 000000000..022cbb513
--- /dev/null
+++ b/packages/server/src/server/agent/providers/claude-agent.redesign.test.ts
@@ -0,0 +1,800 @@
+import { afterEach, beforeEach, describe, expect, test, vi } from "vitest";
+
+import { createTestLogger } from "../../../test-utils/test-logger.js";
+import { AgentManager } from "../agent-manager.js";
+import { ClaudeAgentClient } from "./claude-agent.js";
+import type { AgentStreamEvent } from "../agent-sdk-types.js";
+
+const sdkMocks = vi.hoisted(() => ({
+  query: vi.fn(),
+}));
+
+vi.mock("@anthropic-ai/claude-agent-sdk", () => ({
+  query: sdkMocks.query,
+}));
+
+type QueryMock = {
+  next: ReturnType<typeof vi.fn>;
+  interrupt: ReturnType<typeof vi.fn>;
+  return: ReturnType<typeof vi.fn>;
+  setPermissionMode: ReturnType<typeof vi.fn>;
+  setModel: ReturnType<typeof vi.fn>;
+  supportedModels: ReturnType<typeof vi.fn>;
+  supportedCommands: ReturnType<typeof vi.fn>;
+  rewindFiles: ReturnType<typeof vi.fn>;
+};
+
+function buildUsage() {
+  return {
+    input_tokens: 1,
+    cache_read_input_tokens: 0,
+    output_tokens: 1,
+  };
+}
+
+function createPromptUuidReader(prompt: AsyncIterable<unknown>) {
+  const iterator = prompt[Symbol.asyncIterator]();
+  let cached: Promise<string | null> | null = null;
+  return async () => {
+    if (!cached) {
+      cached = iterator.next().then((next) => {
+        if (next.done) {
+          return null;
+        }
+        const value = next.value as { uuid?: unknown } | undefined;
+        return typeof value?.uuid === "string" ? value.uuid : null;
+      });
+    }
+    return cached;
+  };
+}
+
+function createBaseQueryMock(nextImpl: QueryMock["next"]): QueryMock {
+  return {
+    next: nextImpl,
+    interrupt: vi.fn(async () => undefined),
+    return: vi.fn(async () => undefined),
+    setPermissionMode: vi.fn(async () => undefined),
+    setModel: vi.fn(async () => undefined),
+    supportedModels: vi.fn(async () => [{ value: "opus", displayName: "Opus" }]),
+    supportedCommands: vi.fn(async () => []),
+    rewindFiles: vi.fn(async () => ({ canRewind: true })),
+  };
+}
+
+async function createSession() {
+  const client = new ClaudeAgentClient({ logger: createTestLogger() });
+  return client.createSession({
+    provider: "claude",
+    cwd: process.cwd(),
+  });
+}
+
+async function collectUntilTerminal(
+  stream: AsyncGenerator<AgentStreamEvent>
+): Promise<AgentStreamEvent[]> {
+  const events: AgentStreamEvent[] = [];
+  for await (const event of stream) {
+    events.push(event);
+    if (
+      event.type === "turn_completed" ||
+      event.type === "turn_failed" ||
+      event.type === "turn_canceled"
+    ) {
+      break;
+    }
+  }
+  return events;
+}
+
+async function waitForCondition(
+  check: () => boolean,
+  timeoutMs: number
+): Promise<void> {
+  const started = Date.now();
+  while (Date.now() - started < timeoutMs) {
+    if (check()) {
+      return;
+    }
+    await new Promise((resolve) => setTimeout(resolve, 20));
+  }
+  throw new Error("Timed out waiting for condition");
+}
+
+describe("ClaudeAgentSession redesign invariants", () => {
+  beforeEach(() => {
+    sdkMocks.query.mockReset();
+  });
+
+  afterEach(() => {
+    sdkMocks.query.mockReset();
+  });
+
+  test("routes by deterministic identifier priority: task_id > parent_message_id > message_id", async () => {
+    const session = await createSession();
+    const internal = session as unknown as {
+      createRun: (owner: "autonomous", queue: null) => { id: string };
+      runTracker: {
+        bindIdentifiers: (
+          run: { id: string },
+          ids: { taskId: string | null; parentMessageId: string | null; messageId: string | null }
+        ) => void;
+      };
+      routeMessage: (input: {
+        message: AgentStreamEvent | Record<string, unknown>;
+        identifiers: { taskId: string | null; parentMessageId: string | null; messageId: string | null };
+        metadataOnly: boolean;
+      }) => { run: { id: string } | null; reason: string };
+      turnState: "autonomous";
+    };
+
+    const taskRun = internal.createRun("autonomous", null);
+    internal.runTracker.bindIdentifiers(taskRun, {
+      taskId: "task-A",
+      parentMessageId: null,
+      messageId: "msg-A",
+    });
+
+    const parentRun = internal.createRun("autonomous", null);
+    internal.runTracker.bindIdentifiers(parentRun, {
+      taskId: null,
+      parentMessageId: "parent-B",
+      messageId: "msg-B",
+    });
+
+    const messageRun = internal.createRun("autonomous", null);
+    internal.runTracker.bindIdentifiers(messageRun, {
+      taskId: null,
+      parentMessageId: null,
+      messageId: "msg-C",
+    });
+
+    internal.turnState = "autonomous";
+
+    const taskPriorityRoute = internal.routeMessage({
+      message: { type: "assistant", message: { content: "task-priority" } },
+      identifiers: {
+        taskId: "task-A",
+        parentMessageId: "parent-B",
+        messageId: "msg-C",
+      },
+      metadataOnly: false,
+    });
+    expect(taskPriorityRoute.reason).toBe("task_id");
+    expect(taskPriorityRoute.run?.id).toBe(taskRun.id);
+
+    const parentPriorityRoute = internal.routeMessage({
+      message: { type: "assistant", message: { content: "parent-priority" } },
+      identifiers: {
+        taskId: null,
+        parentMessageId: "parent-B",
+        messageId: "msg-C",
+      },
+      metadataOnly: false,
+    });
+    expect(parentPriorityRoute.reason).toBe("parent_message_id");
+    expect(parentPriorityRoute.run?.id).toBe(parentRun.id);
+
+    const messagePriorityRoute = internal.routeMessage({
+      message: { type: "assistant", message: { content: "message-priority" } },
+      identifiers: {
+        taskId: null,
+        parentMessageId: null,
+        messageId: "msg-C",
+      },
+      metadataOnly: false,
+    });
+    expect(messagePriorityRoute.reason).toBe("message_id");
+    expect(messagePriorityRoute.run?.id).toBe(messageRun.id);
+
+    await session.close();
+  });
+
+  test("does not route unbound events to foreground before prompt replay is observed", async () => {
+    const session = await createSession();
+    const internal = session as unknown as {
+      createRun: (owner: "foreground" | "autonomous", queue: unknown) => { id: string };
+      runTracker: {
+        bindIdentifiers: (
+          run: { id: string },
+          ids: { taskId: string | null; parentMessageId: string | null; messageId: string | null }
+        ) => void;
+      };
+      activeForegroundTurn: { runId: string; queue: unknown } | null;
+      turnState: "foreground";
+      routeMessage: (input: {
+        message: Record<string, unknown>;
+        identifiers: { taskId: string | null; parentMessageId: string | null; messageId: string | null };
+        metadataOnly: boolean;
+      }) => { run: { id: string } | null; reason: string };
+    };
+
+    const foregroundQueueStub = {
+      push: () => undefined,
+      end: () => undefined,
+      [Symbol.asyncIterator]: () => ({
+        next: async () => ({ done: true as const, value: undefined }),
+      }),
+    };
+    const foregroundRun = internal.createRun("foreground", foregroundQueueStub);
+    internal.turnState = "foreground";
+    internal.activeForegroundTurn = {
+      runId: foregroundRun.id,
+      queue: foregroundQueueStub,
+    };
+
+    const unboundBeforeReplay = internal.routeMessage({
+      message: { type: "assistant", message: { content: "stale-before-replay" } },
+      identifiers: {
+        taskId: null,
+        parentMessageId: null,
+        messageId: null,
+      },
+      metadataOnly: false,
+    });
+    expect(unboundBeforeReplay.reason).toBe("fallback");
+    expect(unboundBeforeReplay.run?.id).not.toBe(foregroundRun.id);
+
+    const promptReplayId = "foreground-replay-id";
+    internal.runTracker.bindIdentifiers(foregroundRun, {
+      taskId: null,
+      parentMessageId: null,
+      messageId: promptReplayId,
+    });
+    const replayRoute = internal.routeMessage({
+      message: {
+        type: "user",
+        message: { role: "user", content: "prompt replay" },
+        uuid: promptReplayId,
+      },
+      identifiers: {
+        taskId: null,
+        parentMessageId: null,
+        messageId: promptReplayId,
+      },
+      metadataOnly: false,
+    });
+    expect(replayRoute.reason).toBe("message_id");
+    expect(replayRoute.run?.id).toBe(foregroundRun.id);
+
+    await session.close();
+  });
+
+  test("tracks run lifecycle transitions for success, error, and interrupt", async () => {
+    const session = await createSession();
+    let streamCase: "success" | "error" | "interrupt" = "success";
+
+    sdkMocks.query.mockImplementation(({ prompt }: { prompt: AsyncIterable<unknown> }) => {
+      const readPromptUuid = createPromptUuidReader(prompt);
+      let step = 0;
+      let interruptRequested = false;
+
+      const mock = createBaseQueryMock(
+        vi.fn(async () => {
+          if (step === 0) {
+            step += 1;
+            return {
+              done: false,
+              value: {
+                type: "system",
+                subtype: "init",
+                session_id: "redesign-lifecycle-session",
+                permissionMode: "default",
+                model: "opus",
+              },
+            };
+          }
+          if (step === 1) {
+            step += 1;
+            return {
+              done: false,
+              value: {
+                type: "user",
+                message: { role: "user", content: "prompt replay" },
+                parent_tool_use_id: null,
+                uuid: (await readPromptUuid()) ?? "missing-prompt-uuid",
+                session_id: "redesign-lifecycle-session",
+              },
+            };
+          }
+          if (step === 2) {
+            step += 1;
+            return {
+              done: false,
+              value: {
+                type: "assistant",
+                message: { content: "assistant output" },
+              },
+            };
+          }
+          if (streamCase === "interrupt") {
+            if (!interruptRequested) {
+              await new Promise<void>((resolve) => setTimeout(resolve, 50));
+              return {
+                done: false,
+                value: {
+                  type: "assistant",
+                  message: { content: "waiting for interrupt" },
+                },
+              };
+            }
+            return { done: true, value: undefined };
+          }
+          if (step === 3) {
+            step += 1;
+            if (streamCase === "success") {
+              return {
+                done: false,
+                value: {
+                  type: "result",
+                  subtype: "success",
+                  usage: buildUsage(),
+                  total_cost_usd: 0,
+                },
+              };
+            }
+            return {
+              done: false,
+              value: {
+                type: "result",
+                subtype: "error",
+                usage: buildUsage(),
+                errors: ["simulated failure"],
+                total_cost_usd: 0,
+              },
+            };
+          }
+          return { done: true, value: undefined };
+        })
+      );
+
+      mock.interrupt.mockImplementation(async () => {
+        interruptRequested = true;
+      });
+      return mock;
+    });
+
+    streamCase = "success";
+    const successEvents = await collectUntilTerminal(session.stream("success prompt"));
+    expect(successEvents.some((event) => event.type === "turn_completed")).toBe(
+      true
+    );
+    expect(successEvents.some((event) => event.type === "turn_failed")).toBe(
+      false
+    );
+    expect(successEvents.some((event) => event.type === "turn_canceled")).toBe(
+      false
+    );
+
+    streamCase = "error";
+    const errorEvents = await collectUntilTerminal(session.stream("error prompt"));
+    expect(errorEvents.some((event) => event.type === "turn_failed")).toBe(true);
+    expect(errorEvents.some((event) => event.type === "turn_completed")).toBe(
+      false
+    );
+
+    streamCase = "interrupt";
+    const interruptStream = session.stream("interrupt prompt");
+    const interruptEvents: AgentStreamEvent[] = [];
+    for await (const event of interruptStream) {
+      interruptEvents.push(event);
+      if (
+        event.type === "timeline" &&
+        event.item.type === "assistant_message"
+      ) {
+        await session.interrupt();
+      }
+      if (event.type === "turn_canceled") {
+        break;
+      }
+    }
+    expect(interruptEvents.some((event) => event.type === "turn_canceled")).toBe(
+      true
+    );
+
+    await session.close();
+  });
+
+  test("assembles assistant timeline when message_delta arrives before message_start", async () => {
+    sdkMocks.query.mockImplementation(({ prompt }: { prompt: AsyncIterable<unknown> }) => {
+      const readPromptUuid = createPromptUuidReader(prompt);
+      let step = 0;
+      return createBaseQueryMock(
+        vi.fn(async () => {
+          if (step === 0) {
+            step += 1;
+            return {
+              done: false,
+              value: {
+                type: "system",
+                subtype: "init",
+                session_id: "redesign-timeline-session",
+                permissionMode: "default",
+                model: "opus",
+              },
+            };
+          }
+          if (step === 1) {
+            step += 1;
+            return {
+              done: false,
+              value: {
+                type: "user",
+                message: { role: "user", content: "timeline prompt" },
+                parent_tool_use_id: null,
+                uuid: (await readPromptUuid()) ?? "missing-prompt-uuid",
+                session_id: "redesign-timeline-session",
+              },
+            };
+          }
+          if (step === 2) {
+            step += 1;
+            return {
+              done: false,
+              value: {
+                type: "stream_event",
+                event: {
+                  type: "content_block_delta",
+                  delta: { type: "text_delta", text: "HELLO " },
+                },
+              },
+            };
+          }
+          if (step === 3) {
+            step += 1;
+            return {
+              done: false,
+              value: {
+                type: "stream_event",
+                event: {
+                  type: "message_start",
+                  message: { id: "message-1", role: "assistant", model: "opus" },
+                },
+              },
+            };
+          }
+          if (step === 4) {
+            step += 1;
+            return {
+              done: false,
+              value: {
+                type: "stream_event",
+                event: {
+                  type: "content_block_delta",
+                  message_id: "message-1",
+                  delta: { type: "text_delta", text: "WORLD" },
+                },
+              },
+            };
+          }
+          if (step === 5) {
+            step += 1;
+            return {
+              done: false,
+              value: {
+                type: "stream_event",
+                event: {
+                  type: "message_stop",
+                  message_id: "message-1",
+                },
+              },
+            };
+          }
+          if (step === 6) {
+            step += 1;
+            return {
+              done: false,
+              value: {
+                type: "result",
+                subtype: "success",
+                usage: buildUsage(),
+                total_cost_usd: 0,
+              },
+            };
+          }
+          return { done: true, value: undefined };
+        })
+      );
+    });
+
+    const session = await createSession();
+    const events = await collectUntilTerminal(session.stream("timeline prompt"));
+    const assistantText = events
+      .filter(
+        (event): event is Extract<AgentStreamEvent, { type: "timeline" }> =>
+          event.type === "timeline" && event.item.type === "assistant_message"
+      )
+      .map((event) => event.item.text)
+      .join("");
+
+    expect(assistantText).toContain("HELLO WORLD");
+
+    await session.close();
+  });
+
+  test("does not use stream_event uuid as assistant message identity when message_id is missing", async () => {
+    sdkMocks.query.mockImplementation(({ prompt }: { prompt: AsyncIterable<unknown> }) => {
+      const readPromptUuid = createPromptUuidReader(prompt);
+      let step = 0;
+      return createBaseQueryMock(
+        vi.fn(async () => {
+          if (step === 0) {
+            step += 1;
+            return {
+              done: false,
+              value: {
+                type: "system",
+                subtype: "init",
+                session_id: "redesign-stream-event-uuid-session",
+                permissionMode: "default",
+                model: "opus",
+              },
+            };
+          }
+          if (step === 1) {
+            step += 1;
+            return {
+              done: false,
+              value: {
+                type: "user",
+                message: { role: "user", content: "uuid fallback prompt" },
+                parent_tool_use_id: null,
+                uuid: (await readPromptUuid()) ?? "missing-prompt-uuid",
+                session_id: "redesign-stream-event-uuid-session",
+              },
+            };
+          }
+          if (step === 2) {
+            step += 1;
+            return {
+              done: false,
+              value: {
+                type: "stream_event",
+                uuid: "stream-event-uuid-1",
+                event: {
+                  type: "message_start",
+                  message: { role: "assistant", model: "opus" },
+                },
+              },
+            };
+          }
+          if (step === 3) {
+            step += 1;
+            return {
+              done: false,
+              value: {
+                type: "stream_event",
+                uuid: "stream-event-uuid-2",
+                event: {
+                  type: "content_block_delta",
+                  delta: { type: "text_delta", text: "HELLO " },
+                },
+              },
+            };
+          }
+          if (step === 4) {
+            step += 1;
+            return {
+              done: false,
+              value: {
+                type: "stream_event",
+                uuid: "stream-event-uuid-3",
+                event: {
+                  type: "content_block_delta",
+                  delta: { type: "text_delta", text: "WORLD" },
+                },
+              },
+            };
+          }
+          if (step === 5) {
+            step += 1;
+            return {
+              done: false,
+              value: {
+                type: "stream_event",
+                uuid: "stream-event-uuid-4",
+                event: {
+                  type: "message_stop",
+                },
+              },
+            };
+          }
+          if (step === 6) {
+            step += 1;
+            return {
+              done: false,
+              value: {
+                type: "result",
+                subtype: "success",
+                usage: buildUsage(),
+                total_cost_usd: 0,
+              },
+            };
+          }
+          return { done: true, value: undefined };
+        })
+      );
+    });
+
+    const session = await createSession();
+    const events = await collectUntilTerminal(session.stream("uuid fallback prompt"));
+    const assistantText = events
+      .filter(
+        (event): event is Extract<AgentStreamEvent, { type: "timeline" }> =>
+          event.type === "timeline" && event.item.type === "assistant_message"
+      )
+      .map((event) => event.item.text)
+      .join("");
+
+    expect(assistantText).toContain("HELLO WORLD");
+
+    const assembler = session as unknown as {
+      timelineAssembler: { messages: Map<string, unknown> };
+    };
+    expect(assembler.timelineAssembler.messages.size).toBe(1);
+
+    await session.close();
+  });
+
+  test("surfaces autonomous running transitions through manager-visible events during foreground overlap", async () => {
+    sdkMocks.query.mockImplementation(({ prompt }: { prompt: AsyncIterable<unknown> }) => {
+      const readPromptUuid = createPromptUuidReader(prompt);
+      let step = 0;
+      return createBaseQueryMock(
+        vi.fn(async () => {
+          if (step === 0) {
+            step += 1;
+            return {
+              done: false,
+              value: {
+                type: "system",
+                subtype: "init",
+                session_id: "redesign-manager-overlap-session",
+                permissionMode: "default",
+                model: "opus",
+              },
+            };
+          }
+          if (step === 1) {
+            step += 1;
+            return {
+              done: false,
+              value: {
+                type: "user",
+                message: { role: "user", content: "foreground prompt replay" },
+                parent_tool_use_id: null,
+                uuid: (await readPromptUuid()) ?? "missing-prompt-uuid",
+                session_id: "redesign-manager-overlap-session",
+              },
+            };
+          }
+          if (step === 2) {
+            step += 1;
+            return {
+              done: false,
+              value: {
+                type: "assistant",
+                message: { content: "FOREGROUND_DONE" },
+              },
+            };
+          }
+          if (step === 3) {
+            step += 1;
+            return {
+              done: false,
+              value: {
+                type: "result",
+                subtype: "success",
+                usage: buildUsage(),
+                total_cost_usd: 0,
+              },
+            };
+          }
+          if (step === 4) {
+            step += 1;
+            return {
+              done: false,
+              value: {
+                type: "user",
+                message: {
+                  role: "user",
+                  content:
+                    "<task-notification>\n<task-id>bg-1</task-id>\n<status>completed</status>\n</task-notification>",
+                },
+                parent_tool_use_id: null,
+                uuid: "task-note-overlap-1",
+                session_id: "redesign-manager-overlap-session",
+              },
+            };
+          }
+          if (step === 5) {
+            step += 1;
+            return {
+              done: false,
+              value: {
+                type: "assistant",
+                message: { content: "AUTONOMOUS_OVERLAP_DONE" },
+              },
+            };
+          }
+          if (step === 6) {
+            step += 1;
+            return {
+              done: false,
+              value: {
+                type: "result",
+                subtype: "success",
+                usage: buildUsage(),
+                total_cost_usd: 0,
+              },
+            };
+          }
+          return { done: true, value: undefined };
+        })
+      );
+    });
+
+    const logger = createTestLogger();
+    const manager = new AgentManager({
+      clients: {
+        claude: new ClaudeAgentClient({ logger }),
+      },
+      logger,
+    });
+
+    const agent = await manager.createAgent({
+      provider: "claude",
+      cwd: process.cwd(),
+    });
+
+    const runningStateEvents: string[] = [];
+    const turnStartedEvents: AgentStreamEvent[] = [];
+    const unsubscribe = manager.subscribe(
+      (event) => {
+        if (event.type === "agent_state" && event.agent.id === agent.id) {
+          if (event.agent.lifecycle === "running") {
+            runningStateEvents.push(event.agent.lifecycle);
+          }
+          return;
+        }
+        if (
+          event.type === "agent_stream" &&
+          event.agentId === agent.id &&
+          event.event.type === "turn_started"
+        ) {
+          turnStartedEvents.push(event.event);
+        }
+      },
+      { agentId: agent.id, replayState: true }
+    );
+
+    const foregroundEvents = await collectUntilTerminal(
+      manager.streamAgent(agent.id, "foreground prompt")
+    );
+    expect(
+      foregroundEvents.some((event) => event.type === "turn_completed")
+    ).toBe(true);
+
+    await waitForCondition(() => turnStartedEvents.length >= 2, 5_000);
+    await waitForCondition(() => runningStateEvents.length >= 2, 5_000);
+
+    const timeline = manager.getTimeline(agent.id);
+    expect(
+      timeline.some(
+        (item) =>
+          item.type === "assistant_message" &&
+          item.text.includes("FOREGROUND_DONE")
+      )
+    ).toBe(true);
+    expect(
+      timeline.some(
+        (item) =>
+          item.type === "assistant_message" &&
+          item.text.includes("AUTONOMOUS_OVERLAP_DONE")
+      )
+    ).toBe(true);
+
+    unsubscribe();
+    await manager.closeAgent(agent.id);
+  });
+});
diff --git a/packages/server/src/server/agent/providers/claude-agent.ts b/packages/server/src/server/agent/providers/claude-agent.ts
index c5e192814..cef80961e 100644
--- a/packages/server/src/server/agent/providers/claude-agent.ts
+++ b/packages/server/src/server/agent/providers/claude-agent.ts
@@ -66,15 +66,55 @@ import { getOrchestratorModeInstructions } from "../orchestrator-instructions.js
 
 const fsPromises = promises;
 
-/**
- * Per-turn context to track streaming state.
- * This prevents race conditions when multiple stream() calls overlap
- * (e.g., when an interrupt sends a new message before the previous one completes).
- */
-interface TurnContext {
-  streamedAssistantTextThisTurn: boolean;
-  streamedReasoningThisTurn: boolean;
-}
+type TurnState = "idle" | "foreground" | "autonomous";
+
+type RunOwner = "foreground" | "autonomous";
+
+type RunLifecycleState =
+  | "queued"
+  | "awaiting_response"
+  | "streaming"
+  | "finalizing"
+  | "completed"
+  | "interrupted"
+  | "error";
+
+type SessionLifecycleState = "running" | "permission" | "error" | "idle";
+
+type RoutingReason =
+  | "foreground"
+  | "task_id"
+  | "parent_message_id"
+  | "message_id"
+  | "fallback"
+  | "metadata";
+
+type EventIdentifiers = {
+  taskId: string | null;
+  parentMessageId: string | null;
+  messageId: string | null;
+};
+
+type RunRoute = {
+  run: RunRecord | null;
+  reason: RoutingReason;
+};
+
+type RunRecord = {
+  id: string;
+  owner: RunOwner;
+  queue: Pushable<AgentStreamEvent> | null;
+  state: RunLifecycleState;
+  promptReplaySeen: boolean;
+  taskIds: Set<string>;
+  parentMessageIds: Set<string>;
+  messageIds: Set<string>;
+};
+
+type ForegroundTurnState = {
+  runId: string;
+  queue: Pushable<AgentStreamEvent>;
+};
 
 function normalizeClaudeModelLabel(model: ModelInfo): string {
   const fallback = model.displayName?.trim() || model.value;
@@ -523,6 +563,555 @@ function resolvePermissionKind(
   return "tool";
 }
 
+const ACTIVE_RUN_STATES = new Set<RunLifecycleState>([
+  "queued",
+  "awaiting_response",
+  "streaming",
+  "finalizing",
+]);
+
+class RunTracker {
+  private readonly runs = new Map<string, RunRecord>();
+  private readonly runByTaskId = new Map<string, string>();
+  private readonly runByParentMessageId = new Map<string, string>();
+  private readonly runByMessageId = new Map<string, string>();
+
+  createRun(input: {
+    id: string;
+    owner: RunOwner;
+    queue: Pushable<AgentStreamEvent> | null;
+    promptReplaySeen?: boolean;
+  }): RunRecord {
+    const run: RunRecord = {
+      id: input.id,
+      owner: input.owner,
+      queue: input.queue,
+      state: "queued",
+      promptReplaySeen: input.promptReplaySeen ?? true,
+      taskIds: new Set<string>(),
+      parentMessageIds: new Set<string>(),
+      messageIds: new Set<string>(),
+    };
+    this.runs.set(run.id, run);
+    return run;
+  }
+
+  getRun(runId: string): RunRecord | null {
+    return this.runs.get(runId) ?? null;
+  }
+
+  getForegroundRun(): RunRecord | null {
+    for (const run of this.runs.values()) {
+      if (run.owner === "foreground" && this.isActive(run.state)) {
+        return run;
+      }
+    }
+    return null;
+  }
+
+  listActiveRuns(owner?: RunOwner): RunRecord[] {
+    const runs: RunRecord[] = [];
+    for (const run of this.runs.values()) {
+      if (!this.isActive(run.state)) {
+        continue;
+      }
+      if (owner && run.owner !== owner) {
+        continue;
+      }
+      runs.push(run);
+    }
+    return runs;
+  }
+
+  hasActiveRuns(owner?: RunOwner): boolean {
+    for (const run of this.runs.values()) {
+      if (!this.isActive(run.state)) {
+        continue;
+      }
+      if (owner && run.owner !== owner) {
+        continue;
+      }
+      return true;
+    }
+    return false;
+  }
+
+  resolveByIdentifiers(identifiers: EventIdentifiers): RunRoute {
+    if (identifiers.taskId) {
+      const run = this.resolveMappedRun(this.runByTaskId, identifiers.taskId);
+      if (run) {
+        return { run, reason: "task_id" };
+      }
+    }
+    if (identifiers.parentMessageId) {
+      const run = this.resolveMappedRun(
+        this.runByParentMessageId,
+        identifiers.parentMessageId
+      );
+      if (run) {
+        return { run, reason: "parent_message_id" };
+      }
+    }
+    if (identifiers.messageId) {
+      const run = this.resolveMappedRun(
+        this.runByMessageId,
+        identifiers.messageId
+      );
+      if (run) {
+        return { run, reason: "message_id" };
+      }
+    }
+    return { run: null, reason: "metadata" };
+  }
+
+  bindIdentifiers(run: RunRecord, identifiers: EventIdentifiers): void {
+    if (identifiers.taskId) {
+      run.taskIds.add(identifiers.taskId);
+      this.runByTaskId.set(identifiers.taskId, run.id);
+    }
+    if (identifiers.parentMessageId) {
+      run.parentMessageIds.add(identifiers.parentMessageId);
+      this.runByParentMessageId.set(identifiers.parentMessageId, run.id);
+    }
+    if (identifiers.messageId) {
+      run.messageIds.add(identifiers.messageId);
+      this.runByMessageId.set(identifiers.messageId, run.id);
+    }
+  }
+
+  transition(run: RunRecord, nextState: RunLifecycleState): void {
+    run.state = nextState;
+  }
+
+  complete(run: RunRecord, terminalState: "completed" | "interrupted" | "error"): void {
+    run.state = terminalState;
+    this.clearRunIndex(run);
+  }
+
+  deriveLifecycle(pendingPermissionCount: number): SessionLifecycleState {
+    for (const run of this.runs.values()) {
+      if (this.isActive(run.state)) {
+        return "running";
+      }
+    }
+    if (pendingPermissionCount > 0) {
+      return "permission";
+    }
+    for (const run of this.runs.values()) {
+      if (run.state === "error") {
+        return "error";
+      }
+    }
+    return "idle";
+  }
+
+  private resolveMappedRun(
+    mapping: Map<string, string>,
+    identifier: string
+  ): RunRecord | null {
+    const runId = mapping.get(identifier);
+    if (!runId) {
+      return null;
+    }
+    const run = this.runs.get(runId);
+    if (!run || !this.isActive(run.state)) {
+      mapping.delete(identifier);
+      return null;
+    }
+    return run;
+  }
+
+  private clearRunIndex(run: RunRecord): void {
+    for (const taskId of run.taskIds) {
+      this.runByTaskId.delete(taskId);
+    }
+    for (const parentMessageId of run.parentMessageIds) {
+      this.runByParentMessageId.delete(parentMessageId);
+    }
+    for (const messageId of run.messageIds) {
+      this.runByMessageId.delete(messageId);
+    }
+    run.taskIds.clear();
+    run.parentMessageIds.clear();
+    run.messageIds.clear();
+  }
+
+  private isActive(state: RunLifecycleState): boolean {
+    return ACTIVE_RUN_STATES.has(state);
+  }
+}
+
+type TimelineFragment = {
+  kind: "assistant" | "reasoning";
+  text: string;
+};
+
+type TimelineMessageState = {
+  id: string;
+  assistantText: string;
+  reasoningText: string;
+  emittedAssistantLength: number;
+  emittedReasoningLength: number;
+  stopped: boolean;
+};
+
+class TimelineAssembler {
+  private readonly messages = new Map<string, TimelineMessageState>();
+  private readonly activeMessageByRun = new Map<string, string>();
+  private syntheticMessageCounter = 0;
+
+  consume(input: {
+    message: SDKMessage;
+    runId: string | null;
+    messageIdHint?: string | null;
+  }): AgentTimelineItem[] {
+    if (input.message.type === "assistant") {
+      return this.consumeAssistantMessage(
+        input.message,
+        input.runId,
+        input.messageIdHint ?? null
+      );
+    }
+    if (input.message.type === "stream_event") {
+      return this.consumeStreamEvent(
+        input.message,
+        input.runId,
+        input.messageIdHint ?? null
+      );
+    }
+    return [];
+  }
+
+  private consumeAssistantMessage(
+    message: SDKMessage & { type: "assistant" },
+    runId: string | null,
+    messageIdHint: string | null
+  ): AgentTimelineItem[] {
+    const messageId =
+      this.readMessageIdFromAssistantMessage(message) ??
+      messageIdHint ??
+      this.resolveMessageId({ runId, createIfMissing: true, messageId: null });
+    if (!messageId) {
+      return [];
+    }
+    const state = this.ensureMessageState(messageId, runId);
+    const fragments = this.extractFragments(message.message?.content);
+    return this.applyAbsoluteFragments(state, fragments);
+  }
+
+  private consumeStreamEvent(
+    message: SDKMessage & { type: "stream_event" },
+    runId: string | null,
+    messageIdHint: string | null
+  ): AgentTimelineItem[] {
+    const event = message.event as Record<string, unknown>;
+    const eventType = readTrimmedString(event.type);
+    const streamEventMessageId =
+      this.readMessageIdFromStreamEvent(event) ?? messageIdHint;
+
+    if (eventType === "message_start") {
+      const messageId = this.resolveMessageId({
+        runId,
+        createIfMissing: true,
+        messageId: streamEventMessageId,
+      });
+      if (!messageId) {
+        return [];
+      }
+      this.ensureMessageState(messageId, runId);
+      return [];
+    }
+
+    if (eventType === "message_stop") {
+      const messageId = this.resolveMessageId({
+        runId,
+        createIfMissing: false,
+        messageId: streamEventMessageId,
+      });
+      if (!messageId) {
+        return [];
+      }
+      return this.finalizeMessage(messageId, runId);
+    }
+
+    if (eventType === "content_block_start") {
+      return this.consumeDeltaContent(
+        event.content_block,
+        runId,
+        streamEventMessageId
+      );
+    }
+
+    if (eventType === "content_block_delta") {
+      return this.consumeDeltaContent(event.delta, runId, streamEventMessageId);
+    }
+
+    return [];
+  }
+
+  private consumeDeltaContent(
+    content: unknown,
+    runId: string | null,
+    messageIdHint: string | null
+  ): AgentTimelineItem[] {
+    const fragments = this.extractFragments(content);
+    if (fragments.length === 0) {
+      return [];
+    }
+    const messageId = this.resolveMessageId({
+      runId,
+      createIfMissing: true,
+      messageId: messageIdHint,
+    });
+    if (!messageId) {
+      return [];
+    }
+    const state = this.ensureMessageState(messageId, runId);
+    return this.appendFragments(state, fragments);
+  }
+
+  private appendFragments(
+    state: TimelineMessageState,
+    fragments: TimelineFragment[]
+  ): AgentTimelineItem[] {
+    for (const fragment of fragments) {
+      if (fragment.kind === "assistant") {
+        state.assistantText += fragment.text;
+      } else {
+        state.reasoningText += fragment.text;
+      }
+    }
+    return this.emitNewContent(state);
+  }
+
+  private applyAbsoluteFragments(
+    state: TimelineMessageState,
+    fragments: TimelineFragment[]
+  ): AgentTimelineItem[] {
+    const assistantText = fragments
+      .filter((fragment) => fragment.kind === "assistant")
+      .map((fragment) => fragment.text)
+      .join("");
+    const reasoningText = fragments
+      .filter((fragment) => fragment.kind === "reasoning")
+      .map((fragment) => fragment.text)
+      .join("");
+
+    if (assistantText.length > 0) {
+      if (!assistantText.startsWith(state.assistantText)) {
+        state.emittedAssistantLength = 0;
+      }
+      state.assistantText = assistantText;
+    }
+    if (reasoningText.length > 0) {
+      if (!reasoningText.startsWith(state.reasoningText)) {
+        state.emittedReasoningLength = 0;
+      }
+      state.reasoningText = reasoningText;
+    }
+    return this.emitNewContent(state);
+  }
+
+  private finalizeMessage(
+    messageId: string,
+    runId: string | null
+  ): AgentTimelineItem[] {
+    const state = this.messages.get(messageId);
+    if (!state) {
+      return [];
+    }
+    state.stopped = true;
+    const items = this.emitNewContent(state);
+    if (runId && this.activeMessageByRun.get(runId) === messageId) {
+      this.activeMessageByRun.delete(runId);
+    }
+    return items;
+  }
+
+  private emitNewContent(state: TimelineMessageState): AgentTimelineItem[] {
+    const items: AgentTimelineItem[] = [];
+    const nextAssistantText = state.assistantText.slice(state.emittedAssistantLength);
+    if (
+      nextAssistantText.length > 0 &&
+      nextAssistantText !== "[Request interrupted by user for tool use]"
+    ) {
+      state.emittedAssistantLength = state.assistantText.length;
+      items.push({ type: "assistant_message", text: nextAssistantText });
+    }
+
+    const nextReasoningText = state.reasoningText.slice(state.emittedReasoningLength);
+    if (nextReasoningText.length > 0) {
+      state.emittedReasoningLength = state.reasoningText.length;
+      items.push({ type: "reasoning", text: nextReasoningText });
+    }
+    return items;
+  }
+
+  private ensureMessageState(
+    messageId: string,
+    runId: string | null
+  ): TimelineMessageState {
+    const existing = this.messages.get(messageId);
+    if (existing) {
+      existing.stopped = false;
+      if (runId) {
+        this.activeMessageByRun.set(runId, messageId);
+      }
+      return existing;
+    }
+    const created: TimelineMessageState = {
+      id: messageId,
+      assistantText: "",
+      reasoningText: "",
+      emittedAssistantLength: 0,
+      emittedReasoningLength: 0,
+      stopped: false,
+    };
+    this.messages.set(messageId, created);
+    if (runId) {
+      this.activeMessageByRun.set(runId, messageId);
+    }
+    return created;
+  }
+
+  private resolveMessageId(input: {
+    runId: string | null;
+    createIfMissing: boolean;
+    messageId: string | null;
+  }): string | null {
+    if (input.messageId) {
+      return input.messageId;
+    }
+    if (input.runId) {
+      const active = this.activeMessageByRun.get(input.runId);
+      if (active) {
+        return active;
+      }
+    }
+    if (!input.createIfMissing) {
+      return null;
+    }
+    const synthetic = `synthetic-message-${++this.syntheticMessageCounter}`;
+    if (input.runId) {
+      this.activeMessageByRun.set(input.runId, synthetic);
+    }
+    return synthetic;
+  }
+
+  private extractFragments(content: unknown): TimelineFragment[] {
+    if (typeof content === "string") {
+      if (content.length === 0) {
+        return [];
+      }
+      return [{ kind: "assistant", text: content }];
+    }
+    const blocks = Array.isArray(content) ? content : [content];
+    const fragments: TimelineFragment[] = [];
+    for (const rawBlock of blocks) {
+      if (!isClaudeContentChunk(rawBlock)) {
+        continue;
+      }
+      if (
+        (rawBlock.type === "text" || rawBlock.type === "text_delta") &&
+        typeof rawBlock.text === "string" &&
+        rawBlock.text.length > 0
+      ) {
+        fragments.push({ kind: "assistant", text: rawBlock.text });
+      }
+      if (
+        (rawBlock.type === "thinking" || rawBlock.type === "thinking_delta") &&
+        typeof rawBlock.thinking === "string" &&
+        rawBlock.thinking.length > 0
+      ) {
+        fragments.push({ kind: "reasoning", text: rawBlock.thinking });
+      }
+    }
+    return fragments;
+  }
+
+  private readMessageIdFromAssistantMessage(
+    message: SDKMessage & { type: "assistant" }
+  ): string | null {
+    const candidate = message as unknown as {
+      message_id?: unknown;
+      message?: { id?: unknown } | null;
+    };
+    return readTrimmedString(candidate.message_id) ??
+      readTrimmedString(candidate.message?.id) ??
+      null;
+  }
+
+  private readMessageIdFromStreamEvent(
+    event: Record<string, unknown>
+  ): string | null {
+    const message = event.message as { id?: unknown } | undefined;
+    return (
+      readTrimmedString(event.message_id) ??
+      readTrimmedString(message?.id) ??
+      null
+    );
+  }
+}
+
+function isMetadataOnlySdkMessage(message: SDKMessage): boolean {
+  if (message.type === "system") {
+    return true;
+  }
+  if (message.type !== "user") {
+    return false;
+  }
+  return isTaskNotificationUserContent(message.message?.content);
+}
+
+function readEventIdentifiers(message: SDKMessage): EventIdentifiers {
+  const root = message as unknown as Record<string, unknown>;
+  const messageType = readTrimmedString(root.type);
+  const streamEvent = root.event as Record<string, unknown> | undefined;
+  const streamEventMessage = streamEvent?.message as
+    | Record<string, unknown>
+    | undefined;
+  const messageContainer = root.message as Record<string, unknown> | undefined;
+
+  return {
+    taskId:
+      readTrimmedString(root.task_id) ??
+      readTrimmedString(streamEvent?.task_id) ??
+      readTrimmedString(messageContainer?.task_id) ??
+      null,
+    parentMessageId:
+      readTrimmedString(root.parent_message_id) ??
+      readTrimmedString(streamEvent?.parent_message_id) ??
+      null,
+    messageId:
+      readTrimmedString(root.message_id) ??
+      readTrimmedString(streamEvent?.message_id) ??
+      readTrimmedString(streamEventMessage?.id) ??
+      readTrimmedString(messageContainer?.id) ??
+      (messageType === "user" ? readTrimmedString(root.uuid) : null) ??
+      null,
+  };
+}
+
+function isTaskNotificationUserContent(content: unknown): boolean {
+  if (typeof content === "string") {
+    return content.includes("<task-notification>");
+  }
+  if (!Array.isArray(content)) {
+    return false;
+  }
+  for (const block of content) {
+    if (
+      block &&
+      typeof block === "object" &&
+      typeof (block as { text?: unknown }).text === "string" &&
+      (block as { text: string }).text.includes("<task-notification>")
+    ) {
+      return true;
+    }
+  }
+  return false;
+}
+
 export class ClaudeAgentClient implements AgentClient {
   readonly provider: "claude" = "claude";
   readonly capabilities = CLAUDE_CAPABILITIES;
@@ -698,29 +1287,27 @@ class ClaudeAgentSession implements AgentSession {
   private toolUseIndexToId = new Map<number, string>();
   private toolUseInputBuffers = new Map<string, string>();
   private pendingPermissions = new Map<string, PendingPermission>();
-  private eventQueue: Pushable<AgentStreamEvent> | null = null;
+  private activeForegroundTurn: ForegroundTurnState | null = null;
+  private liveEventQueue = new Pushable<AgentStreamEvent>();
+  private readonly runTracker = new RunTracker();
+  private readonly timelineAssembler = new TimelineAssembler();
   private persistedHistory: AgentTimelineItem[] = [];
   private historyPending = false;
-  private turnCancelRequested = false;
-  // NOTE: streamedAssistantTextThisTurn and streamedReasoningThisTurn were removed
-  // These flags are now tracked per-turn via TurnContext to prevent race conditions
-  // when multiple stream() calls overlap (e.g., interrupt + new message)
+  private turnState: TurnState = "idle";
+  private nextRunOrdinal = 1;
   private cancelCurrentTurn: (() => void) | null = null;
-  // Track the pending interrupt promise so we can await it in processPrompt
-  // This ensures the interrupt's response is consumed before we call query.next()
   private pendingInterruptPromise: Promise<void> | null = null;
-  // Track the current turn ID and active turn promise to serialize concurrent stream() calls
-  // and prevent race conditions where two processPrompt() loops run against the same query
-  private currentTurnId = 0;
   private activeTurnPromise: Promise<void> | null = null;
   private cachedRuntimeInfo: AgentRuntimeInfo | null = null;
   private lastOptionsModel: string | null = null;
   private selectableModelIds: Set<string> | null = null;
   private activeSidechains = new Map<string, SubAgentActivityState>();
   private compacting = false;
+  private queryPumpPromise: Promise<void> | null = null;
   private queryRestartNeeded = false;
   private userMessageIds: string[] = [];
-  private sentUserMessageIds = new Set<string>();
+  private readonly localUserMessageIds = new Set<string>();
+  private suppressLocalReplayActivity = false;
   private closed = false;
 
   constructor(
@@ -824,18 +1411,10 @@ class ClaudeAgentSession implements AgentSession {
     options?: AgentRunOptions
   ): AsyncGenerator<AgentStreamEvent> {
     void options;
-    // Increment turn ID to invalidate any in-flight processPrompt() loops from previous turns.
-    // This prevents race conditions where an interrupted turn's events get mixed with the new turn.
-    const turnId = ++this.currentTurnId;
-
-    // Cancel the previous turn if one exists. The caller of interrupt() is responsible
-    // for awaiting completion - the new turn just signals cancellation and proceeds.
     if (this.cancelCurrentTurn) {
       this.cancelCurrentTurn();
     }
-
-    // Reset cancel flag at the start of each turn to prevent stale state from previous turns
-    this.turnCancelRequested = false;
+    this.suppressLocalReplayActivity = false;
 
     const slashCommand = this.resolveSlashCommandInvocation(prompt);
     if (slashCommand?.commandName === REWIND_COMMAND_NAME) {
@@ -843,38 +1422,71 @@ class ClaudeAgentSession implements AgentSession {
       return;
     }
 
+    await this.awaitPendingInterruptPromise();
+    if (
+      this.turnState === "autonomous" &&
+      this.runTracker.hasActiveRuns("autonomous")
+    ) {
+      await this.transitionAutonomousToForeground();
+    }
+
     const sdkMessage = this.toSdkUserMessage(prompt);
     const queue = new Pushable<AgentStreamEvent>();
-    this.eventQueue = queue;
+    const run = this.createRun("foreground", queue);
+    this.runTracker.bindIdentifiers(run, {
+      taskId: null,
+      parentMessageId: null,
+      messageId: typeof sdkMessage.uuid === "string" ? sdkMessage.uuid : null,
+    });
+    const foregroundTurn: ForegroundTurnState = {
+      runId: run.id,
+      queue,
+    };
+    this.activeForegroundTurn = foregroundTurn;
+    this.transitionTurnState("foreground", "foreground stream started");
+
     let finishedNaturally = false;
     let cancelIssued = false;
+    let queueDrainedWithoutTerminal = false;
+    const turnPromise = Promise.resolve();
+    this.activeTurnPromise = turnPromise;
+
     const requestCancel = () => {
       if (cancelIssued) {
         return;
       }
       cancelIssued = true;
-      this.turnCancelRequested = true;
-      // Store the interrupt promise so processPrompt can await it before calling query.next()
-      this.pendingInterruptPromise = this.interruptActiveTurn().catch((error) => {
-        this.logger.warn({ err: error }, "Failed to interrupt during cancel");
-      });
-      this.flushPendingToolCalls();
-      // Push turn_canceled before ending the queue so consumers get proper lifecycle signals
-      queue.push({
+      if (this.activeForegroundTurn?.runId === run.id) {
+        this.activeForegroundTurn = null;
+      }
+      if (this.cancelCurrentTurn === requestCancel) {
+        this.cancelCurrentTurn = null;
+      }
+      this.cancelRun(run, {
         type: "turn_canceled",
         provider: "claude",
         reason: "Interrupted",
       });
-      queue.end();
+      this.pendingInterruptPromise = this.interruptActiveTurn().catch((error) => {
+        this.logger.warn({ err: error }, "Failed to interrupt during cancel");
+      });
     };
     this.cancelCurrentTurn = requestCancel;
 
-    // Start forwarding events and track the promise so future turns can wait for completion
-    const forwardPromise = this.forwardPromptEvents(sdkMessage, queue, turnId);
-    this.activeTurnPromise = forwardPromise;
-    forwardPromise.catch((error) => {
-      this.logger.error({ err: error }, "Unexpected error in forwardPromptEvents");
-    });
+    try {
+      await this.ensureQuery();
+      if (!this.input) {
+        throw new Error("Claude session input stream not initialized");
+      }
+      this.startQueryPump();
+      this.input.push(sdkMessage);
+    } catch (error) {
+      this.failRun(
+        run,
+        error instanceof Error ? error.message : "Claude stream failed"
+      );
+      finishedNaturally = true;
+    }
 
     try {
       for await (const event of queue) {
@@ -888,25 +1500,44 @@ class ClaudeAgentSession implements AgentSession {
           break;
         }
       }
-    } finally {
       if (!finishedNaturally && !cancelIssued) {
+        queueDrainedWithoutTerminal = true;
+      }
+    } finally {
+      if (!finishedNaturally && !cancelIssued && !queueDrainedWithoutTerminal) {
         requestCancel();
       }
-      if (this.eventQueue === queue) {
-        this.eventQueue = null;
+      if (this.activeForegroundTurn === foregroundTurn) {
+        this.activeForegroundTurn = null;
       }
       if (this.cancelCurrentTurn === requestCancel) {
         this.cancelCurrentTurn = null;
       }
-      // Clear the active turn promise if it's still ours
-      if (this.activeTurnPromise === forwardPromise) {
+      if (this.activeTurnPromise === turnPromise) {
         this.activeTurnPromise = null;
       }
     }
   }
 
   async interrupt(): Promise<void> {
-    this.cancelCurrentTurn?.();
+    if (this.cancelCurrentTurn) {
+      this.cancelCurrentTurn();
+      return;
+    }
+
+    const autonomousRuns = this.runTracker.listActiveRuns("autonomous");
+    if (autonomousRuns.length > 0) {
+      this.flushPendingToolCalls();
+      for (const run of autonomousRuns) {
+        this.emitRunEvent(run, {
+          type: "turn_canceled",
+          provider: "claude",
+          reason: "Interrupted",
+        });
+      }
+    }
+
+    await this.interruptActiveTurn();
   }
 
   async *streamHistory(): AsyncGenerator<AgentStreamEvent> {
@@ -922,84 +1553,12 @@ class ClaudeAgentSession implements AgentSession {
   }
 
   async *streamLiveEvents(): AsyncGenerator<AgentStreamEvent> {
-    let currentHistoryPath: string | null = null;
-    let lineCursor = 0;
-    let suppressLocalTurn = false;
-    let autonomousTurnActive = false;
+    if (this.claudeSessionId) {
+      this.startQueryPump();
+    }
 
-    while (!this.closed) {
-      const sessionId = this.claudeSessionId;
-      const historyPath = sessionId ? this.resolveHistoryPath(sessionId) : null;
-      if (!historyPath) {
-        await this.waitForLiveHistoryPoll();
-        continue;
-      }
-
-      let lines: string[];
-      try {
-        const content = fs.readFileSync(historyPath, "utf8");
-        lines = content.split(/\r?\n/).filter((line) => line.trim().length > 0);
-      } catch {
-        await this.waitForLiveHistoryPoll();
-        continue;
-      }
-
-      if (currentHistoryPath !== historyPath) {
-        currentHistoryPath = historyPath;
-        lineCursor = lines.length;
-        suppressLocalTurn = false;
-        autonomousTurnActive = false;
-        await this.waitForLiveHistoryPoll();
-        continue;
-      }
-
-      if (lineCursor > lines.length) {
-        lineCursor = 0;
-      }
-      if (lineCursor === lines.length) {
-        await this.waitForLiveHistoryPoll();
-        continue;
-      }
-
-      const nextLines = lines.slice(lineCursor);
-      lineCursor = lines.length;
-      for (const rawLine of nextLines) {
-        let entry: any;
-        try {
-          entry = JSON.parse(rawLine);
-        } catch {
-          continue;
-        }
-        if (entry?.isSidechain) {
-          continue;
-        }
-
-        if (
-          entry?.type === "user" &&
-          typeof entry.uuid === "string" &&
-          this.sentUserMessageIds.has(entry.uuid)
-        ) {
-          this.sentUserMessageIds.delete(entry.uuid);
-          suppressLocalTurn = true;
-          continue;
-        }
-
-        if (suppressLocalTurn) {
-          if (entry?.type === "result") {
-            suppressLocalTurn = false;
-          }
-          continue;
-        }
-
-        const converted = this.convertLiveHistoryEntryToEvents({
-          entry,
-          autonomousTurnActive,
-        });
-        autonomousTurnActive = converted.autonomousTurnActive;
-        for (const event of converted.events) {
-          yield event;
-        }
-      }
+    for await (const event of this.liveEventQueue) {
+      yield event;
     }
   }
 
@@ -1136,9 +1695,17 @@ class ClaudeAgentSession implements AgentSession {
   async close(): Promise<void> {
     this.closed = true;
     this.rejectAllPendingPermissions(new Error("Claude session closed"));
+    this.cancelCurrentTurn?.();
+    this.activeForegroundTurn?.queue.end();
+    this.activeForegroundTurn = null;
+    this.cancelCurrentTurn = null;
+    this.turnState = "idle";
+    this.suppressLocalReplayActivity = false;
+    this.liveEventQueue.end();
+    this.activeTurnPromise = null;
     this.input?.end();
-    await this.query?.interrupt?.();
-    await this.query?.return?.();
+    await this.awaitWithTimeout(this.query?.interrupt?.(), "close query interrupt");
+    await this.awaitWithTimeout(this.query?.return?.(), "close query return");
     this.query = null;
     this.input = null;
   }
@@ -1458,6 +2025,25 @@ class ClaudeAgentSession implements AgentSession {
     return this.query;
   }
 
+  private async awaitWithTimeout(
+    promise: Promise<unknown> | undefined,
+    label: string
+  ): Promise<void> {
+    if (!promise) {
+      return;
+    }
+    try {
+      await Promise.race([
+        promise,
+        new Promise<never>((_, reject) => {
+          setTimeout(() => reject(new Error("timeout")), 3_000);
+        }),
+      ]);
+    } catch (error) {
+      this.logger.warn({ err: error, label }, "Claude query operation did not settle cleanly");
+    }
+  }
+
   private buildOptions(): ClaudeOptions {
     const configuredThinkingOptionId = this.config.thinkingOptionId;
     const thinkingOptionId =
@@ -1585,7 +2171,7 @@ class ClaudeAgentSession implements AgentSession {
 
     const messageId = randomUUID();
     this.rememberUserMessageId(messageId);
-    this.sentUserMessageIds.add(messageId);
+    this.localUserMessageIds.add(messageId);
 
     return {
       type: "user",
@@ -1599,140 +2185,424 @@ class ClaudeAgentSession implements AgentSession {
     };
   }
 
-  private async *processPrompt(
-    sdkMessage: SDKUserMessage,
-    turnId: number
-  ): AsyncGenerator<SDKMessage, void, undefined> {
-    // If there's a pending interrupt, await it BEFORE calling ensureQuery().
-    // interruptActiveTurn() clears this.query after interrupt() returns,
-    // so we must wait for it to complete before we try to get the query.
-    if (this.pendingInterruptPromise) {
-      await this.pendingInterruptPromise;
-      this.pendingInterruptPromise = null;
+  private async awaitPendingInterruptPromise(): Promise<void> {
+    if (!this.pendingInterruptPromise) {
+      return;
     }
+    await this.pendingInterruptPromise;
+    this.pendingInterruptPromise = null;
+  }
 
-    // Check if we were superseded while waiting for the interrupt
-    if (this.currentTurnId !== turnId) {
+  private createRun(
+    owner: RunOwner,
+    queue: Pushable<AgentStreamEvent> | null
+  ): RunRecord {
+    const runId = `${owner}-run-${this.nextRunOrdinal++}`;
+    const run = this.runTracker.createRun({
+      id: runId,
+      owner,
+      queue,
+      promptReplaySeen: owner === "autonomous",
+    });
+    this.logger.debug({ runId, owner, state: run.state }, "Created Claude run");
+    return run;
+  }
+
+  private transitionTurnState(next: TurnState, reason: string): void {
+    if (this.turnState === next) {
+      return;
+    }
+    this.logger.debug(
+      { from: this.turnState, to: next, reason },
+      "Claude turn state transition"
+    );
+    this.turnState = next;
+  }
+
+  private transitionTurnStateFromActiveRuns(reason: string): void {
+    if (this.runTracker.hasActiveRuns("foreground")) {
+      this.transitionTurnState("foreground", reason);
+      return;
+    }
+    if (this.runTracker.hasActiveRuns("autonomous")) {
+      this.transitionTurnState("autonomous", reason);
+      return;
+    }
+    this.transitionTurnState("idle", reason);
+  }
+
+  private failRun(run: RunRecord, errorMessage: string): void {
+    this.emitRunEvent(run, {
+      type: "turn_failed",
+      provider: "claude",
+      error: errorMessage,
+    });
+  }
+
+  private cancelRun(
+    run: RunRecord,
+    event: Extract<AgentStreamEvent, { type: "turn_canceled" }>
+  ): void {
+    this.flushPendingToolCalls();
+    this.emitRunEvent(run, event);
+  }
+
+  private emitRunEvent(run: RunRecord, event: AgentStreamEvent): void {
+    this.logger.debug(
+      { runId: run.id, owner: run.owner, eventType: event.type },
+      "Claude run event dispatch"
+    );
+    if (run.owner === "foreground" && run.queue) {
+      run.queue.push(event);
+      if (
+        event.type === "turn_completed" ||
+        event.type === "turn_failed" ||
+        event.type === "turn_canceled"
+      ) {
+        run.queue.end();
+      }
+    } else {
+      this.liveEventQueue.push(event);
+    }
+    this.handleRunTerminalEvent(run, event);
+  }
+
+  private handleRunTerminalEvent(run: RunRecord, event: AgentStreamEvent): void {
+    if (event.type === "turn_completed") {
+      this.runTracker.complete(run, "completed");
+    } else if (event.type === "turn_failed") {
+      this.runTracker.complete(run, "error");
+    } else if (event.type === "turn_canceled") {
+      this.runTracker.complete(run, "interrupted");
+    } else {
       return;
     }
 
-    const query = await this.ensureQuery();
-    if (!this.input) {
-      throw new Error("Claude session input stream not initialized");
+    if (this.activeForegroundTurn?.runId === run.id) {
+      this.activeForegroundTurn = null;
+    }
+    this.transitionTurnStateFromActiveRuns(`run ${run.id} terminal`);
+    this.logDerivedSessionLifecycle("terminal_event");
+  }
+
+  private logDerivedSessionLifecycle(context: string): void {
+    const lifecycle = this.runTracker.deriveLifecycle(this.pendingPermissions.size);
+    this.logger.debug({ lifecycle, context }, "Claude session lifecycle derived");
+  }
+
+  private async transitionAutonomousToForeground(): Promise<void> {
+    const autonomousRuns = this.runTracker.listActiveRuns("autonomous");
+    if (autonomousRuns.length === 0) {
+      this.transitionTurnStateFromActiveRuns("no autonomous runs to transition");
+      return;
     }
 
-    this.input.push(sdkMessage);
-    const expectedPromptUuid =
-      typeof sdkMessage.uuid === "string" && sdkMessage.uuid.length > 0
-        ? sdkMessage.uuid
-        : null;
-    let promptActivated = expectedPromptUuid === null;
+    this.logger.debug(
+      { runIds: autonomousRuns.map((run) => run.id) },
+      "Transitioning autonomous runs to foreground ownership"
+    );
+    this.flushPendingToolCalls();
+    for (const run of autonomousRuns) {
+      this.emitRunEvent(run, {
+        type: "turn_canceled",
+        provider: "claude",
+        reason: "Interrupted by foreground prompt",
+      });
+    }
+    this.pendingInterruptPromise = this.interruptActiveTurn().catch((error) => {
+      this.logger.warn(
+        { err: error },
+        "Failed to interrupt autonomous run during foreground transition"
+      );
+    });
+    await this.awaitPendingInterruptPromise();
+    this.transitionTurnStateFromActiveRuns("autonomous interrupted for foreground");
+  }
 
-    while (true) {
-      // Check if this turn has been superseded by a new one.
-      if (this.currentTurnId !== turnId) {
-        break;
-      }
+  private routeMessage(
+    normalized: {
+      message: SDKMessage;
+      identifiers: EventIdentifiers;
+      metadataOnly: boolean;
+    }
+  ): RunRoute {
+    const byIdentifiers = this.runTracker.resolveByIdentifiers(normalized.identifiers);
+    if (byIdentifiers.run) {
+      return byIdentifiers;
+    }
 
-      const { value, done } = await query.next();
-      if (done) {
-        break;
+    const foregroundRun = this.activeForegroundTurn
+      ? this.runTracker.getRun(this.activeForegroundTurn.runId)
+      : null;
+    if (
+      this.turnState === "foreground" &&
+      foregroundRun &&
+      !normalized.metadataOnly &&
+      this.shouldPreferForegroundRun({
+        run: foregroundRun,
+        message: normalized.message,
+      })
+    ) {
+      return { run: foregroundRun, reason: "foreground" };
+    }
+
+    if (normalized.metadataOnly) {
+      return { run: null, reason: "metadata" };
+    }
+
+    const autonomousRun = this.createRun("autonomous", null);
+    this.emitRunEvent(autonomousRun, { type: "turn_started", provider: "claude" });
+    return { run: autonomousRun, reason: "fallback" };
+  }
+
+  private shouldPreferForegroundRun(input: {
+    run: RunRecord;
+    message: SDKMessage;
+  }): boolean {
+    const { run, message } = input;
+    if (
+      run.state === "completed" ||
+      run.state === "interrupted" ||
+      run.state === "error"
+    ) {
+      return false;
+    }
+
+    if (!run.promptReplaySeen) {
+      return false;
+    }
+
+    if (
+      run.state === "finalizing" &&
+      (message.type === "assistant" || message.type === "stream_event")
+    ) {
+      return false;
+    }
+
+    return true;
+  }
+
+  private startQueryPump(): void {
+    if (this.closed || this.queryPumpPromise) {
+      return;
+    }
+
+    const pump = this.runQueryPump().catch((error) => {
+      this.logger.warn({ err: error }, "Claude query pump exited unexpectedly");
+    });
+
+    this.queryPumpPromise = pump;
+    pump.finally(() => {
+      if (this.queryPumpPromise === pump) {
+        this.queryPumpPromise = null;
       }
-      if (!value) {
+    });
+  }
+
+  private async runQueryPump(): Promise<void> {
+    while (!this.closed) {
+      if (!this.claudeSessionId && !this.activeForegroundTurn && !this.query) {
+        await this.waitForLiveHistoryPoll();
         continue;
       }
 
-      // Double-check turn ID after awaiting, in case a new turn started while we waited
-      if (this.currentTurnId !== turnId) {
-        break;
+      let q: Query;
+      try {
+        q = await this.ensureQuery();
+      } catch (error) {
+        this.logger.warn({ err: error }, "Failed to initialize Claude query pump");
+        await this.waitForLiveHistoryPoll();
+        continue;
       }
 
-      // Guard against stale queued events from a prior run (for example,
-      // task-notification side activity): do not treat assistant/result as part
-      // of this prompt until we observe a prompt-owned stream start.
-      if (!promptActivated) {
-        const isTopLevelAssistantStart =
-          value.type === "stream_event" &&
-          (value as { event?: { type?: unknown }; parent_tool_use_id?: unknown }).event
-            ?.type === "message_start" &&
-          ((value as { parent_tool_use_id?: unknown }).parent_tool_use_id ?? null) ===
-            null;
-        if (
-          value.type === "user" &&
-          typeof value.uuid === "string" &&
-          value.uuid === expectedPromptUuid
-        ) {
-          promptActivated = true;
-          continue;
+      let next: IteratorResult<SDKMessage, void>;
+      try {
+        next = await q.next();
+      } catch (error) {
+        this.logger.warn({ err: error }, "Claude query pump next() failed");
+        for (const run of this.runTracker.listActiveRuns()) {
+          this.failRun(
+            run,
+            error instanceof Error ? error.message : "Claude stream failed"
+          );
         }
-        if (isTopLevelAssistantStart) {
-          promptActivated = true;
-        } else if (value.type === "system" && value.subtype === "init") {
-          yield value;
-          continue;
-        }
-        if (!promptActivated) {
-          continue;
+        this.input?.end();
+        await this.awaitWithTimeout(q.return?.(), "query pump return after failure");
+        if (this.query === q) {
+          this.query = null;
+          this.input = null;
         }
+        await this.waitForLiveHistoryPoll();
+        continue;
       }
 
-      yield value;
-      if (value.type === "result") {
-        break;
+      if (next.done) {
+        this.input?.end();
+        await this.awaitWithTimeout(q.return?.(), "query pump return on done");
+        if (this.query === q) {
+          this.query = null;
+          this.input = null;
+        }
+        const activeRuns = this.runTracker.listActiveRuns();
+        if (activeRuns.length > 0) {
+          for (const run of activeRuns) {
+            this.failRun(run, "Claude stream ended before terminal result");
+          }
+        }
+        await this.waitForLiveHistoryPoll();
+        continue;
+      }
+
+      const sdkMessage = next.value;
+      if (!sdkMessage) {
+        continue;
+      }
+
+      try {
+        this.routeSdkMessageFromPump(sdkMessage);
+      } catch (error) {
+        this.logger.warn({ err: error }, "Failed to route Claude SDK message from query pump");
       }
     }
   }
 
-  private async forwardPromptEvents(
-    message: SDKUserMessage,
-    queue: Pushable<AgentStreamEvent>,
-    turnId: number
-  ) {
-    // Create a turn-local context to track streaming state.
-    // This prevents race conditions when a new stream() call interrupts a running one.
-    const turnContext: TurnContext = {
-      streamedAssistantTextThisTurn: false,
-      streamedReasoningThisTurn: false,
-    };
-    let completedNormally = false;
-    try {
-      for await (const sdkEvent of this.processPrompt(message, turnId)) {
-        // Check if this turn has been superseded before pushing events
-        if (this.currentTurnId !== turnId) {
-          break;
-        }
-        const events = this.translateMessageToEvents(sdkEvent, turnContext);
-        for (const event of events) {
-          queue.push(event);
-          if (event.type === "turn_completed") {
-            completedNormally = true;
-          }
-        }
-      }
-    } catch (error) {
-      if (!this.turnCancelRequested && this.currentTurnId === turnId) {
-        queue.push({
-          type: "turn_failed",
-          provider: "claude",
-          error: error instanceof Error ? error.message : "Claude stream failed",
-        });
-      }
-    } finally {
-      // Emit terminal event for superseded turns so consumers get proper lifecycle signals.
-      // Use turn_canceled (not turn_failed) to distinguish intentional interruption from errors.
-      // Only emit if not already emitted by requestCancel() (indicated by turnCancelRequested).
-      const wasSuperseded = this.currentTurnId !== turnId;
-      if (wasSuperseded && !completedNormally && !this.turnCancelRequested) {
-        this.flushPendingToolCalls();
-        queue.push({
-          type: "turn_canceled",
-          provider: "claude",
-          reason: "Interrupted by new message",
-        });
-      }
-      this.turnCancelRequested = false;
-      queue.end();
+  private routeSdkMessageFromPump(message: SDKMessage): void {
+    if (this.shouldSuppressLocalReplayActivity(message)) {
+      return;
     }
+
+    const identifiers = readEventIdentifiers(message);
+    const metadataOnly = isMetadataOnlySdkMessage(message);
+    const route = this.routeMessage({
+      message,
+      identifiers,
+      metadataOnly,
+    });
+    if (route.run) {
+      this.transitionTurnStateFromActiveRuns(`routed via ${route.reason}`);
+      this.runTracker.bindIdentifiers(route.run, identifiers);
+      this.updateRunLifecycleForMessage(route.run, message, identifiers);
+    }
+
+    this.logger.debug(
+      {
+        routeReason: route.reason,
+        runId: route.run?.id ?? null,
+        turnState: this.turnState,
+        metadataOnly,
+        identifiers,
+      },
+      "Claude query pump routing decision"
+    );
+
+    const messageEvents = this.translateMessageToEvents(message, {
+      suppressAssistantText: true,
+      suppressReasoning: true,
+    });
+    const assistantTimelineItems = this.timelineAssembler.consume({
+      message,
+      runId: route.run?.id ?? null,
+      messageIdHint: identifiers.messageId,
+    });
+    const assistantTimelineEvents: AgentStreamEvent[] = assistantTimelineItems.map(
+      (item) => ({
+        type: "timeline",
+        item,
+        provider: "claude",
+      })
+    );
+    const events = [...messageEvents, ...assistantTimelineEvents];
+
+    if (events.length === 0) {
+      return;
+    }
+
+    if (!route.run) {
+      this.dispatchMetadataEvents(events);
+      return;
+    }
+
+    for (const event of events) {
+      this.emitRunEvent(route.run, event);
+    }
+  }
+
+  private dispatchMetadataEvents(events: AgentStreamEvent[]): void {
+    for (const event of events) {
+      this.pushEvent(event);
+    }
+  }
+
+  private updateRunLifecycleForMessage(
+    run: RunRecord,
+    message: SDKMessage,
+    identifiers: EventIdentifiers
+  ): void {
+    if (
+      message.type === "user" &&
+      identifiers.messageId &&
+      run.messageIds.has(identifiers.messageId)
+    ) {
+      run.promptReplaySeen = true;
+    }
+
+    if (run.state === "queued") {
+      this.runTracker.transition(run, "awaiting_response");
+    }
+
+    if (
+      message.type === "assistant" ||
+      message.type === "stream_event" ||
+      message.type === "tool_progress"
+    ) {
+      this.runTracker.transition(run, "streaming");
+      this.logDerivedSessionLifecycle("streaming_event");
+      return;
+    }
+
+    if (message.type === "result") {
+      this.runTracker.transition(run, "finalizing");
+      this.logDerivedSessionLifecycle("result_event");
+      return;
+    }
+
+    this.logDerivedSessionLifecycle("non_terminal_event");
+  }
+
+  private shouldSuppressLocalReplayActivity(message: SDKMessage): boolean {
+    const localReplay = this.isLocalReplayUserMessage(message);
+    if (!this.activeForegroundTurn && localReplay) {
+      this.suppressLocalReplayActivity = true;
+      this.logger.debug(
+        { uuid: (message as { uuid?: string }).uuid },
+        "Suppressing local replay user message from live pump"
+      );
+      return true;
+    }
+
+    if (!this.suppressLocalReplayActivity) {
+      return false;
+    }
+
+    if (message.type === "user" && !localReplay) {
+      this.suppressLocalReplayActivity = false;
+      return false;
+    }
+
+    return true;
+  }
+
+  private isLocalReplayUserMessage(message: SDKMessage): boolean {
+    if (message.type !== "user") {
+      return false;
+    }
+    const uuid = readTrimmedString(
+      (message as unknown as { uuid?: unknown }).uuid
+    );
+    if (!uuid) {
+      return false;
+    }
+    return this.localUserMessageIds.has(uuid);
   }
 
   private async interruptActiveTurn(): Promise<void> {
@@ -2031,7 +2901,13 @@ class ClaudeAgentSession implements AgentSession {
     return this.normalizeSubAgentText(display.summary);
   }
 
-  private translateMessageToEvents(message: SDKMessage, turnContext: TurnContext): AgentStreamEvent[] {
+  private translateMessageToEvents(
+    message: SDKMessage,
+    options?: {
+      suppressAssistantText?: boolean;
+      suppressReasoning?: boolean;
+    }
+  ): AgentStreamEvent[] {
     const parentToolUseId = "parent_tool_use_id" in message
       ? (message as { parent_tool_use_id: string | null }).parent_tool_use_id
       : null;
@@ -2040,6 +2916,14 @@ class ClaudeAgentSession implements AgentSession {
     }
 
     const events: AgentStreamEvent[] = [];
+    const fallbackThreadSessionId = this.captureSessionIdFromMessage(message);
+    if (fallbackThreadSessionId) {
+      events.push({
+        type: "thread_started",
+        provider: "claude",
+        sessionId: fallbackThreadSessionId,
+      });
+    }
 
     switch (message.type) {
       case "system":
@@ -2100,7 +2984,7 @@ class ClaudeAgentSession implements AgentSession {
             provider: "claude",
           });
         } else if (Array.isArray(content)) {
-          const timelineItems = this.mapBlocksToTimeline(content, { turnContext });
+          const timelineItems = this.mapBlocksToTimeline(content);
           for (const item of timelineItems) {
             if (item.type === "user_message" && messageId && !item.messageId) {
               events.push({
@@ -2117,9 +3001,8 @@ class ClaudeAgentSession implements AgentSession {
       }
       case "assistant": {
         const timelineItems = this.mapBlocksToTimeline(message.message.content, {
-          turnContext,
-          suppressAssistantText: turnContext.streamedAssistantTextThisTurn,
-          suppressReasoning: turnContext.streamedReasoningThisTurn,
+          suppressAssistantText: options?.suppressAssistantText ?? false,
+          suppressReasoning: options?.suppressReasoning ?? false,
         });
         for (const item of timelineItems) {
           events.push({ type: "timeline", item, provider: "claude" });
@@ -2127,7 +3010,10 @@ class ClaudeAgentSession implements AgentSession {
         break;
       }
       case "stream_event": {
-        const timelineItems = this.mapPartialEvent(message.event, turnContext);
+        const timelineItems = this.mapPartialEvent(message.event, {
+          suppressAssistantText: options?.suppressAssistantText ?? false,
+          suppressReasoning: options?.suppressReasoning ?? false,
+        });
         for (const item of timelineItems) {
           events.push({ type: "timeline", item, provider: "claude" });
         }
@@ -2153,6 +3039,39 @@ class ClaudeAgentSession implements AgentSession {
     return events;
   }
 
+  private captureSessionIdFromMessage(message: SDKMessage): string | null {
+    const msg = message as unknown as {
+      session_id?: unknown;
+      sessionId?: unknown;
+      session?: { id?: unknown } | null;
+    };
+    const sessionIdRaw =
+      typeof msg.session_id === "string"
+        ? msg.session_id
+        : typeof msg.sessionId === "string"
+          ? msg.sessionId
+          : typeof msg.session?.id === "string"
+            ? msg.session.id
+            : "";
+    const sessionId = sessionIdRaw.trim();
+    if (!sessionId) {
+      return null;
+    }
+    if (this.claudeSessionId === null) {
+      this.claudeSessionId = sessionId;
+      this.persistence = null;
+      return sessionId;
+    }
+    if (this.claudeSessionId === sessionId) {
+      return null;
+    }
+    throw new Error(
+      `CRITICAL: Claude session ID overwrite detected! ` +
+        `Existing: ${this.claudeSessionId}, New: ${sessionId}. ` +
+        `This indicates a session identity corruption bug.`
+    );
+  }
+
   private handleSystemMessage(message: SDKSystemMessage): string | null {
     if (message.subtype !== "init") {
       return null;
@@ -2358,9 +3277,11 @@ class ClaudeAgentSession implements AgentSession {
   }
 
   private pushEvent(event: AgentStreamEvent) {
-    if (this.eventQueue) {
-      this.eventQueue.push(event);
+    if (this.activeForegroundTurn) {
+      this.activeForegroundTurn.queue.push(event);
+      return;
     }
+    this.liveEventQueue.push(event);
   }
 
   private normalizePermissionUpdates(
@@ -2385,56 +3306,6 @@ class ClaudeAgentSession implements AgentSession {
     return new Promise((resolve) => setTimeout(resolve, 250));
   }
 
-  private convertLiveHistoryEntryToEvents(params: {
-    entry: any;
-    autonomousTurnActive: boolean;
-  }): {
-    events: AgentStreamEvent[];
-    autonomousTurnActive: boolean;
-  } {
-    const { entry, autonomousTurnActive } = params;
-    const events: AgentStreamEvent[] = [];
-
-    if (entry?.type === "result") {
-      if (!autonomousTurnActive) {
-        return { events, autonomousTurnActive: false };
-      }
-      const usage =
-        entry && typeof entry === "object" && entry.usage
-          ? this.convertUsage(entry as SDKResultMessage)
-          : undefined;
-      if (entry?.subtype === "success") {
-        events.push({ type: "turn_completed", provider: "claude", usage });
-      } else {
-        const errorMessage =
-          Array.isArray(entry?.errors) && entry.errors.length > 0
-            ? entry.errors.join("\n")
-            : "Claude run failed";
-        events.push({
-          type: "turn_failed",
-          provider: "claude",
-          error: errorMessage,
-        });
-      }
-      return { events, autonomousTurnActive: false };
-    }
-
-    let nextAutonomousActive = autonomousTurnActive;
-    const timelineItems = this.convertHistoryEntry(entry);
-    if (!nextAutonomousActive && timelineItems.length > 0) {
-      events.push({ type: "turn_started", provider: "claude" });
-      nextAutonomousActive = true;
-    }
-    for (const item of timelineItems) {
-      events.push({ type: "timeline", item, provider: "claude" });
-    }
-
-    return {
-      events,
-      autonomousTurnActive: nextAutonomousActive,
-    };
-  }
-
   private loadPersistedHistory(sessionId: string) {
     try {
       const historyPath = this.resolveHistoryPath(sessionId);
@@ -2483,21 +3354,17 @@ class ClaudeAgentSession implements AgentSession {
 
   private convertHistoryEntry(entry: any): AgentTimelineItem[] {
     return convertClaudeHistoryEntry(entry, (content) =>
-      this.mapBlocksToTimeline(content, { context: "history" })
+      this.mapBlocksToTimeline(content)
     );
   }
 
   private mapBlocksToTimeline(
     content: string | ClaudeContentChunk[],
     options?: {
-      context?: "live" | "history";
-      turnContext?: TurnContext;
       suppressAssistantText?: boolean;
       suppressReasoning?: boolean;
     }
   ): AgentTimelineItem[] {
-    const context = options?.context ?? "live";
-    const turnContext = options?.turnContext;
     const suppressAssistant = options?.suppressAssistantText ?? false;
     const suppressReasoning = options?.suppressReasoning ?? false;
 
@@ -2505,9 +3372,6 @@ class ClaudeAgentSession implements AgentSession {
       if (!content || content === "[Request interrupted by user for tool use]") {
         return [];
       }
-      if (context === "live" && turnContext) {
-        turnContext.streamedAssistantTextThisTurn = true;
-      }
       if (suppressAssistant) {
         return [];
       }
@@ -2520,9 +3384,6 @@ class ClaudeAgentSession implements AgentSession {
         case "text":
         case "text_delta":
           if (block.text && block.text !== "[Request interrupted by user for tool use]") {
-            if (context === "live" && turnContext) {
-              turnContext.streamedAssistantTextThisTurn = true;
-            }
             if (!suppressAssistant) {
               items.push({ type: "assistant_message", text: block.text });
             }
@@ -2531,9 +3392,6 @@ class ClaudeAgentSession implements AgentSession {
         case "thinking":
         case "thinking_delta":
           if (block.thinking) {
-            if (context === "live" && turnContext) {
-              turnContext.streamedReasoningThisTurn = true;
-            }
             if (!suppressReasoning) {
               items.push({ type: "reasoning", text: block.thinking });
             }
@@ -2747,7 +3605,13 @@ class ClaudeAgentSession implements AgentSession {
     return undefined;
   }
 
-  private mapPartialEvent(event: SDKPartialAssistantMessage["event"], turnContext: TurnContext): AgentTimelineItem[] {
+  private mapPartialEvent(
+    event: SDKPartialAssistantMessage["event"],
+    options?: {
+      suppressAssistantText?: boolean;
+      suppressReasoning?: boolean;
+    }
+  ): AgentTimelineItem[] {
     if (event.type === "content_block_start") {
       const block = isClaudeContentChunk(event.content_block) ? event.content_block : null;
       if (block?.type === "tool_use" && typeof event.index === "number" && typeof block.id === "string") {
@@ -2772,10 +3636,18 @@ class ClaudeAgentSession implements AgentSession {
     switch (event.type) {
       case "content_block_start":
         return isClaudeContentChunk(event.content_block)
-          ? this.mapBlocksToTimeline([event.content_block], { turnContext })
+          ? this.mapBlocksToTimeline([event.content_block], {
+              suppressAssistantText: options?.suppressAssistantText,
+              suppressReasoning: options?.suppressReasoning,
+            })
           : [];
       case "content_block_delta":
-        return isClaudeContentChunk(event.delta) ? this.mapBlocksToTimeline([event.delta], { turnContext }) : [];
+        return isClaudeContentChunk(event.delta)
+          ? this.mapBlocksToTimeline([event.delta], {
+              suppressAssistantText: options?.suppressAssistantText,
+              suppressReasoning: options?.suppressReasoning,
+            })
+          : [];
       default:
         return [];
     }
diff --git a/packages/server/src/server/agent/providers/claude/tool-call-detail-parser.ts b/packages/server/src/server/agent/providers/claude/tool-call-detail-parser.ts
index e41bf2d84..825374ab2 100644
--- a/packages/server/src/server/agent/providers/claude/tool-call-detail-parser.ts
+++ b/packages/server/src/server/agent/providers/claude/tool-call-detail-parser.ts
@@ -96,6 +96,12 @@ const ClaudeToolDetailPass2Schema = z.union([
   toolDetailBranchByName("search", ToolSearchInputSchema, z.unknown(), (input) =>
     toSearchToolDetail(input)
   ),
+  toolDetailBranchByName("Glob", ToolSearchInputSchema, z.unknown(), (input) =>
+    toSearchToolDetail(input)
+  ),
+  toolDetailBranchByName("glob", ToolSearchInputSchema, z.unknown(), (input) =>
+    toSearchToolDetail(input)
+  ),
   ClaudeSpeakToolDetailSchema,
 ]);
 
diff --git a/packages/server/src/server/agent/providers/claude/tool-call-mapper.test.ts b/packages/server/src/server/agent/providers/claude/tool-call-mapper.test.ts
index 79b6bdf04..b993b7184 100644
--- a/packages/server/src/server/agent/providers/claude/tool-call-mapper.test.ts
+++ b/packages/server/src/server/agent/providers/claude/tool-call-mapper.test.ts
@@ -226,6 +226,25 @@ describe("claude tool-call mapper", () => {
     });
   });
 
+  it("maps Glob calls as search detail using pattern input", () => {
+    const item = expectMapped(
+      mapClaudeCompletedToolCall({
+        callId: "claude-glob-1",
+        name: "Glob",
+        input: { pattern: "**/.claude/commands/paseo*" },
+        output: { output: "No files found" },
+      })
+    );
+
+    expect(item.status).toBe("completed");
+    expect(item.error).toBeNull();
+    expect(item.name).toBe("Glob");
+    expect(item.detail).toEqual({
+      type: "search",
+      query: "**/.claude/commands/paseo*",
+    });
+  });
+
   it("normalizes claude speak tool names through schema transforms", () => {
     const item = expectMapped(
       mapClaudeCompletedToolCall({
diff --git a/packages/server/src/server/agent/providers/claude/tool-call-mapper.ts b/packages/server/src/server/agent/providers/claude/tool-call-mapper.ts
index 4d178121c..3c21b022c 100644
--- a/packages/server/src/server/agent/providers/claude/tool-call-mapper.ts
+++ b/packages/server/src/server/agent/providers/claude/tool-call-mapper.ts
@@ -75,6 +75,8 @@ const ClaudeSearchToolNameSchema = z.union([
   z.literal("WebSearch"),
   z.literal("web_search"),
   z.literal("search"),
+  z.literal("Glob"),
+  z.literal("glob"),
 ]);
 const ClaudeSpeakToolNameSchema = z
   .string()
diff --git a/packages/server/src/server/agent/providers/codex-app-server-agent.ts b/packages/server/src/server/agent/providers/codex-app-server-agent.ts
index 16c4e8f72..1abf55c90 100644
--- a/packages/server/src/server/agent/providers/codex-app-server-agent.ts
+++ b/packages/server/src/server/agent/providers/codex-app-server-agent.ts
@@ -2229,6 +2229,7 @@ class CodexAppServerAgentSession implements AgentSession {
       provider: CODEX_PROVIDER,
       sessionId: this.currentThreadId,
       model: this.config.model ?? null,
+      thinkingOptionId: normalizeCodexThinkingOptionId(this.config.thinkingOptionId) ?? null,
       modeId: this.currentMode ?? null,
       extra: this.resolvedCollaborationMode
         ? { collaborationMode: this.resolvedCollaborationMode.name }
@@ -2434,22 +2435,39 @@ class CodexAppServerAgentSession implements AgentSession {
     if (!this.client) return;
     if (this.currentThreadId) return;
 
-    // Resolve model - if not specified, query available models and pick default
+    // Resolve model + thinking defaults when omitted.
+    let configuredDefaults: CodexConfiguredDefaults = {};
     let model = this.config.model;
-    if (!model) {
-      const configuredDefaults = await readCodexConfiguredDefaults(this.client, this.logger);
-      model = configuredDefaults.model;
+    let thinkingOptionId = normalizeCodexThinkingOptionId(this.config.thinkingOptionId);
+    if (!model || !thinkingOptionId) {
+      configuredDefaults = await readCodexConfiguredDefaults(this.client, this.logger);
     }
     if (!model) {
+      model = configuredDefaults.model;
+    }
+    if (!thinkingOptionId) {
+      thinkingOptionId = configuredDefaults.thinkingOptionId;
+    }
+
+    if (!model || !thinkingOptionId) {
       const modelResponse = (await this.client.request("model/list", {})) as CodexModelListResponse;
       const models = modelResponse?.data ?? [];
       const defaultModel = models.find((m) => m.isDefault) ?? models[0];
       if (!defaultModel) {
         throw new Error("No models available from Codex app-server");
       }
-      model = defaultModel.id;
+      const selectedModel =
+        (model ? models.find((candidate) => candidate.id === model) : undefined) ?? defaultModel;
+      if (!model) {
+        model = selectedModel.id;
+      }
+      if (!thinkingOptionId) {
+        thinkingOptionId = normalizeCodexThinkingOptionId(selectedModel.defaultReasoningEffort);
+      }
     }
+
     this.config.model = model;
+    this.config.thinkingOptionId = thinkingOptionId;
 
     const preset = MODE_PRESETS[this.currentMode] ?? MODE_PRESETS[DEFAULT_CODEX_MODE_ID];
     const approvalPolicy = this.config.approvalPolicy ?? preset.approvalPolicy;
diff --git a/packages/server/src/server/agent/providers/tool-call-detail-primitives.ts b/packages/server/src/server/agent/providers/tool-call-detail-primitives.ts
index 7657178e1..2ec8d170d 100644
--- a/packages/server/src/server/agent/providers/tool-call-detail-primitives.ts
+++ b/packages/server/src/server/agent/providers/tool-call-detail-primitives.ts
@@ -509,6 +509,7 @@ export const ToolEditOutputSchema = z.union([
 export const ToolSearchInputSchema = z.union([
   z.object({ query: z.string() }).passthrough().transform((value) => ({ query: value.query })),
   z.object({ q: z.string() }).passthrough().transform((value) => ({ query: value.q })),
+  z.object({ pattern: z.string() }).passthrough().transform((value) => ({ query: value.pattern })),
 ]);
 
 export type ParsedToolShellInput = z.infer<typeof ToolShellInputSchema>;
diff --git a/packages/server/src/server/daemon-e2e/claude-autonomous-wake.real.e2e.test.ts b/packages/server/src/server/daemon-e2e/claude-autonomous-wake.real.e2e.test.ts
new file mode 100644
index 000000000..e83bcdedb
--- /dev/null
+++ b/packages/server/src/server/daemon-e2e/claude-autonomous-wake.real.e2e.test.ts
@@ -0,0 +1,811 @@
+import { describe, expect, test } from "vitest";
+import { existsSync, mkdtempSync, readFileSync, realpathSync, rmSync } from "node:fs";
+import { homedir, tmpdir } from "node:os";
+import path from "node:path";
+import pino from "pino";
+import WebSocket from "ws";
+
+import { createTestPaseoDaemon } from "../test-utils/paseo-daemon.js";
+import { DaemonClient } from "../test-utils/daemon-client.js";
+import { ClaudeAgentClient } from "../agent/providers/claude-agent.js";
+import { getFullAccessConfig } from "./agent-configs.js";
+import { isCommandAvailable } from "../agent/provider-launch-config.js";
+
+function tmpCwd(): string {
+  return mkdtempSync(path.join(tmpdir(), "daemon-real-claude-autonomous-wake-"));
+}
+
+function sleep(ms: number): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+function sanitizeClaudeProjectPath(cwd: string): string {
+  return cwd.replace(/[\\/\.]/g, "-").replace(/_/g, "-");
+}
+
+function resolveClaudeTranscriptPath(params: {
+  cwd: string;
+  sessionId: string;
+}): string {
+  const configDir = process.env.CLAUDE_CONFIG_DIR ?? path.join(homedir(), ".claude");
+  const cwdCandidates = [params.cwd];
+  try {
+    const realpath = realpathSync(params.cwd);
+    if (!cwdCandidates.includes(realpath)) {
+      cwdCandidates.push(realpath);
+    }
+  } catch {
+    // ignore realpath errors for temporary cwd teardown races
+  }
+
+  for (const cwd of cwdCandidates) {
+    const candidate = path.join(
+      configDir,
+      "projects",
+      sanitizeClaudeProjectPath(cwd),
+      `${params.sessionId}.jsonl`
+    );
+    if (existsSync(candidate)) {
+      return candidate;
+    }
+  }
+
+  return path.join(
+    configDir,
+    "projects",
+    sanitizeClaudeProjectPath(params.cwd),
+    `${params.sessionId}.jsonl`
+  );
+}
+
+type ClaudeTranscriptLine = {
+  type?: unknown;
+  timestamp?: unknown;
+  uuid?: unknown;
+  parentUuid?: unknown;
+  message?: { content?: unknown } | null;
+};
+
+function readTranscriptLines(pathname: string): ClaudeTranscriptLine[] {
+  if (!existsSync(pathname)) {
+    return [];
+  }
+  const text = readFileSync(pathname, "utf8");
+  const rows: ClaudeTranscriptLine[] = [];
+  for (const line of text.split(/\n+/)) {
+    const trimmed = line.trim();
+    if (!trimmed) {
+      continue;
+    }
+    try {
+      rows.push(JSON.parse(trimmed) as ClaudeTranscriptLine);
+    } catch {
+      // ignore malformed rows while transcript is still being appended
+    }
+  }
+  return rows;
+}
+
+function readUserText(line: ClaudeTranscriptLine): string {
+  const content = line.message?.content;
+  if (typeof content === "string") {
+    return content;
+  }
+  if (!Array.isArray(content)) {
+    return "";
+  }
+  return content
+    .map((chunk) => {
+      if (!chunk || typeof chunk !== "object") {
+        return "";
+      }
+      const text = (chunk as { text?: unknown }).text;
+      if (typeof text === "string") {
+        return text;
+      }
+      const nested = (chunk as { content?: unknown }).content;
+      return typeof nested === "string" ? nested : "";
+    })
+    .join(" ")
+    .trim();
+}
+
+function readAssistantText(line: ClaudeTranscriptLine): string {
+  const content = line.message?.content;
+  if (typeof content === "string") {
+    return content;
+  }
+  if (!Array.isArray(content)) {
+    return "";
+  }
+  return content
+    .map((chunk) => {
+      if (!chunk || typeof chunk !== "object") {
+        return "";
+      }
+      const text = (chunk as { text?: unknown }).text;
+      if (typeof text === "string") {
+        return text;
+      }
+      return "";
+    })
+    .join("")
+    .trim();
+}
+
+function parseTimestamp(line: ClaudeTranscriptLine): number {
+  const timestamp = line.timestamp;
+  if (typeof timestamp !== "string") {
+    return 0;
+  }
+  const parsed = Date.parse(timestamp);
+  return Number.isFinite(parsed) ? parsed : 0;
+}
+
+type TranscriptRaceEvidence = {
+  helloAssistantText: string;
+  notificationOutcomeAssistantText: string;
+};
+
+function extractTranscriptRaceEvidence(
+  lines: ClaudeTranscriptLine[]
+): TranscriptRaceEvidence | null {
+  const userLines = lines.filter((line) => line.type === "user");
+  const assistantLines = lines.filter((line) => line.type === "assistant");
+  const doItAgain = [...userLines]
+    .reverse()
+    .find((line) => readUserText(line).toLowerCase().includes("do it again"));
+  const helloUser = [...userLines]
+    .reverse()
+    .find((line) => readUserText(line).trim().toLowerCase() === "hello");
+
+  if (!doItAgain || !helloUser || typeof helloUser.uuid !== "string") {
+    return null;
+  }
+
+  const helloAssistant = assistantLines.find(
+    (line) =>
+      typeof line.parentUuid === "string" &&
+      line.parentUuid === helloUser.uuid &&
+      readAssistantText(line).length > 0
+  );
+  if (!helloAssistant) {
+    return null;
+  }
+
+  const doItAgainTs = parseTimestamp(doItAgain);
+  const taskNotificationUser = userLines.find((line) => {
+    if (parseTimestamp(line) <= doItAgainTs) {
+      return false;
+    }
+    return readUserText(line).includes("<task-notification>");
+  });
+  if (!taskNotificationUser || typeof taskNotificationUser.uuid !== "string") {
+    return null;
+  }
+  const helloAssistantUuid =
+    typeof helloAssistant.uuid === "string" ? helloAssistant.uuid : null;
+  const taskNotificationTs = parseTimestamp(taskNotificationUser);
+  const notificationOutcomeAssistant = [...assistantLines]
+    .sort((a, b) => parseTimestamp(a) - parseTimestamp(b))
+    .find((line) => {
+      const lineTs = parseTimestamp(line);
+      if (lineTs < taskNotificationTs) {
+        return false;
+      }
+      const lineUuid = typeof line.uuid === "string" ? line.uuid : null;
+      if (helloAssistantUuid && lineUuid === helloAssistantUuid) {
+        return false;
+      }
+      return readAssistantText(line).length > 0;
+    });
+  if (!notificationOutcomeAssistant) {
+    return null;
+  }
+
+  return {
+    helloAssistantText: readAssistantText(helloAssistant),
+    notificationOutcomeAssistantText: readAssistantText(notificationOutcomeAssistant),
+  };
+}
+
+function normalizeText(value: string): string {
+  return value.replace(/\s+/g, " ").trim().toLowerCase();
+}
+
+function summarizeTranscriptTail(lines: ClaudeTranscriptLine[], limit = 14): string {
+  const tail = lines.slice(-limit);
+  return tail
+    .map((line) => {
+      const ts = typeof line.timestamp === "string" ? line.timestamp : "";
+      const type = typeof line.type === "string" ? line.type : "unknown";
+      if (type === "user") {
+        return `${ts} user ${readUserText(line).slice(0, 160)}`;
+      }
+      if (type === "assistant") {
+        return `${ts} assistant ${readAssistantText(line).slice(0, 160)}`;
+      }
+      if (type === "queue-operation") {
+        const op = (line as { operation?: unknown }).operation;
+        const content = (line as { content?: unknown }).content;
+        return `${ts} queue ${typeof op === "string" ? op : "unknown"} ${typeof content === "string" ? content.slice(0, 120) : ""}`;
+      }
+      return `${ts} ${type}`;
+    })
+    .join("\n");
+}
+
+async function runPreHelloNoise(params: {
+  wsUrl: string;
+  durationMs: number;
+}): Promise<void> {
+  const deadline = Date.now() + params.durationMs;
+  while (Date.now() < deadline) {
+    await new Promise<void>((resolve) => {
+      const ws = new WebSocket(params.wsUrl);
+      const fallback = setTimeout(() => {
+        try {
+          ws.close();
+        } catch {
+          // ignore
+        }
+        resolve();
+      }, 250);
+
+      ws.once("open", () => {
+        try {
+          // Intentionally send a session message before hello to create the same
+          // pre-hello churn seen in production logs.
+          ws.send(
+            JSON.stringify({
+              type: "session",
+              payload: {
+                type: "fetch_agents_request",
+                requestId: `noise-${Date.now()}`,
+              },
+            })
+          );
+        } catch {
+          // ignore
+        }
+        setTimeout(() => {
+          try {
+            ws.close();
+          } catch {
+            // ignore
+          }
+        }, 5);
+      });
+
+      ws.once("close", () => {
+        clearTimeout(fallback);
+        resolve();
+      });
+      ws.once("error", () => {
+        clearTimeout(fallback);
+        resolve();
+      });
+    });
+  }
+}
+
+function summarizeTimelineEntry(entry: {
+  item:
+    | { type: "user_message"; text: string }
+    | { type: "assistant_message"; text: string }
+    | { type: "tool_call"; name: string; status: string }
+    | { type: string };
+}): string {
+  const item = entry.item;
+  if (item.type === "user_message") {
+    return `[user] ${item.text}`;
+  }
+  if (item.type === "assistant_message") {
+    return `[assistant] ${item.text}`;
+  }
+  if (item.type === "tool_call") {
+    return `[tool:${item.name}:${item.status}]`;
+  }
+  return `[${item.type}]`;
+}
+
+describe("daemon E2E (real claude) - autonomous wake from background task", () => {
+  test.runIf(isCommandAvailable("claude"))(
+    "returns to running after background sleep completes without a second prompt",
+    async () => {
+      const logger = pino({ level: "silent" });
+      const cwd = tmpCwd();
+      const daemon = await createTestPaseoDaemon({
+        agentClients: { claude: new ClaudeAgentClient({ logger }) },
+        logger,
+      });
+      const client = new DaemonClient({ url: `ws://127.0.0.1:${daemon.port}/ws` });
+
+      try {
+        await client.connect();
+        await client.fetchAgents({
+          subscribe: { subscriptionId: "claude-autonomous-wake-real" },
+        });
+
+        const agent = await client.createAgent({
+          cwd,
+          title: "claude-autonomous-wake-real",
+          ...getFullAccessConfig("claude"),
+        });
+
+        await client.sendMessage(
+          agent.id,
+          [
+            "Use a background task to run exactly: sleep 5",
+            "Do not wait for it to finish.",
+            "After launching it, reply with exactly: SPAWNED",
+          ].join(" ")
+        );
+
+        const firstFinish = await client.waitForFinish(agent.id, 240_000);
+        expect(firstFinish.status).toBe("idle");
+
+        const timelineBeforeWake = await client.fetchAgentTimeline(agent.id, {
+          direction: "tail",
+          limit: 0,
+          projection: "canonical",
+        });
+        const summarized = timelineBeforeWake.entries.map(summarizeTimelineEntry);
+        // Required by reproduction request: log timeline at idle edge before autonomous wake.
+        // eslint-disable-next-line no-console
+        console.log("TIMELINE_BEFORE_AUTONOMOUS_WAKE\n" + summarized.join("\n"));
+        expect(summarized.some((line) => line.includes("SPAWNED"))).toBe(true);
+
+        // No new user prompt here: we expect autonomous transition caused by
+        // background task completion notification.
+        await client.waitForAgentUpsert(
+          agent.id,
+          (snapshot) => snapshot.status === "running",
+          30_000
+        );
+      } finally {
+        await client.close();
+        await daemon.close();
+        rmSync(cwd, { recursive: true, force: true });
+      }
+    },
+    420_000
+  );
+
+  test.runIf(isCommandAvailable("claude"))(
+    "accepts a new prompt after background sleep finishes and replies HELLO",
+    async () => {
+      const logger = pino({ level: "silent" });
+      const cwd = tmpCwd();
+      const daemon = await createTestPaseoDaemon({
+        agentClients: { claude: new ClaudeAgentClient({ logger }) },
+        logger,
+      });
+      const client = new DaemonClient({ url: `ws://127.0.0.1:${daemon.port}/ws` });
+
+      try {
+        await client.connect();
+        await client.fetchAgents({
+          subscribe: { subscriptionId: "claude-autonomous-followup-real" },
+        });
+
+        const agent = await client.createAgent({
+          cwd,
+          title: "claude-autonomous-followup-real",
+          ...getFullAccessConfig("claude"),
+        });
+
+        await client.sendMessage(
+          agent.id,
+          [
+            "Use a background task to run exactly: sleep 5",
+            "Do not wait for it to finish.",
+            "After launching it, reply with exactly: SPAWNED",
+          ].join(" ")
+        );
+        const firstFinish = await client.waitForFinish(agent.id, 240_000);
+        expect(firstFinish.status).toBe("idle");
+
+        await new Promise((resolve) => setTimeout(resolve, 6_000));
+
+        await client.sendMessage(agent.id, "say exactly HELLO");
+        const secondFinish = await client.waitForFinish(agent.id, 240_000);
+        expect(secondFinish.status).toBe("idle");
+        expect(secondFinish.lastMessage?.trim()).toBe("HELLO");
+      } finally {
+        await client.close();
+        await daemon.close();
+        rmSync(cwd, { recursive: true, force: true });
+      }
+    },
+    420_000
+  );
+
+  test.runIf(isCommandAvailable("claude"))(
+    "repro: do-it-again + immediate hello can hang after autonomous wake under churn",
+    async () => {
+      const logger = pino({ level: "silent" });
+      const cwd = tmpCwd();
+      const daemon = await createTestPaseoDaemon({
+        agentClients: { claude: new ClaudeAgentClient({ logger }) },
+        logger,
+      });
+      const wsUrl = `ws://127.0.0.1:${daemon.port}/ws`;
+      const client = new DaemonClient({ url: wsUrl });
+
+      try {
+        await client.connect();
+        await client.fetchAgents({
+          subscribe: { subscriptionId: "claude-hang-repro-real" },
+        });
+
+        const agent = await client.createAgent({
+          cwd,
+          title: "claude-hang-repro-real",
+          ...getFullAccessConfig("claude"),
+        });
+
+        for (let cycle = 0; cycle < 20; cycle += 1) {
+          const noise = runPreHelloNoise({ wsUrl, durationMs: 9_000 });
+
+          await client.sendMessage(agent.id, "sleep for 5, in the background");
+          const firstKickoff = await client.waitForFinish(agent.id, 180_000);
+          expect(firstKickoff.status).toBe("idle");
+
+          await client.waitForAgentUpsert(
+            agent.id,
+            (snapshot) => snapshot.status === "running",
+            30_000
+          );
+          const firstCompletion = await client.waitForFinish(agent.id, 90_000);
+          expect(firstCompletion.status).toBe("idle");
+
+          await client.sendMessage(agent.id, "do it again");
+          const secondKickoff = await client.waitForFinish(agent.id, 180_000);
+          expect(secondKickoff.status).toBe("idle");
+
+          await client.sendMessage(agent.id, "hello");
+          const helloReply = await client.waitForFinish(agent.id, 180_000);
+          expect(helloReply.status).toBe("idle");
+          expect((helloReply.lastMessage ?? "").toLowerCase()).toContain("hello");
+
+          const runningSnapshot = await client.waitForAgentUpsert(
+            agent.id,
+            (snapshot) => snapshot.status === "running",
+            30_000
+          );
+
+          const timelineAtWake = await client.fetchAgentTimeline(agent.id, {
+            direction: "tail",
+            limit: 0,
+            projection: "canonical",
+          });
+
+          // eslint-disable-next-line no-console
+          console.log(
+            JSON.stringify({
+              cycle,
+              wakeUpdatedAt: runningSnapshot.updatedAt,
+              entriesAtWake: timelineAtWake.entries.length,
+            })
+          );
+
+          await sleep(6_000);
+          const timelineAfterWake = await client.fetchAgentTimeline(agent.id, {
+            direction: "tail",
+            limit: 0,
+            projection: "canonical",
+          });
+          expect(timelineAfterWake.entries.length).toBeGreaterThan(
+            timelineAtWake.entries.length
+          );
+
+          const secondCompletion = await client.waitForFinish(agent.id, 20_000);
+          expect(secondCompletion.status).toBe("idle");
+
+          await noise;
+        }
+      } finally {
+        await client.close();
+        await daemon.close();
+        rmSync(cwd, { recursive: true, force: true });
+      }
+    },
+    900_000
+  );
+
+  test.runIf(isCommandAvailable("claude"))(
+    "repro: second background sleep completion after HELLO should settle back to idle",
+    async () => {
+      const logger = pino({ level: "silent" });
+      const cwd = tmpCwd();
+      const daemon = await createTestPaseoDaemon({
+        agentClients: { claude: new ClaudeAgentClient({ logger }) },
+        logger,
+      });
+      const client = new DaemonClient({ url: `ws://127.0.0.1:${daemon.port}/ws` });
+
+      try {
+        await client.connect();
+        await client.fetchAgents({
+          subscribe: { subscriptionId: "claude-background-repro-real" },
+        });
+
+        const agent = await client.createAgent({
+          cwd,
+          title: "claude-background-repro-real",
+          ...getFullAccessConfig("claude"),
+        });
+
+        await client.sendMessage(agent.id, "sleep for 5, in the background");
+        const firstKickoff = await client.waitForFinish(agent.id, 180_000);
+        expect(firstKickoff.status).toBe("idle");
+
+        await client.waitForAgentUpsert(
+          agent.id,
+          (snapshot) => snapshot.status === "running",
+          30_000
+        );
+        const firstCompletion = await client.waitForFinish(agent.id, 60_000);
+        expect(firstCompletion.status).toBe("idle");
+
+        await client.sendMessage(agent.id, "do it again");
+        const secondKickoff = await client.waitForFinish(agent.id, 180_000);
+        expect(secondKickoff.status).toBe("idle");
+
+        await client.sendMessage(agent.id, "hello");
+        const helloReply = await client.waitForFinish(agent.id, 180_000);
+        expect(helloReply.status).toBe("idle");
+        expect((helloReply.lastMessage ?? "").toLowerCase()).toContain("hello");
+
+        await client.waitForAgentUpsert(
+          agent.id,
+          (snapshot) => snapshot.status === "running",
+          30_000
+        );
+
+        // This is the failure point seen in production: agent flips to running
+        // on task completion and never settles back to idle.
+        const secondCompletion = await client.waitForFinish(agent.id, 20_000);
+        expect(secondCompletion.status).toBe("idle");
+      } finally {
+        await client.close();
+        await daemon.close();
+        rmSync(cwd, { recursive: true, force: true });
+      }
+    },
+    600_000
+  );
+
+  test.runIf(isCommandAvailable("claude"))(
+    "stress: immediate HELLO before task notification should not leave autonomous run stuck",
+    async () => {
+      const logger = pino({ level: "silent" });
+      const cwd = tmpCwd();
+      const daemon = await createTestPaseoDaemon({
+        agentClients: { claude: new ClaudeAgentClient({ logger }) },
+        logger,
+      });
+      const client = new DaemonClient({ url: `ws://127.0.0.1:${daemon.port}/ws` });
+
+      try {
+        await client.connect();
+        await client.fetchAgents({
+          subscribe: { subscriptionId: "claude-autonomous-race-stress-real" },
+        });
+
+        const agent = await client.createAgent({
+          cwd,
+          title: "claude-autonomous-race-stress-real",
+          ...getFullAccessConfig("claude"),
+        });
+
+        for (let cycle = 0; cycle < 60; cycle += 1) {
+          const helloToken = `HELLO_CYCLE_${cycle}`;
+
+          await client.sendMessage(
+            agent.id,
+            [
+              "Use the Task tool (not a Bash background process).",
+              "Start a background task that runs exactly: sleep 1",
+              "Do not wait for the task result.",
+              "Immediately reply with exactly: SPAWNED",
+            ].join(" ")
+          );
+
+          const firstFinish = await client.waitForFinish(agent.id, 240_000);
+          expect(firstFinish.status).toBe("idle");
+
+          // Race path under test: immediately send the next user prompt before
+          // the background-task completion notification wakes Claude again.
+          await client.sendMessage(agent.id, `say exactly ${helloToken}`);
+          const secondFinish = await client.waitForFinish(agent.id, 240_000);
+          expect(secondFinish.status).toBe("idle");
+          expect(secondFinish.lastMessage?.trim()).toBe(helloToken);
+
+          const wakeSnapshot = await client.waitForAgentUpsert(
+            agent.id,
+            (snapshot) => snapshot.status === "running",
+            20_000
+          );
+
+          const timelineAtWake = await client.fetchAgentTimeline(agent.id, {
+            direction: "tail",
+            limit: 0,
+            projection: "canonical",
+          });
+
+          // eslint-disable-next-line no-console
+          console.log(
+            JSON.stringify({
+              cycle,
+              autonomousWakeUpdatedAt: wakeSnapshot.updatedAt,
+              timelineEntriesAtWake: timelineAtWake.entries.length,
+            })
+          );
+
+          await sleep(3_000);
+          const timelineAfterWake = await client.fetchAgentTimeline(agent.id, {
+            direction: "tail",
+            limit: 0,
+            projection: "canonical",
+          });
+          expect(timelineAfterWake.entries.length).toBeGreaterThan(
+            timelineAtWake.entries.length
+          );
+
+          await client.cancelAgent(agent.id);
+          const afterCancel = await client.waitForFinish(agent.id, 10_000);
+          expect(afterCancel.status).toBe("idle");
+        }
+      } finally {
+        await client.close();
+        await daemon.close();
+        rmSync(cwd, { recursive: true, force: true });
+      }
+    },
+    900_000
+  );
+
+  test.runIf(isCommandAvailable("claude"))(
+    "repro: transcript/timeline parity after do-it-again + hello race (hang + interrupt + drop)",
+    async () => {
+      const logger = pino({ level: "silent" });
+      const cwd = tmpCwd();
+      const daemon = await createTestPaseoDaemon({
+        agentClients: { claude: new ClaudeAgentClient({ logger }) },
+        logger,
+      });
+      const client = new DaemonClient({ url: `ws://127.0.0.1:${daemon.port}/ws` });
+
+      try {
+        await client.connect();
+        await client.fetchAgents({
+          subscribe: { subscriptionId: "claude-transcript-parity-race" },
+        });
+
+        const agent = await client.createAgent({
+          cwd,
+          title: "claude-transcript-parity-race",
+          ...getFullAccessConfig("claude"),
+        });
+
+        await client.sendMessage(agent.id, "sleep for 5, in the background");
+        const firstKickoff = await client.waitForFinish(agent.id, 180_000);
+        expect(firstKickoff.status).toBe("idle");
+
+        await client.waitForAgentUpsert(
+          agent.id,
+          (snapshot) => snapshot.status === "running",
+          30_000
+        );
+        const firstAutonomousCompletion = await client.waitForFinish(agent.id, 60_000);
+        expect(firstAutonomousCompletion.status).toBe("idle");
+
+        await client.sendMessage(agent.id, "do it again");
+        const secondKickoff = await client.waitForFinish(agent.id, 180_000);
+        expect(secondKickoff.status).toBe("idle");
+
+        await client.waitForAgentUpsert(
+          agent.id,
+          (snapshot) => snapshot.status === "running",
+          30_000
+        );
+        await sleep(500);
+        await client.sendMessage(agent.id, "hello");
+
+        let waitError: Error | null = null;
+        try {
+          await client.waitForFinish(agent.id, 20_000);
+        } catch (error) {
+          waitError =
+            error instanceof Error ? error : new Error(String(error ?? "wait_for_finish failed"));
+        }
+
+        let afterWait = await client.fetchAgent(agent.id);
+        let cancelRecovered = true;
+        if (afterWait?.status === "running") {
+          await client.cancelAgent(agent.id);
+          try {
+            const afterCancel = await client.waitForFinish(agent.id, 15_000);
+            cancelRecovered = afterCancel.status === "idle";
+          } catch {
+            cancelRecovered = false;
+          }
+          afterWait = await client.fetchAgent(agent.id);
+        }
+
+        expect(waitError).toBeNull();
+        expect(cancelRecovered).toBe(true);
+
+        const sessionId =
+          afterWait?.persistence?.sessionId ??
+          afterWait?.runtimeInfo?.sessionId ??
+          null;
+        expect(typeof sessionId === "string" && sessionId.length > 0).toBe(true);
+        const transcriptCwd = afterWait?.cwd ?? cwd;
+        const transcriptPath = resolveClaudeTranscriptPath({
+          cwd: transcriptCwd,
+          sessionId: sessionId as string,
+        });
+
+        let evidence: TranscriptRaceEvidence | null = null;
+        const transcriptDeadline = Date.now() + 20_000;
+        while (Date.now() < transcriptDeadline) {
+          const lines = readTranscriptLines(transcriptPath);
+          evidence = extractTranscriptRaceEvidence(lines);
+          if (evidence) {
+            break;
+          }
+          await sleep(250);
+        }
+        if (!evidence) {
+          const transcriptDump = summarizeTranscriptTail(readTranscriptLines(transcriptPath));
+          throw new Error(
+            [
+              "Failed to extract transcript race evidence (hello assistant and notification-turn assistant).",
+              `transcriptPath=${transcriptPath}`,
+              `waitError=${waitError ? waitError.message : "null"}`,
+              `afterWaitStatus=${afterWait?.status ?? "unknown"}`,
+              `cancelRecovered=${cancelRecovered}`,
+              "transcriptTail:",
+              transcriptDump,
+            ].join("\n")
+          );
+        }
+
+        const timeline = await client.fetchAgentTimeline(agent.id, {
+          direction: "tail",
+          limit: 0,
+          projection: "canonical",
+        });
+        const assistantTexts = timeline.entries
+          .filter(
+            (
+              entry
+            ): entry is {
+              item: { type: "assistant_message"; text: string };
+            } => entry.item.type === "assistant_message"
+          )
+          .map((entry) => normalizeText(entry.item.text));
+
+        const helloAssistant = normalizeText(evidence.helloAssistantText);
+        const notificationAssistant = normalizeText(
+          evidence.notificationOutcomeAssistantText
+        );
+
+        expect(
+          assistantTexts.some((text) => text.includes(helloAssistant))
+        ).toBe(true);
+        expect(
+          assistantTexts.some((text) => text.includes(notificationAssistant))
+        ).toBe(true);
+      } finally {
+        await client.close();
+        await daemon.close();
+        rmSync(cwd, { recursive: true, force: true });
+      }
+    },
+    600_000
+  );
+});
diff --git a/packages/server/src/server/relay-transport.ts b/packages/server/src/server/relay-transport.ts
index 726d01676..4125ff45d 100644
--- a/packages/server/src/server/relay-transport.ts
+++ b/packages/server/src/server/relay-transport.ts
@@ -291,25 +291,25 @@ export function startRelayTransport({
     }, delayMs);
   };
 
-  const ensureClientDataSocket = (routingId: string): void => {
+  const ensureClientDataSocket = (connectionId: string): void => {
     if (stopped) return;
-    if (!routingId) return;
-    if (dataSockets.has(routingId)) return;
+    if (!connectionId) return;
+    if (dataSockets.has(connectionId)) return;
 
     const url = buildRelayWebSocketUrl({
       endpoint: relayEndpoint,
       serverId,
       role: "server",
-      connectionId: routingId,
+      connectionId,
     });
     const socket = new WebSocket(url, { handshakeTimeout: 10_000, perMessageDeflate: false });
-    dataSockets.set(routingId, socket);
+    dataSockets.set(connectionId, socket);
 
     let attached = false;
     const openTimeout = setTimeout(() => {
       if (stopped) return;
       if (socket.readyState === WebSocket.OPEN) return;
-      relayLogger.warn({ url, routingId }, "relay_data_open_timeout_terminating");
+      relayLogger.warn({ url, connectionId }, "relay_data_open_timeout_terminating");
       try {
         socket.terminate();
       } catch {
@@ -319,7 +319,7 @@ export function startRelayTransport({
 
     socket.on("open", () => {
       clearTimeout(openTimeout);
-      relayLogger.info({ url, routingId }, "relay_data_connected");
+      relayLogger.info({ url, connectionId }, "relay_data_connected");
       if (attached) return;
       attached = true;
       const externalMetadata: ExternalSocketMetadata = {
@@ -329,7 +329,7 @@ export function startRelayTransport({
         void attachEncryptedSocket(
           socket,
           daemonKeyPair,
-          relayLogger.child({ routingId }),
+          relayLogger.child({ connectionId }),
           attachSocket,
           externalMetadata
         );
@@ -341,16 +341,16 @@ export function startRelayTransport({
     socket.on("close", (code, reason) => {
       clearTimeout(openTimeout);
       relayLogger.warn(
-        { code, reason: reason?.toString?.(), url, routingId },
+        { code, reason: reason?.toString?.(), url, connectionId },
         "relay_data_disconnected"
       );
-      if (dataSockets.get(routingId) === socket) {
-        dataSockets.delete(routingId);
+      if (dataSockets.get(connectionId) === socket) {
+        dataSockets.delete(connectionId);
       }
     });
 
     socket.on("error", (err) => {
-      relayLogger.warn({ err, url, routingId }, "relay_data_error");
+      relayLogger.warn({ err, url, connectionId }, "relay_data_error");
     });
   };
 
diff --git a/packages/server/src/server/session.ts b/packages/server/src/server/session.ts
index d6ec4dfc1..2d1857a8c 100644
--- a/packages/server/src/server/session.ts
+++ b/packages/server/src/server/session.ts
@@ -63,7 +63,7 @@ import type {
   ManagedAgent,
 } from './agent/agent-manager.js'
 import { scheduleAgentMetadataGeneration } from './agent/agent-metadata-generator.js'
-import { toAgentPayload } from './agent/agent-projections.js'
+import { resolveEffectiveThinkingOptionId, toAgentPayload } from './agent/agent-projections.js'
 import {
   appendTimelineItemIfAgentKnown,
   emitLiveTimelineItemIfAgentKnown,
@@ -953,12 +953,33 @@ export class Session {
     const lastUserMessageAt = record.lastUserMessageAt ? new Date(record.lastUserMessageAt) : null
 
     const provider = coerceAgentProvider(this.sessionLogger, record.provider, record.id)
+    const runtimeInfo = record.runtimeInfo
+      ? {
+          provider: coerceAgentProvider(this.sessionLogger, record.runtimeInfo.provider, record.id),
+          sessionId: record.runtimeInfo.sessionId,
+          ...(Object.prototype.hasOwnProperty.call(record.runtimeInfo, 'model')
+            ? { model: record.runtimeInfo.model ?? null }
+            : {}),
+          ...(Object.prototype.hasOwnProperty.call(record.runtimeInfo, 'thinkingOptionId')
+            ? { thinkingOptionId: record.runtimeInfo.thinkingOptionId ?? null }
+            : {}),
+          ...(Object.prototype.hasOwnProperty.call(record.runtimeInfo, 'modeId')
+            ? { modeId: record.runtimeInfo.modeId ?? null }
+            : {}),
+          ...(record.runtimeInfo.extra ? { extra: record.runtimeInfo.extra } : {}),
+        }
+      : undefined
     return {
       id: record.id,
       provider,
       cwd: record.cwd,
       model: record.config?.model ?? null,
       thinkingOptionId: record.config?.thinkingOptionId ?? null,
+      effectiveThinkingOptionId: resolveEffectiveThinkingOptionId({
+        runtimeInfo,
+        configuredThinkingOptionId: record.config?.thinkingOptionId ?? null,
+      }),
+      ...(runtimeInfo ? { runtimeInfo } : {}),
       createdAt: createdAt.toISOString(),
       updatedAt: updatedAt.toISOString(),
       lastUserMessageAt: lastUserMessageAt ? lastUserMessageAt.toISOString() : null,
@@ -1055,6 +1076,21 @@ export class Session {
       return false
     }
 
+    if (filter?.thinkingOptionId !== undefined) {
+      const expectedThinkingOptionId = resolveEffectiveThinkingOptionId({
+        configuredThinkingOptionId: filter.thinkingOptionId ?? null,
+      })
+      const resolvedThinkingOptionId =
+        agent.effectiveThinkingOptionId ??
+        resolveEffectiveThinkingOptionId({
+          runtimeInfo: agent.runtimeInfo,
+          configuredThinkingOptionId: agent.thinkingOptionId ?? null,
+        })
+      if (resolvedThinkingOptionId !== expectedThinkingOptionId) {
+        return false
+      }
+    }
+
     if (filter?.statuses && filter.statuses.length > 0) {
       const statuses = new Set(filter.statuses)
       if (!statuses.has(agent.status)) {
diff --git a/packages/server/src/shared/messages.ts b/packages/server/src/shared/messages.ts
index cb0a8380c..3e65a1418 100644
--- a/packages/server/src/shared/messages.ts
+++ b/packages/server/src/shared/messages.ts
@@ -366,6 +366,7 @@ const AgentRuntimeInfoSchema: z.ZodType<AgentRuntimeInfo> = z.object({
   provider: AgentProviderSchema,
   sessionId: z.string().nullable(),
   model: z.string().nullable().optional(),
+  thinkingOptionId: z.string().nullable().optional(),
   modeId: z.string().nullable().optional(),
   extra: z.record(z.unknown()).optional(),
 })
@@ -376,6 +377,7 @@ export const AgentSnapshotPayloadSchema = z.object({
   cwd: z.string(),
   model: z.string().nullable(),
   thinkingOptionId: z.string().nullable().optional(),
+  effectiveThinkingOptionId: z.string().nullable().optional(),
   createdAt: z.string(),
   updatedAt: z.string(),
   lastUserMessageAt: z.string().nullable(),
@@ -426,6 +428,7 @@ const AgentDirectoryFilterSchema = z.object({
   statuses: z.array(AgentStatusSchema).optional(),
   includeArchived: z.boolean().optional(),
   requiresAttention: z.boolean().optional(),
+  thinkingOptionId: z.string().nullable().optional(),
 })
 
 export const DeleteAgentRequestMessageSchema = z.object({