From 0610f76ed4e57a47c3b8ca0221181105fe144e28 Mon Sep 17 00:00:00 2001
From: Brennan Benson <79079362+brennanb2025@users.noreply.github.com>
Date: Tue, 22 Sep 2026 17:20:29 -0700
Subject: [PATCH 01/67] fix(claude): open structured chat without a startup
 deadline, and make Retry start fresh

Publish the Claude session as soon as its process is spawned instead of racing
initialize against a fixed 10s deadline. Prompts sent before startup lands are
held and written in order once it does. An exit or sign-in failure before startup
ends the session with the reason and the CLI's stderr.

A create that failed because the process provably exited now carries
ownerVerdict 'exited', so the client marks the launch failed and Retry mints a
new operation instead of replaying the stored failure.
---
 .../claude-agent-sdk-control-requests.ts      |  38 ++--
 .../claude-stream-json-connection.test.ts     |  14 +-
 ...claude-structured-dispatch-test-support.ts |   4 +-
 src/main/claude/claude-structured-dispatch.ts |  36 +++-
 ...claude-structured-effort-reporting.test.ts |   4 +-
 .../claude/claude-structured-init-deadline.ts |  68 -------
 ...laude-structured-launch-resolution.test.ts |  35 +++-
 .../claude-structured-launch-resolution.ts    |  32 +++-
 ...aude-structured-model-confirmation.test.ts |   4 +-
 .../claude-structured-model-preflight.test.ts |   4 +-
 ...ude-structured-option-confirmation.test.ts |   4 +-
 .../claude/claude-structured-options.test.ts  |   4 +-
 src/main/claude/claude-structured-options.ts  |  15 ++
 .../claude-structured-prompt-ownership.ts     |   8 +-
 .../claude/claude-structured-real-cli.test.ts |  33 ++--
 ...ed-session-acquisition-processless.test.ts |   3 +-
 .../claude-structured-session-acquisition.ts  | 173 +++++++----------
 .../claude-structured-session-adapter.test.ts | 103 +++++-----
 .../claude-structured-session-adapter.ts      |  27 ++-
 .../claude/claude-structured-session-close.ts |  10 +-
 ...aude-structured-session-journal-control.ts |   6 +-
 .../claude-structured-session-options.ts      |  12 +-
 .../claude-structured-session-publication.ts  |  46 ++---
 ...structured-session-reading-control.test.ts |  22 ++-
 ...claude-structured-session-recovery.test.ts |   1 +
 .../claude-structured-session-startup-gate.ts | 145 ++++++++++++++
 .../claude-structured-session-startup.test.ts | 160 ++++++++++++++++
 .../claude-structured-session-startup.ts      | 179 ++++++++++++++++++
 .../claude/claude-structured-session-state.ts |   6 +-
 .../claude-structured-session-test-support.ts |  28 ++-
 .../structured-agent-session-adapter.ts       |   2 +
 .../structured-agent-session-attach-flow.ts   |  11 +-
 ...gent-session-dead-generation-settlement.ts |  28 ++-
 ...ession-failed-create-owner-verdict.test.ts | 116 ++++++++++++
 ...red-agent-session-failed-create-refusal.ts |  18 ++
 ...agent-session-startup-failure-exit.test.ts | 104 ++++++++++
 ...tructured-agent-session-unexpected-exit.ts |  20 +-
 ...gent-session-reservation-admission.test.ts |  45 +++++
 .../agent-session-reservation-admission.ts    |  11 +-
 ...ude-structured-session-integration.test.ts |  26 ++-
 .../structured-claude-runtime-adapter.ts      |   3 +-
 .../native-chat/NativeChatLaunchRetry.tsx     |   7 +-
 ...tructuredSession.launch-lifecycle.test.tsx |  16 ++
 ...tiveChatStructuredSession.test-harness.tsx |   5 +-
 .../NativeChatStructuredSession.tsx           |   1 +
 .../use-native-chat-provisional-launch.ts     |   3 +
 .../lib/launch-structured-agent-session.ts    |   5 +-
 ...-agent-session-launch-exited-owner.test.ts | 153 +++++++++++++++
 ...tructured-agent-session-launch-registry.ts |  25 +++
 .../lib/structured-agent-session-launch.ts    |   3 +
 .../agent-session-lease-adjudication.ts       |  14 ++
 src/shared/agent-session-wire-refusals.ts     |   6 +
 52 files changed, 1482 insertions(+), 364 deletions(-)
 delete mode 100644 src/main/claude/claude-structured-init-deadline.ts
 create mode 100644 src/main/claude/claude-structured-session-startup-gate.ts
 create mode 100644 src/main/claude/claude-structured-session-startup.test.ts
 create mode 100644 src/main/claude/claude-structured-session-startup.ts
 create mode 100644 src/main/native-chat/agent-session-wire/structured-agent-session-failed-create-owner-verdict.test.ts
 create mode 100644 src/main/native-chat/agent-session-wire/structured-agent-session-failed-create-refusal.ts
 create mode 100644 src/main/native-chat/agent-session-wire/structured-agent-session-startup-failure-exit.test.ts
 create mode 100644 src/renderer/src/lib/structured-agent-session-launch-exited-owner.test.ts

diff --git a/src/main/claude/claude-agent-sdk-control-requests.ts b/src/main/claude/claude-agent-sdk-control-requests.ts
index 71498f28421b..8ceb7a683814 100644
--- a/src/main/claude/claude-agent-sdk-control-requests.ts
+++ b/src/main/claude/claude-agent-sdk-control-requests.ts
@@ -46,33 +46,34 @@ export type ClaudeControlOptions = { timeoutMs?: number }
 /**
  * Run one native Query control method under Orca's deadline and error classification.
  *
- * The SDK owns correlation but applies no deadline, so the timeout stays here — and its
- * message is load-bearing: the init proof matches on `claude initialize request timed out`.
+ * The SDK owns correlation but applies no deadline, so the timeout stays here. `null` means
+ * none: the request then settles only on the CLI's answer or on the query closing under it.
  * A closed query is a transport failure, not the CLI rejecting the request, so only the
  * latter is re-thrown as a `ClaudeControlRequestError` a caller may surface as a rejection.
  */
 export function runClaudeControl<T>(
   subtype: string,
   run: () => Promise<T>,
-  timeoutMs: number = CLAUDE_DEFAULT_REQUEST_TIMEOUT_MS
+  timeoutMs: number | null = CLAUDE_DEFAULT_REQUEST_TIMEOUT_MS
 ): Promise<T> {
   let timer: ReturnType<typeof setTimeout> | null = null
+  const request = Promise.resolve()
+    .then(run)
+    .catch((error: unknown) => {
+      const message = error instanceof Error ? error.message : String(error)
+      if (error instanceof ClaudeControlRequestError || message === QUERY_CLOSED_MESSAGE) {
+        throw error
+      }
+      throw new ClaudeControlRequestError(subtype, message)
+    })
+  if (timeoutMs === null) {
+    return request
+  }
   const deadline = new Promise<never>((_resolve, reject) => {
     timer = setTimeout(() => reject(new Error(`claude ${subtype} request timed out`)), timeoutMs)
     timer.unref?.()
   })
-  return Promise.race([
-    Promise.resolve()
-      .then(run)
-      .catch((error: unknown) => {
-        const message = error instanceof Error ? error.message : String(error)
-        if (error instanceof ClaudeControlRequestError || message === QUERY_CLOSED_MESSAGE) {
-          throw error
-        }
-        throw new ClaudeControlRequestError(subtype, message)
-      }),
-    deadline
-  ]).finally(() => {
+  return Promise.race([request, deadline]).finally(() => {
     if (timer) {
       clearTimeout(timer)
     }
@@ -93,7 +94,8 @@ export type ClaudeControlSurface = {
   ) => Promise<void>
   stopTask: (taskId: string, options?: ClaudeControlOptions) => Promise<void>
   supportedModels: (options?: ClaudeControlOptions) => Promise<unknown[]>
-  initializationResult: (options?: ClaudeControlOptions) => Promise<unknown>
+  /** Untimed: a slow start is still a start, and the child's exit closes the query under it. */
+  initializationResult: () => Promise<unknown>
   getSettings: (options?: ClaudeControlOptions) => Promise<unknown>
 }
 
@@ -142,8 +144,8 @@ export function createClaudeControlSurface(query: Query): ClaudeControlSurface {
       ),
     supportedModels: (options) =>
       runClaudeControl('list_models', () => query.supportedModels(), options?.timeoutMs),
-    initializationResult: (options) =>
-      runClaudeControl('initialize', () => query.initializationResult(), options?.timeoutMs),
+    initializationResult: () =>
+      runClaudeControl('initialize', () => query.initializationResult(), null),
     getSettings: (options) => {
       const read = claudeQuerySettingsReader(query)
       return read
diff --git a/src/main/claude/claude-stream-json-connection.test.ts b/src/main/claude/claude-stream-json-connection.test.ts
index eb69a66a897d..15c4ac201834 100644
--- a/src/main/claude/claude-stream-json-connection.test.ts
+++ b/src/main/claude/claude-stream-json-connection.test.ts
@@ -501,10 +501,12 @@ describe('Claude stream-json connection', () => {
       }
     })
     const connection = await open(launchFor(scenario))
+    // oxlint-disable-next-line typescript/consistent-type-assertions -- SAFETY: the fixture supplies every session member the option paths under test read.
     const session = {
       connection,
       options: new Map<string, string>(),
-      reportedOptions: {}
+      reportedOptions: {},
+      startup: { state: 'proven' }
     } as unknown as ClaudeSession
 
     const options = await readClaudeStructuredSessionOptions(session, 5_000)
@@ -553,17 +555,15 @@ describe('Claude stream-json connection', () => {
     expect(JSON.stringify(diagnostic)).not.toContain('secret')
   })
 
-  it('reports an unauthenticated start through the init deadline instead of hanging', async () => {
-    // The scripted CLI never answers, which is the shape of a silently unauthenticated CLI.
-    const scenario = scriptScenario([HOLD_OPEN])
+  it('settles an unanswered initialize when the child exits, with no timer of its own', async () => {
+    // The scripted CLI never answers, then leaves: only its exit can settle the request.
+    const scenario = scriptScenario([{ stderr: 'claude: not signed in\n' }, { exit: 1 }])
     const connection = await open({
       ...launchFor(scenario),
       env: { ...launchFor(scenario).env, ORCA_SDK_CONTRACT_IGNORE_CONTROL_REQUESTS: '1' }
     })
 
-    await expect(connection.initializationResult({ timeoutMs: 200 })).rejects.toThrow(
-      'claude initialize request timed out'
-    )
+    await expect(connection.initializationResult()).rejects.toThrow()
   })
 
   it('reports a self-exit with its status, stderr, and observed tree verdict', async () => {
diff --git a/src/main/claude/claude-structured-dispatch-test-support.ts b/src/main/claude/claude-structured-dispatch-test-support.ts
index 83971a38d132..854d4be96203 100644
--- a/src/main/claude/claude-structured-dispatch-test-support.ts
+++ b/src/main/claude/claude-structured-dispatch-test-support.ts
@@ -4,6 +4,7 @@ import { retireClaudeDispatchWaiters } from './claude-structured-dispatch'
 import type { ClaudeSession } from './claude-structured-session-state'
 import { ClaudeBackgroundTaskTracker } from './claude-background-task-tracker'
 import { ClaudeSlashCommandCatalog } from './claude-slash-command-catalog'
+import { createClaudeSessionStartupGate } from './claude-structured-session-startup-gate'
 
 export function sessionFor(send: Mock = vi.fn().mockResolvedValue(undefined)): ClaudeSession {
   return {
@@ -28,7 +29,8 @@ export function sessionFor(send: Mock = vi.fn().mockResolvedValue(undefined)): C
     restoreSkippedOptions: new Set(),
     capabilities: [],
     events: undefined,
-    translator: null
+    translator: null,
+    startup: { ...createClaudeSessionStartupGate(), state: 'proven' }
   }
 }
 
diff --git a/src/main/claude/claude-structured-dispatch.ts b/src/main/claude/claude-structured-dispatch.ts
index 13d29ae9258f..05c152261912 100644
--- a/src/main/claude/claude-structured-dispatch.ts
+++ b/src/main/claude/claude-structured-dispatch.ts
@@ -33,6 +33,12 @@ import {
   claudeUserMessageWasProvablyUnwritten
 } from './claude-agent-sdk-user-message-queue'
 import { AgentSessionPreDispatchError } from '../native-chat/agent-session-wire/structured-agent-session-operation-settlement'
+import {
+  claudeStartupFailureReason,
+  claudeStartupHoldsWrites,
+  failClaudeStartupGate,
+  holdClaudeStartupWrite
+} from './claude-structured-session-startup-gate'
 
 const MAX_ACTIVE_DISPATCH_WAITERS = 64
 
@@ -220,6 +226,7 @@ export function settleCancelledClaudeDispatchWaiters(
  *  Retired rather than dropped: their identities stay joinable, bounded by
  *  `MAX_RETIRED_DISPATCH_WAITERS`. */
 export function retireClaudeDispatchWaiters(session: ClaudeSession): void {
+  failClaudeStartupGate(session, new Error('claude stream-json ended before startup completed'))
   for (const waiter of session.dispatchWaiters.splice(0)) {
     retireWaiter(session, waiter)
     waiter.resolve(null)
@@ -229,7 +236,8 @@ export function retireClaudeDispatchWaiters(session: ClaudeSession): void {
 export async function dispatchClaudeTurn(
   session: ClaudeSession,
   input: { clientMessageId?: string; body: AgentJournalMessageItem; requestedAt?: number },
-  beforeDispatch?: () => Promise<void>
+  beforeDispatch?: () => Promise<void>,
+  onSettledLate?: ClaudeLateDispatchSettlement
 ): Promise<AgentSessionDispatchOutcome> {
   let content: unknown[]
   try {
@@ -240,6 +248,10 @@ export async function dispatchClaudeTurn(
   if (session.dispatchWaiters.length >= MAX_ACTIVE_DISPATCH_WAITERS) {
     return { state: 'rejected', reason: DISPATCH_REJECTED_QUEUE_FULL }
   }
+  const startupFailure = claudeStartupFailureReason(session)
+  if (startupFailure) {
+    return { state: 'rejected', reason: startupFailure }
+  }
   // Read the sent content, not the journal blocks: only the mapped trailing prompt decides
   // whether Claude runs a command, so the two cannot disagree about which frame settles this.
   const acceptsResult = claudeDispatchInvokesSlashCommand(content)
@@ -255,6 +267,21 @@ export async function dispatchClaudeTurn(
       input.requestedAt ?? null
     )
   }
+  const message = {
+    type: 'user',
+    uuid: sentUuid,
+    message: { role: 'user', content },
+    parent_tool_use_id: null,
+    session_id: session.providerSessionId
+  }
+  if (claudeStartupHoldsWrites(session)) {
+    return holdClaudeStartupWrite(session, {
+      message,
+      arm,
+      ...(beforeDispatch ? { beforeDispatch } : {}),
+      ...(onSettledLate ? { settleLate: onSettledLate } : {})
+    })
+  }
   const pending = { replay: beforeDispatch ? undefined : arm() }
   const authorize = beforeDispatch
     ? async () => {
@@ -266,13 +293,6 @@ export async function dispatchClaudeTurn(
       }
     : undefined
   try {
-    const message = {
-      type: 'user',
-      uuid: sentUuid,
-      message: { role: 'user', content },
-      parent_tool_use_id: null,
-      session_id: session.providerSessionId
-    }
     await (authorize
       ? session.connection.send(message, authorize)
       : session.connection.send(message))
diff --git a/src/main/claude/claude-structured-effort-reporting.test.ts b/src/main/claude/claude-structured-effort-reporting.test.ts
index be022d869568..7cf59ee555bc 100644
--- a/src/main/claude/claude-structured-effort-reporting.test.ts
+++ b/src/main/claude/claude-structured-effort-reporting.test.ts
@@ -22,6 +22,7 @@ function sessionWith(
   listed?: { model: string; catalog: readonly Record<string, unknown>[] }
 ) {
   return {
+    // oxlint-disable-next-line typescript/consistent-type-assertions -- SAFETY: the fixture supplies every session member the option paths under test read.
     session: {
       options: new Map<string, string>(listed ? [['model', listed.model]] : []),
       reportedOptions: {} as { model?: string; effort?: string },
@@ -47,7 +48,8 @@ function sessionWith(
             ? { applied: {}, effective: {}, sources: {} }
             : { applied: { effort: reported }, effective: { effortLevel: reported }, sources: {} }
         }
-      }
+      },
+      startup: { state: 'proven' }
     } as unknown as ClaudeSession,
     calls
   }
diff --git a/src/main/claude/claude-structured-init-deadline.ts b/src/main/claude/claude-structured-init-deadline.ts
deleted file mode 100644
index f3acd6c3af98..000000000000
--- a/src/main/claude/claude-structured-init-deadline.ts
+++ /dev/null
@@ -1,68 +0,0 @@
-import type { ClaudeInitObservation } from './claude-structured-init-proof'
-import { claudeInitializationAuthError } from './claude-structured-init-proof'
-import type { ClaudeStreamJsonConnection } from './claude-stream-json-connection'
-import { AgentSessionAcquisitionRefusal } from '../native-chat/agent-session-wire/structured-agent-session-adapter'
-
-export type ClaudeInitDeadline = {
-  promise: Promise<ClaudeInitObservation>
-  resolve: (init: ClaudeInitObservation) => void
-  reject: (error: Error) => void
-  start: () => void
-  clear: () => void
-}
-
-export function claudeInitTimeoutError(
-  sessionId: string,
-  timeoutMs: number
-): AgentSessionAcquisitionRefusal {
-  return new AgentSessionAcquisitionRefusal(
-    `Claude did not finish starting session ${sessionId} within ${Math.ceil(timeoutMs / 1000)} seconds. Verify the selected Claude account is signed in and CLAUDE_CONFIG_DIR contains valid credentials, then retry; no SessionStart or system/init proof arrived.`
-  )
-}
-
-export async function requestClaudeInitialization(
-  connection: ClaudeStreamJsonConnection,
-  sessionId: string,
-  timeoutMs: number
-): Promise<unknown> {
-  try {
-    const result = await connection.initializationResult({ timeoutMs })
-    const authError = claudeInitializationAuthError(result)
-    if (authError) {
-      throw authError
-    }
-    return result
-  } catch (error) {
-    if (error instanceof Error && error.message === 'claude initialize request timed out') {
-      throw claudeInitTimeoutError(sessionId, timeoutMs)
-    }
-    throw error
-  }
-}
-
-export function createClaudeInitDeadline(sessionId: string, timeoutMs: number): ClaudeInitDeadline {
-  let resolve = (_init: ClaudeInitObservation): void => {}
-  let reject = (_error: Error): void => {}
-  const promise = new Promise<ClaudeInitObservation>((resolvePromise, rejectPromise) => {
-    resolve = resolvePromise
-    reject = rejectPromise
-  })
-  void promise.catch(() => {})
-  let timer: ReturnType<typeof setTimeout> | null = null
-
-  return {
-    promise,
-    resolve,
-    reject,
-    start: () => {
-      timer = setTimeout(() => reject(claudeInitTimeoutError(sessionId, timeoutMs)), timeoutMs)
-      timer.unref?.()
-    },
-    clear: () => {
-      if (timer) {
-        clearTimeout(timer)
-        timer = null
-      }
-    }
-  }
-}
diff --git a/src/main/claude/claude-structured-launch-resolution.test.ts b/src/main/claude/claude-structured-launch-resolution.test.ts
index 0ffa70d28622..fce3fd976426 100644
--- a/src/main/claude/claude-structured-launch-resolution.test.ts
+++ b/src/main/claude/claude-structured-launch-resolution.test.ts
@@ -1,7 +1,7 @@
 import { chmodSync, mkdtempSync, mkdirSync, writeFileSync } from 'node:fs'
 import { tmpdir } from 'node:os'
 import { delimiter, join } from 'node:path'
-import { describe, expect, it } from 'vitest'
+import { describe, expect, it, vi } from 'vitest'
 import type { AgentSessionRecord } from '../../shared/agent-session-record'
 import { LOCAL_EXECUTION_HOST_ID } from '../../shared/execution-host'
 import type { AgentSessionRecordStore } from '../runtime/agent-session-record-store'
@@ -58,7 +58,8 @@ function resolverFor(
   resolveEnv?: () => Record<string, string>,
   stripAuthEnv = false,
   // Manual by default so a test that is not about permissions is not silently about them.
-  agentDefaultArgs: Record<string, string> = { claude: '' }
+  agentDefaultArgs: Record<string, string> = { claude: '' },
+  hasTranscript: () => Promise<boolean> = async () => true
 ) {
   return createClaudeStructuredLaunchResolver({
     store: { getRecord: () => value } as unknown as AgentSessionRecordStore,
@@ -66,6 +67,7 @@ function resolverFor(
     resolveCommand: () => '/usr/local/bin/claude',
     resolveAuthPolicy: () => ({ stripAuthEnv }),
     resolvePermissionMode: () => claudeStructuredPermissionModeForSettings({ agentDefaultArgs }),
+    hasTranscript,
     ...(resolveEnv ? { resolveEnv } : {})
   })
 }
@@ -203,6 +205,35 @@ describe('claude structured launch resolution', () => {
     expect(launch.options.resumeSessionAt).toBeUndefined()
   })
 
+  it('launches a leafless head fresh under its own id when Claude never wrote its transcript', async () => {
+    // A start that failed before its first turn: `--resume` would exit "No conversation found".
+    const hasTranscript = vi.fn(async () => false)
+    const launch = await resolverFor(
+      record({
+        // oxlint-disable-next-line typescript/consistent-type-assertions -- SAFETY: the resolver reads only each link's handle.
+        providerHandleChain: [
+          { handle: { provider: 'claude', sessionId: 'provider-current', leafUuid: null } }
+        ] as AgentSessionRecord['providerHandleChain']
+      }),
+      undefined,
+      false,
+      { claude: '' },
+      hasTranscript
+    )({ identity: identityAt(null) })
+
+    expect(hasTranscript).toHaveBeenCalledWith({
+      providerSessionId: 'provider-current',
+      claudeConfigDir: expect.any(String)
+    })
+    expect(launch.options.resume).toBeUndefined()
+    expect(launch.options.sessionId).toBe('provider-current')
+    expect(launch).toMatchObject({
+      providerSessionId: 'provider-current',
+      resumeLeafUuid: null,
+      resumed: false
+    })
+  })
+
   // Agent Permissions is stored as the bypass flag inside the launch arguments, so presence of
   // that flag — not the whole string — is what Yolo means, exactly as a terminal launch reads it.
   it.each([
diff --git a/src/main/claude/claude-structured-launch-resolution.ts b/src/main/claude/claude-structured-launch-resolution.ts
index 2e1544ff9764..c0b110652cfe 100644
--- a/src/main/claude/claude-structured-launch-resolution.ts
+++ b/src/main/claude/claude-structured-launch-resolution.ts
@@ -1,4 +1,5 @@
 import { createHash } from 'node:crypto'
+import { join } from 'node:path'
 import type {
   Options as ClaudeAgentSdkOptions,
   PermissionMode
@@ -25,6 +26,7 @@ import {
   type ClaudeManagedAccountGateSettings
 } from '../native-chat/claude-structured-managed-account-support'
 import { resolveClaudeCommand } from '../codex-cli/command'
+import { resolveSessionFilePath } from '../native-chat/session-file-resolver'
 import type { AgentSessionRecordStore } from '../runtime/agent-session-record-store'
 
 export const CLAUDE_DEFAULT_SETTING_SOURCES = ['user', 'project', 'local'] as const
@@ -119,6 +121,21 @@ export type ClaudeStructuredLaunchResolverDeps = {
   authSwitchSettleTimeoutMs?: number
   /** Account state for the managed-account gate; null when it cannot be read, which refuses. */
   readManagedAccountGate?: () => ClaudeManagedAccountGateSettings | null
+  /** Whether Claude wrote a transcript for this id; defaults to the transcript resolver. */
+  hasTranscript?: (input: {
+    providerSessionId: string
+    claudeConfigDir: string
+  }) => Promise<boolean>
+}
+
+async function claudeTranscriptExists(input: {
+  providerSessionId: string
+  claudeConfigDir: string
+}): Promise<boolean> {
+  const path = await resolveSessionFilePath('claude', input.providerSessionId, {
+    claudeProjectsDir: join(input.claudeConfigDir, 'projects')
+  })
+  return path !== null
 }
 
 /**
@@ -192,6 +209,15 @@ export function createClaudeStructuredLaunchResolver(
       head?.handle.provider === 'claude'
         ? head.handle.sessionId
         : claudeSessionIdForOrcaSession(identity.sessionId)
+    // A start that failed before its first turn wrote no transcript, and `--resume` of an absent
+    // one exits; launch that id fresh instead. With a transcript, `--session-id` would collide.
+    const resumed =
+      head?.handle.provider === 'claude' &&
+      (head.handle.leafUuid !== null ||
+        (await (deps.hasTranscript ?? claudeTranscriptExists)({
+          providerSessionId,
+          claudeConfigDir: record.accountHome.path
+        })))
     // `record.launchArgs` is deliberately not read: the configured CLI arguments are a terminal
     // concern, and the permission mode they used to smuggle in is an owned provider option now.
     const permission = claudeStructuredPermissionOptions(
@@ -238,7 +264,7 @@ export function createClaudeStructuredLaunchResolver(
         ...CLAUDE_STRUCTURED_BASE_OPTIONS,
         ...permission,
         extraArgs: { ...CLAUDE_STRUCTURED_BASE_OPTIONS.extraArgs, ...permission.extraArgs },
-        ...(head?.handle.provider === 'claude'
+        ...(resumed && head?.handle.provider === 'claude'
           ? {
               resume: providerSessionId,
               ...(head.handle.leafUuid === null ? {} : { resumeSessionAt: head.handle.leafUuid })
@@ -249,8 +275,8 @@ export function createClaudeStructuredLaunchResolver(
       env,
       claudeConfigDir: record.accountHome.path,
       providerSessionId,
-      resumeLeafUuid: head?.handle.provider === 'claude' ? head.handle.leafUuid : null,
-      resumed: head?.handle.provider === 'claude'
+      resumeLeafUuid: resumed && head?.handle.provider === 'claude' ? head.handle.leafUuid : null,
+      resumed
     }
   }
 }
diff --git a/src/main/claude/claude-structured-model-confirmation.test.ts b/src/main/claude/claude-structured-model-confirmation.test.ts
index 7bd8f6291194..96d7e9daa391 100644
--- a/src/main/claude/claude-structured-model-confirmation.test.ts
+++ b/src/main/claude/claude-structured-model-confirmation.test.ts
@@ -168,6 +168,7 @@ describe('Claude effort the settings readback cannot report', () => {
     calls: string[] = []
   ): { session: ClaudeSession; calls: string[] } {
     return {
+      // oxlint-disable-next-line typescript/consistent-type-assertions -- SAFETY: the fixture supplies every session member the option paths under test read.
       session: {
         options: new Map<string, string>([['model', 'sonnet']]),
         reportedOptions: {},
@@ -189,7 +190,8 @@ describe('Claude effort the settings readback cannot report', () => {
               sources: {}
             }
           }
-        }
+        },
+        startup: { state: 'proven' }
       } as unknown as ClaudeSession,
       calls
     }
diff --git a/src/main/claude/claude-structured-model-preflight.test.ts b/src/main/claude/claude-structured-model-preflight.test.ts
index e4f5d00b1964..930947e112db 100644
--- a/src/main/claude/claude-structured-model-preflight.test.ts
+++ b/src/main/claude/claude-structured-model-preflight.test.ts
@@ -18,6 +18,7 @@ const HAIKU = {
 function sessionWith(catalog: readonly Record<string, unknown>[] | 'unavailable') {
   const calls: string[] = []
   return {
+    // oxlint-disable-next-line typescript/consistent-type-assertions -- SAFETY: the fixture supplies every session member the option paths under test read.
     session: {
       options: new Map<string, string>(),
       reportedOptions: {} as { model?: string; effort?: string },
@@ -36,7 +37,8 @@ function sessionWith(catalog: readonly Record<string, unknown>[] | 'unavailable'
         setModel: async (model: string) => {
           calls.push(`set_model:${model}`)
         }
-      }
+      },
+      startup: { state: 'proven' }
     } as unknown as ClaudeSession,
     calls
   }
diff --git a/src/main/claude/claude-structured-option-confirmation.test.ts b/src/main/claude/claude-structured-option-confirmation.test.ts
index ca7b8b70f1c8..d5ac5fd4d2dd 100644
--- a/src/main/claude/claude-structured-option-confirmation.test.ts
+++ b/src/main/claude/claude-structured-option-confirmation.test.ts
@@ -162,6 +162,7 @@ describe('confirmation never outlives the write it belongs to', () => {
   it('drops an earlier effort confirmation when the value changes', async () => {
     const calls: string[] = []
     let reported = 'low'
+    // oxlint-disable-next-line typescript/consistent-type-assertions -- SAFETY: the fixture supplies every session member the option paths under test read.
     const session = {
       options: new Map<string, string>([['model', 'sonnet']]),
       reportedOptions: {},
@@ -177,7 +178,8 @@ describe('confirmation never outlives the write it belongs to', () => {
           effective: { effortLevel: reported },
           sources: {}
         })
-      }
+      },
+      startup: { state: 'proven' }
     } as unknown as ClaudeSession
 
     await setClaudeStructuredOption(session, { key: 'effort', value: 'low' }, undefined)
diff --git a/src/main/claude/claude-structured-options.test.ts b/src/main/claude/claude-structured-options.test.ts
index 9b962fc33d71..6b994c8bb2cf 100644
--- a/src/main/claude/claude-structured-options.test.ts
+++ b/src/main/claude/claude-structured-options.test.ts
@@ -6,6 +6,7 @@ import {
 import type { ClaudeSession } from './claude-structured-session-state'
 import { ClaudeBackgroundTaskTracker } from './claude-background-task-tracker'
 import { ClaudeSlashCommandCatalog } from './claude-slash-command-catalog'
+import { createClaudeSessionStartupGate } from './claude-structured-session-startup-gate'
 import {
   observeClaudeFastModeFacts,
   readClaudeStructuredSessionOptions
@@ -39,7 +40,8 @@ function sessionFor(setModel: ClaudeSession['connection']['setModel']): ClaudeSe
     restoreSkippedOptions: new Set(),
     capabilities: [],
     events: undefined,
-    translator: null
+    translator: null,
+    startup: { ...createClaudeSessionStartupGate(), state: 'proven' }
   }
 }
 
diff --git a/src/main/claude/claude-structured-options.ts b/src/main/claude/claude-structured-options.ts
index c85e233cde12..0678ed97a63f 100644
--- a/src/main/claude/claude-structured-options.ts
+++ b/src/main/claude/claude-structured-options.ts
@@ -37,6 +37,21 @@ export function restoredClaudeStructuredSessionOptions(
   )
 }
 
+/** A client's write; the startup restore writes through `setClaudeStructuredOption` directly. */
+export function setClaudeStructuredSessionOption(
+  session: ClaudeSession,
+  input: { key: string; value: string },
+  timeoutMs: number | undefined
+): Promise<Readonly<Record<string, string>>> {
+  // Each write is a control request the CLI answers only after initialize.
+  if (session.startup.state !== 'proven') {
+    return Promise.reject(
+      new AgentSessionOptionRejectedError('Claude is still starting. Try again in a moment.')
+    )
+  }
+  return setClaudeStructuredOption(session, input, timeoutMs)
+}
+
 export async function setClaudeStructuredOption(
   session: ClaudeSession,
   input: { key: string; value: string },
diff --git a/src/main/claude/claude-structured-prompt-ownership.ts b/src/main/claude/claude-structured-prompt-ownership.ts
index 399dd98506ab..666281a6b1b4 100644
--- a/src/main/claude/claude-structured-prompt-ownership.ts
+++ b/src/main/claude/claude-structured-prompt-ownership.ts
@@ -11,8 +11,10 @@ import {
 } from './claude-structured-control-actions'
 import type { ClaudeLateDispatchSettlement } from './claude-structured-dispatch'
 import type { ClaudeSession } from './claude-structured-session-state'
+import { rejectClaudeStartupWrites } from './claude-structured-session-startup-gate'
+import { DISPATCH_REJECTED_CANCELLED } from '../../shared/structured-agent-session-dispatch-rejection'
 
-/** Conservative user-facing window: below the 10s init and 30s control deadlines, trading
+/** Conservative user-facing window: below the 30s control deadline, trading
  * residual slow-pump risk for ensuring delivery bookkeeping cannot block Stop indefinitely. */
 export const CLAUDE_DISPATCH_ADMISSION_TIMEOUT_MS = 3_000
 const CLAUDE_DISPATCH_ADMISSION_POLL_MS = 50
@@ -98,6 +100,10 @@ export async function cancelClaudeStructuredTurn(input: {
   const session = requireSession(sessions, request.sessionId)
   const acquisitionGeneration = session.acquisitionGeneration
   const prompt = request.prompt
+  // Nothing held before startup was written, so Stop withdraws it without an interrupt.
+  if (!prompt && session.startup.state === 'pending' && session.fence === request.fence) {
+    return { cancelled: rejectClaudeStartupWrites(session, DISPATCH_REJECTED_CANCELLED) }
+  }
   if (prompt && session.fence !== request.fence) {
     return { cancelled: false }
   }
diff --git a/src/main/claude/claude-structured-real-cli.test.ts b/src/main/claude/claude-structured-real-cli.test.ts
index cb3bb2b72ead..1b39237af04c 100644
--- a/src/main/claude/claude-structured-real-cli.test.ts
+++ b/src/main/claude/claude-structured-real-cli.test.ts
@@ -51,7 +51,7 @@ function realAdapter(
   events: ClaudeStructuredSessionEvent[] = [],
   cwd = process.cwd()
 ): ClaudeStructuredSessionAdapter {
-  return new ClaudeStructuredSessionAdapter({
+  const adapter = new ClaudeStructuredSessionAdapter({
     resolveLaunch: async () => ({
       pathToClaudeCodeExecutable: command,
       options: { ...CLAUDE_STRUCTURED_BASE_OPTIONS, sessionId: providerSessionId },
@@ -63,9 +63,16 @@ function realAdapter(
     }),
     onEvent: (event) => events.push(event),
     readProcessStartTime: async () => 1,
-    now: () => 2,
-    initTimeoutMs: 5_000
+    now: () => 2
   })
+  // These proofs read startup facts, which land after the session is published.
+  const acquire = adapter.acquire
+  adapter.acquire = async (input) => {
+    const acquisition = await acquire(input)
+    await adapter.drainStartup(input.identity.sessionId)
+    return acquisition
+  }
+  return adapter
 }
 
 function identity(providerSessionId: string): AgentSessionJournalIdentity {
@@ -297,16 +304,20 @@ describe.skipIf(!realClaudeAvailable)('Claude structured real CLI handshake', ()
   it('turns a real silent unauthenticated startup into sign-in guidance', async () => {
     const claudeConfigDir = await mkdtemp(join(tmpdir(), 'orca-claude-no-auth-'))
     const providerSessionId = randomUUID()
-    const adapter = realAdapter(providerSessionId, claudeConfigDir)
+    const events: ClaudeStructuredSessionEvent[] = []
+    const adapter = realAdapter(providerSessionId, claudeConfigDir, events)
 
     try {
-      await expect(
-        adapter.acquire({
-          identity: identity(providerSessionId),
-          fence: 1,
-          spawnToken: 'real-cli-no-auth'
-        })
-      ).rejects.toThrow(/not signed in.*Claude CLI.*CLAUDE_CONFIG_DIR/s)
+      await adapter.acquire({
+        identity: identity(providerSessionId),
+        fence: 1,
+        spawnToken: 'real-cli-no-auth'
+      })
+      await adapter.drainObservedExits()
+      expect(events.find((event) => event.type === 'ended')).toMatchObject({
+        reason: expect.stringMatching(/not signed in.*Claude CLI.*CLAUDE_CONFIG_DIR/s),
+        startupUnproven: true
+      })
     } finally {
       await adapter.closeAll()
       await rm(claudeConfigDir, { recursive: true, force: true })
diff --git a/src/main/claude/claude-structured-session-acquisition-processless.test.ts b/src/main/claude/claude-structured-session-acquisition-processless.test.ts
index 2c83dce18750..89b605fe9662 100644
--- a/src/main/claude/claude-structured-session-acquisition-processless.test.ts
+++ b/src/main/claude/claude-structured-session-acquisition-processless.test.ts
@@ -24,12 +24,13 @@ describe('Claude structured processless acquisition', () => {
       _launch,
       handlers = {}
     ) => {
+      // A failed spawn reports its error on a later tick, as child_process does.
+      setTimeout(() => handlers.onFault?.(fault), 0)
       const connection: ClaudeStreamJsonConnection = {
         pid: undefined,
         closed: true,
         exitVerdict: { root: 'processless', tree: 'exited' },
         initializationResult: async () => {
-          handlers.onFault?.(fault)
           throw fault
         },
         getSettings: async () => ({}),
diff --git a/src/main/claude/claude-structured-session-acquisition.ts b/src/main/claude/claude-structured-session-acquisition.ts
index a10a2dca671c..734d8f6ab5c6 100644
--- a/src/main/claude/claude-structured-session-acquisition.ts
+++ b/src/main/claude/claude-structured-session-acquisition.ts
@@ -9,31 +9,19 @@ import { isClaudeAuthSwitchInProgress } from '../claude-accounts/live-pty-gate'
 import { openClaudeStreamJsonConnection } from './claude-stream-json-connection'
 import { buildClaudePermissionCallbacks } from './claude-structured-inbound-control'
 import { resolveClaudeReplayTurn } from './claude-structured-dispatch'
-import {
-  claudeAuthDiagnostic,
-  readClaudeCapabilities,
-  readClaudeFrameString,
-  readClaudeInit,
-  readClaudeModels
-} from './claude-structured-init-proof'
-import {
-  createClaudeInitDeadline,
-  requestClaudeInitialization
-} from './claude-structured-init-deadline'
+import { readClaudeFrameString, readClaudeInit } from './claude-structured-init-proof'
 import { claudeConfigDirEnvPatch } from './claude-config-dir-pin'
 import { CLAUDE_SPAWN_TOKEN_ENV, claudeProcessIdentity } from './claude-structured-owner-identity'
-import { restoreClaudeStructuredSessionOptions } from './claude-structured-options'
 import { ClaudePromptRegistry } from './claude-structured-prompt-replies'
+import { restoredClaudeStructuredSessionOptions } from './claude-structured-options'
 import { createClaudeSessionJournalTranslator } from './claude-structured-journal-translation'
+import { observeClaudeFastModeFacts } from './claude-structured-session-options'
 import {
-  observeClaudeFastModeFacts,
-  readClaudeSettingsEffort
-} from './claude-structured-session-options'
-import {
-  claudeStructuredSessionPublicationOptions,
-  prepareClaudeStructuredSessionAcquisitionOptions,
-  readClaudeStructuredSessionSettings
-} from './claude-structured-session-acquisition-options'
+  createClaudeInitProof,
+  readClaudeStartupFacts,
+  settleClaudeSessionStartup,
+  type ClaudeStartupFacts
+} from './claude-structured-session-startup'
 import { createClaudeSessionPublication } from './claude-structured-session-publication'
 import {
   mintClaudeAcquisitionGeneration,
@@ -52,8 +40,6 @@ import {
   createClaudeJournalFailureHandler
 } from './claude-structured-session-journal-control'
 
-export const CLAUDE_STRUCTURED_INIT_TIMEOUT_MS = 10_000
-
 export async function acquireClaudeSession({
   input,
   deps,
@@ -83,13 +69,12 @@ export async function acquireClaudeSession({
     expectedProviderSessionId: string | null = null
   // Frames are admitted only after launch resolution proves the provider session
   // this acquisition owns. Keep the check ahead of every stateful consumer.
-  const initTimeoutMs = deps.initTimeoutMs ?? CLAUDE_STRUCTURED_INIT_TIMEOUT_MS
-  const initDeadline = createClaudeInitDeadline(sessionId, initTimeoutMs)
+  const initProof = createClaudeInitProof()
   const translator = createClaudeSessionJournalTranslator(
     input.events,
     prompts,
     String(input.fence),
-    createClaudeJournalFailureHandler({ attempt, initDeadline, callbacks, sessionId })
+    createClaudeJournalFailureHandler({ attempt, initProof, callbacks, sessionId })
   )
 
   const rewind = new ClaudeRewindAttempt(input.rewind, input.rewind?.onProved)
@@ -99,17 +84,17 @@ export async function acquireClaudeSession({
       // An init proof for another (or unnamed) provider must fail acquisition
       // promptly, while ordinary foreign frames stay quarantined silently.
       if (init || (message.type === 'system' && message.subtype === 'init')) {
-        initDeadline.reject(new Error('claude provider session expected'))
+        initProof.reject(new Error('claude provider session expected'))
       }
       return
     }
     const refusal = rewind.observe(message)
     if (refusal) {
-      initDeadline.reject(refusal)
+      initProof.reject(refusal)
       return
     }
     if (init) {
-      initDeadline.resolve(init)
+      initProof.resolve(init)
       // Every turn opens with an init frame naming the model the CLI is actually
       // running; set_model answers success for a model it never resolves, so this
       // report is the session's only adoption evidence.
@@ -189,15 +174,9 @@ export async function acquireClaudeSession({
           onMessage,
           canUseTool,
           onUserDialog,
-          onFault: (error) => {
-            if (!attempt.published) {
-              initDeadline.reject(error)
-            }
-          },
+          onFault: (error) => initProof.reject(error),
           onExit: (error) => {
-            if (!attempt.published) {
-              initDeadline.reject(error)
-            }
+            initProof.reject(error)
             callbacks.handleExit(sessionId, attempt, error)
           }
         }
@@ -206,44 +185,34 @@ export async function acquireClaudeSession({
     attempt.connection = connection
     unbindReadingControl = bindClaudeJournalReadingControl(input.events, connection, translator)
     acquisitions.assertCurrent(sessionId, attempt)
-    initDeadline.start()
-    const [initialization, init] = await withAgentSessionCreatePhase(
-      'init',
-      input.recordPhase,
-      () =>
-        Promise.all([
-          requestClaudeInitialization(connection, sessionId, initTimeoutMs),
-          initDeadline.promise
-        ])
-    )
-    const models = readClaudeModels(initialization)
-    callbacks.deliver(attempt, sessionId, () =>
-      callbacks.emit(liveSession, input.events, { type: 'options', sessionId, models })
-    )
-    initDeadline.clear()
-    acquisitions.assertCurrent(sessionId, attempt)
-    if (init.providerSessionId !== launch.providerSessionId) {
-      throw new Error(
-        `claude proved session ${init.providerSessionId}, expected ${launch.providerSessionId}`
-      )
-    }
-    const settings = await readClaudeStructuredSessionSettings(connection, deps.requestTimeoutMs)
-    const acquisitionOptions = prepareClaudeStructuredSessionAcquisitionOptions({
-      settings,
-      initialization,
-      inputOptions: input.options,
-      resumed: launch.resumed
-    })
-    callbacks.deliver(attempt, sessionId, () =>
-      callbacks.emit(liveSession, input.events, {
-        type: 'auth-diagnostic',
+    const emit = (event: Parameters<typeof callbacks.emit>[2]): void =>
+      callbacks.deliver(attempt, sessionId, () => callbacks.emit(liveSession, input.events, event))
+    const readFacts = (recordPhase?: typeof input.recordPhase): Promise<ClaudeStartupFacts> =>
+      readClaudeStartupFacts({
+        connection,
+        initProof,
         sessionId,
-        diagnostic: claudeAuthDiagnostic(init, settings)
+        providerSessionId: launch.providerSessionId,
+        resumed: launch.resumed,
+        inputOptions: input.options,
+        requestTimeoutMs: deps.requestTimeoutMs,
+        ...(recordPhase ? { recordPhase } : {}),
+        emit
       })
-    )
-    observedLeafUuid = (await rewind.prove(launch, deps)) ?? observedLeafUuid
-    observedLeafUuid =
-      (await proveClaudeRewindRecovery(input.rewindRecovery, launch, deps)) ?? observedLeafUuid
+    // A rewind publishes its target leaf as the durable cursor, so it alone stays unpublished
+    // until the CLI has proven the rewind; still untimed.
+    const proofBeforePublish = Boolean(input.rewind || input.rewindRecovery)
+    let facts: Promise<ClaudeStartupFacts> | null = null
+    if (proofBeforePublish) {
+      facts = Promise.resolve(await readFacts(input.recordPhase))
+      observedLeafUuid = (await rewind.prove(launch, deps)) ?? observedLeafUuid
+      observedLeafUuid =
+        (await proveClaudeRewindRecovery(input.rewindRecovery, launch, deps)) ?? observedLeafUuid
+    }
+    if (connection.pid === undefined) {
+      // A pid-less spawn always reports its error next; surface that, not the missing pid.
+      await initProof.promise
+    }
     const process = await claudeProcessIdentity(
       { ...input, pid: connection.pid },
       deps.readProcessStartTime
@@ -252,46 +221,42 @@ export async function acquireClaudeSession({
     if (connection.closed) {
       throw new Error(`claude stream-json for session ${sessionId} exited while being acquired`)
     }
-    const publication = await withAgentSessionCreatePhase('publish', input.recordPhase, async () =>
-      createClaudeSessionPublication({
-        connection,
-        init,
-        initialization,
-        claudeConfigDir: launch.claudeConfigDir,
-        leafUuid: observedLeafUuid,
-        fence: input.fence,
-        effort: readClaudeSettingsEffort(settings),
-        ...claudeStructuredSessionPublicationOptions(acquisitionOptions),
-        resumed: launch.resumed,
-        prompts,
-        translator,
-        events: input.events,
-        ...(unbindReadingControl ? { unbindReadingControl } : {}),
-        process,
-        acquisitionGeneration: mintClaudeAcquisitionGeneration(deps),
-        options: acquisitionOptions.options,
-        capabilities: readClaudeCapabilities(init, initialization),
-        ...(deps.mintLinkId ? { linkId: deps.mintLinkId() } : {}),
-        observedAt: deps.now?.() ?? Date.now()
-      })
-    )
-    const acquired: AgentSessionAcquisition = publication.acquisition
-    liveSession = publication.session
-    await withAgentSessionCreatePhase('restore_options', input.recordPhase, () =>
-      restoreClaudeStructuredSessionOptions(liveSession!, deps.requestTimeoutMs)
-    )
-    acquisitions.assertCurrent(sessionId, attempt)
+    const publication = createClaudeSessionPublication({
+      connection,
+      providerSessionId: launch.providerSessionId,
+      claudeConfigDir: launch.claudeConfigDir,
+      leafUuid: observedLeafUuid,
+      fence: input.fence,
+      resumed: launch.resumed,
+      prompts,
+      translator,
+      events: input.events,
+      ...(unbindReadingControl ? { unbindReadingControl } : {}),
+      process,
+      acquisitionGeneration: mintClaudeAcquisitionGeneration(deps),
+      options: restoredClaudeStructuredSessionOptions(input.options),
+      ...(deps.mintLinkId ? { linkId: deps.mintLinkId() } : {}),
+      observedAt: deps.now?.() ?? Date.now()
+    })
+    const session = publication.session
+    liveSession = session
     acquisitions.deleteIfCurrent(sessionId, attempt)
     await withAgentSessionCreatePhase('publish', input.recordPhase, async () => {
-      sessions.set(sessionId, liveSession!)
+      sessions.set(sessionId, session)
       attempt.published = true
       for (const event of attempt.buffered.splice(0)) {
         event()
       }
     })
-    return acquired
+    session.startup.settled = settleClaudeSessionStartup({
+      session,
+      facts: facts ?? readFacts(),
+      isCurrent: () => sessions.get(sessionId) === session,
+      requestTimeoutMs: deps.requestTimeoutMs,
+      fault: (error) => callbacks.handleExit(sessionId, attempt, error)
+    })
+    return publication.acquisition
   } catch (error) {
-    initDeadline.clear()
     unbindReadingControl?.()
     const acquisitionError = await resolveClaudeAcquisitionError({
       error,
diff --git a/src/main/claude/claude-structured-session-adapter.test.ts b/src/main/claude/claude-structured-session-adapter.test.ts
index c4fc4b7ff611..ebb7cd936059 100644
--- a/src/main/claude/claude-structured-session-adapter.test.ts
+++ b/src/main/claude/claude-structured-session-adapter.test.ts
@@ -3,17 +3,15 @@ import { join } from 'node:path'
 import { describe, expect, it, vi } from 'vitest'
 import {
   AgentSessionAcquisitionExitUnprovenError,
-  AgentSessionAcquisitionRefusal,
   AgentSessionAcquisitionRootExitObservedError
 } from '../native-chat/agent-session-wire/structured-agent-session-adapter'
 import type { ClaudeStreamJsonConnection } from './claude-stream-json-connection'
 import { ClaudeControlRequestError } from './claude-stream-json-connection'
 import { CLAUDE_SPAWN_TOKEN_ENV } from './claude-structured-owner-identity'
 import { encodeClaudeQuestionOptionId } from './claude-structured-prompt-replies'
-import {
-  CLAUDE_STRUCTURED_INIT_TIMEOUT_MS,
-  type ClaudeStructuredSessionAdapter,
-  type ClaudeStructuredSessionEvent
+import type {
+  ClaudeStructuredSessionAdapter,
+  ClaudeStructuredSessionEvent
 } from './claude-structured-session-adapter'
 import {
   acquired,
@@ -28,10 +26,6 @@ import {
 } from './claude-structured-session-test-support'
 
 describe('ClaudeStructuredSessionAdapter.acquire', () => {
-  it('finishes its startup deadline before the paired mobile request deadline', () => {
-    expect(CLAUDE_STRUCTURED_INIT_TIMEOUT_MS).toBeLessThan(30_000)
-  })
-
   it('pins the account and proves init without treating the system-frame uuid as a chain leaf', async () => {
     const claude = fakeClaude()
     const events: ClaudeStructuredSessionEvent[] = []
@@ -221,7 +215,6 @@ describe('ClaudeStructuredSessionAdapter.acquire', () => {
         }
       }
     })
-    const adapter = adapterFor(claude)
     const input = {
       identity: identityFor(),
       fence: 7,
@@ -229,7 +222,11 @@ describe('ClaudeStructuredSessionAdapter.acquire', () => {
       options: { model: 'temporarily-unavailable' }
     }
 
-    await expect(adapter.acquire(input)).rejects.toThrow('claude set_model request timed out')
+    // Restore runs after publish, so its failure ends the session rather than the create.
+    await expect(endedAtStartup(claude, input)).resolves.toMatchObject({
+      reason: 'claude set_model request timed out',
+      startupUnproven: true
+    })
     expect(claude.connections[0]?.closeCount).toBe(1)
   })
 
@@ -481,36 +478,22 @@ describe('ClaudeStructuredSessionAdapter.acquire', () => {
     })
 
     const wrongClaude = fakeClaude({ initSessionId: 'different-session' })
-    const wrong = adapterFor(wrongClaude)
-    await expect(
-      wrong.acquire({ identity: identityFor(), fence: 7, spawnToken: 'spawn-9' })
-    ).rejects.toThrow(/expected/)
+    await expect(endedAtStartup(wrongClaude)).resolves.toMatchObject({
+      reason: expect.stringMatching(/expected/),
+      startupUnproven: true
+    })
     expect(wrongClaude.connections[0].closeCount).toBe(1)
   })
 
-  it('surfaces a CLI startup failure instead of waiting for the init deadline', async () => {
+  it('ends the published session with the CLI startup failure, never a timer', async () => {
     const claude = fakeClaude({ exitBeforeInit: 'Claude login required' })
-    const adapter = adapterFor(claude)
-
-    await expect(
-      adapter.acquire({ identity: identityFor(), fence: 7, spawnToken: 'spawn-9' })
-    ).rejects.toThrow('Claude login required')
-    expect(claude.connections[0].closeCount).toBe(1)
-  })
 
-  it('closes a silent unauthenticated startup with actionable account guidance', async () => {
-    const claude = fakeClaude({ initProof: 'none' })
-    const adapter = adapterFor(claude, {}, [], [], 20)
-
-    const error = await adapter
-      .acquire({ identity: identityFor(), fence: 7, spawnToken: 'spawn-9' })
-      .catch((cause: unknown) => cause)
-
-    expect(error).toBeInstanceOf(AgentSessionAcquisitionRefusal)
-    expect(error).toMatchObject({
-      message: expect.stringMatching(/selected Claude account is signed in.*CLAUDE_CONFIG_DIR/s)
+    await expect(endedAtStartup(claude)).resolves.toMatchObject({
+      type: 'ended',
+      reason: 'Claude login required',
+      cause: 'unexpected-exit',
+      startupUnproven: true
     })
-    expect(claude.connections[0].calls[0]).toEqual({ subtype: 'initialize' })
     expect(claude.connections[0].closeCount).toBe(1)
   })
 
@@ -519,16 +502,42 @@ describe('ClaudeStructuredSessionAdapter.acquire', () => {
       initProof: 'session-start',
       initAccount: { apiProvider: 'firstParty', tokenSource: 'none' }
     })
-    const adapter = adapterFor(claude)
 
-    await expect(
-      adapter.acquire({ identity: identityFor(), fence: 7, spawnToken: 'spawn-9' })
-    ).rejects.toThrow(/not signed in.*Claude CLI.*CLAUDE_CONFIG_DIR/s)
+    await expect(endedAtStartup(claude)).resolves.toMatchObject({
+      reason: expect.stringMatching(/not signed in.*Claude CLI.*CLAUDE_CONFIG_DIR/s),
+      startupUnproven: true
+    })
     expect(claude.connections[0].closeCount).toBe(1)
   })
 })
 
+/** Acquires, then returns the `ended` event the startup failure published. */
+async function endedAtStartup(
+  claude: ReturnType<typeof fakeClaude>,
+  input: Parameters<ClaudeStructuredSessionAdapter['acquire']>[0] = {
+    identity: identityFor(),
+    fence: 7,
+    spawnToken: 'spawn-9'
+  },
+  launch: Parameters<typeof adapterFor>[1] = {}
+): Promise<ClaudeStructuredSessionEvent | undefined> {
+  const events: ClaudeStructuredSessionEvent[] = []
+  const adapter = adapterFor(claude, launch, events)
+  await adapter.acquire(input)
+  await adapter.drainObservedExits()
+  return events.find((event) => event.type === 'ended')
+}
+
 describe('ClaudeStructuredSessionAdapter acquisition cleanup', () => {
+  // Only a rewind still proves startup before publish, so it is the start that can fail here.
+  const kept = async (): Promise<string> => 'kept'
+  const rewind = {
+    targetUuid: 'kept',
+    previousLeafUuid: 'tip',
+    dropsTurn: 'drop',
+    onProved: async () => {}
+  }
+
   /** A start that fails after the child self-exited, with its close verdict scripted. */
   function failedStart(
     unprovenCloseVerdict: ClaudeStreamJsonConnection['exitVerdict']
@@ -537,8 +546,8 @@ describe('ClaudeStructuredSessionAdapter acquisition cleanup', () => {
       exitBeforeInit: 'claude stream-json exited (code 1): not logged in',
       unprovenCloseVerdict
     })
-    return adapterFor(claude)
-      .acquire({ identity: identityFor(), fence: 7, spawnToken: 'spawn-9' })
+    return adapterFor(claude, { resumed: true, resumeLeafUuid: 'tip' }, [], [], undefined, kept)
+      .acquire({ identity: identityFor(), fence: 7, spawnToken: 'spawn-9', rewind })
       .catch((error: unknown) => error)
   }
 
@@ -601,7 +610,15 @@ describe('ClaudeStructuredSessionAdapter acquisition cleanup', () => {
   it('forgets a retained exit once the session is acquired again', async () => {
     const options: Parameters<typeof fakeClaude>[0] = {}
     const claude = fakeClaude(options)
-    const adapter = await acquired(claude)
+    const adapter = adapterFor(
+      claude,
+      { resumed: true, resumeLeafUuid: 'tip' },
+      [],
+      [],
+      undefined,
+      kept
+    )
+    await adapter.acquire({ identity: identityFor(), fence: 7, spawnToken: 'spawn-9' })
     const first = claude.connections[0]
     first.handlers.onExit?.(new Error('claude stream-json exited (code 1): crashed'))
     first.exitVerdict = { root: 'exited', tree: 'unverifiable' }
@@ -609,7 +626,7 @@ describe('ClaudeStructuredSessionAdapter acquisition cleanup', () => {
     options.exitBeforeInit = 'claude stream-json exited (code 1): not logged in'
 
     await expect(
-      adapter.acquire({ identity: identityFor(), fence: 8, spawnToken: 'spawn-10' })
+      adapter.acquire({ identity: identityFor(), fence: 8, spawnToken: 'spawn-10', rewind })
     ).rejects.toThrow('not logged in')
     // The second start's own proven close is the answer; the first exit is stale.
     await expect(adapter.releaseAcquisition({ sessionId: 'session-1' })).resolves.toBe(true)
diff --git a/src/main/claude/claude-structured-session-adapter.ts b/src/main/claude/claude-structured-session-adapter.ts
index bfb34fa972a8..0f269144ecde 100644
--- a/src/main/claude/claude-structured-session-adapter.ts
+++ b/src/main/claude/claude-structured-session-adapter.ts
@@ -9,9 +9,9 @@ import { dispatchClaudeTurn } from './claude-structured-dispatch'
 import { StructuredSessionCompaction } from '../native-chat/agent-session-wire/structured-session-compaction'
 import { releaseClaudeAcquisition } from './claude-structured-acquisition-release'
 import { acquireClaudeSession } from './claude-structured-session-acquisition'
-export { CLAUDE_STRUCTURED_INIT_TIMEOUT_MS } from './claude-structured-session-acquisition'
+import { failClaudeStartupGate } from './claude-structured-session-startup-gate'
 import { supportsClaudeStructuredLocation } from './claude-structured-location-support'
-import { setClaudeStructuredOption } from './claude-structured-options'
+import { setClaudeStructuredSessionOption } from './claude-structured-options'
 import { readClaudeStructuredSessionOptions } from './claude-structured-session-options'
 import {
   ClaudeAcquisitionRegistry,
@@ -24,6 +24,7 @@ import {
 import {
   closeAllClaudeSessions,
   closeClaudeSession,
+  claudeRootExitObserved,
   settleClaudeExitedSession
 } from './claude-structured-session-close'
 import {
@@ -97,6 +98,7 @@ export class ClaudeStructuredSessionAdapter implements StructuredAgentSessionAda
       return
     }
     this.sessions.delete(sessionId)
+    failClaudeStartupGate(session, error)
     // Re-enter the provider's close ladder before publishing lifecycle recovery.
     // An exit callback is root evidence only; the retained tree proof must run
     // before the host releases and reacquires this exact child.
@@ -110,7 +112,9 @@ export class ClaudeStructuredSessionAdapter implements StructuredAgentSessionAda
     this.exits.set(sessionId, exit)
     exit.publication = closePromise
       .then((proven) => {
-        if (!proven) {
+        // A failed startup keeps the failed-create bar: a first-hand root exit releases it.
+        const startupFailed = session.startup.state === 'failed'
+        if (!proven && !(startupFailed && claudeRootExitObserved(session.connection))) {
           return undefined
         }
         return this.settleUnexpectedExit(sessionId, exit)
@@ -125,6 +129,10 @@ export class ClaudeStructuredSessionAdapter implements StructuredAgentSessionAda
    *  apart without guessing at wall-clock. */
   drainObservedExits = (): Promise<void> => drainClaudeObservedExits(this.exits)
 
+  /** Resolves once a published session's startup has landed or faulted it. */
+  drainStartup = (sessionId: string): Promise<void> =>
+    this.sessions.get(sessionId)?.startup.settled ?? Promise.resolve()
+
   /** Lifecycle recovery is published only after the child tree proof is true. */
   private settleUnexpectedExit(sessionId: string, exit: ClaudeSessionExit): Promise<void> {
     exit.settlementPromise ??= (async () => {
@@ -148,7 +156,8 @@ export class ClaudeStructuredSessionAdapter implements StructuredAgentSessionAda
         cause: 'unexpected-exit',
         fence: exit.session.fence,
         acquisitionGeneration: exit.session.acquisitionGeneration,
-        observedAt: this.deps.now?.() ?? Date.now()
+        observedAt: this.deps.now?.() ?? Date.now(),
+        ...(exit.session.startup.state === 'proven' ? {} : { startupUnproven: true })
       }
       try {
         this.emit(exit.session, ended)
@@ -206,7 +215,9 @@ export class ClaudeStructuredSessionAdapter implements StructuredAgentSessionAda
   }
 
   dispatch: StructuredAgentSessionAdapter['dispatch'] = (input) =>
-    dispatchClaudeTurn(this.session(input.sessionId), input, input.beforeDispatch)
+    dispatchClaudeTurn(this.session(input.sessionId), input, input.beforeDispatch, (settlement) =>
+      this.deps.onDispatchSettledLate?.({ sessionId: input.sessionId, ...settlement })
+    )
 
   compact: NonNullable<StructuredAgentSessionAdapter['compact']> = (input) =>
     compactClaudeSession(this.session(input.sessionId), this.compactions, input)
@@ -249,7 +260,11 @@ export class ClaudeStructuredSessionAdapter implements StructuredAgentSessionAda
   answerPrompt: StructuredAgentSessionAdapter['answerPrompt'] = (request) =>
     answerClaudeStructuredPrompt({ request, sessions: this.sessions })
   setOption: StructuredAgentSessionAdapter['setOption'] = (input) =>
-    setClaudeStructuredOption(this.session(input.sessionId), input, this.deps.requestTimeoutMs)
+    setClaudeStructuredSessionOption(
+      this.session(input.sessionId),
+      input,
+      this.deps.requestTimeoutMs
+    )
   readOptions = (input: { sessionId: string; fence: number }) =>
     readClaudeStructuredSessionOptions(this.session(input.sessionId), this.deps.requestTimeoutMs)
 
diff --git a/src/main/claude/claude-structured-session-close.ts b/src/main/claude/claude-structured-session-close.ts
index f6a58c36357e..4df67c440790 100644
--- a/src/main/claude/claude-structured-session-close.ts
+++ b/src/main/claude/claude-structured-session-close.ts
@@ -19,6 +19,14 @@ import { closeProcessRegistry } from '../../shared/child-process/close-process-r
 import { retireClaudeDispatchWaiters } from './claude-structured-dispatch'
 import { readClaudeTranscriptLeafWithReproof } from './claude-transcript-branch-proof'
 
+/** The root's own exit was seen first-hand; only its descendants went unverified. */
+export function claudeRootExitObserved(
+  connection: ClaudeStreamJsonConnection | null | undefined
+): boolean {
+  const verdict = connection?.exitVerdict
+  return verdict?.root === 'exited' && verdict.tree === 'unverifiable'
+}
+
 export function claudeAcquisitionCleanupError(
   connection: ClaudeStreamJsonConnection | null | undefined,
   cause: unknown
@@ -27,7 +35,7 @@ export function claudeAcquisitionCleanupError(
   if (verdict?.root === 'processless') {
     return new AgentSessionPreSpawnError(cause)
   }
-  return verdict?.root === 'exited' && verdict.tree === 'unverifiable'
+  return claudeRootExitObserved(connection)
     ? new AgentSessionAcquisitionRootExitObservedError(cause)
     : new AgentSessionAcquisitionExitUnprovenError(cause)
 }
diff --git a/src/main/claude/claude-structured-session-journal-control.ts b/src/main/claude/claude-structured-session-journal-control.ts
index dc8a5c9d262a..5517457904d4 100644
--- a/src/main/claude/claude-structured-session-journal-control.ts
+++ b/src/main/claude/claude-structured-session-journal-control.ts
@@ -1,7 +1,7 @@
 import type { StructuredAgentSessionEventSink } from '../native-chat/agent-session-wire/structured-agent-session-event-sink'
 import type { ClaudeStreamJsonConnection } from './claude-stream-json-connection'
 import type { ClaudeJournalTranslator } from './claude-structured-journal-translation'
-import type { createClaudeInitDeadline } from './claude-structured-init-deadline'
+import type { ClaudeInitProof } from './claude-structured-session-startup'
 import type {
   ClaudeAcquisitionAttempt,
   ClaudeAcquireCallbacks
@@ -9,13 +9,13 @@ import type {
 
 export function createClaudeJournalFailureHandler(input: {
   attempt: ClaudeAcquisitionAttempt
-  initDeadline: ReturnType<typeof createClaudeInitDeadline>
+  initProof: ClaudeInitProof
   callbacks: ClaudeAcquireCallbacks
   sessionId: string
 }): (error: Error) => void {
   return (error) => {
     if (!input.attempt.published) {
-      input.initDeadline.reject(error)
+      input.initProof.reject(error)
       return
     }
     const connection = input.attempt.connection
diff --git a/src/main/claude/claude-structured-session-options.ts b/src/main/claude/claude-structured-session-options.ts
index 4ad95223dec2..abedc62966ef 100644
--- a/src/main/claude/claude-structured-session-options.ts
+++ b/src/main/claude/claude-structured-session-options.ts
@@ -202,10 +202,14 @@ export async function readClaudeStructuredSessionOptions(
   timeoutMs: number | undefined
 ): Promise<AgentSessionOptionsResult> {
   const readMutationSequence = session.optionMutationSequence
-  const [catalog, settings] = await Promise.all([
-    session.connection.supportedModels({ timeoutMs }).catch(() => null),
-    session.connection.getSettings({ timeoutMs }).catch(() => null)
-  ])
+  // Before startup both requests would wait on initialize; answer from the saved options.
+  const [catalog, settings] =
+    session.startup.state === 'proven'
+      ? await Promise.all([
+          session.connection.supportedModels({ timeoutMs }).catch(() => null),
+          session.connection.getSettings({ timeoutMs }).catch(() => null)
+        ])
+      : [null, null]
   if (settings !== null && readMutationSequence === session.optionMutationSequence) {
     const effort = readClaudeSettingsEffort(settings)
     const fastMode = readClaudeSettingsFastMode(settings)
diff --git a/src/main/claude/claude-structured-session-publication.ts b/src/main/claude/claude-structured-session-publication.ts
index 2434f5226613..a6a035c3f848 100644
--- a/src/main/claude/claude-structured-session-publication.ts
+++ b/src/main/claude/claude-structured-session-publication.ts
@@ -1,16 +1,16 @@
 import type { AgentSessionAcquisition } from '../native-chat/agent-session-wire/structured-agent-session-adapter'
-import type { ClaudeInitObservation } from './claude-structured-init-proof'
 import { claudeProviderHandleLink } from './claude-structured-owner-identity'
 import type { ClaudePromptRegistry } from './claude-structured-prompt-replies'
 import type { ClaudeJournalTranslator } from './claude-structured-journal-translation'
 import type { ClaudeSession } from './claude-structured-session-state'
 import { ClaudeBackgroundTaskTracker } from './claude-background-task-tracker'
 import { ClaudeSlashCommandCatalog } from './claude-slash-command-catalog'
+import { createClaudeSessionStartupGate } from './claude-structured-session-startup-gate'
 
+/** The session as published at spawn: nothing the CLI reports at init is assumed yet. */
 export function createClaudeSessionPublication(input: {
   connection: ClaudeSession['connection']
-  init: ClaudeInitObservation
-  initialization?: unknown
+  providerSessionId: string
   claudeConfigDir: string
   leafUuid: string | null
   fence: number
@@ -24,22 +24,12 @@ export function createClaudeSessionPublication(input: {
   linkId?: string
   observedAt: number
   options?: ReadonlyMap<string, string>
-  capabilities: readonly string[]
-  /** Read from `get_settings`; `system/init` never reports an effort. */
-  effort: string | null
-  fastMode: boolean | null
-  fastModePerSessionOptIn: boolean | null
-  fastModeState?: ClaudeSession['fastModeState']
-  fastModeDisabledReason?: string
 }): { acquisition: AgentSessionAcquisition; session: ClaudeSession } {
-  const model = input.init.model
-  const effort = input.effort
-  const fastMode = input.fastMode
   return {
     acquisition: {
       process: input.process,
       link: claudeProviderHandleLink({
-        sessionId: input.init.providerSessionId,
+        sessionId: input.providerSessionId,
         leafUuid: input.leafUuid,
         resumed: input.resumed,
         fence: input.fence,
@@ -50,7 +40,7 @@ export function createClaudeSessionPublication(input: {
     },
     session: {
       connection: input.connection,
-      providerSessionId: input.init.providerSessionId,
+      providerSessionId: input.providerSessionId,
       claudeConfigDir: input.claudeConfigDir,
       leafUuid: input.leafUuid,
       fence: input.fence,
@@ -60,32 +50,20 @@ export function createClaudeSessionPublication(input: {
       retiredDispatchWaiters: [],
       replayContentFallbackBlocked: false,
       backgroundTasks: new ClaudeBackgroundTaskTracker(),
-      commands: new ClaudeSlashCommandCatalog(input.init.message, input.initialization),
+      // Undefined until init: an unread catalog is unavailable, not empty.
+      commands: new ClaudeSlashCommandCatalog(),
       dispatchSequence: 0,
       optionMutationSequence: 0,
       options: new Map(input.options),
-      capabilities: input.capabilities,
-      reportedOptions: {
-        ...(model ? { model } : {}),
-        ...(effort ? { effort } : {}),
-        ...(fastMode !== null ? { fastMode } : {})
-      },
-      ...(input.fastModeState ? { fastModeState: input.fastModeState } : {}),
-      ...(input.fastModeDisabledReason
-        ? { fastModeDisabledReason: input.fastModeDisabledReason }
-        : {}),
-      ...(input.fastModePerSessionOptIn !== null
-        ? { fastModePerSessionOptIn: input.fastModePerSessionOptIn }
-        : {}),
+      capabilities: [],
+      reportedOptions: {},
       reportedModelMutation: 0,
-      confirmedOptions: new Set([
-        ...(effort ? ['effort'] : []),
-        ...(fastMode !== null ? ['fastMode'] : [])
-      ]),
+      confirmedOptions: new Set(),
       restoreSkippedOptions: new Set(),
       translator: input.translator,
       events: input.events,
-      ...(input.unbindReadingControl ? { unbindReadingControl: input.unbindReadingControl } : {})
+      ...(input.unbindReadingControl ? { unbindReadingControl: input.unbindReadingControl } : {}),
+      startup: createClaudeSessionStartupGate()
     }
   }
 }
diff --git a/src/main/claude/claude-structured-session-reading-control.test.ts b/src/main/claude/claude-structured-session-reading-control.test.ts
index 7113abd5bf5e..c9cec7996a28 100644
--- a/src/main/claude/claude-structured-session-reading-control.test.ts
+++ b/src/main/claude/claude-structured-session-reading-control.test.ts
@@ -89,8 +89,16 @@ describe('Claude structured reading control', () => {
   })
 
   it('unbinds when acquisition fails after the connection opens', async () => {
-    const claude = fakeClaude({ initProof: 'none' })
-    const adapter = adapterFor(claude, {}, [], [], 1)
+    // A rewind proves startup before publish, so it is the acquisition that can still fail.
+    const claude = fakeClaude({ exitBeforeInit: 'claude stream-json exited (code 1)' })
+    const adapter = adapterFor(
+      claude,
+      { resumed: true, resumeLeafUuid: 'tip' },
+      [],
+      [],
+      undefined,
+      async () => 'kept'
+    )
     const events = controlledSink()
 
     await expect(
@@ -98,9 +106,15 @@ describe('Claude structured reading control', () => {
         identity: identityFor(),
         fence: 7,
         spawnToken: 'spawn-9',
-        events: events.sink
+        events: events.sink,
+        rewind: {
+          targetUuid: 'kept',
+          previousLeafUuid: 'tip',
+          dropsTurn: 'drop',
+          onProved: async () => {}
+        }
       })
-    ).rejects.toThrow('did not finish starting')
+    ).rejects.toThrow('exited (code 1)')
     expect(events.unbind).toHaveBeenCalledOnce()
   })
 
diff --git a/src/main/claude/claude-structured-session-recovery.test.ts b/src/main/claude/claude-structured-session-recovery.test.ts
index bd8f8cb40b29..0675d8c0acf7 100644
--- a/src/main/claude/claude-structured-session-recovery.test.ts
+++ b/src/main/claude/claude-structured-session-recovery.test.ts
@@ -513,6 +513,7 @@ describe('ClaudeStructuredSessionAdapter transcript-derived recovery', () => {
       spawnToken: 'spawn-9',
       events: journalSink
     })
+    await adapter.drainStartup('session-1')
     const first = claude.connections[0]
     const oldPrompt = invokeCanUseTool(first, 'Bash', 'permission-retained', 'tool-retained')
     const oldSession = (
diff --git a/src/main/claude/claude-structured-session-startup-gate.ts b/src/main/claude/claude-structured-session-startup-gate.ts
new file mode 100644
index 000000000000..e8739f933dd1
--- /dev/null
+++ b/src/main/claude/claude-structured-session-startup-gate.ts
@@ -0,0 +1,145 @@
+// A Claude session is published once its child is spawned, before the CLI has answered
+// initialize. Prompts sent in that window are held here and written, in order, once startup
+// lands (init facts read and saved options restored), so a first turn never runs under
+// defaults the restore was about to replace. A held prompt was never written, so a startup
+// that fails rejects it rather than leaving its delivery in doubt.
+
+import type { AgentSessionDispatchOutcome } from '../native-chat/agent-session-wire/structured-agent-session-adapter'
+import { AgentSessionPreDispatchError } from '../native-chat/agent-session-wire/structured-agent-session-operation-settlement'
+import { dispatchWriteFailureReason } from '../../shared/structured-agent-session-dispatch-rejection'
+import { claudeUserMessageWasProvablyUnwritten } from './claude-agent-sdk-user-message-queue'
+import {
+  forgetRetiredWaiter,
+  forgetWaiter,
+  retireWaiter
+} from './claude-structured-dispatch-waiters'
+import type {
+  ClaudeDispatchWaiter,
+  ClaudeLateDispatchOutcome,
+  ClaudeSession
+} from './claude-structured-session-state'
+
+type ClaudeStartupHeldWrite = {
+  waiter: ClaudeDispatchWaiter
+  message: Record<string, unknown>
+  settleLate?: (outcome: ClaudeLateDispatchOutcome) => void
+}
+
+export type ClaudeSessionStartupGate = {
+  state: 'pending' | 'proven' | 'failed'
+  held: ClaudeStartupHeldWrite[]
+  /** Held prompts are still being written; later prompts must queue behind them. */
+  draining: boolean
+  failure: Error | null
+  /** Resolves once startup has landed or faulted the session; never rejects. */
+  settled: Promise<void>
+}
+
+export function createClaudeSessionStartupGate(): ClaudeSessionStartupGate {
+  return { state: 'pending', held: [], draining: false, failure: null, settled: Promise.resolve() }
+}
+
+export function claudeStartupFailureReason(session: ClaudeSession): string | null {
+  return session.startup.state === 'failed'
+    ? dispatchWriteFailureReason(session.startup.failure ?? new Error('claude startup failed'))
+    : null
+}
+
+export function claudeStartupHoldsWrites(session: ClaudeSession): boolean {
+  return session.startup.state === 'pending' || session.startup.draining
+}
+
+/** Admits a prompt while startup is pending; it is written when `openClaudeStartupGate` runs. */
+export async function holdClaudeStartupWrite(
+  session: ClaudeSession,
+  input: {
+    message: Record<string, unknown>
+    arm: () => { waiter: ClaudeDispatchWaiter }
+    beforeDispatch?: () => Promise<void>
+    settleLate?: (outcome: ClaudeLateDispatchOutcome) => void
+  }
+): Promise<AgentSessionDispatchOutcome> {
+  if (input.beforeDispatch) {
+    try {
+      await input.beforeDispatch()
+    } catch (error) {
+      if (error instanceof AgentSessionPreDispatchError) {
+        throw error
+      }
+      return { state: 'rejected', reason: dispatchWriteFailureReason(error) }
+    }
+  }
+  // Startup may have failed while the admission barrier ran.
+  const failed = claudeStartupFailureReason(session)
+  if (failed) {
+    return { state: 'rejected', reason: failed }
+  }
+  const { waiter } = input.arm()
+  session.startup.held.push({
+    waiter,
+    message: input.message,
+    ...(input.settleLate ? { settleLate: input.settleLate } : {})
+  })
+  return { state: 'admitted' }
+}
+
+export async function openClaudeStartupGate(session: ClaudeSession): Promise<void> {
+  const gate = session.startup
+  if (gate.state !== 'pending') {
+    return
+  }
+  gate.state = 'proven'
+  gate.draining = true
+  try {
+    for (let held = gate.held.shift(); held; held = gate.held.shift()) {
+      await writeHeld(session, held)
+    }
+  } finally {
+    gate.draining = false
+  }
+}
+
+async function writeHeld(session: ClaudeSession, held: ClaudeStartupHeldWrite): Promise<void> {
+  try {
+    await session.connection.send(held.message)
+  } catch (error) {
+    if (held.waiter.settledUuid) {
+      return
+    }
+    if (claudeUserMessageWasProvablyUnwritten(error)) {
+      rejectHeld(session, held, dispatchWriteFailureReason(error))
+      return
+    }
+    // Possibly written: only a replay or the child's exit can settle it now.
+    retireWaiter(session, held.waiter)
+    held.waiter.resolve(null)
+  }
+}
+
+function rejectHeld(session: ClaudeSession, held: ClaudeStartupHeldWrite, reason: string): void {
+  forgetWaiter(session, held.waiter)
+  forgetRetiredWaiter(session, held.waiter)
+  held.waiter.resolve(null)
+  if (held.waiter.clientMessageId) {
+    held.settleLate?.({ clientMessageId: held.waiter.clientMessageId, state: 'rejected', reason })
+  }
+}
+
+/** Rejects every held prompt with `reason`; true when any was held. */
+export function rejectClaudeStartupWrites(session: ClaudeSession, reason: string): boolean {
+  const held = session.startup.held.splice(0)
+  for (const entry of held) {
+    rejectHeld(session, entry, reason)
+  }
+  return held.length > 0
+}
+
+/** Startup cannot land any more; nothing held was written, so all of it is rejected. */
+export function failClaudeStartupGate(session: ClaudeSession, error: Error): void {
+  const gate = session.startup
+  if (gate.state === 'pending') {
+    gate.state = 'failed'
+    gate.failure = error
+  }
+  rejectClaudeStartupWrites(session, dispatchWriteFailureReason(error))
+}
diff --git a/src/main/claude/claude-structured-session-startup.test.ts b/src/main/claude/claude-structured-session-startup.test.ts
new file mode 100644
index 000000000000..184716a978b9
--- /dev/null
+++ b/src/main/claude/claude-structured-session-startup.test.ts
@@ -0,0 +1,160 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+import type { ClaudeStructuredSessionAdapterDeps } from './claude-structured-session-adapter'
+import type { ClaudeStructuredSessionEvent } from './claude-structured-session-state'
+import {
+  adapterAtPublishFor,
+  fakeClaude,
+  identityFor,
+  USER_MESSAGE
+} from './claude-structured-session-test-support'
+
+type LateSettlement = Parameters<
+  NonNullable<ClaudeStructuredSessionAdapterDeps['onDispatchSettledLate']>
+>[0]
+
+const SLOW_INIT_MS = 12_000
+
+function startingAdapter(claude: ReturnType<typeof fakeClaude>): {
+  adapter: ReturnType<typeof adapterAtPublishFor>
+  events: ClaudeStructuredSessionEvent[]
+  late: LateSettlement[]
+} {
+  const events: ClaudeStructuredSessionEvent[] = []
+  const late: LateSettlement[] = []
+  const adapter = adapterAtPublishFor(
+    claude,
+    {},
+    events,
+    [],
+    undefined,
+    undefined,
+    undefined,
+    undefined,
+    (settlement) => late.push(settlement)
+  )
+  return { adapter, events, late }
+}
+
+const ACQUIRE = { identity: identityFor(), fence: 7, spawnToken: 'spawn-9' }
+const PROMPT = { sessionId: 'session-1', clientMessageId: 'client-1', body: USER_MESSAGE, fence: 7 }
+
+describe('Claude structured session publishes before the CLI answers initialize', () => {
+  beforeEach(() => {
+    vi.useFakeTimers()
+  })
+  afterEach(() => {
+    vi.useRealTimers()
+  })
+
+  it('creates a session whose init takes longer than any old deadline, then reports its facts', async () => {
+    const claude = fakeClaude({ initDelayMs: SLOW_INIT_MS })
+    const { adapter, events } = startingAdapter(claude)
+
+    await expect(adapter.acquire(ACQUIRE)).resolves.toBeDefined()
+    expect(events.some((event) => event.type === 'options')).toBe(false)
+    expect(adapter.readCommands('session-1')).toBeUndefined()
+
+    await vi.advanceTimersByTimeAsync(SLOW_INIT_MS)
+    await adapter.drainStartup('session-1')
+
+    expect(events.find((event) => event.type === 'options')).toMatchObject({
+      models: [{ value: 'claude-sonnet' }]
+    })
+    expect(events.some((event) => event.type === 'ended')).toBe(false)
+    expect(claude.connections[0].closeCount).toBe(0)
+    await adapter.closeAll()
+  })
+
+  it('holds a prompt sent before init and writes it once startup lands', async () => {
+    const claude = fakeClaude({ initDelayMs: SLOW_INIT_MS })
+    const { adapter } = startingAdapter(claude)
+    await adapter.acquire(ACQUIRE)
+
+    await expect(adapter.dispatch(PROMPT)).resolves.toEqual({ state: 'admitted' })
+    expect(claude.connections[0].sent).toEqual([])
+
+    await vi.advanceTimersByTimeAsync(SLOW_INIT_MS)
+    await adapter.drainStartup('session-1')
+
+    expect(claude.connections[0].sent).toHaveLength(1)
+    expect(claude.connections[0].sent[0]).toMatchObject({ type: 'user' })
+    await adapter.closeAll()
+  })
+
+  it('ends the session with the exit reason when the CLI dies before init, and rejects held prompts', async () => {
+    const claude = fakeClaude({
+      initDelayMs: SLOW_INIT_MS,
+      exitBeforeInit: 'claude stream-json exited (code 1): stderr says no'
+    })
+    const { adapter, events, late } = startingAdapter(claude)
+    await adapter.acquire(ACQUIRE)
+    await adapter.dispatch(PROMPT)
+
+    await vi.advanceTimersByTimeAsync(SLOW_INIT_MS)
+    await adapter.drainStartup('session-1')
+    await adapter.drainObservedExits()
+
+    expect(events.find((event) => event.type === 'ended')).toMatchObject({
+      reason: 'claude stream-json exited (code 1): stderr says no',
+      cause: 'unexpected-exit',
+      startupUnproven: true
+    })
+    expect(late).toEqual([
+      expect.objectContaining({ clientMessageId: 'client-1', state: 'rejected' })
+    ])
+    expect(claude.connections[0].sent).toEqual([])
+    expect(claude.connections[0].closeCount).toBe(1)
+  })
+
+  it('ends an unauthenticated start with sign-in guidance', async () => {
+    const claude = fakeClaude({ initAccount: { apiProvider: 'firstParty', tokenSource: 'none' } })
+    const { adapter, events } = startingAdapter(claude)
+    await adapter.acquire(ACQUIRE)
+    await adapter.drainStartup('session-1')
+    await adapter.drainObservedExits()
+
+    expect(events.find((event) => event.type === 'ended')).toMatchObject({
+      reason: expect.stringMatching(/not signed in/),
+      startupUnproven: true
+    })
+  })
+
+  it('closes a session stopped before init without faulting it or writing held prompts', async () => {
+    const claude = fakeClaude({ initDelayMs: SLOW_INIT_MS })
+    const { adapter, events, late } = startingAdapter(claude)
+    await adapter.acquire(ACQUIRE)
+    await adapter.dispatch(PROMPT)
+
+    await expect(adapter.closeSession('session-1')).resolves.toBe(true)
+    await vi.advanceTimersByTimeAsync(SLOW_INIT_MS)
+    await adapter.drainStartup('session-1')
+
+    const connection = claude.connections[0]
+    expect(connection.closeCount).toBe(1)
+    expect(connection.sent).toEqual([])
+    expect(connection.calls.map(({ subtype }) => subtype)).not.toContain('get_settings')
+    expect(late).toEqual([
+      expect.objectContaining({ clientMessageId: 'client-1', state: 'rejected' })
+    ])
+    expect(events.some((event) => event.type === 'ended' && event.startupUnproven)).toBe(false)
+  })
+
+  it('withdraws a held prompt when the turn is cancelled before init', async () => {
+    const claude = fakeClaude({ initDelayMs: SLOW_INIT_MS })
+    const { adapter, late } = startingAdapter(claude)
+    await adapter.acquire(ACQUIRE)
+    await adapter.dispatch(PROMPT)
+
+    await expect(
+      adapter.cancelTurn({ sessionId: 'session-1', turnId: 'turn-1', fence: 7 })
+    ).resolves.toEqual({ cancelled: true })
+    await vi.advanceTimersByTimeAsync(SLOW_INIT_MS)
+    await adapter.drainStartup('session-1')
+
+    expect(claude.connections[0].sent).toEqual([])
+    expect(late).toEqual([
+      expect.objectContaining({ clientMessageId: 'client-1', state: 'rejected' })
+    ])
+    await adapter.closeAll()
+  })
+})
diff --git a/src/main/claude/claude-structured-session-startup.ts b/src/main/claude/claude-structured-session-startup.ts
new file mode 100644
index 000000000000..be0d9bb4bc55
--- /dev/null
+++ b/src/main/claude/claude-structured-session-startup.ts
@@ -0,0 +1,179 @@
+// What Claude reports at initialize, read after the session is already published. None of it
+// gates the create: a slow start is still a start, and every way it can fail (exit, auth,
+// a foreign session id, a rewind refusal) faults the published session through its exit path.
+
+import type { StructuredAgentSessionAcquireInput } from '../native-chat/agent-session-wire/structured-agent-session-adapter'
+import { withAgentSessionCreatePhase } from '../observability/agent-session-instrumentation'
+import type { ClaudeStreamJsonConnection } from './claude-stream-json-connection'
+import { ClaudeSlashCommandCatalog } from './claude-slash-command-catalog'
+import {
+  claudeAuthDiagnostic,
+  claudeInitializationAuthError,
+  readClaudeCapabilities,
+  readClaudeModels,
+  type ClaudeInitObservation
+} from './claude-structured-init-proof'
+import { restoreClaudeStructuredSessionOptions } from './claude-structured-options'
+import {
+  claudeStructuredSessionPublicationOptions,
+  prepareClaudeStructuredSessionAcquisitionOptions,
+  readClaudeStructuredSessionSettings
+} from './claude-structured-session-acquisition-options'
+import { readClaudeSettingsEffort } from './claude-structured-session-options'
+import {
+  failClaudeStartupGate,
+  openClaudeStartupGate
+} from './claude-structured-session-startup-gate'
+import type { ClaudeSession, ClaudeStructuredSessionEvent } from './claude-structured-session-state'
+
+export type ClaudeInitProof = {
+  promise: Promise<ClaudeInitObservation>
+  resolve: (init: ClaudeInitObservation) => void
+  reject: (error: Error) => void
+}
+
+export function createClaudeInitProof(): ClaudeInitProof {
+  let resolve = (_init: ClaudeInitObservation): void => {}
+  let reject = (_error: Error): void => {}
+  const promise = new Promise<ClaudeInitObservation>((resolvePromise, rejectPromise) => {
+    resolve = resolvePromise
+    reject = rejectPromise
+  })
+  void promise.catch(() => {})
+  return { promise, resolve, reject }
+}
+
+export type ClaudeStartupFacts = {
+  init: ClaudeInitObservation
+  initialization: unknown
+  settings: unknown
+  prepared: ReturnType<typeof prepareClaudeStructuredSessionAcquisitionOptions>
+}
+
+/** Settles on the CLI's answers or on its exit; there is no startup timer. */
+export async function readClaudeStartupFacts(input: {
+  connection: ClaudeStreamJsonConnection
+  initProof: ClaudeInitProof
+  sessionId: string
+  providerSessionId: string
+  resumed: boolean
+  inputOptions: StructuredAgentSessionAcquireInput['options']
+  requestTimeoutMs: number | undefined
+  recordPhase?: StructuredAgentSessionAcquireInput['recordPhase']
+  emit: (event: ClaudeStructuredSessionEvent) => void
+}): Promise<ClaudeStartupFacts> {
+  const [initialization, init] = await withAgentSessionCreatePhase('init', input.recordPhase, () =>
+    Promise.all([
+      input.connection.initializationResult().then((result) => {
+        const authError = claudeInitializationAuthError(result)
+        if (authError) {
+          throw authError
+        }
+        return result
+      }),
+      input.initProof.promise
+    ])
+  )
+  if (input.connection.closed) {
+    throw new Error('claude session closed before startup completed')
+  }
+  input.emit({
+    type: 'options',
+    sessionId: input.sessionId,
+    models: readClaudeModels(initialization)
+  })
+  if (init.providerSessionId !== input.providerSessionId) {
+    throw new Error(
+      `claude proved session ${init.providerSessionId}, expected ${input.providerSessionId}`
+    )
+  }
+  const settings = await readClaudeStructuredSessionSettings(
+    input.connection,
+    input.requestTimeoutMs
+  )
+  input.emit({
+    type: 'auth-diagnostic',
+    sessionId: input.sessionId,
+    diagnostic: claudeAuthDiagnostic(init, settings)
+  })
+  return {
+    init,
+    initialization,
+    settings,
+    prepared: prepareClaudeStructuredSessionAcquisitionOptions({
+      settings,
+      initialization,
+      inputOptions: input.inputOptions,
+      resumed: input.resumed
+    })
+  }
+}
+
+function applyClaudeStartupFacts(session: ClaudeSession, facts: ClaudeStartupFacts): void {
+  const { init, initialization, settings, prepared } = facts
+  const effort = readClaudeSettingsEffort(settings)
+  const published = claudeStructuredSessionPublicationOptions(prepared)
+  // A turn's own init frame may already have reported the running model.
+  if (init.model && session.reportedOptions.model === undefined) {
+    session.reportedOptions.model = init.model
+    session.reportedModelMutation = session.optionMutationSequence
+  }
+  if (effort) {
+    session.reportedOptions.effort = effort
+    session.confirmedOptions.add('effort')
+  }
+  if (published.fastMode !== null) {
+    session.reportedOptions.fastMode = published.fastMode
+    session.confirmedOptions.add('fastMode')
+  }
+  if (published.fastModePerSessionOptIn !== null) {
+    session.fastModePerSessionOptIn = published.fastModePerSessionOptIn
+  }
+  session.fastModeState ??= published.fastModeState
+  session.fastModeDisabledReason ??= published.fastModeDisabledReason
+  session.options = prepared.options
+  session.capabilities = readClaudeCapabilities(init, initialization)
+  // A catalog frame that streamed in after publish is newer than the initialize answer.
+  if (session.commands.commands === undefined) {
+    session.commands = new ClaudeSlashCommandCatalog(init.message, initialization)
+  }
+  session.events?.publish()
+}
+
+/** Applies startup facts to the published session, restores saved options, then releases
+ *  held prompts. Any failure faults the session so the user sees why it never started. */
+export async function settleClaudeSessionStartup(input: {
+  session: ClaudeSession
+  facts: Promise<ClaudeStartupFacts>
+  isCurrent: () => boolean
+  requestTimeoutMs: number | undefined
+  fault: (error: Error) => void
+}): Promise<void> {
+  const { session } = input
+  const superseded = (): boolean => {
+    if (input.isCurrent()) {
+      return false
+    }
+    failClaudeStartupGate(session, new Error('claude session closed before startup completed'))
+    return true
+  }
+  try {
+    const facts = await input.facts
+    if (superseded()) {
+      return
+    }
+    applyClaudeStartupFacts(session, facts)
+    await restoreClaudeStructuredSessionOptions(session, input.requestTimeoutMs)
+    if (!superseded()) {
+      await openClaudeStartupGate(session)
+    }
+  } catch (caught) {
+    const error = caught instanceof Error ? caught : new Error(String(caught))
+    // A close or exit that already ended startup owns how the session ends.
+    const endedElsewhere = session.startup.state !== 'pending'
+    failClaudeStartupGate(session, error)
+    if (!endedElsewhere && input.isCurrent()) {
+      input.fault(error)
+    }
+  }
+}
diff --git a/src/main/claude/claude-structured-session-state.ts b/src/main/claude/claude-structured-session-state.ts
index de697192074b..08792aaca2e1 100644
--- a/src/main/claude/claude-structured-session-state.ts
+++ b/src/main/claude/claude-structured-session-state.ts
@@ -18,6 +18,7 @@ import type {
 } from '../../shared/agent-session-wire'
 import type { ClaudeBackgroundTaskTracker } from './claude-background-task-tracker'
 import type { ClaudeSlashCommandCatalog } from './claude-slash-command-catalog'
+import type { ClaudeSessionStartupGate } from './claude-structured-session-startup-gate'
 
 export type ClaudeAuthDiagnostic = {
   apiKeySourceConfigured: boolean
@@ -63,6 +64,8 @@ export type ClaudeStructuredSessionEvent =
       settlementRetryRequired?: boolean
       /** Host clock when the end was observed. */
       observedAt?: number
+      /** The child ended before proving startup, so reacquiring would repeat the same start. */
+      startupUnproven?: true
     }
 
 export type ClaudeLateDispatchOutcome =
@@ -89,7 +92,6 @@ export type ClaudeStructuredSessionAdapterDeps = {
   mintAcquisitionGeneration?: () => string
   now?: () => number
   requestTimeoutMs?: number
-  initTimeoutMs?: number
   persistHandle?: (input: {
     sessionId: string
     providerSessionId: string
@@ -171,6 +173,8 @@ export type ClaudeSession = {
   translator: ClaudeJournalTranslator | null
   events: StructuredAgentSessionEventSink | undefined
   unbindReadingControl?: () => void
+  /** Published at spawn; init facts, option restore and queued prompts land when startup does. */
+  startup: ClaudeSessionStartupGate
 }
 
 export function mintClaudeAcquisitionGeneration(deps: ClaudeStructuredSessionAdapterDeps): string {
diff --git a/src/main/claude/claude-structured-session-test-support.ts b/src/main/claude/claude-structured-session-test-support.ts
index dbff80182d45..9cf137c634a9 100644
--- a/src/main/claude/claude-structured-session-test-support.ts
+++ b/src/main/claude/claude-structured-session-test-support.ts
@@ -55,6 +55,8 @@ export function fakeClaude(
     initAccount?: unknown
     initCommands?: unknown
     exitBeforeInit?: string
+    /** Host-clock delay before the CLI answers initialize, as on a loaded machine. */
+    initDelayMs?: number
     settings?: unknown
     replayUuid?: string | null
     replayUuids?: (string | null)[]
@@ -87,9 +89,14 @@ export function fakeClaude(
       resumeReading: () => {},
       initializationResult: async () => {
         connection.calls.push({ subtype: 'initialize' })
+        if (options.initDelayMs !== undefined) {
+          await new Promise((resolve) => setTimeout(resolve, options.initDelayMs))
+        }
         if (options.exitBeforeInit) {
+          connection.closed = true
           handlers.onExit?.(new Error(options.exitBeforeInit))
-          return { models: [] }
+          // The SDK rejects pending control requests once the transport ends.
+          throw new Error('Query closed before response received')
         }
         if (options.initProof === 'session-start') {
           handlers.onMessage?.({
@@ -196,12 +203,27 @@ export function fakeClaude(
   return { connections, openConnection, routes }
 }
 
+/** Acquisition resolves only once startup has landed, as suites written before
+ *  publish-first expect; `adapterAtPublishFor` observes the published window itself. */
 export function adapterFor(
+  ...args: Parameters<typeof adapterAtPublishFor>
+): ClaudeStructuredSessionAdapter {
+  const adapter = adapterAtPublishFor(...args)
+  const acquire = adapter.acquire
+  adapter.acquire = async (input) => {
+    const acquisition = await acquire(input)
+    await adapter.drainStartup(input.identity.sessionId)
+    return acquisition
+  }
+  return adapter
+}
+
+export function adapterAtPublishFor(
   claude: ReturnType<typeof fakeClaude>,
   launch: Partial<ClaudeStructuredLaunch> = {},
   events: ClaudeStructuredSessionEvent[] = [],
   persistedHandles: unknown[] = [],
-  initTimeoutMs?: number,
+  requestTimeoutMs?: number,
   readTranscriptLeaf?: ClaudeStructuredSessionAdapterDeps['readTranscriptLeaf'],
   persistHandle?: ClaudeStructuredSessionAdapterDeps['persistHandle'],
   onBackgroundTasksChanged?: ClaudeStructuredSessionAdapterDeps['onBackgroundTasksChanged'],
@@ -222,7 +244,7 @@ export function adapterFor(
     openConnection: claude.openConnection,
     readProcessStartTime: async () => 1_700_000_000_000,
     now: () => 1_700_000_000_500,
-    ...(initTimeoutMs === undefined ? {} : { initTimeoutMs }),
+    ...(requestTimeoutMs === undefined ? {} : { requestTimeoutMs }),
     persistHandle:
       persistHandle ??
       (async (handle) => {
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-adapter.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-adapter.ts
index ac73526fd1cb..ab9ee0673bd1 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-adapter.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-adapter.ts
@@ -124,6 +124,8 @@ export type StructuredAgentSessionLifecycleEvent = {
   observedAt?: number
   /** Translator could not admit terminal rows; host recovery must append its bounded fallback. */
   settlementRetryRequired?: boolean
+  /** The provider ended before it finished starting, so resuming it would repeat the failure. */
+  startupUnproven?: true
 }
 
 export type StructuredAgentSessionAcquireInput = {
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-attach-flow.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-attach-flow.ts
index 3abfd42b8aac..2aad1d2fafe5 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-attach-flow.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-attach-flow.ts
@@ -1,5 +1,6 @@
 import { settlePostAcquisitionAttachFailure } from './structured-agent-session-attach-failure'
 import { rewindRefusal } from './structured-rewind-refusal'
+import { failedCreateRefusal } from './structured-agent-session-failed-create-refusal'
 import {
   AgentSessionRewindRefusal,
   AgentSessionAcquisitionExitUnprovenError,
@@ -147,7 +148,7 @@ export async function performAttach(
         reconstruct: () => null
       })
       if (replay.decision === 'refuse') {
-        return { ok: false, refusal: replay.refusal }
+        return failedCreateRefusal(replay.refusal, reserved.operationRow.outcome.status, record)
       }
     }
     // Sample provider history before a new child is acquired. Once acquireOwner
@@ -168,6 +169,7 @@ export async function performAttach(
       acquiredOwner = true
     }
   } catch (error) {
+    let settled: AgentSessionRecord | null = null
     const spawnToken = reservedRecord?.lease.reservedSpawnToken
     if (reservedRecord && spawnToken && !unsupportedReservationSettlementAttempted) {
       // Settle processless proof and failed operation atomically.
@@ -197,7 +199,7 @@ export async function performAttach(
                 message: error instanceof Error ? error.message : String(error)
               }
       try {
-        await store.settleFailedAcquisition({
+        settled = await store.settleFailedAcquisition({
           sessionId,
           fence: reservedRecord.lease.runtimeFence,
           spawnToken,
@@ -215,10 +217,11 @@ export async function performAttach(
       }
     }
     if (error instanceof AgentSessionRewindRefusal) {
-      return rewindRefusal(error.rewindReason)
+      return failedCreateRefusal(rewindRefusal(error.rewindReason).refusal, 'failed', settled)
     }
     if (error instanceof AgentSessionAcquisitionRefusal) {
-      return { ok: false, refusal: { code: error.code, message: error.message } }
+      const refusal = { code: error.code, message: error.message }
+      return failedCreateRefusal(refusal, 'failed', settled)
     }
     return {
       ok: false,
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-dead-generation-settlement.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-dead-generation-settlement.ts
index 9a3f3a7c091b..259df8a3a55e 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-dead-generation-settlement.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-dead-generation-settlement.ts
@@ -26,15 +26,27 @@ export const MAX_UNEXPECTED_EXIT_REASON_CHARS = 512
 /** The cause is the only thing separating an auth failure from an OOM kill, so it is carried
  *  into the copy rather than left in the durable record nothing renders. */
 export function unexpectedProviderExitOutcome(reason?: string): string {
-  const detail = reason
-    ?.slice(0, MAX_UNEXPECTED_EXIT_REASON_CHARS)
-    .trim()
-    .replace(/[.\s]+$/, '')
+  const detail = exitReasonDetail(reason)
   return detail
     ? `The provider stopped while this response was in progress: ${detail}. You can continue in this conversation.`
     : UNEXPECTED_PROVIDER_EXIT_OUTCOME
 }
 
+/** A start that never finished has no response to interrupt; its cause is the whole story. */
+export function providerStartupFailureOutcome(reason?: string): string {
+  const detail = exitReasonDetail(reason)
+  return detail
+    ? `The provider stopped before it finished starting: ${detail}.`
+    : 'The provider stopped before it finished starting.'
+}
+
+function exitReasonDetail(reason: string | undefined): string | undefined {
+  return reason
+    ?.slice(0, MAX_UNEXPECTED_EXIT_REASON_CHARS)
+    .trim()
+    .replace(/[.\s]+$/, '')
+}
+
 type DeadGenerationSubmission = Pick<
   ReturnType<AgentSessionJournal['submissions']>[number],
   'clientMessageId' | 'dispatchState' | 'recovered'
@@ -106,6 +118,8 @@ export async function settleStructuredAgentSessionDeadGeneration(input: {
   showUnexpectedExitOutcome?: boolean
   /** Why the provider stopped, when the host has it. Rendered with the outcome copy. */
   unexpectedExitReason?: string
+  /** The provider never finished starting; the outcome says so instead of naming a response. */
+  exitedDuringStartup?: boolean
   onError?: (sessionId: string, error: unknown) => void
 }): Promise<boolean> {
   try {
@@ -123,7 +137,11 @@ export async function settleStructuredAgentSessionDeadGeneration(input: {
         identity: { provider: 'orca', clientMessageId: input.settlementId },
         body: {
           kind: 'status',
-          text: boundJournalStatusText(unexpectedProviderExitOutcome(input.unexpectedExitReason))
+          text: boundJournalStatusText(
+            input.exitedDuringStartup
+              ? providerStartupFailureOutcome(input.unexpectedExitReason)
+              : unexpectedProviderExitOutcome(input.unexpectedExitReason)
+          )
         }
       })
     }
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-failed-create-owner-verdict.test.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-failed-create-owner-verdict.test.ts
new file mode 100644
index 000000000000..013f08527be6
--- /dev/null
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-failed-create-owner-verdict.test.ts
@@ -0,0 +1,116 @@
+// A durably failed create tells a client what the host proved about the provider process, so a
+// client can tell "retry under a new operation" (exited) from "the session may exist" (anything else).
+
+import { mkdtemp, rm } from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { afterEach, beforeEach, describe, expect, it, vi, type Mock } from 'vitest'
+import { AgentSessionRecordStore } from '../../runtime/agent-session-record-store'
+import {
+  AgentSessionAcquisitionExitUnprovenError,
+  AgentSessionAcquisitionRefusal,
+  type StructuredAgentSessionAdapter
+} from './structured-agent-session-adapter'
+import { StructuredAgentSessionHost } from './structured-agent-session-host'
+import {
+  HOST_TEST_NOW as NOW,
+  HOST_TEST_SESSION as SESSION,
+  HOST_TEST_THREAD as THREAD,
+  hostTestAttachParams,
+  resetHostTestOperationIds
+} from './structured-agent-session-host-test-data'
+
+const CALLER = { callerKey: 'client-1' }
+const EXIT_REASON = 'claude stream-json exited (code 1): stderr tail'
+
+let root: string
+let store: AgentSessionRecordStore
+let host: StructuredAgentSessionHost
+let acquire: Mock<StructuredAgentSessionAdapter['acquire']>
+
+beforeEach(async () => {
+  root = await mkdtemp(join(tmpdir(), 'orca-failed-create-verdict-'))
+  resetHostTestOperationIds()
+  acquire = vi.fn(async ({ fence, spawnToken }) => ({
+    process: { hostId: 'local', pid: 4242, processStartTimeMs: 1_700_000_000_000, spawnToken },
+    link: {
+      linkId: `link-${fence}`,
+      handle: { provider: 'codex', threadId: THREAD },
+      origin: 'created',
+      mintedAtFence: fence,
+      observedAt: NOW
+    }
+  }))
+  store = await AgentSessionRecordStore.open({ directory: join(root, 'store'), hostId: 'local' })
+  host = new StructuredAgentSessionHost({
+    store,
+    adapter: {
+      acquire,
+      releaseAcquisition: vi.fn(async () => true),
+      dispatch: vi.fn(async () => ({ state: 'admitted' as const })),
+      cancelTurn: vi.fn(async () => ({ cancelled: true })),
+      answerPrompt: vi.fn(async () => undefined),
+      setOption: vi.fn(async () => undefined)
+    },
+    journalRoot: root,
+    claimKeyId: 'key-1',
+    mintSpawnToken: () => 'spawn-a',
+    now: () => NOW
+  })
+})
+
+afterEach(async () => {
+  await host.flushAllStreamedEvents()
+  await rm(root, { recursive: true, force: true })
+})
+
+describe('failed create owner verdict', () => {
+  it('replays an exit-proven failure as exited with its reason, and a new operation starts fresh', async () => {
+    acquire.mockRejectedValueOnce(new Error(EXIT_REASON))
+    const first = hostTestAttachParams(null)
+
+    await expect(host.attach(CALLER, first)).rejects.toThrow(EXIT_REASON)
+    await expect(host.attach(CALLER, first)).resolves.toEqual({
+      ok: false,
+      refusal: {
+        code: 'agent_session_operation_invalid',
+        message: EXIT_REASON,
+        ownerVerdict: 'exited'
+      }
+    })
+    expect(acquire).toHaveBeenCalledOnce()
+
+    const retry = hostTestAttachParams(null)
+    expect(retry.envelope.clientOperationId).not.toBe(first.envelope.clientOperationId)
+    await expect(host.attach(CALLER, retry)).resolves.toMatchObject({ ok: true })
+    expect(acquire).toHaveBeenCalledTimes(2)
+    expect(store.getRecord(SESSION)?.lease.claimStatus).toBe('live')
+  })
+
+  it('answers an acquisition refusal with its verdict directly', async () => {
+    acquire.mockRejectedValueOnce(new AgentSessionAcquisitionRefusal('not signed in'))
+
+    await expect(host.attach(CALLER, hostTestAttachParams(null))).resolves.toEqual({
+      ok: false,
+      refusal: {
+        code: 'agent_session_operation_invalid',
+        message: 'not signed in',
+        ownerVerdict: 'exited'
+      }
+    })
+  })
+
+  it('never claims exited when the failed attempt could not prove its process gone', async () => {
+    acquire.mockRejectedValueOnce(new AgentSessionAcquisitionExitUnprovenError(new Error('hung')))
+    const first = hostTestAttachParams(null)
+
+    await expect(host.attach(CALLER, first)).rejects.toThrow()
+    const replay = await host.attach(CALLER, first)
+
+    expect(replay).toMatchObject({
+      ok: false,
+      refusal: { code: 'agent_session_ownership_unknown', ownerVerdict: 'unverifiable' }
+    })
+    expect(store.getRecord(SESSION)?.lease.claimStatus).not.toBe('released')
+  })
+})
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-failed-create-refusal.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-failed-create-refusal.ts
new file mode 100644
index 000000000000..7302d6ded8df
--- /dev/null
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-failed-create-refusal.ts
@@ -0,0 +1,18 @@
+import type { AgentSessionWireRefusal } from '../../../shared/agent-session-wire'
+import type { AgentSessionOperationOutcome } from '../../../shared/agent-session-operation-ledger'
+import { agentSessionLeaseOwnerVerdict } from '../../../shared/agent-session-lease-adjudication'
+import type { AgentSessionRecord } from '../../../shared/agent-session-record'
+
+/** Only a durably failed operation says anything about retrying under a new one. */
+export function failedCreateRefusal(
+  refusal: AgentSessionWireRefusal,
+  status: AgentSessionOperationOutcome['status'],
+  record: AgentSessionRecord | null
+): { ok: false; refusal: AgentSessionWireRefusal } {
+  return status === 'failed' && record
+    ? {
+        ok: false,
+        refusal: { ...refusal, ownerVerdict: agentSessionLeaseOwnerVerdict(record.lease) }
+      }
+    : { ok: false, refusal }
+}
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-startup-failure-exit.test.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-startup-failure-exit.test.ts
new file mode 100644
index 000000000000..1faa497e5fd6
--- /dev/null
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-startup-failure-exit.test.ts
@@ -0,0 +1,104 @@
+import { describe, expect, it, vi } from 'vitest'
+import type { AgentSessionRecord } from '../../../shared/agent-session-record'
+import {
+  agentSessionLeaseFixture,
+  agentSessionRecordFixture
+} from '../../../shared/agent-session-record.test-fixture'
+import { providerStartupFailureOutcome } from './structured-agent-session-dead-generation-settlement'
+import {
+  settleUnexpectedStructuredAgentSessionExit,
+  type StructuredAgentSessionUnexpectedExitContext,
+  type StructuredAgentSessionUnexpectedExitSession
+} from './structured-agent-session-unexpected-exit'
+
+const SESSION = 'session-1'
+const GENERATION = 'generation-1'
+const REASON = 'Claude Code is not signed in. Sign in with the Claude CLI'
+
+function startedSession(): StructuredAgentSessionUnexpectedExitSession & {
+  journal: { appendLifecycleBatch: ReturnType<typeof vi.fn> }
+} {
+  return {
+    hasProviderChild: true,
+    fence: 7,
+    acquisitionGeneration: GENERATION,
+    journal: {
+      // Nothing ran: the start failed before any response or acknowledged prompt.
+      snapshot: () => ({ items: [] }),
+      appendLifecycleBatch: vi.fn(async () => ({ epoch: 'epoch-1', sequence: 1 })),
+      markPendingSubmissionsUnknown: vi.fn(async () => [])
+    }
+  }
+}
+
+function contextFor(session: StructuredAgentSessionUnexpectedExitSession) {
+  let record: AgentSessionRecord = agentSessionRecordFixture(
+    agentSessionLeaseFixture({
+      sessionId: SESSION,
+      runtimeKind: 'native',
+      runtimeFence: 7,
+      handoffStage: null,
+      ownerProcess: { hostId: 'local', pid: 4242, processStartTimeMs: 1, spawnToken: 'spawn-1' },
+      reservedSpawnToken: 'spawn-1',
+      claimStatus: 'live',
+      unreconciled: false
+    })
+  )
+  const context: StructuredAgentSessionUnexpectedExitContext<typeof session> = {
+    store: {
+      getRecord: () => record,
+      transitionHandoff: async (
+        _sessionId: string,
+        transition: (current: AgentSessionRecord) => AgentSessionRecord
+      ) => (record = transition(record))
+    },
+    sessions: new Map([[SESSION, session]]),
+    flushLifecycle: async () => ({ ok: true }),
+    publishFence: vi.fn(),
+    hasResumeCapableHolder: () => true,
+    serialize: async <T>(_sessionId: string, task: () => Promise<T>) => task(),
+    now: () => 1
+  }
+  return context
+}
+
+const ended = {
+  type: 'ended' as const,
+  sessionId: SESSION,
+  reason: REASON,
+  cause: 'unexpected-exit' as const,
+  fence: 7,
+  acquisitionGeneration: GENERATION
+}
+
+describe('a provider that ends before it finished starting', () => {
+  it('tells the user why, even with no response in progress, and does not auto-resume', async () => {
+    const session = startedSession()
+
+    const ticket = await settleUnexpectedStructuredAgentSessionExit(contextFor(session), {
+      ...ended,
+      startupUnproven: true
+    })
+
+    expect(ticket).toBeNull()
+    expect(session.journal.appendLifecycleBatch).toHaveBeenCalledWith(
+      expect.objectContaining({
+        mutations: [
+          expect.objectContaining({
+            body: { kind: 'status', text: providerStartupFailureOutcome(REASON) }
+          })
+        ]
+      })
+    )
+    expect(providerStartupFailureOutcome(REASON)).toContain('not signed in')
+  })
+
+  it('keeps an ordinary idle exit silent and resumable', async () => {
+    const session = startedSession()
+
+    const ticket = await settleUnexpectedStructuredAgentSessionExit(contextFor(session), ended)
+
+    expect(ticket).not.toBeNull()
+    expect(session.journal.appendLifecycleBatch).not.toHaveBeenCalled()
+  })
+})
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-unexpected-exit.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-unexpected-exit.ts
index 11d004089ca6..5e90d7d79089 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-unexpected-exit.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-unexpected-exit.ts
@@ -96,11 +96,14 @@ export async function settleUnexpectedStructuredAgentSessionExit<
         session,
         stableSettlementId,
         verdict: { state: 'interrupted', completedAt: observedAt },
-        showUnexpectedExitOutcome: unfinishedStructuredAgentSessionWorkWasInterrupted(
-          unfinishedWork,
-          session.journal,
-          observedAt
-        )
+        // A failed start always says why: no response was running to carry the reason.
+        showUnexpectedExitOutcome:
+          unexpectedEvent.startupUnproven === true ||
+          unfinishedStructuredAgentSessionWorkWasInterrupted(
+            unfinishedWork,
+            session.journal,
+            observedAt
+          )
       }))
     } finally {
       // Provider exit was positively observed, so release the owner even when
@@ -138,7 +141,11 @@ export async function settleUnexpectedStructuredAgentSessionExit<
     if (settlementFailed || !released) {
       return null
     }
-    if (!context.hasResumeCapableHolder(unexpectedEvent.sessionId)) {
+    // Resuming a start that failed would respawn into the same failure; the next send retries.
+    if (
+      unexpectedEvent.startupUnproven ||
+      !context.hasResumeCapableHolder(unexpectedEvent.sessionId)
+    ) {
       return null
     }
     return {
@@ -194,6 +201,7 @@ async function retryUnexpectedExitSettlement(input: {
     pendingSubmissionReason: 'provider_exited_before_acknowledgement',
     showUnexpectedExitOutcome: input.showUnexpectedExitOutcome,
     unexpectedExitReason: input.event.reason,
+    exitedDuringStartup: input.event.startupUnproven === true,
     onError: input.context.onBarrierError
   })
 }
diff --git a/src/main/runtime/agent-session-reservation-admission.test.ts b/src/main/runtime/agent-session-reservation-admission.test.ts
index 80bcb77cfa5b..30d54a108c9c 100644
--- a/src/main/runtime/agent-session-reservation-admission.test.ts
+++ b/src/main/runtime/agent-session-reservation-admission.test.ts
@@ -197,3 +197,48 @@ describe('adopted conversation ownership', () => {
     ).toThrow('agent_session_conflict')
   })
 })
+
+describe('re-create over a failed create', () => {
+  const EXITED = agentSessionLeaseFixture({
+    sessionId: 'session-adopting',
+    runtimeKind: 'native',
+    runtimeFence: 2,
+    provenHandleLinkId: null,
+    ownerProcess: null,
+    reservedSpawnToken: null,
+    claimStatus: 'released'
+  })
+  function failedCreate(overrides: Partial<AgentSessionRecord> = {}): AgentSessionRecord {
+    return {
+      ...agentSessionRecordFixture(EXITED),
+      location: LOCATION,
+      accountHome: { variable: 'CLAUDE_CONFIG_DIR', path: '/home/dev/.claude' },
+      providerHandleChain: [],
+      ...overrides
+    }
+  }
+
+  it('reserves a record that never bound a conversation and whose attempt is proven gone', () => {
+    const { record, disposition } = applyAgentSessionReservation(
+      storeState([failedCreate()]),
+      reserveRequest(),
+      LEASE_TTL_MS
+    )
+
+    expect(disposition).toBe('reserved')
+    expect(record.lease).toMatchObject({ claimStatus: 'reserved', runtimeFence: 3 })
+  })
+
+  it('refuses when the record bound a conversation, or its attempt may still run', () => {
+    const bound = failedCreate({ providerHandleChain: [adoptedLink()] })
+    const unproven = failedCreate({
+      lease: { ...EXITED, claimStatus: 'reserved', handoffStage: 'manual-recovery' }
+    })
+
+    for (const record of [bound, unproven]) {
+      expect(() =>
+        applyAgentSessionReservation(storeState([record]), reserveRequest(), LEASE_TTL_MS)
+      ).toThrow('agent_session_conflict')
+    }
+  })
+})
diff --git a/src/main/runtime/agent-session-reservation-admission.ts b/src/main/runtime/agent-session-reservation-admission.ts
index 662ea481921d..436267e24eac 100644
--- a/src/main/runtime/agent-session-reservation-admission.ts
+++ b/src/main/runtime/agent-session-reservation-admission.ts
@@ -17,6 +17,7 @@ import {
   type AgentSessionOperationRow
 } from '../../shared/agent-session-operation-ledger'
 import {
+  agentSessionLeaseOwnerVerdict,
   evaluateAgentSessionAcquisition,
   type AgentSessionOwnerProbe
 } from '../../shared/agent-session-lease-adjudication'
@@ -181,7 +182,13 @@ export function applyAgentSessionReservation(
     // Why: location, provider, and account are the session identity; changing one is a fork.
     throw new Error('agent_session_conflict')
   }
-  if (request.expectedFence === null) {
+  // A create may take over only a record that never bound a conversation and whose last
+  // attempt is proven gone: that is the same as creating it fresh, under a fresh provider id.
+  const recreatable =
+    existing.providerHandleChain.length === 0 &&
+    !request.adoptedHandleLink &&
+    agentSessionLeaseOwnerVerdict(existing.lease) === 'exited'
+  if (request.expectedFence === null && !recreatable) {
     throw new Error('agent_session_conflict')
   }
   const pinned = {
@@ -191,7 +198,7 @@ export function applyAgentSessionReservation(
   }
   return reserveAgentSessionOwner({
     record: pinned,
-    expectedFence: request.expectedFence,
+    expectedFence: request.expectedFence ?? existing.lease.runtimeFence,
     probe: request.probe,
     reservation
   })
diff --git a/src/main/runtime/claude-structured-session-integration.test.ts b/src/main/runtime/claude-structured-session-integration.test.ts
index 2fccc11fb3ce..80e2c4d42fb8 100644
--- a/src/main/runtime/claude-structured-session-integration.test.ts
+++ b/src/main/runtime/claude-structured-session-integration.test.ts
@@ -458,24 +458,22 @@ describe('a structured Claude session over agentSession.*', () => {
     expect(claude.connections).toHaveLength(0)
   })
 
-  it('durably returns actionable sign-in guidance when initialization has no credentials', async () => {
+  it('publishes, then ends the session with sign-in guidance when initialization has no credentials', async () => {
     claude.setInitializeAccount({ apiProvider: 'firstParty', tokenSource: 'none' })
-    const params = createIntentParams()
 
-    const first = await call('agentSession.create', params)
-    const retry = await call('agentSession.create', params)
+    // The create answers once the child is spawned; the missing credentials arrive after.
+    await ok<{ fence: number }>('agentSession.create', createIntentParams())
+    await waitForStructuredAgentSessionRecovery()
 
-    expect(first).toMatchObject({
-      ok: true,
-      result: {
-        ok: false,
-        refusal: {
-          code: 'agent_session_operation_invalid',
-          message: expect.stringMatching(/not signed in.*Claude CLI.*CLAUDE_CONFIG_DIR/s)
-        }
-      }
+    const guidance = itemsOf(await subscribe()).find((item) => item.body?.kind === 'status')
+    expect(guidance?.body).toMatchObject({
+      kind: 'status',
+      text: expect.stringMatching(
+        /stopped before it finished starting: .*not signed in.*Claude CLI.*CLAUDE_CONFIG_DIR/s
+      )
     })
-    expect((retry as { result: unknown }).result).toEqual((first as { result: unknown }).result)
+    expect(leaseOf(SESSION)).toMatchObject({ claimStatus: 'released', handoffStage: null })
+    // A failed start is not auto-resumed into the same failure.
     expect(claude.connections).toHaveLength(1)
   })
 
diff --git a/src/main/runtime/structured-claude-runtime-adapter.ts b/src/main/runtime/structured-claude-runtime-adapter.ts
index 9a070db60af4..fd0f31dd533d 100644
--- a/src/main/runtime/structured-claude-runtime-adapter.ts
+++ b/src/main/runtime/structured-claude-runtime-adapter.ts
@@ -116,7 +116,8 @@ export function createStructuredClaudeRuntimeAdapter(
           acquisitionGeneration: event.acquisitionGeneration,
           ...(event.settlementRetryRequired
             ? { settlementRetryRequired: event.settlementRetryRequired }
-            : {})
+            : {}),
+          ...(event.startupUnproven ? { startupUnproven: event.startupUnproven } : {})
         })
       }
     },
diff --git a/src/renderer/src/components/native-chat/NativeChatLaunchRetry.tsx b/src/renderer/src/components/native-chat/NativeChatLaunchRetry.tsx
index 23b52615ee97..1a4204a326fa 100644
--- a/src/renderer/src/components/native-chat/NativeChatLaunchRetry.tsx
+++ b/src/renderer/src/components/native-chat/NativeChatLaunchRetry.tsx
@@ -5,9 +5,11 @@ import type { StructuredAgentSessionLaunchLifecycle } from '@/lib/structured-age
 
 export function NativeChatLaunchRetry({
   lifecycle,
+  failureReason = null,
   onRetry
 }: {
   lifecycle: StructuredAgentSessionLaunchLifecycle | null
+  failureReason?: string | null
   onRetry: () => void
 }): React.JSX.Element | null {
   if (lifecycle !== 'failed' && lifecycle !== 'visibility-unknown') {
@@ -25,7 +27,10 @@ export function NativeChatLaunchRetry({
         )
   return (
     <div className="mx-auto flex w-full max-w-4xl items-center justify-between gap-3 px-4 py-1 text-xs text-destructive">
-      <span>{message}</span>
+      <span className="min-w-0 break-words">
+        {message}
+        {lifecycle === 'failed' && failureReason ? ` ${failureReason}` : null}
+      </span>
       <Button type="button" variant="ghost" size="xs" onClick={onRetry}>
         <RotateCcw className="size-3" />
         {translate('auto.components.native.chat.NativeChatLaunchRetry.retry', 'Retry')}
diff --git a/src/renderer/src/components/native-chat/NativeChatStructuredSession.launch-lifecycle.test.tsx b/src/renderer/src/components/native-chat/NativeChatStructuredSession.launch-lifecycle.test.tsx
index 1550b3316e9f..a5007d2e6ff3 100644
--- a/src/renderer/src/components/native-chat/NativeChatStructuredSession.launch-lifecycle.test.tsx
+++ b/src/renderer/src/components/native-chat/NativeChatStructuredSession.launch-lifecycle.test.tsx
@@ -68,6 +68,22 @@ describe('NativeChatStructuredSession launch lifecycle', () => {
     expect(mocks.retryLaunch).toHaveBeenCalledWith('wt-1', 'session-1')
   })
 
+  it('shows why a failed launch failed beside Retry', () => {
+    mocks.launchLifecycle = 'failed'
+    mocks.launchFailureReason = 'claude is not signed in'
+    render(sessionView())
+
+    expect(screen.getByText('Chat could not be started. claude is not signed in')).toBeTruthy()
+  })
+
+  it('keeps a stale reason off a launch that is no longer failed', () => {
+    mocks.launchLifecycle = 'visibility-unknown'
+    mocks.launchFailureReason = 'claude is not signed in'
+    render(sessionView())
+
+    expect(screen.getByText('Chat connection could not be confirmed.')).toBeTruthy()
+  })
+
   it('keeps the durable outbox parked until publication, then dispatches it once', async () => {
     mocks.mode = 'outbox'
     mocks.launchLifecycle = 'visibility-unknown'
diff --git a/src/renderer/src/components/native-chat/NativeChatStructuredSession.test-harness.tsx b/src/renderer/src/components/native-chat/NativeChatStructuredSession.test-harness.tsx
index c214479b84d7..42adab5dda0a 100644
--- a/src/renderer/src/components/native-chat/NativeChatStructuredSession.test-harness.tsx
+++ b/src/renderer/src/components/native-chat/NativeChatStructuredSession.test-harness.tsx
@@ -40,6 +40,7 @@ export function createStructuredSessionMocks() {
     call: vi.fn<(...args: never[]) => unknown>(),
     fileLinkClick: vi.fn<(...args: never[]) => unknown>(),
     launchLifecycle: nullable<StructuredAgentSessionLaunchLifecycle>(),
+    launchFailureReason: nullable<string>(),
     retryLaunch: vi.fn<(...args: never[]) => unknown>(),
     controllerProps: nullable<{ transportEnabled?: boolean }>(),
     mode: 'static' as 'static' | 'outbox',
@@ -162,7 +163,8 @@ export function createStructuredSessionMocks() {
     },
     structuredAgentSessionLaunch: () => ({
       retryStructuredAgentSessionLaunch: mocks.retryLaunch,
-      useStructuredAgentSessionLaunchLifecycle: () => mocks.launchLifecycle
+      useStructuredAgentSessionLaunchLifecycle: () => mocks.launchLifecycle,
+      useStructuredAgentSessionLaunchFailureReason: () => mocks.launchFailureReason
     }),
     useNativeChatFontScale: () => ({
       useNativeChatFontScale: () => ({ scale: 1 })
@@ -218,6 +220,7 @@ export function createStructuredSessionMocks() {
   const resetStructuredSessionMocks = (): void => {
     mocks.call.mockReset()
     mocks.launchLifecycle = null
+    mocks.launchFailureReason = null
     mocks.retryLaunch.mockReset()
     mocks.controllerProps = null
     mocks.mode = 'static'
diff --git a/src/renderer/src/components/native-chat/NativeChatStructuredSession.tsx b/src/renderer/src/components/native-chat/NativeChatStructuredSession.tsx
index 36b2ed145e3d..aaf3f4675ee5 100644
--- a/src/renderer/src/components/native-chat/NativeChatStructuredSession.tsx
+++ b/src/renderer/src/components/native-chat/NativeChatStructuredSession.tsx
@@ -307,6 +307,7 @@ export function NativeChatStructuredSession(
       />
       <NativeChatLaunchRetry
         lifecycle={provisionalLaunch.lifecycle}
+        failureReason={provisionalLaunch.failureReason}
         onRetry={provisionalLaunch.retry}
       />
       <NativeChatStructuredSessionStatus
diff --git a/src/renderer/src/components/native-chat/use-native-chat-provisional-launch.ts b/src/renderer/src/components/native-chat/use-native-chat-provisional-launch.ts
index 95a2c05236f7..ce790cf7c6c2 100644
--- a/src/renderer/src/components/native-chat/use-native-chat-provisional-launch.ts
+++ b/src/renderer/src/components/native-chat/use-native-chat-provisional-launch.ts
@@ -1,6 +1,7 @@
 import { useCallback } from 'react'
 import {
   retryStructuredAgentSessionLaunch,
+  useStructuredAgentSessionLaunchFailureReason,
   useStructuredAgentSessionLaunchLifecycle
 } from '@/lib/structured-agent-session-launch'
 
@@ -9,6 +10,7 @@ export function useNativeChatProvisionalLaunch(
   sessionId: string
 ) {
   const lifecycle = useStructuredAgentSessionLaunchLifecycle(worktreeId ?? '', sessionId)
+  const failureReason = useStructuredAgentSessionLaunchFailureReason(worktreeId ?? '', sessionId)
   const retry = useCallback(() => {
     if (worktreeId) {
       retryStructuredAgentSessionLaunch(worktreeId, sessionId)
@@ -16,6 +18,7 @@ export function useNativeChatProvisionalLaunch(
   }, [sessionId, worktreeId])
   return {
     lifecycle,
+    failureReason,
     retry,
     transportEnabled: lifecycle === null || lifecycle === 'published'
   }
diff --git a/src/renderer/src/lib/launch-structured-agent-session.ts b/src/renderer/src/lib/launch-structured-agent-session.ts
index cc043378a56f..d45cf9d77c80 100644
--- a/src/renderer/src/lib/launch-structured-agent-session.ts
+++ b/src/renderer/src/lib/launch-structured-agent-session.ts
@@ -280,8 +280,9 @@ export async function launchStructuredAgentSession(
     throw error
   }
   if (!result.ok) {
-    const { code, message } = result.refusal
-    if (!isDefinitiveAgentSessionCreateRefusal(code)) {
+    const { code, message, ownerVerdict } = result.refusal
+    // A failed operation whose provider is proven gone is a failure a new operation may retry.
+    if (!isDefinitiveAgentSessionCreateRefusal(code) && ownerVerdict !== 'exited') {
       // Keep the focus intent: the session may exist, and recovery still has to adopt it.
       throw new StructuredAgentSessionCreateUnknownOutcomeError(message, code)
     }
diff --git a/src/renderer/src/lib/structured-agent-session-launch-exited-owner.test.ts b/src/renderer/src/lib/structured-agent-session-launch-exited-owner.test.ts
new file mode 100644
index 000000000000..0b0af0aae1e4
--- /dev/null
+++ b/src/renderer/src/lib/structured-agent-session-launch-exited-owner.test.ts
@@ -0,0 +1,153 @@
+// @vitest-environment happy-dom
+// The launch client against the create wire contract: a failed create whose provider is proven
+// gone reads as failed (with its reason) and Retry starts it again; any other verdict stays unknown.
+
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+import type {
+  AgentSessionMutationEnvelope,
+  AgentSessionOwnerVerdict,
+  AgentSessionWireRefusal
+} from '../../../shared/agent-session-wire'
+
+const mocks = vi.hoisted(() => ({
+  call: vi.fn<
+    (
+      target: unknown,
+      method: string,
+      params: { envelope: AgentSessionMutationEnvelope }
+    ) => Promise<unknown>
+  >(),
+  refresh: vi.fn()
+}))
+
+vi.mock('sonner', () => ({ toast: { error: vi.fn(), message: vi.fn() } }))
+vi.mock('@/runtime/structured-agent-session-client', () => ({
+  callStructuredAgentSession: mocks.call
+}))
+vi.mock('@/runtime/local-structured-session-tabs-sync', () => ({
+  refreshLocalStructuredSessionTabs: mocks.refresh
+}))
+vi.mock('@/runtime/web-session-focus-intent', () => ({
+  clearWebSessionFocusIntentIfMatches: vi.fn(),
+  recordWebSessionFocusIntent: vi.fn(),
+  resolveWebSessionVisibleTabId: vi.fn(() => null)
+}))
+vi.mock('@/store', () => ({
+  useAppStore: {
+    getState: () => ({ seedNativeChatLaunchDraft: vi.fn(), clearNativeChatLaunchDraft: vi.fn() })
+  }
+}))
+vi.mock('@/i18n/i18n', () => ({ translate: (_key: string, fallback: string) => fallback }))
+vi.mock('@/lib/agent-catalog', () => ({
+  getAgentLabel: () => 'Codex',
+  getAgentCatalog: () => [{ id: 'codex', label: 'Codex' }]
+}))
+
+import {
+  getStructuredAgentSessionLaunchLifecycle,
+  retryStructuredAgentSessionLaunch,
+  startStructuredAgentLaunch
+} from './structured-agent-session-launch'
+import {
+  getStructuredAgentSessionLaunchFailureReason,
+  resetStructuredAgentLaunchRegistryForTests
+} from './structured-agent-session-launch-registry'
+import { resetStructuredAgentLaunchPersistenceForTests } from './structured-agent-session-launch-persistence'
+
+const WORKTREE = 'wt-1'
+const EXIT_REASON = 'claude stream-json exited (code 1): stderr tail'
+
+/** The verdict the host puts on the failed operation's replay; undefined models an older host. */
+let replayVerdict: AgentSessionOwnerVerdict | undefined
+let failedOperation: string | null = null
+let publishedSessionId: string | null = null
+const createdOperations: string[] = []
+
+/** Mirrors the host: the first attempt's RPC fails, its replay is a durable refusal, and only
+ *  a new operation creates the session again. */
+function hostCreate(envelope: AgentSessionMutationEnvelope): unknown {
+  createdOperations.push(envelope.clientOperationId)
+  failedOperation ??= envelope.clientOperationId
+  if (envelope.clientOperationId !== failedOperation) {
+    publishedSessionId = envelope.sessionId
+    return { ok: true, replayed: false, value: { sessionId: envelope.sessionId, fence: 3 } }
+  }
+  if (createdOperations.length === 1) {
+    throw new Error(EXIT_REASON)
+  }
+  const refusal: AgentSessionWireRefusal = {
+    code: 'agent_session_operation_invalid',
+    message: EXIT_REASON,
+    ...(replayVerdict ? { ownerVerdict: replayVerdict } : {})
+  }
+  return { ok: false, refusal }
+}
+
+async function settle(sessionId: string): Promise<void> {
+  await vi.waitFor(
+    () => expect(getStructuredAgentSessionLaunchLifecycle(WORKTREE, sessionId)).not.toBe('pending'),
+    { timeout: 5_000 }
+  )
+}
+
+function launch(): string {
+  const started = startStructuredAgentLaunch(WORKTREE, 'codex')
+  void started.launchResult.catch(() => undefined)
+  return started.sessionId
+}
+
+beforeEach(() => {
+  vi.clearAllMocks()
+  localStorage.clear()
+  resetStructuredAgentLaunchPersistenceForTests()
+  resetStructuredAgentLaunchRegistryForTests()
+  replayVerdict = 'exited'
+  failedOperation = null
+  publishedSessionId = null
+  createdOperations.length = 0
+  mocks.call.mockImplementation(async (_target, method, params) => {
+    if (method === 'agentSession.createSupport') {
+      return { supported: true }
+    }
+    if (method === 'agentSession.create') {
+      return hostCreate(params.envelope)
+    }
+    throw new Error(`unexpected ${method}`)
+  })
+  mocks.refresh.mockImplementation(async () =>
+    publishedSessionId
+      ? [{ worktree: WORKTREE, tabs: [{ type: 'agent-session', sessionId: publishedSessionId }] }]
+      : []
+  )
+})
+
+describe('structured launch after a host-failed create', () => {
+  it('fails with the host reason when the provider is proven gone, and Retry starts it under a new operation', async () => {
+    const sessionId = launch()
+    await settle(sessionId)
+
+    expect(getStructuredAgentSessionLaunchLifecycle(WORKTREE, sessionId)).toBe('failed')
+    expect(getStructuredAgentSessionLaunchFailureReason(WORKTREE, sessionId)).toBe(EXIT_REASON)
+    expect(createdOperations.every((operation) => operation === failedOperation)).toBe(true)
+
+    expect(retryStructuredAgentSessionLaunch(WORKTREE, sessionId)).toBe(true)
+    await settle(sessionId)
+
+    expect(createdOperations.at(-1)).not.toBe(failedOperation)
+    expect(publishedSessionId).toBe(sessionId)
+    // A published launch retires its client state; failed or unknown would linger.
+    expect(getStructuredAgentSessionLaunchLifecycle(WORKTREE, sessionId)).toBeNull()
+  })
+
+  it.each([
+    ['the host could not prove the process gone', 'unverifiable'],
+    ['the host predates the verdict', undefined]
+  ] as const)('stays unknown when %s', async (_label, verdict) => {
+    replayVerdict = verdict
+    const sessionId = launch()
+    await settle(sessionId)
+
+    expect(getStructuredAgentSessionLaunchLifecycle(WORKTREE, sessionId)).toBe('visibility-unknown')
+    expect(createdOperations.every((operation) => operation === failedOperation)).toBe(true)
+  })
+})
diff --git a/src/renderer/src/lib/structured-agent-session-launch-registry.ts b/src/renderer/src/lib/structured-agent-session-launch-registry.ts
index eb16d8fed252..fa281101c9ce 100644
--- a/src/renderer/src/lib/structured-agent-session-launch-registry.ts
+++ b/src/renderer/src/lib/structured-agent-session-launch-registry.ts
@@ -25,6 +25,8 @@ export type StructuredLaunchState = StructuredLaunchRecoveryState & {
   /** Fixed by the caller that opened this launch so coalesced prompts use one delivery mode. */
   promptDelivery: StructuredAgentLaunchOptions['promptDelivery']
   callers: StructuredLaunchCallerGroup
+  /** Why the last attempt failed, shown beside Retry; the toast stays generic. */
+  failureReason?: string
 }
 
 export type StructuredAgentLaunchStatus = 'idle' | 'pending' | 'unknown'
@@ -163,6 +165,29 @@ export function getStructuredAgentSessionLaunchLifecycle(
   return getPersistedStructuredAgentLaunchRecord(sessionId)?.lifecycle ?? null
 }
 
+export function getStructuredAgentSessionLaunchFailureReason(
+  worktreeId: string,
+  sessionId: string
+): string | null {
+  const state = getStructuredLaunchStateBySessionId(sessionId)
+  return state &&
+    matchesLaunchWorktree(state, worktreeId) &&
+    launchStateLifecycle(state) === 'failed'
+    ? (state.failureReason ?? null)
+    : null
+}
+
+export function useStructuredAgentSessionLaunchFailureReason(
+  worktreeId: string,
+  sessionId: string
+): string | null {
+  return useSyncExternalStore(
+    subscribeStructuredAgentLaunchStatus,
+    () => getStructuredAgentSessionLaunchFailureReason(worktreeId, sessionId),
+    () => null
+  )
+}
+
 export function useStructuredAgentSessionLaunchLifecycle(
   worktreeId: string,
   sessionId: string
diff --git a/src/renderer/src/lib/structured-agent-session-launch.ts b/src/renderer/src/lib/structured-agent-session-launch.ts
index a0c140470140..a028d3c8c882 100644
--- a/src/renderer/src/lib/structured-agent-session-launch.ts
+++ b/src/renderer/src/lib/structured-agent-session-launch.ts
@@ -49,6 +49,7 @@ export {
   retireStructuredAgentSessionLaunchCancellationTombstone,
   shouldRetainStructuredAgentSessionLaunchTab,
   subscribeStructuredAgentLaunchStatus,
+  useStructuredAgentSessionLaunchFailureReason,
   useStructuredAgentSessionLaunchLifecycle,
   type StructuredAgentLaunchStatus,
   type StructuredAgentSessionLaunchLifecycle
@@ -134,6 +135,7 @@ function trackLaunchSettlement(
         }
         return
       }
+      state.failureReason = error instanceof Error ? error.message : String(error)
       if (error instanceof StructuredAgentSessionCreateRefusalError) {
         settleStructuredLaunchRefusal(state)
       } else if (!state.visibilityUnknown) {
@@ -158,6 +160,7 @@ function restartStructuredLaunchState(state: StructuredLaunchState): void {
     state.intent = retryStructuredAgentSessionLaunchIntent(state.intent)
   }
   resetStructuredLaunchCallers(state)
+  delete state.failureReason
   state.callers.outcome = 'pending'
   state.promise = wasVisibilityUnknown ? reconcileUnknownLaunch(state) : launchAndReconcile(state)
   trackLaunchSettlement(state, state.promise)
diff --git a/src/shared/agent-session-lease-adjudication.ts b/src/shared/agent-session-lease-adjudication.ts
index 0181b440c90c..18887a115e02 100644
--- a/src/shared/agent-session-lease-adjudication.ts
+++ b/src/shared/agent-session-lease-adjudication.ts
@@ -15,6 +15,7 @@ import type {
   AgentSessionHandoffStage,
   AgentSessionLease
 } from './agent-session-record'
+import type { AgentSessionOwnerVerdict } from './agent-session-wire-refusals'
 
 export type AgentSessionIdentityMatchField = 'process-start-time' | 'spawn-token'
 
@@ -100,6 +101,19 @@ function deathEvidenceFor(
   return null
 }
 
+/** The store releases a lease only on proven exit or eviction; anything held or mid-handoff may run. */
+export function agentSessionLeaseOwnerVerdict(lease: AgentSessionLease): AgentSessionOwnerVerdict {
+  if (agentSessionLeaseAdmitsWriter(lease)) {
+    return 'live'
+  }
+  return lease.claimStatus === 'released' &&
+    lease.handoffStage === null &&
+    lease.ownerProcess === null &&
+    lease.reservedSpawnToken === null
+    ? 'exited'
+    : 'unverifiable'
+}
+
 /** True when the recorded owner may write right now. Used by every mutating path in later parts. */
 export function agentSessionLeaseAdmitsWriter(lease: AgentSessionLease): boolean {
   return (
diff --git a/src/shared/agent-session-wire-refusals.ts b/src/shared/agent-session-wire-refusals.ts
index 040c3e63d5cb..c155a331151e 100644
--- a/src/shared/agent-session-wire-refusals.ts
+++ b/src/shared/agent-session-wire-refusals.ts
@@ -33,6 +33,9 @@ export function isAgentSessionWireRefusalCode(
   )
 }
 
+/** What the host last proved about a session's provider process; see the SSH execution boundary. */
+export type AgentSessionOwnerVerdict = 'live' | 'unverifiable' | 'exited'
+
 export type AgentSessionWireRefusal = {
   rewindReason?: AgentSessionRewindReason
   code: AgentSessionWireRefusalCode
@@ -43,4 +46,7 @@ export type AgentSessionWireRefusal = {
   resolution?: AgentJournalResolution
   /** On a lost compare-and-set: the revision the host actually holds. */
   currentRevision?: number
+  /** On a durably failed create: `exited` proves nothing runs for the session, so a new
+   *  operation cannot collide with this one. Absent (older hosts) reads as unverifiable. */
+  ownerVerdict?: AgentSessionOwnerVerdict
 }

From a0aa442d4cf1abff6b443efe23d3ef5dd5411de5 Mon Sep 17 00:00:00 2001
From: Brennan Benson <79079362+brennanb2025@users.noreply.github.com>
Date: Tue, 22 Sep 2026 21:14:35 -0700
Subject: [PATCH 02/67] fix(native-chat): sending into a chat that failed to
 start restarts it

---
 ...tructuredSession.launch-lifecycle.test.tsx | 70 +++++++++++++++++++
 ...tiveChatStructuredSession.test-harness.tsx |  1 +
 .../NativeChatStructuredSession.tsx           | 18 +++--
 .../use-native-chat-provisional-launch.ts     | 17 +++++
 4 files changed, 99 insertions(+), 7 deletions(-)

diff --git a/src/renderer/src/components/native-chat/NativeChatStructuredSession.launch-lifecycle.test.tsx b/src/renderer/src/components/native-chat/NativeChatStructuredSession.launch-lifecycle.test.tsx
index a5007d2e6ff3..859b93824f32 100644
--- a/src/renderer/src/components/native-chat/NativeChatStructuredSession.launch-lifecycle.test.tsx
+++ b/src/renderer/src/components/native-chat/NativeChatStructuredSession.launch-lifecycle.test.tsx
@@ -24,6 +24,7 @@ vi.mock('./NativeChatApprovalCard', () => moduleFactories.nativeChatApprovalCard
 vi.mock('./NativeChatQuestionCard', () => moduleFactories.nativeChatQuestionCard())
 
 import { NativeChatStructuredSession } from './NativeChatStructuredSession'
+import { readOutbox } from './structured-agent-session-outbox-storage'
 
 function sessionView(): React.JSX.Element {
   return (
@@ -38,6 +39,14 @@ function sessionView(): React.JSX.Element {
   )
 }
 
+function composerSend(): (text: string, attachments: unknown[]) => boolean {
+  const send = mocks.composerProps?.structuredTransport?.send
+  if (typeof send !== 'function') {
+    throw new Error('Structured composer transport was not installed')
+  }
+  return (text, attachments) => send(text, attachments)
+}
+
 describe('NativeChatStructuredSession launch lifecycle', () => {
   afterEach(() => {
     cleanup()
@@ -112,6 +121,67 @@ describe('NativeChatStructuredSession launch lifecycle', () => {
     )
   })
 
+  it('relaunches a failed start on send, then delivers the message once it publishes', async () => {
+    mocks.mode = 'outbox'
+    mocks.launchLifecycle = 'failed'
+    mocks.call.mockResolvedValue({
+      ok: true,
+      value: { submission: { clientMessageId: 'client-1', dispatchState: 'accepted' } }
+    })
+    const { rerender } = render(sessionView())
+
+    expect(composerSend()('restart and say hi', [])).toBe(true)
+    // The relaunch is launch Retry's own: a new create operation under the same session.
+    expect(mocks.retryLaunch).toHaveBeenCalledExactlyOnceWith('wt-1', 'session-1')
+    expect(mocks.call).not.toHaveBeenCalled()
+
+    mocks.launchLifecycle = 'published'
+    rerender(sessionView())
+    await waitFor(() => expect(mocks.call).toHaveBeenCalledOnce())
+    expect(mocks.call).toHaveBeenCalledWith(
+      { kind: 'local' },
+      'agentSession.send',
+      expect.objectContaining({ envelope: expect.objectContaining({ sessionId: 'session-1' }) })
+    )
+  })
+
+  it('keeps the message queued with the reason shown when the relaunch fails again', async () => {
+    mocks.mode = 'outbox'
+    mocks.launchLifecycle = 'failed'
+    mocks.call.mockResolvedValue({
+      ok: true,
+      value: { submission: { clientMessageId: 'client-1', dispatchState: 'accepted' } }
+    })
+    const { rerender } = render(sessionView())
+
+    expect(composerSend()('still there?', [])).toBe(true)
+    mocks.launchFailureReason = 'claude is not signed in'
+    rerender(sessionView())
+
+    expect(screen.getByText('Chat could not be started. claude is not signed in')).toBeTruthy()
+    expect(mocks.call).not.toHaveBeenCalled()
+    expect(readOutbox('session-1')).toEqual([
+      expect.objectContaining({
+        state: 'queued',
+        body: expect.objectContaining({ blocks: [{ type: 'text', text: 'still there?' }] })
+      })
+    ])
+
+    fireEvent.click(screen.getByRole('button', { name: 'Retry' }))
+    mocks.launchLifecycle = 'published'
+    rerender(sessionView())
+    await waitFor(() => expect(mocks.call).toHaveBeenCalledOnce())
+  })
+
+  it('leaves a send into an unconfirmed start parked without relaunching', () => {
+    mocks.mode = 'outbox'
+    mocks.launchLifecycle = 'visibility-unknown'
+    render(sessionView())
+
+    expect(composerSend()('queued while unconfirmed', [])).toBe(true)
+    expect(mocks.retryLaunch).not.toHaveBeenCalled()
+  })
+
   it.each([null, 'published'] as const)(
     'enables provider transport for lifecycle %s',
     (lifecycle) => {
diff --git a/src/renderer/src/components/native-chat/NativeChatStructuredSession.test-harness.tsx b/src/renderer/src/components/native-chat/NativeChatStructuredSession.test-harness.tsx
index 42adab5dda0a..9ca3490827bb 100644
--- a/src/renderer/src/components/native-chat/NativeChatStructuredSession.test-harness.tsx
+++ b/src/renderer/src/components/native-chat/NativeChatStructuredSession.test-harness.tsx
@@ -163,6 +163,7 @@ export function createStructuredSessionMocks() {
     },
     structuredAgentSessionLaunch: () => ({
       retryStructuredAgentSessionLaunch: mocks.retryLaunch,
+      getStructuredAgentSessionLaunchLifecycle: () => mocks.launchLifecycle,
       useStructuredAgentSessionLaunchLifecycle: () => mocks.launchLifecycle,
       useStructuredAgentSessionLaunchFailureReason: () => mocks.launchFailureReason
     }),
diff --git a/src/renderer/src/components/native-chat/NativeChatStructuredSession.tsx b/src/renderer/src/components/native-chat/NativeChatStructuredSession.tsx
index aaf3f4675ee5..3e2923dc1144 100644
--- a/src/renderer/src/components/native-chat/NativeChatStructuredSession.tsx
+++ b/src/renderer/src/components/native-chat/NativeChatStructuredSession.tsx
@@ -36,6 +36,7 @@ export function NativeChatStructuredSession(
     fileLinkContext?.worktreeId,
     props.sessionId
   )
+  const { sendThroughRelaunch } = provisionalLaunch
   const controller = useStructuredAgentSession({
     ...props,
     transportEnabled: provisionalLaunch.transportEnabled
@@ -155,12 +156,14 @@ export function NativeChatStructuredSession(
   const structuredTransport = useMemo(
     () => ({
       send: (text: string, attachments: readonly { id: string; path: string }[]): boolean =>
-        controller.send(
-          text,
-          attachments.map((attachment) => ({
-            path: attachment.path,
-            previewUri: attachment.path
-          }))
+        sendThroughRelaunch(() =>
+          controller.send(
+            text,
+            attachments.map((attachment) => ({
+              path: attachment.path,
+              previewUri: attachment.path
+            }))
+          )
         ),
       dispatchCommand: (text: string) =>
         dispatchStructuredAgentSessionComposerCommand(text, {
@@ -192,7 +195,8 @@ export function NativeChatStructuredSession(
       optionPickerRequest,
       props.agent,
       props.sessionId,
-      props.target
+      props.target,
+      sendThroughRelaunch
     ]
   )
 
diff --git a/src/renderer/src/components/native-chat/use-native-chat-provisional-launch.ts b/src/renderer/src/components/native-chat/use-native-chat-provisional-launch.ts
index ce790cf7c6c2..800e56476f02 100644
--- a/src/renderer/src/components/native-chat/use-native-chat-provisional-launch.ts
+++ b/src/renderer/src/components/native-chat/use-native-chat-provisional-launch.ts
@@ -1,5 +1,6 @@
 import { useCallback } from 'react'
 import {
+  getStructuredAgentSessionLaunchLifecycle,
   retryStructuredAgentSessionLaunch,
   useStructuredAgentSessionLaunchFailureReason,
   useStructuredAgentSessionLaunchLifecycle
@@ -16,10 +17,26 @@ export function useNativeChatProvisionalLaunch(
       retryStructuredAgentSessionLaunch(worktreeId, sessionId)
     }
   }, [sessionId, worktreeId])
+  // A send into a start that never published relaunches it; the queued message goes out on publish.
+  const sendThroughRelaunch = useCallback(
+    (send: () => boolean): boolean => {
+      const accepted = send()
+      if (
+        accepted &&
+        worktreeId &&
+        getStructuredAgentSessionLaunchLifecycle(worktreeId, sessionId) === 'failed'
+      ) {
+        retryStructuredAgentSessionLaunch(worktreeId, sessionId)
+      }
+      return accepted
+    },
+    [sessionId, worktreeId]
+  )
   return {
     lifecycle,
     failureReason,
     retry,
+    sendThroughRelaunch,
     transportEnabled: lifecycle === null || lifecycle === 'published'
   }
 }

From 732ae66eae9eb87013356e48576c9484231b2057 Mon Sep 17 00:00:00 2001
From: Brennan Benson <79079362+brennanb2025@users.noreply.github.com>
Date: Tue, 22 Sep 2026 16:30:00 -0700
Subject: [PATCH 03/67] fix(native-chat): a send with no live owner restarts it
 once

A provider child that timed out or exited hands its lease back, and every
later send was refused agent_session_ownership_unknown. Clients read that
code as "not admitted yet" and resend forever, while only a surface hold
could make a new child, once per mount, with its failure swallowed.

The send now routes to a live owner, otherwise restarts one from the
persisted resume state where resume eligibility allows it (single-flight
per session), otherwise refuses with the new settled
agent_session_owner_unrecoverable. Unverifiable, reserved and handed-off
leases are left alone. The desktop hold now logs its failure.
---
 .../structured-agent-session-holds.ts         |  22 +-
 ...structured-agent-session-host-mutations.ts |   2 +
 .../structured-agent-session-host.ts          |   1 +
 ...ctured-agent-session-refusal-retry.test.ts |  17 +-
 ...ctured-agent-session-send-recovery.test.ts | 205 ++++++++++++++++++
 .../structured-agent-session-send-recovery.ts | 100 +++++++++
 ...uctured-conversation-command-controller.ts |  27 ++-
 ...use-structured-agent-session-hold.test.tsx |  20 ++
 .../use-structured-agent-session-hold.ts      |   6 +-
 ...e-structured-agent-session-outbox.test.tsx |  25 +++
 src/shared/agent-session-refusal-retry.ts     |   2 +
 src/shared/agent-session-wire-refusals.ts     |   4 +-
 12 files changed, 410 insertions(+), 21 deletions(-)
 create mode 100644 src/main/native-chat/agent-session-wire/structured-agent-session-send-recovery.test.ts
 create mode 100644 src/main/native-chat/agent-session-wire/structured-agent-session-send-recovery.ts

diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-holds.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-holds.ts
index 73880022646b..d49ed086f8a8 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-holds.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-holds.ts
@@ -65,14 +65,7 @@ export class StructuredAgentSessionHolds {
     }
     if (!this.deps.hasProviderChild(sessionId)) {
       try {
-        await this.deps.resume(sessionId)
-        if (!this.deps.hasProviderChild(sessionId)) {
-          throw new Error('agent_session_ownership_unknown')
-        }
-        // The last surface can disconnect before acquisition makes a child available to release.
-        if (!this.disposed && !this.holders.isHeld(sessionId)) {
-          this.clock.arm(sessionId)
-        }
+        await this.resumeUnheld(sessionId)
       } catch (error) {
         if (!alreadyHeld && incarnation !== undefined) {
           this.release(sessionId, holderId, incarnation)
@@ -82,6 +75,19 @@ export class StructuredAgentSessionHolds {
     }
   }
 
+  /** Resumes a childless session for a writer; with no surface holding it, the child is released
+   *  on the same clock a departed surface would start. */
+  async resumeUnheld(sessionId: string): Promise<void> {
+    await this.deps.resume(sessionId)
+    if (!this.deps.hasProviderChild(sessionId)) {
+      throw new Error('agent_session_ownership_unknown')
+    }
+    // The last surface can disconnect before acquisition makes a child available to release.
+    if (!this.disposed && !this.holders.isHeld(sessionId)) {
+      this.clock.arm(sessionId)
+    }
+  }
+
   release(sessionId: string, holderId: string, expectedIncarnation?: symbol): void {
     if (!this.holders.remove(sessionId, holderId, expectedIncarnation)) {
       return
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-host-mutations.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-host-mutations.ts
index 2c8bd5fbabcc..d7480726014c 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-host-mutations.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-host-mutations.ts
@@ -41,6 +41,8 @@ export type StructuredAgentSessionMutationContext = {
   hasPendingStreamedEvents?: (sessionId: string) => boolean
   requireSession: (sessionId: string) => StructuredAgentSessionHostSession
   serialize: <T>(sessionId: string, task: () => Promise<T>) => Promise<T>
+  /** Gives a childless session a provider child; throws the refusal code when it cannot. */
+  resumeUnheld: (sessionId: string) => Promise<void>
   now: () => number
 }
 
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-host.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-host.ts
index 2a1ebb2ac499..541e42b379fb 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-host.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-host.ts
@@ -277,6 +277,7 @@ export class StructuredAgentSessionHost {
         this.runtimeState.hasPendingStreamedEvents(sessionId),
       requireSession: (sessionId) => this.requireSession(sessionId),
       serialize: (sessionId, task) => this.serialize(sessionId, task),
+      resumeUnheld: (sessionId) => this.holds.resumeUnheld(sessionId),
       now: () => this.now()
     }
   }
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-refusal-retry.test.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-refusal-retry.test.ts
index ccad5f7225f7..496df6bcb44e 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-refusal-retry.test.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-refusal-retry.test.ts
@@ -247,7 +247,9 @@ const UNREACHABLE = new Set<Pair>([
   'agentSession.setOption:agent_session_journal_unreadable',
   'agentSession.send:agent_session_journal_unreadable',
   // Send reconstructs doubt from its global tombstone instead of refusing it.
-  'agentSession.send:agent_session_operation_unknown'
+  'agentSession.send:agent_session_operation_unknown',
+  // Only a send restarts a lost owner.
+  'agentSession.setOption:agent_session_owner_unrecoverable'
 ])
 
 describe('agentSessionRefusalOperationState host oracle', () => {
@@ -373,6 +375,19 @@ describe('agentSessionRefusalOperationState host oracle', () => {
       )
     }
 
+    const unrecoverable = await createHarness()
+    await unrecoverable.host.close(SESSION)
+    unrecoverable.host.deps.adapter.acquire = async () => {
+      throw new Error('no provider thread to resume')
+    }
+    record(
+      await assertHostAgreement(
+        unrecoverable,
+        { method: 'agentSession.send', operationId: operationId() },
+        'agent_session_owner_unrecoverable'
+      )
+    )
+
     const allPairs = METHODS.flatMap((method) =>
       AGENT_SESSION_WIRE_REFUSAL_CODES.map((code) => `${method}:${code}` as Pair)
     )
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-send-recovery.test.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-send-recovery.test.ts
new file mode 100644
index 000000000000..c79d6b7c4f9c
--- /dev/null
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-send-recovery.test.ts
@@ -0,0 +1,205 @@
+// A send to a session whose provider child is gone, against the real host.
+
+import { mkdtemp, rm } from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { afterEach, beforeEach, describe, expect, it, vi, type Mock } from 'vitest'
+import { computeAgentSessionPayloadFingerprint } from '../../../shared/agent-session-mutation-envelope'
+import { agentSessionRefusalOperationState } from '../../../shared/agent-session-refusal-retry'
+import type { AgentSessionMutationEnvelope } from '../../../shared/agent-session-wire'
+import { AgentSessionRecordStore } from '../../runtime/agent-session-record-store'
+import type { StructuredAgentSessionAdapter } from './structured-agent-session-adapter'
+import { StructuredAgentSessionHost } from './structured-agent-session-host'
+import {
+  HOST_TEST_NOW as NOW,
+  HOST_TEST_SESSION as SESSION,
+  HOST_TEST_THREAD as THREAD,
+  hostTestAttachParams,
+  hostTestMessage,
+  hostTestOperationId,
+  resetHostTestOperationIds
+} from './structured-agent-session-host-test-data'
+
+const CALLER = { callerKey: 'client-1' }
+const GRACE_MS = 5
+
+let root: string
+let store: AgentSessionRecordStore
+let host: StructuredAgentSessionHost
+let acquire: Mock<StructuredAgentSessionAdapter['acquire']>
+let dispatch: Mock<StructuredAgentSessionAdapter['dispatch']>
+let hostErrors: unknown[]
+
+beforeEach(async () => {
+  root = await mkdtemp(join(tmpdir(), 'orca-send-recovery-'))
+  resetHostTestOperationIds()
+  hostErrors = []
+  let generation = 0
+  acquire = vi.fn(async ({ fence, spawnToken }) => ({
+    process: { hostId: 'local', pid: 4242, processStartTimeMs: 1_700_000_000_000, spawnToken },
+    acquisitionGeneration: `generation-${++generation}`,
+    link: {
+      linkId: `link-${fence}`,
+      handle: { provider: 'codex' as const, threadId: THREAD },
+      origin: store.getRecord(SESSION)?.providerHandleChain.length
+        ? ('resumed' as const)
+        : ('created' as const),
+      mintedAtFence: fence,
+      observedAt: NOW
+    }
+  }))
+  dispatch = vi.fn(async () => ({
+    state: 'accepted' as const,
+    providerIdentity: {
+      provider: 'codex' as const,
+      threadId: THREAD,
+      turnId: `turn-${dispatch.mock.calls.length}`,
+      ordinal: dispatch.mock.calls.length
+    }
+  }))
+  store = await AgentSessionRecordStore.open({ directory: join(root, 'store'), hostId: 'local' })
+  host = new StructuredAgentSessionHost({
+    store,
+    adapter: {
+      acquire,
+      dispatch,
+      closeSession: vi.fn(async () => true),
+      releaseAcquisition: vi.fn(async () => true),
+      cancelTurn: vi.fn(async () => ({ cancelled: false })),
+      answerPrompt: vi.fn(async () => undefined),
+      setOption: vi.fn(async () => undefined)
+    },
+    journalRoot: root,
+    claimKeyId: 'key-1',
+    mintSpawnToken: () => `spawn-${acquire.mock.calls.length}`,
+    releaseGraceMs: GRACE_MS,
+    now: () => NOW,
+    onEventSinkError: ({ error }) => hostErrors.push(error)
+  })
+  expect(await host.attach(CALLER, hostTestAttachParams(null))).toMatchObject({ ok: true })
+})
+
+afterEach(async () => {
+  await host.flushAllStreamedEvents()
+  await rm(root, { recursive: true, force: true })
+})
+
+function sendParams(text: string, operationId = hostTestOperationId()) {
+  const body = hostTestMessage(text)
+  const envelope: AgentSessionMutationEnvelope = {
+    sessionId: SESSION,
+    clientOperationId: operationId,
+    expectedRuntimeFence: store.getRecord(SESSION)?.lease.runtimeFence ?? 1,
+    payloadFingerprint: computeAgentSessionPayloadFingerprint({
+      method: 'agentSession.send',
+      sessionId: SESSION,
+      fields: { body }
+    })
+  }
+  return { envelope, body }
+}
+
+/** The child timed out or exited: its lease is handed back and the host holds no session. */
+async function loseOwner(): Promise<void> {
+  await host.close(SESSION)
+  expect(store.getRecord(SESSION)?.lease).toMatchObject({
+    claimStatus: 'released',
+    ownerProcess: null
+  })
+  acquire.mockClear()
+}
+
+describe('a send with no live owner', () => {
+  it('restarts the owner once and delivers against it', async () => {
+    await loseOwner()
+
+    const result = await host.send(CALLER, sendParams('after the child died'))
+
+    expect(result).toMatchObject({ ok: true, replayed: false })
+    expect(acquire).toHaveBeenCalledOnce()
+    expect(dispatch).toHaveBeenCalledOnce()
+    expect(store.getRecord(SESSION)?.lease.claimStatus).toBe('live')
+  })
+
+  it('restarts an owner that exited while the session stayed readable', async () => {
+    const fence = store.getRecord(SESSION)?.lease.runtimeFence ?? 0
+    await host.handleAdapterEvent({
+      type: 'ended',
+      sessionId: SESSION,
+      reason: 'provider exited',
+      cause: 'unexpected-exit',
+      fence,
+      acquisitionGeneration: 'generation-1'
+    })
+    expect(host.hasSession(SESSION)).toBe(true)
+    expect(store.getRecord(SESSION)?.lease.claimStatus).toBe('released')
+    acquire.mockClear()
+
+    await expect(host.send(CALLER, sendParams('after an exit'))).resolves.toMatchObject({
+      ok: true
+    })
+    expect(acquire).toHaveBeenCalledOnce()
+  })
+
+  it('shares one restart between concurrent sends', async () => {
+    await loseOwner()
+
+    const results = await Promise.all([
+      host.send(CALLER, sendParams('first')),
+      host.send(CALLER, sendParams('second')),
+      host.send(CALLER, sendParams('third'))
+    ])
+
+    expect(results.map((result) => result.ok)).toEqual([true, true, true])
+    expect(acquire).toHaveBeenCalledOnce()
+    expect(dispatch).toHaveBeenCalledTimes(3)
+  })
+
+  it('replays a resent operation instead of running or restarting it again', async () => {
+    const params = sendParams('sent once')
+    await expect(host.send(CALLER, params)).resolves.toMatchObject({ ok: true, replayed: false })
+    await loseOwner()
+
+    await expect(host.send(CALLER, params)).resolves.toMatchObject({ ok: true, replayed: true })
+    await expect(host.send(CALLER, params)).resolves.toMatchObject({ ok: true, replayed: true })
+
+    expect(acquire).toHaveBeenCalledOnce()
+    expect(dispatch).toHaveBeenCalledOnce()
+  })
+
+  it('refuses for good when the owner cannot be restarted', async () => {
+    await loseOwner()
+    acquire.mockRejectedValue(new Error('no provider thread to resume'))
+
+    const result = await host.send(CALLER, sendParams('nothing to resume'))
+
+    expect(result).toMatchObject({
+      ok: false,
+      refusal: {
+        code: 'agent_session_owner_unrecoverable',
+        message: expect.stringMatching(/new chat/)
+      }
+    })
+    expect(dispatch).not.toHaveBeenCalled()
+    expect(hostErrors).not.toEqual([])
+    expect(
+      agentSessionRefusalOperationState('agentSession.send', 'agent_session_owner_unrecoverable')
+    ).toBe('settled-rejected')
+  })
+
+  it('leaves a lease it cannot adjudicate alone', async () => {
+    await loseOwner()
+    await store.transitionHandoff(SESSION, (current) => ({
+      ...current,
+      lease: { ...current.lease, unreconciled: true }
+    }))
+
+    const result = await host.send(CALLER, sendParams('owner unverifiable'))
+
+    expect(result).toMatchObject({
+      ok: false,
+      refusal: { code: 'agent_session_ownership_unknown' }
+    })
+    expect(acquire).not.toHaveBeenCalled()
+  })
+})
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-send-recovery.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-send-recovery.ts
new file mode 100644
index 000000000000..f09192451cd5
--- /dev/null
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-send-recovery.ts
@@ -0,0 +1,100 @@
+// A send that finds no live owner restarts it once, then runs against the new one.
+//
+// A provider child that exits or fails to start hands its lease back. Before this, a send to that
+// session was refused `agent_session_ownership_unknown` — which a client reads as "not admitted
+// yet" and resends forever — and only a surface hold could ever make a new child. Now the send
+// itself decides: route to a live owner; otherwise restart one from the persisted resume state
+// where resume is allowed; otherwise refuse with a code the client stops on.
+
+import type { AgentSessionRecord } from '../../../shared/agent-session-record'
+import type {
+  AgentSessionMutationResult,
+  AgentSessionSendResult,
+  AgentSessionWireRefusal
+} from '../../../shared/agent-session-wire'
+import { refuseAgentSessionMutation } from './structured-agent-session-mutation-admission'
+import { isResumableStructuredAgentSessionRecord } from './structured-agent-session-resume-eligibility'
+import type { sendStructuredAgentSessionTurn } from './structured-agent-session-host-mutations'
+
+export const AGENT_SESSION_OWNER_UNRECOVERABLE: AgentSessionWireRefusal = {
+  code: 'agent_session_owner_unrecoverable',
+  message: "This chat's agent stopped and could not be restarted. Start a new chat to continue."
+}
+
+// A resume refused this way met a lease someone else is settling — not proof it cannot resume.
+const TRANSIENT_RESUME_REFUSALS: ReadonlySet<string> = new Set([
+  'execution_owner_reconciling',
+  'agent_session_conflict',
+  'agent_session_checkpoint_stale',
+  'agent_session_ownership_unknown',
+  'agent_session_operation_capacity'
+])
+
+type SendParams = Parameters<typeof sendStructuredAgentSessionTurn>[2]
+type SendResult = AgentSessionMutationResult<AgentSessionSendResult>
+type Recovery = 'resumed' | 'transient' | 'unrecoverable'
+
+export class StructuredAgentSessionSendRecovery {
+  private readonly inFlight = new Map<string, Promise<Recovery>>()
+
+  constructor(
+    private readonly deps: {
+      getRecord: (sessionId: string) => AgentSessionRecord | undefined
+      /** Gives the session a provider child; throws the refusal code when it cannot. */
+      resume: (sessionId: string) => Promise<void>
+      onError?: (input: { sessionId: string; error: unknown }) => void
+    }
+  ) {}
+
+  async send(params: SendParams, run: (params: SendParams) => Promise<SendResult>) {
+    const first = await run(params)
+    if (first.ok || first.refusal.code !== 'agent_session_ownership_unknown') {
+      return first
+    }
+    const { sessionId, expectedRuntimeFence } = params.envelope
+    const record = this.deps.getRecord(sessionId)
+    // Unverifiable, still reserved, or handed off: that lease is not this send's to replace.
+    if (
+      !this.inFlight.has(sessionId) &&
+      (!record || !isResumableStructuredAgentSessionRecord(record))
+    ) {
+      return first
+    }
+    const fromFence = record?.lease.runtimeFence
+    const recovery = await this.recover(sessionId)
+    if (recovery === 'unrecoverable') {
+      return refuseAgentSessionMutation(AGENT_SESSION_OWNER_UNRECOVERABLE)
+    }
+    const toFence = this.deps.getRecord(sessionId)?.lease.runtimeFence
+    // The client was current as of the lost owner; the new owner is the only thing that moved.
+    const rebase =
+      recovery === 'resumed' && expectedRuntimeFence === fromFence && toFence !== undefined
+    return run(
+      rebase
+        ? { ...params, envelope: { ...params.envelope, expectedRuntimeFence: toFence } }
+        : params
+    )
+  }
+
+  private recover(sessionId: string): Promise<Recovery> {
+    const running = this.inFlight.get(sessionId)
+    if (running) {
+      return running
+    }
+    const recovery = this.deps
+      .resume(sessionId)
+      .then(
+        (): Recovery => 'resumed',
+        (error: unknown): Recovery => {
+          if (error instanceof Error && TRANSIENT_RESUME_REFUSALS.has(error.message)) {
+            return 'transient'
+          }
+          this.deps.onError?.({ sessionId, error })
+          return 'unrecoverable'
+        }
+      )
+      .finally(() => this.inFlight.delete(sessionId))
+    this.inFlight.set(sessionId, recovery)
+    return recovery
+  }
+}
diff --git a/src/main/native-chat/agent-session-wire/structured-conversation-command-controller.ts b/src/main/native-chat/agent-session-wire/structured-conversation-command-controller.ts
index e5a0283ba836..ae71349c0492 100644
--- a/src/main/native-chat/agent-session-wire/structured-conversation-command-controller.ts
+++ b/src/main/native-chat/agent-session-wire/structured-conversation-command-controller.ts
@@ -1,4 +1,5 @@
 import { sendStructuredAgentSessionTurn } from './structured-agent-session-host-mutations'
+import { StructuredAgentSessionSendRecovery } from './structured-agent-session-send-recovery'
 import {
   runStructuredConversationCommand,
   type ConversationCommandParams
@@ -13,19 +14,27 @@ export class StructuredConversationCommandController {
     private readonly context: () => StructuredAgentSessionMutationContext,
     private readonly host: Pick<StructuredAgentSessionHost, 'attach' | 'flushStreamedEvents'>
   ) {}
+  private readonly recovery = new StructuredAgentSessionSendRecovery({
+    getRecord: (sessionId) => this.context().deps.store.getRecord(sessionId),
+    resume: (sessionId) => this.context().resumeUnheld(sessionId),
+    onError: (input) => this.context().deps.onEventSinkError?.(input)
+  })
+
   send = (
     caller: StructuredAgentSessionCaller,
     params: Parameters<typeof sendStructuredAgentSessionTurn>[2]
   ): ReturnType<typeof sendStructuredAgentSessionTurn> =>
-    this.pending.has(params.envelope.sessionId)
-      ? Promise.resolve({
-          ok: false,
-          refusal: {
-            code: 'agent_session_operation_invalid',
-            message: 'Wait for the conversation operation to finish.'
-          }
-        })
-      : sendStructuredAgentSessionTurn(this.context(), caller, params)
+    this.recovery.send(params, (next) =>
+      this.pending.has(next.envelope.sessionId)
+        ? Promise.resolve({
+            ok: false,
+            refusal: {
+              code: 'agent_session_operation_invalid',
+              message: 'Wait for the conversation operation to finish.'
+            }
+          })
+        : sendStructuredAgentSessionTurn(this.context(), caller, next)
+    )
 
   run = (caller: StructuredAgentSessionCaller, params: ConversationCommandParams) => {
     const key = JSON.stringify([caller.callerKey, params.envelope.clientOperationId])
diff --git a/src/renderer/src/components/native-chat/use-structured-agent-session-hold.test.tsx b/src/renderer/src/components/native-chat/use-structured-agent-session-hold.test.tsx
index d8c9981ad042..6e5b248fdb13 100644
--- a/src/renderer/src/components/native-chat/use-structured-agent-session-hold.test.tsx
+++ b/src/renderer/src/components/native-chat/use-structured-agent-session-hold.test.tsx
@@ -78,6 +78,26 @@ describe('a mounted structured chat', () => {
     await waitFor(() => expect(callsTo('agentSession.release')).toHaveLength(1))
   })
 
+  it('reports a hold the host refused and still releases on unmount', async () => {
+    const warn = vi.spyOn(console, 'warn').mockImplementation(() => undefined)
+    const refused = new Error('structured_agent_session_unsupported')
+    mocks.call.mockImplementation((_target: unknown, method: string) =>
+      method === 'agentSession.hold' ? Promise.reject(refused) : Promise.resolve()
+    )
+    const { unmount } = renderHook(() =>
+      useStructuredAgentSessionHold({
+        sessionId: 'session-alpha',
+        target: LOCAL_TARGET,
+        surface: 'desktop-chat'
+      })
+    )
+
+    await waitFor(() => expect(warn).toHaveBeenCalledWith(expect.any(String), refused))
+    unmount()
+    await waitFor(() => expect(callsTo('agentSession.release')).toHaveLength(1))
+    warn.mockRestore()
+  })
+
   it('keeps one hold across re-renders that rebuild the target object', async () => {
     const { rerender, unmount } = renderHook(
       (props: { sessionId: string }) =>
diff --git a/src/renderer/src/components/native-chat/use-structured-agent-session-hold.ts b/src/renderer/src/components/native-chat/use-structured-agent-session-hold.ts
index 2c91621d30ad..628a369281bb 100644
--- a/src/renderer/src/components/native-chat/use-structured-agent-session-hold.ts
+++ b/src/renderer/src/components/native-chat/use-structured-agent-session-hold.ts
@@ -39,8 +39,10 @@ export function useStructuredAgentSessionHold(args: {
     const held = callStructuredAgentSession(runtimeTarget, 'agentSession.hold', {
       sessionId,
       holderId
-      // An older host has no such method; the session still reads, it just is not held.
-    }).catch(() => undefined)
+    }).catch((error: unknown) => {
+      // The session still reads, and a send restarts the agent itself; this only leaves a trace.
+      console.warn('[structured-agent-session] hold failed:', error)
+    })
     return () => {
       void held.then(() =>
         callStructuredAgentSession(runtimeTarget, 'agentSession.release', {
diff --git a/src/renderer/src/components/native-chat/use-structured-agent-session-outbox.test.tsx b/src/renderer/src/components/native-chat/use-structured-agent-session-outbox.test.tsx
index a0b94657e79c..60e4506ae7d9 100644
--- a/src/renderer/src/components/native-chat/use-structured-agent-session-outbox.test.tsx
+++ b/src/renderer/src/components/native-chat/use-structured-agent-session-outbox.test.tsx
@@ -529,6 +529,31 @@ describe('useStructuredAgentSessionOutbox', () => {
     ).toBe(firstId)
   })
 
+  it('stops on a host that could not restart the agent and shows its message', async () => {
+    const message =
+      "This chat's agent stopped and could not be restarted. Start a new chat to continue."
+    mocks.call.mockResolvedValue({
+      ok: false,
+      refusal: { code: 'agent_session_owner_unrecoverable', message }
+    })
+    const { result } = renderHook(() =>
+      useStructuredAgentSessionOutbox({
+        sessionId: 'session-1',
+        target: LOCAL_TARGET,
+        fence: 1,
+        submissions: []
+      })
+    )
+
+    act(() => expect(result.current.send('hello')).toBe(true))
+    await waitFor(() => expect(result.current.error).toBe(message))
+    await act(() => new Promise((resolve) => setTimeout(resolve, 50)))
+
+    expect(mocks.call).toHaveBeenCalledOnce()
+    expect(result.current.outbox).toHaveLength(1)
+    expect(result.current.blockedClientMessageId).toBe(result.current.outbox[0]?.clientMessageId)
+  })
+
   it('persists and dispatches an attachment-only structured send', async () => {
     mocks.call.mockResolvedValue(acceptedResult(1))
     const { result } = renderHook(() =>
diff --git a/src/shared/agent-session-refusal-retry.ts b/src/shared/agent-session-refusal-retry.ts
index 94c8f65c4138..73799d4f756d 100644
--- a/src/shared/agent-session-refusal-retry.ts
+++ b/src/shared/agent-session-refusal-retry.ts
@@ -17,6 +17,8 @@ export function agentSessionRefusalOperationState(
     return 'settled-rejected'
   }
   switch (code) {
+    // The host already tried to restart the owner for this send and could not.
+    case 'agent_session_owner_unrecoverable':
     case 'agent_session_operation_conflict':
     case 'agent_session_operation_expired':
     case 'agent_session_operation_invalid':
diff --git a/src/shared/agent-session-wire-refusals.ts b/src/shared/agent-session-wire-refusals.ts
index c155a331151e..c3ca6bdb710c 100644
--- a/src/shared/agent-session-wire-refusals.ts
+++ b/src/shared/agent-session-wire-refusals.ts
@@ -18,7 +18,9 @@ export const AGENT_SESSION_WIRE_REFUSAL_CODES = [
   'agent_session_already_resolved',
   'agent_session_identity_required',
   'agent_session_journal_unreadable',
-  'execution_owner_reconciling'
+  'execution_owner_reconciling',
+  // Older clients hold an unknown code as a blocked send with the host's message shown.
+  'agent_session_owner_unrecoverable'
 ] as const
 export type AgentSessionWireRefusalCode = (typeof AGENT_SESSION_WIRE_REFUSAL_CODES)[number]
 

From 480b316621ef5a8f5e30af7fb82fe28c3e8fd476 Mon Sep 17 00:00:00 2001
From: Brennan Benson <79079362+brennanb2025@users.noreply.github.com>
Date: Tue, 22 Sep 2026 16:30:31 -0700
Subject: [PATCH 04/67] test(native-chat): pin the unrecoverable refusal as
 settled in the outbox

---
 .../native-chat/use-structured-agent-session-outbox.test.tsx   | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/src/renderer/src/components/native-chat/use-structured-agent-session-outbox.test.tsx b/src/renderer/src/components/native-chat/use-structured-agent-session-outbox.test.tsx
index 60e4506ae7d9..1f9b9d4b565f 100644
--- a/src/renderer/src/components/native-chat/use-structured-agent-session-outbox.test.tsx
+++ b/src/renderer/src/components/native-chat/use-structured-agent-session-outbox.test.tsx
@@ -552,6 +552,9 @@ describe('useStructuredAgentSessionOutbox', () => {
     expect(mocks.call).toHaveBeenCalledOnce()
     expect(result.current.outbox).toHaveLength(1)
     expect(result.current.blockedClientMessageId).toBe(result.current.outbox[0]?.clientMessageId)
+    // Settled, not pending: the refused id never ran, so a Retry is a new operation.
+    const sentId = mocks.call.mock.calls[0]![2].envelope.clientOperationId as string
+    expect(result.current.outbox[0]?.clientMessageId).not.toBe(sentId)
   })
 
   it('persists and dispatches an attachment-only structured send', async () => {

From 34bd71124517301b8dbd666ce8dc3b9f444db0ce Mon Sep 17 00:00:00 2001
From: Brennan Benson <79079362+brennanb2025@users.noreply.github.com>
Date: Tue, 22 Sep 2026 16:34:26 -0700
Subject: [PATCH 05/67] test(native-chat): pin the release clock after a send
 restarts an unheld owner

---
 ...ctured-agent-session-send-recovery.test.ts | 19 ++++++++++++++++++-
 1 file changed, 18 insertions(+), 1 deletion(-)

diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-send-recovery.test.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-send-recovery.test.ts
index c79d6b7c4f9c..cafa9bea9067 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-send-recovery.test.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-send-recovery.test.ts
@@ -21,7 +21,8 @@ import {
 } from './structured-agent-session-host-test-data'
 
 const CALLER = { callerKey: 'client-1' }
-const GRACE_MS = 5
+// Long enough that no release fires mid-test; whether one is pending is asserted directly.
+const GRACE_MS = 60_000
 
 let root: string
 let store: AgentSessionRecordStore
@@ -121,6 +122,22 @@ describe('a send with no live owner', () => {
     expect(store.getRecord(SESSION)?.lease.claimStatus).toBe('live')
   })
 
+  it('releases the restarted child on the usual clock only when no surface holds it', async () => {
+    await loseOwner()
+    await expect(host.send(CALLER, sendParams('nobody is watching'))).resolves.toMatchObject({
+      ok: true
+    })
+    expect(host['holds'].isReleasePending(SESSION)).toBe(true)
+
+    await host.close(SESSION)
+    // A reading surface that does not itself restart the agent.
+    await host.hold(SESSION, 'desktop-chat:1', { resume: false })
+    await expect(host.send(CALLER, sendParams('the chat is open'))).resolves.toMatchObject({
+      ok: true
+    })
+    expect(host['holds'].isReleasePending(SESSION)).toBe(false)
+  })
+
   it('restarts an owner that exited while the session stayed readable', async () => {
     const fence = store.getRecord(SESSION)?.lease.runtimeFence ?? 0
     await host.handleAdapterEvent({

From b1bc4ecdb1c7a9609581aabfa6d6c487c46cec14 Mon Sep 17 00:00:00 2001
From: Brennan Benson <79079362+brennanb2025@users.noreply.github.com>
Date: Tue, 22 Sep 2026 16:39:05 -0700
Subject: [PATCH 06/67] test: read the sent operation id without a cast

---
 .../native-chat/use-structured-agent-session-outbox.test.tsx    | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/renderer/src/components/native-chat/use-structured-agent-session-outbox.test.tsx b/src/renderer/src/components/native-chat/use-structured-agent-session-outbox.test.tsx
index 1f9b9d4b565f..d0542dca95f3 100644
--- a/src/renderer/src/components/native-chat/use-structured-agent-session-outbox.test.tsx
+++ b/src/renderer/src/components/native-chat/use-structured-agent-session-outbox.test.tsx
@@ -553,7 +553,7 @@ describe('useStructuredAgentSessionOutbox', () => {
     expect(result.current.outbox).toHaveLength(1)
     expect(result.current.blockedClientMessageId).toBe(result.current.outbox[0]?.clientMessageId)
     // Settled, not pending: the refused id never ran, so a Retry is a new operation.
-    const sentId = mocks.call.mock.calls[0]![2].envelope.clientOperationId as string
+    const sentId: unknown = mocks.call.mock.calls[0]![2].envelope.clientOperationId
     expect(result.current.outbox[0]?.clientMessageId).not.toBe(sentId)
   })
 

From 70b42b7a220bdb684524e294357f753a830e2ac0 Mon Sep 17 00:00:00 2001
From: Brennan Benson <79079362+brennanb2025@users.noreply.github.com>
Date: Tue, 22 Sep 2026 16:41:09 -0700
Subject: [PATCH 07/67] fix(native-chat): type the send-recovery record lookup
 as the store returns it

---
 .../structured-agent-session-send-recovery.ts                   | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-send-recovery.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-send-recovery.ts
index f09192451cd5..1fd866223515 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-send-recovery.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-send-recovery.ts
@@ -39,7 +39,7 @@ export class StructuredAgentSessionSendRecovery {
 
   constructor(
     private readonly deps: {
-      getRecord: (sessionId: string) => AgentSessionRecord | undefined
+      getRecord: (sessionId: string) => AgentSessionRecord | null
       /** Gives the session a provider child; throws the refusal code when it cannot. */
       resume: (sessionId: string) => Promise<void>
       onError?: (input: { sessionId: string; error: unknown }) => void

From 509c688b632b01b09c59ed6213a8f7c07eebee64 Mon Sep 17 00:00:00 2001
From: Brennan Benson <79079362+brennanb2025@users.noreply.github.com>
Date: Tue, 22 Sep 2026 21:16:56 -0700
Subject: [PATCH 08/67] fix(native-chat): a send ensures its owner before
 admission, and an unheld owner idles for 30 minutes

---
 ...tructured-agent-session-client-delivery.ts |  4 +-
 .../structured-agent-session-holds.test.ts    | 36 +++++++++++
 .../structured-agent-session-holds.ts         |  7 ++-
 ...structured-agent-session-host-mutations.ts | 54 ++++++++++-------
 .../structured-agent-session-host.ts          |  5 +-
 .../structured-agent-session-release-clock.ts | 28 +++++----
 ...ctured-agent-session-send-recovery.test.ts | 60 +++++++++++++++++++
 .../structured-agent-session-send-recovery.ts | 25 ++++----
 .../visible-worktree-activity-inputs.ts       |  4 +-
 9 files changed, 174 insertions(+), 49 deletions(-)

diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-client-delivery.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-client-delivery.ts
index c2702fcd66df..7681e0f34362 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-client-delivery.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-client-delivery.ts
@@ -26,7 +26,8 @@ export class StructuredAgentSessionClientDelivery {
   constructor(
     private readonly sessions: Map<string, StructuredAgentSessionHostSession>,
     now: () => number,
-    deps: () => StructuredAgentSessionHostDeps
+    deps: () => StructuredAgentSessionHostDeps,
+    private readonly onJournalActivity?: (sessionId: string) => void
   ) {
     this.statusFeed = createStructuredAgentSessionHostStatusFeed({ sessions, now, deps })
     this.turnCompletionFeed = new StructuredAgentSessionTurnCompletionFeed({ sessions, now })
@@ -78,6 +79,7 @@ export class StructuredAgentSessionClientDelivery {
     // Derived here rather than per-subscriber: this edge runs whether or not anyone is
     // subscribed, which is the whole reason a backgrounded chat can complete at all.
     this.turnCompletionFeed.observe(sessionId, journal)
+    this.onJournalActivity?.(sessionId)
   }
 
   private requireJournal(sessionId: string): AgentSessionJournal {
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-holds.test.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-holds.test.ts
index 268f28ed54e0..697c944e171b 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-holds.test.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-holds.test.ts
@@ -109,6 +109,42 @@ describe('the release clock', () => {
     expect(evict).not.toHaveBeenCalled()
   })
 
+  it('keeps an idle unheld child for thirty minutes, and activity starts the window over', async () => {
+    vi.useFakeTimers({ toFake: ['setTimeout', 'clearTimeout'] })
+    try {
+      const evict = vi.fn(async () => {})
+      const idle = new StructuredAgentSessionReleaseClock({
+        isTurnActive: () => false,
+        isHeld: () => false,
+        evict
+      })
+      clocks.push(idle)
+      const minutes = (count: number) => vi.advanceTimersByTimeAsync(count * 60_000)
+
+      idle.arm('session-1')
+      await minutes(20)
+      idle.renew('session-1')
+      await minutes(29)
+      expect(evict).not.toHaveBeenCalled()
+
+      await minutes(1)
+      expect(evict).toHaveBeenCalledWith('session-1')
+    } finally {
+      vi.useRealTimers()
+    }
+  })
+
+  it('does not start a window for a session nothing released', async () => {
+    const evict = vi.fn(async () => {})
+    const releasing = clock({ evict })
+
+    releasing.renew('session-1')
+    await new Promise((resolve) => setTimeout(resolve, 30))
+
+    expect(releasing.isArmed('session-1')).toBe(false)
+    expect(evict).not.toHaveBeenCalled()
+  })
+
   it('reports a failed eviction rather than swallowing it', async () => {
     const onError = vi.fn()
     const releasing = clock({
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-holds.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-holds.ts
index d49ed086f8a8..c24c9212374d 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-holds.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-holds.ts
@@ -6,7 +6,7 @@
 //
 // A surface takes a hold when it binds and drops it when it goes away. The first hold on a session
 // with no child resumes it — that, and not the shape of a lease on disk, is what makes a provider
-// process exist. The last hold leaving starts the release clock. Transport close is the BACKSTOP,
+// process exist. The last hold leaving starts the idle release clock. Transport close is the BACKSTOP,
 // not the mechanism: a client that vanishes mid-flight never sends its release, so the caller
 // registers one against the connection and the holder set absorbs the duplicate.
 
@@ -88,6 +88,11 @@ export class StructuredAgentSessionHolds {
     }
   }
 
+  /** Journal activity; only an unheld session's pending release notices. */
+  renew(sessionId: string): void {
+    this.clock.renew(sessionId)
+  }
+
   release(sessionId: string, holderId: string, expectedIncarnation?: symbol): void {
     if (!this.holders.remove(sessionId, holderId, expectedIncarnation)) {
       return
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-host-mutations.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-host-mutations.ts
index d7480726014c..dcdba261f314 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-host-mutations.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-host-mutations.ts
@@ -17,8 +17,10 @@ import type {
   AgentSessionOptionResult,
   AgentSessionOptionsResult,
   AgentSessionPromptResult,
-  AgentSessionSendResult
+  AgentSessionSendResult,
+  AgentSessionWireRefusal
 } from '../../../shared/agent-session-wire'
+import type { AgentSessionRecord } from '../../../shared/agent-session-record'
 import { admitAndRunAgentSessionMutation } from './structured-agent-session-mutation-admission'
 import {
   cancelPlan,
@@ -82,31 +84,39 @@ export function sendStructuredAgentSessionTurn(
   return mutate(context, caller, params.envelope, {
     ...plan,
     run: (ctx) => {
-      const rewind = context.deps.store.getRecord(ctx.sessionId)?.rewind
-      if (rewind?.phase === 'prepared' || rewind?.phase === 'provider-succeeded') {
-        return Promise.resolve(rewindRefusal('outcome-unknown'))
-      }
-      const command = context.deps.store.getRecord(ctx.sessionId)?.conversationCommand
-      if (
-        command &&
-        ((command.state === 'unknown' && command.phase === 'prepared') ||
-          (command.command === 'clear' && command.replacementSessionId))
-      ) {
-        return Promise.resolve({
-          ok: false,
-          refusal: {
-            code: 'agent_session_operation_invalid',
-            message: command.replacementSessionId
-              ? 'This conversation has been cleared. Use the current conversation.'
-              : 'The conversation operation is unconfirmed.'
-          }
-        })
-      }
-      return plan.run(ctx)
+      const blocked = structuredAgentSessionSendBlock(context.deps.store.getRecord(ctx.sessionId))
+      return blocked ? Promise.resolve(blocked) : plan.run(ctx)
     }
   })
 }
 
+/** Why the record refuses any send right now, whoever owns it; null when a send may run. */
+export function structuredAgentSessionSendBlock(
+  record: AgentSessionRecord | null
+): { ok: false; refusal: AgentSessionWireRefusal } | null {
+  const rewind = record?.rewind
+  if (rewind?.phase === 'prepared' || rewind?.phase === 'provider-succeeded') {
+    return rewindRefusal('outcome-unknown')
+  }
+  const command = record?.conversationCommand
+  if (
+    command &&
+    ((command.state === 'unknown' && command.phase === 'prepared') ||
+      (command.command === 'clear' && command.replacementSessionId))
+  ) {
+    return {
+      ok: false,
+      refusal: {
+        code: 'agent_session_operation_invalid',
+        message: command.replacementSessionId
+          ? 'This conversation has been cleared. Use the current conversation.'
+          : 'The conversation operation is unconfirmed.'
+      }
+    }
+  }
+  return null
+}
+
 export function cancelStructuredAgentSessionTurn(
   context: StructuredAgentSessionMutationContext,
   caller: StructuredAgentSessionCaller,
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-host.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-host.ts
index 541e42b379fb..2aa2c3f3c55d 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-host.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-host.ts
@@ -66,7 +66,8 @@ export class StructuredAgentSessionHost {
   private readonly clientDelivery = new StructuredAgentSessionClientDelivery(
     this.sessions,
     () => this.now(),
-    () => this.deps
+    () => this.deps,
+    (sessionId) => this.holds.renew(sessionId)
   )
   private readonly subscribers = this.clientDelivery.subscribers
   private readonly tasks = new StructuredAgentSessionTaskQueue()
@@ -170,7 +171,7 @@ export class StructuredAgentSessionHost {
     options?: StructuredAgentSessionHoldOptions
   ): Promise<void> => this.holds.hold(sessionId, holderId, options)
 
-  /** That surface is gone. The child outlives it by the release grace, and by any running turn. */
+  /** That surface is gone. The child outlives it by the idle window, and by any running turn. */
   release = (sessionId: string, holderId: string): void => this.holds.release(sessionId, holderId)
 
   handleAdapterEvent = (event: Parameters<StructuredAgentSessionEventRecovery['handle']>[0]) =>
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-release-clock.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-release-clock.ts
index 452e6a6fae03..d2454b8b7fe3 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-release-clock.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-release-clock.ts
@@ -1,16 +1,17 @@
-// The delay between "nothing holds this session" and "stop its provider child".
+// The delay between "nothing holds this session and nothing has happened in it" and "stop its
+// provider child".
 //
-// TWO reasons it is not immediate. A surface that reconnects — a mobile socket dropping on a
-// network switch, a renderer remounting a tab — releases and re-holds within a second, and killing
-// an app-server in that window costs the user a respawn plus a resume for nothing. And a turn the
-// user already asked for must finish: the provider is mid-answer, the journal has an open turn
-// marker, and stopping the child there strands both.
+// It is an IDLE window, not a short grace. A surface that reconnects — a mobile socket dropping on
+// a network switch, a renderer remounting a tab, a worktree switch hiding the pane — releases and
+// re-holds, and a send to a chat nobody is looking at restarts its owner; stopping the child soon
+// after either costs the user a respawn plus a resume on the next message. And a turn the user
+// already asked for must finish: stopping the child mid-answer strands the open turn marker.
 //
-// So the clock arms when the last holder leaves, and a tick that finds a turn still running RE-ARMS
-// instead of evicting. That is what makes the wait start at the later of the two events rather than
-// at whichever came first.
+// So the clock arms when the last holder leaves, every journal write while it is armed starts it
+// again, and a tick that finds a turn still running re-arms instead of evicting. The child goes
+// only after a full window with no holder and no activity. Quit still stops every child at once.
 
-export const STRUCTURED_AGENT_SESSION_RELEASE_GRACE_MS = 15_000
+export const STRUCTURED_AGENT_SESSION_RELEASE_GRACE_MS = 30 * 60_000
 
 export type StructuredAgentSessionReleaseClockDeps = {
   /** Never evict mid-turn; a true answer re-arms the clock instead. */
@@ -41,6 +42,13 @@ export class StructuredAgentSessionReleaseClock {
     this.timers.set(sessionId, timer)
   }
 
+  /** Activity in an unheld session: the idle window starts over. */
+  renew(sessionId: string): void {
+    if (this.timers.has(sessionId)) {
+      this.arm(sessionId)
+    }
+  }
+
   cancel(sessionId: string): void {
     const timer = this.timers.get(sessionId)
     if (timer) {
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-send-recovery.test.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-send-recovery.test.ts
index cafa9bea9067..6b13741ad9c8 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-send-recovery.test.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-send-recovery.test.ts
@@ -10,6 +10,7 @@ import type { AgentSessionMutationEnvelope } from '../../../shared/agent-session
 import { AgentSessionRecordStore } from '../../runtime/agent-session-record-store'
 import type { StructuredAgentSessionAdapter } from './structured-agent-session-adapter'
 import { StructuredAgentSessionHost } from './structured-agent-session-host'
+import { StructuredAgentSessionSendRecovery } from './structured-agent-session-send-recovery'
 import {
   HOST_TEST_NOW as NOW,
   HOST_TEST_SESSION as SESSION,
@@ -122,6 +123,65 @@ describe('a send with no live owner', () => {
     expect(store.getRecord(SESSION)?.lease.claimStatus).toBe('live')
   })
 
+  it('restarts the owner before the send is admitted, so the send runs once', async () => {
+    await loseOwner()
+    const order: string[] = []
+    const recovery = new StructuredAgentSessionSendRecovery({
+      getRecord: (sessionId) => store.getRecord(sessionId),
+      resume: async () => {
+        order.push('resume')
+      }
+    })
+
+    await recovery.send(sendParams('ensure first'), async () => {
+      order.push('run')
+      return { ok: false, refusal: { code: 'agent_session_operation_invalid', message: 'stub' } }
+    })
+
+    expect(order).toEqual(['resume', 'run'])
+  })
+
+  it('leaves a live owner alone', async () => {
+    acquire.mockClear()
+
+    await expect(host.send(CALLER, sendParams('owner is live'))).resolves.toMatchObject({
+      ok: true
+    })
+
+    expect(acquire).not.toHaveBeenCalled()
+  })
+
+  it('does not restart an owner for a send the session refuses anyway', async () => {
+    await loseOwner()
+    await store.transitionHandoff(SESSION, (current) => ({
+      ...current,
+      conversationCommand: {
+        command: 'clear',
+        state: 'completed',
+        replacementSessionId: 'session-after-clear',
+        operationId: hostTestOperationId(),
+        callerKey: CALLER.callerKey,
+        phase: 'committed'
+      }
+    }))
+
+    await host.send(CALLER, sendParams('into a cleared chat'))
+
+    expect(acquire).not.toHaveBeenCalled()
+  })
+
+  it('renews the idle window on journal activity in an unheld session', async () => {
+    await loseOwner()
+    await expect(host.send(CALLER, sendParams('restart'))).resolves.toMatchObject({ ok: true })
+    const arm = vi.spyOn(host['holds']['clock'], 'arm')
+
+    await expect(host.send(CALLER, sendParams('more activity'))).resolves.toMatchObject({
+      ok: true
+    })
+
+    expect(arm).toHaveBeenCalledWith(SESSION)
+  })
+
   it('releases the restarted child on the usual clock only when no surface holds it', async () => {
     await loseOwner()
     await expect(host.send(CALLER, sendParams('nobody is watching'))).resolves.toMatchObject({
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-send-recovery.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-send-recovery.ts
index 1fd866223515..48b99afd3f41 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-send-recovery.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-send-recovery.ts
@@ -1,10 +1,11 @@
-// A send that finds no live owner restarts it once, then runs against the new one.
+// A send checks for a live owner before it is admitted, and restarts one if the old one is gone.
 //
 // A provider child that exits or fails to start hands its lease back. Before this, a send to that
 // session was refused `agent_session_ownership_unknown` — which a client reads as "not admitted
 // yet" and resends forever — and only a surface hold could ever make a new child. Now the send
-// itself decides: route to a live owner; otherwise restart one from the persisted resume state
-// where resume is allowed; otherwise refuse with a code the client stops on.
+// itself ensures its owner: a released lease where resume is allowed gets a child first; anything
+// else runs as it is and meets the lease check in admission. A restart that fails for good refuses
+// with a code the client stops on.
 
 import type { AgentSessionRecord } from '../../../shared/agent-session-record'
 import type {
@@ -14,7 +15,10 @@ import type {
 } from '../../../shared/agent-session-wire'
 import { refuseAgentSessionMutation } from './structured-agent-session-mutation-admission'
 import { isResumableStructuredAgentSessionRecord } from './structured-agent-session-resume-eligibility'
-import type { sendStructuredAgentSessionTurn } from './structured-agent-session-host-mutations'
+import {
+  structuredAgentSessionSendBlock,
+  type sendStructuredAgentSessionTurn
+} from './structured-agent-session-host-mutations'
 
 export const AGENT_SESSION_OWNER_UNRECOVERABLE: AgentSessionWireRefusal = {
   code: 'agent_session_owner_unrecoverable',
@@ -47,18 +51,17 @@ export class StructuredAgentSessionSendRecovery {
   ) {}
 
   async send(params: SendParams, run: (params: SendParams) => Promise<SendResult>) {
-    const first = await run(params)
-    if (first.ok || first.refusal.code !== 'agent_session_ownership_unknown') {
-      return first
-    }
     const { sessionId, expectedRuntimeFence } = params.envelope
     const record = this.deps.getRecord(sessionId)
-    // Unverifiable, still reserved, or handed off: that lease is not this send's to replace.
+    // Live, unverifiable, still reserved, or handed off: that lease is not this send's to replace.
+    // A send the record refuses anyway must not leave a child behind it.
     if (
       !this.inFlight.has(sessionId) &&
-      (!record || !isResumableStructuredAgentSessionRecord(record))
+      (!record ||
+        !isResumableStructuredAgentSessionRecord(record) ||
+        structuredAgentSessionSendBlock(record))
     ) {
-      return first
+      return run(params)
     }
     const fromFence = record?.lease.runtimeFence
     const recovery = await this.recover(sessionId)
diff --git a/src/renderer/src/components/sidebar/visible-worktree-activity-inputs.ts b/src/renderer/src/components/sidebar/visible-worktree-activity-inputs.ts
index cdc514658abc..0d65e41a214e 100644
--- a/src/renderer/src/components/sidebar/visible-worktree-activity-inputs.ts
+++ b/src/renderer/src/components/sidebar/visible-worktree-activity-inputs.ts
@@ -43,8 +43,8 @@ const structuredChatWorktreeIds = new WeakMap<Record<string, Tab[]>, ReadonlySet
  * Worktree ids holding a structured chat tab.
  *
  * Why existence rather than a live provider child: that child is held only while the chat's pane is
- * visible and is evicted 15s after it is not, so keying on it would flip a workspace to sleeping on
- * every worktree switch and report a process recycle the user never sees. The chat itself — its
+ * visible and is evicted after it sits idle unheld, so keying on it would flip a workspace to sleeping
+ * after any worktree switch and report a process recycle the user never sees. The chat itself — its
  * transcript, and its ability to take the next send — outlives the child.
  */
 export function getWorktreeIdsWithStructuredChat(

From 1df24577a07755991e23e9830821b71522f4388b Mon Sep 17 00:00:00 2001
From: Brennan Benson <79079362+brennanb2025@users.noreply.github.com>
Date: Tue, 22 Sep 2026 22:10:32 -0700
Subject: [PATCH 09/67] fix(native-chat): a create that throws releases its
 event sink

A child that dies between spawn and journal attach can still write through
the host's event sink, which attach unbound in onAcquiring and never re-bound
because onAttached never ran. The orchestration released that sink only when
performAttach returned a refusal; a thrown failure (the root-exit path) kept
the sink cached with its queued write, so the next attach's drain barrier and
runtime shutdown's flush waited forever.

Also pins the publish-on-root-exit clause for a start that never proved:
deleting it reddened nothing before.
---
 .../claude-structured-session-startup.test.ts | 21 +++++
 ...ured-agent-session-attach-orchestration.ts | 20 +++--
 ...session-failed-create-sink-release.test.ts | 78 +++++++++++++++++++
 3 files changed, 114 insertions(+), 5 deletions(-)
 create mode 100644 src/main/native-chat/agent-session-wire/structured-agent-session-failed-create-sink-release.test.ts

diff --git a/src/main/claude/claude-structured-session-startup.test.ts b/src/main/claude/claude-structured-session-startup.test.ts
index 184716a978b9..6197cc20668d 100644
--- a/src/main/claude/claude-structured-session-startup.test.ts
+++ b/src/main/claude/claude-structured-session-startup.test.ts
@@ -106,6 +106,27 @@ describe('Claude structured session publishes before the CLI answers initialize'
     expect(claude.connections[0].closeCount).toBe(1)
   })
 
+  it('ends a start whose root exit was seen first-hand even when its descendants are unverifiable', async () => {
+    const claude = fakeClaude({
+      initDelayMs: SLOW_INIT_MS,
+      exitBeforeInit: 'claude stream-json exited (code 1): stderr says no',
+      unprovenCloseVerdict: { root: 'exited', tree: 'unverifiable' }
+    })
+    const { adapter, events } = startingAdapter(claude)
+    await adapter.acquire(ACQUIRE)
+
+    await vi.advanceTimersByTimeAsync(SLOW_INIT_MS)
+    await adapter.drainStartup('session-1')
+    await adapter.drainObservedExits()
+
+    // A failed start is released on the same evidence a failed create is; a proven-live
+    // descendant would have answered `tree: 'live'` instead.
+    expect(events.find((event) => event.type === 'ended')).toMatchObject({
+      cause: 'unexpected-exit',
+      startupUnproven: true
+    })
+  })
+
   it('ends an unauthenticated start with sign-in guidance', async () => {
     const claude = fakeClaude({ initAccount: { apiProvider: 'firstParty', tokenSource: 'none' } })
     const { adapter, events } = startingAdapter(claude)
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-attach-orchestration.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-attach-orchestration.ts
index c85536ff679c..6070539c6d1d 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-attach-orchestration.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-attach-orchestration.ts
@@ -81,6 +81,14 @@ export function attachStructuredAgentSession(
       const probe = await withAgentSessionCreatePhase('probe_owner', recordPhase, () =>
         context.runtimeState.probeOwner(sessionId)
       )
+      // Why: a failed attach that left no session behind must not strand a bound sink; the runtime
+      // caches one per session id and would hand this same closed instance to the next attempt.
+      const discardUnattachedSink = (): void => {
+        if (!context.sessions.has(sessionId)) {
+          eventSink.close()
+          context.runtimeState.discardEventSink(sessionId)
+        }
+      }
       const attached = await performAttach({
         rewind,
         store: context.deps.store,
@@ -174,12 +182,14 @@ export function attachStructuredAgentSession(
             context.subscribers.publish(sessionId, attached.journal)
           }
         }
+      }).catch((error: unknown) => {
+        // A throw is a failed attach too, and its dead child may already have queued into the
+        // unbound sink; left cached, that queue wedges the next attach's drain and shutdown.
+        discardUnattachedSink()
+        throw error
       })
-      // Why: a failed attach that left no session behind must not strand a bound sink; the runtime
-      // caches one per session id and would hand this same closed instance to the next attempt.
-      if (!attached.ok && !context.sessions.has(sessionId)) {
-        eventSink.close()
-        context.runtimeState.discardEventSink(sessionId)
+      if (!attached.ok) {
+        discardUnattachedSink()
       }
       return attached
     })
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-failed-create-sink-release.test.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-failed-create-sink-release.test.ts
new file mode 100644
index 000000000000..4248550a7e0c
--- /dev/null
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-failed-create-sink-release.test.ts
@@ -0,0 +1,78 @@
+// A child that dies between spawn and journal attach can still write through the host's event
+// sink, which attach unbound and never re-bound. That queue must die with the failed create, or
+// the next attach's drain barrier and shutdown's flush wait on it forever.
+
+import { mkdtemp, rm } from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { afterEach, beforeEach, describe, expect, it, vi, type Mock } from 'vitest'
+import { AgentSessionRecordStore } from '../../runtime/agent-session-record-store'
+import type { StructuredAgentSessionAdapter } from './structured-agent-session-adapter'
+import { StructuredAgentSessionHost } from './structured-agent-session-host'
+import {
+  HOST_TEST_NOW as NOW,
+  HOST_TEST_THREAD as THREAD,
+  hostTestAttachParams,
+  resetHostTestOperationIds
+} from './structured-agent-session-host-test-data'
+
+const CALLER = { callerKey: 'client-1' }
+const EXIT_REASON = 'claude stream-json exited (code 1): claude: not signed in'
+
+let root: string
+let store: AgentSessionRecordStore
+let host: StructuredAgentSessionHost
+let acquire: Mock<StructuredAgentSessionAdapter['acquire']>
+
+beforeEach(async () => {
+  root = await mkdtemp(join(tmpdir(), 'orca-failed-create-sink-'))
+  resetHostTestOperationIds()
+  acquire = vi.fn(async ({ fence, spawnToken }) => ({
+    process: { hostId: 'local', pid: 4242, processStartTimeMs: 1_700_000_000_000, spawnToken },
+    link: {
+      linkId: `link-${fence}`,
+      handle: { provider: 'codex', threadId: THREAD },
+      origin: 'created',
+      mintedAtFence: fence,
+      observedAt: NOW
+    }
+  }))
+  store = await AgentSessionRecordStore.open({ directory: join(root, 'store'), hostId: 'local' })
+  host = new StructuredAgentSessionHost({
+    store,
+    adapter: {
+      acquire,
+      releaseAcquisition: vi.fn(async () => true),
+      dispatch: vi.fn(async () => ({ state: 'admitted' as const })),
+      cancelTurn: vi.fn(async () => ({ cancelled: true })),
+      answerPrompt: vi.fn(async () => undefined),
+      setOption: vi.fn(async () => undefined)
+    },
+    journalRoot: root,
+    claimKeyId: 'key-1',
+    mintSpawnToken: () => 'spawn-a',
+    now: () => NOW
+  })
+})
+
+afterEach(async () => {
+  await rm(root, { recursive: true, force: true })
+})
+
+describe('a create that throws after its child wrote through the unbound sink', () => {
+  it('releases the sink, so a new create and shutdown both proceed', async () => {
+    acquire.mockImplementationOnce(async ({ events }) => {
+      // The published child's exit reached the translator before any journal was attached.
+      events?.setActivity?.(null)
+      throw new Error(EXIT_REASON)
+    })
+
+    await expect(host.attach(CALLER, hostTestAttachParams(null))).rejects.toThrow(EXIT_REASON)
+
+    await expect(host.attach(CALLER, hostTestAttachParams(null))).resolves.toMatchObject({
+      ok: true
+    })
+    await expect(host.flushAllStreamedEvents()).resolves.toBeUndefined()
+    expect(acquire).toHaveBeenCalledTimes(2)
+  })
+})

From 3156821f1b592fd678a5f740b3ff47145197805d Mon Sep 17 00:00:00 2001
From: Brennan Benson <79079362+brennanb2025@users.noreply.github.com>
Date: Tue, 22 Sep 2026 23:59:52 -0700
Subject: [PATCH 10/67] fix(native-chat): a resend the journal answers restarts
 nothing, and a send joining a restart rebases from the fence it replaced

---
 ...ctured-agent-session-send-recovery.test.ts | 62 ++++++++++++++++++-
 .../structured-agent-session-send-recovery.ts | 53 +++++++++-------
 ...uctured-conversation-command-controller.ts |  5 ++
 3 files changed, 98 insertions(+), 22 deletions(-)

diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-send-recovery.test.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-send-recovery.test.ts
index 6b13741ad9c8..e2ee6c7f3227 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-send-recovery.test.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-send-recovery.test.ts
@@ -128,6 +128,7 @@ describe('a send with no live owner', () => {
     const order: string[] = []
     const recovery = new StructuredAgentSessionSendRecovery({
       getRecord: (sessionId) => store.getRecord(sessionId),
+      hasJournaledSend: () => false,
       resume: async () => {
         order.push('resume')
       }
@@ -218,6 +219,65 @@ describe('a send with no live owner', () => {
     expect(acquire).toHaveBeenCalledOnce()
   })
 
+  it('restarts nothing for a resend the journal already answers', async () => {
+    const params = sendParams('sent once')
+    await expect(host.send(CALLER, params)).resolves.toMatchObject({ ok: true, replayed: false })
+    // The child died during startup: the lease is handed back, the fence moves, and the session
+    // stays readable. The client resends against the new fence.
+    await host.handleAdapterEvent({
+      type: 'ended',
+      sessionId: SESSION,
+      reason: 'startup deadline',
+      cause: 'unexpected-exit',
+      fence: params.envelope.expectedRuntimeFence ?? 0,
+      acquisitionGeneration: 'generation-1',
+      startupUnproven: true
+    })
+    expect(store.getRecord(SESSION)?.lease.claimStatus).toBe('released')
+    acquire.mockClear()
+    const resent = {
+      ...params,
+      envelope: {
+        ...params.envelope,
+        expectedRuntimeFence: store.getRecord(SESSION)?.lease.runtimeFence ?? 0
+      }
+    }
+
+    await expect(host.send(CALLER, resent)).resolves.toMatchObject({ ok: true, replayed: true })
+
+    expect(acquire).not.toHaveBeenCalled()
+    expect(dispatch).toHaveBeenCalledOnce()
+    expect(store.getRecord(SESSION)?.lease.claimStatus).toBe('released')
+  })
+
+  it('rebases a send that arrives after the restart has already claimed the lease', async () => {
+    await loseOwner()
+    const lostFence = store.getRecord(SESSION)?.lease.runtimeFence ?? 0
+    let claimed = () => {}
+    let release = () => {}
+    const claim = new Promise<void>((resolve) => (claimed = resolve))
+    const spawn = new Promise<void>((resolve) => (release = resolve))
+    const spawnChild = acquire.getMockImplementation()
+    acquire.mockImplementationOnce(async (input) => {
+      claimed()
+      await spawn
+      return spawnChild!(input)
+    })
+
+    const first = host.send(CALLER, sendParams('first'))
+    await claim
+    expect(store.getRecord(SESSION)?.lease.runtimeFence).toBe(lostFence + 1)
+    const late = sendParams('second')
+    late.envelope.expectedRuntimeFence = lostFence
+    const second = host.send(CALLER, late)
+    release()
+
+    expect(await first).toMatchObject({ ok: true })
+    expect(await second).toMatchObject({ ok: true })
+    expect(acquire).toHaveBeenCalledOnce()
+    expect(dispatch).toHaveBeenCalledTimes(2)
+  })
+
   it('shares one restart between concurrent sends', async () => {
     await loseOwner()
 
@@ -232,7 +292,7 @@ describe('a send with no live owner', () => {
     expect(dispatch).toHaveBeenCalledTimes(3)
   })
 
-  it('replays a resent operation instead of running or restarting it again', async () => {
+  it('reopens a closed session once for a replay, and never runs the send again', async () => {
     const params = sendParams('sent once')
     await expect(host.send(CALLER, params)).resolves.toMatchObject({ ok: true, replayed: false })
     await loseOwner()
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-send-recovery.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-send-recovery.ts
index 48b99afd3f41..50a7554bf9a7 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-send-recovery.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-send-recovery.ts
@@ -6,6 +6,10 @@
 // itself ensures its owner: a released lease where resume is allowed gets a child first; anything
 // else runs as it is and meets the lease check in admission. A restart that fails for good refuses
 // with a code the client stops on.
+//
+// The ledger outranks the lease here as it does in admission: a resend the journal already answers
+// restarts nothing. Otherwise a child that dies at startup moves the fence, the client resends the
+// same message against the new fence, and each replay spawns another child that dies the same way.
 
 import type { AgentSessionRecord } from '../../../shared/agent-session-record'
 import type {
@@ -37,13 +41,18 @@ const TRANSIENT_RESUME_REFUSALS: ReadonlySet<string> = new Set([
 type SendParams = Parameters<typeof sendStructuredAgentSessionTurn>[2]
 type SendResult = AgentSessionMutationResult<AgentSessionSendResult>
 type Recovery = 'resumed' | 'transient' | 'unrecoverable'
+/** One restart, shared by every send that arrives while it runs. `fromFence` is the fence it
+ *  replaced: a joiner reads the record after the claim, so it cannot recover that itself. */
+type Restart = { fromFence: number; recovery: Promise<Recovery> }
 
 export class StructuredAgentSessionSendRecovery {
-  private readonly inFlight = new Map<string, Promise<Recovery>>()
+  private readonly inFlight = new Map<string, Restart>()
 
   constructor(
     private readonly deps: {
       getRecord: (sessionId: string) => AgentSessionRecord | null
+      /** Whether the loaded journal already carries this send, so admission replays it. */
+      hasJournaledSend: (sessionId: string, clientMessageId: string) => boolean
       /** Gives the session a provider child; throws the refusal code when it cannot. */
       resume: (sessionId: string) => Promise<void>
       onError?: (input: { sessionId: string; error: unknown }) => void
@@ -51,27 +60,32 @@ export class StructuredAgentSessionSendRecovery {
   ) {}
 
   async send(params: SendParams, run: (params: SendParams) => Promise<SendResult>) {
-    const { sessionId, expectedRuntimeFence } = params.envelope
-    const record = this.deps.getRecord(sessionId)
-    // Live, unverifiable, still reserved, or handed off: that lease is not this send's to replace.
-    // A send the record refuses anyway must not leave a child behind it.
-    if (
-      !this.inFlight.has(sessionId) &&
-      (!record ||
-        !isResumableStructuredAgentSessionRecord(record) ||
-        structuredAgentSessionSendBlock(record))
-    ) {
+    const { sessionId, clientOperationId, expectedRuntimeFence } = params.envelope
+    if (this.deps.hasJournaledSend(sessionId, clientOperationId)) {
       return run(params)
     }
-    const fromFence = record?.lease.runtimeFence
-    const recovery = await this.recover(sessionId)
+    let restart = this.inFlight.get(sessionId)
+    if (!restart) {
+      const record = this.deps.getRecord(sessionId)
+      // Live, unverifiable, still reserved, or handed off: that lease is not this send's to
+      // replace. A send the record refuses anyway must not leave a child behind it.
+      if (
+        !record ||
+        !isResumableStructuredAgentSessionRecord(record) ||
+        structuredAgentSessionSendBlock(record)
+      ) {
+        return run(params)
+      }
+      restart = this.start(sessionId, record.lease.runtimeFence)
+    }
+    const recovery = await restart.recovery
     if (recovery === 'unrecoverable') {
       return refuseAgentSessionMutation(AGENT_SESSION_OWNER_UNRECOVERABLE)
     }
     const toFence = this.deps.getRecord(sessionId)?.lease.runtimeFence
     // The client was current as of the lost owner; the new owner is the only thing that moved.
     const rebase =
-      recovery === 'resumed' && expectedRuntimeFence === fromFence && toFence !== undefined
+      recovery === 'resumed' && expectedRuntimeFence === restart.fromFence && toFence !== undefined
     return run(
       rebase
         ? { ...params, envelope: { ...params.envelope, expectedRuntimeFence: toFence } }
@@ -79,11 +93,7 @@ export class StructuredAgentSessionSendRecovery {
     )
   }
 
-  private recover(sessionId: string): Promise<Recovery> {
-    const running = this.inFlight.get(sessionId)
-    if (running) {
-      return running
-    }
+  private start(sessionId: string, fromFence: number): Restart {
     const recovery = this.deps
       .resume(sessionId)
       .then(
@@ -97,7 +107,8 @@ export class StructuredAgentSessionSendRecovery {
         }
       )
       .finally(() => this.inFlight.delete(sessionId))
-    this.inFlight.set(sessionId, recovery)
-    return recovery
+    const restart = { fromFence, recovery }
+    this.inFlight.set(sessionId, restart)
+    return restart
   }
 }
diff --git a/src/main/native-chat/agent-session-wire/structured-conversation-command-controller.ts b/src/main/native-chat/agent-session-wire/structured-conversation-command-controller.ts
index ae71349c0492..519fe80d1747 100644
--- a/src/main/native-chat/agent-session-wire/structured-conversation-command-controller.ts
+++ b/src/main/native-chat/agent-session-wire/structured-conversation-command-controller.ts
@@ -16,6 +16,11 @@ export class StructuredConversationCommandController {
   ) {}
   private readonly recovery = new StructuredAgentSessionSendRecovery({
     getRecord: (sessionId) => this.context().deps.store.getRecord(sessionId),
+    hasJournaledSend: (sessionId, clientMessageId) =>
+      this.context()
+        .sessions.get(sessionId)
+        ?.journal.submissions()
+        .some((submission) => submission.clientMessageId === clientMessageId) ?? false,
     resume: (sessionId) => this.context().resumeUnheld(sessionId),
     onError: (input) => this.context().deps.onEventSinkError?.(input)
   })

From d3e47d764e88805d8eeb09c03ca0a0a4c7331be1 Mon Sep 17 00:00:00 2001
From: Brennan Benson <79079362+brennanb2025@users.noreply.github.com>
Date: Wed, 23 Sep 2026 00:14:30 -0700
Subject: [PATCH 11/67] fix(native-chat): the host learns a Claude start
 positively, and persists only proven options

A publish-first create used to read the session's options before Claude had
answered initialize. With startup pending that read fell back to the built-in
catalog's default, so `record.options.model` was persisted as `sonnet` for
every user whose CLI default is something else; an owner handoff or a reopen
then replayed `set_model('sonnet')` and silently switched their model.

The adapter now reports `started` once startup facts are applied and saved
options restored. The host keeps a `providerChildPhase` on the session it
owns: a starting child hands over nothing but the saved options as intent,
and the `started` event re-reads the options as fact and persists them through
the same record write a user's option change takes. The status summary carries
`hostExecutionPhase` (optional, wire-safe), and the chat pane says the agent is
still starting instead of showing nothing.

A child whose exit already reached the adapter before acquire returns is no
longer handed over as live; the create fails with the CLI's diagnostic.
---
 pnpm-lock.yaml                                |  19 +++
 src/main/claude/claude-structured-options.ts  |   4 +-
 .../claude-structured-session-acquisition.ts  |  20 ++-
 .../claude-structured-session-startup.test.ts |  30 +++++
 .../claude-structured-session-startup.ts      |   3 +
 .../claude/claude-structured-session-state.ts |   2 +
 .../codex/codex-structured-session-close.ts   |   4 +-
 .../codex/codex-structured-session-state.ts   |   4 +-
 .../structured-agent-session-acquisition.ts   |  34 +++--
 .../structured-agent-session-adapter.ts       |  21 ++-
 .../structured-agent-session-attach-flow.ts   |  10 +-
 ...ured-agent-session-attach-orchestration.ts |   6 +-
 ...red-agent-session-claude-root-exit.test.ts |   1 +
 ...ructured-agent-session-close-retry.test.ts |   1 +
 ...structured-agent-session-event-recovery.ts |   4 +
 ...ctured-agent-session-forget-status.test.ts |   1 +
 ...uctured-agent-session-host-handoff.test.ts |   3 +
 .../structured-agent-session-host-handoff.ts  |  18 ++-
 .../structured-agent-session-host-types.ts    |   8 +-
 ...ured-agent-session-journal-handles.test.ts |   1 +
 ...red-agent-session-provider-started.test.ts | 123 ++++++++++++++++++
 ...ructured-agent-session-provider-started.ts |  78 +++++++++++
 .../structured-agent-session-read-restore.ts  |   2 +
 ...-agent-session-status-feed-test-session.ts |   2 +
 ...ructured-agent-session-status-feed.test.ts |  23 +++-
 .../structured-agent-session-status-feed.ts   |  12 +-
 ...tructured-agent-session-unexpected-exit.ts |   6 +-
 .../structured-tui-transcript-catchup.test.ts |   1 +
 .../structured-agent-session-runtime.ts       |   2 +-
 .../structured-claude-runtime-adapter.ts      |  53 +++++---
 ...tiveChatStructuredSession.test-harness.tsx |   4 +-
 .../NativeChatStructuredSession.tsx           |   8 ++
 ...NativeChatStructuredSessionStatus.test.tsx |  49 +++++++
 .../NativeChatStructuredSessionStatus.tsx     |  14 ++
 .../StructuredAgentSessionStatusBridge.tsx    |   2 +-
 src/renderer/src/i18n/locales/en.json         |   3 +
 .../structured-agent-session-status-feed.ts   |   2 +-
 src/shared/agent-session-wire.ts              |   3 +
 38 files changed, 520 insertions(+), 61 deletions(-)
 create mode 100644 src/main/native-chat/agent-session-wire/structured-agent-session-provider-started.test.ts
 create mode 100644 src/main/native-chat/agent-session-wire/structured-agent-session-provider-started.ts
 create mode 100644 src/renderer/src/components/native-chat/NativeChatStructuredSessionStatus.test.tsx

diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index 7ba1cc7f4f5e..fc1b054a5a01 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -6,6 +6,9 @@ importers:
   .:
     configDependencies: {}
     packageManagerDependencies:
+      '@pnpm/exe':
+        specifier: 12.0.0
+        version: 12.0.0
       pnpm:
         specifier: 12.0.0
         version: 12.0.0
@@ -56,6 +59,11 @@ packages:
     cpu: [x64]
     os: [win32]
 
+  '@pnpm/exe@12.0.0':
+    resolution: {integrity: sha512-405vw2qYPPghNxoPRt2cvkGtGNU5gnInDcIe5TztQxe73yUZLqFJN/jCJFGs1xbVaIWDXEVuQ71P8npFZeatZQ==}
+    engines: {node: '>=18.*'}
+    hasBin: true
+
   pnpm@12.0.0:
     resolution: {integrity: sha512-ni49w5EZlYaNyUuBdcIXwn6VQI+gO0oidJd48rNPdzt3zdOznt6BcbIvzVO+ajU0Lp+smUimjvWN9kiM6Jp+Zw==}
     engines: {node: '>=18.*'}
@@ -87,6 +95,17 @@ snapshots:
   '@pnpm/exe.win32-x64@12.0.0':
     optional: true
 
+  '@pnpm/exe@12.0.0':
+    optionalDependencies:
+      '@pnpm/exe.darwin-arm64': 12.0.0
+      '@pnpm/exe.darwin-x64': 12.0.0
+      '@pnpm/exe.linux-arm64': 12.0.0
+      '@pnpm/exe.linux-arm64-musl': 12.0.0
+      '@pnpm/exe.linux-x64': 12.0.0
+      '@pnpm/exe.linux-x64-musl': 12.0.0
+      '@pnpm/exe.win32-arm64': 12.0.0
+      '@pnpm/exe.win32-x64': 12.0.0
+
   pnpm@12.0.0:
     optionalDependencies:
       '@pnpm/exe.darwin-arm64': 12.0.0
diff --git a/src/main/claude/claude-structured-options.ts b/src/main/claude/claude-structured-options.ts
index 0678ed97a63f..fc57b247e90a 100644
--- a/src/main/claude/claude-structured-options.ts
+++ b/src/main/claude/claude-structured-options.ts
@@ -46,7 +46,9 @@ export function setClaudeStructuredSessionOption(
   // Each write is a control request the CLI answers only after initialize.
   if (session.startup.state !== 'proven') {
     return Promise.reject(
-      new AgentSessionOptionRejectedError('Claude is still starting. Try again in a moment.')
+      new AgentSessionOptionRejectedError(
+        'Claude is still starting; options can be changed once it is ready.'
+      )
     )
   }
   return setClaudeStructuredOption(session, input, timeoutMs)
diff --git a/src/main/claude/claude-structured-session-acquisition.ts b/src/main/claude/claude-structured-session-acquisition.ts
index 734d8f6ab5c6..6666be9cb354 100644
--- a/src/main/claude/claude-structured-session-acquisition.ts
+++ b/src/main/claude/claude-structured-session-acquisition.ts
@@ -253,9 +253,25 @@ export async function acquireClaudeSession({
       facts: facts ?? readFacts(),
       isCurrent: () => sessions.get(sessionId) === session,
       requestTimeoutMs: deps.requestTimeoutMs,
-      fault: (error) => callbacks.handleExit(sessionId, attempt, error)
+      fault: (error) => callbacks.handleExit(sessionId, attempt, error),
+      onStarted: () =>
+        emit({
+          type: 'started',
+          sessionId,
+          fence: input.fence,
+          acquisitionGeneration: session.acquisitionGeneration
+        })
     })
-    return publication.acquisition
+    // A child whose exit already reached `handleExit` is not handed over as live: the create
+    // fails with the CLI's own diagnostic, as one that died before publish does.
+    if (sessions.get(sessionId) !== session) {
+      throw (
+        exits.get(sessionId)?.error ?? new Error('claude session ended before acquisition returned')
+      )
+    }
+    // Even a proof-first start applies its facts and restores saved options only now, so the
+    // child is `starting` until `started` says otherwise.
+    return { ...publication.acquisition, providerChildPhase: 'starting' }
   } catch (error) {
     unbindReadingControl?.()
     const acquisitionError = await resolveClaudeAcquisitionError({
diff --git a/src/main/claude/claude-structured-session-startup.test.ts b/src/main/claude/claude-structured-session-startup.test.ts
index 6197cc20668d..e62adf144abf 100644
--- a/src/main/claude/claude-structured-session-startup.test.ts
+++ b/src/main/claude/claude-structured-session-startup.test.ts
@@ -65,6 +65,35 @@ describe('Claude structured session publishes before the CLI answers initialize'
     await adapter.closeAll()
   })
 
+  it('reports `started` once saved options are restored, before any held prompt is written', async () => {
+    const claude = fakeClaude({ initDelayMs: SLOW_INIT_MS, initModel: 'claude-opus-9' })
+    const { adapter, events } = startingAdapter(claude)
+    const order: string[] = []
+    claude.routes.set_model = () => {
+      order.push('set_model')
+      return undefined
+    }
+    await adapter.acquire({ ...ACQUIRE, options: { model: 'opus' } })
+    await adapter.dispatch(PROMPT)
+    expect(events.some((event) => event.type === 'started')).toBe(false)
+
+    await vi.advanceTimersByTimeAsync(SLOW_INIT_MS)
+    await adapter.drainStartup('session-1')
+
+    const startedAt = events.findIndex((event) => event.type === 'started')
+    expect(events[startedAt]).toEqual({
+      type: 'started',
+      sessionId: 'session-1',
+      fence: 7,
+      acquisitionGeneration: expect.any(String)
+    })
+    // The restore wrote the saved model before `started`, and the held prompt only after it.
+    expect(order).toEqual(['set_model'])
+    expect(claude.connections[0].sent).toHaveLength(1)
+    expect(events.slice(0, startedAt).some((event) => event.type === 'options')).toBe(true)
+    await adapter.closeAll()
+  })
+
   it('holds a prompt sent before init and writes it once startup lands', async () => {
     const claude = fakeClaude({ initDelayMs: SLOW_INIT_MS })
     const { adapter } = startingAdapter(claude)
@@ -158,6 +187,7 @@ describe('Claude structured session publishes before the CLI answers initialize'
       expect.objectContaining({ clientMessageId: 'client-1', state: 'rejected' })
     ])
     expect(events.some((event) => event.type === 'ended' && event.startupUnproven)).toBe(false)
+    expect(events.some((event) => event.type === 'started')).toBe(false)
   })
 
   it('withdraws a held prompt when the turn is cancelled before init', async () => {
diff --git a/src/main/claude/claude-structured-session-startup.ts b/src/main/claude/claude-structured-session-startup.ts
index be0d9bb4bc55..d99e0af85cf0 100644
--- a/src/main/claude/claude-structured-session-startup.ts
+++ b/src/main/claude/claude-structured-session-startup.ts
@@ -148,6 +148,8 @@ export async function settleClaudeSessionStartup(input: {
   isCurrent: () => boolean
   requestTimeoutMs: number | undefined
   fault: (error: Error) => void
+  /** Startup has proven: the host may now read this child's options as fact. */
+  onStarted: () => void
 }): Promise<void> {
   const { session } = input
   const superseded = (): boolean => {
@@ -165,6 +167,7 @@ export async function settleClaudeSessionStartup(input: {
     applyClaudeStartupFacts(session, facts)
     await restoreClaudeStructuredSessionOptions(session, input.requestTimeoutMs)
     if (!superseded()) {
+      input.onStarted()
       await openClaudeStartupGate(session)
     }
   } catch (caught) {
diff --git a/src/main/claude/claude-structured-session-state.ts b/src/main/claude/claude-structured-session-state.ts
index 08792aaca2e1..6b5ee50c7815 100644
--- a/src/main/claude/claude-structured-session-state.ts
+++ b/src/main/claude/claude-structured-session-state.ts
@@ -53,6 +53,8 @@ export type ClaudeStructuredSessionEvent =
       fence: number
     }
   | { type: 'auth-diagnostic'; sessionId: string; diagnostic: ClaudeAuthDiagnostic }
+  /** Startup facts applied and saved options restored; held prompts are about to be written. */
+  | { type: 'started'; sessionId: string; fence: number; acquisitionGeneration: string }
   | {
       type: 'ended'
       sessionId: string
diff --git a/src/main/codex/codex-structured-session-close.ts b/src/main/codex/codex-structured-session-close.ts
index 2058f86ce855..1ed8dcd385ce 100644
--- a/src/main/codex/codex-structured-session-close.ts
+++ b/src/main/codex/codex-structured-session-close.ts
@@ -7,7 +7,7 @@ import {
   type CodexStructuredSessionAdapterDeps,
   type CodexStructuredSessionEvent
 } from './codex-structured-session-state'
-import type { StructuredAgentSessionLifecycleEvent } from '../native-chat/agent-session-wire/structured-agent-session-adapter'
+import type { StructuredAgentSessionEndedEvent } from '../native-chat/agent-session-wire/structured-agent-session-adapter'
 
 export function handleCodexSessionExit(input: {
   sessions: Map<string, CodexSession>
@@ -25,7 +25,7 @@ export function handleCodexSessionExit(input: {
     return false
   }
   session.exitObservedAt ??= Date.now()
-  const event: StructuredAgentSessionLifecycleEvent = {
+  const event: StructuredAgentSessionEndedEvent = {
     type: 'ended',
     sessionId: input.sessionId,
     reason: input.error.message,
diff --git a/src/main/codex/codex-structured-session-state.ts b/src/main/codex/codex-structured-session-state.ts
index c890df0be582..9b8659c1e1b6 100644
--- a/src/main/codex/codex-structured-session-state.ts
+++ b/src/main/codex/codex-structured-session-state.ts
@@ -14,7 +14,7 @@ import type { AgentSessionBackgroundTaskState } from '../../shared/agent-session
 import type { CodexBackgroundTaskTracker } from './codex-background-task-tracker'
 import type { CodexJournalTranslator } from './codex-structured-journal-translation'
 import type { CodexTurnProcessSnapshot } from './codex-structured-turn-processes'
-import type { StructuredAgentSessionLifecycleEvent } from '../native-chat/agent-session-wire/structured-agent-session-adapter'
+import type { StructuredAgentSessionEndedEvent } from '../native-chat/agent-session-wire/structured-agent-session-adapter'
 import type { CodexStructuredPermissionPolicy } from './codex-structured-permission-policy'
 
 export type CodexStructuredLaunch = {
@@ -51,7 +51,7 @@ export type CodexStructuredSessionEvent =
       codexItemId: string
       promptKey: string
     }
-  | StructuredAgentSessionLifecycleEvent
+  | StructuredAgentSessionEndedEvent
   /** Translator-only compatibility for callers that do not participate in host recovery. */
   | { type: 'ended'; sessionId: string; reason: string; observedAt?: number }
 
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-acquisition.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-acquisition.ts
index 87c63454b242..17d8a07e7e7e 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-acquisition.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-acquisition.ts
@@ -4,7 +4,8 @@ import type { AgentSessionRecord } from '../../../shared/agent-session-record'
 import {
   AgentSessionPreSpawnError,
   isAgentSessionPreSpawnError,
-  rethrowAfterAgentSessionAcquisitionCleanup
+  rethrowAfterAgentSessionAcquisitionCleanup,
+  type StructuredAgentSessionProviderChildPhase
 } from './structured-agent-session-adapter'
 import { journalIdentityFor } from './structured-agent-session-attach'
 import type { AttachFlowInput } from './structured-agent-session-attach-flow'
@@ -16,7 +17,11 @@ import { withAgentSessionCreatePhase } from '../../observability/agent-session-i
 export async function acquireOwner(
   input: AttachFlowInput,
   record: AgentSessionRecord
-): Promise<{ record: AgentSessionRecord; acquisitionGeneration: string | null }> {
+): Promise<{
+  record: AgentSessionRecord
+  acquisitionGeneration: string | null
+  providerChildPhase: StructuredAgentSessionProviderChildPhase
+}> {
   const { store, rewind, now } = input
   const fence = record.lease.runtimeFence
   const spawnToken = record.lease.reservedSpawnToken
@@ -47,14 +52,20 @@ export async function acquireOwner(
       ...(input.eventSink ? { events: input.eventSink } : {}),
       ...(input.recordPhase ? { recordPhase: input.recordPhase } : {})
     })
-    const options = await withAgentSessionCreatePhase('restore_options', input.recordPhase, () =>
-      readNativeSessionOptions({
-        adapter: input.adapter,
-        sessionId: record.sessionId,
-        fence,
-        ...(record.options ? { priorOptions: record.options } : {})
-      })
-    )
+    const providerChildPhase = acquired.providerChildPhase ?? 'ready'
+    // A starting child has proven nothing: the record keeps the reservation's saved options as
+    // intent, never a catalog guess, and the `started` event persists what the child reports.
+    const options =
+      providerChildPhase === 'starting'
+        ? undefined
+        : await withAgentSessionCreatePhase('restore_options', input.recordPhase, () =>
+            readNativeSessionOptions({
+              adapter: input.adapter,
+              sessionId: record.sessionId,
+              fence,
+              ...(record.options ? { priorOptions: record.options } : {})
+            })
+          )
     if (record.lease.ownerProcess === null) {
       await input.store.commitProcessIdentity({
         sessionId: record.sessionId,
@@ -74,7 +85,8 @@ export async function acquireOwner(
     })
     return {
       record: proved,
-      acquisitionGeneration: acquired.acquisitionGeneration ?? null
+      acquisitionGeneration: acquired.acquisitionGeneration ?? null,
+      providerChildPhase
     }
   } catch (error) {
     if (isAgentSessionPreSpawnError(error)) {
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-adapter.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-adapter.ts
index ab9ee0673bd1..aced8d81221d 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-adapter.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-adapter.ts
@@ -85,6 +85,8 @@ export type AgentSessionAcquisition = {
   /** Host-local identity for this exact provider child, distinct even when the durable fence is
    *  reused by a superseding acquisition. */
   acquisitionGeneration?: string
+  /** Absent means `ready`: the adapter proved startup before answering. */
+  providerChildPhase?: StructuredAgentSessionProviderChildPhase
 }
 
 /** Acquisition failed with first-hand proof that no provider process existed. */
@@ -113,7 +115,7 @@ export type AgentSessionDispatchOutcome =
   /** The call did not settle. Never re-send on the user's behalf. */
   | { state: 'unknown'; reason: string }
 
-export type StructuredAgentSessionLifecycleEvent = {
+export type StructuredAgentSessionEndedEvent = {
   type: 'ended'
   sessionId: string
   reason: string
@@ -128,6 +130,23 @@ export type StructuredAgentSessionLifecycleEvent = {
   startupUnproven?: true
 }
 
+/** The child a publish-first acquire handed over has now proven its start: startup facts applied
+ *  and saved options restored. What it reports from here on is fact, not a catalog guess. */
+export type StructuredAgentSessionStartedEvent = {
+  type: 'started'
+  sessionId: string
+  fence: number
+  acquisitionGeneration: string
+}
+
+export type StructuredAgentSessionLifecycleEvent =
+  | StructuredAgentSessionEndedEvent
+  | StructuredAgentSessionStartedEvent
+
+/** Whether the provider child behind an acquisition has proven its start. A publish-first
+ *  acquire hands over a `starting` child and the `started` lifecycle event flips it. */
+export type StructuredAgentSessionProviderChildPhase = 'starting' | 'ready'
+
 export type StructuredAgentSessionAcquireInput = {
   identity: AgentSessionJournalIdentity
   rewind?: {
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-attach-flow.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-attach-flow.ts
index 2aad1d2fafe5..bb297a5a6c33 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-attach-flow.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-attach-flow.ts
@@ -8,7 +8,8 @@ import {
   AgentSessionAcquisitionRefusal,
   isAgentSessionPreSpawnError,
   type StructuredAgentSessionAcquireInput,
-  type StructuredAgentSessionAdapter
+  type StructuredAgentSessionAdapter,
+  type StructuredAgentSessionProviderChildPhase
 } from './structured-agent-session-adapter'
 // The host supplies owner authority; this flow reserves, proves, and publishes the session.
 
@@ -61,7 +62,8 @@ export type AttachFlowInput = {
   onAttached: (
     attached: AttachedJournal,
     acquisitionGeneration: string | null,
-    acquiredOwner: boolean
+    acquiredOwner: boolean,
+    providerChildPhase: StructuredAgentSessionProviderChildPhase
   ) => Promise<void> | void
   /** Host-owned provider sink, bound to the journal inside `onAttached`. */
   eventSink?: StructuredAgentSessionEventSink
@@ -97,6 +99,7 @@ export async function performAttach(
   let record: AgentSessionRecord
   let acquisitionGeneration: string | null = null
   let acquiredOwner = false
+  let providerChildPhase: StructuredAgentSessionProviderChildPhase = 'ready'
   let reservedRecord: AgentSessionRecord | null = null
   let unsupportedReservationSettlementAttempted = false
   let replayed = false
@@ -166,6 +169,7 @@ export async function performAttach(
       )
       record = acquired.record
       acquisitionGeneration = acquired.acquisitionGeneration
+      providerChildPhase = acquired.providerChildPhase
       acquiredOwner = true
     }
   } catch (error) {
@@ -244,7 +248,7 @@ export async function performAttach(
       providerHistoryWindow
     })
     await importAdoptedTranscript(params, attached, record, preparedTranscript.items)
-    await input.onAttached(attached, acquisitionGeneration, acquiredOwner)
+    await input.onAttached(attached, acquisitionGeneration, acquiredOwner, providerChildPhase)
     await store.recordOperationOutcome({
       callerKey: input.callerKey,
       operationId: params.envelope.clientOperationId,
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-attach-orchestration.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-attach-orchestration.ts
index 6070539c6d1d..dd7ecc8b1fcd 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-attach-orchestration.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-attach-orchestration.ts
@@ -121,7 +121,7 @@ export function attachStructuredAgentSession(
           eventSink.close()
           context.runtimeState.discardEventSink(sessionId)
         },
-        onAttached: async (attached, acquisitionGeneration, acquiredOwner) => {
+        onAttached: async (attached, acquisitionGeneration, acquiredOwner, providerChildPhase) => {
           const fence = context.deps.store.getRecord(sessionId)?.lease.runtimeFence ?? 0
           const previous = context.sessions.get(sessionId)
           const previousFence = previous?.fence
@@ -161,6 +161,10 @@ export function attachStructuredAgentSession(
             params,
             fence,
             hasProviderChild: true,
+            // A re-attach to a live child keeps what that child already proved.
+            providerChildPhase: acquiredOwner
+              ? providerChildPhase
+              : (previous?.providerChildPhase ?? 'ready'),
             acquisitionGeneration: acquisitionGeneration ?? previous?.acquisitionGeneration ?? null
           })
           if (!rewind) {
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-claude-root-exit.test.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-claude-root-exit.test.ts
index a7ca961d13ff..d83ca49a79c5 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-claude-root-exit.test.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-claude-root-exit.test.ts
@@ -106,6 +106,7 @@ describe('Claude root-exit eviction', () => {
           params,
           fence,
           hasProviderChild: true,
+          providerChildPhase: 'ready',
           acquisitionGeneration: acquisition.acquisitionGeneration ?? null
         }
       ]
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-close-retry.test.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-close-retry.test.ts
index 1141f8211748..18f605950e7f 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-close-retry.test.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-close-retry.test.ts
@@ -80,6 +80,7 @@ function hostSession(journal: AgentSessionJournal): StructuredAgentSessionHostSe
     params: {} as StructuredAgentSessionHostSession['params'],
     fence: 1,
     hasProviderChild: false,
+    providerChildPhase: 'ready',
     acquisitionGeneration: null
   }
 }
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-event-recovery.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-event-recovery.ts
index 728942b63475..fda92f144ce2 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-event-recovery.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-event-recovery.ts
@@ -7,6 +7,7 @@ import type {
 } from './structured-agent-session-host-types'
 import type { StructuredAgentSessionSinkBarrier } from './structured-agent-session-event-sink'
 import { resumeHeldStructuredAgentSession } from './structured-agent-session-hold-resume'
+import { settleStructuredAgentSessionProviderStarted } from './structured-agent-session-provider-started'
 import {
   isStructuredAgentSessionRecoveryTicketCurrent,
   settleUnexpectedStructuredAgentSessionExit
@@ -65,6 +66,9 @@ export class StructuredAgentSessionEventRecovery {
   }
 
   async handle(event: StructuredAgentSessionLifecycleEvent): Promise<void> {
+    if (event.type === 'started') {
+      return settleStructuredAgentSessionProviderStarted(this.context, event)
+    }
     const ticket = await settleUnexpectedStructuredAgentSessionExit(this.context, event)
     if (!ticket) {
       return
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-forget-status.test.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-forget-status.test.ts
index 2ff6697eae95..697d351013ab 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-forget-status.test.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-forget-status.test.ts
@@ -138,6 +138,7 @@ async function workingSession(): Promise<{
         },
         fence: 1,
         hasProviderChild: true,
+        providerChildPhase: 'ready',
         acquisitionGeneration: null
       }
     ]
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-host-handoff.test.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-host-handoff.test.ts
index bf2a1381b3b6..d5ab3c679749 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-host-handoff.test.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-host-handoff.test.ts
@@ -165,6 +165,7 @@ describe('native handoff acquisition', () => {
       },
       fence: reserved.record.lease.runtimeFence,
       hasProviderChild: false,
+      providerChildPhase: 'ready' as const,
       acquisitionGeneration: null
     }
     const acquiring = acquireNativeHandoffOwner(
@@ -262,6 +263,7 @@ describe('native handoff acquisition', () => {
       },
       fence: reserved.record.lease.runtimeFence,
       hasProviderChild: false,
+      providerChildPhase: 'ready' as const,
       acquisitionGeneration: null
     }
 
@@ -356,6 +358,7 @@ describe('native handoff acquisition', () => {
       },
       fence: reserved.record.lease.runtimeFence,
       hasProviderChild: false,
+      providerChildPhase: 'ready' as const,
       acquisitionGeneration: null
     }
 
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-host-handoff.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-host-handoff.ts
index 2720a97784c8..5ac5697c551f 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-host-handoff.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-host-handoff.ts
@@ -252,12 +252,17 @@ export async function acquireNativeHandoffOwner(
   })
   let proved: AgentSessionRecord
   try {
-    const options = await readNativeSessionOptions({
-      adapter: deps.adapter,
-      sessionId: input.sessionId,
-      fence: input.fence,
-      ...(record.options ? { priorOptions: record.options } : {})
-    })
+    // A starting child has proven nothing yet: the record keeps the saved options as intent, and
+    // the `started` event persists what the child reports.
+    const options =
+      acquired.providerChildPhase === 'starting'
+        ? undefined
+        : await readNativeSessionOptions({
+            adapter: deps.adapter,
+            sessionId: input.sessionId,
+            fence: input.fence,
+            ...(record.options ? { priorOptions: record.options } : {})
+          })
     await deps.store.commitProcessIdentity({
       sessionId: input.sessionId,
       fence: input.fence,
@@ -275,6 +280,7 @@ export async function acquireNativeHandoffOwner(
     return rethrowAfterAgentSessionAcquisitionCleanup(deps.adapter, input.sessionId, error)
   }
   session.hasProviderChild = true
+  session.providerChildPhase = acquired.providerChildPhase ?? 'ready'
   host.publishStatus?.(input.sessionId)
   session.fence = proved.lease.runtimeFence
   session.acquisitionGeneration = acquired.acquisitionGeneration ?? null
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-host-types.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-host-types.ts
index 8d16a0a33467..d79237e1337d 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-host-types.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-host-types.ts
@@ -6,7 +6,10 @@ import type { AgentSessionRecordStore } from '../../runtime/agent-session-record
 import type { AgentSessionRecoveryCapsule } from '../../runtime/agent-session-recovery-capsule'
 import type { AgentSessionSpawnTokenScan } from '../../runtime/agent-session-spawn-token-process-scan'
 import type { AgentSessionJournal } from '../agent-session-journal/journal-store'
-import type { StructuredAgentSessionAdapter } from './structured-agent-session-adapter'
+import type {
+  StructuredAgentSessionAdapter,
+  StructuredAgentSessionProviderChildPhase
+} from './structured-agent-session-adapter'
 import type { AgentSessionAttachParams } from './structured-agent-session-attach'
 import type { StructuredAgentSessionHandoffTransport } from './structured-agent-session-handoff-types'
 import type { StructuredAgentSessionStatusSink } from './structured-agent-session-status-feed'
@@ -32,6 +35,9 @@ export type StructuredAgentSessionHostSession = {
    *  restored for reading has none, and neither has a session a TUI owns — so neither may be
    *  evicted to free a child, and neither may have its lease released as an observed exit. */
   hasProviderChild: boolean
+  /** Whether the child behind `hasProviderChild` has proven its start. A publish-first acquire
+   *  is `starting` until the adapter's `started` event; only then are its reported options fact. */
+  providerChildPhase: StructuredAgentSessionProviderChildPhase
   /** The wind-down this host still owes for a child it started: settling that generation's work
    *  and handing the lease back. A separate fact from `hasProviderChild`, which goes false the
    *  moment the adapter proves the exit — an eviction that aborts after that point must still be
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-journal-handles.test.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-journal-handles.test.ts
index ea32f1715702..1c9f271004c3 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-journal-handles.test.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-journal-handles.test.ts
@@ -75,6 +75,7 @@ function hostSession(journal: AgentSessionJournal): StructuredAgentSessionHostSe
     params: {} as StructuredAgentSessionHostSession['params'],
     fence: 1,
     hasProviderChild: false,
+    providerChildPhase: 'ready',
     acquisitionGeneration: null
   }
 }
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-provider-started.test.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-provider-started.test.ts
new file mode 100644
index 000000000000..f085f58033bc
--- /dev/null
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-provider-started.test.ts
@@ -0,0 +1,123 @@
+// A publish-first create proves nothing about the model until Claude answers startup. The record
+// must never hold the catalog's default in the meantime: an owner handoff or a reopen would
+// replay it as a `set_model` and silently move a user whose CLI default is not Sonnet.
+
+import { mkdtemp, rm } from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { afterEach, beforeEach, describe, expect, it } from 'vitest'
+import type { AgentSessionStatusEvent } from '../../../shared/agent-session-wire'
+import { ClaudeStructuredSessionAdapter } from '../../claude/claude-structured-session-adapter'
+import {
+  fakeClaude,
+  PROVIDER_SESSION_ID
+} from '../../claude/claude-structured-session-test-support'
+import { AgentSessionRecordStore } from '../../runtime/agent-session-record-store'
+import { structuredClaudeLifecycleEvent } from '../../runtime/structured-claude-runtime-adapter'
+import { StructuredAgentSessionHost } from './structured-agent-session-host'
+import {
+  HOST_TEST_NOW as NOW,
+  HOST_TEST_SESSION as SESSION,
+  hostTestAttachParams,
+  resetHostTestOperationIds
+} from './structured-agent-session-host-test-data'
+
+const CALLER = { callerKey: 'client-1' }
+const INIT_DELAY_MS = 40
+
+let root: string
+let store: AgentSessionRecordStore
+let host: StructuredAgentSessionHost
+let adapter: ClaudeStructuredSessionAdapter
+let lifecycle: Promise<void>[]
+let statuses: AgentSessionStatusEvent[]
+
+beforeEach(async () => {
+  root = await mkdtemp(join(tmpdir(), 'orca-provider-started-'))
+  resetHostTestOperationIds()
+  lifecycle = []
+  statuses = []
+  const claude = fakeClaude({ initDelayMs: INIT_DELAY_MS, initModel: 'claude-opus-9' })
+  adapter = new ClaudeStructuredSessionAdapter({
+    resolveLaunch: async () => ({
+      pathToClaudeCodeExecutable: 'claude',
+      options: {},
+      cwd: root,
+      claudeConfigDir: join(root, 'claude-home'),
+      providerSessionId: PROVIDER_SESSION_ID,
+      resumeLeafUuid: null,
+      resumed: false
+    }),
+    // The runtime's own mapping, so this test drives the same lifecycle path production does.
+    onEvent: (event) => {
+      const mapped = structuredClaudeLifecycleEvent(event)
+      if (mapped) {
+        lifecycle.push(host.handleAdapterEvent(mapped))
+      }
+    },
+    openConnection: claude.openConnection,
+    readProcessStartTime: async () => 1_700_000_000_000,
+    now: () => NOW
+  })
+  store = await AgentSessionRecordStore.open({ directory: join(root, 'store'), hostId: 'local' })
+  host = new StructuredAgentSessionHost({
+    store,
+    // The production router is what declares create support; the bare adapter only knows locations.
+    adapter: Object.assign(adapter, { supportsCreate: () => true }),
+    journalRoot: root,
+    claimKeyId: 'key-1',
+    mintSpawnToken: () => 'spawn-a',
+    now: () => NOW
+  })
+  host.subscribeStatus({ id: 'status-1', emit: (event) => statuses.push(event) })
+})
+
+afterEach(async () => {
+  await adapter.closeAll()
+  await host.flushAllStreamedEvents()
+  await rm(root, { recursive: true, force: true })
+})
+
+function claudeParams() {
+  return hostTestAttachParams(null, {
+    provider: 'claude',
+    agent: 'claude',
+    accountHome: { variable: 'CLAUDE_CONFIG_DIR', path: join(root, 'claude-home') },
+    providerHandle: { kind: 'claude', sessionId: PROVIDER_SESSION_ID, leafUuid: null }
+  })
+}
+
+function lastPhase(): string | undefined {
+  const last = statuses.findLast((event) => event.type === 'status')
+  return last?.type === 'status' ? last.session.hostExecutionPhase : undefined
+}
+
+describe('a publish-first Claude create whose init is slow', () => {
+  it('never persists the catalog default, and persists the reported model once started', async () => {
+    await expect(host.attach(CALLER, claudeParams())).resolves.toMatchObject({ ok: true })
+
+    // Published, not yet answering: the record holds no model rather than a guessed one.
+    expect(store.getRecord(SESSION)?.options?.model).toBeUndefined()
+    expect(lastPhase()).toBe('starting')
+
+    await adapter.drainStartup(SESSION)
+    await Promise.all(lifecycle)
+
+    expect(store.getRecord(SESSION)?.options?.model).toBe('claude-opus-9')
+    expect(lastPhase()).toBe('ready')
+  })
+
+  it('keeps the saved model as intent while starting, then confirms what the child runs', async () => {
+    const params = claudeParams()
+    await expect(
+      host.attach(CALLER, { ...params, options: { model: 'opus' } })
+    ).resolves.toMatchObject({ ok: true })
+    expect(store.getRecord(SESSION)?.options?.model).toBe('opus')
+
+    await adapter.drainStartup(SESSION)
+    await Promise.all(lifecycle)
+
+    expect(store.getRecord(SESSION)?.options?.model).toBe('opus')
+    expect(lastPhase()).toBe('ready')
+  })
+})
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-provider-started.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-provider-started.ts
new file mode 100644
index 000000000000..f62c4e205fe3
--- /dev/null
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-provider-started.ts
@@ -0,0 +1,78 @@
+// The host's half of a provider child proving its start.
+//
+// A publish-first acquire hands the host a child that has answered nothing yet, so the record
+// keeps only the saved options the reservation carried. This is where the host learns the start
+// landed, flips the session to `ready`, and persists what the child now reports as fact through
+// the same record write a user's option change takes. Bookkeeping never gates the user: a failed
+// write is reported and the session stays usable.
+
+import { agentSessionLeaseAdmitsWriter } from '../../../shared/agent-session-lease-adjudication'
+import type { StructuredAgentSessionStartedEvent } from './structured-agent-session-adapter'
+import type {
+  StructuredAgentSessionHostDeps,
+  StructuredAgentSessionHostSession
+} from './structured-agent-session-host-types'
+import { readNativeSessionOptions } from './structured-agent-session-option-restoration'
+
+export type StructuredAgentSessionProviderStartedContext = {
+  deps: StructuredAgentSessionHostDeps
+  sessions: Map<string, StructuredAgentSessionHostSession>
+  serialize: <T>(sessionId: string, task: () => Promise<T>) => Promise<T>
+  now: () => number
+  publishStatus?: (sessionId: string) => void
+  onBarrierError: (sessionId: string, error: unknown) => void
+}
+
+export function settleStructuredAgentSessionProviderStarted(
+  context: StructuredAgentSessionProviderStartedContext,
+  event: StructuredAgentSessionStartedEvent
+): Promise<void> {
+  // Serialized behind the attach that published this child, so the lease it proved is committed.
+  return context.serialize(event.sessionId, async () => {
+    const session = context.sessions.get(event.sessionId)
+    if (
+      !session?.hasProviderChild ||
+      session.fence !== event.fence ||
+      session.acquisitionGeneration !== event.acquisitionGeneration
+    ) {
+      return
+    }
+    session.providerChildPhase = 'ready'
+    try {
+      await persistStartedOptions(context, event)
+    } catch (error) {
+      context.onBarrierError(event.sessionId, error)
+    } finally {
+      context.publishStatus?.(event.sessionId)
+    }
+  })
+}
+
+async function persistStartedOptions(
+  context: StructuredAgentSessionProviderStartedContext,
+  event: StructuredAgentSessionStartedEvent
+): Promise<void> {
+  const { store, adapter } = context.deps
+  const record = store.getRecord(event.sessionId)
+  if (
+    !record ||
+    record.lease.runtimeFence !== event.fence ||
+    !agentSessionLeaseAdmitsWriter(record.lease)
+  ) {
+    return
+  }
+  const options = await readNativeSessionOptions({
+    adapter,
+    sessionId: event.sessionId,
+    fence: event.fence,
+    ...(record.options ? { priorOptions: record.options } : {})
+  })
+  if (options) {
+    await store.replaceSessionOptions({
+      sessionId: event.sessionId,
+      fence: event.fence,
+      options,
+      now: context.now()
+    })
+  }
+}
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-read-restore.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-read-restore.ts
index 34fd6452b08f..543a1a7be709 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-read-restore.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-read-restore.ts
@@ -20,6 +20,7 @@ export type RestoredStructuredAgentSessionRead = {
   params: AgentSessionAttachParams
   fence: number
   hasProviderChild: false
+  providerChildPhase: 'ready'
   acquisitionGeneration: null
 }
 
@@ -67,6 +68,7 @@ export async function restoreStructuredAgentSessionRead(
     params,
     fence: record.lease.runtimeFence,
     hasProviderChild: false,
+    providerChildPhase: 'ready',
     acquisitionGeneration: null
   }
 }
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-status-feed-test-session.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-status-feed-test-session.ts
index 29e450c187d3..e4fa6ebed1bf 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-status-feed-test-session.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-status-feed-test-session.ts
@@ -3,6 +3,7 @@ import type { AgentSessionJournal } from '../agent-session-journal/journal-store
 export function indexedStatusFeedSession(session: {
   journal: AgentSessionJournal
   hasProviderChild?: boolean
+  providerChildPhase?: 'starting' | 'ready'
   fence?: number
 }) {
   return {
@@ -11,6 +12,7 @@ export function indexedStatusFeedSession(session: {
     ...(session.hasProviderChild !== undefined
       ? { hasProviderChild: session.hasProviderChild }
       : {}),
+    ...(session.providerChildPhase ? { providerChildPhase: session.providerChildPhase } : {}),
     params: {
       location: {
         executionHostId: 'local' as const,
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-status-feed.test.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-status-feed.test.ts
index e5d3d16e5dd8..65c7f54fb305 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-status-feed.test.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-status-feed.test.ts
@@ -60,10 +60,7 @@ async function openJournal(sessionId = SESSION, now?: () => number) {
 }
 
 function feedFor(
-  sessions: Map<
-    string,
-    { journal: Awaited<ReturnType<typeof openJournal>>; hasProviderChild?: boolean; fence?: number }
-  >,
+  sessions: Map<string, Parameters<typeof indexed>[0]>,
   record: Partial<AgentSessionRecord> | null = null,
   onStatusChanged?: StructuredAgentSessionStatusFeedDeps['onStatusChanged'],
   readBackgroundTasks?: StructuredAgentSessionStatusFeedDeps['readBackgroundTasks'],
@@ -94,6 +91,24 @@ function feedFor(
 }
 
 describe('StructuredAgentSessionStatusFeed', () => {
+  it('projects whether the owned child has proven its start, and nothing once it is not owned', async () => {
+    const journal = await openJournal()
+    const session = { journal, hasProviderChild: true, providerChildPhase: 'starting' as const }
+    const sessions = new Map<string, Parameters<typeof indexed>[0]>([[SESSION, session]])
+    const { feed, events, dispose } = feedFor(sessions)
+    expect(events.at(-1)).toMatchObject({
+      type: 'snapshot',
+      sessions: [{ hostExecutionOwned: true, hostExecutionPhase: 'starting' }]
+    })
+    sessions.set(SESSION, { ...session, providerChildPhase: 'ready' })
+    feed.publish(SESSION, journal)
+    expect(events.at(-1)).toMatchObject({ session: { hostExecutionPhase: 'ready' } })
+    sessions.set(SESSION, { ...session, hasProviderChild: false })
+    feed.publish(SESSION, journal)
+    expect(events.at(-1)).not.toMatchObject({ session: { hostExecutionPhase: expect.any(String) } })
+    dispose()
+  })
+
   it('publishes provider ownership transitions without changing journal time', async () => {
     const journal = await openJournal()
     const sessions = new Map([[SESSION, { journal, hasProviderChild: true }]])
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-status-feed.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-status-feed.ts
index cecd5455ca7d..fd5d1bff8ab0 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-status-feed.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-status-feed.ts
@@ -22,6 +22,7 @@ import {
 } from '../../../shared/agent-session-wire'
 import { projectStructuredAgentSessionStatusSummary } from '../../../shared/structured-agent-session-projection'
 import type { AgentSessionJournal } from '../agent-session-journal/journal-store'
+import type { StructuredAgentSessionProviderChildPhase } from './structured-agent-session-adapter'
 import { structuredAgentSessionProviderSessionMetadata } from './structured-agent-session-history-result'
 import {
   StructuredAgentSessionStatusOwnership,
@@ -39,6 +40,7 @@ type StatusFeedSession = {
   journal: AgentSessionJournal
   params: { location: AgentSessionRecord['location']; provider: AgentSessionRecord['provider'] }
   hasProviderChild?: boolean
+  providerChildPhase?: StructuredAgentSessionProviderChildPhase
   fence?: number
 }
 
@@ -63,6 +65,7 @@ function summariesEqual(a: AgentSessionStatusSummary, b: AgentSessionStatusSumma
     a.agent === b.agent &&
     a.status === b.status &&
     a.hostExecutionOwned === b.hostExecutionOwned &&
+    a.hostExecutionPhase === b.hostExecutionPhase &&
     a.rewindBlockedReason === b.rewindBlockedReason &&
     // Settled activity changes ranking; streaming active turns must stay quiet.
     (a.status !== 'idle' || a.updatedAt === b.updatedAt) &&
@@ -253,7 +256,14 @@ export class StructuredAgentSessionStatusFeed {
       sessionId,
       workspaceId: session.params.location.workspaceId,
       agent: session.params.provider,
-      ...(session.hasProviderChild ? { hostExecutionOwned: true as const } : {}),
+      ...(session.hasProviderChild
+        ? {
+            hostExecutionOwned: true as const,
+            ...(session.providerChildPhase
+              ? { hostExecutionPhase: session.providerChildPhase }
+              : {})
+          }
+        : {}),
       ...projection.summary,
       ...(record?.rewind?.phase === 'prepared' || record?.rewind?.phase === 'provider-succeeded'
         ? { rewindBlockedReason: 'outcome-unknown' as const }
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-unexpected-exit.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-unexpected-exit.ts
index 5e90d7d79089..34f1a97f1618 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-unexpected-exit.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-unexpected-exit.ts
@@ -1,4 +1,4 @@
-import type { StructuredAgentSessionLifecycleEvent } from './structured-agent-session-adapter'
+import type { StructuredAgentSessionEndedEvent } from './structured-agent-session-adapter'
 import type { StructuredAgentSessionHostSession } from './structured-agent-session-host-types'
 import {
   releaseStoredStructuredAgentSessionOwnerAfterUnexpectedExit,
@@ -14,7 +14,7 @@ import {
 } from './structured-agent-session-dead-generation-settlement'
 import type { StructuredAgentSessionTurnVerdict } from './structured-agent-session-stale-turn-verdict'
 
-type UnexpectedExitLifecycleEvent = StructuredAgentSessionLifecycleEvent & {
+type UnexpectedExitLifecycleEvent = StructuredAgentSessionEndedEvent & {
   cause: 'unexpected-exit'
 }
 
@@ -50,7 +50,7 @@ export async function settleUnexpectedStructuredAgentSessionExit<
   TSession extends StructuredAgentSessionUnexpectedExitSession
 >(
   context: StructuredAgentSessionUnexpectedExitContext<TSession>,
-  event: StructuredAgentSessionLifecycleEvent
+  event: StructuredAgentSessionEndedEvent
 ): Promise<StructuredAgentSessionRecoveryTicket | null> {
   if (event.cause !== 'unexpected-exit') {
     return null
diff --git a/src/main/native-chat/agent-session-wire/structured-tui-transcript-catchup.test.ts b/src/main/native-chat/agent-session-wire/structured-tui-transcript-catchup.test.ts
index 6e4cf64b5bfc..9866b811c613 100644
--- a/src/main/native-chat/agent-session-wire/structured-tui-transcript-catchup.test.ts
+++ b/src/main/native-chat/agent-session-wire/structured-tui-transcript-catchup.test.ts
@@ -104,6 +104,7 @@ function createCatchup(input: Awaited<ReturnType<typeof createCatchupFixture>>)
     store,
     session: () => ({
       hasProviderChild: false,
+      providerChildPhase: 'ready',
       journal: input.journal,
       params: {} as never,
       fence: input.fence,
diff --git a/src/main/runtime/structured-agent-session-runtime.ts b/src/main/runtime/structured-agent-session-runtime.ts
index 7cd945d97022..1e2c8454c6f6 100644
--- a/src/main/runtime/structured-agent-session-runtime.ts
+++ b/src/main/runtime/structured-agent-session-runtime.ts
@@ -284,7 +284,7 @@ async function install(deps: StructuredAgentSessionRuntimeDeps): Promise<Install
               readClaudeManagedAccountGateSettings(deps.getClaudeManagedAccountGateSettings!)
           }
         : {}),
-      onUnexpectedExit: (event) => {
+      onLifecycleEvent: (event) => {
         recoveryChain = recoveryChain.then(async () => {
           try {
             await host?.handleAdapterEvent(event)
diff --git a/src/main/runtime/structured-claude-runtime-adapter.ts b/src/main/runtime/structured-claude-runtime-adapter.ts
index fd0f31dd533d..62f5ba194447 100644
--- a/src/main/runtime/structured-claude-runtime-adapter.ts
+++ b/src/main/runtime/structured-claude-runtime-adapter.ts
@@ -12,6 +12,7 @@ import {
 } from '../claude/claude-structured-session-adapter'
 import { claudeProviderHandleLink } from '../claude/claude-structured-owner-identity'
 import type { StructuredAgentSessionLifecycleEvent } from '../native-chat/agent-session-wire/structured-agent-session-adapter'
+import type { ClaudeStructuredSessionEvent } from '../claude/claude-structured-session-state'
 import {
   readClaudeTranscriptLeafUuid,
   resolveSessionFilePath
@@ -33,7 +34,7 @@ export type StructuredClaudeRuntimeAdapterDeps = {
   readClaudeManagedAccountGate?: () => ClaudeManagedAccountGateSettings | null
   openClaudeConnection?: ClaudeStructuredSessionAdapterDeps['openConnection']
   readProcessStartTime?: ClaudeStructuredSessionAdapterDeps['readProcessStartTime']
-  onUnexpectedExit: (event: StructuredAgentSessionLifecycleEvent) => void
+  onLifecycleEvent: (event: StructuredAgentSessionLifecycleEvent) => void
   onBackgroundTasksChanged?: (
     sessionId: string,
     state: AgentSessionBackgroundTaskState | null
@@ -41,6 +42,35 @@ export type StructuredClaudeRuntimeAdapterDeps = {
   onDispatchSettledLate?: ClaudeStructuredSessionAdapterDeps['onDispatchSettledLate']
 }
 
+/** The adapter events the host's lifecycle handler consumes, in the host's vocabulary. */
+export function structuredClaudeLifecycleEvent(
+  event: ClaudeStructuredSessionEvent
+): StructuredAgentSessionLifecycleEvent | null {
+  if (event.type === 'started') {
+    return event
+  }
+  if (
+    event.type === 'ended' &&
+    event.cause === 'unexpected-exit' &&
+    event.fence !== undefined &&
+    event.acquisitionGeneration
+  ) {
+    return {
+      type: 'ended',
+      sessionId: event.sessionId,
+      reason: event.reason,
+      cause: event.cause,
+      fence: event.fence,
+      acquisitionGeneration: event.acquisitionGeneration,
+      ...(event.settlementRetryRequired
+        ? { settlementRetryRequired: event.settlementRetryRequired }
+        : {}),
+      ...(event.startupUnproven ? { startupUnproven: event.startupUnproven } : {})
+    }
+  }
+  return null
+}
+
 export function createStructuredClaudeRuntimeAdapter(
   deps: StructuredClaudeRuntimeAdapterDeps
 ): ClaudeStructuredSessionAdapter {
@@ -101,24 +131,9 @@ export function createStructuredClaudeRuntimeAdapter(
         : null
     },
     onEvent: (event) => {
-      if (
-        event.type === 'ended' &&
-        event.cause === 'unexpected-exit' &&
-        event.fence !== undefined &&
-        event.acquisitionGeneration
-      ) {
-        deps.onUnexpectedExit({
-          type: 'ended',
-          sessionId: event.sessionId,
-          reason: event.reason,
-          cause: event.cause,
-          fence: event.fence,
-          acquisitionGeneration: event.acquisitionGeneration,
-          ...(event.settlementRetryRequired
-            ? { settlementRetryRequired: event.settlementRetryRequired }
-            : {}),
-          ...(event.startupUnproven ? { startupUnproven: event.startupUnproven } : {})
-        })
+      const lifecycle = structuredClaudeLifecycleEvent(event)
+      if (lifecycle) {
+        deps.onLifecycleEvent(lifecycle)
       }
     },
     ...(deps.onBackgroundTasksChanged
diff --git a/src/renderer/src/components/native-chat/NativeChatStructuredSession.test-harness.tsx b/src/renderer/src/components/native-chat/NativeChatStructuredSession.test-harness.tsx
index 9ca3490827bb..63a9a7592929 100644
--- a/src/renderer/src/components/native-chat/NativeChatStructuredSession.test-harness.tsx
+++ b/src/renderer/src/components/native-chat/NativeChatStructuredSession.test-harness.tsx
@@ -73,7 +73,9 @@ export function createStructuredSessionMocks() {
 
   const moduleFactories = {
     structuredAgentSessionClient: () => ({
-      callStructuredAgentSession: mocks.call
+      callStructuredAgentSession: mocks.call,
+      // The pane activates the host status feed for its startup phase; nothing here drives it.
+      subscribeStructuredAgentSessionStatus: async () => ({ unsubscribe: () => {} })
     }),
     useStructuredAgentSession: async () => {
       const { useStructuredAgentSessionOutbox } =
diff --git a/src/renderer/src/components/native-chat/NativeChatStructuredSession.tsx b/src/renderer/src/components/native-chat/NativeChatStructuredSession.tsx
index 3e2923dc1144..f773993009fe 100644
--- a/src/renderer/src/components/native-chat/NativeChatStructuredSession.tsx
+++ b/src/renderer/src/components/native-chat/NativeChatStructuredSession.tsx
@@ -23,6 +23,8 @@ import { useNativeChatLaunchDraftSignal } from './use-native-chat-launch-draft-a
 import { NativeChatLaunchRetry } from './NativeChatLaunchRetry'
 import { useNativeChatProvisionalLaunch } from './use-native-chat-provisional-launch'
 import { NativeChatDeliveryRetry } from './NativeChatDeliveryRetry'
+import { useStructuredAgentSessionStatusSummary } from './StructuredAgentSessionStatusBridge'
+import { structuredAgentLabel } from '@/lib/structured-agent-session-launch-label'
 
 function encodeQuestionAnswer(questionId: string, answer: string): string {
   return `${encodeURIComponent(questionId)}:${encodeURIComponent(answer)}`
@@ -37,6 +39,10 @@ export function NativeChatStructuredSession(
     props.sessionId
   )
   const { sendThroughRelaunch } = provisionalLaunch
+  // The host's own word on whether the provider child has answered startup yet.
+  const startupPhase =
+    useStructuredAgentSessionStatusSummary(props.sessionId, props.target).summary
+      ?.hostExecutionPhase ?? null
   const controller = useStructuredAgentSession({
     ...props,
     transportEnabled: provisionalLaunch.transportEnabled
@@ -316,6 +322,8 @@ export function NativeChatStructuredSession(
       />
       <NativeChatStructuredSessionStatus
         sessionId={props.sessionId}
+        agentLabel={structuredAgentLabel(props.agent === 'codex' ? 'codex' : 'claude')}
+        startupPhase={startupPhase}
         error={controller.error}
         composerError={composerError}
         isVisible={props.isVisible}
diff --git a/src/renderer/src/components/native-chat/NativeChatStructuredSessionStatus.test.tsx b/src/renderer/src/components/native-chat/NativeChatStructuredSessionStatus.test.tsx
new file mode 100644
index 000000000000..77e365886c8c
--- /dev/null
+++ b/src/renderer/src/components/native-chat/NativeChatStructuredSessionStatus.test.tsx
@@ -0,0 +1,49 @@
+// @vitest-environment happy-dom
+
+import '@testing-library/jest-dom/vitest'
+
+import { cleanup, render, screen } from '@testing-library/react'
+import { afterEach, describe, expect, it, vi } from 'vitest'
+import { NativeChatStructuredSessionStatus } from './NativeChatStructuredSessionStatus'
+
+afterEach(cleanup)
+
+const NO_TASKS = {
+  show: false,
+  isMonitoring: false,
+  tasks: [],
+  settledTasks: [],
+  supportsStop: false,
+  supportsStopAll: false
+}
+
+function renderStatus(startupPhase: 'starting' | 'ready' | null) {
+  return render(
+    <NativeChatStructuredSessionStatus
+      sessionId="session-1"
+      agentLabel="Claude"
+      startupPhase={startupPhase}
+      error={null}
+      composerError={null}
+      isVisible
+      backgroundTasks={NO_TASKS}
+      stopBackgroundTask={vi.fn(async () => undefined)}
+    />
+  )
+}
+
+describe('NativeChatStructuredSessionStatus', () => {
+  it('says the agent is still starting while the host reports a starting child', () => {
+    renderStatus('starting')
+    expect(screen.getByText(/Claude is still starting/)).toBeInTheDocument()
+    expect(screen.getByText(/close this chat/)).toBeInTheDocument()
+  })
+
+  it('shows nothing about startup once the child is ready or the host has no word', () => {
+    renderStatus('ready')
+    expect(screen.queryByText(/still starting/)).not.toBeInTheDocument()
+    cleanup()
+    renderStatus(null)
+    expect(screen.queryByText(/still starting/)).not.toBeInTheDocument()
+  })
+})
diff --git a/src/renderer/src/components/native-chat/NativeChatStructuredSessionStatus.tsx b/src/renderer/src/components/native-chat/NativeChatStructuredSessionStatus.tsx
index 02bc9936f679..86a2b858a422 100644
--- a/src/renderer/src/components/native-chat/NativeChatStructuredSessionStatus.tsx
+++ b/src/renderer/src/components/native-chat/NativeChatStructuredSessionStatus.tsx
@@ -1,4 +1,5 @@
 import { useState } from 'react'
+import { translate } from '@/i18n/i18n'
 import { NativeChatBackgroundTasksStatus } from './NativeChatBackgroundTasksStatus'
 import type { StructuredSessionBackgroundTasksView } from './structured-session-background-tasks-view'
 
@@ -12,6 +13,10 @@ const NO_STOPPING_TASKS: ReadonlySet<string> = new Set()
 
 export function NativeChatStructuredSessionStatus(props: {
   sessionId: string
+  /** What to call the agent in copy about its process. */
+  agentLabel: string
+  /** The host's word on the provider child; `starting` is published but not yet answering. */
+  startupPhase: 'starting' | 'ready' | null
   error: string | null
   composerError: string | null
   isVisible: boolean
@@ -54,6 +59,15 @@ export function NativeChatStructuredSessionStatus(props: {
 
   return (
     <>
+      {props.startupPhase === 'starting' ? (
+        <p className="mx-auto w-full max-w-4xl px-4 py-1 text-xs text-muted-foreground">
+          {translate(
+            'auto.components.native.chat.NativeChatStructuredSessionStatus.starting',
+            '{{value0}} is still starting. Messages wait until it is ready; close this chat to give up on it.',
+            { value0: props.agentLabel }
+          )}
+        </p>
+      ) : null}
       {props.error || props.composerError ? (
         <p className="mx-auto w-full max-w-4xl px-4 py-1 text-xs text-destructive">
           {props.error ?? props.composerError}
diff --git a/src/renderer/src/components/native-chat/StructuredAgentSessionStatusBridge.tsx b/src/renderer/src/components/native-chat/StructuredAgentSessionStatusBridge.tsx
index 05738708bf66..8dc3ec81a554 100644
--- a/src/renderer/src/components/native-chat/StructuredAgentSessionStatusBridge.tsx
+++ b/src/renderer/src/components/native-chat/StructuredAgentSessionStatusBridge.tsx
@@ -19,7 +19,7 @@ import { getStructuredAgentSessionTabs, type StructuredTab } from './structured-
 export { getStructuredAgentSessionTabs } from './structured-agent-session-tabs'
 
 /** The host's projected status for one session, live while the caller is mounted. */
-function useStructuredAgentSessionStatusSummary(
+export function useStructuredAgentSessionStatusSummary(
   sessionId: string,
   target: RuntimeClientTarget
 ): { summary: AgentSessionStatusSummary | null; observation: 'live' | 'unverifiable' } {
diff --git a/src/renderer/src/i18n/locales/en.json b/src/renderer/src/i18n/locales/en.json
index bf89d826a7ff..371e6d422fe8 100644
--- a/src/renderer/src/i18n/locales/en.json
+++ b/src/renderer/src/i18n/locales/en.json
@@ -17087,6 +17087,9 @@
             "failed": "Chat could not be started.",
             "unknown": "Chat connection could not be confirmed.",
             "retry": "Retry"
+          },
+          "NativeChatStructuredSessionStatus": {
+            "starting": "{{value0}} is still starting. Messages wait until it is ready; close this chat to give up on it."
           }
         }
       },
diff --git a/src/renderer/src/runtime/structured-agent-session-status-feed.ts b/src/renderer/src/runtime/structured-agent-session-status-feed.ts
index 4a50717f638a..84bbcacdeccf 100644
--- a/src/renderer/src/runtime/structured-agent-session-status-feed.ts
+++ b/src/renderer/src/runtime/structured-agent-session-status-feed.ts
@@ -95,7 +95,7 @@ function createOwner(target: RuntimeClientTarget): OwnedStatusFeed {
       if (!next) {
         next = new Map(snapshot)
       }
-      const { hostExecutionOwned: _owned, ...retained } = summary
+      const { hostExecutionOwned: _owned, hostExecutionPhase: _phase, ...retained } = summary
       next.set(sessionId, retained)
     }
     if (next) {
diff --git a/src/shared/agent-session-wire.ts b/src/shared/agent-session-wire.ts
index e0fb247a1791..b9a0bdbfa7ca 100644
--- a/src/shared/agent-session-wire.ts
+++ b/src/shared/agent-session-wire.ts
@@ -209,6 +209,9 @@ export type AgentSessionStatusSummary = {
   status: StructuredAgentSessionProjectedStatus | null
   /** Present only while this host has the provider child executing the session. */
   hostExecutionOwned?: true
+  /** With `hostExecutionOwned`: whether that child has proven its start. `starting` is a
+   *  published session whose provider has not yet answered startup; absent on older hosts. */
+  hostExecutionPhase?: 'starting' | 'ready'
   latestPrompt: string
   /** Provider model in force for the next turn; absent until the host has read the options. */
   model?: string

From 49c6c03ae3391cdb8381f8de862807064eb55223 Mon Sep 17 00:00:00 2001
From: Brennan Benson <79079362+brennanb2025@users.noreply.github.com>
Date: Wed, 23 Sep 2026 00:19:01 -0700
Subject: [PATCH 12/67] fix(native-chat): a hold and a send that find the owner
 gone share one restart, and a send the ledger already holds restarts nothing

---
 ...red-agent-session-hold-resume-race.test.ts | 137 ++++--------------
 .../structured-agent-session-hold-resume.ts   |   4 +-
 .../structured-agent-session-holds.test.ts    |  36 ++++-
 .../structured-agent-session-holds.ts         |  36 ++++-
 .../structured-agent-session-host-lifetime.ts |   9 +-
 ...structured-agent-session-host-mutations.ts |   6 +-
 .../structured-agent-session-host.ts          |   2 +-
 ...ctured-agent-session-send-recovery.test.ts |  73 +++++++++-
 .../structured-agent-session-send-recovery.ts |  69 ++++-----
 ...uctured-conversation-command-controller.ts |  13 +-
 .../agent-session-operation-admission.ts      |   9 +-
 .../runtime/agent-session-record-store.ts     |  18 ++-
 ...e-structured-agent-session-outbox.test.tsx |   2 +-
 src/shared/agent-session-operation-ledger.ts  |  14 ++
 14 files changed, 245 insertions(+), 183 deletions(-)

diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-hold-resume-race.test.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-hold-resume-race.test.ts
index bd3a840d9ad9..b7a88d7484ff 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-hold-resume-race.test.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-hold-resume-race.test.ts
@@ -15,6 +15,7 @@ function resumeHarness() {
     resume: async () => {
       await resumeGate.promise
       child = true
+      return { fromFence: 1 }
     },
     hasProviderChild: () => child,
     isTurnActive: () => turnActive,
@@ -165,125 +166,47 @@ describe('a surface leaving while its structured session resumes', () => {
     expect(evict).toHaveBeenCalledExactlyOnceWith('session-1')
   })
 
-  it.each([false, true])(
-    'keeps a reused holder when old resume fails (replacement finished=%s)',
-    async (replacementFinished) => {
-      const firstGate = Promise.withResolvers<void>()
-      const replacementGate = Promise.withResolvers<void>()
-      let child = false
-      const resume = vi
-        .fn()
-        .mockImplementationOnce(() => firstGate.promise)
-        .mockImplementationOnce(async () => {
-          await replacementGate.promise
-          child = true
-        })
-      const evict = vi.fn(async () => {})
-      const holds = new StructuredAgentSessionHolds({
-        resume,
-        hasProviderChild: () => child,
-        isTurnActive: () => false,
-        evict,
-        graceMs: GRACE_MS
-      })
-      pendingHolds.push(holds)
-      const first = holds.hold('session-1', 'same-holder')
-      const rejected = expect(first).rejects.toThrow('old acquisition failed')
-      holds.release('session-1', 'same-holder')
-      const replacement = holds.hold('session-1', 'same-holder')
-      if (replacementFinished) {
-        replacementGate.resolve()
-        await replacement
-      }
+  it('joins a pending resume for a holder that left and came back, and a failure releases it', async () => {
+    const { holds, resumeGate, evict } = resumeHarness()
+    const first = holds.hold('session-1', 'same-holder')
+    const firstRejected = expect(first).rejects.toThrow('acquisition failed')
+    holds.release('session-1', 'same-holder')
+    const replacement = holds.hold('session-1', 'same-holder')
+    const replacementRejected = expect(replacement).rejects.toThrow('acquisition failed')
+    expect(holds.isHeld('session-1')).toBe(true)
 
-      firstGate.reject(new Error('old acquisition failed'))
-      await rejected
-      expect(holds.isHeld('session-1')).toBe(true)
-      replacementGate.resolve()
-      await replacement
-      await vi.advanceTimersByTimeAsync(GRACE_MS * 2)
-      expect(evict).not.toHaveBeenCalled()
+    resumeGate.reject(new Error('acquisition failed'))
+    await Promise.all([firstRejected, replacementRejected])
 
-      holds.release('session-1', 'same-holder')
-      await vi.advanceTimersByTimeAsync(GRACE_MS)
-      expect(evict).toHaveBeenCalledExactlyOnceWith('session-1')
-    }
-  )
+    expect(holds.isHeld('session-1')).toBe(false)
+    expect(holds.isReleasePending('session-1')).toBe(false)
+    await vi.advanceTimersByTimeAsync(GRACE_MS * 2)
+    expect(evict).not.toHaveBeenCalled()
+  })
 
-  it('removes a failed replacement while the released old hold is still pending', async () => {
-    const firstGate = Promise.withResolvers<void>()
+  it('starts a fresh resume once the failed one has settled', async () => {
+    let child = false
     const resume = vi
-      .fn()
-      .mockImplementationOnce(() => firstGate.promise)
-      .mockRejectedValueOnce(new Error('replacement acquisition failed'))
+      .fn<() => Promise<{ fromFence: number }>>()
+      .mockRejectedValueOnce(new Error('first acquisition failed'))
+      .mockImplementationOnce(async () => {
+        child = true
+        return { fromFence: 1 }
+      })
     const holds = new StructuredAgentSessionHolds({
       resume,
-      hasProviderChild: () => false,
+      hasProviderChild: () => child,
       isTurnActive: () => false,
       evict: async () => {},
       graceMs: GRACE_MS
     })
     pendingHolds.push(holds)
-    const first = holds.hold('session-1', 'same-holder')
-    const rejected = expect(first).rejects.toThrow('old acquisition failed')
-    holds.release('session-1', 'same-holder')
 
-    await expect(holds.hold('session-1', 'same-holder')).rejects.toThrow(
-      'replacement acquisition failed'
-    )
-    expect(holds.isHeld('session-1')).toBe(false)
-    expect(holds.isReleasePending('session-1')).toBe(false)
+    await expect(holds.hold('session-1', 'chat-1')).rejects.toThrow('first acquisition failed')
+    expect(holds.isResuming('session-1')).toBe(false)
+    await holds.hold('session-1', 'chat-1')
 
-    firstGate.reject(new Error('old acquisition failed'))
-    await rejected
-    expect(holds.isHeld('session-1')).toBe(false)
+    expect(resume).toHaveBeenCalledTimes(2)
+    expect(holds.isHeld('session-1')).toBe(true)
   })
-
-  it.each(['old-holder', 'different-holder'])(
-    'releases the old acquisition after replacement %s fails, once its turn finishes',
-    async (replacementHolder) => {
-      const firstGate = Promise.withResolvers<void>()
-      const replacementGate = Promise.withResolvers<void>()
-      let child = false
-      let turnActive = true
-      const resume = vi
-        .fn()
-        .mockImplementationOnce(async () => {
-          await firstGate.promise
-          child = true
-        })
-        .mockImplementationOnce(() => replacementGate.promise)
-      const evict = vi.fn(async () => {
-        child = false
-      })
-      const holds = new StructuredAgentSessionHolds({
-        resume,
-        hasProviderChild: () => child,
-        isTurnActive: () => turnActive,
-        evict,
-        graceMs: GRACE_MS
-      })
-      pendingHolds.push(holds)
-      const first = holds.hold('session-1', 'old-holder')
-      holds.release('session-1', 'old-holder')
-      const replacement = holds.hold('session-1', replacementHolder)
-      const rejected = expect(replacement).rejects.toThrow('replacement acquisition failed')
-      firstGate.resolve()
-      await first
-      expect(holds.isReleasePending('session-1')).toBe(false)
-
-      replacementGate.reject(new Error('replacement acquisition failed'))
-      await rejected
-      expect(holds.isHeld('session-1')).toBe(false)
-      expect(holds.isReleasePending('session-1')).toBe(true)
-      await vi.advanceTimersByTimeAsync(GRACE_MS)
-      expect(evict).not.toHaveBeenCalled()
-      expect(child).toBe(true)
-
-      turnActive = false
-      await vi.advanceTimersByTimeAsync(GRACE_MS)
-      expect(evict).toHaveBeenCalledExactlyOnceWith('session-1')
-      expect(child).toBe(false)
-    }
-  )
 })
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-hold-resume.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-hold-resume.ts
index 5ebdfed01145..2bc46e40747a 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-hold-resume.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-hold-resume.ts
@@ -11,6 +11,7 @@ import type {
 } from '../../../shared/agent-session-wire'
 import type { AgentSessionAttachParams } from './structured-agent-session-attach'
 import type { StructuredAgentSessionHostDeps } from './structured-agent-session-host-types'
+import type { StructuredAgentSessionResumed } from './structured-agent-session-holds'
 import { adapterSupportsRecord } from './structured-agent-session-provider-support'
 import {
   structuredAgentSessionResumeOperationId,
@@ -24,7 +25,7 @@ export async function resumeHeldStructuredAgentSession(input: {
   attach: (
     params: AgentSessionAttachParams
   ) => Promise<AgentSessionMutationResult<AgentSessionAttachResult>>
-}): Promise<void> {
+}): Promise<StructuredAgentSessionResumed> {
   const record = input.deps.store.getRecord(input.sessionId)
   if (!record) {
     throw new Error('agent_session_identity_required')
@@ -49,4 +50,5 @@ export async function resumeHeldStructuredAgentSession(input: {
   if (!attached.ok) {
     throw new Error(attached.refusal.code)
   }
+  return { fromFence: record.lease.runtimeFence }
 }
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-holds.test.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-holds.test.ts
index 697c944e171b..6742720838db 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-holds.test.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-holds.test.ts
@@ -170,6 +170,7 @@ describe('holds', () => {
     let child = false
     const resume = vi.fn(async () => {
       child = true
+      return { fromFence: 1 }
     })
     const holds = new StructuredAgentSessionHolds({
       resume,
@@ -191,10 +192,41 @@ describe('holds', () => {
     holds.dispose()
   })
 
+  it('runs one resume for a hold and a writer that ask in the same gap', async () => {
+    const gate = Promise.withResolvers<void>()
+    let child = false
+    const resume = vi.fn(async () => {
+      await gate.promise
+      child = true
+      return { fromFence: 7 }
+    })
+    const holds = new StructuredAgentSessionHolds({
+      resume,
+      hasProviderChild: () => child,
+      isTurnActive: () => false,
+      evict: async () => {},
+      graceMs: 1
+    })
+
+    const writer = holds.resumeUnheld('session-1')
+    expect(holds.isResuming('session-1')).toBe(true)
+    const hold = holds.hold('session-1', 'chat-1')
+    gate.resolve()
+
+    await expect(writer).resolves.toEqual({ fromFence: 7 })
+    await hold
+    expect(resume).toHaveBeenCalledOnce()
+    expect(holds.isResuming('session-1')).toBe(false)
+    // The surface arrived while the writer's resume ran, so the child it got is held, not idle.
+    expect(holds.isHeld('session-1')).toBe(true)
+    expect(holds.isReleasePending('session-1')).toBe(false)
+    holds.dispose()
+  })
+
   it('never arms the clock for a session with nothing to stop', async () => {
     const evict = vi.fn(async () => {})
     const holds = new StructuredAgentSessionHolds({
-      resume: async () => {},
+      resume: async () => ({ fromFence: 1 }),
       hasProviderChild: () => false,
       isTurnActive: () => false,
       evict,
@@ -212,7 +244,7 @@ describe('holds', () => {
 
   it('fails a write-capable hold when resume proves no provider child', async () => {
     const holds = new StructuredAgentSessionHolds({
-      resume: async () => {},
+      resume: async () => ({ fromFence: 1 }),
       hasProviderChild: () => false,
       isTurnActive: () => false,
       evict: async () => {},
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-holds.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-holds.ts
index c24c9212374d..8212f64068c0 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-holds.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-holds.ts
@@ -9,6 +9,11 @@
 // process exist. The last hold leaving starts the idle release clock. Transport close is the BACKSTOP,
 // not the mechanism: a client that vanishes mid-flight never sends its release, so the caller
 // registers one against the connection and the holder set absorbs the duplicate.
+//
+// A send to a childless session resumes it too, through the same single-flight: whoever asks first
+// starts the one resume, and everyone who asks while it runs shares its outcome. Two resumes for
+// one session would each attach against the same released fence, and the loser's stale fence
+// refuses it — a hold that lost dropped its holder, a send that lost was refused.
 
 import {
   StructuredAgentSessionReleaseClock,
@@ -16,9 +21,12 @@ import {
 } from './structured-agent-session-release-clock'
 import { StructuredAgentSessionHolders } from './structured-agent-session-holders'
 
+/** A resume moves the fence; a writer that was current as of the lost owner rebases from here. */
+export type StructuredAgentSessionResumed = { fromFence: number }
+
 export type StructuredAgentSessionHoldsDeps = {
-  /** Acquires a provider child for a session that has none. A no-op when one is already live. */
-  resume: (sessionId: string) => Promise<void>
+  /** Acquires a provider child for a session that has none. Throws the refusal code when it cannot. */
+  resume: (sessionId: string) => Promise<StructuredAgentSessionResumed>
   /** Whether evicting this session would actually free anything. */
   hasProviderChild: (sessionId: string) => boolean
   isTurnActive: (sessionId: string) => boolean
@@ -36,6 +44,7 @@ export type StructuredAgentSessionHoldOptions = {
 export class StructuredAgentSessionHolds {
   private readonly holders = new StructuredAgentSessionHolders()
   private readonly clock: StructuredAgentSessionReleaseClock
+  private readonly resumes = new Map<string, Promise<StructuredAgentSessionResumed>>()
   private disposed = false
 
   constructor(private readonly deps: StructuredAgentSessionHoldsDeps) {
@@ -75,10 +84,24 @@ export class StructuredAgentSessionHolds {
     }
   }
 
-  /** Resumes a childless session for a writer; with no surface holding it, the child is released
-   *  on the same clock a departed surface would start. */
-  async resumeUnheld(sessionId: string): Promise<void> {
-    await this.deps.resume(sessionId)
+  /** Resumes a childless session, or joins the resume already running for it. With no surface
+   *  holding it afterwards, the child is released on the same clock a departed surface would start. */
+  resumeUnheld(sessionId: string): Promise<StructuredAgentSessionResumed> {
+    const inFlight = this.resumes.get(sessionId)
+    if (inFlight) {
+      return inFlight
+    }
+    const resume = this.resumeOnce(sessionId).finally(() => this.resumes.delete(sessionId))
+    this.resumes.set(sessionId, resume)
+    return resume
+  }
+
+  isResuming(sessionId: string): boolean {
+    return this.resumes.has(sessionId)
+  }
+
+  private async resumeOnce(sessionId: string): Promise<StructuredAgentSessionResumed> {
+    const resumed = await this.deps.resume(sessionId)
     if (!this.deps.hasProviderChild(sessionId)) {
       throw new Error('agent_session_ownership_unknown')
     }
@@ -86,6 +109,7 @@ export class StructuredAgentSessionHolds {
     if (!this.disposed && !this.holders.isHeld(sessionId)) {
       this.clock.arm(sessionId)
     }
+    return resumed
   }
 
   /** Journal activity; only an unheld session's pending release notices. */
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-host-lifetime.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-host-lifetime.ts
index 4c6b355214a4..a6c54479e836 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-host-lifetime.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-host-lifetime.ts
@@ -12,7 +12,10 @@ import {
   type StructuredAgentSessionEvictionContext
 } from './structured-agent-session-eviction'
 import { withStructuredAgentSessionEvictionDeadline } from './structured-agent-session-eviction-deadline'
-import { StructuredAgentSessionHolds } from './structured-agent-session-holds'
+import {
+  StructuredAgentSessionHolds,
+  type StructuredAgentSessionResumed
+} from './structured-agent-session-holds'
 import type { StructuredAgentSessionHostRuntimeState } from './structured-agent-session-host-runtime-state'
 import type {
   StructuredAgentSessionHostDeps,
@@ -172,13 +175,13 @@ export async function resumeStructuredAgentSessionForHold(
   },
   sessionId: string,
   attach: Parameters<typeof resumeHeldStructuredAgentSession>[0]['attach']
-): Promise<void> {
+): Promise<StructuredAgentSessionResumed> {
   const unreconciled = await context.reconcileLeases(sessionId)
   if (unreconciled) {
     throw new Error(unreconciled.code)
   }
   await context.runtimeState.resolveRecovery(sessionId)
-  await resumeHeldStructuredAgentSession({
+  return resumeHeldStructuredAgentSession({
     sessionId,
     deps: context.deps,
     now: context.now,
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-host-mutations.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-host-mutations.ts
index dcdba261f314..3b7e56a1379d 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-host-mutations.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-host-mutations.ts
@@ -21,6 +21,7 @@ import type {
   AgentSessionWireRefusal
 } from '../../../shared/agent-session-wire'
 import type { AgentSessionRecord } from '../../../shared/agent-session-record'
+import type { StructuredAgentSessionHolds } from './structured-agent-session-holds'
 import { admitAndRunAgentSessionMutation } from './structured-agent-session-mutation-admission'
 import {
   cancelPlan,
@@ -43,8 +44,9 @@ export type StructuredAgentSessionMutationContext = {
   hasPendingStreamedEvents?: (sessionId: string) => boolean
   requireSession: (sessionId: string) => StructuredAgentSessionHostSession
   serialize: <T>(sessionId: string, task: () => Promise<T>) => Promise<T>
-  /** Gives a childless session a provider child; throws the refusal code when it cannot. */
-  resumeUnheld: (sessionId: string) => Promise<void>
+  /** The one resume a session may have running: a send restarts a lost owner through it, and joins
+   *  one a surface hold already started. */
+  resumes: Pick<StructuredAgentSessionHolds, 'resumeUnheld' | 'isResuming'>
   now: () => number
 }
 
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-host.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-host.ts
index 2aa2c3f3c55d..0da5f213f871 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-host.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-host.ts
@@ -278,7 +278,7 @@ export class StructuredAgentSessionHost {
         this.runtimeState.hasPendingStreamedEvents(sessionId),
       requireSession: (sessionId) => this.requireSession(sessionId),
       serialize: (sessionId, task) => this.serialize(sessionId, task),
-      resumeUnheld: (sessionId) => this.holds.resumeUnheld(sessionId),
+      resumes: this.holds,
       now: () => this.now()
     }
   }
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-send-recovery.test.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-send-recovery.test.ts
index e2ee6c7f3227..7517fba0d9a1 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-send-recovery.test.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-send-recovery.test.ts
@@ -128,9 +128,12 @@ describe('a send with no live owner', () => {
     const order: string[] = []
     const recovery = new StructuredAgentSessionSendRecovery({
       getRecord: (sessionId) => store.getRecord(sessionId),
-      hasJournaledSend: () => false,
+      isAttached: () => true,
+      hasLedgerRow: () => false,
+      isResuming: () => false,
       resume: async () => {
         order.push('resume')
+        return { fromFence: 1 }
       }
     })
 
@@ -248,6 +251,58 @@ describe('a send with no live owner', () => {
     expect(acquire).not.toHaveBeenCalled()
     expect(dispatch).toHaveBeenCalledOnce()
     expect(store.getRecord(SESSION)?.lease.claimStatus).toBe('released')
+
+    // Retry rotates the id: a genuinely new send restarts the owner once.
+    await expect(host.send(CALLER, sendParams('sent once'))).resolves.toMatchObject({
+      ok: true,
+      replayed: false
+    })
+    expect(acquire).toHaveBeenCalledOnce()
+    expect(dispatch).toHaveBeenCalledTimes(2)
+  })
+
+  it('restarts nothing for a send the ledger holds but the journal never saw', async () => {
+    const params = sendParams('claimed, then the host died')
+    // The row was claimed and the host went down before the journal write: on replay, admission
+    // reconstructs an unknown-outcome submission and never needs an owner.
+    await store.admitMutationOperation({
+      callerKey: CALLER.callerKey,
+      envelope: params.envelope,
+      hostFingerprint: params.envelope.payloadFingerprint,
+      now: NOW,
+      operationIdScope: 'global'
+    })
+    await store.recordOperationOutcome({
+      callerKey: CALLER.callerKey,
+      operationId: params.envelope.clientOperationId,
+      outcome: { status: 'unknown' }
+    })
+    await host.handleAdapterEvent({
+      type: 'ended',
+      sessionId: SESSION,
+      reason: 'provider exited',
+      cause: 'unexpected-exit',
+      fence: params.envelope.expectedRuntimeFence ?? 0,
+      acquisitionGeneration: 'generation-1'
+    })
+    expect(store.getRecord(SESSION)?.lease.claimStatus).toBe('released')
+    acquire.mockClear()
+
+    const result = await host.send(CALLER, {
+      ...params,
+      envelope: {
+        ...params.envelope,
+        expectedRuntimeFence: store.getRecord(SESSION)?.lease.runtimeFence ?? 0
+      }
+    })
+
+    expect(result).toMatchObject({
+      ok: true,
+      replayed: true,
+      value: { submission: { dispatchState: 'unknown', recovered: true } }
+    })
+    expect(acquire).not.toHaveBeenCalled()
+    expect(dispatch).not.toHaveBeenCalled()
   })
 
   it('rebases a send that arrives after the restart has already claimed the lease', async () => {
@@ -292,6 +347,22 @@ describe('a send with no live owner', () => {
     expect(dispatch).toHaveBeenCalledTimes(3)
   })
 
+  it('shares one restart between a hold and a send that arrive in the same gap', async () => {
+    await loseOwner()
+
+    const [held, sent] = await Promise.allSettled([
+      host.hold(SESSION, 'desktop-chat:1'),
+      host.send(CALLER, sendParams('while the chat opens'))
+    ])
+
+    expect(held).toMatchObject({ status: 'fulfilled' })
+    expect(sent).toMatchObject({ status: 'fulfilled', value: { ok: true } })
+    expect(acquire).toHaveBeenCalledOnce()
+    expect(dispatch).toHaveBeenCalledOnce()
+    expect(host['holds'].isHeld(SESSION)).toBe(true)
+    expect(host['holds'].isReleasePending(SESSION)).toBe(false)
+  })
+
   it('reopens a closed session once for a replay, and never runs the send again', async () => {
     const params = sendParams('sent once')
     await expect(host.send(CALLER, params)).resolves.toMatchObject({ ok: true, replayed: false })
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-send-recovery.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-send-recovery.ts
index 50a7554bf9a7..972e2d3f03fc 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-send-recovery.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-send-recovery.ts
@@ -7,9 +7,13 @@
 // else runs as it is and meets the lease check in admission. A restart that fails for good refuses
 // with a code the client stops on.
 //
-// The ledger outranks the lease here as it does in admission: a resend the journal already answers
-// restarts nothing. Otherwise a child that dies at startup moves the fence, the client resends the
-// same message against the new fence, and each replay spawns another child that dies the same way.
+// The ledger outranks the lease here as it does in admission: a send the ledger already holds a
+// row for restarts nothing, because admission replays or refuses it whoever owns the session now.
+// Otherwise a child that dies at startup moves the fence, the client resends the same message
+// against the new fence, and each replay spawns another child that dies the same way.
+//
+// The restart is the holds' single-flight resume, so a hold and a send arriving in the same gap
+// start one child between them, and a send that joins reads the replaced fence from the resume.
 
 import type { AgentSessionRecord } from '../../../shared/agent-session-record'
 import type {
@@ -17,6 +21,7 @@ import type {
   AgentSessionSendResult,
   AgentSessionWireRefusal
 } from '../../../shared/agent-session-wire'
+import type { StructuredAgentSessionResumed } from './structured-agent-session-holds'
 import { refuseAgentSessionMutation } from './structured-agent-session-mutation-admission'
 import { isResumableStructuredAgentSessionRecord } from './structured-agent-session-resume-eligibility'
 import {
@@ -26,7 +31,7 @@ import {
 
 export const AGENT_SESSION_OWNER_UNRECOVERABLE: AgentSessionWireRefusal = {
   code: 'agent_session_owner_unrecoverable',
-  message: "This chat's agent stopped and could not be restarted. Start a new chat to continue."
+  message: "This chat's agent stopped and could not be restarted. Retry, or start a new chat."
 }
 
 // A resume refused this way met a lease someone else is settling — not proof it cannot resume.
@@ -40,32 +45,29 @@ const TRANSIENT_RESUME_REFUSALS: ReadonlySet<string> = new Set([
 
 type SendParams = Parameters<typeof sendStructuredAgentSessionTurn>[2]
 type SendResult = AgentSessionMutationResult<AgentSessionSendResult>
-type Recovery = 'resumed' | 'transient' | 'unrecoverable'
-/** One restart, shared by every send that arrives while it runs. `fromFence` is the fence it
- *  replaced: a joiner reads the record after the claim, so it cannot recover that itself. */
-type Restart = { fromFence: number; recovery: Promise<Recovery> }
 
 export class StructuredAgentSessionSendRecovery {
-  private readonly inFlight = new Map<string, Restart>()
-
   constructor(
     private readonly deps: {
       getRecord: (sessionId: string) => AgentSessionRecord | null
-      /** Whether the loaded journal already carries this send, so admission replays it. */
-      hasJournaledSend: (sessionId: string, clientMessageId: string) => boolean
-      /** Gives the session a provider child; throws the refusal code when it cannot. */
-      resume: (sessionId: string) => Promise<void>
+      /** Whether admission can answer this session at all: it replays out of the loaded journal. */
+      isAttached: (sessionId: string) => boolean
+      /** Whether the ledger holds this send's row, so admission answers it without an owner. */
+      hasLedgerRow: (clientOperationId: string) => boolean
+      isResuming: (sessionId: string) => boolean
+      /** Gives the session a provider child, or joins the resume already running for it; throws
+       *  the refusal code when it cannot. */
+      resume: (sessionId: string) => Promise<StructuredAgentSessionResumed>
       onError?: (input: { sessionId: string; error: unknown }) => void
     }
   ) {}
 
   async send(params: SendParams, run: (params: SendParams) => Promise<SendResult>) {
     const { sessionId, clientOperationId, expectedRuntimeFence } = params.envelope
-    if (this.deps.hasJournaledSend(sessionId, clientOperationId)) {
+    if (this.deps.isAttached(sessionId) && this.deps.hasLedgerRow(clientOperationId)) {
       return run(params)
     }
-    let restart = this.inFlight.get(sessionId)
-    if (!restart) {
+    if (!this.deps.isResuming(sessionId)) {
       const record = this.deps.getRecord(sessionId)
       // Live, unverifiable, still reserved, or handed off: that lease is not this send's to
       // replace. A send the record refuses anyway must not leave a child behind it.
@@ -76,39 +78,24 @@ export class StructuredAgentSessionSendRecovery {
       ) {
         return run(params)
       }
-      restart = this.start(sessionId, record.lease.runtimeFence)
     }
-    const recovery = await restart.recovery
-    if (recovery === 'unrecoverable') {
+    let resumed: StructuredAgentSessionResumed
+    try {
+      resumed = await this.deps.resume(sessionId)
+    } catch (error) {
+      if (error instanceof Error && TRANSIENT_RESUME_REFUSALS.has(error.message)) {
+        return run(params)
+      }
+      this.deps.onError?.({ sessionId, error })
       return refuseAgentSessionMutation(AGENT_SESSION_OWNER_UNRECOVERABLE)
     }
     const toFence = this.deps.getRecord(sessionId)?.lease.runtimeFence
     // The client was current as of the lost owner; the new owner is the only thing that moved.
-    const rebase =
-      recovery === 'resumed' && expectedRuntimeFence === restart.fromFence && toFence !== undefined
+    const rebase = expectedRuntimeFence === resumed.fromFence && toFence !== undefined
     return run(
       rebase
         ? { ...params, envelope: { ...params.envelope, expectedRuntimeFence: toFence } }
         : params
     )
   }
-
-  private start(sessionId: string, fromFence: number): Restart {
-    const recovery = this.deps
-      .resume(sessionId)
-      .then(
-        (): Recovery => 'resumed',
-        (error: unknown): Recovery => {
-          if (error instanceof Error && TRANSIENT_RESUME_REFUSALS.has(error.message)) {
-            return 'transient'
-          }
-          this.deps.onError?.({ sessionId, error })
-          return 'unrecoverable'
-        }
-      )
-      .finally(() => this.inFlight.delete(sessionId))
-    const restart = { fromFence, recovery }
-    this.inFlight.set(sessionId, restart)
-    return restart
-  }
 }
diff --git a/src/main/native-chat/agent-session-wire/structured-conversation-command-controller.ts b/src/main/native-chat/agent-session-wire/structured-conversation-command-controller.ts
index 519fe80d1747..1347117d662e 100644
--- a/src/main/native-chat/agent-session-wire/structured-conversation-command-controller.ts
+++ b/src/main/native-chat/agent-session-wire/structured-conversation-command-controller.ts
@@ -16,12 +16,13 @@ export class StructuredConversationCommandController {
   ) {}
   private readonly recovery = new StructuredAgentSessionSendRecovery({
     getRecord: (sessionId) => this.context().deps.store.getRecord(sessionId),
-    hasJournaledSend: (sessionId, clientMessageId) =>
-      this.context()
-        .sessions.get(sessionId)
-        ?.journal.submissions()
-        .some((submission) => submission.clientMessageId === clientMessageId) ?? false,
-    resume: (sessionId) => this.context().resumeUnheld(sessionId),
+    isAttached: (sessionId) => this.context().sessions.has(sessionId),
+    hasLedgerRow: (clientOperationId) => {
+      const { deps, now } = this.context()
+      return deps.store.findGlobalOperationRow(clientOperationId, now()) !== undefined
+    },
+    isResuming: (sessionId) => this.context().resumes.isResuming(sessionId),
+    resume: (sessionId) => this.context().resumes.resumeUnheld(sessionId),
     onError: (input) => this.context().deps.onEventSinkError?.(input)
   })
 
diff --git a/src/main/runtime/agent-session-operation-admission.ts b/src/main/runtime/agent-session-operation-admission.ts
index a4d90216651d..f3e2d4486800 100644
--- a/src/main/runtime/agent-session-operation-admission.ts
+++ b/src/main/runtime/agent-session-operation-admission.ts
@@ -5,6 +5,7 @@ import {
   agentSessionOperationKey,
   claimAgentSessionOperation,
   evaluateAgentSessionOperation,
+  findAgentSessionGlobalOperationRow,
   pruneAgentSessionOperationRows,
   settleAgentSessionOperation,
   type AgentSessionOperationClaim,
@@ -61,13 +62,7 @@ export function admitAgentSessionGlobalOperationRow(
   rows: OperationRows,
   args: AgentSessionOperationAdmission
 ): { rows: OperationRows; decision: AgentSessionOperationDecision } {
-  let existing: AgentSessionOperationRow | undefined
-  for (const row of rows.values()) {
-    if (row.expiresAt > args.now && row.operationId === args.operationId) {
-      existing = row
-      break
-    }
-  }
+  const existing = findAgentSessionGlobalOperationRow(rows, args.operationId, args.now)
   if (!existing) {
     return admitAgentSessionOperationRow(rows, args)
   }
diff --git a/src/main/runtime/agent-session-record-store.ts b/src/main/runtime/agent-session-record-store.ts
index 807547af3c30..5b506011d0df 100644
--- a/src/main/runtime/agent-session-record-store.ts
+++ b/src/main/runtime/agent-session-record-store.ts
@@ -3,11 +3,12 @@ import { commitConversationCommandRecord } from './agent-session-conversation-co
 import { setAgentSessionRecordConversationName } from './agent-session-record-conversation-name'
 /** Durable single-writer session records and their operation ledger. */
 
-import type {
-  AgentSessionOperationClaim,
-  AgentSessionOperationDecision,
-  AgentSessionOperationOutcome,
-  AgentSessionOperationRow
+import {
+  findAgentSessionGlobalOperationRow,
+  type AgentSessionOperationClaim,
+  type AgentSessionOperationDecision,
+  type AgentSessionOperationOutcome,
+  type AgentSessionOperationRow
 } from '../../shared/agent-session-operation-ledger'
 import {
   admitAgentSessionGlobalOperationInto,
@@ -163,6 +164,13 @@ export class AgentSessionRecordStore {
 
   listOperationRows = (): AgentSessionOperationRow[] => [...this.state.operations.values()]
 
+  /** The row a globally scoped id (a send) already holds, under whichever caller admitted it. */
+  findGlobalOperationRow = (
+    operationId: string,
+    now: number
+  ): AgentSessionOperationRow | undefined =>
+    findAgentSessionGlobalOperationRow(this.state.operations, operationId, now)
+
   isClaimKeyVerifiable = (keyId: string, now: number): boolean =>
     isAgentSessionClaimKeyVerifiable(this.state, keyId, now)
 
diff --git a/src/renderer/src/components/native-chat/use-structured-agent-session-outbox.test.tsx b/src/renderer/src/components/native-chat/use-structured-agent-session-outbox.test.tsx
index d0542dca95f3..9b67ee7f69fb 100644
--- a/src/renderer/src/components/native-chat/use-structured-agent-session-outbox.test.tsx
+++ b/src/renderer/src/components/native-chat/use-structured-agent-session-outbox.test.tsx
@@ -531,7 +531,7 @@ describe('useStructuredAgentSessionOutbox', () => {
 
   it('stops on a host that could not restart the agent and shows its message', async () => {
     const message =
-      "This chat's agent stopped and could not be restarted. Start a new chat to continue."
+      "This chat's agent stopped and could not be restarted. Retry, or start a new chat."
     mocks.call.mockResolvedValue({
       ok: false,
       refusal: { code: 'agent_session_owner_unrecoverable', message }
diff --git a/src/shared/agent-session-operation-ledger.ts b/src/shared/agent-session-operation-ledger.ts
index e3d39fdee341..765f8e511423 100644
--- a/src/shared/agent-session-operation-ledger.ts
+++ b/src/shared/agent-session-operation-ledger.ts
@@ -181,6 +181,20 @@ export function agentSessionOperationExpiry(
   )
 }
 
+/** The unexpired row a globally scoped id already holds, under whichever caller admitted it. */
+export function findAgentSessionGlobalOperationRow(
+  rows: ReadonlyMap<string, AgentSessionOperationRow>,
+  operationId: string,
+  now: number
+): AgentSessionOperationRow | undefined {
+  for (const row of rows.values()) {
+    if (row.expiresAt > now && row.operationId === operationId) {
+      return row
+    }
+  }
+  return undefined
+}
+
 export function pruneAgentSessionOperationRows(
   rows: ReadonlyMap<string, AgentSessionOperationRow>,
   now: number

From 6c0393aa54792a862b562c9480cf1e4facdeaf3b Mon Sep 17 00:00:00 2001
From: Brennan Benson <79079362+brennanb2025@users.noreply.github.com>
Date: Wed, 23 Sep 2026 00:20:41 -0700
Subject: [PATCH 13/67] fix(native-chat): a failed create answers one refusal
 shape, stamped once at the boundary

A create whose Claude process was seen to exit answered twice in two shapes:
the first call threw a generic runtime error, and only the replay of the same
operation carried the `ownerVerdict: 'exited'` refusal that lets a client
retry under a new operation. Three sites stamped the verdict and the store
failure path stamped nothing.

The first-hand root exit is now returned as the refusal on the first call,
with the provider's own diagnostic as its message. The verdict is stamped in
one place, at the boundary of the attach, from the durable row the operation
settled to, so every refusal shape answers the same fact and no site can
forget it. The per-site stamps are gone.
---
 .../structured-agent-session-attach-flow.ts   |  19 +-
 ...ured-agent-session-attach-orchestration.ts | 199 ++++++++++--------
 ...ession-failed-create-owner-verdict.test.ts |  22 ++
 ...red-agent-session-failed-create-refusal.ts |  33 ++-
 .../runtime/agent-session-record-store.ts     |   4 +
 ...-agent-session-launch-exited-owner.test.ts |  18 +-
 6 files changed, 194 insertions(+), 101 deletions(-)

diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-attach-flow.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-attach-flow.ts
index bb297a5a6c33..be4641606d24 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-attach-flow.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-attach-flow.ts
@@ -1,6 +1,5 @@
 import { settlePostAcquisitionAttachFailure } from './structured-agent-session-attach-failure'
 import { rewindRefusal } from './structured-rewind-refusal'
-import { failedCreateRefusal } from './structured-agent-session-failed-create-refusal'
 import {
   AgentSessionRewindRefusal,
   AgentSessionAcquisitionExitUnprovenError,
@@ -151,7 +150,7 @@ export async function performAttach(
         reconstruct: () => null
       })
       if (replay.decision === 'refuse') {
-        return failedCreateRefusal(replay.refusal, reserved.operationRow.outcome.status, record)
+        return { ok: false, refusal: replay.refusal }
       }
     }
     // Sample provider history before a new child is acquired. Once acquireOwner
@@ -173,7 +172,6 @@ export async function performAttach(
       acquiredOwner = true
     }
   } catch (error) {
-    let settled: AgentSessionRecord | null = null
     const spawnToken = reservedRecord?.lease.reservedSpawnToken
     if (reservedRecord && spawnToken && !unsupportedReservationSettlementAttempted) {
       // Settle processless proof and failed operation atomically.
@@ -203,7 +201,7 @@ export async function performAttach(
                 message: error instanceof Error ? error.message : String(error)
               }
       try {
-        settled = await store.settleFailedAcquisition({
+        await store.settleFailedAcquisition({
           sessionId,
           fence: reservedRecord.lease.runtimeFence,
           spawnToken,
@@ -221,11 +219,18 @@ export async function performAttach(
       }
     }
     if (error instanceof AgentSessionRewindRefusal) {
-      return failedCreateRefusal(rewindRefusal(error.rewindReason).refusal, 'failed', settled)
+      return rewindRefusal(error.rewindReason)
     }
     if (error instanceof AgentSessionAcquisitionRefusal) {
-      const refusal = { code: error.code, message: error.message }
-      return failedCreateRefusal(refusal, 'failed', settled)
+      return { ok: false, refusal: { code: error.code, message: error.message } }
+    }
+    // A first-hand root exit is a settled fact, answered once as a refusal rather than thrown
+    // now and refused only on replay; its message is the provider's own diagnostic.
+    if (error instanceof AgentSessionAcquisitionRootExitObservedError) {
+      return {
+        ok: false,
+        refusal: { code: 'agent_session_operation_invalid', message: error.message }
+      }
     }
     return {
       ok: false,
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-attach-orchestration.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-attach-orchestration.ts
index dd7ecc8b1fcd..df5aa97816bc 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-attach-orchestration.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-attach-orchestration.ts
@@ -16,6 +16,7 @@ import type {
 } from '../../../shared/agent-session-wire'
 import type { AgentSessionAttachParams } from './structured-agent-session-attach'
 import { performAttach } from './structured-agent-session-attach-flow'
+import { stampFailedCreateOwnerVerdict } from './structured-agent-session-failed-create-refusal'
 import {
   pinnedAgentSessionLaunchArgs,
   pinnedAgentSessionLaunchEnv
@@ -89,109 +90,125 @@ export function attachStructuredAgentSession(
           context.runtimeState.discardEventSink(sessionId)
         }
       }
-      const attached = await performAttach({
-        rewind,
-        store: context.deps.store,
-        adapter: context.deps.adapter,
-        journalRoot: context.deps.journalRoot,
-        eventSink: eventSink.sink,
-        onAcquiring: async () => {
-          const barrier = await eventSink.drained()
-          if (!barrier.ok) {
-            throw barrier.error
-          }
-          eventSink.unbind()
-        },
-        authority: {
-          spawnToken: () => context.deps.mintSpawnToken?.() ?? randomUUID(),
-          claimKeyId: context.deps.claimKeyId,
-          handoffOperationId: params.envelope.clientOperationId,
-          probe,
-          ...(await pinnedAgentSessionLaunchArgs(context.deps.resolveLaunchArgs, params)),
-          ...(await pinnedAgentSessionLaunchEnv(context.deps.resolveLaunchEnv, params))
-        },
+      const attached = stampFailedCreateOwnerVerdict(
+        context.deps.store,
         callerKey,
-        params,
-        now: () => context.now(),
-        recordPhase,
-        // Site 9: this closes the PRIOR map entry it drops, never the provisional
-        // journal — it has no reference to that one. `onAttached` owns that.
-        onAttachFailed: async () => {
-          await forgetStructuredAgentSession(context, sessionId)
-          eventSink.close()
-          context.runtimeState.discardEventSink(sessionId)
-        },
-        onAttached: async (attached, acquisitionGeneration, acquiredOwner, providerChildPhase) => {
-          const fence = context.deps.store.getRecord(sessionId)?.lease.runtimeFence ?? 0
-          const previous = context.sessions.get(sessionId)
-          const previousFence = previous?.fence
-          // Site 8: the provisional journal has no owner until the map takes it,
-          // and the barrier below throws by design.
-          try {
-            if (acquiredOwner) {
-              // Before the drain: the buffered events are the new child's, never a stale row's.
-              await settleStaleSessionStateOnAcquire({
-                journal: attached.journal,
-                sessionId,
-                fence,
-                acquisitionGeneration
-              })
+        params.envelope,
+        await performAttach({
+          rewind,
+          store: context.deps.store,
+          adapter: context.deps.adapter,
+          journalRoot: context.deps.journalRoot,
+          eventSink: eventSink.sink,
+          onAcquiring: async () => {
+            const barrier = await eventSink.drained()
+            if (!barrier.ok) {
+              throw barrier.error
             }
-            await bindAndDrain(eventSink, attached.journal, fence, (activity) =>
-              context.subscribers.publish(sessionId, attached.journal, activity)
-            )
-          } catch (error) {
-            await agentSessionJournalCloseRetries.closeOrRetain(attached.journal)
-            throw error
-          }
-          // Site 10: a `set` over a live entry would orphan its handle — and a
-          // close that REJECTED did not release it. The replacement is therefore
-          // ABORTED rather than completed over a handle nothing can reach again:
-          // `previous` stays indexed, so teardown still owns it and can retry.
-          if (previous && previous.journal !== attached.journal) {
+            eventSink.unbind()
+          },
+          authority: {
+            spawnToken: () => context.deps.mintSpawnToken?.() ?? randomUUID(),
+            claimKeyId: context.deps.claimKeyId,
+            handoffOperationId: params.envelope.clientOperationId,
+            probe,
+            ...(await pinnedAgentSessionLaunchArgs(context.deps.resolveLaunchArgs, params)),
+            ...(await pinnedAgentSessionLaunchEnv(context.deps.resolveLaunchEnv, params))
+          },
+          callerKey,
+          params,
+          now: () => context.now(),
+          recordPhase,
+          // Site 9: this closes the PRIOR map entry it drops, never the provisional
+          // journal — it has no reference to that one. `onAttached` owns that.
+          onAttachFailed: async () => {
+            await forgetStructuredAgentSession(context, sessionId)
+            eventSink.close()
+            context.runtimeState.discardEventSink(sessionId)
+          },
+          onAttached: async (
+            attached,
+            acquisitionGeneration,
+            acquiredOwner,
+            providerChildPhase
+          ) => {
+            const fence = context.deps.store.getRecord(sessionId)?.lease.runtimeFence ?? 0
+            const previous = context.sessions.get(sessionId)
+            const previousFence = previous?.fence
+            // Site 8: the provisional journal has no owner until the map takes it,
+            // and the barrier below throws by design.
             try {
-              await previous.journal.close()
+              if (acquiredOwner) {
+                // Before the drain: the buffered events are the new child's, never a stale row's.
+                await settleStaleSessionStateOnAcquire({
+                  journal: attached.journal,
+                  sessionId,
+                  fence,
+                  acquisitionGeneration
+                })
+              }
+              await bindAndDrain(eventSink, attached.journal, fence, (activity) =>
+                context.subscribers.publish(sessionId, attached.journal, activity)
+              )
             } catch (error) {
               await agentSessionJournalCloseRetries.closeOrRetain(attached.journal)
               throw error
             }
-          }
-          context.sessions.set(sessionId, {
-            journal: attached.journal,
-            params,
-            fence,
-            hasProviderChild: true,
-            // A re-attach to a live child keeps what that child already proved.
-            providerChildPhase: acquiredOwner
-              ? providerChildPhase
-              : (previous?.providerChildPhase ?? 'ready'),
-            acquisitionGeneration: acquisitionGeneration ?? previous?.acquisitionGeneration ?? null
-          })
-          if (!rewind) {
-            await recoverStructuredRewind(
+            // Site 10: a `set` over a live entry would orphan its handle — and a
+            // close that REJECTED did not release it. The replacement is therefore
+            // ABORTED rather than completed over a handle nothing can reach again:
+            // `previous` stays indexed, so teardown still owns it and can retry.
+            if (previous && previous.journal !== attached.journal) {
+              try {
+                await previous.journal.close()
+              } catch (error) {
+                await agentSessionJournalCloseRetries.closeOrRetain(attached.journal)
+                throw error
+              }
+            }
+            context.sessions.set(sessionId, {
+              journal: attached.journal,
+              params,
+              fence,
+              hasProviderChild: true,
+              // A re-attach to a live child keeps what that child already proved.
+              providerChildPhase: acquiredOwner
+                ? providerChildPhase
+                : (previous?.providerChildPhase ?? 'ready'),
+              acquisitionGeneration:
+                acquisitionGeneration ?? previous?.acquisitionGeneration ?? null
+            })
+            if (!rewind) {
+              await recoverStructuredRewind(
+                context.deps.store,
+                sessionId,
+                attached.journal,
+                fence,
+                context.deps.adapter,
+                context.now
+              )
+            }
+            await recoverInterruptedCompaction(
               context.deps.store,
               sessionId,
               attached.journal,
-              fence,
-              context.deps.adapter,
-              context.now
+              fence
             )
+            if (attached.recovery) {
+              context.subscribers.reset(sessionId, attached.journal, attached.recovery.reset, fence)
+            } else if (previousFence !== undefined && previousFence !== fence) {
+              context.subscribers.snapshot(sessionId, attached.journal, fence)
+            } else {
+              context.subscribers.publish(sessionId, attached.journal)
+            }
           }
-          await recoverInterruptedCompaction(context.deps.store, sessionId, attached.journal, fence)
-          if (attached.recovery) {
-            context.subscribers.reset(sessionId, attached.journal, attached.recovery.reset, fence)
-          } else if (previousFence !== undefined && previousFence !== fence) {
-            context.subscribers.snapshot(sessionId, attached.journal, fence)
-          } else {
-            context.subscribers.publish(sessionId, attached.journal)
-          }
-        }
-      }).catch((error: unknown) => {
-        // A throw is a failed attach too, and its dead child may already have queued into the
-        // unbound sink; left cached, that queue wedges the next attach's drain and shutdown.
-        discardUnattachedSink()
-        throw error
-      })
+        }).catch((error: unknown) => {
+          // A throw is a failed attach too, and its dead child may already have queued into the
+          // unbound sink; left cached, that queue wedges the next attach's drain and shutdown.
+          discardUnattachedSink()
+          throw error
+        })
+      )
       if (!attached.ok) {
         discardUnattachedSink()
       }
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-failed-create-owner-verdict.test.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-failed-create-owner-verdict.test.ts
index 013f08527be6..5ea4e12a754d 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-failed-create-owner-verdict.test.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-failed-create-owner-verdict.test.ts
@@ -9,6 +9,7 @@ import { AgentSessionRecordStore } from '../../runtime/agent-session-record-stor
 import {
   AgentSessionAcquisitionExitUnprovenError,
   AgentSessionAcquisitionRefusal,
+  AgentSessionAcquisitionRootExitObservedError,
   type StructuredAgentSessionAdapter
 } from './structured-agent-session-adapter'
 import { StructuredAgentSessionHost } from './structured-agent-session-host'
@@ -87,6 +88,27 @@ describe('failed create owner verdict', () => {
     expect(store.getRecord(SESSION)?.lease.claimStatus).toBe('live')
   })
 
+  it('answers a first-hand root exit as exited on the first call, in the shape its replay takes', async () => {
+    acquire.mockRejectedValueOnce(
+      new AgentSessionAcquisitionRootExitObservedError(new Error(EXIT_REASON))
+    )
+    const first = hostTestAttachParams(null)
+    const refusal = {
+      code: 'agent_session_operation_invalid',
+      message: EXIT_REASON,
+      ownerVerdict: 'exited'
+    }
+
+    await expect(host.attach(CALLER, first)).resolves.toEqual({ ok: false, refusal })
+    await expect(host.attach(CALLER, first)).resolves.toEqual({ ok: false, refusal })
+    expect(acquire).toHaveBeenCalledOnce()
+
+    await expect(host.attach(CALLER, hostTestAttachParams(null))).resolves.toMatchObject({
+      ok: true
+    })
+    expect(acquire).toHaveBeenCalledTimes(2)
+  })
+
   it('answers an acquisition refusal with its verdict directly', async () => {
     acquire.mockRejectedValueOnce(new AgentSessionAcquisitionRefusal('not signed in'))
 
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-failed-create-refusal.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-failed-create-refusal.ts
index 7302d6ded8df..b843bb6611b9 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-failed-create-refusal.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-failed-create-refusal.ts
@@ -1,5 +1,12 @@
-import type { AgentSessionWireRefusal } from '../../../shared/agent-session-wire'
-import type { AgentSessionOperationOutcome } from '../../../shared/agent-session-operation-ledger'
+import type {
+  AgentSessionAttachResult,
+  AgentSessionMutationResult,
+  AgentSessionWireRefusal
+} from '../../../shared/agent-session-wire'
+import type {
+  AgentSessionOperationOutcome,
+  AgentSessionOperationRow
+} from '../../../shared/agent-session-operation-ledger'
 import { agentSessionLeaseOwnerVerdict } from '../../../shared/agent-session-lease-adjudication'
 import type { AgentSessionRecord } from '../../../shared/agent-session-record'
 
@@ -16,3 +23,25 @@ export function failedCreateRefusal(
       }
     : { ok: false, refusal }
 }
+
+/** The one place a create refusal learns its verdict: from the durable row this operation
+ *  settled to, so every refusal shape answers the same fact and no site can forget the stamp. */
+export function stampFailedCreateOwnerVerdict(
+  store: {
+    getOperationRow: (callerKey: string, operationId: string) => AgentSessionOperationRow | null
+    getRecord: (sessionId: string) => AgentSessionRecord | null
+  },
+  callerKey: string,
+  envelope: { sessionId: string; clientOperationId: string },
+  result: AgentSessionMutationResult<AgentSessionAttachResult>
+): AgentSessionMutationResult<AgentSessionAttachResult> {
+  if (result.ok) {
+    return result
+  }
+  const row = store.getOperationRow(callerKey, envelope.clientOperationId)
+  return failedCreateRefusal(
+    result.refusal,
+    row?.outcome.status ?? 'pending',
+    store.getRecord(envelope.sessionId)
+  )
+}
diff --git a/src/main/runtime/agent-session-record-store.ts b/src/main/runtime/agent-session-record-store.ts
index 807547af3c30..edb447b9dd2e 100644
--- a/src/main/runtime/agent-session-record-store.ts
+++ b/src/main/runtime/agent-session-record-store.ts
@@ -9,6 +9,7 @@ import type {
   AgentSessionOperationOutcome,
   AgentSessionOperationRow
 } from '../../shared/agent-session-operation-ledger'
+import { agentSessionOperationKey } from '../../shared/agent-session-operation-ledger'
 import {
   admitAgentSessionGlobalOperationInto,
   admitAgentSessionMutationOperation,
@@ -163,6 +164,9 @@ export class AgentSessionRecordStore {
 
   listOperationRows = (): AgentSessionOperationRow[] => [...this.state.operations.values()]
 
+  getOperationRow = (callerKey: string, operationId: string): AgentSessionOperationRow | null =>
+    this.state.operations.get(agentSessionOperationKey(callerKey, operationId)) ?? null
+
   isClaimKeyVerifiable = (keyId: string, now: number): boolean =>
     isAgentSessionClaimKeyVerifiable(this.state, keyId, now)
 
diff --git a/src/renderer/src/lib/structured-agent-session-launch-exited-owner.test.ts b/src/renderer/src/lib/structured-agent-session-launch-exited-owner.test.ts
index 0b0af0aae1e4..1662e4c04300 100644
--- a/src/renderer/src/lib/structured-agent-session-launch-exited-owner.test.ts
+++ b/src/renderer/src/lib/structured-agent-session-launch-exited-owner.test.ts
@@ -59,6 +59,8 @@ const EXIT_REASON = 'claude stream-json exited (code 1): stderr tail'
 
 /** The verdict the host puts on the failed operation's replay; undefined models an older host. */
 let replayVerdict: AgentSessionOwnerVerdict | undefined
+/** A host that answers the proven exit on the first call, not only on replay. */
+let refuseFirstCall = false
 let failedOperation: string | null = null
 let publishedSessionId: string | null = null
 const createdOperations: string[] = []
@@ -72,7 +74,7 @@ function hostCreate(envelope: AgentSessionMutationEnvelope): unknown {
     publishedSessionId = envelope.sessionId
     return { ok: true, replayed: false, value: { sessionId: envelope.sessionId, fence: 3 } }
   }
-  if (createdOperations.length === 1) {
+  if (createdOperations.length === 1 && !refuseFirstCall) {
     throw new Error(EXIT_REASON)
   }
   const refusal: AgentSessionWireRefusal = {
@@ -102,6 +104,7 @@ beforeEach(() => {
   resetStructuredAgentLaunchPersistenceForTests()
   resetStructuredAgentLaunchRegistryForTests()
   replayVerdict = 'exited'
+  refuseFirstCall = false
   failedOperation = null
   publishedSessionId = null
   createdOperations.length = 0
@@ -139,6 +142,19 @@ describe('structured launch after a host-failed create', () => {
     expect(getStructuredAgentSessionLaunchLifecycle(WORKTREE, sessionId)).toBeNull()
   })
 
+  it('fails on the first answer when the host already refuses with the proven exit', async () => {
+    refuseFirstCall = true
+    const sessionId = launch()
+    await settle(sessionId)
+    expect(getStructuredAgentSessionLaunchLifecycle(WORKTREE, sessionId)).toBe('failed')
+    expect(getStructuredAgentSessionLaunchFailureReason(WORKTREE, sessionId)).toBe(EXIT_REASON)
+    expect(createdOperations).toEqual([failedOperation])
+    expect(retryStructuredAgentSessionLaunch(WORKTREE, sessionId)).toBe(true)
+    await settle(sessionId)
+    expect(createdOperations.at(-1)).not.toBe(failedOperation)
+    expect(publishedSessionId).toBe(sessionId)
+  })
+
   it.each([
     ['the host could not prove the process gone', 'unverifiable'],
     ['the host predates the verdict', undefined]

From 39234e44bf7881fd7a5c3adfeca907340c93f153 Mon Sep 17 00:00:00 2001
From: Brennan Benson <79079362+brennanb2025@users.noreply.github.com>
Date: Wed, 23 Sep 2026 00:26:48 -0700
Subject: [PATCH 14/67] fix(native-chat): a send into a session whose child
 ended restarts it before admission

A session that published and then lost its Claude child before startup (not
signed in, for one) keeps a released lease and a chat the user can still type
into. The send was refused as ownership-unknown, the outbox parked it as
pending admission, and nothing ever restarted the child: the message sat
there until the user closed and reopened the tab.

A send reaching a session with no provider child now runs the same resume a
surface's first hold runs, before the write is admitted. The resume reserves
a new fence, so that send is answered stale with the published fence and the
client's outbox re-drives under it, as after any fence change. A resume that
fails is not this send's answer; admission reports the lease as it stands.
---
 .../structured-agent-session-holds.ts         |   6 +
 ...structured-agent-session-host-mutations.ts |  28 +++-
 .../structured-agent-session-host.ts          |   1 +
 ...nt-session-send-after-failed-start.test.ts | 138 ++++++++++++++++++
 4 files changed, 172 insertions(+), 1 deletion(-)
 create mode 100644 src/main/native-chat/agent-session-wire/structured-agent-session-send-after-failed-start.test.ts

diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-holds.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-holds.ts
index 73880022646b..038e79137b63 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-holds.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-holds.ts
@@ -49,6 +49,12 @@ export class StructuredAgentSessionHolds {
     this.clock = new StructuredAgentSessionReleaseClock(clockDeps)
   }
 
+  /** A write reaching a session with no child is the user asking for it back: the same resume a
+   *  first hold runs, without taking a holder, since the surface that sent already holds one. */
+  resumeForWrite(sessionId: string): Promise<void> {
+    return this.deps.hasProviderChild(sessionId) ? Promise.resolve() : this.deps.resume(sessionId)
+  }
+
   async hold(
     sessionId: string,
     holderId: string,
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-host-mutations.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-host-mutations.ts
index 2c8bd5fbabcc..537d9253b39e 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-host-mutations.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-host-mutations.ts
@@ -1,4 +1,5 @@
 import { rewindRefusal } from './structured-rewind-refusal'
+import { isResumableStructuredAgentSessionRecord } from './structured-agent-session-resume-eligibility'
 // Everything a client can ask an ALREADY-ATTACHED session to do: send a turn, cancel one, answer a
 // prompt, change an option, read the options back.
 //
@@ -41,6 +42,8 @@ export type StructuredAgentSessionMutationContext = {
   hasPendingStreamedEvents?: (sessionId: string) => boolean
   requireSession: (sessionId: string) => StructuredAgentSessionHostSession
   serialize: <T>(sessionId: string, task: () => Promise<T>) => Promise<T>
+  /** Gives a childless session its provider child back before a write is admitted. */
+  resumeProviderChild?: (sessionId: string) => Promise<void>
   now: () => number
 }
 
@@ -66,7 +69,29 @@ function mutate<TValue>(
   )
 }
 
-export function sendStructuredAgentSessionTurn(
+/** A send into a session whose child ended (a start that failed, an exit at idle) restarts it
+ *  the way a surface's first hold does, so the message is not parked forever behind a released
+ *  lease. The resume's own failure is not this send's answer: admission reports the lease as it
+ *  stands, and the client re-drives under the fence the resume published. */
+async function resumeBeforeSend(
+  context: StructuredAgentSessionMutationContext,
+  sessionId: string
+): Promise<void> {
+  const session = context.sessions.get(sessionId)
+  const record = context.deps.store.getRecord(sessionId)
+  if (
+    !context.resumeProviderChild ||
+    !session ||
+    session.hasProviderChild ||
+    !record ||
+    !isResumableStructuredAgentSessionRecord(record)
+  ) {
+    return
+  }
+  await context.resumeProviderChild(sessionId).catch(() => undefined)
+}
+
+export async function sendStructuredAgentSessionTurn(
   context: StructuredAgentSessionMutationContext,
   caller: StructuredAgentSessionCaller,
   params: {
@@ -77,6 +102,7 @@ export function sendStructuredAgentSessionTurn(
   }
 ): Promise<AgentSessionMutationResult<AgentSessionSendResult>> {
   const plan = sendPlan(params)
+  await resumeBeforeSend(context, params.envelope.sessionId)
   return mutate(context, caller, params.envelope, {
     ...plan,
     run: (ctx) => {
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-host.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-host.ts
index 2a1ebb2ac499..409c116896d4 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-host.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-host.ts
@@ -277,6 +277,7 @@ export class StructuredAgentSessionHost {
         this.runtimeState.hasPendingStreamedEvents(sessionId),
       requireSession: (sessionId) => this.requireSession(sessionId),
       serialize: (sessionId, task) => this.serialize(sessionId, task),
+      resumeProviderChild: (sessionId) => this.holds.resumeForWrite(sessionId),
       now: () => this.now()
     }
   }
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-send-after-failed-start.test.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-send-after-failed-start.test.ts
new file mode 100644
index 000000000000..ec5837d3c043
--- /dev/null
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-send-after-failed-start.test.ts
@@ -0,0 +1,138 @@
+// A session that published and then lost its child before startup (not signed in, say) keeps a
+// released lease and a chat the user can still type into. The send is the user asking for the
+// child back: the host restarts it before admitting the write, instead of parking the message
+// behind a lease nothing would ever re-acquire.
+
+import { mkdtemp, rm } from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { afterEach, beforeEach, describe, expect, it, vi, type Mock } from 'vitest'
+import { computeAgentSessionPayloadFingerprint } from '../../../shared/agent-session-mutation-envelope'
+import type { AgentSessionMutationEnvelope } from '../../../shared/agent-session-wire'
+import { AgentSessionRecordStore } from '../../runtime/agent-session-record-store'
+import type { StructuredAgentSessionAdapter } from './structured-agent-session-adapter'
+import { StructuredAgentSessionHost } from './structured-agent-session-host'
+import {
+  HOST_TEST_NOW as NOW,
+  HOST_TEST_SESSION as SESSION,
+  HOST_TEST_THREAD as THREAD,
+  hostTestAttachParams,
+  hostTestMessage,
+  hostTestOperationId,
+  resetHostTestOperationIds
+} from './structured-agent-session-host-test-data'
+
+const CALLER = { callerKey: 'client-1' }
+const EXIT_REASON = 'Claude Code is not signed in. Sign in with the Claude CLI'
+
+let root: string
+let store: AgentSessionRecordStore
+let host: StructuredAgentSessionHost
+let acquire: Mock<StructuredAgentSessionAdapter['acquire']>
+let generation = 0
+
+function sendEnvelope(
+  fence: number,
+  body: ReturnType<typeof hostTestMessage>
+): AgentSessionMutationEnvelope {
+  return {
+    sessionId: SESSION,
+    clientOperationId: hostTestOperationId(),
+    expectedRuntimeFence: fence,
+    payloadFingerprint: computeAgentSessionPayloadFingerprint({
+      method: 'agentSession.send',
+      sessionId: SESSION,
+      fields: { body }
+    })
+  }
+}
+
+beforeEach(async () => {
+  root = await mkdtemp(join(tmpdir(), 'orca-send-after-failed-start-'))
+  resetHostTestOperationIds()
+  generation = 0
+  acquire = vi.fn(async ({ fence, spawnToken }) => ({
+    process: { hostId: 'local', pid: 4242, processStartTimeMs: 1_700_000_000_000, spawnToken },
+    link: {
+      linkId: `link-${fence}`,
+      handle: { provider: 'codex', threadId: THREAD },
+      // A re-acquire resumes the thread the first child minted, as a real adapter does.
+      origin: generation === 0 ? ('created' as const) : ('resumed' as const),
+      mintedAtFence: fence,
+      observedAt: NOW
+    },
+    acquisitionGeneration: `generation-${++generation}`,
+    providerChildPhase: 'starting' as const
+  }))
+  store = await AgentSessionRecordStore.open({ directory: join(root, 'store'), hostId: 'local' })
+  host = new StructuredAgentSessionHost({
+    store,
+    adapter: {
+      acquire,
+      releaseAcquisition: vi.fn(async () => true),
+      dispatch: vi.fn(async () => ({ state: 'admitted' as const })),
+      cancelTurn: vi.fn(async () => ({ cancelled: true })),
+      answerPrompt: vi.fn(async () => undefined),
+      setOption: vi.fn(async () => undefined)
+    },
+    journalRoot: root,
+    claimKeyId: 'key-1',
+    mintSpawnToken: () => `spawn-${generation + 1}`,
+    now: () => NOW
+  })
+})
+
+afterEach(async () => {
+  await host.flushAllStreamedEvents()
+  await rm(root, { recursive: true, force: true })
+})
+
+describe('a send into a published session whose child ended before startup', () => {
+  it('restarts the child and admits the message once the resume has published', async () => {
+    await expect(host.attach(CALLER, hostTestAttachParams(null))).resolves.toMatchObject({
+      ok: true
+    })
+    const startedFence = store.getRecord(SESSION)?.lease.runtimeFence ?? 0
+    await host.handleAdapterEvent({
+      type: 'ended',
+      sessionId: SESSION,
+      reason: EXIT_REASON,
+      cause: 'unexpected-exit',
+      fence: startedFence,
+      acquisitionGeneration: 'generation-1',
+      startupUnproven: true
+    })
+    // The failed start released the lease and no resume ran on its own.
+    expect(store.getRecord(SESSION)?.lease.claimStatus).toBe('released')
+    expect(acquire).toHaveBeenCalledOnce()
+    const releasedFence = store.getRecord(SESSION)?.lease.runtimeFence ?? 0
+
+    const body = hostTestMessage('hello again')
+    const first = await host.send(CALLER, { envelope: sendEnvelope(releasedFence, body), body })
+    expect(acquire).toHaveBeenCalledTimes(2)
+    expect(store.getRecord(SESSION)?.lease.claimStatus).toBe('live')
+    // The resume reserved a new fence, so this send is answered stale with the fence it published;
+    // the client's outbox re-drives under it, exactly as after any other fence change.
+    expect(first, JSON.stringify(first)).toMatchObject({
+      ok: false,
+      refusal: { code: 'agent_session_checkpoint_stale', currentFence: expect.any(Number) }
+    })
+    const current = first.ok ? 0 : (first.refusal.currentFence ?? 0)
+    expect(current).toBeGreaterThan(releasedFence)
+
+    await expect(
+      host.send(CALLER, { envelope: sendEnvelope(current, body), body })
+    ).resolves.toMatchObject({ ok: true, value: { submission: { dispatchState: 'pending' } } })
+    expect(acquire).toHaveBeenCalledTimes(2)
+  })
+
+  it('leaves a send against a live child alone', async () => {
+    await host.attach(CALLER, hostTestAttachParams(null))
+    const fence = store.getRecord(SESSION)?.lease.runtimeFence ?? 0
+    const body = hostTestMessage('hello')
+    await expect(
+      host.send(CALLER, { envelope: sendEnvelope(fence, body), body })
+    ).resolves.toMatchObject({ ok: true })
+    expect(acquire).toHaveBeenCalledOnce()
+  })
+})

From 3d1e4744b7e234386d3835395630116b1b3ddb5d Mon Sep 17 00:00:00 2001
From: Brennan Benson <79079362+brennanb2025@users.noreply.github.com>
Date: Wed, 23 Sep 2026 00:34:44 -0700
Subject: [PATCH 15/67] chore: restore pnpm-lock.yaml to origin/main (local
 pnpm rewrote it)

---
 pnpm-lock.yaml | 19 -------------------
 1 file changed, 19 deletions(-)

diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index fc1b054a5a01..7ba1cc7f4f5e 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -6,9 +6,6 @@ importers:
   .:
     configDependencies: {}
     packageManagerDependencies:
-      '@pnpm/exe':
-        specifier: 12.0.0
-        version: 12.0.0
       pnpm:
         specifier: 12.0.0
         version: 12.0.0
@@ -59,11 +56,6 @@ packages:
     cpu: [x64]
     os: [win32]
 
-  '@pnpm/exe@12.0.0':
-    resolution: {integrity: sha512-405vw2qYPPghNxoPRt2cvkGtGNU5gnInDcIe5TztQxe73yUZLqFJN/jCJFGs1xbVaIWDXEVuQ71P8npFZeatZQ==}
-    engines: {node: '>=18.*'}
-    hasBin: true
-
   pnpm@12.0.0:
     resolution: {integrity: sha512-ni49w5EZlYaNyUuBdcIXwn6VQI+gO0oidJd48rNPdzt3zdOznt6BcbIvzVO+ajU0Lp+smUimjvWN9kiM6Jp+Zw==}
     engines: {node: '>=18.*'}
@@ -95,17 +87,6 @@ snapshots:
   '@pnpm/exe.win32-x64@12.0.0':
     optional: true
 
-  '@pnpm/exe@12.0.0':
-    optionalDependencies:
-      '@pnpm/exe.darwin-arm64': 12.0.0
-      '@pnpm/exe.darwin-x64': 12.0.0
-      '@pnpm/exe.linux-arm64': 12.0.0
-      '@pnpm/exe.linux-arm64-musl': 12.0.0
-      '@pnpm/exe.linux-x64': 12.0.0
-      '@pnpm/exe.linux-x64-musl': 12.0.0
-      '@pnpm/exe.win32-arm64': 12.0.0
-      '@pnpm/exe.win32-x64': 12.0.0
-
   pnpm@12.0.0:
     optionalDependencies:
       '@pnpm/exe.darwin-arm64': 12.0.0

From 4fd2c30143a0067b0a8de882af9886ec5a2658c8 Mon Sep 17 00:00:00 2001
From: Brennan Benson <79079362+brennanb2025@users.noreply.github.com>
Date: Wed, 23 Sep 2026 00:37:24 -0700
Subject: [PATCH 16/67] test(native-chat): pin the pre-handover exit as a
 failed acquire; stub the status feed in the delivery test

An exit the adapter observes before acquire returns now fails the acquire
with the CLI's diagnostic instead of handing over a dead child; the
published-then-ended path stays pinned by the slow-init startup case. The
delivery test renders the pane, which now activates the host status feed.
---
 .../claude-structured-session-adapter.test.ts   | 17 +++++++++++++----
 ...NativeChatStructuredSessionDelivery.test.tsx |  4 +++-
 2 files changed, 16 insertions(+), 5 deletions(-)

diff --git a/src/main/claude/claude-structured-session-adapter.test.ts b/src/main/claude/claude-structured-session-adapter.test.ts
index ebb7cd936059..d38629c7e892 100644
--- a/src/main/claude/claude-structured-session-adapter.test.ts
+++ b/src/main/claude/claude-structured-session-adapter.test.ts
@@ -485,16 +485,25 @@ describe('ClaudeStructuredSessionAdapter.acquire', () => {
     expect(wrongClaude.connections[0].closeCount).toBe(1)
   })
 
-  it('ends the published session with the CLI startup failure, never a timer', async () => {
+  it('fails the acquire with the CLI diagnostic when the exit lands before the handover', async () => {
+    // No init delay: the child dies inside the initialize call, before acquire can return it.
     const claude = fakeClaude({ exitBeforeInit: 'Claude login required' })
+    const events: ClaudeStructuredSessionEvent[] = []
+    const adapter = adapterFor(claude, {}, events)
 
-    await expect(endedAtStartup(claude)).resolves.toMatchObject({
-      type: 'ended',
+    await expect(
+      adapter.acquire({ identity: identityFor(), fence: 7, spawnToken: 'spawn-9' })
+    ).rejects.toThrow('Claude login required')
+    await adapter.drainObservedExits()
+
+    // The published-then-ended path is the slow-init case in the startup suite. The first-hand
+    // exit is still reported as it was seen; the host holds no session under it to end.
+    expect(events.find((event) => event.type === 'ended')).toMatchObject({
       reason: 'Claude login required',
       cause: 'unexpected-exit',
       startupUnproven: true
     })
-    expect(claude.connections[0].closeCount).toBe(1)
+    expect(claude.connections[0].closeCount).toBeGreaterThanOrEqual(1)
   })
 
   it('refuses an unauthenticated initialize response even when SessionStart runs', async () => {
diff --git a/src/renderer/src/components/native-chat/NativeChatStructuredSessionDelivery.test.tsx b/src/renderer/src/components/native-chat/NativeChatStructuredSessionDelivery.test.tsx
index f632d98f3cb7..c12d152fe0fa 100644
--- a/src/renderer/src/components/native-chat/NativeChatStructuredSessionDelivery.test.tsx
+++ b/src/renderer/src/components/native-chat/NativeChatStructuredSessionDelivery.test.tsx
@@ -38,7 +38,9 @@ const mocks = vi.hoisted(() => ({
 }))
 
 vi.mock('@/runtime/structured-agent-session-client', () => ({
-  callStructuredAgentSession: mocks.call
+  callStructuredAgentSession: mocks.call,
+  // The pane activates the host status feed for its startup phase; nothing here drives it.
+  subscribeStructuredAgentSessionStatus: async () => ({ unsubscribe: () => {} })
 }))
 
 vi.mock('./use-structured-agent-session', async () => {

From f7178a3919ce19d38f06f119c1437f0bf6a015ca Mon Sep 17 00:00:00 2001
From: Brennan Benson <79079362+brennanb2025@users.noreply.github.com>
Date: Wed, 23 Sep 2026 00:40:51 -0700
Subject: [PATCH 17/67] test(native-chat): a same-ID re-hold over the wire
 joins the one resume, and a replay reopen goes on the idle clock

---
 ...red-agent-session-hold-resume-race.test.ts |  28 ++++
 ...ctured-agent-session-send-recovery.test.ts |   2 +
 .../structured-agent-session-hold.test.ts     | 129 +++++++-----------
 3 files changed, 80 insertions(+), 79 deletions(-)

diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-hold-resume-race.test.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-hold-resume-race.test.ts
index b7a88d7484ff..9b954efc00c1 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-hold-resume-race.test.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-hold-resume-race.test.ts
@@ -184,6 +184,34 @@ describe('a surface leaving while its structured session resumes', () => {
     expect(evict).not.toHaveBeenCalled()
   })
 
+  it('keeps a hold that found the child already there when the resume that made it still fails', async () => {
+    const gate = Promise.withResolvers<void>()
+    let child = false
+    const holds = new StructuredAgentSessionHolds({
+      // The child is up before the resume settles, and then the resume fails behind it.
+      resume: async () => {
+        child = true
+        await gate.promise
+        return { fromFence: 1 }
+      },
+      hasProviderChild: () => child,
+      isTurnActive: () => false,
+      evict: async () => {},
+      graceMs: GRACE_MS
+    })
+    pendingHolds.push(holds)
+    const first = holds.hold('session-1', 'same-holder')
+    const rejected = expect(first).rejects.toThrow('acquisition failed')
+    holds.release('session-1', 'same-holder')
+    await holds.hold('session-1', 'same-holder')
+
+    gate.reject(new Error('acquisition failed'))
+    await rejected
+
+    expect(holds.isHeld('session-1')).toBe(true)
+    expect(holds.isReleasePending('session-1')).toBe(false)
+  })
+
   it('starts a fresh resume once the failed one has settled', async () => {
     let child = false
     const resume = vi
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-send-recovery.test.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-send-recovery.test.ts
index 7517fba0d9a1..222afbfc7c78 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-send-recovery.test.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-send-recovery.test.ts
@@ -373,6 +373,8 @@ describe('a send with no live owner', () => {
 
     expect(acquire).toHaveBeenCalledOnce()
     expect(dispatch).toHaveBeenCalledOnce()
+    // The reopened child is nobody's: it goes on the idle clock like any unheld restart.
+    expect(host['holds'].isReleasePending(SESSION)).toBe(true)
   })
 
   it('refuses for good when the owner cannot be restarted', async () => {
diff --git a/src/main/runtime/rpc/methods/structured-agent-session-hold.test.ts b/src/main/runtime/rpc/methods/structured-agent-session-hold.test.ts
index da34108604ab..20a6c7ab5d28 100644
--- a/src/main/runtime/rpc/methods/structured-agent-session-hold.test.ts
+++ b/src/main/runtime/rpc/methods/structured-agent-session-hold.test.ts
@@ -162,106 +162,77 @@ describe('a client that holds a session', () => {
 })
 
 describe('a client that disappears without cleanup', () => {
-  it('releases a late child after its same-ID replacement refuses the stale fence', async () => {
+  it('shares one child with a same-ID replacement that arrives while the first hold resumes', async () => {
     await host.close(SESSION)
     await host.restoreReadableSessions()
     closeSession.mockClear()
-    const firstEntered = Promise.withResolvers<void>()
-    const firstGate = Promise.withResolvers<void>()
-    const replacementEntered = Promise.withResolvers<void>()
-    const replacementGate = Promise.withResolvers<void>()
+    const entered = Promise.withResolvers<void>()
+    const gate = Promise.withResolvers<void>()
     const attach = host.attach.bind(host)
-    const attachSpy = vi
-      .spyOn(host, 'attach')
-      .mockImplementationOnce(async (...args) => {
-        firstEntered.resolve()
-        await firstGate.promise
-        return attach(...args)
-      })
-      .mockImplementationOnce(async (...args) => {
-        replacementEntered.resolve()
-        await replacementGate.promise
-        return attach(...args)
-      })
+    const attachSpy = vi.spyOn(host, 'attach').mockImplementationOnce(async (...args) => {
+      entered.resolve()
+      await gate.promise
+      return attach(...args)
+    })
     try {
       const params = { sessionId: SESSION, holderId: 'same-chat' }
       const first = call('agentSession.hold', params)
-      await firstEntered.promise
+      await entered.promise
+      // Re-registering the cleanup id released the first hold; the replacement joins its resume.
       const replacement = call('agentSession.hold', params)
-      await replacementEntered.promise
-      firstGate.resolve()
+      gate.resolve()
+
       expect(await first).toMatchObject({ ok: true })
+      expect(await replacement).toMatchObject({ ok: true })
+      expect(attachSpy).toHaveBeenCalledOnce()
       expect(host.isHeld(SESSION)).toBe(true)
+      await new Promise((resolve) => setTimeout(resolve, GRACE_MS * 4))
       expect(closeSession).not.toHaveBeenCalled()
 
-      replacementGate.resolve()
-      expect(await replacement).toMatchObject({
-        ok: false,
-        error: { code: 'agent_session_checkpoint_stale' }
-      })
-      expect(host.isHeld(SESSION)).toBe(false)
+      runtime.cleanupSubscriptionsForConnection(CONNECTION)
       await vi.waitFor(() => expect(host.hasSession(SESSION)).toBe(false))
       expect(closeSession).toHaveBeenCalledExactlyOnceWith(SESSION)
     } finally {
-      firstGate.resolve()
-      replacementGate.resolve()
+      gate.resolve()
       attachSpy.mockRestore()
     }
   })
 
-  it.each([false, true])(
-    'keeps replacement hold and cleanup after an old request fails (replacement finished=%s)',
-    async (replacementFinished) => {
-      await host.close(SESSION)
-      await host.restoreReadableSessions()
-      closeSession.mockClear()
-      const firstEntered = Promise.withResolvers<void>()
-      const firstGate = Promise.withResolvers<void>()
-      const replacementEntered = Promise.withResolvers<void>()
-      const replacementGate = Promise.withResolvers<void>()
-      const attach = host.attach.bind(host)
-      const attachSpy = vi
-        .spyOn(host, 'attach')
-        .mockImplementationOnce(async () => {
-          firstEntered.resolve()
-          await firstGate.promise
-          throw new Error('old acquisition failed')
-        })
-        .mockImplementationOnce(async (...args) => {
-          replacementEntered.resolve()
-          await replacementGate.promise
-          return attach(...args)
-        })
-      try {
-        const params = { sessionId: SESSION, holderId: 'same-chat' }
-        const first = call('agentSession.hold', params)
-        await firstEntered.promise
-        const replacement = call('agentSession.hold', params)
-        await replacementEntered.promise
-        if (replacementFinished) {
-          replacementGate.resolve()
-          expect(await replacement).toMatchObject({ ok: true })
-        }
+  it('fails a hold and its same-ID replacement together when their one resume fails, and the next hold starts over', async () => {
+    await host.close(SESSION)
+    await host.restoreReadableSessions()
+    closeSession.mockClear()
+    const entered = Promise.withResolvers<void>()
+    const gate = Promise.withResolvers<void>()
+    const attachSpy = vi.spyOn(host, 'attach').mockImplementationOnce(async () => {
+      entered.resolve()
+      await gate.promise
+      throw new Error('acquisition failed')
+    })
+    try {
+      const params = { sessionId: SESSION, holderId: 'same-chat' }
+      const first = call('agentSession.hold', params)
+      await entered.promise
+      const replacement = call('agentSession.hold', params)
+      gate.resolve()
 
-        firstGate.resolve()
-        expect(await first).toMatchObject({ ok: false })
-        expect(host.isHeld(SESSION)).toBe(true)
-        replacementGate.resolve()
-        expect(await replacement).toMatchObject({ ok: true })
-        await new Promise((resolve) => setTimeout(resolve, GRACE_MS * 4))
-        expect(host.hasSession(SESSION)).toBe(true)
-        expect(closeSession).not.toHaveBeenCalled()
-
-        runtime.cleanupSubscriptionsForConnection(CONNECTION)
-        await vi.waitFor(() => expect(host.hasSession(SESSION)).toBe(false))
-        expect(closeSession).toHaveBeenCalledExactlyOnceWith(SESSION)
-      } finally {
-        firstGate.resolve()
-        replacementGate.resolve()
-        attachSpy.mockRestore()
-      }
+      expect(await first).toMatchObject({ ok: false })
+      expect(await replacement).toMatchObject({ ok: false })
+      expect(host.isHeld(SESSION)).toBe(false)
+      expect(closeSession).not.toHaveBeenCalled()
+
+      expect(await call('agentSession.hold', params)).toMatchObject({ ok: true })
+      expect(attachSpy).toHaveBeenCalledTimes(2)
+      expect(host.isHeld(SESSION)).toBe(true)
+
+      runtime.cleanupSubscriptionsForConnection(CONNECTION)
+      await vi.waitFor(() => expect(host.hasSession(SESSION)).toBe(false))
+      expect(closeSession).toHaveBeenCalledExactlyOnceWith(SESSION)
+    } finally {
+      gate.resolve()
+      attachSpy.mockRestore()
     }
-  )
+  })
 
   it('still releases the session when its transport closes', async () => {
     await call('agentSession.hold', { sessionId: SESSION, holderId: 'chat-1' })

From fe2143437d960b596b99e802da1515b65f75803f Mon Sep 17 00:00:00 2001
From: Brennan Benson <79079362+brennanb2025@users.noreply.github.com>
Date: Wed, 23 Sep 2026 00:44:50 -0700
Subject: [PATCH 18/67] test(native-chat): a re-hold that joins a failing
 resume proves one resume ran

---
 ...uctured-agent-session-hold-resume-race.test.ts | 15 +++++++++------
 1 file changed, 9 insertions(+), 6 deletions(-)

diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-hold-resume-race.test.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-hold-resume-race.test.ts
index 9b954efc00c1..e410c8bb0495 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-hold-resume-race.test.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-hold-resume-race.test.ts
@@ -11,12 +11,13 @@ function resumeHarness() {
   const evict = vi.fn(async () => {
     child = false
   })
+  const resume = vi.fn(async () => {
+    await resumeGate.promise
+    child = true
+    return { fromFence: 1 }
+  })
   const holds = new StructuredAgentSessionHolds({
-    resume: async () => {
-      await resumeGate.promise
-      child = true
-      return { fromFence: 1 }
-    },
+    resume,
     hasProviderChild: () => child,
     isTurnActive: () => turnActive,
     evict,
@@ -25,6 +26,7 @@ function resumeHarness() {
   pendingHolds.push(holds)
   return {
     holds,
+    resume,
     resumeGate,
     evict,
     hasChild: () => child,
@@ -167,13 +169,14 @@ describe('a surface leaving while its structured session resumes', () => {
   })
 
   it('joins a pending resume for a holder that left and came back, and a failure releases it', async () => {
-    const { holds, resumeGate, evict } = resumeHarness()
+    const { holds, resume, resumeGate, evict } = resumeHarness()
     const first = holds.hold('session-1', 'same-holder')
     const firstRejected = expect(first).rejects.toThrow('acquisition failed')
     holds.release('session-1', 'same-holder')
     const replacement = holds.hold('session-1', 'same-holder')
     const replacementRejected = expect(replacement).rejects.toThrow('acquisition failed')
     expect(holds.isHeld('session-1')).toBe(true)
+    expect(resume).toHaveBeenCalledOnce()
 
     resumeGate.reject(new Error('acquisition failed'))
     await Promise.all([firstRejected, replacementRejected])

From e52cce43aa39820590a1b6b950099ed91e172e2f Mon Sep 17 00:00:00 2001
From: Brennan Benson <79079362+brennanb2025@users.noreply.github.com>
Date: Wed, 23 Sep 2026 10:50:54 -0700
Subject: [PATCH 19/67] fix(native-chat): a create whose child was proven gone
 answers the refusal on the first call

The previous change answered a first-hand root exit as the exited refusal on the
first call, but the common failed start never took that path: when the close
ladder proves the whole tree dead the acquisition error is a plain one, the
store-failure classifier rethrows it, and the client still saw a runtime error
first and the refusal only on replay.

The cleanup that proves the child gone now names such a failure
`AgentSessionAcquisitionExitProvenError`, carrying the provider's diagnostic,
unless it already names its own verdict (a refusal, a typed exit proof, a host
store code). The attach answers both proven-exit kinds as the refusal its replay
gives. How a failed acquisition settles and how it is first answered now live
beside the verdict stamp, in the failed-create module.
---
 ...-agent-session-acquisition-options.test.ts | 18 +++--
 .../structured-agent-session-adapter.test.ts  | 18 ++++-
 .../structured-agent-session-adapter.ts       | 24 ++++++-
 .../structured-agent-session-attach-flow.ts   | 72 +++++--------------
 ...ession-failed-create-owner-verdict.test.ts | 19 +++--
 ...red-agent-session-failed-create-refusal.ts | 54 ++++++++++++++
 ...session-failed-create-sink-release.test.ts | 44 ++++++++----
 .../structured-agent-session-host.test.ts     | 20 ++++--
 ...agent-session-settled-attach-retry.test.ts |  5 +-
 ...ude-structured-session-integration.test.ts | 39 +++++++++-
 10 files changed, 216 insertions(+), 97 deletions(-)

diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-acquisition-options.test.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-acquisition-options.test.ts
index 78bf7cf2808f..75dd5f95bfd9 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-acquisition-options.test.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-acquisition-options.test.ts
@@ -419,7 +419,10 @@ describe('structured session acquisition options', () => {
         now: () => NOW,
         onAttached: () => {}
       })
-    ).rejects.toThrow('model list unavailable')
+    ).resolves.toEqual({
+      ok: false,
+      refusal: { code: 'agent_session_operation_invalid', message: 'model list unavailable' }
+    })
     expect(releaseAcquisition).toHaveBeenCalledOnce()
     expect(store.getRecord(SESSION)?.lease.ownerProcess).toBeNull()
   })
@@ -508,9 +511,16 @@ describe('structured session acquisition options', () => {
           onAttached: () => {}
         })
 
-      await expect(perform(store, CREATE_OPERATION, null)).rejects.toThrow(
-        exitProven ? injected.message : 'agent_session_acquisition_exit_unproven'
-      )
+      // A proven exit before the journal opens is answered once, as the refusal its replay gives.
+      const failed = perform(store, CREATE_OPERATION, null)
+      await (exitProven && failurePoint !== 'journal'
+        ? expect(failed).resolves.toEqual({
+            ok: false,
+            refusal: { code: 'agent_session_operation_invalid', message: injected.message }
+          })
+        : expect(failed).rejects.toThrow(
+            exitProven ? injected.message : 'agent_session_acquisition_exit_unproven'
+          ))
 
       const reopened = await AgentSessionRecordStore.open({
         directory: storeDir,
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-adapter.test.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-adapter.test.ts
index 77cce9153f51..93f9b9037df7 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-adapter.test.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-adapter.test.ts
@@ -1,15 +1,31 @@
 import { describe, expect, it, vi } from 'vitest'
 
 import {
+  AgentSessionAcquisitionExitProvenError,
   AgentSessionAcquisitionExitUnprovenError,
+  AgentSessionAcquisitionRefusal,
   AgentSessionAcquisitionRootExitObservedError,
   rethrowAfterAgentSessionAcquisitionCleanup
 } from './structured-agent-session-adapter'
 
 describe('failed agent-session acquisition cleanup', () => {
-  it('preserves the acquisition failure after proven cleanup', async () => {
+  it('names a failure exit-proven after proven cleanup, keeping its diagnostic and cause', async () => {
     const cause = new Error('proof failed')
+    const thrown = await rethrowAfterAgentSessionAcquisitionCleanup(
+      { releaseAcquisition: vi.fn(async () => true) },
+      'session-1',
+      cause
+    ).catch((error: unknown) => error)
+
+    expect(thrown).toBeInstanceOf(AgentSessionAcquisitionExitProvenError)
+    expect(thrown).toMatchObject({ message: 'proof failed', cause })
+  })
 
+  it.each([
+    ['a refusal', new AgentSessionAcquisitionRefusal('not signed in')],
+    ['a root exit', new AgentSessionAcquisitionRootExitObservedError(new Error('exited'))],
+    ['a host store code', new Error('agent_session_checkpoint_stale')]
+  ])('keeps %s that already names its verdict after proven cleanup', async (_label, cause) => {
     await expect(
       rethrowAfterAgentSessionAcquisitionCleanup(
         { releaseAcquisition: vi.fn(async () => true) },
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-adapter.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-adapter.ts
index aced8d81221d..626724b7c73c 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-adapter.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-adapter.ts
@@ -29,6 +29,7 @@ import type {
   AgentSessionSlashCommand,
   AgentSessionWireRefusalCode
 } from '../../../shared/agent-session-wire'
+import { isAgentSessionWireRefusalCode } from '../../../shared/agent-session-wire-refusals'
 import type { ProviderHistoryWindow } from '../agent-session-journal/journal-submission-reconciler'
 import type { StructuredAgentSessionEventSink } from './structured-agent-session-event-sink'
 import type { AgentSessionCreatePhaseRecorder } from '../../observability/agent-session-instrumentation'
@@ -70,6 +71,15 @@ export class AgentSessionAcquisitionRootExitObservedError extends Error {
   }
 }
 
+/** The provider child failed and cleanup proved its whole tree gone. As with a root exit, the
+ *  provider's own diagnostic is the message. */
+export class AgentSessionAcquisitionExitProvenError extends Error {
+  constructor(cause: unknown) {
+    super(cause instanceof Error ? cause.message : String(cause), { cause })
+    this.name = 'AgentSessionAcquisitionExitProvenError'
+  }
+}
+
 export class AgentSessionAcquisitionExitUnprovenError extends Error {
   constructor(cause: unknown) {
     super('agent_session_acquisition_exit_unproven', { cause })
@@ -306,7 +316,19 @@ export async function rethrowAfterAgentSessionAcquisitionCleanup(
         )
   }
   if (released) {
-    throw cause
+    throw provenExitAcquisitionFailure(cause)
   }
   throw new AgentSessionAcquisitionExitUnprovenError(cause)
 }
+
+/** A failure whose child cleanup proved gone. One that already names its own verdict — a
+ *  refusal, a typed exit proof, or a host store code — keeps it. */
+function provenExitAcquisitionFailure(cause: unknown): unknown {
+  const classified =
+    cause instanceof AgentSessionAcquisitionRefusal ||
+    cause instanceof AgentSessionAcquisitionRootExitObservedError ||
+    cause instanceof AgentSessionAcquisitionExitUnprovenError ||
+    isAgentSessionPreSpawnError(cause) ||
+    (cause instanceof Error && isAgentSessionWireRefusalCode(cause.message))
+  return classified ? cause : new AgentSessionAcquisitionExitProvenError(cause)
+}
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-attach-flow.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-attach-flow.ts
index be4641606d24..9445620c9024 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-attach-flow.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-attach-flow.ts
@@ -1,14 +1,12 @@
 import { settlePostAcquisitionAttachFailure } from './structured-agent-session-attach-failure'
-import { rewindRefusal } from './structured-rewind-refusal'
 import {
-  AgentSessionRewindRefusal,
-  AgentSessionAcquisitionExitUnprovenError,
-  AgentSessionAcquisitionRootExitObservedError,
-  AgentSessionAcquisitionRefusal,
-  isAgentSessionPreSpawnError,
-  type StructuredAgentSessionAcquireInput,
-  type StructuredAgentSessionAdapter,
-  type StructuredAgentSessionProviderChildPhase
+  failedAcquisitionRefusal,
+  failedAcquisitionSettlement
+} from './structured-agent-session-failed-create-refusal'
+import type {
+  StructuredAgentSessionAcquireInput,
+  StructuredAgentSessionAdapter,
+  StructuredAgentSessionProviderChildPhase
 } from './structured-agent-session-adapter'
 // The host supplies owner authority; this flow reserves, proves, and publishes the session.
 
@@ -175,31 +173,6 @@ export async function performAttach(
     const spawnToken = reservedRecord?.lease.reservedSpawnToken
     if (reservedRecord && spawnToken && !unsupportedReservationSettlementAttempted) {
       // Settle processless proof and failed operation atomically.
-      const exitProof = isAgentSessionPreSpawnError(error)
-        ? 'processless'
-        : error instanceof AgentSessionAcquisitionExitUnprovenError
-          ? 'unproven'
-          : error instanceof AgentSessionAcquisitionRootExitObservedError
-            ? 'root-exit-observed'
-            : 'exit-proven'
-      const outcome =
-        error instanceof AgentSessionAcquisitionExitUnprovenError
-          ? {
-              status: 'failed' as const,
-              code: 'agent_session_ownership_unknown',
-              message: error.message
-            }
-          : error instanceof AgentSessionAcquisitionRefusal
-            ? {
-                status: 'failed' as const,
-                code: error.code,
-                message: error.message
-              }
-            : {
-                status: 'failed' as const,
-                code: 'agent_session_operation_invalid',
-                message: error instanceof Error ? error.message : String(error)
-              }
       try {
         await store.settleFailedAcquisition({
           sessionId,
@@ -207,8 +180,7 @@ export async function performAttach(
           spawnToken,
           callerKey: input.callerKey,
           operationId: params.envelope.clientOperationId,
-          outcome,
-          exitProof,
+          ...failedAcquisitionSettlement(error),
           now: input.now()
         })
       } catch (settlementError) {
@@ -218,28 +190,16 @@ export async function performAttach(
         )
       }
     }
-    if (error instanceof AgentSessionRewindRefusal) {
-      return rewindRefusal(error.rewindReason)
-    }
-    if (error instanceof AgentSessionAcquisitionRefusal) {
-      return { ok: false, refusal: { code: error.code, message: error.message } }
-    }
-    // A first-hand root exit is a settled fact, answered once as a refusal rather than thrown
-    // now and refused only on replay; its message is the provider's own diagnostic.
-    if (error instanceof AgentSessionAcquisitionRootExitObservedError) {
-      return {
+    return (
+      failedAcquisitionRefusal(error) ?? {
         ok: false,
-        refusal: { code: 'agent_session_operation_invalid', message: error.message }
+        refusal: classifyStoreFailure(
+          error,
+          store.getRecord(sessionId)?.lease.runtimeFence ?? null,
+          store.getRecord(sessionId)
+        )
       }
-    }
-    return {
-      ok: false,
-      refusal: classifyStoreFailure(
-        error,
-        store.getRecord(sessionId)?.lease.runtimeFence ?? null,
-        store.getRecord(sessionId)
-      )
-    }
+    )
   }
 
   let attached: AttachedJournal
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-failed-create-owner-verdict.test.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-failed-create-owner-verdict.test.ts
index 5ea4e12a754d..3d064eed7e0b 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-failed-create-owner-verdict.test.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-failed-create-owner-verdict.test.ts
@@ -66,19 +66,18 @@ afterEach(async () => {
 })
 
 describe('failed create owner verdict', () => {
-  it('replays an exit-proven failure as exited with its reason, and a new operation starts fresh', async () => {
+  it('answers an exit-proven failure as exited on the first call and its replay, and a new operation starts fresh', async () => {
+    // The cleanup's release proves the whole tree gone: the common failed start.
     acquire.mockRejectedValueOnce(new Error(EXIT_REASON))
     const first = hostTestAttachParams(null)
+    const refusal = {
+      code: 'agent_session_operation_invalid',
+      message: EXIT_REASON,
+      ownerVerdict: 'exited'
+    }
 
-    await expect(host.attach(CALLER, first)).rejects.toThrow(EXIT_REASON)
-    await expect(host.attach(CALLER, first)).resolves.toEqual({
-      ok: false,
-      refusal: {
-        code: 'agent_session_operation_invalid',
-        message: EXIT_REASON,
-        ownerVerdict: 'exited'
-      }
-    })
+    await expect(host.attach(CALLER, first)).resolves.toEqual({ ok: false, refusal })
+    await expect(host.attach(CALLER, first)).resolves.toEqual({ ok: false, refusal })
     expect(acquire).toHaveBeenCalledOnce()
 
     const retry = hostTestAttachParams(null)
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-failed-create-refusal.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-failed-create-refusal.ts
index b843bb6611b9..c12b7319359a 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-failed-create-refusal.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-failed-create-refusal.ts
@@ -9,6 +9,60 @@ import type {
 } from '../../../shared/agent-session-operation-ledger'
 import { agentSessionLeaseOwnerVerdict } from '../../../shared/agent-session-lease-adjudication'
 import type { AgentSessionRecord } from '../../../shared/agent-session-record'
+import type { AgentSessionAcquisitionExitProof } from '../../runtime/agent-session-acquisition-failure-settlement'
+import {
+  AgentSessionAcquisitionExitProvenError,
+  AgentSessionAcquisitionExitUnprovenError,
+  AgentSessionAcquisitionRefusal,
+  AgentSessionAcquisitionRootExitObservedError,
+  AgentSessionRewindRefusal,
+  isAgentSessionPreSpawnError
+} from './structured-agent-session-adapter'
+import { rewindRefusal } from './structured-rewind-refusal'
+
+/** What a failed acquisition proved about its process, and the outcome its operation settles to. */
+export function failedAcquisitionSettlement(error: unknown): {
+  exitProof: AgentSessionAcquisitionExitProof
+  outcome: Extract<AgentSessionOperationOutcome, { status: 'failed' }>
+} {
+  if (error instanceof AgentSessionAcquisitionExitUnprovenError) {
+    const outcome = { code: 'agent_session_ownership_unknown', message: error.message }
+    return { exitProof: 'unproven', outcome: { status: 'failed', ...outcome } }
+  }
+  const exitProof = isAgentSessionPreSpawnError(error)
+    ? 'processless'
+    : error instanceof AgentSessionAcquisitionRootExitObservedError
+      ? 'root-exit-observed'
+      : 'exit-proven'
+  const message = error instanceof Error ? error.message : String(error)
+  const code =
+    error instanceof AgentSessionAcquisitionRefusal ? error.code : 'agent_session_operation_invalid'
+  return { exitProof, outcome: { status: 'failed', code, message } }
+}
+
+/** A failed acquisition answered as a refusal on the first call, in the shape its replay takes;
+ *  null leaves the error to the store-failure classification. */
+export function failedAcquisitionRefusal(
+  error: unknown
+): { ok: false; refusal: AgentSessionWireRefusal } | null {
+  if (error instanceof AgentSessionRewindRefusal) {
+    return rewindRefusal(error.rewindReason)
+  }
+  if (error instanceof AgentSessionAcquisitionRefusal) {
+    return { ok: false, refusal: { code: error.code, message: error.message } }
+  }
+  // A proven exit is a settled fact; its message is the provider's own diagnostic.
+  if (
+    error instanceof AgentSessionAcquisitionRootExitObservedError ||
+    error instanceof AgentSessionAcquisitionExitProvenError
+  ) {
+    return {
+      ok: false,
+      refusal: { code: 'agent_session_operation_invalid', message: error.message }
+    }
+  }
+  return null
+}
 
 /** Only a durably failed operation says anything about retrying under a new one. */
 export function failedCreateRefusal(
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-failed-create-sink-release.test.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-failed-create-sink-release.test.ts
index 4248550a7e0c..fd71bc8bc569 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-failed-create-sink-release.test.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-failed-create-sink-release.test.ts
@@ -7,7 +7,10 @@ import { tmpdir } from 'node:os'
 import { join } from 'node:path'
 import { afterEach, beforeEach, describe, expect, it, vi, type Mock } from 'vitest'
 import { AgentSessionRecordStore } from '../../runtime/agent-session-record-store'
-import type { StructuredAgentSessionAdapter } from './structured-agent-session-adapter'
+import {
+  AgentSessionPreSpawnError,
+  type StructuredAgentSessionAdapter
+} from './structured-agent-session-adapter'
 import { StructuredAgentSessionHost } from './structured-agent-session-host'
 import {
   HOST_TEST_NOW as NOW,
@@ -59,20 +62,31 @@ afterEach(async () => {
   await rm(root, { recursive: true, force: true })
 })
 
-describe('a create that throws after its child wrote through the unbound sink', () => {
-  it('releases the sink, so a new create and shutdown both proceed', async () => {
-    acquire.mockImplementationOnce(async ({ events }) => {
-      // The published child's exit reached the translator before any journal was attached.
-      events?.setActivity?.(null)
-      throw new Error(EXIT_REASON)
-    })
+describe('a create that fails after its child wrote through the unbound sink', () => {
+  it.each([
+    // The common failed start: answered as a refusal.
+    ['refused', new Error(EXIT_REASON)],
+    // A failure the attach cannot classify still throws, and must release the sink too.
+    ['thrown', new AgentSessionPreSpawnError(new Error(EXIT_REASON))]
+  ])(
+    'releases the sink when %s, so a new create and shutdown both proceed',
+    async (_how, cause) => {
+      acquire.mockImplementationOnce(async ({ events }) => {
+        // The published child's exit reached the translator before any journal was attached.
+        events?.setActivity?.(null)
+        throw cause
+      })
 
-    await expect(host.attach(CALLER, hostTestAttachParams(null))).rejects.toThrow(EXIT_REASON)
+      const failed = host.attach(CALLER, hostTestAttachParams(null))
+      await (cause instanceof AgentSessionPreSpawnError
+        ? expect(failed).rejects.toThrow(EXIT_REASON)
+        : expect(failed).resolves.toMatchObject({ ok: false, refusal: { message: EXIT_REASON } }))
 
-    await expect(host.attach(CALLER, hostTestAttachParams(null))).resolves.toMatchObject({
-      ok: true
-    })
-    await expect(host.flushAllStreamedEvents()).resolves.toBeUndefined()
-    expect(acquire).toHaveBeenCalledTimes(2)
-  })
+      await expect(host.attach(CALLER, hostTestAttachParams(null))).resolves.toMatchObject({
+        ok: true
+      })
+      await expect(host.flushAllStreamedEvents()).resolves.toBeUndefined()
+      expect(acquire).toHaveBeenCalledTimes(2)
+    }
+  )
 })
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-host.test.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-host.test.ts
index a19735657d60..1386b620d736 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-host.test.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-host.test.ts
@@ -138,13 +138,16 @@ describe('attach', () => {
     })
     const params = attachParams()
 
-    await expect(host.attach(CALLER, params)).rejects.toThrow(
-      'agent_session_provider_handle_stale_fence'
-    )
-    expect(await host.attach(CALLER, params)).toMatchObject({
+    const refused = {
       ok: false,
-      refusal: { code: 'agent_session_operation_invalid' }
-    })
+      refusal: {
+        code: 'agent_session_operation_invalid',
+        message: 'agent_session_provider_handle_stale_fence',
+        ownerVerdict: 'exited'
+      }
+    }
+    expect(await host.attach(CALLER, params)).toEqual(refused)
+    expect(await host.attach(CALLER, params)).toEqual(refused)
     const releasedFence = store.getRecord(SESSION)?.lease.runtimeFence ?? 0
     expect(await host.attach(CALLER, ensureParams(releasedFence))).toMatchObject({ ok: true })
     expect(acquire).toHaveBeenCalledTimes(2)
@@ -155,7 +158,10 @@ describe('attach', () => {
   it('reaps an acquisition when process identity commit fails', async () => {
     vi.spyOn(store, 'commitProcessIdentity').mockRejectedValueOnce(new Error('commit failed'))
 
-    await expect(host.attach(CALLER, attachParams())).rejects.toThrow('commit failed')
+    await expect(host.attach(CALLER, attachParams())).resolves.toMatchObject({
+      ok: false,
+      refusal: { message: 'commit failed', ownerVerdict: 'exited' }
+    })
 
     expect(releaseAcquisition).toHaveBeenCalledWith({ sessionId: SESSION })
   })
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-settled-attach-retry.test.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-settled-attach-retry.test.ts
index 278619c2c617..5780359a8aec 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-settled-attach-retry.test.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-settled-attach-retry.test.ts
@@ -382,7 +382,10 @@ describe('settled attach retry', () => {
   it('records proven acquisition cleanup as durable death evidence', async () => {
     acquire.mockRejectedValueOnce(new Error('resume rejected'))
 
-    await expect(host.attach(CALLER, hostTestAttachParams(null))).rejects.toThrow('resume rejected')
+    await expect(host.attach(CALLER, hostTestAttachParams(null))).resolves.toMatchObject({
+      ok: false,
+      refusal: { message: 'resume rejected', ownerVerdict: 'exited' }
+    })
 
     expect(releaseAcquisition).toHaveBeenCalledTimes(1)
     expect(store.getRecord(SESSION)?.lease).toMatchObject({
diff --git a/src/main/runtime/claude-structured-session-integration.test.ts b/src/main/runtime/claude-structured-session-integration.test.ts
index 80e2c4d42fb8..a53252f8e7e6 100644
--- a/src/main/runtime/claude-structured-session-integration.test.ts
+++ b/src/main/runtime/claude-structured-session-integration.test.ts
@@ -132,7 +132,7 @@ function fakeClaude() {
       exitVerdict: selfExit?.exitVerdict ?? { root: 'live', tree: 'unverifiable' },
       close: async () => {
         connection.closed = true
-        return selfExit === null
+        return selfExit === null || selfExit.exitVerdict.tree === 'exited'
       }
     }
     connections.push(connection)
@@ -486,7 +486,18 @@ describe('a structured Claude session over agentSession.*', () => {
 
     const failed = await call('agentSession.create', createIntentParams())
 
-    expect(JSON.stringify(failed)).toContain('claude: not signed in')
+    // Answered once, as the refusal a replay of this operation gives, never thrown first.
+    expect(failed).toMatchObject({
+      ok: true,
+      result: {
+        ok: false,
+        refusal: {
+          code: 'agent_session_operation_invalid',
+          message: expect.stringContaining('claude: not signed in'),
+          ownerVerdict: 'exited'
+        }
+      }
+    })
     const lease = leaseOf(SESSION)
     // Latching here would refuse every later attach with agent_session_ownership_unknown,
     // wedging a user who only needs to sign in.
@@ -501,6 +512,30 @@ describe('a structured Claude session over agentSession.*', () => {
     await ok<{ fence: number }>('agentSession.ensure', ensureParams(lease.runtimeFence))
   })
 
+  it('answers a create whose whole CLI tree exited as exited on the first call', async () => {
+    claude.setSelfExit({
+      message: 'claude stream-json exited (code 1): claude: not signed in',
+      // The common case: the close ladder proves the root and every descendant gone.
+      exitVerdict: { root: 'exited', tree: 'exited' }
+    })
+
+    const failed = await call('agentSession.create', createIntentParams())
+
+    expect(failed).toMatchObject({
+      ok: true,
+      result: {
+        ok: false,
+        refusal: {
+          code: 'agent_session_operation_invalid',
+          message: expect.stringContaining('claude: not signed in'),
+          ownerVerdict: 'exited'
+        }
+      }
+    })
+    expect(leaseOf(SESSION)).toMatchObject({ claimStatus: 'released', handoffStage: null })
+    claude.setSelfExit(null)
+  })
+
   it('keeps a session reserved when a descendant of the failed start was seen alive', async () => {
     claude.setSelfExit({
       message: 'claude stream-json exited (code 1): claude: not signed in',

From 136a39deb088787a1be9e43b77ef42ed854d719d Mon Sep 17 00:00:00 2001
From: Brennan Benson <79079362+brennanb2025@users.noreply.github.com>
Date: Wed, 23 Sep 2026 10:55:06 -0700
Subject: [PATCH 20/67] test(native-chat): pin the outbox re-driving a
 stale-refused send under the resumed fence

A send into a session whose child ended is answered stale once the host has
restarted the child. The outbox keeps that operation queued and blocked, and the
fence change the resume publishes re-drives the same operation under the new
fence; the host admits it.
---
 ...e-structured-agent-session-outbox.test.tsx | 33 +++++++++++++++++++
 1 file changed, 33 insertions(+)

diff --git a/src/renderer/src/components/native-chat/use-structured-agent-session-outbox.test.tsx b/src/renderer/src/components/native-chat/use-structured-agent-session-outbox.test.tsx
index a0b94657e79c..d80d742ba7ca 100644
--- a/src/renderer/src/components/native-chat/use-structured-agent-session-outbox.test.tsx
+++ b/src/renderer/src/components/native-chat/use-structured-agent-session-outbox.test.tsx
@@ -529,6 +529,39 @@ describe('useStructuredAgentSessionOutbox', () => {
     ).toBe(firstId)
   })
 
+  it('re-drives a send refused as stale under the fence a host resume published', async () => {
+    // A send into a session whose child ended: the host restarts it and answers stale.
+    mocks.call
+      .mockResolvedValueOnce(refusedResult('agent_session_checkpoint_stale'))
+      .mockResolvedValueOnce(acceptedResult(2))
+    const { result, rerender } = renderHook(
+      ({ fence }) =>
+        useStructuredAgentSessionOutbox({
+          sessionId: 'session-1',
+          target: LOCAL_TARGET,
+          fence,
+          submissions: []
+        }),
+      { initialProps: { fence: 1 } }
+    )
+
+    act(() => expect(result.current.send('hello')).toBe(true))
+    await waitFor(() => expect(result.current.error).toBe('agent_session_checkpoint_stale'))
+    expect(mocks.call).toHaveBeenCalledOnce()
+
+    rerender({ fence: 2 })
+    await waitFor(() => expect(result.current.outbox).toHaveLength(0))
+    const envelopes = mocks.call.mock.calls.map(
+      (call) => (call[2] as { envelope: { clientOperationId: string } }).envelope
+    )
+    expect(envelopes).toHaveLength(2)
+    expect(envelopes[1]).toMatchObject({
+      expectedRuntimeFence: 2,
+      clientOperationId: envelopes[0]!.clientOperationId
+    })
+    expect(result.current.error).toBeNull()
+  })
+
   it('persists and dispatches an attachment-only structured send', async () => {
     mocks.call.mockResolvedValue(acceptedResult(1))
     const { result } = renderHook(() =>

From e52c4a6f085dbc45961b1d5cb098aeaa465e34da Mon Sep 17 00:00:00 2001
From: Brennan Benson <79079362+brennanb2025@users.noreply.github.com>
Date: Wed, 23 Sep 2026 10:55:12 -0700
Subject: [PATCH 21/67] fix(native-chat): a child restarted for a send nobody
 holds is still released

The restart a send runs for a childless session takes no holder, on the premise
that the sending surface already holds one. A one-shot writer holds nothing, so
the child it restarted had no release clock and lived until the app quit. The
write resume now arms the clock when no holder is present, as the first-hold
resume already does. The send-after-failed-start cases also pin that the stale
answer's operation is admitted when re-sent under the new fence, and that two
racing sends restart the child once.
---
 .../structured-agent-session-holds.test.ts    | 20 ++++++++++++
 .../structured-agent-session-holds.ts         | 15 +++++++--
 ...nt-session-send-after-failed-start.test.ts | 31 +++++++++++++++++--
 3 files changed, 62 insertions(+), 4 deletions(-)

diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-holds.test.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-holds.test.ts
index 268f28ed54e0..6e12bb43f1c6 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-holds.test.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-holds.test.ts
@@ -174,6 +174,26 @@ describe('holds', () => {
     holds.dispose()
   })
 
+  it('hands a child a write resumed for no holder to the release clock', async () => {
+    let child = false
+    const evict = vi.fn(async () => {
+      child = false
+    })
+    const holds = new StructuredAgentSessionHolds({
+      resume: async () => {
+        child = true
+      },
+      hasProviderChild: () => child,
+      isTurnActive: () => false,
+      evict,
+      graceMs: 1
+    })
+
+    await holds.resumeForWrite('session-1')
+    await vi.waitFor(() => expect(evict).toHaveBeenCalledWith('session-1'))
+    holds.dispose()
+  })
+
   it('fails a write-capable hold when resume proves no provider child', async () => {
     const holds = new StructuredAgentSessionHolds({
       resume: async () => {},
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-holds.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-holds.ts
index 038e79137b63..75ae9c804ce2 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-holds.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-holds.ts
@@ -51,8 +51,19 @@ export class StructuredAgentSessionHolds {
 
   /** A write reaching a session with no child is the user asking for it back: the same resume a
    *  first hold runs, without taking a holder, since the surface that sent already holds one. */
-  resumeForWrite(sessionId: string): Promise<void> {
-    return this.deps.hasProviderChild(sessionId) ? Promise.resolve() : this.deps.resume(sessionId)
+  async resumeForWrite(sessionId: string): Promise<void> {
+    if (this.deps.hasProviderChild(sessionId)) {
+      return
+    }
+    await this.deps.resume(sessionId)
+    // A writer that holds nothing (a one-shot send) still leaves a child something must release.
+    if (
+      !this.disposed &&
+      !this.holders.isHeld(sessionId) &&
+      this.deps.hasProviderChild(sessionId)
+    ) {
+      this.clock.arm(sessionId)
+    }
   }
 
   async hold(
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-send-after-failed-start.test.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-send-after-failed-start.test.ts
index ec5837d3c043..8dec128dfe0f 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-send-after-failed-start.test.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-send-after-failed-start.test.ts
@@ -108,7 +108,8 @@ describe('a send into a published session whose child ended before startup', ()
     const releasedFence = store.getRecord(SESSION)?.lease.runtimeFence ?? 0
 
     const body = hostTestMessage('hello again')
-    const first = await host.send(CALLER, { envelope: sendEnvelope(releasedFence, body), body })
+    const envelope = sendEnvelope(releasedFence, body)
+    const first = await host.send(CALLER, { envelope, body })
     expect(acquire).toHaveBeenCalledTimes(2)
     expect(store.getRecord(SESSION)?.lease.claimStatus).toBe('live')
     // The resume reserved a new fence, so this send is answered stale with the fence it published;
@@ -120,12 +121,38 @@ describe('a send into a published session whose child ended before startup', ()
     const current = first.ok ? 0 : (first.refusal.currentFence ?? 0)
     expect(current).toBeGreaterThan(releasedFence)
 
+    // The outbox re-drives the same operation, as it does after any fence change.
     await expect(
-      host.send(CALLER, { envelope: sendEnvelope(current, body), body })
+      host.send(CALLER, { envelope: { ...envelope, expectedRuntimeFence: current }, body })
     ).resolves.toMatchObject({ ok: true, value: { submission: { dispatchState: 'pending' } } })
     expect(acquire).toHaveBeenCalledTimes(2)
   })
 
+  it('restarts the child once when two sends race into the ended session', async () => {
+    await host.attach(CALLER, hostTestAttachParams(null))
+    const startedFence = store.getRecord(SESSION)?.lease.runtimeFence ?? 0
+    await host.handleAdapterEvent({
+      type: 'ended',
+      sessionId: SESSION,
+      reason: EXIT_REASON,
+      cause: 'unexpected-exit',
+      fence: startedFence,
+      acquisitionGeneration: 'generation-1',
+      startupUnproven: true
+    })
+    const releasedFence = store.getRecord(SESSION)?.lease.runtimeFence ?? 0
+    const first = hostTestMessage('first')
+    const second = hostTestMessage('second')
+
+    await Promise.all([
+      host.send(CALLER, { envelope: sendEnvelope(releasedFence, first), body: first }),
+      host.send(CALLER, { envelope: sendEnvelope(releasedFence, second), body: second })
+    ])
+
+    expect(acquire).toHaveBeenCalledTimes(2)
+    expect(store.getRecord(SESSION)?.lease.claimStatus).toBe('live')
+  })
+
   it('leaves a send against a live child alone', async () => {
     await host.attach(CALLER, hostTestAttachParams(null))
     const fence = store.getRecord(SESSION)?.lease.runtimeFence ?? 0

From b8feb16fb012398ad4a4ad7074d8555e200ea84b Mon Sep 17 00:00:00 2001
From: Brennan Benson <79079362+brennanb2025@users.noreply.github.com>
Date: Wed, 23 Sep 2026 10:57:28 -0700
Subject: [PATCH 22/67] test(native-chat): pin the picked Claude model across a
 resume whose child starts on its own default

The started event re-reads and persists what the child reports. A resumed child
answers initialize with its CLI default before the saved pick is restored over
it; the record must hold the pick while starting and after started.
---
 ...red-agent-session-provider-started.test.ts | 25 ++++++++++++++++++-
 1 file changed, 24 insertions(+), 1 deletion(-)

diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-provider-started.test.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-provider-started.test.ts
index f085f58033bc..fa5d6c238f04 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-provider-started.test.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-provider-started.test.ts
@@ -46,7 +46,8 @@ beforeEach(async () => {
       claudeConfigDir: join(root, 'claude-home'),
       providerSessionId: PROVIDER_SESSION_ID,
       resumeLeafUuid: null,
-      resumed: false
+      // A session that already minted its provider handle resumes it, as the real launch does.
+      resumed: (store.getRecord(SESSION)?.providerHandleChain.length ?? 0) > 0
     }),
     // The runtime's own mapping, so this test drives the same lifecycle path production does.
     onEvent: (event) => {
@@ -120,4 +121,26 @@ describe('a publish-first Claude create whose init is slow', () => {
     expect(store.getRecord(SESSION)?.options?.model).toBe('opus')
     expect(lastPhase()).toBe('ready')
   })
+
+  it('keeps the picked model across a resume whose new child starts on its own default', async () => {
+    const params = claudeParams()
+    await host.attach(CALLER, { ...params, options: { model: 'opus' } })
+    await adapter.drainStartup(SESSION)
+    await Promise.all(lifecycle)
+    await host.close(SESSION)
+    const releasedFence = store.getRecord(SESSION)?.lease.runtimeFence ?? 0
+
+    // Reopening the chat: the surface's first hold resumes the session.
+    await host.hold(SESSION, 'chat-1')
+    expect(store.getRecord(SESSION)?.lease.runtimeFence).toBeGreaterThan(releasedFence)
+    // The new child's init reports its CLI default; the saved pick is restored over it.
+    expect(store.getRecord(SESSION)?.options?.model).toBe('opus')
+    expect(lastPhase()).toBe('starting')
+
+    await adapter.drainStartup(SESSION)
+    await Promise.all(lifecycle)
+
+    expect(store.getRecord(SESSION)?.options?.model).toBe('opus')
+    expect(lastPhase()).toBe('ready')
+  })
 })

From f411c217c14063d6b9a4d5af0d335fe7a26f33b8 Mon Sep 17 00:00:00 2001
From: Brennan Benson <79079362+brennanb2025@users.noreply.github.com>
Date: Wed, 23 Sep 2026 11:11:53 -0700
Subject: [PATCH 23/67] Revert "fix(native-chat): a child restarted for a send
 nobody holds is still released"

This reverts commit e52c4a6f085dbc45961b1d5cb098aeaa465e34da.
---
 .../structured-agent-session-holds.test.ts    | 20 ------------
 .../structured-agent-session-holds.ts         | 15 ++-------
 ...nt-session-send-after-failed-start.test.ts | 31 ++-----------------
 3 files changed, 4 insertions(+), 62 deletions(-)

diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-holds.test.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-holds.test.ts
index 6e12bb43f1c6..268f28ed54e0 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-holds.test.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-holds.test.ts
@@ -174,26 +174,6 @@ describe('holds', () => {
     holds.dispose()
   })
 
-  it('hands a child a write resumed for no holder to the release clock', async () => {
-    let child = false
-    const evict = vi.fn(async () => {
-      child = false
-    })
-    const holds = new StructuredAgentSessionHolds({
-      resume: async () => {
-        child = true
-      },
-      hasProviderChild: () => child,
-      isTurnActive: () => false,
-      evict,
-      graceMs: 1
-    })
-
-    await holds.resumeForWrite('session-1')
-    await vi.waitFor(() => expect(evict).toHaveBeenCalledWith('session-1'))
-    holds.dispose()
-  })
-
   it('fails a write-capable hold when resume proves no provider child', async () => {
     const holds = new StructuredAgentSessionHolds({
       resume: async () => {},
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-holds.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-holds.ts
index 75ae9c804ce2..038e79137b63 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-holds.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-holds.ts
@@ -51,19 +51,8 @@ export class StructuredAgentSessionHolds {
 
   /** A write reaching a session with no child is the user asking for it back: the same resume a
    *  first hold runs, without taking a holder, since the surface that sent already holds one. */
-  async resumeForWrite(sessionId: string): Promise<void> {
-    if (this.deps.hasProviderChild(sessionId)) {
-      return
-    }
-    await this.deps.resume(sessionId)
-    // A writer that holds nothing (a one-shot send) still leaves a child something must release.
-    if (
-      !this.disposed &&
-      !this.holders.isHeld(sessionId) &&
-      this.deps.hasProviderChild(sessionId)
-    ) {
-      this.clock.arm(sessionId)
-    }
+  resumeForWrite(sessionId: string): Promise<void> {
+    return this.deps.hasProviderChild(sessionId) ? Promise.resolve() : this.deps.resume(sessionId)
   }
 
   async hold(
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-send-after-failed-start.test.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-send-after-failed-start.test.ts
index 8dec128dfe0f..ec5837d3c043 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-send-after-failed-start.test.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-send-after-failed-start.test.ts
@@ -108,8 +108,7 @@ describe('a send into a published session whose child ended before startup', ()
     const releasedFence = store.getRecord(SESSION)?.lease.runtimeFence ?? 0
 
     const body = hostTestMessage('hello again')
-    const envelope = sendEnvelope(releasedFence, body)
-    const first = await host.send(CALLER, { envelope, body })
+    const first = await host.send(CALLER, { envelope: sendEnvelope(releasedFence, body), body })
     expect(acquire).toHaveBeenCalledTimes(2)
     expect(store.getRecord(SESSION)?.lease.claimStatus).toBe('live')
     // The resume reserved a new fence, so this send is answered stale with the fence it published;
@@ -121,38 +120,12 @@ describe('a send into a published session whose child ended before startup', ()
     const current = first.ok ? 0 : (first.refusal.currentFence ?? 0)
     expect(current).toBeGreaterThan(releasedFence)
 
-    // The outbox re-drives the same operation, as it does after any fence change.
     await expect(
-      host.send(CALLER, { envelope: { ...envelope, expectedRuntimeFence: current }, body })
+      host.send(CALLER, { envelope: sendEnvelope(current, body), body })
     ).resolves.toMatchObject({ ok: true, value: { submission: { dispatchState: 'pending' } } })
     expect(acquire).toHaveBeenCalledTimes(2)
   })
 
-  it('restarts the child once when two sends race into the ended session', async () => {
-    await host.attach(CALLER, hostTestAttachParams(null))
-    const startedFence = store.getRecord(SESSION)?.lease.runtimeFence ?? 0
-    await host.handleAdapterEvent({
-      type: 'ended',
-      sessionId: SESSION,
-      reason: EXIT_REASON,
-      cause: 'unexpected-exit',
-      fence: startedFence,
-      acquisitionGeneration: 'generation-1',
-      startupUnproven: true
-    })
-    const releasedFence = store.getRecord(SESSION)?.lease.runtimeFence ?? 0
-    const first = hostTestMessage('first')
-    const second = hostTestMessage('second')
-
-    await Promise.all([
-      host.send(CALLER, { envelope: sendEnvelope(releasedFence, first), body: first }),
-      host.send(CALLER, { envelope: sendEnvelope(releasedFence, second), body: second })
-    ])
-
-    expect(acquire).toHaveBeenCalledTimes(2)
-    expect(store.getRecord(SESSION)?.lease.claimStatus).toBe('live')
-  })
-
   it('leaves a send against a live child alone', async () => {
     await host.attach(CALLER, hostTestAttachParams(null))
     const fence = store.getRecord(SESSION)?.lease.runtimeFence ?? 0

From a696115e46535e9bb219a1358281a1629b0d493d Mon Sep 17 00:00:00 2001
From: Brennan Benson <79079362+brennanb2025@users.noreply.github.com>
Date: Wed, 23 Sep 2026 11:11:53 -0700
Subject: [PATCH 24/67] Revert "test(native-chat): pin the outbox re-driving a
 stale-refused send under the resumed fence"

This reverts commit 136a39deb088787a1be9e43b77ef42ed854d719d.
---
 ...e-structured-agent-session-outbox.test.tsx | 33 -------------------
 1 file changed, 33 deletions(-)

diff --git a/src/renderer/src/components/native-chat/use-structured-agent-session-outbox.test.tsx b/src/renderer/src/components/native-chat/use-structured-agent-session-outbox.test.tsx
index d80d742ba7ca..a0b94657e79c 100644
--- a/src/renderer/src/components/native-chat/use-structured-agent-session-outbox.test.tsx
+++ b/src/renderer/src/components/native-chat/use-structured-agent-session-outbox.test.tsx
@@ -529,39 +529,6 @@ describe('useStructuredAgentSessionOutbox', () => {
     ).toBe(firstId)
   })
 
-  it('re-drives a send refused as stale under the fence a host resume published', async () => {
-    // A send into a session whose child ended: the host restarts it and answers stale.
-    mocks.call
-      .mockResolvedValueOnce(refusedResult('agent_session_checkpoint_stale'))
-      .mockResolvedValueOnce(acceptedResult(2))
-    const { result, rerender } = renderHook(
-      ({ fence }) =>
-        useStructuredAgentSessionOutbox({
-          sessionId: 'session-1',
-          target: LOCAL_TARGET,
-          fence,
-          submissions: []
-        }),
-      { initialProps: { fence: 1 } }
-    )
-
-    act(() => expect(result.current.send('hello')).toBe(true))
-    await waitFor(() => expect(result.current.error).toBe('agent_session_checkpoint_stale'))
-    expect(mocks.call).toHaveBeenCalledOnce()
-
-    rerender({ fence: 2 })
-    await waitFor(() => expect(result.current.outbox).toHaveLength(0))
-    const envelopes = mocks.call.mock.calls.map(
-      (call) => (call[2] as { envelope: { clientOperationId: string } }).envelope
-    )
-    expect(envelopes).toHaveLength(2)
-    expect(envelopes[1]).toMatchObject({
-      expectedRuntimeFence: 2,
-      clientOperationId: envelopes[0]!.clientOperationId
-    })
-    expect(result.current.error).toBeNull()
-  })
-
   it('persists and dispatches an attachment-only structured send', async () => {
     mocks.call.mockResolvedValue(acceptedResult(1))
     const { result } = renderHook(() =>

From c690f243ed8354e9eb1493b5367851c3d254bef1 Mon Sep 17 00:00:00 2001
From: Brennan Benson <79079362+brennanb2025@users.noreply.github.com>
Date: Wed, 23 Sep 2026 11:11:53 -0700
Subject: [PATCH 25/67] Revert "fix(native-chat): a send into a session whose
 child ended restarts it before admission"

This reverts commit 39234e44bf7881fd7a5c3adfeca907340c93f153.
---
 .../structured-agent-session-holds.ts         |   6 -
 ...structured-agent-session-host-mutations.ts |  28 +---
 .../structured-agent-session-host.ts          |   1 -
 ...nt-session-send-after-failed-start.test.ts | 138 ------------------
 4 files changed, 1 insertion(+), 172 deletions(-)
 delete mode 100644 src/main/native-chat/agent-session-wire/structured-agent-session-send-after-failed-start.test.ts

diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-holds.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-holds.ts
index 038e79137b63..73880022646b 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-holds.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-holds.ts
@@ -49,12 +49,6 @@ export class StructuredAgentSessionHolds {
     this.clock = new StructuredAgentSessionReleaseClock(clockDeps)
   }
 
-  /** A write reaching a session with no child is the user asking for it back: the same resume a
-   *  first hold runs, without taking a holder, since the surface that sent already holds one. */
-  resumeForWrite(sessionId: string): Promise<void> {
-    return this.deps.hasProviderChild(sessionId) ? Promise.resolve() : this.deps.resume(sessionId)
-  }
-
   async hold(
     sessionId: string,
     holderId: string,
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-host-mutations.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-host-mutations.ts
index 537d9253b39e..2c8bd5fbabcc 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-host-mutations.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-host-mutations.ts
@@ -1,5 +1,4 @@
 import { rewindRefusal } from './structured-rewind-refusal'
-import { isResumableStructuredAgentSessionRecord } from './structured-agent-session-resume-eligibility'
 // Everything a client can ask an ALREADY-ATTACHED session to do: send a turn, cancel one, answer a
 // prompt, change an option, read the options back.
 //
@@ -42,8 +41,6 @@ export type StructuredAgentSessionMutationContext = {
   hasPendingStreamedEvents?: (sessionId: string) => boolean
   requireSession: (sessionId: string) => StructuredAgentSessionHostSession
   serialize: <T>(sessionId: string, task: () => Promise<T>) => Promise<T>
-  /** Gives a childless session its provider child back before a write is admitted. */
-  resumeProviderChild?: (sessionId: string) => Promise<void>
   now: () => number
 }
 
@@ -69,29 +66,7 @@ function mutate<TValue>(
   )
 }
 
-/** A send into a session whose child ended (a start that failed, an exit at idle) restarts it
- *  the way a surface's first hold does, so the message is not parked forever behind a released
- *  lease. The resume's own failure is not this send's answer: admission reports the lease as it
- *  stands, and the client re-drives under the fence the resume published. */
-async function resumeBeforeSend(
-  context: StructuredAgentSessionMutationContext,
-  sessionId: string
-): Promise<void> {
-  const session = context.sessions.get(sessionId)
-  const record = context.deps.store.getRecord(sessionId)
-  if (
-    !context.resumeProviderChild ||
-    !session ||
-    session.hasProviderChild ||
-    !record ||
-    !isResumableStructuredAgentSessionRecord(record)
-  ) {
-    return
-  }
-  await context.resumeProviderChild(sessionId).catch(() => undefined)
-}
-
-export async function sendStructuredAgentSessionTurn(
+export function sendStructuredAgentSessionTurn(
   context: StructuredAgentSessionMutationContext,
   caller: StructuredAgentSessionCaller,
   params: {
@@ -102,7 +77,6 @@ export async function sendStructuredAgentSessionTurn(
   }
 ): Promise<AgentSessionMutationResult<AgentSessionSendResult>> {
   const plan = sendPlan(params)
-  await resumeBeforeSend(context, params.envelope.sessionId)
   return mutate(context, caller, params.envelope, {
     ...plan,
     run: (ctx) => {
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-host.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-host.ts
index 409c116896d4..2a1ebb2ac499 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-host.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-host.ts
@@ -277,7 +277,6 @@ export class StructuredAgentSessionHost {
         this.runtimeState.hasPendingStreamedEvents(sessionId),
       requireSession: (sessionId) => this.requireSession(sessionId),
       serialize: (sessionId, task) => this.serialize(sessionId, task),
-      resumeProviderChild: (sessionId) => this.holds.resumeForWrite(sessionId),
       now: () => this.now()
     }
   }
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-send-after-failed-start.test.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-send-after-failed-start.test.ts
deleted file mode 100644
index ec5837d3c043..000000000000
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-send-after-failed-start.test.ts
+++ /dev/null
@@ -1,138 +0,0 @@
-// A session that published and then lost its child before startup (not signed in, say) keeps a
-// released lease and a chat the user can still type into. The send is the user asking for the
-// child back: the host restarts it before admitting the write, instead of parking the message
-// behind a lease nothing would ever re-acquire.
-
-import { mkdtemp, rm } from 'node:fs/promises'
-import { tmpdir } from 'node:os'
-import { join } from 'node:path'
-import { afterEach, beforeEach, describe, expect, it, vi, type Mock } from 'vitest'
-import { computeAgentSessionPayloadFingerprint } from '../../../shared/agent-session-mutation-envelope'
-import type { AgentSessionMutationEnvelope } from '../../../shared/agent-session-wire'
-import { AgentSessionRecordStore } from '../../runtime/agent-session-record-store'
-import type { StructuredAgentSessionAdapter } from './structured-agent-session-adapter'
-import { StructuredAgentSessionHost } from './structured-agent-session-host'
-import {
-  HOST_TEST_NOW as NOW,
-  HOST_TEST_SESSION as SESSION,
-  HOST_TEST_THREAD as THREAD,
-  hostTestAttachParams,
-  hostTestMessage,
-  hostTestOperationId,
-  resetHostTestOperationIds
-} from './structured-agent-session-host-test-data'
-
-const CALLER = { callerKey: 'client-1' }
-const EXIT_REASON = 'Claude Code is not signed in. Sign in with the Claude CLI'
-
-let root: string
-let store: AgentSessionRecordStore
-let host: StructuredAgentSessionHost
-let acquire: Mock<StructuredAgentSessionAdapter['acquire']>
-let generation = 0
-
-function sendEnvelope(
-  fence: number,
-  body: ReturnType<typeof hostTestMessage>
-): AgentSessionMutationEnvelope {
-  return {
-    sessionId: SESSION,
-    clientOperationId: hostTestOperationId(),
-    expectedRuntimeFence: fence,
-    payloadFingerprint: computeAgentSessionPayloadFingerprint({
-      method: 'agentSession.send',
-      sessionId: SESSION,
-      fields: { body }
-    })
-  }
-}
-
-beforeEach(async () => {
-  root = await mkdtemp(join(tmpdir(), 'orca-send-after-failed-start-'))
-  resetHostTestOperationIds()
-  generation = 0
-  acquire = vi.fn(async ({ fence, spawnToken }) => ({
-    process: { hostId: 'local', pid: 4242, processStartTimeMs: 1_700_000_000_000, spawnToken },
-    link: {
-      linkId: `link-${fence}`,
-      handle: { provider: 'codex', threadId: THREAD },
-      // A re-acquire resumes the thread the first child minted, as a real adapter does.
-      origin: generation === 0 ? ('created' as const) : ('resumed' as const),
-      mintedAtFence: fence,
-      observedAt: NOW
-    },
-    acquisitionGeneration: `generation-${++generation}`,
-    providerChildPhase: 'starting' as const
-  }))
-  store = await AgentSessionRecordStore.open({ directory: join(root, 'store'), hostId: 'local' })
-  host = new StructuredAgentSessionHost({
-    store,
-    adapter: {
-      acquire,
-      releaseAcquisition: vi.fn(async () => true),
-      dispatch: vi.fn(async () => ({ state: 'admitted' as const })),
-      cancelTurn: vi.fn(async () => ({ cancelled: true })),
-      answerPrompt: vi.fn(async () => undefined),
-      setOption: vi.fn(async () => undefined)
-    },
-    journalRoot: root,
-    claimKeyId: 'key-1',
-    mintSpawnToken: () => `spawn-${generation + 1}`,
-    now: () => NOW
-  })
-})
-
-afterEach(async () => {
-  await host.flushAllStreamedEvents()
-  await rm(root, { recursive: true, force: true })
-})
-
-describe('a send into a published session whose child ended before startup', () => {
-  it('restarts the child and admits the message once the resume has published', async () => {
-    await expect(host.attach(CALLER, hostTestAttachParams(null))).resolves.toMatchObject({
-      ok: true
-    })
-    const startedFence = store.getRecord(SESSION)?.lease.runtimeFence ?? 0
-    await host.handleAdapterEvent({
-      type: 'ended',
-      sessionId: SESSION,
-      reason: EXIT_REASON,
-      cause: 'unexpected-exit',
-      fence: startedFence,
-      acquisitionGeneration: 'generation-1',
-      startupUnproven: true
-    })
-    // The failed start released the lease and no resume ran on its own.
-    expect(store.getRecord(SESSION)?.lease.claimStatus).toBe('released')
-    expect(acquire).toHaveBeenCalledOnce()
-    const releasedFence = store.getRecord(SESSION)?.lease.runtimeFence ?? 0
-
-    const body = hostTestMessage('hello again')
-    const first = await host.send(CALLER, { envelope: sendEnvelope(releasedFence, body), body })
-    expect(acquire).toHaveBeenCalledTimes(2)
-    expect(store.getRecord(SESSION)?.lease.claimStatus).toBe('live')
-    // The resume reserved a new fence, so this send is answered stale with the fence it published;
-    // the client's outbox re-drives under it, exactly as after any other fence change.
-    expect(first, JSON.stringify(first)).toMatchObject({
-      ok: false,
-      refusal: { code: 'agent_session_checkpoint_stale', currentFence: expect.any(Number) }
-    })
-    const current = first.ok ? 0 : (first.refusal.currentFence ?? 0)
-    expect(current).toBeGreaterThan(releasedFence)
-
-    await expect(
-      host.send(CALLER, { envelope: sendEnvelope(current, body), body })
-    ).resolves.toMatchObject({ ok: true, value: { submission: { dispatchState: 'pending' } } })
-    expect(acquire).toHaveBeenCalledTimes(2)
-  })
-
-  it('leaves a send against a live child alone', async () => {
-    await host.attach(CALLER, hostTestAttachParams(null))
-    const fence = store.getRecord(SESSION)?.lease.runtimeFence ?? 0
-    const body = hostTestMessage('hello')
-    await expect(
-      host.send(CALLER, { envelope: sendEnvelope(fence, body), body })
-    ).resolves.toMatchObject({ ok: true })
-    expect(acquire).toHaveBeenCalledOnce()
-  })
-})

From 0e58f827af721ff19d183f129c72e59f68e0454b Mon Sep 17 00:00:00 2001
From: Brennan Benson <79079362+brennanb2025@users.noreply.github.com>
Date: Wed, 23 Sep 2026 11:39:37 -0700
Subject: [PATCH 26/67] refactor(native-chat): make ensure-owner a step of the
 serialized send

A send that found the owner gone restarted it OUTSIDE the host's per-session
serialize, through a single-flight resume map shared with the surface hold, then
rebased its fence by heuristic. The attach body is now callable from inside
`serialize` (`attachStructuredAgentSessionUnderSerialize`), and every restart
runs there: a hold, a send's ensure-owner step, provider-exit recovery and the
rewind owner replacement take turns on one queue, so the first to run attaches
and the next finds its child. The single-flight map and `isResuming` are gone.

Admission is two-phase for a send: the ledger's answer comes first and places
nothing; a send it will admit gives the session an owner, and only then are the
row placed and the lease and fence checked. A send it will replay into a closed
session makes the journal readable and spawns nothing. The session entry
records the released fence the child replaced (`resumedFromFence`), so a writer
current as of that owner is admitted at the new fence by bookkeeping, whether it
ran the restart or arrived behind it.

The resume reads its record only after this host has reconciled it and exited
any recovery stage a failed attempt latched, so a hold behind a failed attempt
makes its own attempt against the lease as it now stands.
---
 ...ured-agent-session-attach-orchestration.ts | 388 ++++++++++--------
 ...structured-agent-session-event-recovery.ts |  32 +-
 ...red-agent-session-hold-resume-race.test.ts |  31 +-
 .../structured-agent-session-hold-resume.ts   |  37 +-
 .../structured-agent-session-holds.test.ts    |  50 ++-
 .../structured-agent-session-holds.ts         |  66 ++-
 .../structured-agent-session-host-lifetime.ts |  56 +--
 ...structured-agent-session-host-mutations.ts |  80 ++--
 .../structured-agent-session-host-types.ts    |   4 +
 .../structured-agent-session-host.ts          |  12 +-
 ...ctured-agent-session-mutation-admission.ts |  51 ++-
 ...uctured-agent-session-readable-restorer.ts |  20 +-
 ...tructured-agent-session-restart-restore.ts |  46 ++-
 .../structured-agent-session-reveal.ts        |   5 +-
 .../structured-agent-session-rewind.ts        |   2 +-
 ...ed-agent-session-send-preparation.test.ts} |  77 +++-
 ...ructured-agent-session-send-preparation.ts | 126 ++++++
 .../structured-agent-session-send-recovery.ts | 101 -----
 ...ession-send-restarts-failed-start.test.ts} |   0
 ...uctured-conversation-command-controller.ts |  33 +-
 .../structured-conversation-command.ts        |   2 +-
 .../structured-rewind-claude-owner.ts         |  15 +-
 .../agent-session-operation-admission.ts      |  89 +++-
 .../runtime/agent-session-record-store.ts     |  13 +-
 .../structured-agent-session-hold.test.ts     |  57 +--
 25 files changed, 809 insertions(+), 584 deletions(-)
 rename src/main/native-chat/agent-session-wire/{structured-agent-session-send-recovery.test.ts => structured-agent-session-send-preparation.test.ts} (85%)
 create mode 100644 src/main/native-chat/agent-session-wire/structured-agent-session-send-preparation.ts
 delete mode 100644 src/main/native-chat/agent-session-wire/structured-agent-session-send-recovery.ts
 rename src/main/native-chat/agent-session-wire/{structured-agent-session-send-after-failed-start.test.ts => structured-agent-session-send-restarts-failed-start.test.ts} (100%)

diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-attach-orchestration.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-attach-orchestration.ts
index df5aa97816bc..c538b521c389 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-attach-orchestration.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-attach-orchestration.ts
@@ -22,6 +22,7 @@ import {
   pinnedAgentSessionLaunchEnv
 } from './structured-agent-session-launch-env'
 import { refuseAgentSessionMutation } from './structured-agent-session-mutation-admission'
+import { isResumableStructuredAgentSessionRecord } from './structured-agent-session-resume-eligibility'
 import { retryPendingStructuredAgentSessionSettlement } from './structured-agent-session-settlement-retry'
 import { settleStaleSessionStateOnAcquire } from './structured-agent-session-stale-turn-verdict'
 import type { StructuredAgentSessionAttachContext } from './structured-agent-session-attach-context'
@@ -36,200 +37,229 @@ import {
   type AgentSessionCreatePhaseRecorder
 } from '../../observability/agent-session-instrumentation'
 
-export function attachStructuredAgentSession(
+export type StructuredAgentSessionAttachOptions = {
+  /** Provider-exit recovery: refuses once the ticket the restart was issued for is stale. */
+  admitRecoveryTicket?: () => boolean
+  rewind?: StructuredAgentSessionAcquireInput['rewind']
+  recordPhase?: AgentSessionCreatePhaseRecorder
+}
+
+/**
+ * The attach itself, for a caller already inside the session's serialize.
+ *
+ * That is every caller that has to know what the session looks like RIGHT NOW: a hold, a send
+ * making sure it has an owner, provider-exit recovery, a rewind replacing the owner. They run their
+ * check and this attach in one serialized step, so "the session has no child" is still true when
+ * the attach starts. `attachStructuredAgentSession` is this under `serialize`, for a client.
+ */
+export function attachStructuredAgentSessionUnderSerialize(
   context: StructuredAgentSessionAttachContext,
   callerKey: string,
   params: AgentSessionAttachParams,
-  admitRecoveryTicket?: () => boolean,
-  rewind?: StructuredAgentSessionAcquireInput['rewind']
+  options: StructuredAgentSessionAttachOptions = {}
+): Promise<AgentSessionMutationResult<AgentSessionAttachResult>> {
+  return context.tasks.trackAttach(runAttach(context, callerKey, params, options))
+}
+
+export function attachStructuredAgentSession(
+  context: StructuredAgentSessionAttachContext,
+  callerKey: string,
+  params: AgentSessionAttachParams
 ): Promise<AgentSessionMutationResult<AgentSessionAttachResult>> {
   const sessionId = params.envelope.sessionId
   const run = (recordPhase?: AgentSessionCreatePhaseRecorder) =>
-    context.serialize(sessionId, async () => {
-      if (admitRecoveryTicket && !admitRecoveryTicket()) {
-        return refuseAgentSessionMutation({
-          code: 'agent_session_checkpoint_stale',
-          message: 'The provider-exit recovery ticket is no longer current.'
-        })
-      }
-      const unreconciled = await withAgentSessionCreatePhase('reconcile_leases', recordPhase, () =>
-        context.reconcileLeases(sessionId)
-      )
-      if (unreconciled) {
-        return refuseAgentSessionMutation(unreconciled)
-      }
-      await withAgentSessionCreatePhase('resolve_recovery', recordPhase, () =>
-        context.runtimeState.resolveRecovery(sessionId)
-      )
-      // Retries a durable provider-exit journal settlement before a new owner is reserved. Answers
-      // settled when the record has none pending, so every attach can ask unconditionally.
-      const settled = await withAgentSessionCreatePhase('settlement_retry', recordPhase, () =>
-        retryPendingStructuredAgentSessionSettlement({
-          deps: context.deps,
-          sessions: context.sessions,
-          sessionId,
-          params,
-          now: () => context.now()
-        })
-      )
-      if (!settled) {
-        return refuseAgentSessionMutation({
-          code: 'agent_session_ownership_unknown',
-          message: 'The provider-exit terminal journal settlement is still pending; retry attach.'
-        })
-      }
-      const eventSink = context.runtimeState.eventSinkFor(sessionId)
-      const probe = await withAgentSessionCreatePhase('probe_owner', recordPhase, () =>
-        context.runtimeState.probeOwner(sessionId)
-      )
-      // Why: a failed attach that left no session behind must not strand a bound sink; the runtime
-      // caches one per session id and would hand this same closed instance to the next attempt.
-      const discardUnattachedSink = (): void => {
-        if (!context.sessions.has(sessionId)) {
-          eventSink.close()
-          context.runtimeState.discardEventSink(sessionId)
+    context.serialize(sessionId, () =>
+      attachStructuredAgentSessionUnderSerialize(context, callerKey, params, { recordPhase })
+    )
+  if (params.envelope.expectedRuntimeFence !== null) {
+    return run()
+  }
+  return withAgentSessionSpan(async (span) => {
+    const startedAtMs = Date.now()
+    const phases: Parameters<AgentSessionCreatePhaseRecorder>[0][] = []
+    try {
+      return await run((timing) => phases.push(timing))
+    } finally {
+      addAgentSessionCreatePhaseAttributes(span, {
+        totalDurationMs: Math.max(0, Date.now() - startedAtMs),
+        phases
+      })
+    }
+  })
+}
+
+async function runAttach(
+  context: StructuredAgentSessionAttachContext,
+  callerKey: string,
+  params: AgentSessionAttachParams,
+  options: StructuredAgentSessionAttachOptions
+): Promise<AgentSessionMutationResult<AgentSessionAttachResult>> {
+  const sessionId = params.envelope.sessionId
+  const recordPhase = options.recordPhase
+  if (options.admitRecoveryTicket && !options.admitRecoveryTicket()) {
+    return refuseAgentSessionMutation({
+      code: 'agent_session_checkpoint_stale',
+      message: 'The provider-exit recovery ticket is no longer current.'
+    })
+  }
+  const unreconciled = await withAgentSessionCreatePhase('reconcile_leases', recordPhase, () =>
+    context.reconcileLeases(sessionId)
+  )
+  if (unreconciled) {
+    return refuseAgentSessionMutation(unreconciled)
+  }
+  await withAgentSessionCreatePhase('resolve_recovery', recordPhase, () =>
+    context.runtimeState.resolveRecovery(sessionId)
+  )
+  // Retries a durable provider-exit journal settlement before a new owner is reserved. Answers
+  // settled when the record has none pending, so every attach can ask unconditionally.
+  const settled = await withAgentSessionCreatePhase('settlement_retry', recordPhase, () =>
+    retryPendingStructuredAgentSessionSettlement({
+      deps: context.deps,
+      sessions: context.sessions,
+      sessionId,
+      params,
+      now: () => context.now()
+    })
+  )
+  if (!settled) {
+    return refuseAgentSessionMutation({
+      code: 'agent_session_ownership_unknown',
+      message: 'The provider-exit terminal journal settlement is still pending; retry attach.'
+    })
+  }
+  const eventSink = context.runtimeState.eventSinkFor(sessionId)
+  const probe = await withAgentSessionCreatePhase('probe_owner', recordPhase, () =>
+    context.runtimeState.probeOwner(sessionId)
+  )
+  // Why: a failed attach that left no session behind must not strand a bound sink; the runtime
+  // caches one per session id and would hand this same closed instance to the next attempt.
+  const discardUnattachedSink = (): void => {
+    if (!context.sessions.has(sessionId)) {
+      eventSink.close()
+      context.runtimeState.discardEventSink(sessionId)
+    }
+  }
+  // A lease handed back cleanly is what a resume replaces. A writer current as of that owner is
+  // rebased onto the fence this attach publishes, since the restart is the only thing that moved it.
+  const released = context.deps.store.getRecord(sessionId)
+  const resumedFromFence =
+    released && isResumableStructuredAgentSessionRecord(released)
+      ? released.lease.runtimeFence
+      : undefined
+  const attached = stampFailedCreateOwnerVerdict(
+    context.deps.store,
+    callerKey,
+    params.envelope,
+    await performAttach({
+      rewind: options.rewind,
+      store: context.deps.store,
+      adapter: context.deps.adapter,
+      journalRoot: context.deps.journalRoot,
+      eventSink: eventSink.sink,
+      onAcquiring: async () => {
+        const barrier = await eventSink.drained()
+        if (!barrier.ok) {
+          throw barrier.error
         }
-      }
-      const attached = stampFailedCreateOwnerVerdict(
-        context.deps.store,
-        callerKey,
-        params.envelope,
-        await performAttach({
-          rewind,
-          store: context.deps.store,
-          adapter: context.deps.adapter,
-          journalRoot: context.deps.journalRoot,
-          eventSink: eventSink.sink,
-          onAcquiring: async () => {
-            const barrier = await eventSink.drained()
-            if (!barrier.ok) {
-              throw barrier.error
-            }
-            eventSink.unbind()
-          },
-          authority: {
-            spawnToken: () => context.deps.mintSpawnToken?.() ?? randomUUID(),
-            claimKeyId: context.deps.claimKeyId,
-            handoffOperationId: params.envelope.clientOperationId,
-            probe,
-            ...(await pinnedAgentSessionLaunchArgs(context.deps.resolveLaunchArgs, params)),
-            ...(await pinnedAgentSessionLaunchEnv(context.deps.resolveLaunchEnv, params))
-          },
-          callerKey,
-          params,
-          now: () => context.now(),
-          recordPhase,
-          // Site 9: this closes the PRIOR map entry it drops, never the provisional
-          // journal — it has no reference to that one. `onAttached` owns that.
-          onAttachFailed: async () => {
-            await forgetStructuredAgentSession(context, sessionId)
-            eventSink.close()
-            context.runtimeState.discardEventSink(sessionId)
-          },
-          onAttached: async (
-            attached,
-            acquisitionGeneration,
-            acquiredOwner,
-            providerChildPhase
-          ) => {
-            const fence = context.deps.store.getRecord(sessionId)?.lease.runtimeFence ?? 0
-            const previous = context.sessions.get(sessionId)
-            const previousFence = previous?.fence
-            // Site 8: the provisional journal has no owner until the map takes it,
-            // and the barrier below throws by design.
-            try {
-              if (acquiredOwner) {
-                // Before the drain: the buffered events are the new child's, never a stale row's.
-                await settleStaleSessionStateOnAcquire({
-                  journal: attached.journal,
-                  sessionId,
-                  fence,
-                  acquisitionGeneration
-                })
-              }
-              await bindAndDrain(eventSink, attached.journal, fence, (activity) =>
-                context.subscribers.publish(sessionId, attached.journal, activity)
-              )
-            } catch (error) {
-              await agentSessionJournalCloseRetries.closeOrRetain(attached.journal)
-              throw error
-            }
-            // Site 10: a `set` over a live entry would orphan its handle — and a
-            // close that REJECTED did not release it. The replacement is therefore
-            // ABORTED rather than completed over a handle nothing can reach again:
-            // `previous` stays indexed, so teardown still owns it and can retry.
-            if (previous && previous.journal !== attached.journal) {
-              try {
-                await previous.journal.close()
-              } catch (error) {
-                await agentSessionJournalCloseRetries.closeOrRetain(attached.journal)
-                throw error
-              }
-            }
-            context.sessions.set(sessionId, {
+        eventSink.unbind()
+      },
+      authority: {
+        spawnToken: () => context.deps.mintSpawnToken?.() ?? randomUUID(),
+        claimKeyId: context.deps.claimKeyId,
+        handoffOperationId: params.envelope.clientOperationId,
+        probe,
+        ...(await pinnedAgentSessionLaunchArgs(context.deps.resolveLaunchArgs, params)),
+        ...(await pinnedAgentSessionLaunchEnv(context.deps.resolveLaunchEnv, params))
+      },
+      callerKey,
+      params,
+      now: () => context.now(),
+      recordPhase,
+      // Site 9: this closes the PRIOR map entry it drops, never the provisional
+      // journal — it has no reference to that one. `onAttached` owns that.
+      onAttachFailed: async () => {
+        await forgetStructuredAgentSession(context, sessionId)
+        eventSink.close()
+        context.runtimeState.discardEventSink(sessionId)
+      },
+      onAttached: async (attached, acquisitionGeneration, acquiredOwner, providerChildPhase) => {
+        const fence = context.deps.store.getRecord(sessionId)?.lease.runtimeFence ?? 0
+        const previous = context.sessions.get(sessionId)
+        const previousFence = previous?.fence
+        // Site 8: the provisional journal has no owner until the map takes it,
+        // and the barrier below throws by design.
+        try {
+          if (acquiredOwner) {
+            // Before the drain: the buffered events are the new child's, never a stale row's.
+            await settleStaleSessionStateOnAcquire({
               journal: attached.journal,
-              params,
+              sessionId,
               fence,
-              hasProviderChild: true,
-              // A re-attach to a live child keeps what that child already proved.
-              providerChildPhase: acquiredOwner
-                ? providerChildPhase
-                : (previous?.providerChildPhase ?? 'ready'),
-              acquisitionGeneration:
-                acquisitionGeneration ?? previous?.acquisitionGeneration ?? null
+              acquisitionGeneration
             })
-            if (!rewind) {
-              await recoverStructuredRewind(
-                context.deps.store,
-                sessionId,
-                attached.journal,
-                fence,
-                context.deps.adapter,
-                context.now
-              )
-            }
-            await recoverInterruptedCompaction(
-              context.deps.store,
-              sessionId,
-              attached.journal,
-              fence
-            )
-            if (attached.recovery) {
-              context.subscribers.reset(sessionId, attached.journal, attached.recovery.reset, fence)
-            } else if (previousFence !== undefined && previousFence !== fence) {
-              context.subscribers.snapshot(sessionId, attached.journal, fence)
-            } else {
-              context.subscribers.publish(sessionId, attached.journal)
-            }
           }
-        }).catch((error: unknown) => {
-          // A throw is a failed attach too, and its dead child may already have queued into the
-          // unbound sink; left cached, that queue wedges the next attach's drain and shutdown.
-          discardUnattachedSink()
+          await bindAndDrain(eventSink, attached.journal, fence, (activity) =>
+            context.subscribers.publish(sessionId, attached.journal, activity)
+          )
+        } catch (error) {
+          await agentSessionJournalCloseRetries.closeOrRetain(attached.journal)
           throw error
-        })
-      )
-      if (!attached.ok) {
-        discardUnattachedSink()
-      }
-      return attached
-    })
-  const attaching =
-    params.envelope.expectedRuntimeFence === null
-      ? withAgentSessionSpan(async (span) => {
-          const startedAtMs = Date.now()
-          const phases: Parameters<AgentSessionCreatePhaseRecorder>[0][] = []
+        }
+        // Site 10: a `set` over a live entry would orphan its handle — and a
+        // close that REJECTED did not release it. The replacement is therefore
+        // ABORTED rather than completed over a handle nothing can reach again:
+        // `previous` stays indexed, so teardown still owns it and can retry.
+        if (previous && previous.journal !== attached.journal) {
           try {
-            return await run((timing) => phases.push(timing))
-          } finally {
-            addAgentSessionCreatePhaseAttributes(span, {
-              totalDurationMs: Math.max(0, Date.now() - startedAtMs),
-              phases
-            })
+            await previous.journal.close()
+          } catch (error) {
+            await agentSessionJournalCloseRetries.closeOrRetain(attached.journal)
+            throw error
           }
+        }
+        context.sessions.set(sessionId, {
+          journal: attached.journal,
+          params,
+          fence,
+          hasProviderChild: true,
+          // A re-attach to a live child keeps what that child already proved.
+          providerChildPhase: acquiredOwner
+            ? providerChildPhase
+            : (previous?.providerChildPhase ?? 'ready'),
+          acquisitionGeneration: acquisitionGeneration ?? previous?.acquisitionGeneration ?? null,
+          resumedFromFence: acquiredOwner ? resumedFromFence : previous?.resumedFromFence
         })
-      : run()
-  return context.tasks.trackAttach(attaching)
+        if (!options.rewind) {
+          await recoverStructuredRewind(
+            context.deps.store,
+            sessionId,
+            attached.journal,
+            fence,
+            context.deps.adapter,
+            context.now
+          )
+        }
+        await recoverInterruptedCompaction(context.deps.store, sessionId, attached.journal, fence)
+        if (attached.recovery) {
+          context.subscribers.reset(sessionId, attached.journal, attached.recovery.reset, fence)
+        } else if (previousFence !== undefined && previousFence !== fence) {
+          context.subscribers.snapshot(sessionId, attached.journal, fence)
+        } else {
+          context.subscribers.publish(sessionId, attached.journal)
+        }
+      }
+    }).catch((error: unknown) => {
+      // A throw is a failed attach too, and its dead child may already have queued into the
+      // unbound sink; left cached, that queue wedges the next attach's drain and shutdown.
+      discardUnattachedSink()
+      throw error
+    })
+  )
+  if (!attached.ok) {
+    discardUnattachedSink()
+  }
+  return attached
 }
 
 /** Binds the sink to the journal and waits for the barrier the host publishes
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-event-recovery.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-event-recovery.ts
index fda92f144ce2..ac569a286c29 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-event-recovery.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-event-recovery.ts
@@ -1,4 +1,4 @@
-import { attachStructuredAgentSession } from './structured-agent-session-attach-orchestration'
+import { attachStructuredAgentSessionUnderSerialize } from './structured-agent-session-attach-orchestration'
 import type { StructuredAgentSessionAttachContext } from './structured-agent-session-attach-context'
 import type { StructuredAgentSessionLifecycleEvent } from './structured-agent-session-adapter'
 import type {
@@ -73,18 +73,26 @@ export class StructuredAgentSessionEventRecovery {
     if (!ticket) {
       return
     }
+    // One serialized step with the ticket check inside it: a hold or a send that got there first
+    // has already replaced the owner, and this attach then refuses on the stale ticket rather than
+    // spawning a second child against the fence it moved.
     try {
-      await resumeHeldStructuredAgentSession({
-        sessionId: ticket.sessionId,
-        deps: this.context.deps,
-        now: this.context.now,
-        attach: (params) =>
-          attachStructuredAgentSession(
-            this.context.attachContext(),
-            'trusted-local:provider-exit-recovery',
-            params,
-            () => isStructuredAgentSessionRecoveryTicketCurrent(this.context, ticket)
-          )
+      await this.context.serialize(ticket.sessionId, () => {
+        const attachContext = this.context.attachContext()
+        return resumeHeldStructuredAgentSession({
+          sessionId: ticket.sessionId,
+          context: attachContext,
+          attach: (params) =>
+            attachStructuredAgentSessionUnderSerialize(
+              attachContext,
+              'trusted-local:provider-exit-recovery',
+              params,
+              {
+                admitRecoveryTicket: () =>
+                  isStructuredAgentSessionRecoveryTicketCurrent(this.context, ticket)
+              }
+            )
+        })
       })
     } catch (error) {
       if (isStructuredAgentSessionRecoveryTicketCurrent(this.context, ticket)) {
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-hold-resume-race.test.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-hold-resume-race.test.ts
index e410c8bb0495..2f5af0df24f9 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-hold-resume-race.test.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-hold-resume-race.test.ts
@@ -1,9 +1,17 @@
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+import { runKeyedSerializedOperation } from '../../cli/keyed-promise-queue'
 import { StructuredAgentSessionHolds } from './structured-agent-session-holds'
 
 const GRACE_MS = 15_000
 const pendingHolds: StructuredAgentSessionHolds[] = []
 
+/** The host's per-session queue: a second hold waits for the attach the first one is running. */
+function keyedSerialize() {
+  const chains = new Map<string, Promise<void>>()
+  return <T>(sessionId: string, task: () => Promise<T>) =>
+    runKeyedSerializedOperation(chains, sessionId, task)
+}
+
 function resumeHarness() {
   const resumeGate = Promise.withResolvers<void>()
   let child = false
@@ -14,10 +22,10 @@ function resumeHarness() {
   const resume = vi.fn(async () => {
     await resumeGate.promise
     child = true
-    return { fromFence: 1 }
   })
   const holds = new StructuredAgentSessionHolds({
     resume,
+    serialize: keyedSerialize(),
     hasProviderChild: () => child,
     isTurnActive: () => turnActive,
     evict,
@@ -168,35 +176,38 @@ describe('a surface leaving while its structured session resumes', () => {
     expect(evict).toHaveBeenCalledExactlyOnceWith('session-1')
   })
 
-  it('joins a pending resume for a holder that left and came back, and a failure releases it', async () => {
+  it('lets a holder that left and came back make its own attempt behind a failing one, and its failure releases it', async () => {
     const { holds, resume, resumeGate, evict } = resumeHarness()
     const first = holds.hold('session-1', 'same-holder')
     const firstRejected = expect(first).rejects.toThrow('acquisition failed')
     holds.release('session-1', 'same-holder')
     const replacement = holds.hold('session-1', 'same-holder')
     const replacementRejected = expect(replacement).rejects.toThrow('acquisition failed')
+    await vi.advanceTimersByTimeAsync(0)
     expect(holds.isHeld('session-1')).toBe(true)
     expect(resume).toHaveBeenCalledOnce()
 
+    // The gate stays rejected, so the replacement's own attempt fails the same way.
     resumeGate.reject(new Error('acquisition failed'))
     await Promise.all([firstRejected, replacementRejected])
 
+    expect(resume).toHaveBeenCalledTimes(2)
     expect(holds.isHeld('session-1')).toBe(false)
     expect(holds.isReleasePending('session-1')).toBe(false)
     await vi.advanceTimersByTimeAsync(GRACE_MS * 2)
     expect(evict).not.toHaveBeenCalled()
   })
 
-  it('keeps a hold that found the child already there when the resume that made it still fails', async () => {
+  it('keeps a re-hold that finds the child the failing attempt ahead of it left behind', async () => {
     const gate = Promise.withResolvers<void>()
     let child = false
     const holds = new StructuredAgentSessionHolds({
-      // The child is up before the resume settles, and then the resume fails behind it.
+      // The child is up before the attempt settles, and then the attempt fails behind it.
       resume: async () => {
         child = true
         await gate.promise
-        return { fromFence: 1 }
       },
+      serialize: keyedSerialize(),
       hasProviderChild: () => child,
       isTurnActive: () => false,
       evict: async () => {},
@@ -206,10 +217,13 @@ describe('a surface leaving while its structured session resumes', () => {
     const first = holds.hold('session-1', 'same-holder')
     const rejected = expect(first).rejects.toThrow('acquisition failed')
     holds.release('session-1', 'same-holder')
-    await holds.hold('session-1', 'same-holder')
+    const replacement = holds.hold('session-1', 'same-holder')
 
     gate.reject(new Error('acquisition failed'))
     await rejected
+    // The first hold's failure released only the holder it added, at the incarnation it added;
+    // the replacement then ran, found the child, and kept the holder it re-took.
+    await replacement
 
     expect(holds.isHeld('session-1')).toBe(true)
     expect(holds.isReleasePending('session-1')).toBe(false)
@@ -218,14 +232,14 @@ describe('a surface leaving while its structured session resumes', () => {
   it('starts a fresh resume once the failed one has settled', async () => {
     let child = false
     const resume = vi
-      .fn<() => Promise<{ fromFence: number }>>()
+      .fn<() => Promise<void>>()
       .mockRejectedValueOnce(new Error('first acquisition failed'))
       .mockImplementationOnce(async () => {
         child = true
-        return { fromFence: 1 }
       })
     const holds = new StructuredAgentSessionHolds({
       resume,
+      serialize: keyedSerialize(),
       hasProviderChild: () => child,
       isTurnActive: () => false,
       evict: async () => {},
@@ -234,7 +248,6 @@ describe('a surface leaving while its structured session resumes', () => {
     pendingHolds.push(holds)
 
     await expect(holds.hold('session-1', 'chat-1')).rejects.toThrow('first acquisition failed')
-    expect(holds.isResuming('session-1')).toBe(false)
     await holds.hold('session-1', 'chat-1')
 
     expect(resume).toHaveBeenCalledTimes(2)
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-hold-resume.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-hold-resume.ts
index 2bc46e40747a..6b073057e2b7 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-hold-resume.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-hold-resume.ts
@@ -1,17 +1,18 @@
-// Giving a held session its provider child back.
+// Giving a session its provider child back.
 //
 // This is the replacement for the startup resume, and the difference is only in WHO asks: the same
-// eligibility rule, run when a surface binds instead of when the app launches. A write-capable hold
-// must fail when acquisition is refused so the surface never mistakes a readable journal for a live
-// provider child.
+// eligibility rule, run when a surface binds, when a send finds the owner gone, or when a child
+// exits under an open surface — never when the app launches. It runs inside the session's
+// serialize, with the attach it is given, so the eligibility it reads is the one the attach acts
+// on. A write-capable hold must fail when acquisition is refused so the surface never mistakes a
+// readable journal for a live provider child.
 
 import type {
   AgentSessionAttachResult,
   AgentSessionMutationResult
 } from '../../../shared/agent-session-wire'
 import type { AgentSessionAttachParams } from './structured-agent-session-attach'
-import type { StructuredAgentSessionHostDeps } from './structured-agent-session-host-types'
-import type { StructuredAgentSessionResumed } from './structured-agent-session-holds'
+import type { StructuredAgentSessionAttachContext } from './structured-agent-session-attach-context'
 import { adapterSupportsRecord } from './structured-agent-session-provider-support'
 import {
   structuredAgentSessionResumeOperationId,
@@ -20,22 +21,33 @@ import {
 
 export async function resumeHeldStructuredAgentSession(input: {
   sessionId: string
-  deps: StructuredAgentSessionHostDeps
-  now: () => number
+  context: Pick<
+    StructuredAgentSessionAttachContext,
+    'deps' | 'runtimeState' | 'reconcileLeases' | 'now'
+  >
   attach: (
     params: AgentSessionAttachParams
   ) => Promise<AgentSessionMutationResult<AgentSessionAttachResult>>
-}): Promise<StructuredAgentSessionResumed> {
-  const record = input.deps.store.getRecord(input.sessionId)
+}): Promise<void> {
+  const { sessionId, context } = input
+  // The record is read only once this host has adjudicated it and exited any recovery stage a
+  // failed attempt latched — a lease left in `manual-recovery` by an unproven exit is one the
+  // resolver hands back, and the eligibility below must see it that way.
+  const unreconciled = await context.reconcileLeases(sessionId)
+  if (unreconciled) {
+    throw new Error(unreconciled.code)
+  }
+  await context.runtimeState.resolveRecovery(sessionId)
+  const record = context.deps.store.getRecord(sessionId)
   if (!record) {
     throw new Error('agent_session_identity_required')
   }
-  if (!adapterSupportsRecord(input.deps.adapter, record)) {
+  if (!adapterSupportsRecord(context.deps.adapter, record)) {
     throw new Error('structured_agent_session_unsupported')
   }
   const params = structuredAgentSessionResumeParams(
     record,
-    structuredAgentSessionResumeOperationId(input.now())
+    structuredAgentSessionResumeOperationId(context.now())
   )
   if (!params) {
     throw new Error(
@@ -50,5 +62,4 @@ export async function resumeHeldStructuredAgentSession(input: {
   if (!attached.ok) {
     throw new Error(attached.refusal.code)
   }
-  return { fromFence: record.lease.runtimeFence }
 }
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-holds.test.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-holds.test.ts
index 6742720838db..2157256c5353 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-holds.test.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-holds.test.ts
@@ -2,6 +2,7 @@
 // deadline that keeps teardown from hanging.
 
 import { afterEach, describe, expect, it, vi } from 'vitest'
+import { runKeyedSerializedOperation } from '../../cli/keyed-promise-queue'
 import { StructuredAgentSessionHolders } from './structured-agent-session-holders'
 import { StructuredAgentSessionReleaseClock } from './structured-agent-session-release-clock'
 import { StructuredAgentSessionHolds } from './structured-agent-session-holds'
@@ -16,6 +17,13 @@ import {
 
 const clocks: StructuredAgentSessionReleaseClock[] = []
 
+/** The host's per-session queue, so a hold and a writer really take turns. */
+function keyedSerialize() {
+  const chains = new Map<string, Promise<void>>()
+  return <T>(sessionId: string, task: () => Promise<T>) =>
+    runKeyedSerializedOperation(chains, sessionId, task)
+}
+
 function clock(deps: {
   isTurnActive?: () => boolean
   isHeld?: () => boolean
@@ -170,10 +178,10 @@ describe('holds', () => {
     let child = false
     const resume = vi.fn(async () => {
       child = true
-      return { fromFence: 1 }
     })
     const holds = new StructuredAgentSessionHolds({
       resume,
+      serialize: keyedSerialize(),
       hasProviderChild: () => child,
       isTurnActive: () => false,
       evict: async () => {},
@@ -192,41 +200,64 @@ describe('holds', () => {
     holds.dispose()
   })
 
-  it('runs one resume for a hold and a writer that ask in the same gap', async () => {
+  it('runs one resume for a writer and a hold that ask in the same gap', async () => {
     const gate = Promise.withResolvers<void>()
     let child = false
     const resume = vi.fn(async () => {
       await gate.promise
       child = true
-      return { fromFence: 7 }
     })
+    const serialize = keyedSerialize()
     const holds = new StructuredAgentSessionHolds({
       resume,
+      serialize,
       hasProviderChild: () => child,
       isTurnActive: () => false,
       evict: async () => {},
       graceMs: 1
     })
 
-    const writer = holds.resumeUnheld('session-1')
-    expect(holds.isResuming('session-1')).toBe(true)
+    // A send's ensure-owner step: already inside the session's serialize when it asks.
+    const writer = serialize('session-1', () => holds.ensureProviderChild('session-1'))
     const hold = holds.hold('session-1', 'chat-1')
     gate.resolve()
 
-    await expect(writer).resolves.toEqual({ fromFence: 7 })
+    await expect(writer).resolves.toBeUndefined()
     await hold
+    // The hold ran after the writer's step and found the child: nothing to resume.
     expect(resume).toHaveBeenCalledOnce()
-    expect(holds.isResuming('session-1')).toBe(false)
     // The surface arrived while the writer's resume ran, so the child it got is held, not idle.
     expect(holds.isHeld('session-1')).toBe(true)
     expect(holds.isReleasePending('session-1')).toBe(false)
     holds.dispose()
   })
 
+  it('puts a child a writer resumed with no surface on the idle clock', async () => {
+    let child = false
+    const serialize = keyedSerialize()
+    const holds = new StructuredAgentSessionHolds({
+      resume: async () => {
+        child = true
+      },
+      serialize,
+      hasProviderChild: () => child,
+      isTurnActive: () => false,
+      evict: async () => {},
+      graceMs: 60_000
+    })
+
+    await serialize('session-1', () => holds.ensureProviderChild('session-1'))
+
+    expect(holds.isHeld('session-1')).toBe(false)
+    expect(holds.isReleasePending('session-1')).toBe(true)
+    holds.dispose()
+  })
+
   it('never arms the clock for a session with nothing to stop', async () => {
     const evict = vi.fn(async () => {})
     const holds = new StructuredAgentSessionHolds({
-      resume: async () => ({ fromFence: 1 }),
+      resume: async () => {},
+      serialize: keyedSerialize(),
       hasProviderChild: () => false,
       isTurnActive: () => false,
       evict,
@@ -244,7 +275,8 @@ describe('holds', () => {
 
   it('fails a write-capable hold when resume proves no provider child', async () => {
     const holds = new StructuredAgentSessionHolds({
-      resume: async () => ({ fromFence: 1 }),
+      resume: async () => {},
+      serialize: keyedSerialize(),
       hasProviderChild: () => false,
       isTurnActive: () => false,
       evict: async () => {},
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-holds.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-holds.ts
index 8212f64068c0..362119d1e0d7 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-holds.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-holds.ts
@@ -10,10 +10,11 @@
 // not the mechanism: a client that vanishes mid-flight never sends its release, so the caller
 // registers one against the connection and the holder set absorbs the duplicate.
 //
-// A send to a childless session resumes it too, through the same single-flight: whoever asks first
-// starts the one resume, and everyone who asks while it runs shares its outcome. Two resumes for
-// one session would each attach against the same released fence, and the loser's stale fence
-// refuses it — a hold that lost dropped its holder, a send that lost was refused.
+// A send to a childless session resumes it too, and so does provider-exit recovery under an open
+// surface. All three go through `ensureProviderChild` inside the session's serialize, so they take
+// turns: the first to run attaches, and the next finds the child and attaches nothing. Two attaches
+// for one session would race against the same released fence, and the loser's stale fence refused
+// it — a hold that lost dropped its holder, a send that lost was refused.
 
 import {
   StructuredAgentSessionReleaseClock,
@@ -21,12 +22,11 @@ import {
 } from './structured-agent-session-release-clock'
 import { StructuredAgentSessionHolders } from './structured-agent-session-holders'
 
-/** A resume moves the fence; a writer that was current as of the lost owner rebases from here. */
-export type StructuredAgentSessionResumed = { fromFence: number }
-
 export type StructuredAgentSessionHoldsDeps = {
-  /** Acquires a provider child for a session that has none. Throws the refusal code when it cannot. */
-  resume: (sessionId: string) => Promise<StructuredAgentSessionResumed>
+  /** Attaches a provider child, for a caller already inside `serialize`. Throws the refusal code
+   *  when it cannot. */
+  resume: (sessionId: string) => Promise<void>
+  serialize: <T>(sessionId: string, task: () => Promise<T>) => Promise<T>
   /** Whether evicting this session would actually free anything. */
   hasProviderChild: (sessionId: string) => boolean
   isTurnActive: (sessionId: string) => boolean
@@ -44,7 +44,6 @@ export type StructuredAgentSessionHoldOptions = {
 export class StructuredAgentSessionHolds {
   private readonly holders = new StructuredAgentSessionHolders()
   private readonly clock: StructuredAgentSessionReleaseClock
-  private readonly resumes = new Map<string, Promise<StructuredAgentSessionResumed>>()
   private disposed = false
 
   constructor(private readonly deps: StructuredAgentSessionHoldsDeps) {
@@ -72,36 +71,32 @@ export class StructuredAgentSessionHolds {
     if (options.resume === false) {
       return
     }
-    if (!this.deps.hasProviderChild(sessionId)) {
-      try {
-        await this.resumeUnheld(sessionId)
-      } catch (error) {
-        if (!alreadyHeld && incarnation !== undefined) {
-          this.release(sessionId, holderId, incarnation)
-        }
-        throw error
+    try {
+      await this.deps.serialize(sessionId, () => this.ensureProviderChild(sessionId))
+    } catch (error) {
+      // Only the holder this call added, at the incarnation it added: a same-ID hold that left
+      // and came back while this one waited owns the holder now, and its own attempt decides it.
+      if (!alreadyHeld && incarnation !== undefined) {
+        this.release(sessionId, holderId, incarnation)
       }
+      throw error
     }
   }
 
-  /** Resumes a childless session, or joins the resume already running for it. With no surface
-   *  holding it afterwards, the child is released on the same clock a departed surface would start. */
-  resumeUnheld(sessionId: string): Promise<StructuredAgentSessionResumed> {
-    const inFlight = this.resumes.get(sessionId)
-    if (inFlight) {
-      return inFlight
+  /**
+   * Gives the session a provider child if it has none.
+   *
+   * For a caller already inside the session's serialize, which is what makes "if it has none"
+   * exact: a hold and a send that both find the owner gone run this in turn, and the second sees
+   * the first one's child. Each caller makes at most one attach, and a failed one leaves the
+   * next caller to make its own. With no surface holding the session afterwards, the child goes
+   * on the same clock a departed surface would start.
+   */
+  async ensureProviderChild(sessionId: string): Promise<void> {
+    if (this.deps.hasProviderChild(sessionId)) {
+      return
     }
-    const resume = this.resumeOnce(sessionId).finally(() => this.resumes.delete(sessionId))
-    this.resumes.set(sessionId, resume)
-    return resume
-  }
-
-  isResuming(sessionId: string): boolean {
-    return this.resumes.has(sessionId)
-  }
-
-  private async resumeOnce(sessionId: string): Promise<StructuredAgentSessionResumed> {
-    const resumed = await this.deps.resume(sessionId)
+    await this.deps.resume(sessionId)
     if (!this.deps.hasProviderChild(sessionId)) {
       throw new Error('agent_session_ownership_unknown')
     }
@@ -109,7 +104,6 @@ export class StructuredAgentSessionHolds {
     if (!this.disposed && !this.holders.isHeld(sessionId)) {
       this.clock.arm(sessionId)
     }
-    return resumed
   }
 
   /** Journal activity; only an unheld session's pending release notices. */
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-host-lifetime.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-host-lifetime.ts
index a6c54479e836..d539784f0bea 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-host-lifetime.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-host-lifetime.ts
@@ -12,10 +12,7 @@ import {
   type StructuredAgentSessionEvictionContext
 } from './structured-agent-session-eviction'
 import { withStructuredAgentSessionEvictionDeadline } from './structured-agent-session-eviction-deadline'
-import {
-  StructuredAgentSessionHolds,
-  type StructuredAgentSessionResumed
-} from './structured-agent-session-holds'
+import { StructuredAgentSessionHolds } from './structured-agent-session-holds'
 import type { StructuredAgentSessionHostRuntimeState } from './structured-agent-session-host-runtime-state'
 import type {
   StructuredAgentSessionHostDeps,
@@ -23,7 +20,8 @@ import type {
 } from './structured-agent-session-host-types'
 import { releaseStoredStructuredAgentSessionOwner } from './structured-agent-session-lease-release'
 import { resumeHeldStructuredAgentSession } from './structured-agent-session-hold-resume'
-import type { AgentSessionWireRefusal } from '../../../shared/agent-session-wire'
+import type { StructuredAgentSessionAttachContext } from './structured-agent-session-attach-context'
+import { attachStructuredAgentSessionUnderSerialize } from './structured-agent-session-attach-orchestration'
 import { settleStructuredAgentSessionDeadGeneration } from './structured-agent-session-dead-generation-settlement'
 
 export type StructuredAgentSessionLifetimeContext = {
@@ -168,43 +166,25 @@ export async function evictOwnedStructuredAgentSessions(
   }
 }
 
-/** The first hold on a childless session: reconcile the lease, settle recovery, then attach. */
-export async function resumeStructuredAgentSessionForHold(
-  context: StructuredAgentSessionLifetimeContext & {
-    reconcileLeases: (sessionId: string) => Promise<AgentSessionWireRefusal | null>
-  },
-  sessionId: string,
-  attach: Parameters<typeof resumeHeldStructuredAgentSession>[0]['attach']
-): Promise<StructuredAgentSessionResumed> {
-  const unreconciled = await context.reconcileLeases(sessionId)
-  if (unreconciled) {
-    throw new Error(unreconciled.code)
-  }
-  await context.runtimeState.resolveRecovery(sessionId)
-  return resumeHeldStructuredAgentSession({
-    sessionId,
-    deps: context.deps,
-    now: context.now,
-    attach
-  })
-}
-
+/** The holds resume through the host's own attach, inside the session's serialize: a hold's
+ *  resume and a send's ensure-owner step are the same serialized attach with a different asker. */
 export function createStructuredAgentSessionHolds(
-  context: StructuredAgentSessionLifetimeContext,
-  input: {
-    reconcileLeases: (sessionId: string) => Promise<AgentSessionWireRefusal | null>
-    attach: Parameters<typeof resumeHeldStructuredAgentSession>[0]['attach']
-    close: (sessionId: string) => Promise<void>
-  }
+  attachContext: () => StructuredAgentSessionAttachContext,
+  close: (sessionId: string) => Promise<void>
 ): StructuredAgentSessionHolds {
+  const context = attachContext()
   return new StructuredAgentSessionHolds({
-    resume: (sessionId) =>
-      resumeStructuredAgentSessionForHold(
-        { ...context, reconcileLeases: input.reconcileLeases },
+    resume: (sessionId) => {
+      const current = attachContext()
+      return resumeHeldStructuredAgentSession({
         sessionId,
-        input.attach
-      ),
-    evict: input.close,
+        context: current,
+        attach: (params) =>
+          attachStructuredAgentSessionUnderSerialize(current, 'trusted-local:surface-hold', params)
+      })
+    },
+    serialize: (sessionId, task) => attachContext().serialize(sessionId, task),
+    evict: close,
     hasProviderChild: (sessionId) => hasProviderChild(context, sessionId),
     isTurnActive: (sessionId) => {
       const session = context.sessions.get(sessionId)
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-host-mutations.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-host-mutations.ts
index 3b7e56a1379d..9c1ea582ec96 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-host-mutations.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-host-mutations.ts
@@ -1,10 +1,10 @@
-import { rewindRefusal } from './structured-rewind-refusal'
-// Everything a client can ask an ALREADY-ATTACHED session to do: send a turn, cancel one, answer a
-// prompt, change an option, read the options back.
+// Everything a client can ask an ATTACHED session to do: send a turn, cancel one, answer a prompt,
+// change an option, read the options back.
 //
 // They share one shape — admit the envelope against the lease, run a plan, publish the journal — so
 // they share one path here rather than five copies in the host. The host keeps attach, holds and
-// teardown; this is the surface that assumes those already happened.
+// teardown. A send is the one mutation that may need those first: it makes sure the session has
+// an owner as a step of its own serialized admission, see `structured-agent-session-send-preparation`.
 
 import type {
   AgentJournalItemIdentity,
@@ -17,12 +17,17 @@ import type {
   AgentSessionOptionResult,
   AgentSessionOptionsResult,
   AgentSessionPromptResult,
-  AgentSessionSendResult,
-  AgentSessionWireRefusal
+  AgentSessionSendResult
 } from '../../../shared/agent-session-wire'
-import type { AgentSessionRecord } from '../../../shared/agent-session-record'
 import type { StructuredAgentSessionHolds } from './structured-agent-session-holds'
-import { admitAndRunAgentSessionMutation } from './structured-agent-session-mutation-admission'
+import {
+  admitAndRunAgentSessionMutation,
+  type AgentSessionMutationRequest
+} from './structured-agent-session-mutation-admission'
+import {
+  prepareStructuredAgentSessionSend,
+  structuredAgentSessionSendBlock
+} from './structured-agent-session-send-preparation'
 import {
   cancelPlan,
   promptPlan,
@@ -44,9 +49,11 @@ export type StructuredAgentSessionMutationContext = {
   hasPendingStreamedEvents?: (sessionId: string) => boolean
   requireSession: (sessionId: string) => StructuredAgentSessionHostSession
   serialize: <T>(sessionId: string, task: () => Promise<T>) => Promise<T>
-  /** The one resume a session may have running: a send restarts a lost owner through it, and joins
-   *  one a surface hold already started. */
-  resumes: Pick<StructuredAgentSessionHolds, 'resumeUnheld' | 'isResuming'>
+  /** A send that finds the owner gone brings it back through here, inside its own serialize. */
+  holds: Pick<StructuredAgentSessionHolds, 'ensureProviderChild'>
+  /** Makes a closed session's journal readable again, inside the caller's serialize, for a send
+   *  the ledger answers without an owner. */
+  restoreReadable: (sessionId: string) => Promise<boolean>
   now: () => number
 }
 
@@ -54,7 +61,8 @@ function mutate<TValue>(
   context: StructuredAgentSessionMutationContext,
   caller: StructuredAgentSessionCaller,
   envelope: AgentSessionMutationEnvelope,
-  plan: MutationPlan<TValue>
+  plan: MutationPlan<TValue>,
+  prepareSession?: AgentSessionMutationRequest<TValue>['prepareSession']
 ): Promise<AgentSessionMutationResult<TValue>> {
   return context.serialize(envelope.sessionId, () =>
     admitAndRunAgentSessionMutation({
@@ -63,7 +71,8 @@ function mutate<TValue>(
       callerKey: caller.callerKey,
       envelope,
       plan,
-      journal: context.sessions.get(envelope.sessionId)?.journal,
+      journal: () => context.sessions.get(envelope.sessionId)?.journal,
+      prepareSession,
       publish: (journal) => context.publish(envelope.sessionId, journal),
       flushStreamedEvents: context.flushStreamedEvents,
       hasPendingStreamedEvents: context.hasPendingStreamedEvents,
@@ -83,40 +92,19 @@ export function sendStructuredAgentSessionTurn(
   }
 ): Promise<AgentSessionMutationResult<AgentSessionSendResult>> {
   const plan = sendPlan(params)
-  return mutate(context, caller, params.envelope, {
-    ...plan,
-    run: (ctx) => {
-      const blocked = structuredAgentSessionSendBlock(context.deps.store.getRecord(ctx.sessionId))
-      return blocked ? Promise.resolve(blocked) : plan.run(ctx)
-    }
-  })
-}
-
-/** Why the record refuses any send right now, whoever owns it; null when a send may run. */
-export function structuredAgentSessionSendBlock(
-  record: AgentSessionRecord | null
-): { ok: false; refusal: AgentSessionWireRefusal } | null {
-  const rewind = record?.rewind
-  if (rewind?.phase === 'prepared' || rewind?.phase === 'provider-succeeded') {
-    return rewindRefusal('outcome-unknown')
-  }
-  const command = record?.conversationCommand
-  if (
-    command &&
-    ((command.state === 'unknown' && command.phase === 'prepared') ||
-      (command.command === 'clear' && command.replacementSessionId))
-  ) {
-    return {
-      ok: false,
-      refusal: {
-        code: 'agent_session_operation_invalid',
-        message: command.replacementSessionId
-          ? 'This conversation has been cleared. Use the current conversation.'
-          : 'The conversation operation is unconfirmed.'
+  return mutate(
+    context,
+    caller,
+    params.envelope,
+    {
+      ...plan,
+      run: (ctx) => {
+        const blocked = structuredAgentSessionSendBlock(context.deps.store.getRecord(ctx.sessionId))
+        return blocked ? Promise.resolve(blocked) : plan.run(ctx)
       }
-    }
-  }
-  return null
+    },
+    (ledger, record) => prepareStructuredAgentSessionSend(context, params.envelope, ledger, record)
+  )
 }
 
 export function cancelStructuredAgentSessionTurn(
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-host-types.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-host-types.ts
index d79237e1337d..a3d207e72b9a 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-host-types.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-host-types.ts
@@ -45,6 +45,10 @@ export type StructuredAgentSessionHostSession = {
   owesProviderChildWindDown?: boolean
   /** Exact adapter acquisition behind `hasProviderChild`; retained after exit to fence recovery. */
   acquisitionGeneration: string | null
+  /** The fence of the released owner this child replaced, when it was resumed into a lease handed
+   *  back cleanly. A writer current as of that owner is admitted at `fence`: the restart is the
+   *  only thing that moved it. Absent for a create, a handoff, or a journal restored for reading. */
+  resumedFromFence?: number
 }
 
 export type StructuredAgentSessionHostDeps = {
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-host.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-host.ts
index 0da5f213f871..d9a7cf61b6e2 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-host.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-host.ts
@@ -119,11 +119,10 @@ export class StructuredAgentSessionHost {
       publishStatus: this.clientDelivery.publishStatus,
       now: this.now
     })
-    this.holds = createStructuredAgentSessionHolds(this.lifetimeContext(), {
-      reconcileLeases: this.reconcileLeases,
-      attach: (params) => this.attach({ callerKey: 'trusted-local:surface-hold' }, params),
-      close: (sessionId) => this.close(sessionId)
-    })
+    this.holds = createStructuredAgentSessionHolds(
+      () => this.attachContext(),
+      (sessionId) => this.close(sessionId)
+    )
     this.restore = createStructuredAgentSessionHostRestore(deps, this.sessions, () => this.now(), {
       reconcile: this.reconcileLeases,
       resolveRecovery: (sessionId) => this.runtimeState.resolveRecovery(sessionId),
@@ -278,7 +277,8 @@ export class StructuredAgentSessionHost {
         this.runtimeState.hasPendingStreamedEvents(sessionId),
       requireSession: (sessionId) => this.requireSession(sessionId),
       serialize: (sessionId, task) => this.serialize(sessionId, task),
-      resumes: this.holds,
+      holds: this.holds,
+      restoreReadable: (sessionId) => this.restore.restoreReadableUnderSerialize(sessionId),
       now: () => this.now()
     }
   }
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-mutation-admission.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-mutation-admission.ts
index ca1ddb7b8da0..81eedfd11890 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-mutation-admission.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-mutation-admission.ts
@@ -2,12 +2,19 @@
 // fingerprint, admit through the durable operation ledger, check the lease, then
 // run the plan. It lives outside the host so that no method can quietly grow its
 // own admission rules by sitting next to the call site.
+//
+// Admission is two-phase for a call that brings a `prepareSession`. The ledger's
+// answer comes first and places nothing; a call it will admit may then give the
+// session an owner, and only after that are the row placed and the lease and
+// fence checked — against the lease as it stands once the owner is there.
 
 import {
   admitAgentSessionMutation,
   agentSessionFingerprintConflict,
   computeAgentSessionPayloadFingerprint
 } from '../../../shared/agent-session-mutation-envelope'
+import type { AgentSessionOperationDecision } from '../../../shared/agent-session-operation-ledger'
+import type { AgentSessionRecord } from '../../../shared/agent-session-record'
 import type {
   AgentSessionMutationEnvelope,
   AgentSessionMutationResult,
@@ -36,14 +43,25 @@ export function refuseAgentSessionMutation(refusal: AgentSessionWireRefusal): {
   return { ok: false, refusal }
 }
 
+export type AgentSessionMutationSessionPreparation =
+  | { ok: true; envelope: AgentSessionMutationEnvelope }
+  | { ok: false; refusal: AgentSessionWireRefusal }
+
 export type AgentSessionMutationRequest<TValue> = {
   store: AgentSessionRecordStore
   adapter: StructuredAgentSessionAdapter
   callerKey: string
   envelope: AgentSessionMutationEnvelope
   plan: MutationPlan<TValue>
-  /** Journal of the attached session; absent when this host holds none. */
-  journal: AgentSessionJournal | undefined
+  /** Journal of the attached session, read after `prepareSession`; absent when this host holds none. */
+  journal: () => AgentSessionJournal | undefined
+  /** Between the ledger's answer and the lease check, for a call that may first have to make the
+   *  session ready for itself. Answers with the envelope to admit — the caller's, or one moved
+   *  onto a fence the preparation itself published — or with the refusal that ends the call. */
+  prepareSession?: (
+    ledger: Exclude<AgentSessionOperationDecision['decision'], 'refused'>,
+    record: AgentSessionRecord
+  ) => Promise<AgentSessionMutationSessionPreparation>
   publish: (journal: AgentSessionJournal) => void
   flushStreamedEvents: (sessionId: string) => Promise<void>
   hasPendingStreamedEvents?: (sessionId: string) => boolean
@@ -53,10 +71,8 @@ export type AgentSessionMutationRequest<TValue> = {
 export async function admitAndRunAgentSessionMutation<TValue>(
   request: AgentSessionMutationRequest<TValue>
 ): Promise<AgentSessionMutationResult<TValue>> {
-  const { envelope, plan, journal } = request
-  if (!journal) {
-    return refuseAgentSessionMutation(AGENT_SESSION_NOT_ATTACHED)
-  }
+  const { plan } = request
+  let { envelope } = request
   const hostFingerprint = computeAgentSessionPayloadFingerprint({
     method: plan.method,
     sessionId: envelope.sessionId,
@@ -66,6 +82,29 @@ export async function admitAndRunAgentSessionMutation<TValue>(
   if (conflict) {
     return refuseAgentSessionMutation(conflict)
   }
+  if (request.prepareSession) {
+    const ledger = request.store.evaluateMutationOperation({
+      callerKey: request.callerKey,
+      envelope,
+      hostFingerprint,
+      now: request.now(),
+      ...(plan.operationIdScope ? { operationIdScope: plan.operationIdScope } : {})
+    })
+    if (!ledger) {
+      return refuseAgentSessionMutation(AGENT_SESSION_NOT_ATTACHED)
+    }
+    if (ledger.decision.decision !== 'refused') {
+      const prepared = await request.prepareSession(ledger.decision.decision, ledger.record)
+      if (!prepared.ok) {
+        return prepared
+      }
+      envelope = prepared.envelope
+    }
+  }
+  const journal = request.journal()
+  if (!journal) {
+    return refuseAgentSessionMutation(AGENT_SESSION_NOT_ATTACHED)
+  }
   const admitted = await request.store.admitMutationOperation({
     callerKey: request.callerKey,
     envelope,
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-readable-restorer.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-readable-restorer.ts
index a0bb32ad7374..a0099be32a71 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-readable-restorer.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-readable-restorer.ts
@@ -4,6 +4,7 @@ import type { AgentSessionRecordStore } from '../../runtime/agent-session-record
 import type { RestoredStructuredAgentSessionRead } from './structured-agent-session-read-restore'
 import {
   restoreOneStructuredAgentSessionRead,
+  restoreOneStructuredAgentSessionReadUnderSerialize,
   restoreStructuredAgentSessionsOnRestart
 } from './structured-agent-session-restart-restore'
 
@@ -48,14 +49,29 @@ export class StructuredAgentSessionReadableRestorer {
    * answers for Claude and Codex from the record's own provider.
    */
   async restoreOne(sessionId: string): Promise<boolean> {
-    const record = this.input.store.getRecord(sessionId)
-    if (!record || !this.input.supportsRecord(record)) {
+    if (!this.supports(sessionId)) {
       return false
     }
     await restoreOneStructuredAgentSessionRead(this.input, sessionId)
     return this.input.hasSession(sessionId)
   }
 
+  /** `restoreOne` for a caller already inside the session's serialize. Reconciliation is skipped
+   *  on purpose: a lease this host has not adjudicated is the attach's problem, and a replay
+   *  needs only the journal. */
+  async restoreOneUnderSerialize(sessionId: string): Promise<boolean> {
+    if (!this.supports(sessionId)) {
+      return false
+    }
+    await restoreOneStructuredAgentSessionReadUnderSerialize(this.input, sessionId)
+    return this.input.hasSession(sessionId)
+  }
+
+  private supports(sessionId: string): boolean {
+    const record = this.input.store.getRecord(sessionId)
+    return record !== null && this.input.supportsRecord(record)
+  }
+
   private async restoreReadableSessions(sessionIds?: readonly string[]): Promise<void> {
     const targetOrder = sessionIds
       ? new Map(sessionIds.map((sessionId, index) => [sessionId, index]))
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-restart-restore.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-restart-restore.ts
index 7e697efbdc73..8cc202b28c76 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-restart-restore.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-restart-restore.ts
@@ -53,24 +53,36 @@ export async function restoreOneStructuredAgentSessionRead(
     // A session latched in recovery exits here at startup, without waiting for a client.
     await input.resolveRecovery(sessionId)
   }
-  await input.serialize(sessionId, async () => {
-    if (input.hasSession(sessionId)) {
-      // A surface that took a hold mid-restore already attached this one.
-      await input.restoreHandoff(sessionId)
-      return
-    }
-    const restored = await restoreStructuredAgentSessionRead(
-      input.store,
-      input.journalRoot,
-      sessionId
-    )
-    if (!restored) {
-      return
-    }
-    input.onReadable(sessionId, restored)
-    await input.retrySettlement(sessionId, restored.params)
+  await input.serialize(sessionId, () =>
+    restoreOneStructuredAgentSessionReadUnderSerialize(input, sessionId)
+  )
+}
+
+/** The serialized half of the restore, for a caller already inside the session's serialize — a
+ *  send replaying into a session this host has closed, which needs the journal and no child. */
+export async function restoreOneStructuredAgentSessionReadUnderSerialize(
+  input: Pick<
+    StructuredAgentSessionReadRestoreDeps,
+    'store' | 'journalRoot' | 'hasSession' | 'onReadable' | 'retrySettlement' | 'restoreHandoff'
+  >,
+  sessionId: string
+): Promise<void> {
+  if (input.hasSession(sessionId)) {
+    // A surface that took a hold mid-restore already attached this one.
     await input.restoreHandoff(sessionId)
-  })
+    return
+  }
+  const restored = await restoreStructuredAgentSessionRead(
+    input.store,
+    input.journalRoot,
+    sessionId
+  )
+  if (!restored) {
+    return
+  }
+  input.onReadable(sessionId, restored)
+  await input.retrySettlement(sessionId, restored.params)
+  await input.restoreHandoff(sessionId)
 }
 
 export async function restoreStructuredAgentSessionsOnRestart(
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-reveal.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-reveal.ts
index d940fb323bd1..8676e86acfbb 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-reveal.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-reveal.ts
@@ -66,6 +66,8 @@ export function createStructuredAgentSessionHostRestore(
 ): {
   restoreReadableSessions: (sessionIds?: readonly string[]) => Promise<void>
   revealSession: (sessionId: string) => Promise<StructuredAgentSessionReveal>
+  /** One session, for a caller already inside its serialize. */
+  restoreReadableUnderSerialize: (sessionId: string) => Promise<boolean>
 } {
   const restorer = new StructuredAgentSessionReadableRestorer({
     store: deps.store,
@@ -81,6 +83,7 @@ export function createStructuredAgentSessionHostRestore(
     revealSession: (sessionId) =>
       revealStructuredAgentSession(deps, sessionId, wiring.hasSession, (id) =>
         restorer.restoreOne(id)
-      )
+      ),
+    restoreReadableUnderSerialize: (sessionId) => restorer.restoreOneUnderSerialize(sessionId)
   }
 }
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-rewind.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-rewind.ts
index c301845c7c13..2229016e4d4b 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-rewind.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-rewind.ts
@@ -36,7 +36,7 @@ export async function rewindStructuredAgentSession(
       adapter: context.deps.adapter,
       callerKey: caller.callerKey,
       envelope: params.envelope,
-      journal: context.sessions.get(sessionId)?.journal,
+      journal: () => context.sessions.get(sessionId)?.journal,
       publish: (journal) => context.publish(sessionId, journal),
       flushStreamedEvents: context.flushStreamedEvents,
       now: context.now,
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-send-recovery.test.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-send-preparation.test.ts
similarity index 85%
rename from src/main/native-chat/agent-session-wire/structured-agent-session-send-recovery.test.ts
rename to src/main/native-chat/agent-session-wire/structured-agent-session-send-preparation.test.ts
index 222afbfc7c78..5f611bbb5221 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-send-recovery.test.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-send-preparation.test.ts
@@ -1,4 +1,4 @@
-// A send to a session whose provider child is gone, against the real host.
+// A send, or a hold, that finds the session's provider child gone, against the real host.
 
 import { mkdtemp, rm } from 'node:fs/promises'
 import { tmpdir } from 'node:os'
@@ -10,7 +10,6 @@ import type { AgentSessionMutationEnvelope } from '../../../shared/agent-session
 import { AgentSessionRecordStore } from '../../runtime/agent-session-record-store'
 import type { StructuredAgentSessionAdapter } from './structured-agent-session-adapter'
 import { StructuredAgentSessionHost } from './structured-agent-session-host'
-import { StructuredAgentSessionSendRecovery } from './structured-agent-session-send-recovery'
 import {
   HOST_TEST_NOW as NOW,
   HOST_TEST_SESSION as SESSION,
@@ -123,26 +122,26 @@ describe('a send with no live owner', () => {
     expect(store.getRecord(SESSION)?.lease.claimStatus).toBe('live')
   })
 
-  it('restarts the owner before the send is admitted, so the send runs once', async () => {
+  it('restarts the owner before the send is admitted, so the send is admitted once', async () => {
     await loseOwner()
     const order: string[] = []
-    const recovery = new StructuredAgentSessionSendRecovery({
-      getRecord: (sessionId) => store.getRecord(sessionId),
-      isAttached: () => true,
-      hasLedgerRow: () => false,
-      isResuming: () => false,
-      resume: async () => {
-        order.push('resume')
-        return { fromFence: 1 }
-      }
+    const spawnChild = acquire.getMockImplementation()!
+    acquire.mockImplementationOnce(async (input) => {
+      order.push('acquire')
+      return spawnChild(input)
+    })
+    const admit = store.admitMutationOperation
+    vi.spyOn(store, 'admitMutationOperation').mockImplementation((args) => {
+      order.push('admit')
+      return admit(args)
     })
 
-    await recovery.send(sendParams('ensure first'), async () => {
-      order.push('run')
-      return { ok: false, refusal: { code: 'agent_session_operation_invalid', message: 'stub' } }
+    await expect(host.send(CALLER, sendParams('ensure first'))).resolves.toMatchObject({
+      ok: true,
+      replayed: false
     })
 
-    expect(order).toEqual(['resume', 'run'])
+    expect(order).toEqual(['acquire', 'admit'])
   })
 
   it('leaves a live owner alone', async () => {
@@ -363,7 +362,7 @@ describe('a send with no live owner', () => {
     expect(host['holds'].isReleasePending(SESSION)).toBe(false)
   })
 
-  it('reopens a closed session once for a replay, and never runs the send again', async () => {
+  it('replays into a closed session without spawning anything', async () => {
     const params = sendParams('sent once')
     await expect(host.send(CALLER, params)).resolves.toMatchObject({ ok: true, replayed: false })
     await loseOwner()
@@ -371,10 +370,12 @@ describe('a send with no live owner', () => {
     await expect(host.send(CALLER, params)).resolves.toMatchObject({ ok: true, replayed: true })
     await expect(host.send(CALLER, params)).resolves.toMatchObject({ ok: true, replayed: true })
 
-    expect(acquire).toHaveBeenCalledOnce()
+    // The journal was made readable for the answer; the record's lease was left as it was.
+    expect(host.hasSession(SESSION)).toBe(true)
+    expect(acquire).not.toHaveBeenCalled()
     expect(dispatch).toHaveBeenCalledOnce()
-    // The reopened child is nobody's: it goes on the idle clock like any unheld restart.
-    expect(host['holds'].isReleasePending(SESSION)).toBe(true)
+    expect(store.getRecord(SESSION)?.lease.claimStatus).toBe('released')
+    expect(host['holds'].isReleasePending(SESSION)).toBe(false)
   })
 
   it('refuses for good when the owner cannot be restarted', async () => {
@@ -397,6 +398,42 @@ describe('a send with no live owner', () => {
     ).toBe('settled-rejected')
   })
 
+  it('keeps a second surface holder taken during an auto-restart, and starts nothing for it', async () => {
+    await host.hold(SESSION, 'desktop-chat:1')
+    const exitedFence = store.getRecord(SESSION)?.lease.runtimeFence ?? 0
+    acquire.mockClear()
+    const entered = Promise.withResolvers<void>()
+    const gate = Promise.withResolvers<void>()
+    const spawnChild = acquire.getMockImplementation()!
+    acquire.mockImplementationOnce(async (input) => {
+      entered.resolve()
+      await gate.promise
+      return spawnChild(input)
+    })
+
+    // The held child exits: the host restarts it on its own, under the surface that holds it.
+    const restarted = host.handleAdapterEvent({
+      type: 'ended',
+      sessionId: SESSION,
+      reason: 'provider exited',
+      cause: 'unexpected-exit',
+      fence: exitedFence,
+      acquisitionGeneration: 'generation-1'
+    })
+    await entered.promise
+    const second = host.hold(SESSION, 'paired-phone:1')
+    gate.resolve()
+    await Promise.all([restarted, second])
+
+    expect(acquire).toHaveBeenCalledOnce()
+    expect(host['holds']['holders'].holderIds(SESSION)).toEqual([
+      'desktop-chat:1',
+      'paired-phone:1'
+    ])
+    expect(host['holds'].isReleasePending(SESSION)).toBe(false)
+    expect(store.getRecord(SESSION)?.lease.claimStatus).toBe('live')
+  })
+
   it('leaves a lease it cannot adjudicate alone', async () => {
     await loseOwner()
     await store.transitionHandoff(SESSION, (current) => ({
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-send-preparation.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-send-preparation.ts
new file mode 100644
index 000000000000..11e95e670b63
--- /dev/null
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-send-preparation.ts
@@ -0,0 +1,126 @@
+// What a send needs from the session before its lease is checked.
+//
+// A provider child that exits or fails to start hands its lease back. Before this, a send to that
+// session was refused `agent_session_ownership_unknown` — which a client reads as "not admitted
+// yet" and resends forever — and only a surface hold could ever make a new child. Now the send
+// makes sure it has an owner as a step of its own serialized admission: a released lease where
+// resume is allowed gets a child first; anything else runs as it is and meets the lease check.
+// A restart that fails for good refuses with a code the client stops on.
+//
+// The ledger's answer comes first, so a send it already holds a row for restarts nothing:
+// admission replays or refuses it whoever owns the session now, and a closed session is made
+// readable for that, never given a child. Otherwise a child that dies at startup moves the fence,
+// the client resends the same message against the new fence, and each replay spawns another
+// child that dies the same way.
+//
+// Running inside the send's serialize is what makes "no child" exact and the fence bookkeeping
+// simple: the owner this send (or a hold just ahead of it) replaced is the one the client was
+// current as of, so the send is admitted at the fence the restart published.
+
+import type { AgentSessionRecord } from '../../../shared/agent-session-record'
+import type {
+  AgentSessionMutationEnvelope,
+  AgentSessionWireRefusal
+} from '../../../shared/agent-session-wire'
+import type { StructuredAgentSessionHostSession } from './structured-agent-session-host-types'
+import type { StructuredAgentSessionMutationContext } from './structured-agent-session-host-mutations'
+import type { AgentSessionMutationSessionPreparation } from './structured-agent-session-mutation-admission'
+import { isResumableStructuredAgentSessionRecord } from './structured-agent-session-resume-eligibility'
+import { rewindRefusal } from './structured-rewind-refusal'
+
+export const AGENT_SESSION_OWNER_UNRECOVERABLE: AgentSessionWireRefusal = {
+  code: 'agent_session_owner_unrecoverable',
+  message: "This chat's agent stopped and could not be restarted. Retry, or start a new chat."
+}
+
+// A resume refused this way met a lease someone else is settling — not proof it cannot resume.
+const TRANSIENT_RESUME_REFUSALS: ReadonlySet<string> = new Set([
+  'execution_owner_reconciling',
+  'agent_session_conflict',
+  'agent_session_checkpoint_stale',
+  'agent_session_ownership_unknown',
+  'agent_session_operation_capacity'
+])
+
+/** Why the record refuses any send right now, whoever owns it; null when a send may run. */
+export function structuredAgentSessionSendBlock(
+  record: AgentSessionRecord | null
+): { ok: false; refusal: AgentSessionWireRefusal } | null {
+  const rewind = record?.rewind
+  if (rewind?.phase === 'prepared' || rewind?.phase === 'provider-succeeded') {
+    return rewindRefusal('outcome-unknown')
+  }
+  const command = record?.conversationCommand
+  if (
+    command &&
+    ((command.state === 'unknown' && command.phase === 'prepared') ||
+      (command.command === 'clear' && command.replacementSessionId))
+  ) {
+    return {
+      ok: false,
+      refusal: {
+        code: 'agent_session_operation_invalid',
+        message: command.replacementSessionId
+          ? 'This conversation has been cleared. Use the current conversation.'
+          : 'The conversation operation is unconfirmed.'
+      }
+    }
+  }
+  return null
+}
+
+/** Whether this send is the one that must bring the owner back: no child, a lease handed back
+ *  cleanly, and nothing on the record that refuses the send anyway. Live, unverifiable, still
+ *  reserved, or handed off: that lease is not this send's to replace. */
+export function structuredAgentSessionSendNeedsOwner(
+  session: StructuredAgentSessionHostSession | undefined,
+  record: AgentSessionRecord
+): boolean {
+  return (
+    session?.hasProviderChild !== true &&
+    isResumableStructuredAgentSessionRecord(record) &&
+    structuredAgentSessionSendBlock(record) === null
+  )
+}
+
+export async function prepareStructuredAgentSessionSend(
+  context: Pick<
+    StructuredAgentSessionMutationContext,
+    'deps' | 'sessions' | 'holds' | 'restoreReadable'
+  >,
+  envelope: AgentSessionMutationEnvelope,
+  ledger: 'admit' | 'replay',
+  record: AgentSessionRecord
+): Promise<AgentSessionMutationSessionPreparation> {
+  const { sessionId } = record
+  if (ledger !== 'admit') {
+    if (!context.sessions.has(sessionId)) {
+      await context.restoreReadable(sessionId)
+    }
+    return { ok: true, envelope }
+  }
+  if (structuredAgentSessionSendNeedsOwner(context.sessions.get(sessionId), record)) {
+    try {
+      await context.holds.ensureProviderChild(sessionId)
+    } catch (error) {
+      if (!(error instanceof Error && TRANSIENT_RESUME_REFUSALS.has(error.message))) {
+        context.deps.onEventSinkError?.({ sessionId, error })
+        return { ok: false, refusal: AGENT_SESSION_OWNER_UNRECOVERABLE }
+      }
+    }
+  }
+  return { ok: true, envelope: admitAtResumedFence(context.sessions.get(sessionId), envelope) }
+}
+
+/** A writer current as of the owner this child replaced is current now: the restart was the only
+ *  thing that moved the fence, whether this send ran it or one just ahead of it did. */
+function admitAtResumedFence(
+  session: StructuredAgentSessionHostSession | undefined,
+  envelope: AgentSessionMutationEnvelope
+): AgentSessionMutationEnvelope {
+  return session?.hasProviderChild &&
+    session.resumedFromFence !== undefined &&
+    envelope.expectedRuntimeFence === session.resumedFromFence
+    ? { ...envelope, expectedRuntimeFence: session.fence }
+    : envelope
+}
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-send-recovery.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-send-recovery.ts
deleted file mode 100644
index 972e2d3f03fc..000000000000
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-send-recovery.ts
+++ /dev/null
@@ -1,101 +0,0 @@
-// A send checks for a live owner before it is admitted, and restarts one if the old one is gone.
-//
-// A provider child that exits or fails to start hands its lease back. Before this, a send to that
-// session was refused `agent_session_ownership_unknown` — which a client reads as "not admitted
-// yet" and resends forever — and only a surface hold could ever make a new child. Now the send
-// itself ensures its owner: a released lease where resume is allowed gets a child first; anything
-// else runs as it is and meets the lease check in admission. A restart that fails for good refuses
-// with a code the client stops on.
-//
-// The ledger outranks the lease here as it does in admission: a send the ledger already holds a
-// row for restarts nothing, because admission replays or refuses it whoever owns the session now.
-// Otherwise a child that dies at startup moves the fence, the client resends the same message
-// against the new fence, and each replay spawns another child that dies the same way.
-//
-// The restart is the holds' single-flight resume, so a hold and a send arriving in the same gap
-// start one child between them, and a send that joins reads the replaced fence from the resume.
-
-import type { AgentSessionRecord } from '../../../shared/agent-session-record'
-import type {
-  AgentSessionMutationResult,
-  AgentSessionSendResult,
-  AgentSessionWireRefusal
-} from '../../../shared/agent-session-wire'
-import type { StructuredAgentSessionResumed } from './structured-agent-session-holds'
-import { refuseAgentSessionMutation } from './structured-agent-session-mutation-admission'
-import { isResumableStructuredAgentSessionRecord } from './structured-agent-session-resume-eligibility'
-import {
-  structuredAgentSessionSendBlock,
-  type sendStructuredAgentSessionTurn
-} from './structured-agent-session-host-mutations'
-
-export const AGENT_SESSION_OWNER_UNRECOVERABLE: AgentSessionWireRefusal = {
-  code: 'agent_session_owner_unrecoverable',
-  message: "This chat's agent stopped and could not be restarted. Retry, or start a new chat."
-}
-
-// A resume refused this way met a lease someone else is settling — not proof it cannot resume.
-const TRANSIENT_RESUME_REFUSALS: ReadonlySet<string> = new Set([
-  'execution_owner_reconciling',
-  'agent_session_conflict',
-  'agent_session_checkpoint_stale',
-  'agent_session_ownership_unknown',
-  'agent_session_operation_capacity'
-])
-
-type SendParams = Parameters<typeof sendStructuredAgentSessionTurn>[2]
-type SendResult = AgentSessionMutationResult<AgentSessionSendResult>
-
-export class StructuredAgentSessionSendRecovery {
-  constructor(
-    private readonly deps: {
-      getRecord: (sessionId: string) => AgentSessionRecord | null
-      /** Whether admission can answer this session at all: it replays out of the loaded journal. */
-      isAttached: (sessionId: string) => boolean
-      /** Whether the ledger holds this send's row, so admission answers it without an owner. */
-      hasLedgerRow: (clientOperationId: string) => boolean
-      isResuming: (sessionId: string) => boolean
-      /** Gives the session a provider child, or joins the resume already running for it; throws
-       *  the refusal code when it cannot. */
-      resume: (sessionId: string) => Promise<StructuredAgentSessionResumed>
-      onError?: (input: { sessionId: string; error: unknown }) => void
-    }
-  ) {}
-
-  async send(params: SendParams, run: (params: SendParams) => Promise<SendResult>) {
-    const { sessionId, clientOperationId, expectedRuntimeFence } = params.envelope
-    if (this.deps.isAttached(sessionId) && this.deps.hasLedgerRow(clientOperationId)) {
-      return run(params)
-    }
-    if (!this.deps.isResuming(sessionId)) {
-      const record = this.deps.getRecord(sessionId)
-      // Live, unverifiable, still reserved, or handed off: that lease is not this send's to
-      // replace. A send the record refuses anyway must not leave a child behind it.
-      if (
-        !record ||
-        !isResumableStructuredAgentSessionRecord(record) ||
-        structuredAgentSessionSendBlock(record)
-      ) {
-        return run(params)
-      }
-    }
-    let resumed: StructuredAgentSessionResumed
-    try {
-      resumed = await this.deps.resume(sessionId)
-    } catch (error) {
-      if (error instanceof Error && TRANSIENT_RESUME_REFUSALS.has(error.message)) {
-        return run(params)
-      }
-      this.deps.onError?.({ sessionId, error })
-      return refuseAgentSessionMutation(AGENT_SESSION_OWNER_UNRECOVERABLE)
-    }
-    const toFence = this.deps.getRecord(sessionId)?.lease.runtimeFence
-    // The client was current as of the lost owner; the new owner is the only thing that moved.
-    const rebase = expectedRuntimeFence === resumed.fromFence && toFence !== undefined
-    return run(
-      rebase
-        ? { ...params, envelope: { ...params.envelope, expectedRuntimeFence: toFence } }
-        : params
-    )
-  }
-}
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-send-after-failed-start.test.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-send-restarts-failed-start.test.ts
similarity index 100%
rename from src/main/native-chat/agent-session-wire/structured-agent-session-send-after-failed-start.test.ts
rename to src/main/native-chat/agent-session-wire/structured-agent-session-send-restarts-failed-start.test.ts
diff --git a/src/main/native-chat/agent-session-wire/structured-conversation-command-controller.ts b/src/main/native-chat/agent-session-wire/structured-conversation-command-controller.ts
index 1347117d662e..e5a0283ba836 100644
--- a/src/main/native-chat/agent-session-wire/structured-conversation-command-controller.ts
+++ b/src/main/native-chat/agent-session-wire/structured-conversation-command-controller.ts
@@ -1,5 +1,4 @@
 import { sendStructuredAgentSessionTurn } from './structured-agent-session-host-mutations'
-import { StructuredAgentSessionSendRecovery } from './structured-agent-session-send-recovery'
 import {
   runStructuredConversationCommand,
   type ConversationCommandParams
@@ -14,33 +13,19 @@ export class StructuredConversationCommandController {
     private readonly context: () => StructuredAgentSessionMutationContext,
     private readonly host: Pick<StructuredAgentSessionHost, 'attach' | 'flushStreamedEvents'>
   ) {}
-  private readonly recovery = new StructuredAgentSessionSendRecovery({
-    getRecord: (sessionId) => this.context().deps.store.getRecord(sessionId),
-    isAttached: (sessionId) => this.context().sessions.has(sessionId),
-    hasLedgerRow: (clientOperationId) => {
-      const { deps, now } = this.context()
-      return deps.store.findGlobalOperationRow(clientOperationId, now()) !== undefined
-    },
-    isResuming: (sessionId) => this.context().resumes.isResuming(sessionId),
-    resume: (sessionId) => this.context().resumes.resumeUnheld(sessionId),
-    onError: (input) => this.context().deps.onEventSinkError?.(input)
-  })
-
   send = (
     caller: StructuredAgentSessionCaller,
     params: Parameters<typeof sendStructuredAgentSessionTurn>[2]
   ): ReturnType<typeof sendStructuredAgentSessionTurn> =>
-    this.recovery.send(params, (next) =>
-      this.pending.has(next.envelope.sessionId)
-        ? Promise.resolve({
-            ok: false,
-            refusal: {
-              code: 'agent_session_operation_invalid',
-              message: 'Wait for the conversation operation to finish.'
-            }
-          })
-        : sendStructuredAgentSessionTurn(this.context(), caller, next)
-    )
+    this.pending.has(params.envelope.sessionId)
+      ? Promise.resolve({
+          ok: false,
+          refusal: {
+            code: 'agent_session_operation_invalid',
+            message: 'Wait for the conversation operation to finish.'
+          }
+        })
+      : sendStructuredAgentSessionTurn(this.context(), caller, params)
 
   run = (caller: StructuredAgentSessionCaller, params: ConversationCommandParams) => {
     const key = JSON.stringify([caller.callerKey, params.envelope.clientOperationId])
diff --git a/src/main/native-chat/agent-session-wire/structured-conversation-command.ts b/src/main/native-chat/agent-session-wire/structured-conversation-command.ts
index 44131886f5b2..8157a32669b2 100644
--- a/src/main/native-chat/agent-session-wire/structured-conversation-command.ts
+++ b/src/main/native-chat/agent-session-wire/structured-conversation-command.ts
@@ -52,7 +52,7 @@ export function runStructuredConversationCommand(
       adapter: context.deps.adapter,
       callerKey: caller.callerKey,
       envelope,
-      journal: context.sessions.get(sessionId)?.journal,
+      journal: () => context.sessions.get(sessionId)?.journal,
       publish: (journal) => context.publish(sessionId, journal),
       flushStreamedEvents: context.flushStreamedEvents,
       now: context.now,
diff --git a/src/main/native-chat/agent-session-wire/structured-rewind-claude-owner.ts b/src/main/native-chat/agent-session-wire/structured-rewind-claude-owner.ts
index 13d2b51f284b..32829c2a2c35 100644
--- a/src/main/native-chat/agent-session-wire/structured-rewind-claude-owner.ts
+++ b/src/main/native-chat/agent-session-wire/structured-rewind-claude-owner.ts
@@ -5,7 +5,7 @@ import type { AgentSessionRewindParams } from '../../../shared/agent-session-rew
 import type { StructuredAgentSessionAcquireInput } from './structured-agent-session-adapter'
 import { attachFingerprintFields } from './structured-agent-session-attach'
 import type { StructuredAgentSessionAttachContext } from './structured-agent-session-attach-context'
-import { attachStructuredAgentSession } from './structured-agent-session-attach-orchestration'
+import { attachStructuredAgentSessionUnderSerialize } from './structured-agent-session-attach-orchestration'
 import { rewindRefusal } from './structured-rewind-refusal'
 
 /** Runs within the rewind's session queue; acquisition still uses the normal reservation CAS. */
@@ -49,16 +49,9 @@ export async function replaceClaudeRewindOwner(
       sessionId,
       fields: attachFingerprintFields(attachParams)
     })
-    return attachStructuredAgentSession(
-      {
-        ...context,
-        serialize: (_id, run) => run()
-      },
-      callerKey,
-      attachParams,
-      undefined,
-      intent
-    )
+    return attachStructuredAgentSessionUnderSerialize(context, callerKey, attachParams, {
+      rewind: intent
+    })
   }
   const result = await attach(rewind, 'rewind')
   if (result.ok) {
diff --git a/src/main/runtime/agent-session-operation-admission.ts b/src/main/runtime/agent-session-operation-admission.ts
index f3e2d4486800..49dbab1c90dc 100644
--- a/src/main/runtime/agent-session-operation-admission.ts
+++ b/src/main/runtime/agent-session-operation-admission.ts
@@ -43,54 +43,105 @@ export type AgentSessionMutationOperationDecision = {
   record: AgentSessionRecord
 } | null
 
-/** Prune, evaluate, and (on admit) place the row. The caller runs this inside one
- *  transaction, so two concurrent copies of an operation id cannot both admit. */
-export function admitAgentSessionOperationRow(
+type EvaluatedOperationRows = { rows: OperationRows; decision: AgentSessionOperationDecision }
+
+/** Prune and evaluate, placing nothing: the ledger's answer as it stands. */
+export function evaluateAgentSessionOperationRow(
   rows: OperationRows,
   args: AgentSessionOperationAdmission
-): { rows: OperationRows; decision: AgentSessionOperationDecision } {
+): EvaluatedOperationRows {
   const pruned = pruneAgentSessionOperationRows(rows, args.now)
-  const decision = evaluateAgentSessionOperation({ rows: pruned, ...args })
-  if (decision.decision === 'admit') {
-    pruned.set(agentSessionOperationKey(args.callerKey, args.operationId), decision.row)
-  }
-  return { rows: pruned, decision }
+  return { rows: pruned, decision: evaluateAgentSessionOperation({ rows: pruned, ...args }) }
 }
 
 /** Send ids name one provider delivery even when the authenticated caller changes. */
-export function admitAgentSessionGlobalOperationRow(
+export function evaluateAgentSessionGlobalOperationRow(
   rows: OperationRows,
   args: AgentSessionOperationAdmission
-): { rows: OperationRows; decision: AgentSessionOperationDecision } {
+): EvaluatedOperationRows {
   const existing = findAgentSessionGlobalOperationRow(rows, args.operationId, args.now)
   if (!existing) {
-    return admitAgentSessionOperationRow(rows, args)
+    return evaluateAgentSessionOperationRow(rows, args)
   }
-  const pruned = pruneAgentSessionOperationRows(rows, args.now)
   const syntheticRows = new Map([
     [agentSessionOperationKey(args.callerKey, args.operationId), existing]
   ])
   return {
-    rows: pruned,
+    rows: pruneAgentSessionOperationRows(rows, args.now),
     decision: evaluateAgentSessionOperation({ rows: syntheticRows, ...args })
   }
 }
 
-/** Admit the ledger row and its lease/fence preconditions in one durable transaction. */
-export function admitAgentSessionMutationOperation(
-  state: AgentSessionStoreState,
+/** Places the row an evaluation admitted. The caller runs this inside one transaction, so two
+ *  concurrent copies of an operation id cannot both admit. */
+function placeAdmittedAgentSessionOperationRow(
+  evaluated: EvaluatedOperationRows,
+  args: AgentSessionOperationAdmission
+): EvaluatedOperationRows {
+  if (evaluated.decision.decision === 'admit') {
+    evaluated.rows.set(
+      agentSessionOperationKey(args.callerKey, args.operationId),
+      evaluated.decision.row
+    )
+  }
+  return evaluated
+}
+
+export function admitAgentSessionOperationRow(
+  rows: OperationRows,
+  args: AgentSessionOperationAdmission
+): EvaluatedOperationRows {
+  return placeAdmittedAgentSessionOperationRow(evaluateAgentSessionOperationRow(rows, args), args)
+}
+
+export function admitAgentSessionGlobalOperationRow(
+  rows: OperationRows,
+  args: AgentSessionOperationAdmission
+): EvaluatedOperationRows {
+  return placeAdmittedAgentSessionOperationRow(
+    evaluateAgentSessionGlobalOperationRow(rows, args),
+    args
+  )
+}
+
+/** The ledger's answer for a mutation, placing nothing and checking no lease: what a call must
+ *  know before it decides whether to give the session an owner. Null when no record exists. */
+export function evaluateAgentSessionMutationOperation(
+  state: Pick<AgentSessionStoreState, 'records' | 'operations'>,
   args: AgentSessionMutationOperationAdmission
-): AgentSessionMutationOperationDecision {
+): { decision: AgentSessionOperationDecision; record: AgentSessionRecord } | null {
   const record = state.records.get(args.envelope.sessionId)
   if (!record) {
     return null
   }
-  const operation = {
+  const operation = mutationOperation(args)
+  const evaluated = args.operationIdScope
+    ? evaluateAgentSessionGlobalOperationRow(state.operations, operation)
+    : evaluateAgentSessionOperationRow(state.operations, operation)
+  return { decision: evaluated.decision, record }
+}
+
+function mutationOperation(
+  args: AgentSessionMutationOperationAdmission
+): AgentSessionOperationAdmission {
+  return {
     callerKey: args.callerKey,
     operationId: args.envelope.clientOperationId,
     fingerprint: args.hostFingerprint,
     now: args.now
   }
+}
+
+/** Admit the ledger row and its lease/fence preconditions in one durable transaction. */
+export function admitAgentSessionMutationOperation(
+  state: AgentSessionStoreState,
+  args: AgentSessionMutationOperationAdmission
+): AgentSessionMutationOperationDecision {
+  const record = state.records.get(args.envelope.sessionId)
+  if (!record) {
+    return null
+  }
+  const operation = mutationOperation(args)
   const ledger = args.operationIdScope
     ? admitAgentSessionGlobalOperationRow(state.operations, operation)
     : admitAgentSessionOperationRow(state.operations, operation)
diff --git a/src/main/runtime/agent-session-record-store.ts b/src/main/runtime/agent-session-record-store.ts
index a3f3c3a3fe79..22d93d6c886b 100644
--- a/src/main/runtime/agent-session-record-store.ts
+++ b/src/main/runtime/agent-session-record-store.ts
@@ -5,7 +5,6 @@ import { setAgentSessionRecordConversationName } from './agent-session-record-co
 
 import {
   agentSessionOperationKey,
-  findAgentSessionGlobalOperationRow,
   type AgentSessionOperationClaim,
   type AgentSessionOperationDecision,
   type AgentSessionOperationOutcome,
@@ -14,6 +13,7 @@ import {
 import {
   admitAgentSessionGlobalOperationInto,
   admitAgentSessionMutationOperation,
+  evaluateAgentSessionMutationOperation,
   admitAgentSessionOperationInto,
   claimAgentSessionOperationInto,
   settleAgentSessionOperationInto,
@@ -165,13 +165,6 @@ export class AgentSessionRecordStore {
 
   listOperationRows = (): AgentSessionOperationRow[] => [...this.state.operations.values()]
 
-  /** The row a globally scoped id (a send) already holds, under whichever caller admitted it. */
-  findGlobalOperationRow = (
-    operationId: string,
-    now: number
-  ): AgentSessionOperationRow | undefined =>
-    findAgentSessionGlobalOperationRow(this.state.operations, operationId, now)
-
   getOperationRow = (callerKey: string, operationId: string): AgentSessionOperationRow | null =>
     this.state.operations.get(agentSessionOperationKey(callerKey, operationId)) ?? null
 
@@ -299,6 +292,10 @@ export class AgentSessionRecordStore {
   admitMutationOperation = (args: AgentSessionMutationOperationAdmission) =>
     this.transact(() => admitAgentSessionMutationOperation(this.state, args))
 
+  /** The ledger's answer alone, placing nothing; `admitMutationOperation` is the transaction. */
+  evaluateMutationOperation = (args: AgentSessionMutationOperationAdmission) =>
+    evaluateAgentSessionMutationOperation(this.state, args)
+
   /** Durable compare-and-swap for the right to run an admitted operation's effect: two replays both
    *  read `pending`, and only a conditional swap tells the one that may run from the one that must
    *  replay. */
diff --git a/src/main/runtime/rpc/methods/structured-agent-session-hold.test.ts b/src/main/runtime/rpc/methods/structured-agent-session-hold.test.ts
index 20a6c7ab5d28..c3099d843ced 100644
--- a/src/main/runtime/rpc/methods/structured-agent-session-hold.test.ts
+++ b/src/main/runtime/rpc/methods/structured-agent-session-hold.test.ts
@@ -40,6 +40,7 @@ let host: StructuredAgentSessionHost
 let runtime: OrcaRuntimeService
 let dispatcher: RpcDispatcher
 let closeSession: Mock<NonNullable<StructuredAgentSessionAdapter['closeSession']>>
+let acquire: Mock<StructuredAgentSessionAdapter['acquire']>
 let requests = 0
 let structuredNativeChatEnabled = true
 
@@ -60,20 +61,26 @@ beforeEach(async () => {
   requests = 0
   structuredNativeChatEnabled = true
   closeSession = vi.fn(async () => true)
+  acquire = vi.fn(async ({ fence, spawnToken }) => ({
+    process: { hostId: 'local', pid: 4242, processStartTimeMs: 1_700_000_000_000, spawnToken },
+    link: {
+      linkId: `link-${fence}`,
+      handle: { provider: 'codex' as const, threadId: THREAD },
+      origin: store.getRecord(SESSION)?.providerHandleChain.length
+        ? ('resumed' as const)
+        : ('created' as const),
+      mintedAtFence: fence,
+      observedAt: NOW
+    }
+  }))
   store = await AgentSessionRecordStore.open({ directory: join(root, 'store'), hostId: 'local' })
   host = new StructuredAgentSessionHost({
     store,
     adapter: {
-      acquire: async ({ fence, spawnToken }) => ({
-        process: { hostId: 'local', pid: 4242, processStartTimeMs: 1_700_000_000_000, spawnToken },
-        link: {
-          linkId: `link-${fence}`,
-          handle: { provider: 'codex', threadId: THREAD },
-          origin: store.getRecord(SESSION)?.providerHandleChain.length ? 'resumed' : 'created',
-          mintedAtFence: fence,
-          observedAt: NOW
-        }
-      }),
+      acquire,
+      // A failed acquisition is proven gone, as the real adapters prove it; without this an
+      // acquire that throws leaves an unverifiable owner nothing may replace.
+      releaseAcquisition: vi.fn(async () => true),
       closeSession,
       dispatch: async () => ({ state: 'rejected', reason: 'unused' }),
       cancelTurn: async () => ({ cancelled: false }),
@@ -166,25 +173,27 @@ describe('a client that disappears without cleanup', () => {
     await host.close(SESSION)
     await host.restoreReadableSessions()
     closeSession.mockClear()
+    acquire.mockClear()
     const entered = Promise.withResolvers<void>()
     const gate = Promise.withResolvers<void>()
-    const attach = host.attach.bind(host)
-    const attachSpy = vi.spyOn(host, 'attach').mockImplementationOnce(async (...args) => {
+    const spawnChild = acquire.getMockImplementation()!
+    acquire.mockImplementationOnce(async (input) => {
       entered.resolve()
       await gate.promise
-      return attach(...args)
+      return spawnChild(input)
     })
     try {
       const params = { sessionId: SESSION, holderId: 'same-chat' }
       const first = call('agentSession.hold', params)
       await entered.promise
-      // Re-registering the cleanup id released the first hold; the replacement joins its resume.
+      // Re-registering the cleanup id released the first hold; the replacement waits its turn
+      // behind the first hold's attach and finds the child it made.
       const replacement = call('agentSession.hold', params)
       gate.resolve()
 
       expect(await first).toMatchObject({ ok: true })
       expect(await replacement).toMatchObject({ ok: true })
-      expect(attachSpy).toHaveBeenCalledOnce()
+      expect(acquire).toHaveBeenCalledOnce()
       expect(host.isHeld(SESSION)).toBe(true)
       await new Promise((resolve) => setTimeout(resolve, GRACE_MS * 4))
       expect(closeSession).not.toHaveBeenCalled()
@@ -194,17 +203,17 @@ describe('a client that disappears without cleanup', () => {
       expect(closeSession).toHaveBeenCalledExactlyOnceWith(SESSION)
     } finally {
       gate.resolve()
-      attachSpy.mockRestore()
     }
   })
 
-  it('fails a hold and its same-ID replacement together when their one resume fails, and the next hold starts over', async () => {
+  it('lets a same-ID replacement make its own attempt when the first hold fails to acquire', async () => {
     await host.close(SESSION)
     await host.restoreReadableSessions()
     closeSession.mockClear()
+    acquire.mockClear()
     const entered = Promise.withResolvers<void>()
     const gate = Promise.withResolvers<void>()
-    const attachSpy = vi.spyOn(host, 'attach').mockImplementationOnce(async () => {
+    acquire.mockImplementationOnce(async () => {
       entered.resolve()
       await gate.promise
       throw new Error('acquisition failed')
@@ -217,20 +226,18 @@ describe('a client that disappears without cleanup', () => {
       gate.resolve()
 
       expect(await first).toMatchObject({ ok: false })
-      expect(await replacement).toMatchObject({ ok: false })
-      expect(host.isHeld(SESSION)).toBe(false)
-      expect(closeSession).not.toHaveBeenCalled()
-
-      expect(await call('agentSession.hold', params)).toMatchObject({ ok: true })
-      expect(attachSpy).toHaveBeenCalledTimes(2)
+      // One attempt per hold: the replacement's own succeeds, and the holder it re-took stands.
+      const replaced = await replacement
+      expect(replaced, JSON.stringify(replaced)).toMatchObject({ ok: true })
+      expect(acquire).toHaveBeenCalledTimes(2)
       expect(host.isHeld(SESSION)).toBe(true)
+      expect(closeSession).not.toHaveBeenCalled()
 
       runtime.cleanupSubscriptionsForConnection(CONNECTION)
       await vi.waitFor(() => expect(host.hasSession(SESSION)).toBe(false))
       expect(closeSession).toHaveBeenCalledExactlyOnceWith(SESSION)
     } finally {
       gate.resolve()
-      attachSpy.mockRestore()
     }
   })
 

From 6754dd4523a8244871d5ffc043778940f9a16f50 Mon Sep 17 00:00:00 2001
From: Brennan Benson <79079362+brennanb2025@users.noreply.github.com>
Date: Wed, 23 Sep 2026 11:49:22 -0700
Subject: [PATCH 27/67] fix(native-chat): a Claude start proving itself no
 longer waits on the CLI

The host handles a Claude child's `started` on the recovery chain every
session's unexpected-exit handling shares, under that session's serialized
step. It then asked the CLI for the model list and settings again, so one slow
CLI held every other session's exit recovery, and its own close, behind up to
two request timeouts.

The adapter already holds those answers when startup proves: the settings read
at startup, the restore's confirmations, and the initialize result the SDK
answers the model list from. `started` now carries that snapshot, and the host
turns it into one record write without any provider I/O.
---
 .../claude-structured-session-acquisition.ts  |   5 +-
 .../claude-structured-session-options.ts      |  20 ++
 .../claude-structured-session-startup.test.ts |   5 +-
 .../claude-structured-session-startup.ts      |  28 ++-
 .../claude/claude-structured-session-state.ts |   3 +-
 .../structured-agent-session-adapter.ts       |   5 +
 ...ctured-agent-session-option-restoration.ts |  27 ++-
 ...ructured-agent-session-provider-started.ts |  25 ++-
 ...t-session-runtime-provider-started.test.ts | 196 ++++++++++++++++++
 9 files changed, 286 insertions(+), 28 deletions(-)
 create mode 100644 src/main/runtime/structured-agent-session-runtime-provider-started.test.ts

diff --git a/src/main/claude/claude-structured-session-acquisition.ts b/src/main/claude/claude-structured-session-acquisition.ts
index 6666be9cb354..637bee1bc5ae 100644
--- a/src/main/claude/claude-structured-session-acquisition.ts
+++ b/src/main/claude/claude-structured-session-acquisition.ts
@@ -254,12 +254,13 @@ export async function acquireClaudeSession({
       isCurrent: () => sessions.get(sessionId) === session,
       requestTimeoutMs: deps.requestTimeoutMs,
       fault: (error) => callbacks.handleExit(sessionId, attempt, error),
-      onStarted: () =>
+      onStarted: (options) =>
         emit({
           type: 'started',
           sessionId,
           fence: input.fence,
-          acquisitionGeneration: session.acquisitionGeneration
+          acquisitionGeneration: session.acquisitionGeneration,
+          ...options
         })
     })
     // A child whose exit already reached `handleExit` is not handed over as live: the create
diff --git a/src/main/claude/claude-structured-session-options.ts b/src/main/claude/claude-structured-session-options.ts
index abedc62966ef..dbc7959d6e97 100644
--- a/src/main/claude/claude-structured-session-options.ts
+++ b/src/main/claude/claude-structured-session-options.ts
@@ -210,6 +210,15 @@ export async function readClaudeStructuredSessionOptions(
           session.connection.getSettings({ timeoutMs }).catch(() => null)
         ])
       : [null, null]
+  observeClaudeSettingsReadback(session, settings, readMutationSequence)
+  return claudeStructuredSessionOptionsFrom(session, catalog, readMutationSequence)
+}
+
+function observeClaudeSettingsReadback(
+  session: ClaudeSession,
+  settings: unknown,
+  readMutationSequence: number
+): void {
   if (settings !== null && readMutationSequence === session.optionMutationSequence) {
     const effort = readClaudeSettingsEffort(settings)
     const fastMode = readClaudeSettingsFastMode(settings)
@@ -228,6 +237,17 @@ export async function readClaudeStructuredSessionOptions(
       session.fastModePerSessionOptIn = perSessionOptIn
     }
   }
+}
+
+/** The options as main already holds them, over `catalog`; asks the CLI nothing. Startup's
+ *  settings readback and restore's confirmations are applied by the time a start proves, and
+ *  the SDK answers `list_models` from its initialize result, so a started session's snapshot
+ *  passes that result here rather than paying two round trips for what it already read. */
+export function claudeStructuredSessionOptionsFrom(
+  session: ClaudeSession,
+  catalog: unknown[] | null,
+  readMutationSequence = session.optionMutationSequence
+): AgentSessionOptionsResult {
   const discovered = listedModels(catalog ? { models: catalog } : null)
   const models = discovered.length > 0 ? discovered : seedModels()
   const current = readClaudeCurrentModel(session)
diff --git a/src/main/claude/claude-structured-session-startup.test.ts b/src/main/claude/claude-structured-session-startup.test.ts
index e62adf144abf..b373e3f94693 100644
--- a/src/main/claude/claude-structured-session-startup.test.ts
+++ b/src/main/claude/claude-structured-session-startup.test.ts
@@ -85,7 +85,10 @@ describe('Claude structured session publishes before the CLI answers initialize'
       type: 'started',
       sessionId: 'session-1',
       fence: 7,
-      acquisitionGeneration: expect.any(String)
+      acquisitionGeneration: expect.any(String),
+      // What the restore just proved, carried so the host never asks the CLI again.
+      reportedOptions: expect.objectContaining({ model: 'opus' }),
+      restoreSkippedOptions: []
     })
     // The restore wrote the saved model before `started`, and the held prompt only after it.
     expect(order).toEqual(['set_model'])
diff --git a/src/main/claude/claude-structured-session-startup.ts b/src/main/claude/claude-structured-session-startup.ts
index d99e0af85cf0..6b6560d86f27 100644
--- a/src/main/claude/claude-structured-session-startup.ts
+++ b/src/main/claude/claude-structured-session-startup.ts
@@ -2,7 +2,10 @@
 // gates the create: a slow start is still a start, and every way it can fail (exit, auth,
 // a foreign session id, a rewind refusal) faults the published session through its exit path.
 
-import type { StructuredAgentSessionAcquireInput } from '../native-chat/agent-session-wire/structured-agent-session-adapter'
+import type {
+  StructuredAgentSessionAcquireInput,
+  StructuredAgentSessionStartedEvent
+} from '../native-chat/agent-session-wire/structured-agent-session-adapter'
 import { withAgentSessionCreatePhase } from '../observability/agent-session-instrumentation'
 import type { ClaudeStreamJsonConnection } from './claude-stream-json-connection'
 import { ClaudeSlashCommandCatalog } from './claude-slash-command-catalog'
@@ -19,7 +22,10 @@ import {
   prepareClaudeStructuredSessionAcquisitionOptions,
   readClaudeStructuredSessionSettings
 } from './claude-structured-session-acquisition-options'
-import { readClaudeSettingsEffort } from './claude-structured-session-options'
+import {
+  claudeStructuredSessionOptionsFrom,
+  readClaudeSettingsEffort
+} from './claude-structured-session-options'
 import {
   failClaudeStartupGate,
   openClaudeStartupGate
@@ -43,6 +49,11 @@ export function createClaudeInitProof(): ClaudeInitProof {
   return { promise, resolve, reject }
 }
 
+export type StructuredAgentSessionStartedOptions = Pick<
+  StructuredAgentSessionStartedEvent,
+  'reportedOptions' | 'restoreSkippedOptions'
+>
+
 export type ClaudeStartupFacts = {
   init: ClaudeInitObservation
   initialization: unknown
@@ -148,8 +159,8 @@ export async function settleClaudeSessionStartup(input: {
   isCurrent: () => boolean
   requestTimeoutMs: number | undefined
   fault: (error: Error) => void
-  /** Startup has proven: the host may now read this child's options as fact. */
-  onStarted: () => void
+  /** Startup has proven; `options` is what the child now reports, snapshotted from memory. */
+  onStarted: (options: StructuredAgentSessionStartedOptions) => void
 }): Promise<void> {
   const { session } = input
   const superseded = (): boolean => {
@@ -167,7 +178,14 @@ export async function settleClaudeSessionStartup(input: {
     applyClaudeStartupFacts(session, facts)
     await restoreClaudeStructuredSessionOptions(session, input.requestTimeoutMs)
     if (!superseded()) {
-      input.onStarted()
+      input.onStarted({
+        // `list_models` is answered from this same initialize result, so nothing is re-read.
+        reportedOptions: claudeStructuredSessionOptionsFrom(
+          session,
+          readClaudeModels(facts.initialization)
+        ).current,
+        restoreSkippedOptions: [...session.restoreSkippedOptions]
+      })
       await openClaudeStartupGate(session)
     }
   } catch (caught) {
diff --git a/src/main/claude/claude-structured-session-state.ts b/src/main/claude/claude-structured-session-state.ts
index 6b5ee50c7815..9e04e439e1da 100644
--- a/src/main/claude/claude-structured-session-state.ts
+++ b/src/main/claude/claude-structured-session-state.ts
@@ -3,6 +3,7 @@ import type {
   AgentSessionJournalIdentity
 } from '../../shared/agent-session-journal-types'
 import type { StructuredAgentSessionEventSink } from '../native-chat/agent-session-wire/structured-agent-session-event-sink'
+import type { StructuredAgentSessionStartedEvent } from '../native-chat/agent-session-wire/structured-agent-session-adapter'
 import type {
   ClaudeStreamJsonConnection,
   openClaudeStreamJsonConnection
@@ -54,7 +55,7 @@ export type ClaudeStructuredSessionEvent =
     }
   | { type: 'auth-diagnostic'; sessionId: string; diagnostic: ClaudeAuthDiagnostic }
   /** Startup facts applied and saved options restored; held prompts are about to be written. */
-  | { type: 'started'; sessionId: string; fence: number; acquisitionGeneration: string }
+  | StructuredAgentSessionStartedEvent
   | {
       type: 'ended'
       sessionId: string
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-adapter.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-adapter.ts
index 7ea1face0cfa..5396b4942b64 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-adapter.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-adapter.ts
@@ -148,6 +148,11 @@ export type StructuredAgentSessionStartedEvent = {
   sessionId: string
   fence: number
   acquisitionGeneration: string
+  /** What the child proved, snapshotted by the adapter from what startup already read. The host
+   *  handles this on the chain every session's exit recovery shares, so it must not ask the CLI. */
+  reportedOptions: AgentSessionOptionsResult['current']
+  /** Saved options the restore could not apply; the host drops them rather than persist them. */
+  restoreSkippedOptions: readonly string[]
 }
 
 export type StructuredAgentSessionLifecycleEvent =
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-option-restoration.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-option-restoration.ts
index 98db575a3374..d3461a7e9ee3 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-option-restoration.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-option-restoration.ts
@@ -1,3 +1,4 @@
+import type { AgentSessionOptionsResult } from '../../../shared/agent-session-wire'
 import type { StructuredAgentSessionAdapter } from './structured-agent-session-adapter'
 import { encodeStructuredAgentSessionOptionValue } from '../../../shared/structured-agent-session-option-codec'
 
@@ -12,22 +13,36 @@ export async function readNativeSessionOptions(input: {
   if (!reported) {
     return undefined
   }
-  const skipped = new Set(input.adapter.readOptionRestoreFailures?.(sessionId) ?? [])
+  return nativeSessionOptionsFromReport({
+    reported: reported.current,
+    restoreSkipped: adapter.readOptionRestoreFailures?.(sessionId) ?? [],
+    ...(priorOptions ? { priorOptions } : {})
+  })
+}
+
+/** The record's options once the provider has reported: its model, effort and Fast replace the
+ *  saved ones, other saved options stay, and any the restore could not apply are dropped. */
+export function nativeSessionOptionsFromReport(input: {
+  reported: AgentSessionOptionsResult['current']
+  restoreSkipped: readonly string[]
+  priorOptions?: Readonly<Record<string, string>>
+}): Readonly<Record<string, string>> {
+  const { reported, priorOptions } = input
   const restored = priorOptions ? { ...priorOptions } : {}
   delete restored.model
   delete restored.effort
   delete restored.fastMode
-  for (const key of skipped) {
+  for (const key of input.restoreSkipped) {
     delete restored[key]
   }
   const fastMode =
-    reported.current.fastMode === undefined
+    reported.fastMode === undefined
       ? undefined
-      : encodeStructuredAgentSessionOptionValue('fastMode', reported.current.fastMode)
+      : encodeStructuredAgentSessionOptionValue('fastMode', reported.fastMode)
   return {
     ...restored,
-    model: reported.current.model,
-    ...(reported.current.effort ? { effort: reported.current.effort } : {}),
+    model: reported.model,
+    ...(reported.effort ? { effort: reported.effort } : {}),
     ...(fastMode !== undefined && fastMode !== null ? { fastMode } : {})
   }
 }
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-provider-started.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-provider-started.ts
index f62c4e205fe3..c53f9a5ae195 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-provider-started.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-provider-started.ts
@@ -5,6 +5,9 @@
 // landed, flips the session to `ready`, and persists what the child now reports as fact through
 // the same record write a user's option change takes. Bookkeeping never gates the user: a failed
 // write is reported and the session stays usable.
+//
+// This runs on the chain every session's exit recovery shares, and under the session's own
+// serialized step, so it asks the provider nothing: the event carries what the child proved.
 
 import { agentSessionLeaseAdmitsWriter } from '../../../shared/agent-session-lease-adjudication'
 import type { StructuredAgentSessionStartedEvent } from './structured-agent-session-adapter'
@@ -12,7 +15,7 @@ import type {
   StructuredAgentSessionHostDeps,
   StructuredAgentSessionHostSession
 } from './structured-agent-session-host-types'
-import { readNativeSessionOptions } from './structured-agent-session-option-restoration'
+import { nativeSessionOptionsFromReport } from './structured-agent-session-option-restoration'
 
 export type StructuredAgentSessionProviderStartedContext = {
   deps: StructuredAgentSessionHostDeps
@@ -52,7 +55,7 @@ async function persistStartedOptions(
   context: StructuredAgentSessionProviderStartedContext,
   event: StructuredAgentSessionStartedEvent
 ): Promise<void> {
-  const { store, adapter } = context.deps
+  const { store } = context.deps
   const record = store.getRecord(event.sessionId)
   if (
     !record ||
@@ -61,18 +64,14 @@ async function persistStartedOptions(
   ) {
     return
   }
-  const options = await readNativeSessionOptions({
-    adapter,
+  await store.replaceSessionOptions({
     sessionId: event.sessionId,
     fence: event.fence,
-    ...(record.options ? { priorOptions: record.options } : {})
+    options: nativeSessionOptionsFromReport({
+      reported: event.reportedOptions,
+      restoreSkipped: event.restoreSkippedOptions,
+      ...(record.options ? { priorOptions: record.options } : {})
+    }),
+    now: context.now()
   })
-  if (options) {
-    await store.replaceSessionOptions({
-      sessionId: event.sessionId,
-      fence: event.fence,
-      options,
-      now: context.now()
-    })
-  }
 }
diff --git a/src/main/runtime/structured-agent-session-runtime-provider-started.test.ts b/src/main/runtime/structured-agent-session-runtime-provider-started.test.ts
new file mode 100644
index 000000000000..c922d1e0abe4
--- /dev/null
+++ b/src/main/runtime/structured-agent-session-runtime-provider-started.test.ts
@@ -0,0 +1,196 @@
+// Every provider's lifecycle events share one recovery chain in the runtime. A Claude child
+// proving its start must not make that chain, or the session's own serialized operations,
+// wait on the CLI: the host records what the child proved from what the adapter already holds.
+
+import { mkdir, mkdtemp, rm } from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { afterEach, describe, expect, it, vi } from 'vitest'
+import type {
+  ClaudeStreamJsonConnection,
+  ClaudeStreamJsonConnectionHandlers,
+  openClaudeStreamJsonConnection
+} from '../claude/claude-stream-json-connection'
+import { claudeSessionIdForOrcaSession } from '../claude/claude-structured-launch-resolution'
+import { hostTestAttachParams } from '../native-chat/agent-session-wire/structured-agent-session-host-test-data'
+import type { StructuredAgentSessionHost } from '../native-chat/agent-session-wire/structured-agent-session-host'
+import {
+  ensureStructuredAgentSessionHost,
+  stopStructuredAgentSessionRuntime,
+  waitForStructuredAgentSessionRecovery
+} from './structured-agent-session-runtime'
+
+const STALLED = 'claude-started-stalled'
+const HEALTHY = 'claude-started-healthy'
+const CALLER = { callerKey: 'client-1' }
+
+type ScriptedClaude = {
+  sessionId: string
+  calls: string[]
+  handlers: ClaudeStreamJsonConnectionHandlers
+  connection: Omit<ClaudeStreamJsonConnection, 'closed' | 'exitVerdict'> & {
+    closed: boolean
+    exitVerdict: ClaudeStreamJsonConnection['exitVerdict']
+  }
+}
+
+let root: string | null = null
+let operations = 0
+// The runtime's own clock admits operation ids, so these are minted against it.
+const operationId = (): string => `${Date.now()}-${(++operations).toString(16).padStart(32, '0')}`
+let releaseStall: () => void = () => {}
+
+afterEach(async () => {
+  releaseStall()
+  await stopStructuredAgentSessionRuntime()
+  if (root) {
+    await rm(root, { recursive: true, force: true })
+    root = null
+  }
+})
+
+/** A CLI that answers startup, then never answers another control read for `stalledSessionId`. */
+function scriptedClaude(stalledSessionId: string) {
+  const children: ScriptedClaude[] = []
+  let release = (): void => {}
+  const stall = new Promise<void>((resolve) => {
+    release = resolve
+  })
+  const answer = <T>(child: ScriptedClaude, value: T, startup: boolean): Promise<T> =>
+    child.sessionId === stalledSessionId && !startup
+      ? stall.then(() => value)
+      : Promise.resolve(value)
+  const openConnection: typeof openClaudeStreamJsonConnection = async (launch, handlers = {}) => {
+    const providerSessionId = String(launch.options.sessionId ?? launch.options.resume)
+    const sessionId = [STALLED, HEALTHY].find(
+      (candidate) => claudeSessionIdForOrcaSession(candidate) === providerSessionId
+    )!
+    let settingsReads = 0
+    const child: ScriptedClaude = {
+      sessionId,
+      calls: [],
+      handlers,
+      connection: {
+        pid: 5000 + children.length,
+        closed: false,
+        exitVerdict: { root: 'live', tree: 'unverifiable' },
+        initializationResult: async () => {
+          handlers.onMessage?.({
+            type: 'system',
+            subtype: 'init',
+            session_id: providerSessionId,
+            model: 'claude-sonnet-5',
+            apiKeySource: 'none'
+          })
+          return { models: [{ value: 'sonnet', displayName: 'Sonnet' }] }
+        },
+        getSettings: () => {
+          child.calls.push('get_settings')
+          settingsReads += 1
+          return answer(child, { effective: { effortLevel: 'high' } }, settingsReads === 1)
+        },
+        supportedModels: () => {
+          child.calls.push('list_models')
+          return answer(child, [{ value: 'sonnet', displayName: 'Sonnet' }], false)
+        },
+        setModel: async () => {},
+        setPermissionMode: async () => {},
+        applyFlagSettings: async () => {},
+        interrupt: async () => undefined,
+        cancelAsyncMessage: async () => {},
+        stopTask: async () => {},
+        send: async () => {},
+        close: async () => {
+          child.connection.closed = true
+          return true
+        }
+      }
+    }
+    children.push(child)
+    return child.connection
+  }
+  const child = (sessionId: string): ScriptedClaude => {
+    const found = children.findLast((entry) => entry.sessionId === sessionId)
+    if (!found) {
+      throw new Error(`no Claude child for ${sessionId}`)
+    }
+    return found
+  }
+  return { openConnection, child, release: () => release() }
+}
+
+function claudeParams(sessionId: string) {
+  return hostTestAttachParams(null, {
+    envelope: {
+      sessionId,
+      clientOperationId: operationId(),
+      expectedRuntimeFence: null,
+      payloadFingerprint: ''
+    },
+    provider: 'claude',
+    agent: 'claude',
+    accountHome: { variable: 'CLAUDE_CONFIG_DIR', path: join(root!, 'claude-home') },
+    providerHandle: {
+      kind: 'claude',
+      sessionId: claudeSessionIdForOrcaSession(sessionId),
+      leafUuid: null
+    }
+  })
+}
+
+async function install(
+  claude: ReturnType<typeof scriptedClaude>
+): Promise<StructuredAgentSessionHost> {
+  root = await mkdtemp(join(tmpdir(), 'orca-runtime-provider-started-'))
+  await mkdir(join(root, 'claude-home'), { recursive: true })
+  return ensureStructuredAgentSessionHost({
+    stateDirectory: root,
+    hostId: 'local',
+    claimKeyId: 'key-1',
+    resolveWorkspacePath: async () => root!,
+    resolveClaudeCommand: () => '/usr/local/bin/claude',
+    resolveClaudeAuthPolicy: () => ({ stripAuthEnv: false }),
+    openClaudeConnection: claude.openConnection,
+    readProcessStartTime: async (pid: number) => pid * 10
+  })
+}
+
+describe('a Claude child proving its start', () => {
+  it("never holds another session's exit recovery, or its own close, on a CLI read", async () => {
+    const claude = scriptedClaude(STALLED)
+    releaseStall = claude.release
+    const host = await install(claude)
+
+    const first = await host.attach(CALLER, claudeParams(HEALTHY))
+    expect(first, JSON.stringify(first)).toMatchObject({ ok: true })
+    await waitForStructuredAgentSessionRecovery()
+
+    // This child answers startup, then never answers another control read.
+    await expect(host.attach(CALLER, claudeParams(STALLED))).resolves.toMatchObject({ ok: true })
+    await vi.waitFor(() => expect(claude.child(STALLED).calls).toContain('get_settings'))
+    // Its `started` reaches the shared chain ahead of the exit below.
+    await new Promise((resolve) => setImmediate(resolve))
+
+    const healthy = claude.child(HEALTHY)
+    healthy.connection.exitVerdict = { root: 'exited', tree: 'unverifiable' }
+    healthy.handlers.onExit?.(new Error('claude stream-json exited (code 1): crashed'))
+    await vi.waitFor(() =>
+      expect(host.deps.store.getRecord(HEALTHY)?.lease.claimStatus).toBe('released')
+    )
+
+    // What the child proved is still recorded, from the startup it already answered.
+    await vi.waitFor(() =>
+      expect(host.deps.store.getRecord(STALLED)?.options).toEqual({
+        model: 'claude-sonnet-5',
+        effort: 'high'
+      })
+    )
+    expect(claude.child(STALLED).calls).toEqual(['get_settings'])
+
+    let closed = false
+    void host.close(STALLED).then(() => {
+      closed = true
+    })
+    await vi.waitFor(() => expect(closed).toBe(true))
+  })
+})

From fc65d74c13185b08a0f6e06b0e8591c0a8df132a Mon Sep 17 00:00:00 2001
From: Brennan Benson <79079362+brennanb2025@users.noreply.github.com>
Date: Wed, 23 Sep 2026 11:51:54 -0700
Subject: [PATCH 28/67] test(native-chat): a hold reads its lease only after
 this host has reconciled it and exited a latched recovery stage

---
 ...red-agent-session-send-preparation.test.ts | 35 +++++++++++++++++++
 1 file changed, 35 insertions(+)

diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-send-preparation.test.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-send-preparation.test.ts
index 5f611bbb5221..645bd99e60d4 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-send-preparation.test.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-send-preparation.test.ts
@@ -434,6 +434,41 @@ describe('a send with no live owner', () => {
     expect(store.getRecord(SESSION)?.lease.claimStatus).toBe('live')
   })
 
+  it('adjudicates a lease this host has not reconciled before a hold resumes it', async () => {
+    await loseOwner()
+    await store.transitionHandoff(SESSION, (current) => ({
+      ...current,
+      lease: { ...current.lease, unreconciled: true }
+    }))
+    host.deps.probeOwner = async () => ({ outcome: 'pid-absent' })
+
+    await host.hold(SESSION, 'desktop-chat:1')
+
+    expect(acquire).toHaveBeenCalledOnce()
+    expect(store.getRecord(SESSION)?.lease).toMatchObject({
+      unreconciled: false,
+      claimStatus: 'live'
+    })
+  })
+
+  it('exits the recovery stage a failed attempt latched before a hold resumes', async () => {
+    await loseOwner()
+    // What an acquisition whose exit could not be proven leaves behind: nobody's, but latched.
+    await store.transitionHandoff(SESSION, (current) => ({
+      ...current,
+      lease: { ...current.lease, handoffStage: 'manual-recovery' }
+    }))
+    host.deps.probeOwner = async () => ({ outcome: 'pid-absent' })
+
+    await host.hold(SESSION, 'desktop-chat:1')
+
+    expect(acquire).toHaveBeenCalledOnce()
+    expect(store.getRecord(SESSION)?.lease).toMatchObject({
+      handoffStage: null,
+      claimStatus: 'live'
+    })
+  })
+
   it('leaves a lease it cannot adjudicate alone', async () => {
     await loseOwner()
     await store.transitionHandoff(SESSION, (current) => ({

From 150cadf41c3c8f7f2b8621d27253933c357d4f30 Mon Sep 17 00:00:00 2001
From: Brennan Benson <79079362+brennanb2025@users.noreply.github.com>
Date: Wed, 23 Sep 2026 11:57:20 -0700
Subject: [PATCH 29/67] fix(claude): a chat whose first start failed resumes as
 the same conversation

A Claude start that dies before initialize writes no transcript, so the next
start launches the chain head's provider id fresh instead of `--resume`. The
launch flag that chose that mode also chose the provider-handle link's origin,
so the fresh launch published a second `created` link onto a chain that
already had a head. The store refused it, the healthy child was closed, and
every later reopen, hold or send spawned and killed another Claude.

The launch now carries the two facts separately: `resumesTranscript` (launch
mode, from whether Claude wrote a transcript) and `continuesChain` (lineage,
from the record's chain head). The link origin reads lineage; rewind and the
Fast opt-in carry-over read launch mode.
---
 ...laude-structured-launch-resolution.test.ts |  10 +-
 .../claude-structured-launch-resolution.ts    |  17 +-
 .../claude/claude-structured-real-cli.test.ts |   3 +-
 .../claude/claude-structured-rewind.test.ts   |  24 ++-
 src/main/claude/claude-structured-rewind.ts   |   8 +-
 ...-structured-session-acquisition-options.ts |   9 +-
 ...ed-session-acquisition-processless.test.ts |   3 +-
 .../claude-structured-session-acquisition.ts  |   4 +-
 .../claude-structured-session-adapter.test.ts |  18 +-
 .../claude-structured-session-publication.ts  |   5 +-
 ...structured-session-reading-control.test.ts |   2 +-
 ...claude-structured-session-recovery.test.ts |   9 +-
 .../claude-structured-session-startup.ts      |   4 +-
 .../claude-structured-session-test-support.ts |   3 +-
 ...tui-resume-real-binary.integration.test.ts |   3 +-
 ...red-agent-session-provider-started.test.ts |   3 +-
 ...ude-structured-failed-start-resume.test.ts |  52 ++++++
 ...t-session-runtime-provider-started.test.ts | 166 ++---------------
 ...ed-claude-scripted-runtime-test-support.ts | 175 ++++++++++++++++++
 19 files changed, 327 insertions(+), 191 deletions(-)
 create mode 100644 src/main/runtime/claude-structured-failed-start-resume.test.ts
 create mode 100644 src/main/runtime/structured-claude-scripted-runtime-test-support.ts

diff --git a/src/main/claude/claude-structured-launch-resolution.test.ts b/src/main/claude/claude-structured-launch-resolution.test.ts
index fce3fd976426..953c99245584 100644
--- a/src/main/claude/claude-structured-launch-resolution.test.ts
+++ b/src/main/claude/claude-structured-launch-resolution.test.ts
@@ -117,7 +117,8 @@ describe('claude structured launch resolution', () => {
       cwd: '/repos/workspace-1',
       claudeConfigDir: '/home/work/.claude',
       resumeLeafUuid: null,
-      resumed: false
+      resumesTranscript: false,
+      continuesChain: false
     })
     expect(first.options).toEqual({
       includePartialMessages: true,
@@ -151,7 +152,8 @@ describe('claude structured launch resolution', () => {
     expect(launch).toMatchObject({
       providerSessionId: 'provider-current',
       resumeLeafUuid: 'leaf-current',
-      resumed: true
+      resumesTranscript: true,
+      continuesChain: true
     })
     expect(launch.options.resume).toBe('provider-current')
     expect(launch.options.resumeSessionAt).toBe('leaf-current')
@@ -230,7 +232,9 @@ describe('claude structured launch resolution', () => {
     expect(launch).toMatchObject({
       providerSessionId: 'provider-current',
       resumeLeafUuid: null,
-      resumed: false
+      resumesTranscript: false,
+      // Launching the id fresh does not start a new conversation: the child continues the chain.
+      continuesChain: true
     })
   })
 
diff --git a/src/main/claude/claude-structured-launch-resolution.ts b/src/main/claude/claude-structured-launch-resolution.ts
index c0b110652cfe..d4ca395015f1 100644
--- a/src/main/claude/claude-structured-launch-resolution.ts
+++ b/src/main/claude/claude-structured-launch-resolution.ts
@@ -97,7 +97,11 @@ export type ClaudeStructuredLaunch = {
   claudeConfigDir: string
   providerSessionId: string
   resumeLeafUuid: string | null
-  resumed: boolean
+  /** Launch mode: `--resume` of a transcript Claude wrote, rather than starting the id fresh. */
+  resumesTranscript: boolean
+  /** Lineage: the record's chain already heads this provider session, so the child continues it
+   *  even when no transcript exists to `--resume`. Never derived from the launch mode. */
+  continuesChain: boolean
 }
 
 export type ClaudeStructuredLaunchResolverDeps = {
@@ -209,9 +213,10 @@ export function createClaudeStructuredLaunchResolver(
       head?.handle.provider === 'claude'
         ? head.handle.sessionId
         : claudeSessionIdForOrcaSession(identity.sessionId)
+    const continuesChain = head?.handle.provider === 'claude'
     // A start that failed before its first turn wrote no transcript, and `--resume` of an absent
     // one exits; launch that id fresh instead. With a transcript, `--session-id` would collide.
-    const resumed =
+    const resumesTranscript =
       head?.handle.provider === 'claude' &&
       (head.handle.leafUuid !== null ||
         (await (deps.hasTranscript ?? claudeTranscriptExists)({
@@ -264,7 +269,7 @@ export function createClaudeStructuredLaunchResolver(
         ...CLAUDE_STRUCTURED_BASE_OPTIONS,
         ...permission,
         extraArgs: { ...CLAUDE_STRUCTURED_BASE_OPTIONS.extraArgs, ...permission.extraArgs },
-        ...(resumed && head?.handle.provider === 'claude'
+        ...(resumesTranscript && head?.handle.provider === 'claude'
           ? {
               resume: providerSessionId,
               ...(head.handle.leafUuid === null ? {} : { resumeSessionAt: head.handle.leafUuid })
@@ -275,8 +280,10 @@ export function createClaudeStructuredLaunchResolver(
       env,
       claudeConfigDir: record.accountHome.path,
       providerSessionId,
-      resumeLeafUuid: resumed && head?.handle.provider === 'claude' ? head.handle.leafUuid : null,
-      resumed
+      resumeLeafUuid:
+        resumesTranscript && head?.handle.provider === 'claude' ? head.handle.leafUuid : null,
+      resumesTranscript,
+      continuesChain
     }
   }
 }
diff --git a/src/main/claude/claude-structured-real-cli.test.ts b/src/main/claude/claude-structured-real-cli.test.ts
index 1b39237af04c..4181dab43c7a 100644
--- a/src/main/claude/claude-structured-real-cli.test.ts
+++ b/src/main/claude/claude-structured-real-cli.test.ts
@@ -59,7 +59,8 @@ function realAdapter(
       claudeConfigDir,
       providerSessionId,
       resumeLeafUuid: null,
-      resumed: false
+      resumesTranscript: false,
+      continuesChain: false
     }),
     onEvent: (event) => events.push(event),
     readProcessStartTime: async () => 1,
diff --git a/src/main/claude/claude-structured-rewind.test.ts b/src/main/claude/claude-structured-rewind.test.ts
index 5642e6cd088d..f63dc67771ba 100644
--- a/src/main/claude/claude-structured-rewind.test.ts
+++ b/src/main/claude/claude-structured-rewind.test.ts
@@ -13,7 +13,8 @@ const proofLaunch = {
   providerSessionId: PROVIDER_SESSION_ID,
   claudeConfigDir: '/claude',
   options: {},
-  resumed: true,
+  resumesTranscript: true,
+  continuesChain: true,
   resumeLeafUuid: 'tip',
   cwd: '/workspace',
   pathToClaudeCodeExecutable: 'claude'
@@ -25,7 +26,7 @@ describe('Claude rewind acquisition', () => {
     const proof = vi.fn(async (_input: { intentionalRewindUuid?: string }) => 'kept')
     const adapter = adapterFor(
       fake,
-      { resumed: true, resumeLeafUuid: 'tip' },
+      { resumesTranscript: true, continuesChain: true, resumeLeafUuid: 'tip' },
       [],
       [],
       undefined,
@@ -81,7 +82,14 @@ describe('Claude rewind acquisition', () => {
       return connection
     }
     const proof = vi.fn(async (_input: { intentionalRewindUuid?: string }) => 'kept')
-    const adapter = adapterFor(fake, { resumed: true }, [], [], undefined, proof)
+    const adapter = adapterFor(
+      fake,
+      { resumesTranscript: true, continuesChain: true },
+      [],
+      [],
+      undefined,
+      proof
+    )
     await expect(
       adapter.acquire({ identity: identityFor(), fence: 7, spawnToken: 'spawn', rewind: intent })
     ).rejects.toMatchObject({ rewindReason: 'provider-refused' })
@@ -99,7 +107,8 @@ describe('Claude rewind acquisition', () => {
       providerSessionId: PROVIDER_SESSION_ID,
       claudeConfigDir: '/claude',
       options: {},
-      resumed: true,
+      resumesTranscript: true,
+      continuesChain: true,
       resumeLeafUuid: 'tip',
       cwd: '/workspace',
       pathToClaudeCodeExecutable: 'claude'
@@ -129,7 +138,8 @@ describe('Claude rewind acquisition', () => {
       providerSessionId: PROVIDER_SESSION_ID,
       claudeConfigDir: '/claude',
       options: {},
-      resumed: true,
+      resumesTranscript: true,
+      continuesChain: true,
       resumeLeafUuid: 'tip',
       cwd: '/workspace',
       pathToClaudeCodeExecutable: 'claude'
@@ -141,7 +151,7 @@ describe('Claude rewind acquisition', () => {
   })
   it('checkpoints the proved target before late acquisition failure without persisting a stale cursor', async () => {
     const fake = fakeClaude()
-    const launch = { resumed: true, resumeLeafUuid: 'tip' }
+    const launch = { resumesTranscript: true, continuesChain: true, resumeLeafUuid: 'tip' }
     const persisted: unknown[] = []
     const proof = vi.fn(async () => 'kept')
     const adapter = adapterFor(fake, launch, [], persisted, undefined, proof)
@@ -178,7 +188,7 @@ describe('Claude rewind acquisition', () => {
     const restored = vi.fn(async () => {})
     const adapter = adapterFor(
       fake,
-      { resumed: true, resumeLeafUuid: 'tip' },
+      { resumesTranscript: true, continuesChain: true, resumeLeafUuid: 'tip' },
       [],
       [],
       undefined,
diff --git a/src/main/claude/claude-structured-rewind.ts b/src/main/claude/claude-structured-rewind.ts
index 79587327a093..00a6292fdc1a 100644
--- a/src/main/claude/claude-structured-rewind.ts
+++ b/src/main/claude/claude-structured-rewind.ts
@@ -43,7 +43,7 @@ export class ClaudeRewindAttempt {
     if (!this.intent) {
       return
     }
-    if (!launch.resumed || !deps.readTranscriptLeaf) {
+    if (!launch.resumesTranscript || !deps.readTranscriptLeaf) {
       throw new AgentSessionRewindRefusal('unsupported')
     }
     launch.options = {
@@ -102,7 +102,11 @@ export async function proveClaudeRewindRecovery(
   if (!recovery) {
     return null
   }
-  if (!launch.resumed || launch.resumeLeafUuid !== recovery.leafUuid || !deps.readTranscriptLeaf) {
+  if (
+    !launch.resumesTranscript ||
+    launch.resumeLeafUuid !== recovery.leafUuid ||
+    !deps.readTranscriptLeaf
+  ) {
     throw new AgentSessionRewindRefusal('proof-mismatch')
   }
   const leaf = await deps.readTranscriptLeaf({
diff --git a/src/main/claude/claude-structured-session-acquisition-options.ts b/src/main/claude/claude-structured-session-acquisition-options.ts
index be50d04b2e2d..7557419dd08b 100644
--- a/src/main/claude/claude-structured-session-acquisition-options.ts
+++ b/src/main/claude/claude-structured-session-acquisition-options.ts
@@ -17,13 +17,18 @@ export function prepareClaudeStructuredSessionAcquisitionOptions(args: {
   settings: unknown
   initialization: unknown
   inputOptions: Readonly<Record<string, string>> | undefined
-  resumed: boolean
+  /** A fresh CLI session has not carried a per-session Fast opt-in over from anywhere. */
+  resumesTranscript: boolean
 }) {
   const fastMode = readClaudeSettingsFastMode(args.settings)
   const fastModePerSessionOptIn = readClaudeSettingsFastModePerSessionOptIn(args.settings)
   const fastModeFacts = readClaudeFastModeFacts(args.initialization)
   const options = restoredClaudeStructuredSessionOptions(args.inputOptions)
-  if (!args.resumed && fastModePerSessionOptIn === true && options.get('fastMode') === 'true') {
+  if (
+    !args.resumesTranscript &&
+    fastModePerSessionOptIn === true &&
+    options.get('fastMode') === 'true'
+  ) {
     options.delete('fastMode')
   }
   return { fastMode, fastModePerSessionOptIn, fastModeFacts, options }
diff --git a/src/main/claude/claude-structured-session-acquisition-processless.test.ts b/src/main/claude/claude-structured-session-acquisition-processless.test.ts
index 89b605fe9662..4ad372d9d540 100644
--- a/src/main/claude/claude-structured-session-acquisition-processless.test.ts
+++ b/src/main/claude/claude-structured-session-acquisition-processless.test.ts
@@ -54,7 +54,8 @@ describe('Claude structured processless acquisition', () => {
         claudeConfigDir: '/accounts/claude',
         providerSessionId: PROVIDER_SESSION_ID,
         resumeLeafUuid: null,
-        resumed: false
+        resumesTranscript: false,
+        continuesChain: false
       }),
       openConnection
     })
diff --git a/src/main/claude/claude-structured-session-acquisition.ts b/src/main/claude/claude-structured-session-acquisition.ts
index 637bee1bc5ae..4dd0ddca3b41 100644
--- a/src/main/claude/claude-structured-session-acquisition.ts
+++ b/src/main/claude/claude-structured-session-acquisition.ts
@@ -193,7 +193,7 @@ export async function acquireClaudeSession({
         initProof,
         sessionId,
         providerSessionId: launch.providerSessionId,
-        resumed: launch.resumed,
+        resumesTranscript: launch.resumesTranscript,
         inputOptions: input.options,
         requestTimeoutMs: deps.requestTimeoutMs,
         ...(recordPhase ? { recordPhase } : {}),
@@ -227,7 +227,7 @@ export async function acquireClaudeSession({
       claudeConfigDir: launch.claudeConfigDir,
       leafUuid: observedLeafUuid,
       fence: input.fence,
-      resumed: launch.resumed,
+      continuesChain: launch.continuesChain,
       prompts,
       translator,
       events: input.events,
diff --git a/src/main/claude/claude-structured-session-adapter.test.ts b/src/main/claude/claude-structured-session-adapter.test.ts
index d38629c7e892..c8e8cb1f82d6 100644
--- a/src/main/claude/claude-structured-session-adapter.test.ts
+++ b/src/main/claude/claude-structured-session-adapter.test.ts
@@ -67,7 +67,7 @@ describe('ClaudeStructuredSessionAdapter.acquire', () => {
 
   it('restores persisted model and effort before publishing a reacquired session', async () => {
     const claude = fakeClaude()
-    const adapter = adapterFor(claude, { resumed: true })
+    const adapter = adapterFor(claude, { resumesTranscript: true, continuesChain: true })
 
     await adapter.acquire({
       identity: identityFor(),
@@ -140,7 +140,7 @@ describe('ClaudeStructuredSessionAdapter.acquire', () => {
         list_models: () => [{ value: 'opus', displayName: 'Opus', supportsFastMode: true }]
       }
     })
-    const adapter = adapterFor(claude, { resumed: true })
+    const adapter = adapterFor(claude, { resumesTranscript: true, continuesChain: true })
 
     await adapter.acquire({
       identity: identityFor(),
@@ -462,7 +462,8 @@ describe('ClaudeStructuredSessionAdapter.acquire', () => {
   it('resumes the same provider id and refuses an init proof for another session', async () => {
     const resumedClaude = fakeClaude()
     const resumed = adapterFor(resumedClaude, {
-      resumed: true,
+      resumesTranscript: true,
+      continuesChain: true,
       resumeLeafUuid: 'leaf-before'
     })
     const acquisition = await resumed.acquire({
@@ -555,7 +556,14 @@ describe('ClaudeStructuredSessionAdapter acquisition cleanup', () => {
       exitBeforeInit: 'claude stream-json exited (code 1): not logged in',
       unprovenCloseVerdict
     })
-    return adapterFor(claude, { resumed: true, resumeLeafUuid: 'tip' }, [], [], undefined, kept)
+    return adapterFor(
+      claude,
+      { resumesTranscript: true, continuesChain: true, resumeLeafUuid: 'tip' },
+      [],
+      [],
+      undefined,
+      kept
+    )
       .acquire({ identity: identityFor(), fence: 7, spawnToken: 'spawn-9', rewind })
       .catch((error: unknown) => error)
   }
@@ -621,7 +629,7 @@ describe('ClaudeStructuredSessionAdapter acquisition cleanup', () => {
     const claude = fakeClaude(options)
     const adapter = adapterFor(
       claude,
-      { resumed: true, resumeLeafUuid: 'tip' },
+      { resumesTranscript: true, continuesChain: true, resumeLeafUuid: 'tip' },
       [],
       [],
       undefined,
diff --git a/src/main/claude/claude-structured-session-publication.ts b/src/main/claude/claude-structured-session-publication.ts
index a6a035c3f848..0ae9e9a8e5e1 100644
--- a/src/main/claude/claude-structured-session-publication.ts
+++ b/src/main/claude/claude-structured-session-publication.ts
@@ -15,7 +15,8 @@ export function createClaudeSessionPublication(input: {
   leafUuid: string | null
   fence: number
   acquisitionGeneration: string
-  resumed: boolean
+  /** The record's chain already heads this provider session: the link resumes, never creates. */
+  continuesChain: boolean
   prompts: ClaudePromptRegistry
   translator: ClaudeJournalTranslator | null
   events: ClaudeSession['events']
@@ -31,7 +32,7 @@ export function createClaudeSessionPublication(input: {
       link: claudeProviderHandleLink({
         sessionId: input.providerSessionId,
         leafUuid: input.leafUuid,
-        resumed: input.resumed,
+        resumed: input.continuesChain,
         fence: input.fence,
         ...(input.linkId ? { linkId: input.linkId } : {}),
         observedAt: input.observedAt
diff --git a/src/main/claude/claude-structured-session-reading-control.test.ts b/src/main/claude/claude-structured-session-reading-control.test.ts
index c9cec7996a28..48108e8c6c3b 100644
--- a/src/main/claude/claude-structured-session-reading-control.test.ts
+++ b/src/main/claude/claude-structured-session-reading-control.test.ts
@@ -93,7 +93,7 @@ describe('Claude structured reading control', () => {
     const claude = fakeClaude({ exitBeforeInit: 'claude stream-json exited (code 1)' })
     const adapter = adapterFor(
       claude,
-      { resumed: true, resumeLeafUuid: 'tip' },
+      { resumesTranscript: true, continuesChain: true, resumeLeafUuid: 'tip' },
       [],
       [],
       undefined,
diff --git a/src/main/claude/claude-structured-session-recovery.test.ts b/src/main/claude/claude-structured-session-recovery.test.ts
index 0675d8c0acf7..e24dd25c369a 100644
--- a/src/main/claude/claude-structured-session-recovery.test.ts
+++ b/src/main/claude/claude-structured-session-recovery.test.ts
@@ -65,7 +65,8 @@ describe('ClaudeStructuredSessionAdapter transcript-derived recovery', () => {
         claudeConfigDir: '/accounts/claude',
         providerSessionId: PROVIDER_SESSION_ID,
         resumeLeafUuid: null,
-        resumed: false
+        resumesTranscript: false,
+        continuesChain: false
       }),
       onEvent: (event) => {
         events.push(event)
@@ -479,7 +480,8 @@ describe('ClaudeStructuredSessionAdapter transcript-derived recovery', () => {
           claudeConfigDir: '/accounts/claude',
           providerSessionId: PROVIDER_SESSION_ID,
           resumeLeafUuid: null,
-          resumed: false
+          resumesTranscript: false,
+          continuesChain: false
         }
       }
       return {
@@ -489,7 +491,8 @@ describe('ClaudeStructuredSessionAdapter transcript-derived recovery', () => {
         claudeConfigDir: '/accounts/claude',
         providerSessionId: PROVIDER_SESSION_ID,
         resumeLeafUuid: durableLeafUuid,
-        resumed: true
+        resumesTranscript: true,
+        continuesChain: true
       }
     })
     const persistHandle = vi.fn<NonNullable<ClaudeStructuredSessionAdapterDeps['persistHandle']>>(
diff --git a/src/main/claude/claude-structured-session-startup.ts b/src/main/claude/claude-structured-session-startup.ts
index 6b6560d86f27..6250e851912b 100644
--- a/src/main/claude/claude-structured-session-startup.ts
+++ b/src/main/claude/claude-structured-session-startup.ts
@@ -67,7 +67,7 @@ export async function readClaudeStartupFacts(input: {
   initProof: ClaudeInitProof
   sessionId: string
   providerSessionId: string
-  resumed: boolean
+  resumesTranscript: boolean
   inputOptions: StructuredAgentSessionAcquireInput['options']
   requestTimeoutMs: number | undefined
   recordPhase?: StructuredAgentSessionAcquireInput['recordPhase']
@@ -115,7 +115,7 @@ export async function readClaudeStartupFacts(input: {
       settings,
       initialization,
       inputOptions: input.inputOptions,
-      resumed: input.resumed
+      resumesTranscript: input.resumesTranscript
     })
   }
 }
diff --git a/src/main/claude/claude-structured-session-test-support.ts b/src/main/claude/claude-structured-session-test-support.ts
index 9cf137c634a9..67c90f906887 100644
--- a/src/main/claude/claude-structured-session-test-support.ts
+++ b/src/main/claude/claude-structured-session-test-support.ts
@@ -237,7 +237,8 @@ export function adapterAtPublishFor(
       claudeConfigDir: '/accounts/claude',
       providerSessionId: PROVIDER_SESSION_ID,
       resumeLeafUuid: null,
-      resumed: false,
+      resumesTranscript: false,
+      continuesChain: false,
       ...launch
     }),
     onEvent: (event) => events.push(event),
diff --git a/src/main/claude/claude-tui-resume-real-binary.integration.test.ts b/src/main/claude/claude-tui-resume-real-binary.integration.test.ts
index f8822505c5a5..ff525f640237 100644
--- a/src/main/claude/claude-tui-resume-real-binary.integration.test.ts
+++ b/src/main/claude/claude-tui-resume-real-binary.integration.test.ts
@@ -189,7 +189,8 @@ describe.skipIf(!claudeAuthenticated)('real Claude TUI resume proof', () => {
         claudeConfigDir,
         providerSessionId,
         resumeLeafUuid: null,
-        resumed: false
+        resumesTranscript: false,
+        continuesChain: false
       }),
       onEvent: (event) => events.push(event),
       onDispatchSettledLate: (settlement) => settlements.push(settlement),
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-provider-started.test.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-provider-started.test.ts
index fa5d6c238f04..52699fd062f6 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-provider-started.test.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-provider-started.test.ts
@@ -47,7 +47,8 @@ beforeEach(async () => {
       providerSessionId: PROVIDER_SESSION_ID,
       resumeLeafUuid: null,
       // A session that already minted its provider handle resumes it, as the real launch does.
-      resumed: (store.getRecord(SESSION)?.providerHandleChain.length ?? 0) > 0
+      resumesTranscript: (store.getRecord(SESSION)?.providerHandleChain.length ?? 0) > 0,
+      continuesChain: (store.getRecord(SESSION)?.providerHandleChain.length ?? 0) > 0
     }),
     // The runtime's own mapping, so this test drives the same lifecycle path production does.
     onEvent: (event) => {
diff --git a/src/main/runtime/claude-structured-failed-start-resume.test.ts b/src/main/runtime/claude-structured-failed-start-resume.test.ts
new file mode 100644
index 000000000000..c46d632a6645
--- /dev/null
+++ b/src/main/runtime/claude-structured-failed-start-resume.test.ts
@@ -0,0 +1,52 @@
+// A Claude chat whose first start died before initialize (not signed in, a crash) wrote no
+// transcript, so its next start launches that same provider id fresh. It is still the same
+// conversation: the new child continues the record's chain rather than creating a second root.
+
+import { afterEach, describe, expect, it, vi } from 'vitest'
+import { claudeSessionIdForOrcaSession } from '../claude/claude-structured-launch-resolution'
+import { waitForStructuredAgentSessionRecovery } from './structured-agent-session-runtime'
+import { createScriptedClaudeRuntime } from './structured-claude-scripted-runtime-test-support'
+
+const SESSION = 'claude-failed-start'
+const CALLER = { callerKey: 'client-1' }
+
+let claude = createScriptedClaudeRuntime([SESSION])
+
+afterEach(async () => {
+  await claude.dispose()
+  claude = createScriptedClaudeRuntime([SESSION])
+})
+
+describe('a Claude chat whose first start died before initialize', () => {
+  it('resumes on reopen, launching its id fresh and continuing the same chain', async () => {
+    claude.behave(SESSION, { initHangs: true })
+    const host = await claude.install()
+    await expect(host.attach(CALLER, claude.attachParams(SESSION, null))).resolves.toMatchObject({
+      ok: true
+    })
+    claude.child(SESSION).exit(new Error('claude stream-json exited (code 1): not signed in'))
+    await waitForStructuredAgentSessionRecovery()
+    const failed = host.deps.store.getRecord(SESSION)
+    expect(failed?.lease.claimStatus).toBe('released')
+
+    // The user signs in and reopens the chat.
+    claude.behave(SESSION, {})
+    const reopened = await host.attach(
+      CALLER,
+      claude.attachParams(SESSION, failed?.lease.runtimeFence ?? null)
+    )
+
+    expect(reopened, JSON.stringify(reopened)).toMatchObject({ ok: true })
+    const providerSessionId = claudeSessionIdForOrcaSession(SESSION)
+    // No transcript exists to `--resume`, so the id is started fresh...
+    expect(claude.child(SESSION).launch.options).toMatchObject({ sessionId: providerSessionId })
+    expect(claude.child(SESSION).launch.options.resume).toBeUndefined()
+    // ...and the record still holds one conversation under one root.
+    expect(
+      host.deps.store.getRecord(SESSION)?.providerHandleChain.map((link) => link.origin)
+    ).toEqual(['created', 'resumed'])
+    await vi.waitFor(() =>
+      expect(host.deps.store.getRecord(SESSION)?.lease.claimStatus).toBe('live')
+    )
+  })
+})
diff --git a/src/main/runtime/structured-agent-session-runtime-provider-started.test.ts b/src/main/runtime/structured-agent-session-runtime-provider-started.test.ts
index c922d1e0abe4..a2921ee41ea6 100644
--- a/src/main/runtime/structured-agent-session-runtime-provider-started.test.ts
+++ b/src/main/runtime/structured-agent-session-runtime-provider-started.test.ts
@@ -2,178 +2,40 @@
 // proving its start must not make that chain, or the session's own serialized operations,
 // wait on the CLI: the host records what the child proved from what the adapter already holds.
 
-import { mkdir, mkdtemp, rm } from 'node:fs/promises'
-import { tmpdir } from 'node:os'
-import { join } from 'node:path'
 import { afterEach, describe, expect, it, vi } from 'vitest'
-import type {
-  ClaudeStreamJsonConnection,
-  ClaudeStreamJsonConnectionHandlers,
-  openClaudeStreamJsonConnection
-} from '../claude/claude-stream-json-connection'
-import { claudeSessionIdForOrcaSession } from '../claude/claude-structured-launch-resolution'
-import { hostTestAttachParams } from '../native-chat/agent-session-wire/structured-agent-session-host-test-data'
-import type { StructuredAgentSessionHost } from '../native-chat/agent-session-wire/structured-agent-session-host'
-import {
-  ensureStructuredAgentSessionHost,
-  stopStructuredAgentSessionRuntime,
-  waitForStructuredAgentSessionRecovery
-} from './structured-agent-session-runtime'
+import { waitForStructuredAgentSessionRecovery } from './structured-agent-session-runtime'
+import { createScriptedClaudeRuntime } from './structured-claude-scripted-runtime-test-support'
 
 const STALLED = 'claude-started-stalled'
 const HEALTHY = 'claude-started-healthy'
 const CALLER = { callerKey: 'client-1' }
 
-type ScriptedClaude = {
-  sessionId: string
-  calls: string[]
-  handlers: ClaudeStreamJsonConnectionHandlers
-  connection: Omit<ClaudeStreamJsonConnection, 'closed' | 'exitVerdict'> & {
-    closed: boolean
-    exitVerdict: ClaudeStreamJsonConnection['exitVerdict']
-  }
-}
-
-let root: string | null = null
-let operations = 0
-// The runtime's own clock admits operation ids, so these are minted against it.
-const operationId = (): string => `${Date.now()}-${(++operations).toString(16).padStart(32, '0')}`
-let releaseStall: () => void = () => {}
+let claude = createScriptedClaudeRuntime([STALLED, HEALTHY])
 
 afterEach(async () => {
-  releaseStall()
-  await stopStructuredAgentSessionRuntime()
-  if (root) {
-    await rm(root, { recursive: true, force: true })
-    root = null
-  }
+  await claude.dispose()
+  claude = createScriptedClaudeRuntime([STALLED, HEALTHY])
 })
 
-/** A CLI that answers startup, then never answers another control read for `stalledSessionId`. */
-function scriptedClaude(stalledSessionId: string) {
-  const children: ScriptedClaude[] = []
-  let release = (): void => {}
-  const stall = new Promise<void>((resolve) => {
-    release = resolve
-  })
-  const answer = <T>(child: ScriptedClaude, value: T, startup: boolean): Promise<T> =>
-    child.sessionId === stalledSessionId && !startup
-      ? stall.then(() => value)
-      : Promise.resolve(value)
-  const openConnection: typeof openClaudeStreamJsonConnection = async (launch, handlers = {}) => {
-    const providerSessionId = String(launch.options.sessionId ?? launch.options.resume)
-    const sessionId = [STALLED, HEALTHY].find(
-      (candidate) => claudeSessionIdForOrcaSession(candidate) === providerSessionId
-    )!
-    let settingsReads = 0
-    const child: ScriptedClaude = {
-      sessionId,
-      calls: [],
-      handlers,
-      connection: {
-        pid: 5000 + children.length,
-        closed: false,
-        exitVerdict: { root: 'live', tree: 'unverifiable' },
-        initializationResult: async () => {
-          handlers.onMessage?.({
-            type: 'system',
-            subtype: 'init',
-            session_id: providerSessionId,
-            model: 'claude-sonnet-5',
-            apiKeySource: 'none'
-          })
-          return { models: [{ value: 'sonnet', displayName: 'Sonnet' }] }
-        },
-        getSettings: () => {
-          child.calls.push('get_settings')
-          settingsReads += 1
-          return answer(child, { effective: { effortLevel: 'high' } }, settingsReads === 1)
-        },
-        supportedModels: () => {
-          child.calls.push('list_models')
-          return answer(child, [{ value: 'sonnet', displayName: 'Sonnet' }], false)
-        },
-        setModel: async () => {},
-        setPermissionMode: async () => {},
-        applyFlagSettings: async () => {},
-        interrupt: async () => undefined,
-        cancelAsyncMessage: async () => {},
-        stopTask: async () => {},
-        send: async () => {},
-        close: async () => {
-          child.connection.closed = true
-          return true
-        }
-      }
-    }
-    children.push(child)
-    return child.connection
-  }
-  const child = (sessionId: string): ScriptedClaude => {
-    const found = children.findLast((entry) => entry.sessionId === sessionId)
-    if (!found) {
-      throw new Error(`no Claude child for ${sessionId}`)
-    }
-    return found
-  }
-  return { openConnection, child, release: () => release() }
-}
-
-function claudeParams(sessionId: string) {
-  return hostTestAttachParams(null, {
-    envelope: {
-      sessionId,
-      clientOperationId: operationId(),
-      expectedRuntimeFence: null,
-      payloadFingerprint: ''
-    },
-    provider: 'claude',
-    agent: 'claude',
-    accountHome: { variable: 'CLAUDE_CONFIG_DIR', path: join(root!, 'claude-home') },
-    providerHandle: {
-      kind: 'claude',
-      sessionId: claudeSessionIdForOrcaSession(sessionId),
-      leafUuid: null
-    }
-  })
-}
-
-async function install(
-  claude: ReturnType<typeof scriptedClaude>
-): Promise<StructuredAgentSessionHost> {
-  root = await mkdtemp(join(tmpdir(), 'orca-runtime-provider-started-'))
-  await mkdir(join(root, 'claude-home'), { recursive: true })
-  return ensureStructuredAgentSessionHost({
-    stateDirectory: root,
-    hostId: 'local',
-    claimKeyId: 'key-1',
-    resolveWorkspacePath: async () => root!,
-    resolveClaudeCommand: () => '/usr/local/bin/claude',
-    resolveClaudeAuthPolicy: () => ({ stripAuthEnv: false }),
-    openClaudeConnection: claude.openConnection,
-    readProcessStartTime: async (pid: number) => pid * 10
-  })
-}
-
 describe('a Claude child proving its start', () => {
   it("never holds another session's exit recovery, or its own close, on a CLI read", async () => {
-    const claude = scriptedClaude(STALLED)
-    releaseStall = claude.release
-    const host = await install(claude)
+    claude.behave(STALLED, { stallsControlReads: true })
+    const host = await claude.install()
 
-    const first = await host.attach(CALLER, claudeParams(HEALTHY))
-    expect(first, JSON.stringify(first)).toMatchObject({ ok: true })
+    await expect(host.attach(CALLER, claude.attachParams(HEALTHY, null))).resolves.toMatchObject({
+      ok: true
+    })
     await waitForStructuredAgentSessionRecovery()
 
     // This child answers startup, then never answers another control read.
-    await expect(host.attach(CALLER, claudeParams(STALLED))).resolves.toMatchObject({ ok: true })
+    await expect(host.attach(CALLER, claude.attachParams(STALLED, null))).resolves.toMatchObject({
+      ok: true
+    })
     await vi.waitFor(() => expect(claude.child(STALLED).calls).toContain('get_settings'))
     // Its `started` reaches the shared chain ahead of the exit below.
     await new Promise((resolve) => setImmediate(resolve))
 
-    const healthy = claude.child(HEALTHY)
-    healthy.connection.exitVerdict = { root: 'exited', tree: 'unverifiable' }
-    healthy.handlers.onExit?.(new Error('claude stream-json exited (code 1): crashed'))
+    claude.child(HEALTHY).exit(new Error('claude stream-json exited (code 1): crashed'))
     await vi.waitFor(() =>
       expect(host.deps.store.getRecord(HEALTHY)?.lease.claimStatus).toBe('released')
     )
diff --git a/src/main/runtime/structured-claude-scripted-runtime-test-support.ts b/src/main/runtime/structured-claude-scripted-runtime-test-support.ts
new file mode 100644
index 000000000000..3f971ce24b57
--- /dev/null
+++ b/src/main/runtime/structured-claude-scripted-runtime-test-support.ts
@@ -0,0 +1,175 @@
+// A structured-session runtime whose Claude children are scripted: the production runtime,
+// adapter, record store and host, with only the CLI process replaced.
+
+import { mkdir, mkdtemp, rm } from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import type {
+  ClaudeStreamJsonConnection,
+  ClaudeStreamJsonConnectionHandlers,
+  ClaudeStreamJsonLaunch,
+  openClaudeStreamJsonConnection
+} from '../claude/claude-stream-json-connection'
+import { claudeSessionIdForOrcaSession } from '../claude/claude-structured-launch-resolution'
+import { hostTestAttachParams } from '../native-chat/agent-session-wire/structured-agent-session-host-test-data'
+import type { StructuredAgentSessionHost } from '../native-chat/agent-session-wire/structured-agent-session-host'
+import {
+  ensureStructuredAgentSessionHost,
+  stopStructuredAgentSessionRuntime
+} from './structured-agent-session-runtime'
+
+export type ScriptedClaudeBehavior = {
+  /** Initialize never answers; only the child's exit settles it. */
+  initHangs?: boolean
+  /** Every control read after startup's own settings read waits for `releaseStalls`. */
+  stallsControlReads?: boolean
+}
+
+export type ScriptedClaudeChild = {
+  sessionId: string
+  launch: ClaudeStreamJsonLaunch
+  calls: string[]
+  handlers: ClaudeStreamJsonConnectionHandlers
+  connection: Omit<ClaudeStreamJsonConnection, 'closed' | 'exitVerdict'> & {
+    closed: boolean
+    exitVerdict: ClaudeStreamJsonConnection['exitVerdict']
+  }
+  /** The CLI exits on its own: its root is gone, its tree unverifiable. */
+  exit: (error: Error) => void
+}
+
+export function createScriptedClaudeRuntime(sessionIds: readonly string[]) {
+  const children: ScriptedClaudeChild[] = []
+  const behaviors = new Map<string, ScriptedClaudeBehavior>()
+  let releaseStalls = (): void => {}
+  const stall = new Promise<void>((resolve) => {
+    releaseStalls = resolve
+  })
+  let root: string | null = null
+  let operations = 0
+
+  const openConnection: typeof openClaudeStreamJsonConnection = async (launch, handlers = {}) => {
+    const providerSessionId = String(launch.options.sessionId ?? launch.options.resume)
+    const sessionId = sessionIds.find(
+      (candidate) => claudeSessionIdForOrcaSession(candidate) === providerSessionId
+    )
+    if (!sessionId) {
+      throw new Error(`no scripted Claude session for ${providerSessionId}`)
+    }
+    const behavior = behaviors.get(sessionId) ?? {}
+    let failInit = (_error: Error): void => {}
+    const answer = <T>(value: T, startup: boolean): Promise<T> =>
+      behavior.stallsControlReads && !startup ? stall.then(() => value) : Promise.resolve(value)
+    let settingsReads = 0
+    const child: ScriptedClaudeChild = {
+      sessionId,
+      launch,
+      calls: [],
+      handlers,
+      exit: (error) => {
+        child.connection.exitVerdict = { root: 'exited', tree: 'unverifiable' }
+        failInit(error)
+        handlers.onExit?.(error)
+      },
+      connection: {
+        pid: 5000 + children.length,
+        closed: false,
+        exitVerdict: { root: 'live', tree: 'unverifiable' },
+        initializationResult: () => {
+          if (behavior.initHangs) {
+            return new Promise((_resolve, reject) => {
+              failInit = reject
+            })
+          }
+          handlers.onMessage?.({
+            type: 'system',
+            subtype: 'init',
+            session_id: providerSessionId,
+            model: 'claude-sonnet-5',
+            apiKeySource: 'none'
+          })
+          return Promise.resolve({ models: [{ value: 'sonnet', displayName: 'Sonnet' }] })
+        },
+        getSettings: () => {
+          child.calls.push('get_settings')
+          settingsReads += 1
+          return answer({ effective: { effortLevel: 'high' } }, settingsReads === 1)
+        },
+        supportedModels: () => {
+          child.calls.push('list_models')
+          return answer([{ value: 'sonnet', displayName: 'Sonnet' }], false)
+        },
+        setModel: async () => {},
+        setPermissionMode: async () => {},
+        applyFlagSettings: async () => {},
+        interrupt: async () => undefined,
+        cancelAsyncMessage: async () => {},
+        stopTask: async () => {},
+        send: async () => {},
+        close: async () => {
+          child.connection.closed = true
+          return true
+        }
+      }
+    }
+    children.push(child)
+    return child.connection
+  }
+
+  return {
+    behave: (sessionId: string, behavior: ScriptedClaudeBehavior): void => {
+      behaviors.set(sessionId, behavior)
+    },
+    /** The latest child spawned for `sessionId`. */
+    child: (sessionId: string): ScriptedClaudeChild => {
+      const found = children.findLast((entry) => entry.sessionId === sessionId)
+      if (!found) {
+        throw new Error(`no Claude child for ${sessionId}`)
+      }
+      return found
+    },
+    children: (sessionId: string): ScriptedClaudeChild[] =>
+      children.filter((entry) => entry.sessionId === sessionId),
+    install: async (): Promise<StructuredAgentSessionHost> => {
+      root = await mkdtemp(join(tmpdir(), 'orca-scripted-claude-runtime-'))
+      await mkdir(join(root, 'claude-home'), { recursive: true })
+      const directory = root
+      return ensureStructuredAgentSessionHost({
+        stateDirectory: directory,
+        hostId: 'local',
+        claimKeyId: 'key-1',
+        resolveWorkspacePath: async () => directory,
+        resolveClaudeCommand: () => '/usr/local/bin/claude',
+        resolveClaudeAuthPolicy: () => ({ stripAuthEnv: false }),
+        openClaudeConnection: openConnection,
+        readProcessStartTime: async (pid: number) => pid * 10
+      })
+    },
+    attachParams: (sessionId: string, expectedRuntimeFence: number | null) =>
+      hostTestAttachParams(expectedRuntimeFence, {
+        envelope: {
+          sessionId,
+          // The runtime's own clock admits operation ids, so these are minted against it.
+          clientOperationId: `${Date.now()}-${(++operations).toString(16).padStart(32, '0')}`,
+          expectedRuntimeFence,
+          payloadFingerprint: ''
+        },
+        provider: 'claude',
+        agent: 'claude',
+        accountHome: { variable: 'CLAUDE_CONFIG_DIR', path: join(root ?? '', 'claude-home') },
+        providerHandle: {
+          kind: 'claude',
+          sessionId: claudeSessionIdForOrcaSession(sessionId),
+          leafUuid: null
+        }
+      }),
+    dispose: async (): Promise<void> => {
+      releaseStalls()
+      await stopStructuredAgentSessionRuntime()
+      if (root) {
+        await rm(root, { recursive: true, force: true })
+        root = null
+      }
+    }
+  }
+}

From a666d882c0c222f473ac3521fbb4aacff475434c Mon Sep 17 00:00:00 2001
From: Brennan Benson <79079362+brennanb2025@users.noreply.github.com>
Date: Wed, 23 Sep 2026 12:08:51 -0700
Subject: [PATCH 30/67] refactor(native-chat): a resume answers with a typed
 refusal the send classifies
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

`resumeHeldStructuredAgentSession` and the holds' `ensureProviderChild` answer
`{ ok: true } | { ok: false, refusal }` instead of throwing the refusal code.
The refusal is the attach's own, with its message and, when the failed attach
proved its child gone, its `ownerVerdict`. An attach that settles a failed
acquisition in the ledger and then rethrows the cause is read back off that row,
so a durably failed restart is a refusal and only an unrecorded error is a fault.

The send classifies the refusal through a `Record` over every wire code — a new
code does not compile until it is placed — into transient (the lease is someone
else's to settle; the send runs as the lease stands) or terminal. A terminal
one answers `agent_session_owner_unrecoverable` carrying the cause, forwards the
verdict, and writes the same status row into the chat that a start that failed
leaves, so the user sees why after the error strip is gone. Nothing about the
failure is remembered; a Retry is a fresh attempt. A fault thrown by the restart
itself is reported and the send runs as the lease stands, since bookkeeping
never gates a user's action.

`hold()` still raises the refusal code for its RPC caller.
---
 ...gent-session-dead-generation-settlement.ts |   9 ++
 ...structured-agent-session-event-recovery.ts |  31 ++---
 ...red-agent-session-hold-resume-race.test.ts |   6 +-
 .../structured-agent-session-hold-resume.ts   | 111 ++++++++++++---
 .../structured-agent-session-holds.test.ts    |   9 +-
 .../structured-agent-session-holds.ts         |  51 +++++--
 .../structured-agent-session-host-lifetime.ts |  14 +-
 ...ctured-agent-session-refusal-retry.test.ts |   2 +
 ...red-agent-session-send-preparation.test.ts |  73 +++++++++-
 ...ructured-agent-session-send-preparation.ts | 131 ++++++++++++++----
 10 files changed, 344 insertions(+), 93 deletions(-)

diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-dead-generation-settlement.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-dead-generation-settlement.ts
index 259df8a3a55e..fda95a0ce739 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-dead-generation-settlement.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-dead-generation-settlement.ts
@@ -32,6 +32,15 @@ export function unexpectedProviderExitOutcome(reason?: string): string {
     : UNEXPECTED_PROVIDER_EXIT_OUTCOME
 }
 
+/** A restart that produced no child, answered to the send that asked for it; its cause is the
+ *  whole story, and nothing is remembered, so the next try is a fresh one. */
+export function providerRestartFailureOutcome(reason?: string): string {
+  const detail = exitReasonDetail(reason)
+  return detail
+    ? `This chat's agent could not be restarted: ${detail}. Retry, or start a new chat.`
+    : "This chat's agent stopped and could not be restarted. Retry, or start a new chat."
+}
+
 /** A start that never finished has no response to interrupt; its cause is the whole story. */
 export function providerStartupFailureOutcome(reason?: string): string {
   const detail = exitReasonDetail(reason)
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-event-recovery.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-event-recovery.ts
index ac569a286c29..851b08a1d20c 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-event-recovery.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-event-recovery.ts
@@ -1,4 +1,3 @@
-import { attachStructuredAgentSessionUnderSerialize } from './structured-agent-session-attach-orchestration'
 import type { StructuredAgentSessionAttachContext } from './structured-agent-session-attach-context'
 import type { StructuredAgentSessionLifecycleEvent } from './structured-agent-session-adapter'
 import type {
@@ -77,23 +76,23 @@ export class StructuredAgentSessionEventRecovery {
     // has already replaced the owner, and this attach then refuses on the stale ticket rather than
     // spawning a second child against the fence it moved.
     try {
-      await this.context.serialize(ticket.sessionId, () => {
-        const attachContext = this.context.attachContext()
-        return resumeHeldStructuredAgentSession({
+      const resumed = await this.context.serialize(ticket.sessionId, () =>
+        resumeHeldStructuredAgentSession({
           sessionId: ticket.sessionId,
-          context: attachContext,
-          attach: (params) =>
-            attachStructuredAgentSessionUnderSerialize(
-              attachContext,
-              'trusted-local:provider-exit-recovery',
-              params,
-              {
-                admitRecoveryTicket: () =>
-                  isStructuredAgentSessionRecoveryTicketCurrent(this.context, ticket)
-              }
-            )
+          context: this.context.attachContext(),
+          callerKey: 'trusted-local:provider-exit-recovery',
+          attachOptions: {
+            admitRecoveryTicket: () =>
+              isStructuredAgentSessionRecoveryTicketCurrent(this.context, ticket)
+          }
         })
-      })
+      )
+      if (!resumed.ok && isStructuredAgentSessionRecoveryTicketCurrent(this.context, ticket)) {
+        this.context.onBarrierError(
+          ticket.sessionId,
+          new Error(`${resumed.refusal.code}: ${resumed.refusal.message}`)
+        )
+      }
     } catch (error) {
       if (isStructuredAgentSessionRecoveryTicketCurrent(this.context, ticket)) {
         this.context.onBarrierError(ticket.sessionId, error)
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-hold-resume-race.test.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-hold-resume-race.test.ts
index 2f5af0df24f9..637a37fb88d3 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-hold-resume-race.test.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-hold-resume-race.test.ts
@@ -1,5 +1,6 @@
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
 import { runKeyedSerializedOperation } from '../../cli/keyed-promise-queue'
+import type { StructuredAgentSessionResumeOutcome } from './structured-agent-session-hold-resume'
 import { StructuredAgentSessionHolds } from './structured-agent-session-holds'
 
 const GRACE_MS = 15_000
@@ -22,6 +23,7 @@ function resumeHarness() {
   const resume = vi.fn(async () => {
     await resumeGate.promise
     child = true
+    return { ok: true as const }
   })
   const holds = new StructuredAgentSessionHolds({
     resume,
@@ -206,6 +208,7 @@ describe('a surface leaving while its structured session resumes', () => {
       resume: async () => {
         child = true
         await gate.promise
+        return { ok: true as const }
       },
       serialize: keyedSerialize(),
       hasProviderChild: () => child,
@@ -232,10 +235,11 @@ describe('a surface leaving while its structured session resumes', () => {
   it('starts a fresh resume once the failed one has settled', async () => {
     let child = false
     const resume = vi
-      .fn<() => Promise<void>>()
+      .fn<() => Promise<StructuredAgentSessionResumeOutcome>>()
       .mockRejectedValueOnce(new Error('first acquisition failed'))
       .mockImplementationOnce(async () => {
         child = true
+        return { ok: true }
       })
     const holds = new StructuredAgentSessionHolds({
       resume,
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-hold-resume.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-hold-resume.ts
index 6b073057e2b7..9ea59e18487c 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-hold-resume.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-hold-resume.ts
@@ -9,57 +9,122 @@
 
 import type {
   AgentSessionAttachResult,
-  AgentSessionMutationResult
+  AgentSessionMutationResult,
+  AgentSessionWireRefusal
 } from '../../../shared/agent-session-wire'
-import type { AgentSessionAttachParams } from './structured-agent-session-attach'
+import { isAgentSessionWireRefusalCode } from '../../../shared/agent-session-wire-refusals'
 import type { StructuredAgentSessionAttachContext } from './structured-agent-session-attach-context'
+import {
+  attachStructuredAgentSessionUnderSerialize,
+  type StructuredAgentSessionAttachOptions
+} from './structured-agent-session-attach-orchestration'
+import { failedCreateRefusal } from './structured-agent-session-failed-create-refusal'
 import { adapterSupportsRecord } from './structured-agent-session-provider-support'
 import {
   structuredAgentSessionResumeOperationId,
   structuredAgentSessionResumeParams
 } from './structured-agent-session-resume-eligibility'
 
+/** A resume answers with the attach's own refusal, verdict and all, so the asker can tell a lease
+ *  someone else is settling from an owner that will not come back. */
+export type StructuredAgentSessionResumeOutcome =
+  | { ok: true }
+  | { ok: false; refusal: AgentSessionWireRefusal }
+
 export async function resumeHeldStructuredAgentSession(input: {
   sessionId: string
-  context: Pick<
-    StructuredAgentSessionAttachContext,
-    'deps' | 'runtimeState' | 'reconcileLeases' | 'now'
-  >
-  attach: (
-    params: AgentSessionAttachParams
-  ) => Promise<AgentSessionMutationResult<AgentSessionAttachResult>>
-}): Promise<void> {
-  const { sessionId, context } = input
+  context: StructuredAgentSessionAttachContext
+  /** Who is asking; the attach keys the ledger row it settles by it. */
+  callerKey: string
+  attachOptions?: StructuredAgentSessionAttachOptions
+}): Promise<StructuredAgentSessionResumeOutcome> {
+  const { sessionId, context, callerKey } = input
   // The record is read only once this host has adjudicated it and exited any recovery stage a
   // failed attempt latched — a lease left in `manual-recovery` by an unproven exit is one the
   // resolver hands back, and the eligibility below must see it that way.
   const unreconciled = await context.reconcileLeases(sessionId)
   if (unreconciled) {
-    throw new Error(unreconciled.code)
+    return { ok: false, refusal: unreconciled }
   }
   await context.runtimeState.resolveRecovery(sessionId)
   const record = context.deps.store.getRecord(sessionId)
   if (!record) {
-    throw new Error('agent_session_identity_required')
+    return refuse('agent_session_identity_required', 'No structured session exists by that id.')
   }
   if (!adapterSupportsRecord(context.deps.adapter, record)) {
-    throw new Error('structured_agent_session_unsupported')
+    return refuse(
+      'structured_agent_session_unsupported',
+      'This execution host cannot resume the requested structured agent session.'
+    )
   }
   const params = structuredAgentSessionResumeParams(
     record,
     structuredAgentSessionResumeOperationId(context.now())
   )
   if (!params) {
-    throw new Error(
-      record.lease.unreconciled
-        ? 'execution_owner_reconciling'
-        : record.lease.claimStatus === 'conflicted'
-          ? 'agent_session_conflict'
-          : 'agent_session_ownership_unknown'
+    return record.lease.unreconciled
+      ? refuse(
+          'execution_owner_reconciling',
+          'This host has not yet adjudicated the session lease.'
+        )
+      : record.lease.claimStatus === 'conflicted'
+        ? refuse('agent_session_conflict', 'Another process claims this session.')
+        : refuse(
+            'agent_session_ownership_unknown',
+            'The session lease is not one this host may resume.'
+          )
+  }
+  let attached: AgentSessionMutationResult<AgentSessionAttachResult>
+  try {
+    attached = await attachStructuredAgentSessionUnderSerialize(
+      context,
+      callerKey,
+      params,
+      input.attachOptions
+    )
+  } catch (error) {
+    // The attach settles an acquisition that failed — the ledger row, the released lease — before
+    // it rethrows the cause. That row is the answer: a failure it recorded is this resume's
+    // refusal, verdict and all. Only an error it did not record is a fault for the caller.
+    const settled = settledResumeRefusal(
+      context,
+      callerKey,
+      params.envelope.clientOperationId,
+      sessionId,
+      error
     )
+    if (settled) {
+      return settled
+    }
+    throw error
   }
-  const attached = await input.attach(params)
-  if (!attached.ok) {
-    throw new Error(attached.refusal.code)
+  return attached.ok ? { ok: true } : { ok: false, refusal: attached.refusal }
+}
+
+function settledResumeRefusal(
+  context: Pick<StructuredAgentSessionAttachContext, 'deps'>,
+  callerKey: string,
+  operationId: string,
+  sessionId: string,
+  error: unknown
+): StructuredAgentSessionResumeOutcome | null {
+  const outcome = context.deps.store.getOperationRow(callerKey, operationId)?.outcome
+  if (outcome?.status !== 'failed' || !isAgentSessionWireRefusalCode(outcome.code)) {
+    return null
   }
+  return failedCreateRefusal(
+    {
+      code: outcome.code,
+      message: outcome.message ?? (error instanceof Error ? error.message : String(error))
+    },
+    outcome.status,
+    context.deps.store.getRecord(sessionId)
+  )
+}
+
+function refuse(
+  code: AgentSessionWireRefusal['code'],
+  message: string
+): StructuredAgentSessionResumeOutcome {
+  return { ok: false, refusal: { code, message } }
 }
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-holds.test.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-holds.test.ts
index 2157256c5353..d8e240817a10 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-holds.test.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-holds.test.ts
@@ -178,6 +178,7 @@ describe('holds', () => {
     let child = false
     const resume = vi.fn(async () => {
       child = true
+      return { ok: true as const }
     })
     const holds = new StructuredAgentSessionHolds({
       resume,
@@ -206,6 +207,7 @@ describe('holds', () => {
     const resume = vi.fn(async () => {
       await gate.promise
       child = true
+      return { ok: true as const }
     })
     const serialize = keyedSerialize()
     const holds = new StructuredAgentSessionHolds({
@@ -222,7 +224,7 @@ describe('holds', () => {
     const hold = holds.hold('session-1', 'chat-1')
     gate.resolve()
 
-    await expect(writer).resolves.toBeUndefined()
+    await expect(writer).resolves.toEqual({ ok: true })
     await hold
     // The hold ran after the writer's step and found the child: nothing to resume.
     expect(resume).toHaveBeenCalledOnce()
@@ -238,6 +240,7 @@ describe('holds', () => {
     const holds = new StructuredAgentSessionHolds({
       resume: async () => {
         child = true
+        return { ok: true as const }
       },
       serialize,
       hasProviderChild: () => child,
@@ -256,7 +259,7 @@ describe('holds', () => {
   it('never arms the clock for a session with nothing to stop', async () => {
     const evict = vi.fn(async () => {})
     const holds = new StructuredAgentSessionHolds({
-      resume: async () => {},
+      resume: async () => ({ ok: true as const }),
       serialize: keyedSerialize(),
       hasProviderChild: () => false,
       isTurnActive: () => false,
@@ -275,7 +278,7 @@ describe('holds', () => {
 
   it('fails a write-capable hold when resume proves no provider child', async () => {
     const holds = new StructuredAgentSessionHolds({
-      resume: async () => {},
+      resume: async () => ({ ok: true as const }),
       serialize: keyedSerialize(),
       hasProviderChild: () => false,
       isTurnActive: () => false,
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-holds.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-holds.ts
index 362119d1e0d7..fc88974f14a9 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-holds.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-holds.ts
@@ -21,11 +21,11 @@ import {
   type StructuredAgentSessionReleaseClockDeps
 } from './structured-agent-session-release-clock'
 import { StructuredAgentSessionHolders } from './structured-agent-session-holders'
+import type { StructuredAgentSessionResumeOutcome } from './structured-agent-session-hold-resume'
 
 export type StructuredAgentSessionHoldsDeps = {
-  /** Attaches a provider child, for a caller already inside `serialize`. Throws the refusal code
-   *  when it cannot. */
-  resume: (sessionId: string) => Promise<void>
+  /** Attaches a provider child, for a caller already inside `serialize`. */
+  resume: (sessionId: string) => Promise<StructuredAgentSessionResumeOutcome>
   serialize: <T>(sessionId: string, task: () => Promise<T>) => Promise<T>
   /** Whether evicting this session would actually free anything. */
   hasProviderChild: (sessionId: string) => boolean
@@ -71,16 +71,31 @@ export class StructuredAgentSessionHolds {
     if (options.resume === false) {
       return
     }
+    let resumed: StructuredAgentSessionResumeOutcome
     try {
-      await this.deps.serialize(sessionId, () => this.ensureProviderChild(sessionId))
+      resumed = await this.deps.serialize(sessionId, () => this.ensureProviderChild(sessionId))
     } catch (error) {
-      // Only the holder this call added, at the incarnation it added: a same-ID hold that left
-      // and came back while this one waited owns the holder now, and its own attempt decides it.
-      if (!alreadyHeld && incarnation !== undefined) {
-        this.release(sessionId, holderId, incarnation)
-      }
+      this.releaseFailedHold(sessionId, holderId, alreadyHeld, incarnation)
       throw error
     }
+    if (!resumed.ok) {
+      this.releaseFailedHold(sessionId, holderId, alreadyHeld, incarnation)
+      // The RPC surface raises a refusal as its code.
+      throw new Error(resumed.refusal.code)
+    }
+  }
+
+  /** Only the holder this call added, at the incarnation it added: a same-ID hold that left and
+   *  came back while this one waited owns the holder now, and its own attempt decides it. */
+  private releaseFailedHold(
+    sessionId: string,
+    holderId: string,
+    alreadyHeld: boolean,
+    incarnation: symbol | undefined
+  ): void {
+    if (!alreadyHeld && incarnation !== undefined) {
+      this.release(sessionId, holderId, incarnation)
+    }
   }
 
   /**
@@ -92,18 +107,28 @@ export class StructuredAgentSessionHolds {
    * next caller to make its own. With no surface holding the session afterwards, the child goes
    * on the same clock a departed surface would start.
    */
-  async ensureProviderChild(sessionId: string): Promise<void> {
+  async ensureProviderChild(sessionId: string): Promise<StructuredAgentSessionResumeOutcome> {
     if (this.deps.hasProviderChild(sessionId)) {
-      return
+      return { ok: true }
+    }
+    const resumed = await this.deps.resume(sessionId)
+    if (!resumed.ok) {
+      return resumed
     }
-    await this.deps.resume(sessionId)
     if (!this.deps.hasProviderChild(sessionId)) {
-      throw new Error('agent_session_ownership_unknown')
+      return {
+        ok: false,
+        refusal: {
+          code: 'agent_session_ownership_unknown',
+          message: 'The session attached without a provider child to write to.'
+        }
+      }
     }
     // The last surface can disconnect before acquisition makes a child available to release.
     if (!this.disposed && !this.holders.isHeld(sessionId)) {
       this.clock.arm(sessionId)
     }
+    return { ok: true }
   }
 
   /** Journal activity; only an unheld session's pending release notices. */
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-host-lifetime.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-host-lifetime.ts
index d539784f0bea..8b1f108b3e66 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-host-lifetime.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-host-lifetime.ts
@@ -21,7 +21,6 @@ import type {
 import { releaseStoredStructuredAgentSessionOwner } from './structured-agent-session-lease-release'
 import { resumeHeldStructuredAgentSession } from './structured-agent-session-hold-resume'
 import type { StructuredAgentSessionAttachContext } from './structured-agent-session-attach-context'
-import { attachStructuredAgentSessionUnderSerialize } from './structured-agent-session-attach-orchestration'
 import { settleStructuredAgentSessionDeadGeneration } from './structured-agent-session-dead-generation-settlement'
 
 export type StructuredAgentSessionLifetimeContext = {
@@ -174,15 +173,12 @@ export function createStructuredAgentSessionHolds(
 ): StructuredAgentSessionHolds {
   const context = attachContext()
   return new StructuredAgentSessionHolds({
-    resume: (sessionId) => {
-      const current = attachContext()
-      return resumeHeldStructuredAgentSession({
+    resume: (sessionId) =>
+      resumeHeldStructuredAgentSession({
         sessionId,
-        context: current,
-        attach: (params) =>
-          attachStructuredAgentSessionUnderSerialize(current, 'trusted-local:surface-hold', params)
-      })
-    },
+        context: attachContext(),
+        callerKey: 'trusted-local:surface-hold'
+      }),
     serialize: (sessionId, task) => attachContext().serialize(sessionId, task),
     evict: close,
     hasProviderChild: (sessionId) => hasProviderChild(context, sessionId),
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-refusal-retry.test.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-refusal-retry.test.ts
index 496df6bcb44e..4cf6111952b3 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-refusal-retry.test.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-refusal-retry.test.ts
@@ -100,6 +100,8 @@ async function createHarness(options: { attached?: boolean; transport?: boolean
     }),
     cancelTurn: async () => ({ cancelled: true }),
     answerPrompt: async () => undefined,
+    // A failed acquisition is proven gone, as the real adapters prove it.
+    releaseAcquisition: async () => true,
     setOption
   }
   const host = new StructuredAgentSessionHost({
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-send-preparation.test.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-send-preparation.test.ts
index 645bd99e60d4..30b27f608c7d 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-send-preparation.test.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-send-preparation.test.ts
@@ -28,6 +28,7 @@ let root: string
 let store: AgentSessionRecordStore
 let host: StructuredAgentSessionHost
 let acquire: Mock<StructuredAgentSessionAdapter['acquire']>
+let spawnChild: StructuredAgentSessionAdapter['acquire']
 let dispatch: Mock<StructuredAgentSessionAdapter['dispatch']>
 let hostErrors: unknown[]
 
@@ -36,7 +37,7 @@ beforeEach(async () => {
   resetHostTestOperationIds()
   hostErrors = []
   let generation = 0
-  acquire = vi.fn(async ({ fence, spawnToken }) => ({
+  spawnChild = async ({ fence, spawnToken }) => ({
     process: { hostId: 'local', pid: 4242, processStartTimeMs: 1_700_000_000_000, spawnToken },
     acquisitionGeneration: `generation-${++generation}`,
     link: {
@@ -48,7 +49,8 @@ beforeEach(async () => {
       mintedAtFence: fence,
       observedAt: NOW
     }
-  }))
+  })
+  acquire = vi.fn(spawnChild)
   dispatch = vi.fn(async () => ({
     state: 'accepted' as const,
     providerIdentity: {
@@ -100,6 +102,17 @@ function sendParams(text: string, operationId = hostTestOperationId()) {
   return { envelope, body }
 }
 
+/** Every status row the chat shows, oldest first; none when the session is not even readable. */
+function journalStatuses(): string[] {
+  if (!host.hasSession(SESSION)) {
+    return []
+  }
+  const history = host.history({ sessionId: SESSION, direction: 'tail' })
+  return history.ok
+    ? history.page.items.flatMap((item) => (item.body.kind === 'status' ? [item.body.text] : []))
+    : []
+}
+
 /** The child timed out or exited: its lease is handed back and the host holds no session. */
 async function loseOwner(): Promise<void> {
   await host.close(SESSION)
@@ -378,7 +391,7 @@ describe('a send with no live owner', () => {
     expect(host['holds'].isReleasePending(SESSION)).toBe(false)
   })
 
-  it('refuses for good when the owner cannot be restarted', async () => {
+  it('refuses for good when the owner cannot be restarted, saying why in the answer and in the chat', async () => {
     await loseOwner()
     acquire.mockRejectedValue(new Error('no provider thread to resume'))
 
@@ -388,7 +401,11 @@ describe('a send with no live owner', () => {
       ok: false,
       refusal: {
         code: 'agent_session_owner_unrecoverable',
-        message: expect.stringMatching(/new chat/)
+        message: expect.stringMatching(
+          /no provider thread to resume.*Retry, or start a new chat\.$/
+        ),
+        // The failed attach proved its child gone: nothing runs for this session.
+        ownerVerdict: 'exited'
       }
     })
     expect(dispatch).not.toHaveBeenCalled()
@@ -396,6 +413,54 @@ describe('a send with no live owner', () => {
     expect(
       agentSessionRefusalOperationState('agentSession.send', 'agent_session_owner_unrecoverable')
     ).toBe('settled-rejected')
+    // The same status row a failed start leaves, so the reason outlives the error strip.
+    expect(journalStatuses()).toEqual([expect.stringContaining('no provider thread to resume')])
+
+    // Nothing is remembered: a Retry under a new id is a fresh attempt, and this one succeeds.
+    acquire.mockReset()
+    acquire.mockImplementation(spawnChild)
+    await expect(host.send(CALLER, sendParams('nothing to resume'))).resolves.toMatchObject({
+      ok: true
+    })
+  })
+
+  it('runs the send as the lease stands when the restart met a lease someone else is settling', async () => {
+    await loseOwner()
+    vi.spyOn(host['holds'], 'ensureProviderChild').mockResolvedValueOnce({
+      ok: false,
+      refusal: {
+        code: 'execution_owner_reconciling',
+        message: 'Another runtime is still adjudicating this lease.'
+      }
+    })
+
+    const result = await host.send(CALLER, sendParams('owner being settled'))
+
+    // The ordinary lease check answers, retryably; nothing terminal and nothing in the chat.
+    expect(result).toMatchObject({
+      ok: false,
+      refusal: { code: 'agent_session_ownership_unknown' }
+    })
+    expect(acquire).not.toHaveBeenCalled()
+    expect(journalStatuses()).toEqual([])
+  })
+
+  it('runs the send as the lease stands when the restart itself faults', async () => {
+    await loseOwner()
+    vi.spyOn(host['holds'], 'ensureProviderChild').mockRejectedValueOnce(
+      new Error('spawn-token mint failed')
+    )
+
+    const result = await host.send(CALLER, sendParams('bookkeeping failed'))
+
+    expect(result).toMatchObject({
+      ok: false,
+      refusal: { code: 'agent_session_ownership_unknown' }
+    })
+    expect(hostErrors).toContainEqual(
+      expect.objectContaining({ message: 'spawn-token mint failed' })
+    )
+    expect(journalStatuses()).toEqual([])
   })
 
   it('keeps a second surface holder taken during an auto-restart, and starts nothing for it', async () => {
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-send-preparation.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-send-preparation.ts
index 11e95e670b63..dcb1d74d05a3 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-send-preparation.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-send-preparation.ts
@@ -5,7 +5,8 @@
 // yet" and resends forever — and only a surface hold could ever make a new child. Now the send
 // makes sure it has an owner as a step of its own serialized admission: a released lease where
 // resume is allowed gets a child first; anything else runs as it is and meets the lease check.
-// A restart that fails for good refuses with a code the client stops on.
+// A restart that fails for good refuses with a code the client stops on, carrying the cause, and
+// writes that cause into the chat the way a start that failed does, so the user sees why.
 //
 // The ledger's answer comes first, so a send it already holds a row for restarts nothing:
 // admission replays or refuses it whoever owns the session now, and a closed session is made
@@ -22,26 +23,40 @@ import type {
   AgentSessionMutationEnvelope,
   AgentSessionWireRefusal
 } from '../../../shared/agent-session-wire'
+import type { AgentSessionWireRefusalCode } from '../../../shared/agent-session-wire-refusals'
+import { boundJournalStatusText } from '../agent-session-journal/journal-prompt-body-bounds'
+import { providerRestartFailureOutcome } from './structured-agent-session-dead-generation-settlement'
 import type { StructuredAgentSessionHostSession } from './structured-agent-session-host-types'
 import type { StructuredAgentSessionMutationContext } from './structured-agent-session-host-mutations'
 import type { AgentSessionMutationSessionPreparation } from './structured-agent-session-mutation-admission'
 import { isResumableStructuredAgentSessionRecord } from './structured-agent-session-resume-eligibility'
 import { rewindRefusal } from './structured-rewind-refusal'
 
-export const AGENT_SESSION_OWNER_UNRECOVERABLE: AgentSessionWireRefusal = {
-  code: 'agent_session_owner_unrecoverable',
-  message: "This chat's agent stopped and could not be restarted. Retry, or start a new chat."
+/**
+ * What a refused resume means for the send that ran it. `transient`: the resume met a lease
+ * someone else is settling, which is not proof it cannot resume — the send runs as the lease
+ * stands and admission reports it. `terminal`: the restart itself failed; the send answers with
+ * the cause and stops the client's retry loop. A new wire code does not compile until it is
+ * classified here.
+ */
+const RESUME_REFUSAL_OUTCOME: Record<AgentSessionWireRefusalCode, 'transient' | 'terminal'> = {
+  execution_owner_reconciling: 'transient',
+  agent_session_conflict: 'transient',
+  agent_session_checkpoint_stale: 'transient',
+  agent_session_ownership_unknown: 'transient',
+  agent_session_operation_capacity: 'transient',
+  structured_agent_session_unsupported: 'terminal',
+  agent_session_operation_conflict: 'terminal',
+  agent_session_operation_expired: 'terminal',
+  agent_session_operation_invalid: 'terminal',
+  agent_session_operation_unknown: 'terminal',
+  agent_session_item_revision_stale: 'terminal',
+  agent_session_already_resolved: 'terminal',
+  agent_session_identity_required: 'terminal',
+  agent_session_journal_unreadable: 'terminal',
+  agent_session_owner_unrecoverable: 'terminal'
 }
 
-// A resume refused this way met a lease someone else is settling — not proof it cannot resume.
-const TRANSIENT_RESUME_REFUSALS: ReadonlySet<string> = new Set([
-  'execution_owner_reconciling',
-  'agent_session_conflict',
-  'agent_session_checkpoint_stale',
-  'agent_session_ownership_unknown',
-  'agent_session_operation_capacity'
-])
-
 /** Why the record refuses any send right now, whoever owns it; null when a send may run. */
 export function structuredAgentSessionSendBlock(
   record: AgentSessionRecord | null
@@ -83,11 +98,13 @@ export function structuredAgentSessionSendNeedsOwner(
   )
 }
 
+type SendPreparationContext = Pick<
+  StructuredAgentSessionMutationContext,
+  'deps' | 'sessions' | 'holds' | 'restoreReadable' | 'publish' | 'now'
+>
+
 export async function prepareStructuredAgentSessionSend(
-  context: Pick<
-    StructuredAgentSessionMutationContext,
-    'deps' | 'sessions' | 'holds' | 'restoreReadable'
-  >,
+  context: SendPreparationContext,
   envelope: AgentSessionMutationEnvelope,
   ledger: 'admit' | 'replay',
   record: AgentSessionRecord
@@ -100,18 +117,84 @@ export async function prepareStructuredAgentSessionSend(
     return { ok: true, envelope }
   }
   if (structuredAgentSessionSendNeedsOwner(context.sessions.get(sessionId), record)) {
-    try {
-      await context.holds.ensureProviderChild(sessionId)
-    } catch (error) {
-      if (!(error instanceof Error && TRANSIENT_RESUME_REFUSALS.has(error.message))) {
-        context.deps.onEventSinkError?.({ sessionId, error })
-        return { ok: false, refusal: AGENT_SESSION_OWNER_UNRECOVERABLE }
-      }
+    const refusal = await restartOwnerForSend(context, sessionId)
+    if (refusal) {
+      return { ok: false, refusal }
     }
   }
   return { ok: true, envelope: admitAtResumedFence(context.sessions.get(sessionId), envelope) }
 }
 
+/** One restart attempt. Answers with the refusal that ends the send, or null when the send goes
+ *  on to admission — after a child, after a transient refusal, or after a fault in the restart's
+ *  own bookkeeping, which is reported and never gates the user's action. */
+async function restartOwnerForSend(
+  context: SendPreparationContext,
+  sessionId: string
+): Promise<AgentSessionWireRefusal | null> {
+  let resumed: Awaited<ReturnType<typeof context.holds.ensureProviderChild>>
+  try {
+    resumed = await context.holds.ensureProviderChild(sessionId)
+  } catch (error) {
+    context.deps.onEventSinkError?.({ sessionId, error })
+    return null
+  }
+  if (resumed.ok || RESUME_REFUSAL_OUTCOME[resumed.refusal.code] === 'transient') {
+    return null
+  }
+  const refusal = ownerUnrecoverableRefusal(resumed.refusal)
+  context.deps.onEventSinkError?.({
+    sessionId,
+    error: new Error(`${resumed.refusal.code}: ${resumed.refusal.message}`)
+  })
+  await recordFailedRestart(context, sessionId, refusal.message)
+  return refusal
+}
+
+/** The client stops on the code; the message says why, and the verdict — when the failed attach
+ *  proved its child gone — tells a client that nothing is running for the session. */
+function ownerUnrecoverableRefusal(cause: AgentSessionWireRefusal): AgentSessionWireRefusal {
+  return {
+    code: 'agent_session_owner_unrecoverable',
+    message: providerRestartFailureOutcome(cause.message),
+    ...(cause.ownerVerdict ? { ownerVerdict: cause.ownerVerdict } : {})
+  }
+}
+
+/** The same status row a start that failed leaves in the chat, so the reason outlives the error
+ *  strip. The journal is made readable for it when the failed attach left none behind. */
+async function recordFailedRestart(
+  context: SendPreparationContext,
+  sessionId: string,
+  text: string
+): Promise<void> {
+  try {
+    if (!context.sessions.has(sessionId)) {
+      await context.restoreReadable(sessionId)
+    }
+    const session = context.sessions.get(sessionId)
+    if (!session) {
+      return
+    }
+    const settlementId = `failed-restart:${sessionId}:${session.fence}:${context.now()}`
+    await session.journal.appendLifecycleBatch({
+      settlementId,
+      fence: session.fence,
+      recovered: true,
+      mutations: [
+        {
+          kind: 'item',
+          identity: { provider: 'orca', clientMessageId: settlementId },
+          body: { kind: 'status', text: boundJournalStatusText(text) }
+        }
+      ]
+    })
+    context.publish(sessionId, session.journal)
+  } catch (error) {
+    context.deps.onEventSinkError?.({ sessionId, error })
+  }
+}
+
 /** A writer current as of the owner this child replaced is current now: the restart was the only
  *  thing that moved the fence, whether this send ran it or one just ahead of it did. */
 function admitAtResumedFence(

From ab5c8cdbad3d344416bfdccbcafa978474d7519c Mon Sep 17 00:00:00 2001
From: Brennan Benson <79079362+brennanb2025@users.noreply.github.com>
Date: Wed, 23 Sep 2026 12:21:10 -0700
Subject: [PATCH 31/67] fix(native-chat): a child's event sink belongs to the
 attach attempt that spawned it

The runtime kept one event sink per session id and handed it to every attach.
An attach that acquired a new child unbound that sink first, so when the
acquire then failed its dead child's queued frames stayed in the cached,
unbound sink. The earlier guard only discarded it when no session entry was
left, which a resume of a still-indexed session never satisfies: the next
attach's drain and shutdown's flush waited on it forever. A TUI-to-native
handoff acquire had the same shape.

Each acquiring attempt now mints its own sink. Only a successful attach (or a
proven handoff owner) adopts it as the session's, closing the one it
replaces; any other exit closes it with whatever its child queued. A re-attach
to a live child keeps the sink that child already writes through. A sink that
is not the session's own can no longer force the session's provider down.

The native handoff acquisition moves to its own module, which keeps the
handoff file under its line budget.
---
 ...ured-agent-session-attach-orchestration.ts |  44 +++---
 ...ructured-agent-session-close-retry.test.ts |  10 +-
 ...session-failed-create-sink-release.test.ts |  43 +++++-
 ...ctured-agent-session-forget-status.test.ts |   4 +
 ...uctured-agent-session-host-handoff.test.ts | 130 ++++++++++++++++-
 .../structured-agent-session-host-handoff.ts  |  99 ++-----------
 ...ctured-agent-session-host-runtime-state.ts |  58 +++++---
 .../structured-agent-session-host.ts          |   2 +-
 ...gent-session-native-handoff-acquisition.ts | 131 ++++++++++++++++++
 9 files changed, 378 insertions(+), 143 deletions(-)
 create mode 100644 src/main/native-chat/agent-session-wire/structured-agent-session-native-handoff-acquisition.ts

diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-attach-orchestration.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-attach-orchestration.ts
index df5aa97816bc..93a4f1f44f9f 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-attach-orchestration.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-attach-orchestration.ts
@@ -78,19 +78,14 @@ export function attachStructuredAgentSession(
           message: 'The provider-exit terminal journal settlement is still pending; retry attach.'
         })
       }
-      const eventSink = context.runtimeState.eventSinkFor(sessionId)
       const probe = await withAgentSessionCreatePhase('probe_owner', recordPhase, () =>
         context.runtimeState.probeOwner(sessionId)
       )
-      // Why: a failed attach that left no session behind must not strand a bound sink; the runtime
-      // caches one per session id and would hand this same closed instance to the next attempt.
-      const discardUnattachedSink = (): void => {
-        if (!context.sessions.has(sessionId)) {
-          eventSink.close()
-          context.runtimeState.discardEventSink(sessionId)
-        }
-      }
-      const attached = stampFailedCreateOwnerVerdict(
+      // A child this attach spawns writes through a sink this attempt owns. Only a successful
+      // attach makes it the session's; any other exit closes it with whatever the child queued.
+      const attemptSink = context.runtimeState.mintEventSink(sessionId)
+      let attemptSinkAdopted = false
+      return stampFailedCreateOwnerVerdict(
         context.deps.store,
         callerKey,
         params.envelope,
@@ -99,13 +94,13 @@ export function attachStructuredAgentSession(
           store: context.deps.store,
           adapter: context.deps.adapter,
           journalRoot: context.deps.journalRoot,
-          eventSink: eventSink.sink,
+          eventSink: attemptSink.sink,
+          // The superseded child's writes settle into its own journal before a new child starts.
           onAcquiring: async () => {
-            const barrier = await eventSink.drained()
-            if (!barrier.ok) {
+            const barrier = await context.runtimeState.currentEventSink(sessionId)?.drained()
+            if (barrier && !barrier.ok) {
               throw barrier.error
             }
-            eventSink.unbind()
           },
           authority: {
             spawnToken: () => context.deps.mintSpawnToken?.() ?? randomUUID(),
@@ -123,7 +118,7 @@ export function attachStructuredAgentSession(
           // journal — it has no reference to that one. `onAttached` owns that.
           onAttachFailed: async () => {
             await forgetStructuredAgentSession(context, sessionId)
-            eventSink.close()
+            context.runtimeState.currentEventSink(sessionId)?.close()
             context.runtimeState.discardEventSink(sessionId)
           },
           onAttached: async (
@@ -135,6 +130,10 @@ export function attachStructuredAgentSession(
             const fence = context.deps.store.getRecord(sessionId)?.lease.runtimeFence ?? 0
             const previous = context.sessions.get(sessionId)
             const previousFence = previous?.fence
+            // A re-attach to a live child keeps the sink that child already writes through.
+            const eventSink = acquiredOwner
+              ? attemptSink
+              : (context.runtimeState.currentEventSink(sessionId) ?? attemptSink)
             // Site 8: the provisional journal has no owner until the map takes it,
             // and the barrier below throws by design.
             try {
@@ -166,6 +165,8 @@ export function attachStructuredAgentSession(
                 throw error
               }
             }
+            context.runtimeState.adoptEventSink(sessionId, eventSink)
+            attemptSinkAdopted = eventSink === attemptSink
             context.sessions.set(sessionId, {
               journal: attached.journal,
               params,
@@ -202,17 +203,12 @@ export function attachStructuredAgentSession(
               context.subscribers.publish(sessionId, attached.journal)
             }
           }
-        }).catch((error: unknown) => {
-          // A throw is a failed attach too, and its dead child may already have queued into the
-          // unbound sink; left cached, that queue wedges the next attach's drain and shutdown.
-          discardUnattachedSink()
-          throw error
+        }).finally(() => {
+          if (!attemptSinkAdopted) {
+            attemptSink.close()
+          }
         })
       )
-      if (!attached.ok) {
-        discardUnattachedSink()
-      }
-      return attached
     })
   const attaching =
     params.envelope.expectedRuntimeFence === null
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-close-retry.test.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-close-retry.test.ts
index 18f605950e7f..b9e8f8e506d7 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-close-retry.test.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-close-retry.test.ts
@@ -116,11 +116,15 @@ function attachContext(
     bind: () => undefined,
     close: () => undefined
   }
+  // oxlint-disable-next-line typescript/consistent-type-assertions -- SAFETY: a partial context double; the attach reads only the members defined here.
   return {
     deps: { store: { getRecord: () => null }, claimKeyId: 'key-1', journalRoot: root },
     runtimeState: {
       resolveRecovery: async () => undefined,
       eventSinkFor: () => eventSink,
+      currentEventSink: () => eventSink,
+      mintEventSink: () => eventSink,
+      adoptEventSink: () => undefined,
       probeOwner: async () => ({ outcome: 'pid-absent' }),
       discardEventSink: () => undefined
     },
@@ -216,8 +220,10 @@ describe('the attach orchestration', () => {
       bind: () => undefined,
       close: () => undefined
     }
-    context.runtimeState.eventSinkFor = (() =>
-      failing) as unknown as typeof context.runtimeState.eventSinkFor
+    // The re-attach binds the sink the live child already writes through.
+    // oxlint-disable-next-line typescript/consistent-type-assertions -- SAFETY: a partial sink double; the attach reads only drained/bind/close from it.
+    context.runtimeState.currentEventSink = (() =>
+      failing) as unknown as typeof context.runtimeState.currentEventSink
 
     await expect(attachStructuredAgentSession(context, 'caller-1', attachParams)).rejects.toThrow(
       'sink barrier failed'
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-failed-create-sink-release.test.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-failed-create-sink-release.test.ts
index fd71bc8bc569..5f5c33886e3b 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-failed-create-sink-release.test.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-failed-create-sink-release.test.ts
@@ -14,6 +14,7 @@ import {
 import { StructuredAgentSessionHost } from './structured-agent-session-host'
 import {
   HOST_TEST_NOW as NOW,
+  HOST_TEST_SESSION as SESSION,
   HOST_TEST_THREAD as THREAD,
   hostTestAttachParams,
   resetHostTestOperationIds
@@ -35,10 +36,12 @@ beforeEach(async () => {
     link: {
       linkId: `link-${fence}`,
       handle: { provider: 'codex', threadId: THREAD },
-      origin: 'created',
+      // A resume continues the chain the first start created.
+      origin: store.getRecord(SESSION)?.providerHandleChain.length ? 'resumed' : 'created',
       mintedAtFence: fence,
       observedAt: NOW
-    }
+    },
+    acquisitionGeneration: `generation-${fence}`
   }))
   store = await AgentSessionRecordStore.open({ directory: join(root, 'store'), hostId: 'local' })
   host = new StructuredAgentSessionHost({
@@ -89,4 +92,40 @@ describe('a create that fails after its child wrote through the unbound sink', (
       expect(acquire).toHaveBeenCalledTimes(2)
     }
   )
+
+  it.each([
+    ['refused', new Error(EXIT_REASON)],
+    ['thrown', new AgentSessionPreSpawnError(new Error(EXIT_REASON))]
+  ])('releases the sink when a resume of a still-indexed session is %s', async (_how, cause) => {
+    await expect(host.attach(CALLER, hostTestAttachParams(null))).resolves.toMatchObject({
+      ok: true
+    })
+    const exitedFence = store.getRecord(SESSION)?.lease.runtimeFence ?? 0
+    await host.handleAdapterEvent({
+      type: 'ended',
+      sessionId: SESSION,
+      reason: 'provider exited',
+      cause: 'unexpected-exit',
+      fence: exitedFence,
+      acquisitionGeneration: `generation-${exitedFence}`
+    })
+    const releasedFence = store.getRecord(SESSION)?.lease.runtimeFence ?? 0
+    acquire.mockImplementationOnce(async ({ events }) => {
+      events?.setActivity?.(null)
+      throw cause
+    })
+
+    // The session stays indexed across this failure: it is a resume, not a create.
+    const failed = host.attach(CALLER, hostTestAttachParams(releasedFence))
+    await (cause instanceof AgentSessionPreSpawnError
+      ? expect(failed).rejects.toThrow(EXIT_REASON)
+      : expect(failed).resolves.toMatchObject({ ok: false }))
+
+    const fence = store.getRecord(SESSION)?.lease.runtimeFence ?? 0
+    await expect(host.attach(CALLER, hostTestAttachParams(fence))).resolves.toMatchObject({
+      ok: true
+    })
+    await expect(host.flushAllStreamedEvents()).resolves.toBeUndefined()
+    expect(acquire).toHaveBeenCalledTimes(3)
+  })
 })
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-forget-status.test.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-forget-status.test.ts
index 697d351013ab..20531bd64653 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-forget-status.test.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-forget-status.test.ts
@@ -172,11 +172,15 @@ function attachContext(
     bind: () => undefined,
     close: () => undefined
   }
+  // oxlint-disable-next-line typescript/consistent-type-assertions -- SAFETY: a partial context double; the attach reads only the members defined here.
   return {
     deps: { store: { getRecord: () => null }, claimKeyId: 'key-1', journalRoot: root },
     runtimeState: {
       resolveRecovery: async () => undefined,
       eventSinkFor: () => eventSink,
+      currentEventSink: () => eventSink,
+      mintEventSink: () => eventSink,
+      adoptEventSink: () => undefined,
       probeOwner: async () => ({ outcome: 'pid-absent' }),
       discardEventSink: () => undefined
     },
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-host-handoff.test.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-host-handoff.test.ts
index d5ab3c679749..9e971960c2dd 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-host-handoff.test.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-host-handoff.test.ts
@@ -10,13 +10,17 @@ import type { AgentSessionHandoffStatus } from '../../../shared/agent-session-wi
 import { LOCAL_EXECUTION_HOST_ID } from '../../../shared/execution-host'
 import { AgentSessionRecordStore } from '../../runtime/agent-session-record-store'
 import { createTrackedJournalOpener } from '../agent-session-journal/journal-store-test-open'
-import { createDeferredStructuredAgentSessionEventSink } from './structured-agent-session-event-sink'
+import {
+  createDeferredStructuredAgentSessionEventSink,
+  type DeferredStructuredAgentSessionEventSink
+} from './structured-agent-session-event-sink'
 import type { StructuredAgentSessionHostDeps } from './structured-agent-session-host-types'
 import {
-  acquireNativeHandoffOwner,
   createStructuredAgentSessionHostHandoff,
   structuredTuiTranscriptImportOptions
 } from './structured-agent-session-host-handoff'
+import { acquireNativeHandoffOwner } from './structured-agent-session-native-handoff-acquisition'
+import { AgentSessionSubscribers } from './structured-agent-session-subscribers'
 
 const journals = createTrackedJournalOpener()
 
@@ -30,6 +34,19 @@ function importRecord(provider: 'claude' | 'codex', accountHome: string): AgentS
   } as AgentSessionRecord
 }
 
+/** The session's sink is `current`; a native acquire's attempt gets its own. */
+function sinksOver(current: DeferredStructuredAgentSessionEventSink) {
+  return {
+    eventSinkFor: () => current,
+    mintEventSink: () => createDeferredStructuredAgentSessionEventSink(),
+    adoptEventSink: () => undefined
+  }
+}
+
+function unreachableSink(): never {
+  throw new Error('unreachable: publishing reads no sink')
+}
+
 describe('structured TUI transcript import roots', () => {
   it('uses the managed Claude account home when no live transcript path remains', () => {
     expect(structuredTuiTranscriptImportOptions(importRecord('claude', '/managed/claude'))).toEqual(
@@ -178,7 +195,7 @@ describe('native handoff acquisition', () => {
       {
         session: () => session,
         findSession: () => session,
-        eventSink: () => eventSink,
+        eventSinks: sinksOver(eventSink),
         flush: async () => undefined,
         serialize: async (_session, task) => task(),
         subscribers: {
@@ -278,7 +295,7 @@ describe('native handoff acquisition', () => {
         {
           session: () => session,
           findSession: () => session,
-          eventSink: () => eventSink,
+          eventSinks: sinksOver(eventSink),
           flush: async () => undefined,
           serialize: async (_sessionId, task) => task(),
           subscribers: {
@@ -373,7 +390,7 @@ describe('native handoff acquisition', () => {
         {
           session: () => session,
           findSession: () => session,
-          eventSink: () => eventSink,
+          eventSinks: sinksOver(eventSink),
           flush: async () => undefined,
           serialize: async (_sessionId, task) => task(),
           subscribers: {
@@ -391,6 +408,103 @@ describe('native handoff acquisition', () => {
     expect(unbind).toHaveBeenCalledOnce()
     expect(acquire).not.toHaveBeenCalled()
   })
+
+  it("takes a failed native child's queued rows with it, leaving the session sink drainable", async () => {
+    const sessionId = 'session-handoff-failed'
+    const location: AgentSessionExecutionLocation = {
+      executionHostId: LOCAL_EXECUTION_HOST_ID,
+      wslDistro: null,
+      workspaceId: 'workspace-failed',
+      workspaceKind: 'folder'
+    }
+    const operationId = `${now}-00000000000000000000000000000031`
+    const reserved = await store.reserveOwner({
+      sessionId,
+      location,
+      provider: 'codex',
+      accountHome: { variable: 'CODEX_HOME', path: join(root, 'codex-home') },
+      runtimeKind: 'native',
+      expectedFence: null,
+      spawnToken: 'failed-spawn',
+      claimKeyId: 'key-1',
+      handoffOperationId: operationId,
+      probe: { outcome: 'reservation-unused' },
+      operation: { callerKey: 'test', operationId, fingerprint: 'failed' },
+      now
+    })
+    const journal = await journals.open({
+      identity: {
+        sessionId,
+        workspaceId: location.workspaceId,
+        hostId: location.executionHostId,
+        agent: 'codex',
+        providerHandle: { kind: 'codex', threadId: 'failed-thread' }
+      },
+      journalDir: join(root, 'failed-journal')
+    })
+    const current = createDeferredStructuredAgentSessionEventSink()
+    current.bind({ journal, fence: reserved.record.lease.runtimeFence, publish: () => undefined })
+    const attempt = createDeferredStructuredAgentSessionEventSink()
+    const acquire = vi.fn<NonNullable<StructuredAgentSessionHostDeps['adapter']['acquire']>>(
+      async ({ events }) => {
+        // The child wrote before it died, into whatever sink it was handed.
+        events?.setActivity?.(null)
+        throw new Error('codex app-server exited (code 1)')
+      }
+    )
+    const session = {
+      journal,
+      params: {
+        envelope: {
+          sessionId,
+          clientOperationId: `${now}-00000000000000000000000000000032`,
+          expectedRuntimeFence: reserved.record.lease.runtimeFence,
+          payloadFingerprint: 'failed'
+        },
+        location,
+        provider: 'codex' as const,
+        agent: 'codex' as const,
+        accountHome: { variable: 'CODEX_HOME' as const, path: join(root, 'codex-home') },
+        runtimeKind: 'native' as const,
+        providerHandle: { kind: 'codex' as const, threadId: 'failed-thread' }
+      },
+      fence: reserved.record.lease.runtimeFence,
+      hasProviderChild: false,
+      providerChildPhase: 'ready' as const,
+      acquisitionGeneration: null
+    }
+
+    await expect(
+      acquireNativeHandoffOwner(
+        {
+          store,
+          adapter: {
+            acquire,
+            dispatch: vi.fn(async () => ({ state: 'admitted' as const })),
+            cancelTurn: vi.fn(async () => ({ cancelled: true })),
+            answerPrompt: vi.fn(async () => undefined),
+            setOption: vi.fn(async () => undefined)
+          },
+          journalRoot: root,
+          claimKeyId: 'key-1'
+        },
+        {
+          session: () => session,
+          findSession: () => session,
+          eventSinks: { ...sinksOver(current), mintEventSink: () => attempt },
+          flush: async () => undefined,
+          serialize: async (_sessionId, task) => task(),
+          subscribers: new AgentSessionSubscribers(),
+          now: () => now
+        },
+        { sessionId, fence: reserved.record.lease.runtimeFence, spawnToken: 'failed-spawn' }
+      )
+    ).rejects.toThrow('codex app-server exited')
+    // The next attach drains the session's sink before acquiring; nothing may be stranded there.
+    expect(current.state().queuedOperations).toBe(0)
+    await expect(current.drained()).resolves.toEqual({ ok: true })
+    expect(attempt.sink.tryPublish?.()).toEqual({ accepted: false, reason: 'closed' })
+  })
 })
 
 describe('handoff status published for a session the host no longer holds', () => {
@@ -424,8 +538,10 @@ describe('handoff status published for a session the host no longer holds', () =
           throw new Error('agent_session_ownership_unknown')
         },
         findSession: () => undefined,
-        eventSink: () => {
-          throw new Error('unreachable: publishing reads no sink')
+        eventSinks: {
+          eventSinkFor: unreachableSink,
+          mintEventSink: unreachableSink,
+          adoptEventSink: unreachableSink
         },
         flush: async () => undefined,
         serialize: async (_sessionId, task) => task(),
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-host-handoff.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-host-handoff.ts
index 5ac5697c551f..41e2d8c61e3f 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-host-handoff.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-host-handoff.ts
@@ -3,29 +3,27 @@ import type { AgentSessionOwnerProbe } from '../../../shared/agent-session-lease
 import type { AgentSessionRecord } from '../../../shared/agent-session-record'
 import type { LegacyImportOptions } from '../agent-session-journal/journal-legacy-import'
 import { importLegacyTranscriptIntoJournal } from '../agent-session-journal/journal-legacy-import'
-import { journalIdentityFor } from './structured-agent-session-attach'
-import {
-  rethrowAfterAgentSessionAcquisitionCleanup,
-  type StructuredAgentSessionAdapter
-} from './structured-agent-session-adapter'
+import type { StructuredAgentSessionAdapter } from './structured-agent-session-adapter'
 import { canRestoreLiveTuiOwner } from './structured-agent-session-handoff-restart'
-import type { DeferredStructuredAgentSessionEventSink } from './structured-agent-session-event-sink'
 import type { StructuredAgentSessionHostDeps } from './structured-agent-session-host'
+import type { StructuredAgentSessionHostRuntimeState } from './structured-agent-session-host-runtime-state'
 import type { StructuredAgentSessionHostSession } from './structured-agent-session-host-types'
 import { StructuredAgentSessionHandoffCoordinator } from './structured-agent-session-handoff'
 import { recoverDeadTuiHandoffStatus } from './structured-agent-session-dead-tui-recovery'
-import { readNativeSessionOptions } from './structured-agent-session-option-restoration'
+import { acquireNativeHandoffOwner } from './structured-agent-session-native-handoff-acquisition'
 import type { AgentSessionSubscribers } from './structured-agent-session-subscribers'
 import { StructuredTuiTranscriptCatchup } from './structured-tui-transcript-catchup'
-import { adapterSupportsCreateIfDeclared } from './structured-agent-session-provider-support'
 import { retryLoadedStructuredAgentSessionSettlement } from './structured-agent-session-settlement-retry'
 import { latestJournalDispatchObservation } from '../agent-session-journal/journal-dispatch-observation'
 
-type HostHandoffAccess = {
+export type HostHandoffAccess = {
   session: (sessionId: string) => StructuredAgentSessionHostSession
   /** Non-throwing lookup, for the paths that only observe a detached session. */
   findSession: (sessionId: string) => StructuredAgentSessionHostSession | undefined
-  eventSink: (sessionId: string) => DeferredStructuredAgentSessionEventSink
+  eventSinks: Pick<
+    StructuredAgentSessionHostRuntimeState,
+    'eventSinkFor' | 'mintEventSink' | 'adoptEventSink'
+  >
   flush: (sessionId: string) => Promise<void>
   serialize: (sessionId: string, task: () => Promise<void>) => Promise<void>
   subscribers: AgentSessionSubscribers
@@ -97,7 +95,7 @@ export function createStructuredAgentSessionHostHandoff(
         )
         host.subscribers.publish(sessionId, session.journal)
         host.publishStatus?.(sessionId)
-        host.eventSink(sessionId).unbind()
+        host.eventSinks.eventSinkFor(sessionId).unbind()
         return { state: 'stopped' }
       } catch (error) {
         return { state: 'stopped-cleanup-failed', error }
@@ -217,82 +215,3 @@ export function structuredTuiTranscriptImportOptions(
     ? { claudeProjectsDir: join(record.accountHome.path, 'projects') }
     : { codexSessionsDirs: [join(record.accountHome.path, 'sessions')] }
 }
-
-export async function acquireNativeHandoffOwner(
-  deps: StructuredAgentSessionHostDeps,
-  host: HostHandoffAccess,
-  input: { sessionId: string; fence: number; spawnToken: string }
-): Promise<AgentSessionRecord> {
-  const session = host.session(input.sessionId)
-  const record = deps.store.getRecord(input.sessionId)
-  if (!record) {
-    throw new Error('agent_session_identity_required')
-  }
-  // Native handoff bypasses attach admission; reject before unbinding TUI ownership.
-  if (!adapterSupportsCreateIfDeclared(deps.adapter, record.location, record.provider)) {
-    throw new Error('structured_agent_session_unsupported')
-  }
-  const eventSink = host.eventSink(input.sessionId)
-  const priorBarrier = await eventSink.drained()
-  if (!priorBarrier.ok) {
-    throw priorBarrier.error
-  }
-  eventSink.unbind()
-  // Recheck immediately before acquisition; capability probes may drift while
-  // the old TUI event sink is draining.
-  if (!adapterSupportsCreateIfDeclared(deps.adapter, record.location, record.provider)) {
-    throw new Error('structured_agent_session_unsupported')
-  }
-  const acquired = await deps.adapter.acquire({
-    identity: journalIdentityFor(record, session.params),
-    fence: input.fence,
-    spawnToken: input.spawnToken,
-    ...(record.options ? { options: record.options } : {}),
-    events: eventSink.sink
-  })
-  let proved: AgentSessionRecord
-  try {
-    // A starting child has proven nothing yet: the record keeps the saved options as intent, and
-    // the `started` event persists what the child reports.
-    const options =
-      acquired.providerChildPhase === 'starting'
-        ? undefined
-        : await readNativeSessionOptions({
-            adapter: deps.adapter,
-            sessionId: input.sessionId,
-            fence: input.fence,
-            ...(record.options ? { priorOptions: record.options } : {})
-          })
-    await deps.store.commitProcessIdentity({
-      sessionId: input.sessionId,
-      fence: input.fence,
-      process: acquired.process,
-      now: host.now()
-    })
-    proved = await deps.store.proveOwner({
-      sessionId: input.sessionId,
-      fence: input.fence,
-      link: acquired.link,
-      now: host.now(),
-      ...(options ? { options } : {})
-    })
-  } catch (error) {
-    return rethrowAfterAgentSessionAcquisitionCleanup(deps.adapter, input.sessionId, error)
-  }
-  session.hasProviderChild = true
-  session.providerChildPhase = acquired.providerChildPhase ?? 'ready'
-  host.publishStatus?.(input.sessionId)
-  session.fence = proved.lease.runtimeFence
-  session.acquisitionGeneration = acquired.acquisitionGeneration ?? null
-  eventSink.bind({
-    journal: session.journal,
-    fence: proved.lease.runtimeFence,
-    publish: (activity) => host.subscribers.publish(input.sessionId, session.journal, activity)
-  })
-  const acquiredBarrier = await eventSink.drained()
-  if (!acquiredBarrier.ok) {
-    throw acquiredBarrier.error
-  }
-  host.subscribers.snapshot(input.sessionId, session.journal, proved.lease.runtimeFence)
-  return proved
-}
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-host-runtime-state.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-host-runtime-state.ts
index 85eaf1e29410..e0ea81c6b056 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-host-runtime-state.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-host-runtime-state.ts
@@ -42,30 +42,54 @@ export class StructuredAgentSessionHostRuntimeState {
     this.leaseRenewer.stop()
   }
 
+  /** The sink the session's current child writes through, created on first use. */
   eventSinkFor(sessionId: string): DeferredStructuredAgentSessionEventSink {
-    const existing = this.eventSinks.get(sessionId)
+    const existing = this.currentEventSink(sessionId)
     if (existing) {
-      // A sink failure is terminal for that sink instance. Reusing it on a
-      // recovery attach makes `drained()` return the old error forever and
-      // prevents the newly acquired journal from accepting provider events.
-      // Replace the cache entry before attach calls its drain barrier.
-      if (existing.state().failed) {
-        existing.close()
-        this.eventSinks.delete(sessionId)
-      } else {
-        return existing
-      }
+      return existing
     }
-    const created = createDeferredStructuredAgentSessionEventSink({
-      onError: (error) => {
-        this.deps.onEventSinkError?.({ sessionId, error })
-        this.onEventSinkFailure?.(sessionId, error)
-      }
-    })
+    const created = this.mintEventSink(sessionId)
     this.eventSinks.set(sessionId, created)
     return created
   }
 
+  /** The session's sink, if it has a usable one. A failed sink is terminal: reusing it would make
+   *  `drained()` return the old error forever, so it is dropped here instead. */
+  currentEventSink(sessionId: string): DeferredStructuredAgentSessionEventSink | undefined {
+    const existing = this.eventSinks.get(sessionId)
+    if (existing?.state().failed) {
+      existing.close()
+      this.eventSinks.delete(sessionId)
+      return undefined
+    }
+    return existing
+  }
+
+  /** A sink owned by one attach attempt. Uncached until `adoptEventSink`, so an attempt that fails
+   *  takes its queue with it rather than leaving it for the next attach to drain. */
+  mintEventSink(sessionId: string): DeferredStructuredAgentSessionEventSink {
+    const minted: DeferredStructuredAgentSessionEventSink =
+      createDeferredStructuredAgentSessionEventSink({
+        onError: (error) => {
+          this.deps.onEventSinkError?.({ sessionId, error })
+          // Only the session's own sink may force its provider down; an attempt's never is.
+          if (this.eventSinks.get(sessionId) === minted) {
+            this.onEventSinkFailure?.(sessionId, error)
+          }
+        }
+      })
+    return minted
+  }
+
+  /** The attempt's sink now serves the session; the one it replaces is closed. */
+  adoptEventSink(sessionId: string, sink: DeferredStructuredAgentSessionEventSink): void {
+    const replaced = this.eventSinks.get(sessionId)
+    if (replaced && replaced !== sink) {
+      replaced.close()
+    }
+    this.eventSinks.set(sessionId, sink)
+  }
+
   discardEventSink(sessionId: string): void {
     this.eventSinks.delete(sessionId)
   }
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-host.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-host.ts
index b439f880c900..cb15f81fffd7 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-host.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-host.ts
@@ -111,7 +111,7 @@ export class StructuredAgentSessionHost {
     this.handoffs = createStructuredAgentSessionHostHandoff(deps, {
       session: (sessionId) => this.requireSession(sessionId),
       findSession: (sessionId) => this.sessions.get(sessionId),
-      eventSink: (sessionId) => this.runtimeState.eventSinkFor(sessionId),
+      eventSinks: this.runtimeState,
       flush: (sessionId) => this.flushStreamedEvents(sessionId),
       serialize: (sessionId, task) => this.serialize(sessionId, task),
       subscribers: this.subscribers,
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-native-handoff-acquisition.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-native-handoff-acquisition.ts
new file mode 100644
index 000000000000..40f1c5721772
--- /dev/null
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-native-handoff-acquisition.ts
@@ -0,0 +1,131 @@
+// The host's half of a TUI-to-native handoff acquiring its native child.
+//
+// Like attach, the new child writes through a sink this attempt owns: only a proven owner makes it
+// the session's, so a failed acquire takes whatever its child queued with it instead of leaving it
+// in the session's sink for the next drain to wait on.
+
+import type { AgentSessionRecord } from '../../../shared/agent-session-record'
+import { journalIdentityFor } from './structured-agent-session-attach'
+import { rethrowAfterAgentSessionAcquisitionCleanup } from './structured-agent-session-adapter'
+import type { DeferredStructuredAgentSessionEventSink } from './structured-agent-session-event-sink'
+import type { StructuredAgentSessionHostDeps } from './structured-agent-session-host'
+import type { HostHandoffAccess } from './structured-agent-session-host-handoff'
+import type { StructuredAgentSessionHostSession } from './structured-agent-session-host-types'
+import { readNativeSessionOptions } from './structured-agent-session-option-restoration'
+import { adapterSupportsCreateIfDeclared } from './structured-agent-session-provider-support'
+
+export async function acquireNativeHandoffOwner(
+  deps: StructuredAgentSessionHostDeps,
+  host: HostHandoffAccess,
+  input: { sessionId: string; fence: number; spawnToken: string }
+): Promise<AgentSessionRecord> {
+  const session = host.session(input.sessionId)
+  const record = deps.store.getRecord(input.sessionId)
+  if (!record) {
+    throw new Error('agent_session_identity_required')
+  }
+  // Native handoff bypasses attach admission; reject before unbinding TUI ownership.
+  if (!adapterSupportsCreateIfDeclared(deps.adapter, record.location, record.provider)) {
+    throw new Error('structured_agent_session_unsupported')
+  }
+  const priorSink = host.eventSinks.eventSinkFor(input.sessionId)
+  const priorBarrier = await priorSink.drained()
+  if (!priorBarrier.ok) {
+    throw priorBarrier.error
+  }
+  priorSink.unbind()
+  // The new child writes through a sink this attempt owns; only a proven owner makes it the
+  // session's, so a failed acquire takes whatever its child queued with it.
+  const eventSink = host.eventSinks.mintEventSink(input.sessionId)
+  let adopted = false
+  try {
+    return await proveNativeHandoffOwner(
+      deps,
+      host,
+      { ...input, session, record },
+      eventSink,
+      () => {
+        host.eventSinks.adoptEventSink(input.sessionId, eventSink)
+        adopted = true
+      }
+    )
+  } finally {
+    if (!adopted) {
+      eventSink.close()
+    }
+  }
+}
+
+async function proveNativeHandoffOwner(
+  deps: StructuredAgentSessionHostDeps,
+  host: HostHandoffAccess,
+  input: {
+    sessionId: string
+    fence: number
+    spawnToken: string
+    session: StructuredAgentSessionHostSession
+    record: AgentSessionRecord
+  },
+  eventSink: DeferredStructuredAgentSessionEventSink,
+  adopt: () => void
+): Promise<AgentSessionRecord> {
+  const { session, record } = input
+  // Recheck immediately before acquisition; capability probes may drift while
+  // the old TUI event sink is draining.
+  if (!adapterSupportsCreateIfDeclared(deps.adapter, record.location, record.provider)) {
+    throw new Error('structured_agent_session_unsupported')
+  }
+  const acquired = await deps.adapter.acquire({
+    identity: journalIdentityFor(record, session.params),
+    fence: input.fence,
+    spawnToken: input.spawnToken,
+    ...(record.options ? { options: record.options } : {}),
+    events: eventSink.sink
+  })
+  let proved: AgentSessionRecord
+  try {
+    // A starting child has proven nothing yet: the record keeps the saved options as intent, and
+    // the `started` event persists what the child reports.
+    const options =
+      acquired.providerChildPhase === 'starting'
+        ? undefined
+        : await readNativeSessionOptions({
+            adapter: deps.adapter,
+            sessionId: input.sessionId,
+            fence: input.fence,
+            ...(record.options ? { priorOptions: record.options } : {})
+          })
+    await deps.store.commitProcessIdentity({
+      sessionId: input.sessionId,
+      fence: input.fence,
+      process: acquired.process,
+      now: host.now()
+    })
+    proved = await deps.store.proveOwner({
+      sessionId: input.sessionId,
+      fence: input.fence,
+      link: acquired.link,
+      now: host.now(),
+      ...(options ? { options } : {})
+    })
+  } catch (error) {
+    return rethrowAfterAgentSessionAcquisitionCleanup(deps.adapter, input.sessionId, error)
+  }
+  session.hasProviderChild = true
+  session.providerChildPhase = acquired.providerChildPhase ?? 'ready'
+  host.publishStatus?.(input.sessionId)
+  session.fence = proved.lease.runtimeFence
+  session.acquisitionGeneration = acquired.acquisitionGeneration ?? null
+  adopt()
+  eventSink.bind({
+    journal: session.journal,
+    fence: proved.lease.runtimeFence,
+    publish: (activity) => host.subscribers.publish(input.sessionId, session.journal, activity)
+  })
+  const acquiredBarrier = await eventSink.drained()
+  if (!acquiredBarrier.ok) {
+    throw acquiredBarrier.error
+  }
+  host.subscribers.snapshot(input.sessionId, session.journal, proved.lease.runtimeFence)
+  return proved
+}

From 395774e6a01e17bb545f3eb071885857f18397f6 Mon Sep 17 00:00:00 2001
From: Brennan Benson <79079362+brennanb2025@users.noreply.github.com>
Date: Wed, 23 Sep 2026 12:36:21 -0700
Subject: [PATCH 32/67] test(native-chat): pin that only the adopted child's
 event sink still takes writes

Closing a failed attempt's sink and closing the sink a resume replaces were both
unpinned: removing either left every suite green, because neither sink is in the
map that drains and flushes read. The resume test now asserts the failed
attempt's sink and the exited generation's sink refuse writes, and the adopted
one accepts them; deleting either close reddens its own assertion.
---
 ...tured-agent-session-failed-create-sink-release.test.ts | 8 +++++++-
 1 file changed, 7 insertions(+), 1 deletion(-)

diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-failed-create-sink-release.test.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-failed-create-sink-release.test.ts
index 5f5c33886e3b..c61d93cbb8fd 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-failed-create-sink-release.test.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-failed-create-sink-release.test.ts
@@ -125,7 +125,13 @@ describe('a create that fails after its child wrote through the unbound sink', (
     await expect(host.attach(CALLER, hostTestAttachParams(fence))).resolves.toMatchObject({
       ok: true
     })
-    await expect(host.flushAllStreamedEvents()).resolves.toBeUndefined()
     expect(acquire).toHaveBeenCalledTimes(3)
+    // Only the adopted child's sink still takes writes: the failed attempt's closed with it, and
+    // the exited generation's closed when the resume replaced it.
+    const [exited, failedAttempt, resumed] = acquire.mock.calls.map(([input]) => input.events)
+    expect(failedAttempt?.tryPublish?.()).toEqual({ accepted: false, reason: 'closed' })
+    expect(exited?.tryPublish?.()).toEqual({ accepted: false, reason: 'closed' })
+    expect(resumed?.tryPublish?.()).toEqual({ accepted: true })
+    await expect(host.flushAllStreamedEvents()).resolves.toBeUndefined()
   })
 })

From 09faab52e6d3657ef236de7fc206d3d76e4e0ea1 Mon Sep 17 00:00:00 2001
From: Brennan Benson <79079362+brennanb2025@users.noreply.github.com>
Date: Wed, 23 Sep 2026 12:39:10 -0700
Subject: [PATCH 33/67] perf(native-chat): the chat reads only the host's
 startup phase from the status feed

The chat took the whole status summary to read one field, so every status change
for its session (prompt, update time, background tasks) re-rendered the chat
view. It now subscribes with the phase itself as the snapshot, so it re-renders
only when the phase changes.
---
 .../NativeChatStructuredSession.tsx           |  6 ++---
 ...tructuredAgentSessionStatusBridge.test.tsx | 27 ++++++++++++++++++-
 .../StructuredAgentSessionStatusBridge.tsx    | 14 ++++++++++
 3 files changed, 42 insertions(+), 5 deletions(-)

diff --git a/src/renderer/src/components/native-chat/NativeChatStructuredSession.tsx b/src/renderer/src/components/native-chat/NativeChatStructuredSession.tsx
index 438353f6d0bd..70bc5e19ffda 100644
--- a/src/renderer/src/components/native-chat/NativeChatStructuredSession.tsx
+++ b/src/renderer/src/components/native-chat/NativeChatStructuredSession.tsx
@@ -23,7 +23,7 @@ import { useNativeChatLaunchDraftSignal } from './use-native-chat-launch-draft-a
 import { NativeChatLaunchRetry } from './NativeChatLaunchRetry'
 import { useNativeChatProvisionalLaunch } from './use-native-chat-provisional-launch'
 import { NativeChatDeliveryRetry } from './NativeChatDeliveryRetry'
-import { useStructuredAgentSessionStatusSummary } from './StructuredAgentSessionStatusBridge'
+import { useStructuredAgentSessionHostExecutionPhase } from './StructuredAgentSessionStatusBridge'
 import { structuredAgentLabel } from '@/lib/structured-agent-session-launch-label'
 import { NativeChatThreadGoalBanner } from './NativeChatThreadGoalBanner'
 
@@ -41,9 +41,7 @@ export function NativeChatStructuredSession(
   )
   const { sendThroughRelaunch } = provisionalLaunch
   // The host's own word on whether the provider child has answered startup yet.
-  const startupPhase =
-    useStructuredAgentSessionStatusSummary(props.sessionId, props.target).summary
-      ?.hostExecutionPhase ?? null
+  const startupPhase = useStructuredAgentSessionHostExecutionPhase(props.sessionId, props.target)
   const controller = useStructuredAgentSession({
     ...props,
     transportEnabled: provisionalLaunch.transportEnabled
diff --git a/src/renderer/src/components/native-chat/StructuredAgentSessionStatusBridge.test.tsx b/src/renderer/src/components/native-chat/StructuredAgentSessionStatusBridge.test.tsx
index 746817523e44..549b0f7235c9 100644
--- a/src/renderer/src/components/native-chat/StructuredAgentSessionStatusBridge.test.tsx
+++ b/src/renderer/src/components/native-chat/StructuredAgentSessionStatusBridge.test.tsx
@@ -63,7 +63,8 @@ vi.mock('@/runtime/structured-agent-session-client', () => ({
 
 import {
   getStructuredAgentSessionTabs,
-  StructuredAgentSessionStatusBridge
+  StructuredAgentSessionStatusBridge,
+  useStructuredAgentSessionHostExecutionPhase
 } from './StructuredAgentSessionStatusBridge'
 import { resetStructuredAgentSessionStatusFeedsForTests } from '@/runtime/structured-agent-session-status-feed'
 
@@ -696,4 +697,28 @@ describe('StructuredAgentSessionStatusBridge', () => {
     expect(mocks.subscribeStatus).not.toHaveBeenCalled()
     expect(mocks.setAgentStatus).not.toHaveBeenCalled()
   })
+
+  it('re-renders a startup-phase reader only when the phase changes', async () => {
+    const phases: (string | null)[] = []
+    function PhaseProbe(): null {
+      phases.push(useStructuredAgentSessionHostExecutionPhase('session-1', { kind: 'local' }))
+      return null
+    }
+    render(<PhaseProbe />)
+    await waitFor(() => expect(mocks.subscribeStatus).toHaveBeenCalledOnce())
+
+    act(() => feed().emit({ type: 'status', session: summary({ hostExecutionPhase: 'starting' }) }))
+    const rendersWhileStarting = phases.length
+    act(() =>
+      feed().emit({
+        type: 'status',
+        session: summary({ hostExecutionPhase: 'starting', latestPrompt: 'next', updatedAt: 2 })
+      })
+    )
+    expect(phases).toHaveLength(rendersWhileStarting)
+
+    act(() => feed().emit({ type: 'status', session: summary({ hostExecutionPhase: 'ready' }) }))
+    expect(phases.at(-1)).toBe('ready')
+    expect(phases).toContain('starting')
+  })
 })
diff --git a/src/renderer/src/components/native-chat/StructuredAgentSessionStatusBridge.tsx b/src/renderer/src/components/native-chat/StructuredAgentSessionStatusBridge.tsx
index 455ab21f837c..dbf057e1f23a 100644
--- a/src/renderer/src/components/native-chat/StructuredAgentSessionStatusBridge.tsx
+++ b/src/renderer/src/components/native-chat/StructuredAgentSessionStatusBridge.tsx
@@ -38,6 +38,20 @@ export function useStructuredAgentSessionStatusSummary(
   return { summary, observation }
 }
 
+/** Only the host's startup phase, so a chat re-renders when that changes, not on every status. */
+export function useStructuredAgentSessionHostExecutionPhase(
+  sessionId: string,
+  target: RuntimeClientTarget
+): AgentSessionStatusSummary['hostExecutionPhase'] | null {
+  const feed = useMemo(() => getStructuredAgentSessionStatusFeed(target), [target])
+  useEffect(() => feed.activate(), [feed])
+  return useSyncExternalStore(
+    feed.subscribe,
+    () => feed.getSnapshot().get(sessionId)?.hostExecutionPhase ?? null,
+    () => null
+  )
+}
+
 function projectStatus(
   tab: StructuredTab,
   summary: AgentSessionStatusSummary | null,

From 35924edca1e0a87563d3444ce19059bab391dc45 Mon Sep 17 00:00:00 2001
From: Brennan Benson <79079362+brennanb2025@users.noreply.github.com>
Date: Wed, 23 Sep 2026 12:42:47 -0700
Subject: [PATCH 34/67] fix(native-chat): the startup-phase hook answers a
 phase or null, never undefined

---
 .../native-chat/StructuredAgentSessionStatusBridge.tsx          | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/renderer/src/components/native-chat/StructuredAgentSessionStatusBridge.tsx b/src/renderer/src/components/native-chat/StructuredAgentSessionStatusBridge.tsx
index dbf057e1f23a..e89f47cc401e 100644
--- a/src/renderer/src/components/native-chat/StructuredAgentSessionStatusBridge.tsx
+++ b/src/renderer/src/components/native-chat/StructuredAgentSessionStatusBridge.tsx
@@ -42,7 +42,7 @@ export function useStructuredAgentSessionStatusSummary(
 export function useStructuredAgentSessionHostExecutionPhase(
   sessionId: string,
   target: RuntimeClientTarget
-): AgentSessionStatusSummary['hostExecutionPhase'] | null {
+): NonNullable<AgentSessionStatusSummary['hostExecutionPhase']> | null {
   const feed = useMemo(() => getStructuredAgentSessionStatusFeed(target), [target])
   useEffect(() => feed.activate(), [feed])
   return useSyncExternalStore(

From 386265719ed7627ce03a1f2e09452435e09960da Mon Sep 17 00:00:00 2001
From: Brennan Benson <79079362+brennanb2025@users.noreply.github.com>
Date: Wed, 23 Sep 2026 12:54:33 -0700
Subject: [PATCH 35/67] fix(native-chat): every restart is counted from the
 moment it is asked for, and a handoff clears the restart fence

Provider-exit recovery now restarts through the holds' `ensureProviderChild`
like a hold and a send do, so a child whose only surface left while the attach
ran goes on the idle clock instead of living until quit. A hold's resume and a
client attach are tracked as in flight from enqueue, not from their turn on the
queue, so a quit's drain waits for one queued behind a close before it decides
what to evict. A handoff back to native moves the fence in place and now clears
`resumedFromFence`: only a restart may rebase a writer. The failed-restart
status row is keyed by the send's operation id, not the clock, so a resend of
the same id that fails again adds no second row.
---
 ...ured-agent-session-attach-orchestration.ts |  6 +-
 ...structured-agent-session-event-recovery.ts | 21 ++----
 .../structured-agent-session-holds.ts         | 16 +++-
 ...uctured-agent-session-host-handoff.test.ts |  6 +-
 .../structured-agent-session-host-lifetime.ts | 14 +++-
 .../structured-agent-session-host.ts          |  5 +-
 ...gent-session-native-handoff-acquisition.ts |  2 +
 ...red-agent-session-send-preparation.test.ts | 73 ++++++++++++++++++-
 ...ructured-agent-session-send-preparation.ts | 17 +++--
 9 files changed, 127 insertions(+), 33 deletions(-)

diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-attach-orchestration.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-attach-orchestration.ts
index e02ee5750d37..207c497636bb 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-attach-orchestration.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-attach-orchestration.ts
@@ -67,9 +67,11 @@ export function attachStructuredAgentSession(
   params: AgentSessionAttachParams
 ): Promise<AgentSessionMutationResult<AgentSessionAttachResult>> {
   const sessionId = params.envelope.sessionId
+  // Tracked from enqueue, not from its turn on the queue: a quit drains a queued attach before it
+  // evicts, so no child is spawned behind the eviction and orphaned.
   const run = (recordPhase?: AgentSessionCreatePhaseRecorder) =>
-    context.serialize(sessionId, () =>
-      attachStructuredAgentSessionUnderSerialize(context, callerKey, params, { recordPhase })
+    context.tasks.trackAttach(
+      context.serialize(sessionId, () => runAttach(context, callerKey, params, { recordPhase }))
     )
   if (params.envelope.expectedRuntimeFence !== null) {
     return run()
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-event-recovery.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-event-recovery.ts
index 851b08a1d20c..0c87a9780e73 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-event-recovery.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-event-recovery.ts
@@ -1,11 +1,10 @@
-import type { StructuredAgentSessionAttachContext } from './structured-agent-session-attach-context'
 import type { StructuredAgentSessionLifecycleEvent } from './structured-agent-session-adapter'
 import type {
   StructuredAgentSessionHostDeps,
   StructuredAgentSessionHostSession
 } from './structured-agent-session-host-types'
 import type { StructuredAgentSessionSinkBarrier } from './structured-agent-session-event-sink'
-import { resumeHeldStructuredAgentSession } from './structured-agent-session-hold-resume'
+import type { StructuredAgentSessionHolds } from './structured-agent-session-holds'
 import { settleStructuredAgentSessionProviderStarted } from './structured-agent-session-provider-started'
 import {
   isStructuredAgentSessionRecoveryTicketCurrent,
@@ -26,7 +25,8 @@ export class StructuredAgentSessionEventRecovery {
       hasResumeCapableHolder: (sessionId: string) => boolean
       serialize: <T>(sessionId: string, task: () => Promise<T>) => Promise<T>
       now: () => number
-      attachContext: () => StructuredAgentSessionAttachContext
+      /** The one restart every asker shares; the holds put an unheld child on the idle clock. */
+      ensureProviderChild: StructuredAgentSessionHolds['ensureProviderChild']
       onBarrierError: (sessionId: string, error: unknown) => void
     }
   ) {}
@@ -73,18 +73,13 @@ export class StructuredAgentSessionEventRecovery {
       return
     }
     // One serialized step with the ticket check inside it: a hold or a send that got there first
-    // has already replaced the owner, and this attach then refuses on the stale ticket rather than
-    // spawning a second child against the fence it moved.
+    // has already replaced the owner, and this step finds that child and attaches nothing — or,
+    // once the lease has moved on, refuses on the stale ticket rather than spawning a second child.
     try {
       const resumed = await this.context.serialize(ticket.sessionId, () =>
-        resumeHeldStructuredAgentSession({
-          sessionId: ticket.sessionId,
-          context: this.context.attachContext(),
-          callerKey: 'trusted-local:provider-exit-recovery',
-          attachOptions: {
-            admitRecoveryTicket: () =>
-              isStructuredAgentSessionRecoveryTicketCurrent(this.context, ticket)
-          }
+        this.context.ensureProviderChild(ticket.sessionId, {
+          admitRecoveryTicket: () =>
+            isStructuredAgentSessionRecoveryTicketCurrent(this.context, ticket)
         })
       )
       if (!resumed.ok && isStructuredAgentSessionRecoveryTicketCurrent(this.context, ticket)) {
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-holds.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-holds.ts
index fc88974f14a9..cd824cbaf7c5 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-holds.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-holds.ts
@@ -22,10 +22,14 @@ import {
 } from './structured-agent-session-release-clock'
 import { StructuredAgentSessionHolders } from './structured-agent-session-holders'
 import type { StructuredAgentSessionResumeOutcome } from './structured-agent-session-hold-resume'
+import type { StructuredAgentSessionAttachOptions } from './structured-agent-session-attach-orchestration'
 
 export type StructuredAgentSessionHoldsDeps = {
   /** Attaches a provider child, for a caller already inside `serialize`. */
-  resume: (sessionId: string) => Promise<StructuredAgentSessionResumeOutcome>
+  resume: (
+    sessionId: string,
+    attachOptions?: StructuredAgentSessionAttachOptions
+  ) => Promise<StructuredAgentSessionResumeOutcome>
   serialize: <T>(sessionId: string, task: () => Promise<T>) => Promise<T>
   /** Whether evicting this session would actually free anything. */
   hasProviderChild: (sessionId: string) => boolean
@@ -105,13 +109,17 @@ export class StructuredAgentSessionHolds {
    * exact: a hold and a send that both find the owner gone run this in turn, and the second sees
    * the first one's child. Each caller makes at most one attach, and a failed one leaves the
    * next caller to make its own. With no surface holding the session afterwards, the child goes
-   * on the same clock a departed surface would start.
+   * on the same clock a departed surface would start — including the surface that held it when
+   * provider-exit recovery began and left while the attach ran.
    */
-  async ensureProviderChild(sessionId: string): Promise<StructuredAgentSessionResumeOutcome> {
+  async ensureProviderChild(
+    sessionId: string,
+    attachOptions?: StructuredAgentSessionAttachOptions
+  ): Promise<StructuredAgentSessionResumeOutcome> {
     if (this.deps.hasProviderChild(sessionId)) {
       return { ok: true }
     }
-    const resumed = await this.deps.resume(sessionId)
+    const resumed = await this.deps.resume(sessionId, attachOptions)
     if (!resumed.ok) {
       return resumed
     }
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-host-handoff.test.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-host-handoff.test.ts
index 9e971960c2dd..55e186ba5232 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-host-handoff.test.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-host-handoff.test.ts
@@ -183,7 +183,9 @@ describe('native handoff acquisition', () => {
       fence: reserved.record.lease.runtimeFence,
       hasProviderChild: false,
       providerChildPhase: 'ready' as const,
-      acquisitionGeneration: null
+      acquisitionGeneration: null,
+      // Left by a restart before the handoff; a writer current as of it is not current now.
+      resumedFromFence: 1
     }
     const acquiring = acquireNativeHandoffOwner(
       {
@@ -220,6 +222,8 @@ describe('native handoff acquisition', () => {
     await acquiring
 
     expect(order).toEqual(['append-entered', 'append-complete', 'unbind', 'acquire'])
+    // The handoff moved the fence, not a restart: nothing is rebased across it.
+    expect(session.resumedFromFence).toBeUndefined()
   })
 
   it('refuses an unsupported adapter before unbinding the TUI owner', async () => {
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-host-lifetime.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-host-lifetime.ts
index 8b1f108b3e66..8ac528f1e356 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-host-lifetime.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-host-lifetime.ts
@@ -173,13 +173,21 @@ export function createStructuredAgentSessionHolds(
 ): StructuredAgentSessionHolds {
   const context = attachContext()
   return new StructuredAgentSessionHolds({
-    resume: (sessionId) =>
+    resume: (sessionId, attachOptions) =>
       resumeHeldStructuredAgentSession({
         sessionId,
         context: attachContext(),
-        callerKey: 'trusted-local:surface-hold'
+        callerKey: attachOptions?.admitRecoveryTicket
+          ? 'trusted-local:provider-exit-recovery'
+          : 'trusted-local:surface-hold',
+        ...(attachOptions ? { attachOptions } : {})
       }),
-    serialize: (sessionId, task) => attachContext().serialize(sessionId, task),
+    // Tracked from enqueue: a quit drains a queued resume before it evicts, so no child is
+    // spawned behind the eviction and orphaned.
+    serialize: (sessionId, task) => {
+      const current = attachContext()
+      return current.tasks.trackAttach(current.serialize(sessionId, task))
+    },
     evict: close,
     hasProviderChild: (sessionId) => hasProviderChild(context, sessionId),
     isTurnActive: (sessionId) => {
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-host.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-host.ts
index b97b53474785..9b3544dae074 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-host.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-host.ts
@@ -145,9 +145,10 @@ export class StructuredAgentSessionHost {
         this.subscribers.snapshot(sessionId, session.journal, session.fence),
       publishStatus: this.clientDelivery.publishStatusAndSettlement,
       hasResumeCapableHolder: (sessionId) => this.holds.hasResumeCapableHolder(sessionId),
-      serialize: (sessionId, task) => this.serialize(sessionId, task),
+      // Tracked: a quit drains a queued restart before it evicts, so no child outlives it.
+      serialize: (sessionId, task) => this.tasks.trackAttach(this.serialize(sessionId, task)),
       now: () => this.now(),
-      attachContext: () => this.attachContext(),
+      ensureProviderChild: (id, options) => this.holds.ensureProviderChild(id, options),
       onBarrierError: (sessionId, error) => deps.onEventSinkError?.({ sessionId, error })
     })
     this.restartResume = createStructuredAgentSessionRestartResume(deps, this.sessions, {
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-native-handoff-acquisition.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-native-handoff-acquisition.ts
index 40f1c5721772..c88f0918d25e 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-native-handoff-acquisition.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-native-handoff-acquisition.ts
@@ -115,6 +115,8 @@ async function proveNativeHandoffOwner(
   session.providerChildPhase = acquired.providerChildPhase ?? 'ready'
   host.publishStatus?.(input.sessionId)
   session.fence = proved.lease.runtimeFence
+  // A handoff moved the fence, not a restart: no writer is rebased across it.
+  delete session.resumedFromFence
   session.acquisitionGeneration = acquired.acquisitionGeneration ?? null
   adopt()
   eventSink.bind({
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-send-preparation.test.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-send-preparation.test.ts
index 30b27f608c7d..cee652cabecf 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-send-preparation.test.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-send-preparation.test.ts
@@ -394,8 +394,9 @@ describe('a send with no live owner', () => {
   it('refuses for good when the owner cannot be restarted, saying why in the answer and in the chat', async () => {
     await loseOwner()
     acquire.mockRejectedValue(new Error('no provider thread to resume'))
+    const params = sendParams('nothing to resume')
 
-    const result = await host.send(CALLER, sendParams('nothing to resume'))
+    const result = await host.send(CALLER, params)
 
     expect(result).toMatchObject({
       ok: false,
@@ -416,6 +417,14 @@ describe('a send with no live owner', () => {
     // The same status row a failed start leaves, so the reason outlives the error strip.
     expect(journalStatuses()).toEqual([expect.stringContaining('no provider thread to resume')])
 
+    // A client that resends the same id gets another attempt, and the chat no second row.
+    await expect(host.send(CALLER, params)).resolves.toMatchObject({
+      ok: false,
+      refusal: { code: 'agent_session_owner_unrecoverable' }
+    })
+    expect(acquire).toHaveBeenCalledTimes(2)
+    expect(journalStatuses()).toHaveLength(1)
+
     // Nothing is remembered: a Retry under a new id is a fresh attempt, and this one succeeds.
     acquire.mockReset()
     acquire.mockImplementation(spawnChild)
@@ -499,6 +508,68 @@ describe('a send with no live owner', () => {
     expect(store.getRecord(SESSION)?.lease.claimStatus).toBe('live')
   })
 
+  it('puts the child of an auto-restart on the idle clock when its surface left mid-attach', async () => {
+    await host.hold(SESSION, 'desktop-chat:1')
+    const exitedFence = store.getRecord(SESSION)?.lease.runtimeFence ?? 0
+    acquire.mockClear()
+    const entered = Promise.withResolvers<void>()
+    const gate = Promise.withResolvers<void>()
+    const spawnChild = acquire.getMockImplementation()!
+    acquire.mockImplementationOnce(async (input) => {
+      entered.resolve()
+      await gate.promise
+      return spawnChild(input)
+    })
+
+    const restarted = host.handleAdapterEvent({
+      type: 'ended',
+      sessionId: SESSION,
+      reason: 'provider exited',
+      cause: 'unexpected-exit',
+      fence: exitedFence,
+      acquisitionGeneration: 'generation-1'
+    })
+    await entered.promise
+    // The only surface leaves while the host is still spawning the child it asked for.
+    host.release(SESSION, 'desktop-chat:1')
+    gate.resolve()
+    await restarted
+
+    expect(acquire).toHaveBeenCalledOnce()
+    expect(host['holds'].isHeld(SESSION)).toBe(false)
+    // Nobody holds the child, so it goes on the same clock a departed surface would start.
+    expect(host['holds'].isReleasePending(SESSION)).toBe(true)
+    expect(hostErrors).toEqual([])
+  })
+
+  it('counts a queued restart as in flight from the moment it is asked for, so a quit drains it', async () => {
+    const closeSession = vi.mocked(host.deps.adapter.closeSession!)
+    acquire.mockClear()
+    const gate = Promise.withResolvers<void>()
+    closeSession.mockImplementationOnce(async () => {
+      await gate.promise
+      return true
+    })
+    const closing = host.close(SESSION)
+    const hold = host.hold(SESSION, 'desktop-chat:1')
+    let drained = false
+    void host['tasks'].drainAttaches().then(() => {
+      drained = true
+    })
+    await new Promise<void>((resolve) => setImmediate(resolve))
+
+    // The hold waits its turn behind the close, and the quit's drain waits for the hold: the
+    // child it is about to spawn must exist before the quit decides what to evict.
+    expect(acquire).not.toHaveBeenCalled()
+    expect(drained).toBe(false)
+
+    gate.resolve()
+    await Promise.all([closing, hold])
+    await new Promise<void>((resolve) => setImmediate(resolve))
+    expect(acquire).toHaveBeenCalledOnce()
+    expect(drained).toBe(true)
+  })
+
   it('adjudicates a lease this host has not reconciled before a hold resumes it', async () => {
     await loseOwner()
     await store.transitionHandoff(SESSION, (current) => ({
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-send-preparation.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-send-preparation.ts
index dcb1d74d05a3..394afc5dc200 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-send-preparation.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-send-preparation.ts
@@ -100,7 +100,7 @@ export function structuredAgentSessionSendNeedsOwner(
 
 type SendPreparationContext = Pick<
   StructuredAgentSessionMutationContext,
-  'deps' | 'sessions' | 'holds' | 'restoreReadable' | 'publish' | 'now'
+  'deps' | 'sessions' | 'holds' | 'restoreReadable' | 'publish'
 >
 
 export async function prepareStructuredAgentSessionSend(
@@ -117,7 +117,7 @@ export async function prepareStructuredAgentSessionSend(
     return { ok: true, envelope }
   }
   if (structuredAgentSessionSendNeedsOwner(context.sessions.get(sessionId), record)) {
-    const refusal = await restartOwnerForSend(context, sessionId)
+    const refusal = await restartOwnerForSend(context, envelope)
     if (refusal) {
       return { ok: false, refusal }
     }
@@ -130,8 +130,9 @@ export async function prepareStructuredAgentSessionSend(
  *  own bookkeeping, which is reported and never gates the user's action. */
 async function restartOwnerForSend(
   context: SendPreparationContext,
-  sessionId: string
+  envelope: AgentSessionMutationEnvelope
 ): Promise<AgentSessionWireRefusal | null> {
+  const { sessionId } = envelope
   let resumed: Awaited<ReturnType<typeof context.holds.ensureProviderChild>>
   try {
     resumed = await context.holds.ensureProviderChild(sessionId)
@@ -147,7 +148,7 @@ async function restartOwnerForSend(
     sessionId,
     error: new Error(`${resumed.refusal.code}: ${resumed.refusal.message}`)
   })
-  await recordFailedRestart(context, sessionId, refusal.message)
+  await recordFailedRestart(context, envelope, refusal.message)
   return refusal
 }
 
@@ -162,12 +163,14 @@ function ownerUnrecoverableRefusal(cause: AgentSessionWireRefusal): AgentSession
 }
 
 /** The same status row a start that failed leaves in the chat, so the reason outlives the error
- *  strip. The journal is made readable for it when the failed attach left none behind. */
+ *  strip. The journal is made readable for it when the failed attach left none behind. Keyed by
+ *  the send, not the clock: a resend of the same id that fails again adds no second row. */
 async function recordFailedRestart(
   context: SendPreparationContext,
-  sessionId: string,
+  envelope: AgentSessionMutationEnvelope,
   text: string
 ): Promise<void> {
+  const { sessionId } = envelope
   try {
     if (!context.sessions.has(sessionId)) {
       await context.restoreReadable(sessionId)
@@ -176,7 +179,7 @@ async function recordFailedRestart(
     if (!session) {
       return
     }
-    const settlementId = `failed-restart:${sessionId}:${session.fence}:${context.now()}`
+    const settlementId = `failed-restart:${envelope.clientOperationId}`
     await session.journal.appendLifecycleBatch({
       settlementId,
       fence: session.fence,

From 2458b2a842439b5283a74e0956add3e2abf7a8ef Mon Sep 17 00:00:00 2001
From: Brennan Benson <79079362+brennanb2025@users.noreply.github.com>
Date: Wed, 23 Sep 2026 13:01:23 -0700
Subject: [PATCH 36/67] fix(native-chat): a Claude start no longer waits behind
 another session's exit recovery

The runtime delivered every Claude lifecycle event on the single chain
exit recovery uses so teardown can drain it. That chain orders nothing
across sessions, and an exit recovery on it can run a full reacquisition,
so one chat's `started` waited on an unrelated chat's respawn and kept
its 'still starting' line up. `started` now takes only its own session's
serialized step, is queued the moment it is emitted (ahead of any later
exit of that child), and is tracked in a set the same teardown drain waits
on.
---
 .../structured-agent-session-adapter.ts       |  2 +-
 ...ructured-agent-session-provider-started.ts |  4 +-
 ...ctured-agent-session-lifecycle-delivery.ts | 59 +++++++++++++++++
 ...t-session-runtime-provider-started.test.ts | 63 ++++++++++++++++++-
 .../structured-agent-session-runtime.ts       | 49 ++++-----------
 ...ed-claude-scripted-runtime-test-support.ts |  5 ++
 6 files changed, 139 insertions(+), 43 deletions(-)
 create mode 100644 src/main/runtime/structured-agent-session-lifecycle-delivery.ts

diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-adapter.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-adapter.ts
index 5396b4942b64..bdc7dd27d7c7 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-adapter.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-adapter.ts
@@ -149,7 +149,7 @@ export type StructuredAgentSessionStartedEvent = {
   fence: number
   acquisitionGeneration: string
   /** What the child proved, snapshotted by the adapter from what startup already read. The host
-   *  handles this on the chain every session's exit recovery shares, so it must not ask the CLI. */
+   *  handles this inside the session's serialized step, so it must not ask the CLI. */
   reportedOptions: AgentSessionOptionsResult['current']
   /** Saved options the restore could not apply; the host drops them rather than persist them. */
   restoreSkippedOptions: readonly string[]
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-provider-started.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-provider-started.ts
index c53f9a5ae195..77807c0ca44e 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-provider-started.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-provider-started.ts
@@ -6,8 +6,8 @@
 // the same record write a user's option change takes. Bookkeeping never gates the user: a failed
 // write is reported and the session stays usable.
 //
-// This runs on the chain every session's exit recovery shares, and under the session's own
-// serialized step, so it asks the provider nothing: the event carries what the child proved.
+// This runs under the session's own serialized step, which its close and sends wait on, so it
+// asks the provider nothing: the event carries what the child proved.
 
 import { agentSessionLeaseAdmitsWriter } from '../../../shared/agent-session-lease-adjudication'
 import type { StructuredAgentSessionStartedEvent } from './structured-agent-session-adapter'
diff --git a/src/main/runtime/structured-agent-session-lifecycle-delivery.ts b/src/main/runtime/structured-agent-session-lifecycle-delivery.ts
new file mode 100644
index 000000000000..961c4d50aa84
--- /dev/null
+++ b/src/main/runtime/structured-agent-session-lifecycle-delivery.ts
@@ -0,0 +1,59 @@
+// How provider lifecycle events reach the host, and how teardown knows every one has landed.
+//
+// Exit recovery runs on one chain so teardown can drain it: exit callbacks arrive from child
+// process tasks, and a fire-and-forget one could otherwise append after the host flushed and
+// removed its journal directory. That chain orders nothing across sessions, and a recovery on it
+// can run a whole reacquisition, so `started` stays off it: it takes only its own session's
+// serialized step, and is tracked here so the same drain still waits for it.
+
+import type { StructuredAgentSessionLifecycleEvent } from '../native-chat/agent-session-wire/structured-agent-session-adapter'
+
+export function createStructuredAgentSessionLifecycleDelivery(input: {
+  handle: (event: StructuredAgentSessionLifecycleEvent) => Promise<void> | undefined
+  onError?: (input: { scope: string; error: unknown }) => void
+  /** Exits the adapter has observed but not yet published. */
+  drainObservedExits: () => Promise<void>
+}): {
+  deliver: (event: StructuredAgentSessionLifecycleEvent) => void
+  /** Resolves once every observed exit has published and everything delivered has settled. */
+  drain: () => Promise<void>
+} {
+  let recoveryChain = Promise.resolve()
+  const settlingStarts = new Set<Promise<void>>()
+  const settle = async (event: StructuredAgentSessionLifecycleEvent): Promise<void> => {
+    try {
+      await input.handle(event)
+    } catch (error) {
+      const scope = event.type === 'started' ? 'started' : 'exit'
+      input.onError?.({ scope: `structured-agent-session-${scope}:${event.sessionId}`, error })
+    }
+  }
+  return {
+    deliver: (event) => {
+      if (event.type === 'started') {
+        // Called now, so the step is queued on its session ahead of any later exit of that child.
+        const settling = settle(event)
+        settlingStarts.add(settling)
+        void settling.finally(() => settlingStarts.delete(settling))
+        return
+      }
+      recoveryChain = recoveryChain.then(() => settle(event))
+    },
+    drain: async () => {
+      // A recovery may synchronously trigger another exit while it is reacquiring, so observe
+      // until nothing new arrives.
+      for (;;) {
+        await input.drainObservedExits()
+        const observed = recoveryChain
+        await observed
+        if (settlingStarts.size > 0) {
+          await Promise.all(settlingStarts)
+          continue
+        }
+        if (observed === recoveryChain) {
+          return
+        }
+      }
+    }
+  }
+}
diff --git a/src/main/runtime/structured-agent-session-runtime-provider-started.test.ts b/src/main/runtime/structured-agent-session-runtime-provider-started.test.ts
index a2921ee41ea6..e7a2bb822b46 100644
--- a/src/main/runtime/structured-agent-session-runtime-provider-started.test.ts
+++ b/src/main/runtime/structured-agent-session-runtime-provider-started.test.ts
@@ -1,6 +1,6 @@
-// Every provider's lifecycle events share one recovery chain in the runtime. A Claude child
-// proving its start must not make that chain, or the session's own serialized operations,
-// wait on the CLI: the host records what the child proved from what the adapter already holds.
+// A Claude child proving its start must not wait on another session's exit recovery, and must
+// not make that recovery, or the session's own serialized operations, wait on the CLI: the host
+// records what the child proved from what the adapter already holds.
 
 import { afterEach, describe, expect, it, vi } from 'vitest'
 import { waitForStructuredAgentSessionRecovery } from './structured-agent-session-runtime'
@@ -55,4 +55,61 @@ describe('a Claude child proving its start', () => {
     })
     await vi.waitFor(() => expect(closed).toBe(true))
   })
+
+  it("flips to ready while another session's exit recovery is still acquiring", async () => {
+    const host = await claude.install()
+    await expect(host.attach(CALLER, claude.attachParams(HEALTHY, null))).resolves.toMatchObject({
+      ok: true
+    })
+    await host.hold(HEALTHY, 'surface-1')
+    await waitForStructuredAgentSessionRecovery()
+
+    // Its exit recovery reacquires, and that spawn never returns.
+    claude.behave(HEALTHY, { spawnHangs: true })
+    claude.child(HEALTHY).exit(new Error('claude stream-json exited (code 1): crashed'))
+    await vi.waitFor(() =>
+      expect(host.deps.store.getRecord(HEALTHY)?.lease.claimStatus).toBe('released')
+    )
+
+    await expect(host.attach(CALLER, claude.attachParams(STALLED, null))).resolves.toMatchObject({
+      ok: true
+    })
+    await vi.waitFor(() =>
+      expect(host.deps.store.getRecord(STALLED)?.options).toEqual({
+        model: 'claude-sonnet-5',
+        effort: 'high'
+      })
+    )
+  })
+
+  it('is drained by the runtime before teardown proceeds', async () => {
+    const host = await claude.install()
+    const store = host.deps.store
+    const replaceSessionOptions = store.replaceSessionOptions.bind(store)
+    let landWrite = (): void => {}
+    const writeHeld = new Promise<void>((resolve) => {
+      landWrite = resolve
+    })
+    let writing = false
+    vi.spyOn(store, 'replaceSessionOptions').mockImplementation(async (input) => {
+      writing = true
+      await writeHeld
+      return replaceSessionOptions(input)
+    })
+    await expect(host.attach(CALLER, claude.attachParams(HEALTHY, null))).resolves.toMatchObject({
+      ok: true
+    })
+    await vi.waitFor(() => expect(writing).toBe(true))
+
+    let drained = false
+    const recovery = waitForStructuredAgentSessionRecovery().then(() => {
+      drained = true
+    })
+    await new Promise((resolve) => setTimeout(resolve, 20))
+    expect(drained).toBe(false)
+
+    landWrite()
+    await recovery
+    expect(store.getRecord(HEALTHY)?.options).toEqual({ model: 'claude-sonnet-5', effort: 'high' })
+  })
 })
diff --git a/src/main/runtime/structured-agent-session-runtime.ts b/src/main/runtime/structured-agent-session-runtime.ts
index 1e2c8454c6f6..6cabfce36839 100644
--- a/src/main/runtime/structured-agent-session-runtime.ts
+++ b/src/main/runtime/structured-agent-session-runtime.ts
@@ -49,6 +49,7 @@ import { resolveLoginShellEnvironment } from '../startup/login-shell-environment
 import { recordAgentSessionProviderHandle } from './agent-session-provider-handle-transition'
 import type { ClaudeStructuredAuthPolicy } from '../claude-accounts/claude-structured-auth-policy'
 import { createStructuredClaudeRuntimeAdapter } from './structured-claude-runtime-adapter'
+import { createStructuredAgentSessionLifecycleDelivery } from './structured-agent-session-lifecycle-delivery'
 
 /** Sibling of the journal tree rather than inside it: one file adjudicates every
  *  session's lease, while a journal is per session. */
@@ -212,7 +213,13 @@ async function install(deps: StructuredAgentSessionRuntimeDeps): Promise<Install
   })
   try {
     let host: StructuredAgentSessionHost | null = null
-    let recoveryChain = Promise.resolve()
+    const lifecycle = createStructuredAgentSessionLifecycleDelivery({
+      handle: (event) => host?.handleAdapterEvent(event),
+      ...(deps.onError ? { onError: deps.onError } : {}),
+      // Claude publishes an observed exit only after its close ladder and transcript write; Codex
+      // publishes inside its own exit callback and needs nothing.
+      drainObservedExits: () => claude.drainObservedExits()
+    })
     const onDispatchSettledLate = (
       settlement: Parameters<StructuredAgentSessionHost['settleLateDispatch']>[0]
     ): void => {
@@ -252,19 +259,9 @@ async function install(deps: StructuredAgentSessionRuntimeDeps): Promise<Install
           )
       },
       onEvent: (event) => {
-        if (event.type !== 'ended' || !('cause' in event) || event.cause !== 'unexpected-exit') {
-          return
+        if (event.type === 'ended' && 'cause' in event && event.cause === 'unexpected-exit') {
+          lifecycle.deliver(event)
         }
-        // Serialize recovery with teardown. Exit callbacks arrive from child
-        // process tasks, so a fire-and-forget callback can otherwise append
-        // after the host has flushed and its journal directory is removed.
-        recoveryChain = recoveryChain.then(async () => {
-          try {
-            await host?.handleAdapterEvent(event)
-          } catch (error) {
-            deps.onError?.({ scope: `structured-agent-session-exit:${event.sessionId}`, error })
-          }
-        })
       }
     })
     const claude = createStructuredClaudeRuntimeAdapter({
@@ -284,15 +281,7 @@ async function install(deps: StructuredAgentSessionRuntimeDeps): Promise<Install
               readClaudeManagedAccountGateSettings(deps.getClaudeManagedAccountGateSettings!)
           }
         : {}),
-      onLifecycleEvent: (event) => {
-        recoveryChain = recoveryChain.then(async () => {
-          try {
-            await host?.handleAdapterEvent(event)
-          } catch (error) {
-            deps.onError?.({ scope: `structured-agent-session-exit:${event.sessionId}`, error })
-          }
-        })
-      },
+      onLifecycleEvent: (event) => lifecycle.deliver(event),
       onBackgroundTasksChanged: (sessionId, state) =>
         host?.publishBackgroundTaskState(sessionId, state),
       onDispatchSettledLate,
@@ -333,21 +322,7 @@ async function install(deps: StructuredAgentSessionRuntimeDeps): Promise<Install
     return {
       host,
       adapter,
-      waitForRecovery: async () => {
-        // A recovery may synchronously trigger another exit while it is
-        // reacquiring. Observe until the chain stops growing.
-        for (;;) {
-          // Claude reaches the chain only once its close ladder and transcript
-          // write publish the exit, so an observed death is not yet a chained
-          // one. Codex publishes inside its own exit callback and needs nothing.
-          await claude.drainObservedExits()
-          const observed = recoveryChain
-          await observed
-          if (observed === recoveryChain) {
-            return
-          }
-        }
-      }
+      waitForRecovery: lifecycle.drain
     }
   } catch (error) {
     agentSessionPtyWriteGate.detachRecordLookup()
diff --git a/src/main/runtime/structured-claude-scripted-runtime-test-support.ts b/src/main/runtime/structured-claude-scripted-runtime-test-support.ts
index 3f971ce24b57..2b495ed49620 100644
--- a/src/main/runtime/structured-claude-scripted-runtime-test-support.ts
+++ b/src/main/runtime/structured-claude-scripted-runtime-test-support.ts
@@ -23,6 +23,8 @@ export type ScriptedClaudeBehavior = {
   initHangs?: boolean
   /** Every control read after startup's own settings read waits for `releaseStalls`. */
   stallsControlReads?: boolean
+  /** The spawn itself waits for `releaseStalls`, holding its acquisition open. */
+  spawnHangs?: boolean
 }
 
 export type ScriptedClaudeChild = {
@@ -57,6 +59,9 @@ export function createScriptedClaudeRuntime(sessionIds: readonly string[]) {
       throw new Error(`no scripted Claude session for ${providerSessionId}`)
     }
     const behavior = behaviors.get(sessionId) ?? {}
+    if (behavior.spawnHangs) {
+      await stall
+    }
     let failInit = (_error: Error): void => {}
     const answer = <T>(value: T, startup: boolean): Promise<T> =>
       behavior.stallsControlReads && !startup ? stall.then(() => value) : Promise.resolve(value)

From a9dd581c918a2ad6ded762a944de86c5e9c59258 Mon Sep 17 00:00:00 2001
From: Brennan Benson <79079362+brennanb2025@users.noreply.github.com>
Date: Wed, 23 Sep 2026 13:05:55 -0700
Subject: [PATCH 37/67] fix(native-chat): a Claude create that dies at spawn is
 refused with the CLI's own diagnostic
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

A CLI that exited before its acquisition handed the child over was
refused with 'claude stream-json for session … exited while being
acquired', or with an unreadable start time, and the stderr the exit
carried (for example 'not signed in') appeared nowhere. The acquisition
now keeps the error its connection ended with and answers with it at
both sites; the generic message is only a fallback when none exists.
---
 .../claude-structured-session-acquisition.ts  | 18 +++++++++++++---
 ...ude-structured-failed-start-resume.test.ts | 20 ++++++++++++++++++
 ...ed-claude-scripted-runtime-test-support.ts | 21 ++++++++++++++++++-
 3 files changed, 55 insertions(+), 4 deletions(-)

diff --git a/src/main/claude/claude-structured-session-acquisition.ts b/src/main/claude/claude-structured-session-acquisition.ts
index 4dd0ddca3b41..f7395447a487 100644
--- a/src/main/claude/claude-structured-session-acquisition.ts
+++ b/src/main/claude/claude-structured-session-acquisition.ts
@@ -67,6 +67,8 @@ export async function acquireClaudeSession({
   let liveSession: ClaudeSession | null = null
   let observedLeafUuid: string | null = null,
     expectedProviderSessionId: string | null = null
+  // The CLI's own account of why it ended (stderr included): the only reason a user can act on.
+  let childEnded: Error | null = null
   // Frames are admitted only after launch resolution proves the provider session
   // this acquisition owns. Keep the check ahead of every stateful consumer.
   const initProof = createClaudeInitProof()
@@ -174,8 +176,12 @@ export async function acquireClaudeSession({
           onMessage,
           canUseTool,
           onUserDialog,
-          onFault: (error) => initProof.reject(error),
+          onFault: (error) => {
+            childEnded ??= error
+            initProof.reject(error)
+          },
           onExit: (error) => {
+            childEnded ??= error
             initProof.reject(error)
             callbacks.handleExit(sessionId, attempt, error)
           }
@@ -216,10 +222,16 @@ export async function acquireClaudeSession({
     const process = await claudeProcessIdentity(
       { ...input, pid: connection.pid },
       deps.readProcessStartTime
-    )
+    ).catch((error: unknown) => {
+      // A child that already ended explains why its start time could not be read.
+      throw childEnded ?? error
+    })
     acquisitions.assertCurrent(sessionId, attempt)
     if (connection.closed) {
-      throw new Error(`claude stream-json for session ${sessionId} exited while being acquired`)
+      throw (
+        childEnded ??
+        new Error(`claude stream-json for session ${sessionId} exited while being acquired`)
+      )
     }
     const publication = createClaudeSessionPublication({
       connection,
diff --git a/src/main/runtime/claude-structured-failed-start-resume.test.ts b/src/main/runtime/claude-structured-failed-start-resume.test.ts
index c46d632a6645..32362cbafdce 100644
--- a/src/main/runtime/claude-structured-failed-start-resume.test.ts
+++ b/src/main/runtime/claude-structured-failed-start-resume.test.ts
@@ -50,3 +50,23 @@ describe('a Claude chat whose first start died before initialize', () => {
     )
   })
 })
+
+describe('a Claude chat whose CLI exits the moment it is spawned', () => {
+  // Before the spawn returns, the start time of a dead pid is unreadable; during that read, the
+  // child is found closed afterwards. Both must answer with what the CLI said.
+  it.each(['spawn', 'start-time-read'] as const)(
+    "refuses the create with the CLI's own diagnostic when it exits at %s",
+    async (at) => {
+      const diagnostic = 'claude stream-json exited (code 1): claude: not signed in'
+      claude.behave(SESSION, { exitsDuringSpawn: { diagnostic, at } })
+      const host = await claude.install()
+
+      const created = await host.attach(CALLER, claude.attachParams(SESSION, null))
+
+      expect(created).toMatchObject({
+        ok: false,
+        refusal: { message: expect.stringContaining('not signed in'), ownerVerdict: 'exited' }
+      })
+    }
+  )
+})
diff --git a/src/main/runtime/structured-claude-scripted-runtime-test-support.ts b/src/main/runtime/structured-claude-scripted-runtime-test-support.ts
index 2b495ed49620..7a7bba8d7500 100644
--- a/src/main/runtime/structured-claude-scripted-runtime-test-support.ts
+++ b/src/main/runtime/structured-claude-scripted-runtime-test-support.ts
@@ -25,6 +25,8 @@ export type ScriptedClaudeBehavior = {
   stallsControlReads?: boolean
   /** The spawn itself waits for `releaseStalls`, holding its acquisition open. */
   spawnHangs?: boolean
+  /** The CLI exits with this diagnostic before its spawn returns, or while its start time is read. */
+  exitsDuringSpawn?: { diagnostic: string; at: 'spawn' | 'start-time-read' }
 }
 
 export type ScriptedClaudeChild = {
@@ -118,8 +120,25 @@ export function createScriptedClaudeRuntime(sessionIds: readonly string[]) {
       }
     }
     children.push(child)
+    if (behavior.exitsDuringSpawn?.at === 'spawn') {
+      exitAtSpawn(child, behavior.exitsDuringSpawn.diagnostic)
+    }
     return child.connection
   }
+  const exitAtSpawn = (child: ScriptedClaudeChild, diagnostic: string): void => {
+    child.connection.closed = true
+    child.exit(new Error(diagnostic))
+  }
+  /** A pid whose process is gone has no start time to read. */
+  const readProcessStartTime = async (pid: number): Promise<number | null> => {
+    const child = children.find((entry) => entry.connection.pid === pid)
+    const exits = child ? behaviors.get(child.sessionId)?.exitsDuringSpawn : undefined
+    if (child && exits?.at === 'start-time-read' && !child.connection.closed) {
+      exitAtSpawn(child, exits.diagnostic)
+      return pid * 10
+    }
+    return child?.connection.exitVerdict.root === 'exited' ? null : pid * 10
+  }
 
   return {
     behave: (sessionId: string, behavior: ScriptedClaudeBehavior): void => {
@@ -147,7 +166,7 @@ export function createScriptedClaudeRuntime(sessionIds: readonly string[]) {
         resolveClaudeCommand: () => '/usr/local/bin/claude',
         resolveClaudeAuthPolicy: () => ({ stripAuthEnv: false }),
         openClaudeConnection: openConnection,
-        readProcessStartTime: async (pid: number) => pid * 10
+        readProcessStartTime
       })
     },
     attachParams: (sessionId: string, expectedRuntimeFence: number | null) =>

From b2ad2c3c5bb6585e557dc5d8866b060f7bdefecb Mon Sep 17 00:00:00 2001
From: Brennan Benson <79079362+brennanb2025@users.noreply.github.com>
Date: Wed, 23 Sep 2026 13:09:56 -0700
Subject: [PATCH 38/67] test(native-chat): pin that a reopened Claude chat
 dying before initialize says why

A resumed start is published at spawn, so a CLI that exits before it
answers initialize fails a chat the user is looking at. Pin that the
open chat is sent the 'stopped before it finished starting' row with the
CLI's diagnostic even when the child's tree cannot be proven gone, and
that a message held for that start is refused rather than left in doubt.
---
 ...e-structured-resumed-start-failure.test.ts | 79 +++++++++++++++++++
 ...ed-claude-scripted-runtime-test-support.ts |  4 +-
 2 files changed, 82 insertions(+), 1 deletion(-)
 create mode 100644 src/main/runtime/claude-structured-resumed-start-failure.test.ts

diff --git a/src/main/runtime/claude-structured-resumed-start-failure.test.ts b/src/main/runtime/claude-structured-resumed-start-failure.test.ts
new file mode 100644
index 000000000000..8fcef7e4a48b
--- /dev/null
+++ b/src/main/runtime/claude-structured-resumed-start-failure.test.ts
@@ -0,0 +1,79 @@
+// A reopened Claude chat is published as soon as its child spawns, so a CLI that dies before it
+// answers initialize fails a session the user is already looking at. That chat must say why, in
+// the transcript, exactly as a failed first start does.
+
+import { afterEach, describe, expect, it, vi } from 'vitest'
+import { computeAgentSessionPayloadFingerprint } from '../../shared/agent-session-mutation-envelope'
+import type { AgentSessionSubscribeEvent } from '../../shared/agent-session-wire'
+import { hostTestMessage } from '../native-chat/agent-session-wire/structured-agent-session-host-test-data'
+import { waitForStructuredAgentSessionRecovery } from './structured-agent-session-runtime'
+import { createScriptedClaudeRuntime } from './structured-claude-scripted-runtime-test-support'
+
+const SESSION = 'claude-resumed-start'
+const CALLER = { callerKey: 'client-1' }
+const DIAGNOSTIC = 'claude stream-json exited (code 1): claude: not signed in'
+
+let claude = createScriptedClaudeRuntime([SESSION])
+
+afterEach(async () => {
+  await claude.dispose()
+  claude = createScriptedClaudeRuntime([SESSION])
+})
+
+/** Status rows the open chat was sent, whether in a batch or in the snapshot a fence change sends. */
+function statusTexts(events: AgentSessionSubscribeEvent[]): string[] {
+  return events.flatMap((event) => {
+    const items =
+      event.type === 'batch' ? event.batch.items : event.type === 'snapshot' ? event.page.items : []
+    return items.flatMap((item) => (item.body.kind === 'status' ? [item.body.text] : []))
+  })
+}
+
+describe('a reopened Claude chat whose CLI dies before initialize', () => {
+  it('publishes the startup failure, with the diagnostic, to the open chat', async () => {
+    const host = await claude.install()
+    await expect(host.attach(CALLER, claude.attachParams(SESSION, null))).resolves.toMatchObject({
+      ok: true
+    })
+    await waitForStructuredAgentSessionRecovery()
+    await host.close(SESSION)
+
+    // The user reopens it; this time the CLI never answers, then dies, and its tree is unprovable.
+    claude.behave(SESSION, { initHangs: true, closeUnproven: true })
+    await host.hold(SESSION, 'surface-1')
+    const events: AgentSessionSubscribeEvent[] = []
+    host.subscribe({ id: 'sub-1', sessionId: SESSION, emit: (event) => events.push(event) })
+    const body = hostTestMessage('hello')
+    const fence = host.deps.store.getRecord(SESSION)?.lease.runtimeFence ?? 0
+    const sent = await host.send(CALLER, {
+      envelope: {
+        sessionId: SESSION,
+        clientOperationId: `${Date.now()}-${'f'.repeat(32)}`,
+        expectedRuntimeFence: fence,
+        payloadFingerprint: computeAgentSessionPayloadFingerprint({
+          method: 'agentSession.send',
+          sessionId: SESSION,
+          fields: { body }
+        })
+      },
+      body
+    })
+    expect(sent).toMatchObject({ ok: true, value: { submission: { dispatchState: 'pending' } } })
+
+    claude.child(SESSION).exit(new Error(DIAGNOSTIC))
+    await waitForStructuredAgentSessionRecovery()
+
+    await vi.waitFor(() =>
+      expect(statusTexts(events)).toContainEqual(
+        expect.stringMatching(/stopped before it finished starting: .*not signed in/)
+      )
+    )
+    // Never written, so it did not happen: refused, not left in doubt.
+    const submission = host
+      .journalSnapshot(SESSION)
+      .submissions.find(
+        (entry) => entry.clientMessageId === (sent.ok && sent.value.clientMessageId)
+      )
+    expect(submission).toMatchObject({ dispatchState: 'rejected' })
+  })
+})
diff --git a/src/main/runtime/structured-claude-scripted-runtime-test-support.ts b/src/main/runtime/structured-claude-scripted-runtime-test-support.ts
index 7a7bba8d7500..48c3cf1b2240 100644
--- a/src/main/runtime/structured-claude-scripted-runtime-test-support.ts
+++ b/src/main/runtime/structured-claude-scripted-runtime-test-support.ts
@@ -27,6 +27,8 @@ export type ScriptedClaudeBehavior = {
   spawnHangs?: boolean
   /** The CLI exits with this diagnostic before its spawn returns, or while its start time is read. */
   exitsDuringSpawn?: { diagnostic: string; at: 'spawn' | 'start-time-read' }
+  /** Closing cannot prove the descendant tree gone, as when it was never snapshottable. */
+  closeUnproven?: boolean
 }
 
 export type ScriptedClaudeChild = {
@@ -115,7 +117,7 @@ export function createScriptedClaudeRuntime(sessionIds: readonly string[]) {
         send: async () => {},
         close: async () => {
           child.connection.closed = true
-          return true
+          return !behavior.closeUnproven
         }
       }
     }

From d878a150457ec37e3ece7a91bf2ff70e158ca851 Mon Sep 17 00:00:00 2001
From: Brennan Benson <79079362+brennanb2025@users.noreply.github.com>
Date: Wed, 23 Sep 2026 13:12:09 -0700
Subject: [PATCH 39/67] fix(native-chat): Stop while a Claude start drains its
 held prompts withdraws the rest

Stop withdrew held prompts only while startup was pending. Once startup
landed and the gate began writing them one by one, a Stop interrupted the
CLI and the prompts still waiting were written straight after it. Stop
now withdraws whatever the gate still holds in both states; the drain
takes each prompt off the queue immediately before writing it, so a
withdrawn prompt can never be written. The one already written still
gets the interrupt.
---
 .../claude-structured-prompt-ownership.ts     | 18 ++++++---
 .../claude-structured-session-startup.test.ts | 39 +++++++++++++++++++
 2 files changed, 52 insertions(+), 5 deletions(-)

diff --git a/src/main/claude/claude-structured-prompt-ownership.ts b/src/main/claude/claude-structured-prompt-ownership.ts
index 666281a6b1b4..e4c9de982d07 100644
--- a/src/main/claude/claude-structured-prompt-ownership.ts
+++ b/src/main/claude/claude-structured-prompt-ownership.ts
@@ -11,7 +11,10 @@ import {
 } from './claude-structured-control-actions'
 import type { ClaudeLateDispatchSettlement } from './claude-structured-dispatch'
 import type { ClaudeSession } from './claude-structured-session-state'
-import { rejectClaudeStartupWrites } from './claude-structured-session-startup-gate'
+import {
+  claudeStartupHoldsWrites,
+  rejectClaudeStartupWrites
+} from './claude-structured-session-startup-gate'
 import { DISPATCH_REJECTED_CANCELLED } from '../../shared/structured-agent-session-dispatch-rejection'
 
 /** Conservative user-facing window: below the 30s control deadline, trading
@@ -100,9 +103,14 @@ export async function cancelClaudeStructuredTurn(input: {
   const session = requireSession(sessions, request.sessionId)
   const acquisitionGeneration = session.acquisitionGeneration
   const prompt = request.prompt
-  // Nothing held before startup was written, so Stop withdraws it without an interrupt.
-  if (!prompt && session.startup.state === 'pending' && session.fence === request.fence) {
-    return { cancelled: rejectClaudeStartupWrites(session, DISPATCH_REJECTED_CANCELLED) }
+  // A held prompt was never written, so Stop withdraws it; the drain only writes what it still
+  // holds. Before startup lands nothing was written, so there is nothing to interrupt either.
+  let withdrewHeld = false
+  if (!prompt && claudeStartupHoldsWrites(session) && session.fence === request.fence) {
+    withdrewHeld = rejectClaudeStartupWrites(session, DISPATCH_REJECTED_CANCELLED)
+    if (session.startup.state === 'pending') {
+      return { cancelled: withdrewHeld }
+    }
   }
   if (prompt && session.fence !== request.fence) {
     return { cancelled: false }
@@ -185,7 +193,7 @@ export async function cancelClaudeStructuredTurn(input: {
     } else if (claim) {
       session.prompts.releaseClaim(claim)
     }
-    return result
+    return withdrewHeld ? { ...result, cancelled: true } : result
   } catch (error) {
     if (claim && !interruptConfirmed) {
       session.prompts.releaseClaim(claim)
diff --git a/src/main/claude/claude-structured-session-startup.test.ts b/src/main/claude/claude-structured-session-startup.test.ts
index b373e3f94693..37e9f9fc3de9 100644
--- a/src/main/claude/claude-structured-session-startup.test.ts
+++ b/src/main/claude/claude-structured-session-startup.test.ts
@@ -211,4 +211,43 @@ describe('Claude structured session publishes before the CLI answers initialize'
     ])
     await adapter.closeAll()
   })
+
+  it('withdraws the prompts still held when Stop lands while startup is writing them', async () => {
+    const claude = fakeClaude({ initDelayMs: SLOW_INIT_MS })
+    const { adapter, late } = startingAdapter(claude)
+    await adapter.acquire(ACQUIRE)
+    const connection = claude.connections[0]
+    const send = connection.send
+    let landFirstWrite = (): void => {}
+    const firstWrite = new Promise<void>((resolve) => {
+      landFirstWrite = resolve
+    })
+    let writes = 0
+    connection.send = async (message, beforeDispatch) => {
+      writes += 1
+      if (writes === 1) {
+        await firstWrite
+      }
+      return send(message, beforeDispatch)
+    }
+    await adapter.dispatch(PROMPT)
+    await adapter.dispatch({ ...PROMPT, clientMessageId: 'client-2' })
+
+    await vi.advanceTimersByTimeAsync(SLOW_INIT_MS)
+    // Startup has landed and is writing the first held prompt.
+    expect(writes).toBe(1)
+    const cancelled = adapter.cancelTurn({ sessionId: 'session-1', turnId: 'turn-1', fence: 7 })
+    await vi.advanceTimersByTimeAsync(0)
+    landFirstWrite()
+    await vi.advanceTimersByTimeAsync(5_000)
+    await adapter.drainStartup('session-1')
+
+    expect(connection.sent.filter((message) => message.type === 'user')).toHaveLength(1)
+    expect(late).toContainEqual(
+      expect.objectContaining({ clientMessageId: 'client-2', state: 'rejected' })
+    )
+    // Stop withdrew something, so it answers as a cancel whatever the interrupt made of the turn.
+    await expect(cancelled).resolves.toEqual({ cancelled: true })
+    await adapter.closeAll()
+  })
 })

From 0c395506d798bb8cd77c2f795aa7ca6f399e6eb4 Mon Sep 17 00:00:00 2001
From: Brennan Benson <79079362+brennanb2025@users.noreply.github.com>
Date: Wed, 23 Sep 2026 13:15:06 -0700
Subject: [PATCH 40/67] fix(native-chat): the release clock keeps a session
 that still owes a sent message

When the last surface stops holding a session, the release clock evicts
it after the grace unless a turn is running. A message sent while Claude
is still starting is held, not running, so switching away from that chat
for the grace evicted the session and refused a message the user had
already sent. The clock now asks whether the session owes work: a running
turn, or a submission the provider has not taken yet (still pending in
the journal). Both are read from the journal; nothing new is stored. A
starting session that owes nothing is still released, and an explicit
close still ends everything.
---
 ...red-agent-session-hold-resume-race.test.ts |   8 +-
 .../structured-agent-session-holds.test.ts    |  12 +-
 .../structured-agent-session-holds.ts         |   4 +-
 .../structured-agent-session-host-lifetime.ts |  11 +-
 .../structured-agent-session-release-clock.ts |  12 +-
 ...red-agent-session-starting-release.test.ts | 168 ++++++++++++++++++
 6 files changed, 193 insertions(+), 22 deletions(-)
 create mode 100644 src/main/native-chat/agent-session-wire/structured-agent-session-starting-release.test.ts

diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-hold-resume-race.test.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-hold-resume-race.test.ts
index bd3a840d9ad9..bf5f1408dc43 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-hold-resume-race.test.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-hold-resume-race.test.ts
@@ -17,7 +17,7 @@ function resumeHarness() {
       child = true
     },
     hasProviderChild: () => child,
-    isTurnActive: () => turnActive,
+    hasOwedWork: () => turnActive,
     evict,
     graceMs: GRACE_MS
   })
@@ -182,7 +182,7 @@ describe('a surface leaving while its structured session resumes', () => {
       const holds = new StructuredAgentSessionHolds({
         resume,
         hasProviderChild: () => child,
-        isTurnActive: () => false,
+        hasOwedWork: () => false,
         evict,
         graceMs: GRACE_MS
       })
@@ -219,7 +219,7 @@ describe('a surface leaving while its structured session resumes', () => {
     const holds = new StructuredAgentSessionHolds({
       resume,
       hasProviderChild: () => false,
-      isTurnActive: () => false,
+      hasOwedWork: () => false,
       evict: async () => {},
       graceMs: GRACE_MS
     })
@@ -259,7 +259,7 @@ describe('a surface leaving while its structured session resumes', () => {
       const holds = new StructuredAgentSessionHolds({
         resume,
         hasProviderChild: () => child,
-        isTurnActive: () => turnActive,
+        hasOwedWork: () => turnActive,
         evict,
         graceMs: GRACE_MS
       })
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-holds.test.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-holds.test.ts
index 268f28ed54e0..836f58352747 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-holds.test.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-holds.test.ts
@@ -17,13 +17,13 @@ import {
 const clocks: StructuredAgentSessionReleaseClock[] = []
 
 function clock(deps: {
-  isTurnActive?: () => boolean
+  hasOwedWork?: () => boolean
   isHeld?: () => boolean
   evict: (sessionId: string) => Promise<void>
   onError?: (input: { sessionId: string; error: unknown }) => void
 }): StructuredAgentSessionReleaseClock {
   const created = new StructuredAgentSessionReleaseClock({
-    isTurnActive: deps.isTurnActive ?? (() => false),
+    hasOwedWork: deps.hasOwedWork ?? (() => false),
     isHeld: deps.isHeld ?? (() => false),
     evict: deps.evict,
     ...(deps.onError ? { onError: deps.onError } : {}),
@@ -89,7 +89,7 @@ describe('the release clock', () => {
   it('waits out a running turn instead of evicting into it', async () => {
     const evict = vi.fn(async () => {})
     let turnRunning = true
-    const releasing = clock({ isTurnActive: () => turnRunning, evict })
+    const releasing = clock({ hasOwedWork: () => turnRunning, evict })
 
     releasing.arm('session-1')
     await new Promise((resolve) => setTimeout(resolve, 30))
@@ -138,7 +138,7 @@ describe('holds', () => {
     const holds = new StructuredAgentSessionHolds({
       resume,
       hasProviderChild: () => child,
-      isTurnActive: () => false,
+      hasOwedWork: () => false,
       evict: async () => {},
       graceMs: 1
     })
@@ -160,7 +160,7 @@ describe('holds', () => {
     const holds = new StructuredAgentSessionHolds({
       resume: async () => {},
       hasProviderChild: () => false,
-      isTurnActive: () => false,
+      hasOwedWork: () => false,
       evict,
       graceMs: 1
     })
@@ -178,7 +178,7 @@ describe('holds', () => {
     const holds = new StructuredAgentSessionHolds({
       resume: async () => {},
       hasProviderChild: () => false,
-      isTurnActive: () => false,
+      hasOwedWork: () => false,
       evict: async () => {},
       graceMs: 1
     })
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-holds.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-holds.ts
index 73880022646b..992c736b4ce8 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-holds.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-holds.ts
@@ -21,7 +21,7 @@ export type StructuredAgentSessionHoldsDeps = {
   resume: (sessionId: string) => Promise<void>
   /** Whether evicting this session would actually free anything. */
   hasProviderChild: (sessionId: string) => boolean
-  isTurnActive: (sessionId: string) => boolean
+  hasOwedWork: (sessionId: string) => boolean
   evict: (sessionId: string) => Promise<void>
   onError?: (input: { sessionId: string; error: unknown }) => void
   graceMs?: number
@@ -40,7 +40,7 @@ export class StructuredAgentSessionHolds {
 
   constructor(private readonly deps: StructuredAgentSessionHoldsDeps) {
     const clockDeps: StructuredAgentSessionReleaseClockDeps = {
-      isTurnActive: deps.isTurnActive,
+      hasOwedWork: deps.hasOwedWork,
       isHeld: (sessionId) => this.holders.isHeld(sessionId),
       evict: (sessionId) => this.deps.evict(sessionId),
       ...(deps.onError ? { onError: deps.onError } : {}),
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-host-lifetime.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-host-lifetime.ts
index 4c6b355214a4..8568ba1909a7 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-host-lifetime.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-host-lifetime.ts
@@ -203,10 +203,13 @@ export function createStructuredAgentSessionHolds(
       ),
     evict: input.close,
     hasProviderChild: (sessionId) => hasProviderChild(context, sessionId),
-    isTurnActive: (sessionId) => {
-      const session = context.sessions.get(sessionId)
-      return session
-        ? activeStructuredAgentSessionTurnId(session.journal.snapshot().items) !== null
+    // A pending submission is a message the provider has not taken yet, such as one held for a
+    // start that has not landed; evicting would refuse it. A settled `unknown` owes nothing more.
+    hasOwedWork: (sessionId) => {
+      const journal = context.sessions.get(sessionId)?.journal
+      return journal
+        ? activeStructuredAgentSessionTurnId(journal.snapshot().items) !== null ||
+            journal.pendingSubmissions().length > 0
         : false
     },
     onError: (error) => context.deps.onEventSinkError?.(error),
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-release-clock.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-release-clock.ts
index 452e6a6fae03..0fc65a78a5d4 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-release-clock.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-release-clock.ts
@@ -6,15 +6,15 @@
 // user already asked for must finish: the provider is mid-answer, the journal has an open turn
 // marker, and stopping the child there strands both.
 //
-// So the clock arms when the last holder leaves, and a tick that finds a turn still running RE-ARMS
-// instead of evicting. That is what makes the wait start at the later of the two events rather than
-// at whichever came first.
+// So the clock arms when the last holder leaves, and a tick that finds work still owed — a turn
+// running, or a message sent but not yet taken by the provider — RE-ARMS instead of evicting. That
+// is what makes the wait start at the later of the two events rather than at whichever came first.
 
 export const STRUCTURED_AGENT_SESSION_RELEASE_GRACE_MS = 15_000
 
 export type StructuredAgentSessionReleaseClockDeps = {
-  /** Never evict mid-turn; a true answer re-arms the clock instead. */
-  isTurnActive: (sessionId: string) => boolean
+  /** Never evict while work is owed; a true answer re-arms the clock instead. */
+  hasOwedWork: (sessionId: string) => boolean
   /** Re-checked at fire time: a holder may have arrived while the timer ran. */
   isHeld: (sessionId: string) => boolean
   evict: (sessionId: string) => Promise<void>
@@ -64,7 +64,7 @@ export class StructuredAgentSessionReleaseClock {
     if (this.deps.isHeld(sessionId)) {
       return
     }
-    if (this.deps.isTurnActive(sessionId)) {
+    if (this.deps.hasOwedWork(sessionId)) {
       this.arm(sessionId)
       return
     }
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-starting-release.test.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-starting-release.test.ts
new file mode 100644
index 000000000000..f5c7e3cac776
--- /dev/null
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-starting-release.test.ts
@@ -0,0 +1,168 @@
+// A Claude chat is published before its CLI answers initialize, and a message sent in that window
+// is held until it does. Switching away from the chat starts the release clock; the clock must
+// treat that held message as work still owed, exactly as it treats a running turn, or it evicts
+// the session and refuses a message the user already sent.
+
+import { mkdtemp, rm } from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+import { computeAgentSessionPayloadFingerprint } from '../../../shared/agent-session-mutation-envelope'
+import { ClaudeStructuredSessionAdapter } from '../../claude/claude-structured-session-adapter'
+import {
+  fakeClaude,
+  PROVIDER_SESSION_ID
+} from '../../claude/claude-structured-session-test-support'
+import { AgentSessionRecordStore } from '../../runtime/agent-session-record-store'
+import { structuredClaudeLifecycleEvent } from '../../runtime/structured-claude-runtime-adapter'
+import { StructuredAgentSessionHost } from './structured-agent-session-host'
+import {
+  HOST_TEST_NOW as NOW,
+  HOST_TEST_SESSION as SESSION,
+  hostTestAttachParams,
+  hostTestMessage,
+  hostTestOperationId,
+  resetHostTestOperationIds
+} from './structured-agent-session-host-test-data'
+
+const CALLER = { callerKey: 'client-1' }
+const SURFACE = 'desktop-chat:1'
+const GRACE_MS = 5
+
+let root: string
+let store: AgentSessionRecordStore
+let host: StructuredAgentSessionHost
+let adapter: ClaudeStructuredSessionAdapter
+let claude: ReturnType<typeof fakeClaude>
+let landInit: () => void
+
+beforeEach(async () => {
+  root = await mkdtemp(join(tmpdir(), 'orca-starting-release-'))
+  resetHostTestOperationIds()
+  claude = fakeClaude()
+  const initLanded = new Promise<void>((resolve) => {
+    landInit = resolve
+  })
+  adapter = new ClaudeStructuredSessionAdapter({
+    resolveLaunch: async () => ({
+      pathToClaudeCodeExecutable: 'claude',
+      options: {},
+      cwd: root,
+      claudeConfigDir: join(root, 'claude-home'),
+      providerSessionId: PROVIDER_SESSION_ID,
+      resumeLeafUuid: null,
+      resumesTranscript: false,
+      continuesChain: false
+    }),
+    onEvent: (event) => {
+      const mapped = structuredClaudeLifecycleEvent(event)
+      if (mapped) {
+        void host.handleAdapterEvent(mapped)
+      }
+    },
+    // As the runtime wires it: a held prompt's outcome reaches the journal out of band.
+    onDispatchSettledLate: (settlement) => void host.settleLateDispatch(settlement),
+    // Initialize answers only when the test says so.
+    openConnection: async (launch, handlers) => {
+      const connection = await claude.openConnection(launch, handlers)
+      const answer = connection.initializationResult
+      connection.initializationResult = async () => {
+        await initLanded
+        return answer()
+      }
+      return connection
+    },
+    readProcessStartTime: async () => 1_700_000_000_000,
+    now: () => NOW
+  })
+  store = await AgentSessionRecordStore.open({ directory: join(root, 'store'), hostId: 'local' })
+  host = new StructuredAgentSessionHost({
+    store,
+    adapter: Object.assign(adapter, { supportsCreate: () => true }),
+    journalRoot: root,
+    claimKeyId: 'key-1',
+    mintSpawnToken: () => 'spawn-a',
+    releaseGraceMs: GRACE_MS,
+    now: () => NOW
+  })
+})
+
+afterEach(async () => {
+  landInit()
+  await adapter.closeAll()
+  await host.flushAllStreamedEvents()
+  await rm(root, { recursive: true, force: true })
+})
+
+async function attachStarting(): Promise<void> {
+  const created = await host.attach(
+    CALLER,
+    hostTestAttachParams(null, {
+      provider: 'claude',
+      agent: 'claude',
+      accountHome: { variable: 'CLAUDE_CONFIG_DIR', path: join(root, 'claude-home') },
+      providerHandle: { kind: 'claude', sessionId: PROVIDER_SESSION_ID, leafUuid: null }
+    })
+  )
+  expect(created).toMatchObject({ ok: true })
+  await host.hold(SESSION, SURFACE)
+}
+
+async function send(text: string): Promise<string> {
+  const body = hostTestMessage(text)
+  const sent = await host.send(CALLER, {
+    envelope: {
+      sessionId: SESSION,
+      clientOperationId: hostTestOperationId(),
+      expectedRuntimeFence: store.getRecord(SESSION)?.lease.runtimeFence ?? 1,
+      payloadFingerprint: computeAgentSessionPayloadFingerprint({
+        method: 'agentSession.send',
+        sessionId: SESSION,
+        fields: { body }
+      })
+    },
+    body
+  })
+  expect(sent).toMatchObject({ ok: true, value: { submission: { dispatchState: 'pending' } } })
+  return sent.ok ? sent.value.clientMessageId : ''
+}
+
+function dispatchState(clientMessageId: string): string | undefined {
+  return host
+    .journalSnapshot(SESSION)
+    .submissions.find((entry) => entry.clientMessageId === clientMessageId)?.dispatchState
+}
+
+/** Long enough for several grace windows to elapse, so "not evicted" means the clock declined. */
+function waitOutSeveralGraceWindows(): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, GRACE_MS * 20))
+}
+
+describe('a chat left while its Claude CLI is still starting', () => {
+  it('keeps the session for a message it is holding, and delivers it once startup lands', async () => {
+    await attachStarting()
+    const held = await send('sent while starting')
+
+    host.release(SESSION, SURFACE)
+    await waitOutSeveralGraceWindows()
+
+    expect(host.hasSession(SESSION)).toBe(true)
+    expect(claude.connections[0].closeCount).toBe(0)
+    expect(dispatchState(held)).toBe('pending')
+
+    landInit()
+    await adapter.drainStartup(SESSION)
+
+    expect(claude.connections[0].sent).toEqual([expect.objectContaining({ type: 'user' })])
+    await vi.waitFor(() => expect(dispatchState(held)).toBe('accepted'))
+  })
+
+  it('is released after the grace when it owes nothing', async () => {
+    await attachStarting()
+
+    host.release(SESSION, SURFACE)
+
+    await vi.waitFor(() => expect(host.hasSession(SESSION)).toBe(false))
+    expect(claude.connections[0].closeCount).toBe(1)
+  })
+})

From 40ae2c01937c7b32806172bb29b3a3017df1dd2b Mon Sep 17 00:00:00 2001
From: Brennan Benson <79079362+brennanb2025@users.noreply.github.com>
Date: Wed, 23 Sep 2026 13:29:50 -0700
Subject: [PATCH 41/67] fix(native-chat): only a start that holds a sent
 message keeps a released session

The release clock kept any session with a pending submission. A Codex
send is admitted and stays pending until its echo, which may never come,
and only an eviction retires it, so such a session was never released
while the app ran. A pending send now keeps the session only while its
child is still starting, which is when the send is held for that start.
Pins that a ready session with an unechoed send is evicted, and that a
Claude chat whose turn finished is released after the grace.
---
 .../structured-agent-session-host-lifetime.ts | 13 +++++-----
 ...red-agent-session-starting-release.test.ts | 26 +++++++++++++++++--
 ...red-agent-session-surface-lifetime.test.ts | 11 ++++++++
 3 files changed, 42 insertions(+), 8 deletions(-)

diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-host-lifetime.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-host-lifetime.ts
index 8568ba1909a7..5462a816641e 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-host-lifetime.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-host-lifetime.ts
@@ -203,13 +203,14 @@ export function createStructuredAgentSessionHolds(
       ),
     evict: input.close,
     hasProviderChild: (sessionId) => hasProviderChild(context, sessionId),
-    // A pending submission is a message the provider has not taken yet, such as one held for a
-    // start that has not landed; evicting would refuse it. A settled `unknown` owes nothing more.
+    // A send pending while the child is still starting is held for that start; evicting would
+    // refuse it. Any other pending send may wait on an echo that never comes, so eviction retires it.
     hasOwedWork: (sessionId) => {
-      const journal = context.sessions.get(sessionId)?.journal
-      return journal
-        ? activeStructuredAgentSessionTurnId(journal.snapshot().items) !== null ||
-            journal.pendingSubmissions().length > 0
+      const session = context.sessions.get(sessionId)
+      return session
+        ? activeStructuredAgentSessionTurnId(session.journal.snapshot().items) !== null ||
+            (session.providerChildPhase === 'starting' &&
+              session.journal.pendingSubmissions().length > 0)
         : false
     },
     onError: (error) => context.deps.onEventSinkError?.(error),
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-starting-release.test.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-starting-release.test.ts
index f5c7e3cac776..4c660cc46997 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-starting-release.test.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-starting-release.test.ts
@@ -108,7 +108,7 @@ async function attachStarting(): Promise<void> {
   await host.hold(SESSION, SURFACE)
 }
 
-async function send(text: string): Promise<string> {
+async function send(text: string, dispatchState = 'pending'): Promise<string> {
   const body = hostTestMessage(text)
   const sent = await host.send(CALLER, {
     envelope: {
@@ -123,7 +123,7 @@ async function send(text: string): Promise<string> {
     },
     body
   })
-  expect(sent).toMatchObject({ ok: true, value: { submission: { dispatchState: 'pending' } } })
+  expect(sent).toMatchObject({ ok: true, value: { submission: { dispatchState } } })
   return sent.ok ? sent.value.clientMessageId : ''
 }
 
@@ -157,6 +157,28 @@ describe('a chat left while its Claude CLI is still starting', () => {
     await vi.waitFor(() => expect(dispatchState(held)).toBe('accepted'))
   })
 
+  it('is released after the grace once its turn has finished', async () => {
+    await attachStarting()
+    landInit()
+    await adapter.drainStartup(SESSION)
+    await send('answered', 'accepted')
+    claude.connections[0].handlers.onMessage?.({
+      type: 'result',
+      subtype: 'success',
+      uuid: 'result-1',
+      session_id: PROVIDER_SESSION_ID,
+      is_error: false,
+      result: 'done'
+    })
+    await host.flushStreamedEvents(SESSION)
+    expect(host.journalSnapshot(SESSION).submissions).toHaveLength(1)
+
+    host.release(SESSION, SURFACE)
+
+    await vi.waitFor(() => expect(host.hasSession(SESSION)).toBe(false))
+    expect(claude.connections[0].closeCount).toBe(1)
+  })
+
   it('is released after the grace when it owes nothing', async () => {
     await attachStarting()
 
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-surface-lifetime.test.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-surface-lifetime.test.ts
index e26e65d1db45..2071b74ed459 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-surface-lifetime.test.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-surface-lifetime.test.ts
@@ -431,6 +431,17 @@ describe('a session with a turn in flight', () => {
 
     await waitForEviction()
   })
+
+  // Codex settles an admitted send only on its echo, which may never come; eviction retires it.
+  it('is evicted with an admitted send outstanding once no turn runs', async () => {
+    await attach()
+    await host.hold(SESSION, SURFACE)
+    await sendPending('admitted, never echoed')
+
+    host.release(SESSION, SURFACE)
+
+    await waitForEviction()
+  })
 })
 
 describe('startup', () => {

From 3f564ab4bf1acda0ca1d6a784e4f25e01093b9aa Mon Sep 17 00:00:00 2001
From: Brennan Benson <79079362+brennanb2025@users.noreply.github.com>
Date: Wed, 23 Sep 2026 13:46:23 -0700
Subject: [PATCH 42/67] fix(native-chat): a send waits for the owner it met to
 prove its start before it is admitted
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

A Claude child is published before the CLI has answered initialize, so a send admitted right
behind a restart — or right behind the first start — was dispatched into a child that could die
milliseconds later, and learned of the death only as a delivery nobody could confirm. The terminal
refusal the send was written to give was unreachable on the real adapter for exactly the failure
it was written for.

The send's serialized step now admits nothing against a `starting` child. It registers for the
child's startup verdict and returns having placed nothing; the send waits off the session's queue
(the `started` and `ended` settlements run on it) and admits again once the child is `ready`, or is
refused `agent_session_owner_unrecoverable` with the child's own exit reason when it exits first.
The exit settlement writes the one status row, decided by the host's own phase rather than only
the provider's flag. A close, an eviction or a replacement answers the wait too, and quit releases
whatever is left; there is no timer. One spawn per user action holds across re-entries.
---
 ...ructured-agent-session-close-retry.test.ts |   3 +-
 ...structured-agent-session-event-recovery.ts |   3 +
 ...ctured-agent-session-forget-status.test.ts |   3 +-
 .../structured-agent-session-host-lifetime.ts |   1 +
 ...structured-agent-session-host-mutations.ts |  37 +--
 ...ctured-agent-session-host-runtime-state.ts |   3 +
 .../structured-agent-session-host-teardown.ts |   4 +
 .../structured-agent-session-host.ts          |   8 +-
 ...ructured-agent-session-provider-started.ts |   4 +
 ...ructured-agent-session-send-preparation.ts |  46 +++-
 ...session-send-restarts-failed-start.test.ts | 214 +++++++++++++++---
 ...uctured-agent-session-send-startup-wait.ts |  96 ++++++++
 ...agent-session-startup-failure-exit.test.ts |  23 ++
 ...ctured-agent-session-startup-watch.test.ts |  67 ++++++
 .../structured-agent-session-startup-watch.ts |  91 ++++++++
 ...ent-session-teardown-handoff-drain.test.ts |  13 +-
 ...tructured-agent-session-unexpected-exit.ts |  26 ++-
 ...-structured-send-waits-for-startup.test.ts | 157 +++++++++++++
 ...ed-claude-scripted-runtime-test-support.ts |  29 ++-
 19 files changed, 749 insertions(+), 79 deletions(-)
 create mode 100644 src/main/native-chat/agent-session-wire/structured-agent-session-send-startup-wait.ts
 create mode 100644 src/main/native-chat/agent-session-wire/structured-agent-session-startup-watch.test.ts
 create mode 100644 src/main/native-chat/agent-session-wire/structured-agent-session-startup-watch.ts
 create mode 100644 src/main/runtime/claude-structured-send-waits-for-startup.test.ts

diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-close-retry.test.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-close-retry.test.ts
index b9e8f8e506d7..8e2dff7ceda9 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-close-retry.test.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-close-retry.test.ts
@@ -126,7 +126,8 @@ function attachContext(
       mintEventSink: () => eventSink,
       adoptEventSink: () => undefined,
       probeOwner: async () => ({ outcome: 'pid-absent' }),
-      discardEventSink: () => undefined
+      discardEventSink: () => undefined,
+      startup: { dropped: () => undefined }
     },
     sessions,
     subscribers: {
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-event-recovery.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-event-recovery.ts
index 0c87a9780e73..5a5481c4aff5 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-event-recovery.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-event-recovery.ts
@@ -6,6 +6,7 @@ import type {
 import type { StructuredAgentSessionSinkBarrier } from './structured-agent-session-event-sink'
 import type { StructuredAgentSessionHolds } from './structured-agent-session-holds'
 import { settleStructuredAgentSessionProviderStarted } from './structured-agent-session-provider-started'
+import type { StructuredAgentSessionStartupWatch } from './structured-agent-session-startup-watch'
 import {
   isStructuredAgentSessionRecoveryTicketCurrent,
   settleUnexpectedStructuredAgentSessionExit
@@ -28,6 +29,8 @@ export class StructuredAgentSessionEventRecovery {
       /** The one restart every asker shares; the holds put an unheld child on the idle clock. */
       ensureProviderChild: StructuredAgentSessionHolds['ensureProviderChild']
       onBarrierError: (sessionId: string, error: unknown) => void
+      /** Answered by both settlements, for a send waiting on the child's start. */
+      startup: Pick<StructuredAgentSessionStartupWatch, 'proven' | 'exited'>
     }
   ) {}
 
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-forget-status.test.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-forget-status.test.ts
index 20531bd64653..1d8ac48daa92 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-forget-status.test.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-forget-status.test.ts
@@ -182,7 +182,8 @@ function attachContext(
       mintEventSink: () => eventSink,
       adoptEventSink: () => undefined,
       probeOwner: async () => ({ outcome: 'pid-absent' }),
-      discardEventSink: () => undefined
+      discardEventSink: () => undefined,
+      startup: { dropped: () => undefined }
     },
     sessions,
     subscribers: { reset: () => undefined, snapshot: () => undefined, publish: () => undefined },
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-host-lifetime.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-host-lifetime.ts
index 8ac528f1e356..c13cda7bacdf 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-host-lifetime.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-host-lifetime.ts
@@ -43,6 +43,7 @@ export async function forgetStructuredAgentSession(
   await context.sessions.get(sessionId)?.journal.close()
   context.sessions.delete(sessionId)
   context.forgetStatus(sessionId)
+  context.runtimeState.startup.dropped(sessionId)
 }
 
 function hasProviderChild(
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-host-mutations.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-host-mutations.ts
index 373a38f9853c..5ac8d1e6efdf 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-host-mutations.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-host-mutations.ts
@@ -27,10 +27,9 @@ import {
   admitAndRunAgentSessionMutation,
   type AgentSessionMutationRequest
 } from './structured-agent-session-mutation-admission'
-import {
-  prepareStructuredAgentSessionSend,
-  structuredAgentSessionSendBlock
-} from './structured-agent-session-send-preparation'
+import { structuredAgentSessionSendBlock } from './structured-agent-session-send-preparation'
+import { runStructuredAgentSessionSend } from './structured-agent-session-send-startup-wait'
+import type { StructuredAgentSessionStartupWatch } from './structured-agent-session-startup-watch'
 import {
   cancelPlan,
   promptPlan,
@@ -57,6 +56,8 @@ export type StructuredAgentSessionMutationContext = {
   /** Makes a closed session's journal readable again, inside the caller's serialize, for a send
    *  the ledger answers without an owner. */
   restoreReadable: (sessionId: string) => Promise<boolean>
+  /** Where a send waits, off the session's queue, for an owner that has not proven its start. */
+  startup: Pick<StructuredAgentSessionStartupWatch, 'awaitVerdict'>
   now: () => number
 }
 
@@ -95,18 +96,22 @@ export function sendStructuredAgentSessionTurn(
   }
 ): Promise<AgentSessionMutationResult<AgentSessionSendResult>> {
   const plan = sendPlan(params)
-  return mutate(
-    context,
-    caller,
-    params.envelope,
-    {
-      ...plan,
-      run: (ctx) => {
-        const blocked = structuredAgentSessionSendBlock(context.deps.store.getRecord(ctx.sessionId))
-        return blocked ? Promise.resolve(blocked) : plan.run(ctx)
-      }
-    },
-    (ledger, record) => prepareStructuredAgentSessionSend(context, params.envelope, ledger, record)
+  return runStructuredAgentSessionSend(context, params.envelope, (prepareSession) =>
+    mutate(
+      context,
+      caller,
+      params.envelope,
+      {
+        ...plan,
+        run: (ctx) => {
+          const blocked = structuredAgentSessionSendBlock(
+            context.deps.store.getRecord(ctx.sessionId)
+          )
+          return blocked ? Promise.resolve(blocked) : plan.run(ctx)
+        }
+      },
+      prepareSession
+    )
   )
 }
 
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-host-runtime-state.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-host-runtime-state.ts
index e0ea81c6b056..e20d8d2dfff9 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-host-runtime-state.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-host-runtime-state.ts
@@ -8,9 +8,12 @@ import {
 import type { StructuredAgentSessionHostDeps } from './structured-agent-session-host'
 import { StructuredAgentSessionLeaseRenewer } from './structured-agent-session-lease-renewer'
 import { resolveStructuredSessionRecovery } from './structured-agent-session-recovery-resolution'
+import { StructuredAgentSessionStartupWatch } from './structured-agent-session-startup-watch'
 
 export class StructuredAgentSessionHostRuntimeState {
   private readonly eventSinks = new Map<string, DeferredStructuredAgentSessionEventSink>()
+  /** Where a caller that must not act on an unproven child waits for its start to be settled. */
+  readonly startup = new StructuredAgentSessionStartupWatch()
   private readonly leaseRenewer: StructuredAgentSessionLeaseRenewer
   private readonly onEventSinkFailure?: (sessionId: string, error: unknown) => void
 
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-host-teardown.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-host-teardown.ts
index 604edbe63c4e..41b0dafd9a62 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-host-teardown.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-host-teardown.ts
@@ -60,6 +60,9 @@ export function structuredAgentSessionHostTeardownPhases(collaborators: {
   runtimeState: {
     stopLeaseRenewal: () => void
     flushAllEventSinks: () => Promise<void>
+    /** Sends still waiting on a child's start: those of an evicted session were answered by its
+     *  eviction; a session retained on failure keeps its child, and its senders are told here. */
+    startup: { dispose: () => void }
   }
   handoffs: { stopTuiHistoryCatchup: () => void; drain: () => Promise<void> }
   tasks: { drainAttaches: () => Promise<void> }
@@ -90,6 +93,7 @@ export function structuredAgentSessionHostTeardownPhases(collaborators: {
       name: 'evict-owned-sessions',
       run: () => withPhaseTimeout(collaborators.evictOwnedSessions, CHILD_EVICTION_TIMEOUT_MS)
     },
+    { name: 'release-startup-waits', run: () => collaborators.runtimeState.startup.dispose() },
     {
       name: 'record-resume-markers',
       run: () =>
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-host.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-host.ts
index 9b3544dae074..20b02f2597bf 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-host.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-host.ts
@@ -149,7 +149,8 @@ export class StructuredAgentSessionHost {
       serialize: (sessionId, task) => this.tasks.trackAttach(this.serialize(sessionId, task)),
       now: () => this.now(),
       ensureProviderChild: (id, options) => this.holds.ensureProviderChild(id, options),
-      onBarrierError: (sessionId, error) => deps.onEventSinkError?.({ sessionId, error })
+      onBarrierError: (sessionId, error) => deps.onEventSinkError?.({ sessionId, error }),
+      startup: this.runtimeState.startup
     })
     this.restartResume = createStructuredAgentSessionRestartResume(deps, this.sessions, {
       ...structuredAgentSessionRestartResumeSurfaces(this, this.now),
@@ -269,8 +270,7 @@ export class StructuredAgentSessionHost {
 
   private mutationContext(): StructuredAgentSessionMutationContext {
     return {
-      deps: this.deps,
-      sessions: this.sessions,
+      ...this.lifetimeContext(),
       publish: (sessionId, journal) => this.subscribers.publish(sessionId, journal),
       flushStreamedEvents: this.flushStreamedEvents,
       hasPendingStreamedEvents: (id) => this.runtimeState.hasPendingStreamedEvents(id),
@@ -278,7 +278,7 @@ export class StructuredAgentSessionHost {
       serialize: (sessionId, task) => this.serialize(sessionId, task),
       holds: this.holds,
       restoreReadable: (sessionId) => this.restore.restoreReadableUnderSerialize(sessionId),
-      now: () => this.now()
+      startup: this.runtimeState.startup
     }
   }
 
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-provider-started.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-provider-started.ts
index c53f9a5ae195..39ae0118be65 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-provider-started.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-provider-started.ts
@@ -16,6 +16,7 @@ import type {
   StructuredAgentSessionHostSession
 } from './structured-agent-session-host-types'
 import { nativeSessionOptionsFromReport } from './structured-agent-session-option-restoration'
+import type { StructuredAgentSessionStartupWatch } from './structured-agent-session-startup-watch'
 
 export type StructuredAgentSessionProviderStartedContext = {
   deps: StructuredAgentSessionHostDeps
@@ -23,6 +24,8 @@ export type StructuredAgentSessionProviderStartedContext = {
   serialize: <T>(sessionId: string, task: () => Promise<T>) => Promise<T>
   now: () => number
   publishStatus?: (sessionId: string) => void
+  /** Told the child proved its start, for a send waiting to be admitted against it. */
+  startup?: Pick<StructuredAgentSessionStartupWatch, 'proven'>
   onBarrierError: (sessionId: string, error: unknown) => void
 }
 
@@ -41,6 +44,7 @@ export function settleStructuredAgentSessionProviderStarted(
       return
     }
     session.providerChildPhase = 'ready'
+    context.startup?.proven(event.sessionId, event)
     try {
       await persistStartedOptions(context, event)
     } catch (error) {
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-send-preparation.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-send-preparation.ts
index 394afc5dc200..7c026d1e83a2 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-send-preparation.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-send-preparation.ts
@@ -17,6 +17,12 @@
 // Running inside the send's serialize is what makes "no child" exact and the fence bookkeeping
 // simple: the owner this send (or a hold just ahead of it) replaced is the one the client was
 // current as of, so the send is admitted at the fence the restart published.
+//
+// An owner is not an owner until it has proven its start. A publish-first attach answers before
+// the CLI has, so a send admitted right behind it would be dispatched into a child that may die
+// next and learn of that only as a delivery nobody can confirm. The serialized step therefore
+// admits nothing against a `starting` child: it registers for the verdict and returns, and
+// `structured-agent-session-send-startup-wait` waits off the queue and admits again.
 
 import type { AgentSessionRecord } from '../../../shared/agent-session-record'
 import type {
@@ -30,6 +36,7 @@ import type { StructuredAgentSessionHostSession } from './structured-agent-sessi
 import type { StructuredAgentSessionMutationContext } from './structured-agent-session-host-mutations'
 import type { AgentSessionMutationSessionPreparation } from './structured-agent-session-mutation-admission'
 import { isResumableStructuredAgentSessionRecord } from './structured-agent-session-resume-eligibility'
+import type { StructuredAgentSessionStartupVerdict } from './structured-agent-session-startup-watch'
 import { rewindRefusal } from './structured-rewind-refusal'
 
 /**
@@ -98,17 +105,25 @@ export function structuredAgentSessionSendNeedsOwner(
   )
 }
 
-type SendPreparationContext = Pick<
+export type SendPreparationContext = Pick<
   StructuredAgentSessionMutationContext,
-  'deps' | 'sessions' | 'holds' | 'restoreReadable' | 'publish'
+  'deps' | 'sessions' | 'holds' | 'restoreReadable' | 'publish' | 'startup'
 >
 
+/** The owner this send met has not proven its start. Nothing was placed; the send waits for the
+ *  verdict off the queue and admits again. `restarted` when this send's own step spawned it. */
+export type StructuredAgentSessionSendStartupWait = {
+  startup: Promise<StructuredAgentSessionStartupVerdict>
+  restarted: boolean
+}
+
 export async function prepareStructuredAgentSessionSend(
   context: SendPreparationContext,
   envelope: AgentSessionMutationEnvelope,
   ledger: 'admit' | 'replay',
-  record: AgentSessionRecord
-): Promise<AgentSessionMutationSessionPreparation> {
+  record: AgentSessionRecord,
+  mayRestart = true
+): Promise<AgentSessionMutationSessionPreparation | StructuredAgentSessionSendStartupWait> {
   const { sessionId } = record
   if (ledger !== 'admit') {
     if (!context.sessions.has(sessionId)) {
@@ -116,13 +131,30 @@ export async function prepareStructuredAgentSessionSend(
     }
     return { ok: true, envelope }
   }
-  if (structuredAgentSessionSendNeedsOwner(context.sessions.get(sessionId), record)) {
+  const needsOwner = structuredAgentSessionSendNeedsOwner(context.sessions.get(sessionId), record)
+  if (needsOwner && mayRestart) {
     const refusal = await restartOwnerForSend(context, envelope)
     if (refusal) {
       return { ok: false, refusal }
     }
   }
-  return { ok: true, envelope: admitAtResumedFence(context.sessions.get(sessionId), envelope) }
+  const session = context.sessions.get(sessionId)
+  // A `starting` child with no acquisition generation is one no settlement can ever match.
+  if (
+    session?.hasProviderChild &&
+    session.providerChildPhase === 'starting' &&
+    session.acquisitionGeneration !== null
+  ) {
+    return {
+      startup: context.startup.awaitVerdict(sessionId, {
+        fence: session.fence,
+        acquisitionGeneration: session.acquisitionGeneration
+      }),
+      // No child at the check and one now: this step's ensure spawned it, inside the serialize.
+      restarted: needsOwner
+    }
+  }
+  return { ok: true, envelope: admitAtResumedFence(session, envelope) }
 }
 
 /** One restart attempt. Answers with the refusal that ends the send, or null when the send goes
@@ -154,7 +186,7 @@ async function restartOwnerForSend(
 
 /** The client stops on the code; the message says why, and the verdict — when the failed attach
  *  proved its child gone — tells a client that nothing is running for the session. */
-function ownerUnrecoverableRefusal(cause: AgentSessionWireRefusal): AgentSessionWireRefusal {
+export function ownerUnrecoverableRefusal(cause: AgentSessionWireRefusal): AgentSessionWireRefusal {
   return {
     code: 'agent_session_owner_unrecoverable',
     message: providerRestartFailureOutcome(cause.message),
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-send-restarts-failed-start.test.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-send-restarts-failed-start.test.ts
index 234d85e141df..57c3331f9177 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-send-restarts-failed-start.test.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-send-restarts-failed-start.test.ts
@@ -2,6 +2,10 @@
 // released lease and a chat the user can still type into. The send is the user asking for the
 // child back: the host restarts it before admitting the write and delivers against the new owner,
 // instead of parking the message behind a lease nothing would ever re-acquire.
+//
+// A child is published before it has proven its start, so the send waits for that proof before it
+// is admitted: admitted once the child is `ready`, refused with the child's own reason when it
+// exits first. Nothing here ever dispatches into a child that may be about to die.
 
 import { mkdtemp, rm } from 'node:fs/promises'
 import { tmpdir } from 'node:os'
@@ -29,6 +33,8 @@ let root: string
 let store: AgentSessionRecordStore
 let host: StructuredAgentSessionHost
 let acquire: Mock<StructuredAgentSessionAdapter['acquire']>
+let dispatch: Mock<StructuredAgentSessionAdapter['dispatch']>
+let hostErrors: unknown[]
 let generation = 0
 
 function sendEnvelope(
@@ -47,10 +53,55 @@ function sendEnvelope(
   }
 }
 
+function send(text: string, fence = store.getRecord(SESSION)?.lease.runtimeFence ?? 0) {
+  const body = hostTestMessage(text)
+  return host.send(CALLER, { envelope: sendEnvelope(fence, body), body })
+}
+
+/** The child of the current acquisition, as the adapter would identify it in a lifecycle event. */
+function currentChild() {
+  return {
+    sessionId: SESSION,
+    fence: store.getRecord(SESSION)?.lease.runtimeFence ?? 0,
+    acquisitionGeneration: `generation-${generation}`
+  }
+}
+
+function proveStarted(): Promise<void> {
+  return host.handleAdapterEvent({
+    type: 'started',
+    ...currentChild(),
+    reportedOptions: { model: 'sonnet' },
+    restoreSkippedOptions: []
+  })
+}
+
+function exitBeforeProof(): Promise<void> {
+  return host.handleAdapterEvent({
+    type: 'ended',
+    ...currentChild(),
+    reason: EXIT_REASON,
+    cause: 'unexpected-exit',
+    startupUnproven: true
+  })
+}
+
+/** The send's serialized step has run and left it waiting, off the queue, on the child's start. */
+function sendIsWaitingOnStartup(): Promise<void> {
+  return vi.waitFor(() => expect(host['runtimeState'].startup['waiters'].has(SESSION)).toBe(true))
+}
+
+function journalStatuses(): string[] {
+  return host
+    .journalSnapshot(SESSION)
+    .items.flatMap((item) => (item.body.kind === 'status' ? [item.body.text] : []))
+}
+
 beforeEach(async () => {
   root = await mkdtemp(join(tmpdir(), 'orca-send-after-failed-start-'))
   resetHostTestOperationIds()
   generation = 0
+  hostErrors = []
   acquire = vi.fn(async ({ fence, spawnToken }) => ({
     process: { hostId: 'local', pid: 4242, processStartTimeMs: 1_700_000_000_000, spawnToken },
     link: {
@@ -64,13 +115,15 @@ beforeEach(async () => {
     acquisitionGeneration: `generation-${++generation}`,
     providerChildPhase: 'starting' as const
   }))
+  dispatch = vi.fn(async () => ({ state: 'admitted' as const }))
   store = await AgentSessionRecordStore.open({ directory: join(root, 'store'), hostId: 'local' })
   host = new StructuredAgentSessionHost({
     store,
     adapter: {
       acquire,
       releaseAcquisition: vi.fn(async () => true),
-      dispatch: vi.fn(async () => ({ state: 'admitted' as const })),
+      closeSession: vi.fn(async () => true),
+      dispatch,
       cancelTurn: vi.fn(async () => ({ cancelled: true })),
       answerPrompt: vi.fn(async () => undefined),
       setOption: vi.fn(async () => undefined)
@@ -78,7 +131,11 @@ beforeEach(async () => {
     journalRoot: root,
     claimKeyId: 'key-1',
     mintSpawnToken: () => `spawn-${generation + 1}`,
-    now: () => NOW
+    now: () => NOW,
+    onEventSinkError: ({ error }) => hostErrors.push(error)
+  })
+  await expect(host.attach(CALLER, hostTestAttachParams(null))).resolves.toMatchObject({
+    ok: true
   })
 })
 
@@ -88,56 +145,149 @@ afterEach(async () => {
 })
 
 describe('a send into a published session whose child ended before startup', () => {
-  it('restarts the child and delivers the message against it', async () => {
-    await expect(host.attach(CALLER, hostTestAttachParams(null))).resolves.toMatchObject({
-      ok: true
-    })
-    const startedFence = store.getRecord(SESSION)?.lease.runtimeFence ?? 0
-    await host.handleAdapterEvent({
-      type: 'ended',
-      sessionId: SESSION,
-      reason: EXIT_REASON,
-      cause: 'unexpected-exit',
-      fence: startedFence,
-      acquisitionGeneration: 'generation-1',
-      startupUnproven: true
-    })
+  beforeEach(async () => {
+    await exitBeforeProof()
     // The failed start released the lease and no resume ran on its own.
     expect(store.getRecord(SESSION)?.lease.claimStatus).toBe('released')
     expect(acquire).toHaveBeenCalledOnce()
+  })
+
+  it('restarts the child, waits for it to prove its start, then delivers against it', async () => {
     const releasedFence = store.getRecord(SESSION)?.lease.runtimeFence ?? 0
 
-    const body = hostTestMessage('hello again')
-    const first = await host.send(CALLER, { envelope: sendEnvelope(releasedFence, body), body })
+    const first = send('hello again', releasedFence)
+    await sendIsWaitingOnStartup()
     expect(acquire).toHaveBeenCalledTimes(2)
     expect(store.getRecord(SESSION)?.lease.claimStatus).toBe('live')
+    // Restarted, but not admitted: the child has proven nothing yet.
+    expect(dispatch).not.toHaveBeenCalled()
+
+    await proveStarted()
+
     // The client was current as of the lost owner, so the send is rebased onto the fence the
     // resume published and admitted once, with no stale round trip.
-    expect(first, JSON.stringify(first)).toMatchObject({
+    await expect(first).resolves.toMatchObject({
       ok: true,
       replayed: false,
       value: { submission: { dispatchState: 'pending' } }
     })
+    expect(dispatch).toHaveBeenCalledOnce()
     const current = store.getRecord(SESSION)?.lease.runtimeFence ?? 0
     expect(current).toBeGreaterThan(releasedFence)
 
-    // The next send meets a live owner and restarts nothing.
-    await expect(
-      host.send(CALLER, {
-        envelope: sendEnvelope(current, hostTestMessage('and again')),
-        body: hostTestMessage('and again')
-      })
-    ).resolves.toMatchObject({ ok: true, value: { submission: { dispatchState: 'pending' } } })
+    // The next send meets a live, proven owner and restarts nothing.
+    await expect(send('and again', current)).resolves.toMatchObject({
+      ok: true,
+      value: { submission: { dispatchState: 'pending' } }
+    })
+    expect(acquire).toHaveBeenCalledTimes(2)
+  })
+
+  it('refuses with the cause when the restarted child exits before proving its start', async () => {
+    const releasedFence = store.getRecord(SESSION)?.lease.runtimeFence ?? 0
+    const rowsBefore = journalStatuses().length
+
+    const sent = send('still not signed in', releasedFence)
+    await sendIsWaitingOnStartup()
+    await exitBeforeProof()
+
+    await expect(sent).resolves.toMatchObject({
+      ok: false,
+      refusal: {
+        code: 'agent_session_owner_unrecoverable',
+        message: `This chat's agent could not be restarted: ${EXIT_REASON}. Retry, or start a new chat.`,
+        ownerVerdict: 'exited'
+      }
+    })
+    // Never dispatched, so never left in doubt; one row in the chat names the cause.
+    expect(dispatch).not.toHaveBeenCalled()
+    expect(journalSnapshotSubmissions()).toEqual([])
+    expect(journalStatuses().slice(rowsBefore)).toEqual([
+      expect.stringMatching(/stopped before it finished starting: .*not signed in/)
+    ])
+    expect(hostErrors).toContainEqual(
+      expect.objectContaining({ message: expect.stringContaining(EXIT_REASON) })
+    )
+    // The failed restart moved the fence twice: the acquisition, and the exit that released it.
+    expect(store.getRecord(SESSION)?.lease.runtimeFence).toBe(releasedFence + 2)
+    expect(store.getRecord(SESSION)?.lease.claimStatus).toBe('released')
+    // One spawn per user action: nothing restarted it a second time.
     expect(acquire).toHaveBeenCalledTimes(2)
+
+    // Retry is a fresh action: it restarts once and, once proven, is delivered.
+    const retried = send('signed in now')
+    await vi.waitFor(() => expect(acquire).toHaveBeenCalledTimes(3))
+    await proveStarted()
+    await expect(retried).resolves.toMatchObject({ ok: true })
+    expect(dispatch).toHaveBeenCalledOnce()
+  })
+
+  function journalSnapshotSubmissions() {
+    return host.journalSnapshot(SESSION).submissions
+  }
+})
+
+describe('a send while the child of the first start is still proving itself', () => {
+  it('waits, and is admitted once the child proves its start', async () => {
+    const sent = send('hello')
+
+    await sendIsWaitingOnStartup()
+    expect(dispatch).not.toHaveBeenCalled()
+    expect(acquire).toHaveBeenCalledOnce()
+
+    await proveStarted()
+
+    await expect(sent).resolves.toMatchObject({
+      ok: true,
+      value: { submission: { dispatchState: 'pending' } }
+    })
+    expect(dispatch).toHaveBeenCalledOnce()
+    expect(acquire).toHaveBeenCalledOnce()
   })
 
-  it('leaves a send against a live child alone', async () => {
-    await host.attach(CALLER, hostTestAttachParams(null))
+  it('is refused with the cause when that child exits first, and restarts nothing', async () => {
     const fence = store.getRecord(SESSION)?.lease.runtimeFence ?? 0
-    const body = hostTestMessage('hello')
-    await expect(
-      host.send(CALLER, { envelope: sendEnvelope(fence, body), body })
-    ).resolves.toMatchObject({ ok: true })
+    const sent = send('hello')
+    await sendIsWaitingOnStartup()
+
+    await exitBeforeProof()
+
+    await expect(sent).resolves.toMatchObject({
+      ok: false,
+      refusal: {
+        code: 'agent_session_owner_unrecoverable',
+        message: expect.stringContaining(EXIT_REASON),
+        ownerVerdict: 'exited'
+      }
+    })
+    expect(dispatch).not.toHaveBeenCalled()
+    expect(acquire).toHaveBeenCalledOnce()
+    expect(journalStatuses()).toEqual([
+      expect.stringMatching(/stopped before it finished starting: .*not signed in/)
+    ])
+    expect(store.getRecord(SESSION)?.lease.runtimeFence).toBe(fence + 1)
+  })
+
+  it('answers retryably, and spawns nothing, when the session is closed under it', async () => {
+    const sent = send('hello')
+    await sendIsWaitingOnStartup()
+
+    await host.close(SESSION)
+
+    await expect(sent).resolves.toMatchObject({
+      ok: false,
+      refusal: { code: 'agent_session_ownership_unknown' }
+    })
+    expect(dispatch).not.toHaveBeenCalled()
+    expect(acquire).toHaveBeenCalledOnce()
+  })
+
+  it('leaves a send against a proven child alone', async () => {
+    await proveStarted()
+
+    await expect(send('hello')).resolves.toMatchObject({ ok: true })
+
     expect(acquire).toHaveBeenCalledOnce()
+    expect(dispatch).toHaveBeenCalledOnce()
   })
 })
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-send-startup-wait.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-send-startup-wait.ts
new file mode 100644
index 000000000000..4673023227a2
--- /dev/null
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-send-startup-wait.ts
@@ -0,0 +1,96 @@
+// A send's admission, run again behind the verdict on an owner that had not proven its start.
+//
+// The serialized step in `structured-agent-session-send-preparation` admits nothing against a
+// `starting` child: the `started` and `ended` events that decide it are settled on the same
+// per-session queue, so waiting there would wait on itself. The step registers for the verdict
+// and returns, and this loop — off the queue — waits, then admits again on `ready`, or ends the
+// send with the child's own reason when it exited first. Each admission re-derives everything,
+// so a verdict that arrived late or for a child since replaced costs one more step, never a
+// wrong answer.
+
+import type {
+  AgentSessionMutationEnvelope,
+  AgentSessionMutationResult,
+  AgentSessionWireRefusal
+} from '../../../shared/agent-session-wire'
+import type { AgentSessionMutationRequest } from './structured-agent-session-mutation-admission'
+import {
+  ownerUnrecoverableRefusal,
+  prepareStructuredAgentSessionSend,
+  type SendPreparationContext,
+  type StructuredAgentSessionSendStartupWait
+} from './structured-agent-session-send-preparation'
+
+type SendPreparationStep = NonNullable<AgentSessionMutationRequest<unknown>['prepareSession']>
+
+/** What a step that must wait answers admission with. The loop below never surfaces it — it waits
+ *  instead — but a caller that did not would still hold a true, retryable answer. */
+const OWNER_STARTING: AgentSessionWireRefusal = {
+  code: 'agent_session_ownership_unknown',
+  message: "This chat's agent is still starting."
+}
+
+/**
+ * Runs `admit` — one serialized admission, with this send's preparation as its `prepareSession`
+ * — until the send has its answer. A step that met an owner still proving its start placed
+ * nothing; its verdict settles on the session's own queue, so it is awaited here, off it, and the
+ * send is admitted again once the owner is `ready`. An owner that exits first ends the send the
+ * way a restart that failed outright does, carrying the child's own reason; the exit settlement
+ * wrote that reason into the chat, so no second row is written here.
+ */
+export async function runStructuredAgentSessionSend<TValue>(
+  context: SendPreparationContext,
+  envelope: AgentSessionMutationEnvelope,
+  admit: (prepareSession: SendPreparationStep) => Promise<AgentSessionMutationResult<TValue>>
+): Promise<AgentSessionMutationResult<TValue>> {
+  const { sessionId } = envelope
+  // One spawn per user action, however many verdicts this send waits behind.
+  let mayRestart = true
+  const waits: StructuredAgentSessionSendStartupWait[] = []
+  const prepare: SendPreparationStep = async (ledger, record) => {
+    const prepared = await prepareStructuredAgentSessionSend(
+      context,
+      envelope,
+      ledger,
+      record,
+      mayRestart
+    )
+    if (!('startup' in prepared)) {
+      return prepared
+    }
+    waits.push(prepared)
+    return { ok: false, refusal: OWNER_STARTING }
+  }
+  for (;;) {
+    const result = await admit(prepare)
+    const wait = waits.pop()
+    if (!wait) {
+      return result
+    }
+    mayRestart &&= !wait.restarted
+    const verdict = await wait.startup
+    if (verdict.verdict === 'ready') {
+      continue
+    }
+    if (verdict.verdict === 'gone') {
+      return {
+        ok: false,
+        refusal: {
+          code: 'agent_session_ownership_unknown',
+          message: "This chat's agent was stopped before it finished starting."
+        }
+      }
+    }
+    // The adapter proved the exit, whatever the lease's bookkeeping says of it.
+    const refusal = ownerUnrecoverableRefusal({
+      code: 'agent_session_operation_invalid',
+      message: verdict.reason,
+      ownerVerdict: 'exited'
+    })
+    context.deps.onEventSinkError?.({
+      sessionId,
+      error: new Error(`${refusal.code}: ${verdict.reason}`)
+    })
+    return { ok: false, refusal }
+  }
+}
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-startup-failure-exit.test.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-startup-failure-exit.test.ts
index 1faa497e5fd6..722637d6e80c 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-startup-failure-exit.test.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-startup-failure-exit.test.ts
@@ -101,4 +101,27 @@ describe('a provider that ends before it finished starting', () => {
     expect(ticket).not.toBeNull()
     expect(session.journal.appendLifecycleBatch).not.toHaveBeenCalled()
   })
+
+  it("reads a start that failed off the host's own phase when the provider omits the flag", async () => {
+    const session = { ...startedSession(), providerChildPhase: 'starting' as const }
+    const exited = vi.fn()
+
+    const ticket = await settleUnexpectedStructuredAgentSessionExit(
+      { ...contextFor(session), startup: { exited } },
+      ended
+    )
+
+    expect(ticket).toBeNull()
+    expect(session.journal.appendLifecycleBatch).toHaveBeenCalledWith(
+      expect.objectContaining({
+        mutations: [
+          expect.objectContaining({
+            body: { kind: 'status', text: providerStartupFailureOutcome(REASON) }
+          })
+        ]
+      })
+    )
+    // A send waiting on this child learns it exited, with the child's own reason.
+    expect(exited).toHaveBeenCalledWith(SESSION, expect.objectContaining(ended), REASON)
+  })
 })
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-startup-watch.test.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-startup-watch.test.ts
new file mode 100644
index 000000000000..32b18aa3e1d9
--- /dev/null
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-startup-watch.test.ts
@@ -0,0 +1,67 @@
+import { describe, expect, it } from 'vitest'
+import { StructuredAgentSessionStartupWatch } from './structured-agent-session-startup-watch'
+
+const SESSION = 'session-1'
+const CHILD = { fence: 3, acquisitionGeneration: 'generation-3' }
+
+describe('the startup watch', () => {
+  it('answers ready to a waiter on the child that proved its start', async () => {
+    const watch = new StructuredAgentSessionStartupWatch()
+    const verdict = watch.awaitVerdict(SESSION, CHILD)
+
+    watch.proven(SESSION, CHILD)
+
+    await expect(verdict).resolves.toEqual({ verdict: 'ready' })
+  })
+
+  it('answers exited, with the reason, to a waiter on the child that exited', async () => {
+    const watch = new StructuredAgentSessionStartupWatch()
+    const verdict = watch.awaitVerdict(SESSION, CHILD)
+
+    watch.exited(SESSION, CHILD, 'not signed in')
+
+    await expect(verdict).resolves.toEqual({ verdict: 'exited', reason: 'not signed in' })
+  })
+
+  it('ignores a verdict on another child of the same session', async () => {
+    const watch = new StructuredAgentSessionStartupWatch()
+    const verdict = watch.awaitVerdict(SESSION, CHILD)
+    let settled = false
+    void verdict.then(() => {
+      settled = true
+    })
+
+    watch.proven(SESSION, { fence: 2, acquisitionGeneration: 'generation-2' })
+    watch.exited(SESSION, { fence: 3, acquisitionGeneration: 'generation-2' }, 'other')
+    await Promise.resolve()
+
+    expect(settled).toBe(false)
+    watch.dropped(SESSION)
+    await expect(verdict).resolves.toEqual({ verdict: 'gone' })
+  })
+
+  it('answers gone to every waiter of a dropped session, and to all on dispose', async () => {
+    const watch = new StructuredAgentSessionStartupWatch()
+    const first = watch.awaitVerdict(SESSION, CHILD)
+    const second = watch.awaitVerdict(SESSION, { fence: 4, acquisitionGeneration: 'generation-4' })
+    const other = watch.awaitVerdict('session-2', CHILD)
+
+    watch.dropped(SESSION)
+    await expect(first).resolves.toEqual({ verdict: 'gone' })
+    await expect(second).resolves.toEqual({ verdict: 'gone' })
+
+    watch.dispose()
+    await expect(other).resolves.toEqual({ verdict: 'gone' })
+  })
+
+  it('settles each waiter once', async () => {
+    const watch = new StructuredAgentSessionStartupWatch()
+    const verdict = watch.awaitVerdict(SESSION, CHILD)
+
+    watch.proven(SESSION, CHILD)
+    watch.exited(SESSION, CHILD, 'later')
+    watch.dropped(SESSION)
+
+    await expect(verdict).resolves.toEqual({ verdict: 'ready' })
+  })
+})
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-startup-watch.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-startup-watch.ts
new file mode 100644
index 000000000000..5d9b1c096537
--- /dev/null
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-startup-watch.ts
@@ -0,0 +1,91 @@
+// The verdict on a provider child's start, for a caller that must not act on an unproven one.
+//
+// A publish-first attach hands the host a child that has answered nothing yet. Whether it proves
+// its start or dies first arrives later, as a `started` or `ended` event settled on the session's
+// own queue. A send admitted against that child would be dispatched into a process that may be
+// about to die, and learn of the death only as a delivery nobody can confirm. So the send
+// registers here and waits OFF the queue: the settlement that flips the child to `ready` answers
+// `ready`, the exit settlement answers `exited` with the child's own reason, and a close, an
+// eviction or a replacement answers `gone`. There is no timer — a child either proves its start
+// or exits, and the host observes both.
+
+export type StructuredAgentSessionProviderChildIdentity = {
+  fence: number
+  acquisitionGeneration: string
+}
+
+export type StructuredAgentSessionStartupVerdict =
+  | { verdict: 'ready' }
+  | { verdict: 'exited'; reason: string }
+  /** The child was stopped, evicted or replaced before it proved anything. */
+  | { verdict: 'gone' }
+
+type StartupWaiter = {
+  child: StructuredAgentSessionProviderChildIdentity
+  settle: (verdict: StructuredAgentSessionStartupVerdict) => void
+}
+
+export class StructuredAgentSessionStartupWatch {
+  private readonly waiters = new Map<string, Set<StartupWaiter>>()
+
+  /** For a caller inside the session's serialize: the verdict settles on a later step of that
+   *  queue, so it cannot land before this registers. Settles exactly once. */
+  awaitVerdict(
+    sessionId: string,
+    child: StructuredAgentSessionProviderChildIdentity
+  ): Promise<StructuredAgentSessionStartupVerdict> {
+    return new Promise((settle) => {
+      const waiting = this.waiters.get(sessionId) ?? new Set()
+      waiting.add({ child, settle })
+      this.waiters.set(sessionId, waiting)
+    })
+  }
+
+  proven(sessionId: string, child: StructuredAgentSessionProviderChildIdentity): void {
+    this.settle(sessionId, child, { verdict: 'ready' })
+  }
+
+  exited(
+    sessionId: string,
+    child: StructuredAgentSessionProviderChildIdentity,
+    reason: string
+  ): void {
+    this.settle(sessionId, child, { verdict: 'exited', reason })
+  }
+
+  /** The session's entry is gone or replaced: no child it held will prove anything now. */
+  dropped(sessionId: string): void {
+    this.settle(sessionId, null, { verdict: 'gone' })
+  }
+
+  dispose(): void {
+    for (const sessionId of this.waiters.keys()) {
+      this.dropped(sessionId)
+    }
+  }
+
+  private settle(
+    sessionId: string,
+    child: StructuredAgentSessionProviderChildIdentity | null,
+    verdict: StructuredAgentSessionStartupVerdict
+  ): void {
+    const waiting = this.waiters.get(sessionId)
+    if (!waiting) {
+      return
+    }
+    for (const waiter of waiting) {
+      if (
+        child &&
+        (waiter.child.fence !== child.fence ||
+          waiter.child.acquisitionGeneration !== child.acquisitionGeneration)
+      ) {
+        continue
+      }
+      waiting.delete(waiter)
+      waiter.settle(verdict)
+    }
+    if (waiting.size === 0) {
+      this.waiters.delete(sessionId)
+    }
+  }
+}
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-teardown-handoff-drain.test.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-teardown-handoff-drain.test.ts
index 76adcb82e6fd..617fadfaa16c 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-teardown-handoff-drain.test.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-teardown-handoff-drain.test.ts
@@ -153,7 +153,11 @@ describe('structured agent-session host teardown', () => {
     const noop = async (): Promise<void> => undefined
     const phases = structuredAgentSessionHostTeardownPhases({
       holds: { dispose: noop },
-      runtimeState: { stopLeaseRenewal: () => undefined, flushAllEventSinks: noop },
+      runtimeState: {
+        stopLeaseRenewal: () => undefined,
+        flushAllEventSinks: noop,
+        startup: { dispose: () => undefined }
+      },
       handoffs: { stopTuiHistoryCatchup: () => undefined, drain: noop },
       tasks: { drainAttaches: noop },
       evictOwnedSessions: noop,
@@ -168,6 +172,7 @@ describe('structured agent-session host teardown', () => {
       'drain-handoffs',
       'drain-attaches',
       'evict-owned-sessions',
+      'release-startup-waits',
       'record-resume-markers',
       'flush-event-sinks'
     ])
@@ -181,7 +186,11 @@ describe('structured agent-session host teardown', () => {
     const flush = vi.fn(async () => cleaned())
     const phases = structuredAgentSessionHostTeardownPhases({
       holds: { dispose: cleaned },
-      runtimeState: { stopLeaseRenewal: () => {}, flushAllEventSinks: flush },
+      runtimeState: {
+        stopLeaseRenewal: () => {},
+        flushAllEventSinks: flush,
+        startup: { dispose: () => undefined }
+      },
       handoffs: { stopTuiHistoryCatchup: () => {}, drain: cleaned },
       tasks: { drainAttaches: cleaned },
       evictOwnedSessions: cleaned,
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-unexpected-exit.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-unexpected-exit.ts
index 34f1a97f1618..72f382905d3b 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-unexpected-exit.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-unexpected-exit.ts
@@ -1,4 +1,7 @@
-import type { StructuredAgentSessionEndedEvent } from './structured-agent-session-adapter'
+import type {
+  StructuredAgentSessionEndedEvent,
+  StructuredAgentSessionProviderChildPhase
+} from './structured-agent-session-adapter'
 import type { StructuredAgentSessionHostSession } from './structured-agent-session-host-types'
 import {
   releaseStoredStructuredAgentSessionOwnerAfterUnexpectedExit,
@@ -13,6 +16,7 @@ import {
   unfinishedStructuredAgentSessionWorkWasInterrupted
 } from './structured-agent-session-dead-generation-settlement'
 import type { StructuredAgentSessionTurnVerdict } from './structured-agent-session-stale-turn-verdict'
+import type { StructuredAgentSessionStartupWatch } from './structured-agent-session-startup-watch'
 
 type UnexpectedExitLifecycleEvent = StructuredAgentSessionEndedEvent & {
   cause: 'unexpected-exit'
@@ -30,6 +34,7 @@ export type StructuredAgentSessionUnexpectedExitSession = {
   hasProviderChild: boolean
   fence: number
   acquisitionGeneration: string | null
+  providerChildPhase?: StructuredAgentSessionProviderChildPhase
 }
 
 export type StructuredAgentSessionUnexpectedExitContext<
@@ -44,6 +49,8 @@ export type StructuredAgentSessionUnexpectedExitContext<
   serialize: <T>(sessionId: string, task: () => Promise<T>) => Promise<T>
   now: () => number
   onBarrierError?: (sessionId: string, error: unknown) => void
+  /** Told the child exited, with its reason, for a send waiting to be admitted against it. */
+  startup?: Pick<StructuredAgentSessionStartupWatch, 'exited'>
 }
 
 export async function settleUnexpectedStructuredAgentSessionExit<
@@ -71,9 +78,14 @@ export async function settleUnexpectedStructuredAgentSessionExit<
     if (!record || record.lease.handoffStage !== null) {
       // The handoff coordinator owns an already-started transition.
       session.hasProviderChild = false
+      context.startup?.exited(unexpectedEvent.sessionId, unexpectedEvent, unexpectedEvent.reason)
       context.publishStatus?.(unexpectedEvent.sessionId)
       return null
     }
+    // The host's own phase decides, so a provider that omits the flag still gets a start that
+    // failed told as one: the row says so, and nothing resumes into the same failure.
+    const exitedDuringStartup =
+      unexpectedEvent.startupUnproven === true || session.providerChildPhase === 'starting'
 
     let settlementFailed = false
     const stableSettlementId = providerExitSettlementId(unexpectedEvent)
@@ -96,9 +108,10 @@ export async function settleUnexpectedStructuredAgentSessionExit<
         session,
         stableSettlementId,
         verdict: { state: 'interrupted', completedAt: observedAt },
+        exitedDuringStartup,
         // A failed start always says why: no response was running to carry the reason.
         showUnexpectedExitOutcome:
-          unexpectedEvent.startupUnproven === true ||
+          exitedDuringStartup ||
           unfinishedStructuredAgentSessionWorkWasInterrupted(
             unfinishedWork,
             session.journal,
@@ -131,6 +144,7 @@ export async function settleUnexpectedStructuredAgentSessionExit<
         context.onBarrierError?.(unexpectedEvent.sessionId, error)
       } finally {
         session.hasProviderChild = false
+        context.startup?.exited(unexpectedEvent.sessionId, unexpectedEvent, unexpectedEvent.reason)
         context.publishStatus?.(unexpectedEvent.sessionId)
         if (released) {
           session.fence = released.lease.runtimeFence
@@ -142,10 +156,7 @@ export async function settleUnexpectedStructuredAgentSessionExit<
       return null
     }
     // Resuming a start that failed would respawn into the same failure; the next send retries.
-    if (
-      unexpectedEvent.startupUnproven ||
-      !context.hasResumeCapableHolder(unexpectedEvent.sessionId)
-    ) {
+    if (exitedDuringStartup || !context.hasResumeCapableHolder(unexpectedEvent.sessionId)) {
       return null
     }
     return {
@@ -190,6 +201,7 @@ async function retryUnexpectedExitSettlement(input: {
   session: Pick<StructuredAgentSessionUnexpectedExitSession, 'journal' | 'fence'>
   stableSettlementId: string
   verdict: StructuredAgentSessionTurnVerdict
+  exitedDuringStartup: boolean
   showUnexpectedExitOutcome?: boolean
 }): Promise<boolean> {
   return settleStructuredAgentSessionDeadGeneration({
@@ -201,7 +213,7 @@ async function retryUnexpectedExitSettlement(input: {
     pendingSubmissionReason: 'provider_exited_before_acknowledgement',
     showUnexpectedExitOutcome: input.showUnexpectedExitOutcome,
     unexpectedExitReason: input.event.reason,
-    exitedDuringStartup: input.event.startupUnproven === true,
+    exitedDuringStartup: input.exitedDuringStartup,
     onError: input.context.onBarrierError
   })
 }
diff --git a/src/main/runtime/claude-structured-send-waits-for-startup.test.ts b/src/main/runtime/claude-structured-send-waits-for-startup.test.ts
new file mode 100644
index 000000000000..a6e1a3865b36
--- /dev/null
+++ b/src/main/runtime/claude-structured-send-waits-for-startup.test.ts
@@ -0,0 +1,157 @@
+// A Claude chat is published the moment its child spawns, before the CLI has answered initialize.
+// A send in that window — into a fresh start, or into the restart a send itself asked for after
+// a start that failed — is admitted only once the child has proven its start. When the CLI dies
+// first, the send is refused with the CLI's own diagnostic, the chat shows it once, and nothing
+// is left as a delivery nobody can confirm. Against the production runtime, adapter, record
+// store and host, with only the CLI process scripted.
+
+import { afterEach, describe, expect, it, vi } from 'vitest'
+import { computeAgentSessionPayloadFingerprint } from '../../shared/agent-session-mutation-envelope'
+import { hostTestMessage } from '../native-chat/agent-session-wire/structured-agent-session-host-test-data'
+import type { StructuredAgentSessionHost } from '../native-chat/agent-session-wire/structured-agent-session-host'
+import { waitForStructuredAgentSessionRecovery } from './structured-agent-session-runtime'
+import { createScriptedClaudeRuntime } from './structured-claude-scripted-runtime-test-support'
+
+const SESSION = 'claude-send-waits'
+const CALLER = { callerKey: 'client-1' }
+const DIAGNOSTIC = 'claude stream-json exited (code 1): claude: not signed in (rig)'
+
+let claude = createScriptedClaudeRuntime([SESSION])
+let operations = 0
+
+afterEach(async () => {
+  await claude.dispose()
+  claude = createScriptedClaudeRuntime([SESSION])
+})
+
+function send(host: StructuredAgentSessionHost, text: string) {
+  const body = hostTestMessage(text)
+  return host.send(CALLER, {
+    envelope: {
+      sessionId: SESSION,
+      clientOperationId: `${Date.now()}-${(++operations).toString(16).padStart(32, '0')}`,
+      expectedRuntimeFence: fence(host),
+      payloadFingerprint: computeAgentSessionPayloadFingerprint({
+        method: 'agentSession.send',
+        sessionId: SESSION,
+        fields: { body }
+      })
+    },
+    body
+  })
+}
+
+function fence(host: StructuredAgentSessionHost): number {
+  return host.deps.store.getRecord(SESSION)?.lease.runtimeFence ?? 0
+}
+
+function statusRows(host: StructuredAgentSessionHost): string[] {
+  return host
+    .journalSnapshot(SESSION)
+    .items.flatMap((item) => (item.body.kind === 'status' ? [item.body.text] : []))
+}
+
+/** The send's serialized step has run and left it waiting, off the queue, on the child's start. */
+function sendIsWaitingOnStartup(host: StructuredAgentSessionHost): Promise<void> {
+  return vi.waitFor(() => expect(host['runtimeState'].startup['waiters'].has(SESSION)).toBe(true))
+}
+
+/** The CLI keeps dying at startup: the latest child exits with the diagnostic once it exists. */
+async function failLatestStart(host: StructuredAgentSessionHost, count: number): Promise<void> {
+  await vi.waitFor(() => expect(claude.children(SESSION)).toHaveLength(count))
+  claude.child(SESSION).exit(new Error(DIAGNOSTIC))
+  await waitForStructuredAgentSessionRecovery()
+  await vi.waitFor(() =>
+    expect(host.deps.store.getRecord(SESSION)?.lease.claimStatus).toBe('released')
+  )
+}
+
+describe('a send into a Claude chat whose CLI keeps failing at startup', () => {
+  it('restarts once, is refused with the diagnostic when that start dies too, then delivers once the CLI is healthy', async () => {
+    claude.behave(SESSION, { initHangs: true })
+    const host = await claude.install()
+    await expect(host.attach(CALLER, claude.attachParams(SESSION, null))).resolves.toMatchObject({
+      ok: true
+    })
+    await failLatestStart(host, 1)
+    expect(statusRows(host)).toEqual([expect.stringContaining('not signed in')])
+    const releasedFence = fence(host)
+
+    // The send asks for the child back; the CLI dies again before it answers initialize.
+    const sent = send(host, 'hello?')
+    await sendIsWaitingOnStartup(host)
+    await failLatestStart(host, 2)
+
+    const refused = await sent
+    expect(refused, JSON.stringify(refused)).toMatchObject({
+      ok: false,
+      refusal: {
+        code: 'agent_session_owner_unrecoverable',
+        message: `This chat's agent could not be restarted: ${DIAGNOSTIC}. Retry, or start a new chat.`,
+        ownerVerdict: 'exited'
+      }
+    })
+    // Not admitted, so not a delivery in doubt; one row for this attempt names the cause.
+    expect(host.journalSnapshot(SESSION).submissions).toEqual([])
+    expect(statusRows(host)).toEqual([
+      expect.stringContaining('not signed in'),
+      expect.stringMatching(/stopped before it finished starting: .*not signed in \(rig\)/)
+    ])
+    // The restart moved the fence twice: its acquisition, and the exit that released it.
+    expect(fence(host)).toBe(releasedFence + 2)
+    expect(claude.children(SESSION)).toHaveLength(2)
+
+    // The user signs in and retries: one restart, proven, delivered.
+    claude.behave(SESSION, {})
+    const delivered = await send(host, 'hello again')
+    expect(delivered, JSON.stringify(delivered)).toMatchObject({ ok: true, replayed: false })
+    expect(claude.children(SESSION)).toHaveLength(3)
+    expect(fence(host)).toBe(releasedFence + 3)
+    await vi.waitFor(() =>
+      expect(host.deps.store.getRecord(SESSION)?.lease.claimStatus).toBe('live')
+    )
+  })
+})
+
+describe('a send while the first Claude start is still answering initialize', () => {
+  it('waits, and is admitted once the CLI proves its start', async () => {
+    claude.behave(SESSION, { initHangs: true })
+    const host = await claude.install()
+    await host.attach(CALLER, claude.attachParams(SESSION, null))
+
+    const sent = send(host, 'hello')
+    await sendIsWaitingOnStartup(host)
+
+    // The CLI answers: startup lands and the waiting send is admitted against the proven child.
+    claude.child(SESSION).answerInit()
+
+    await expect(sent).resolves.toMatchObject({ ok: true, replayed: false })
+    expect(claude.children(SESSION)).toHaveLength(1)
+  })
+
+  it('is refused with the diagnostic when the CLI dies first, and restarts nothing', async () => {
+    claude.behave(SESSION, { initHangs: true })
+    const host = await claude.install()
+    await host.attach(CALLER, claude.attachParams(SESSION, null))
+    const startedFence = fence(host)
+
+    const sent = send(host, 'hello')
+    await sendIsWaitingOnStartup(host)
+    await failLatestStart(host, 1)
+
+    await expect(sent).resolves.toMatchObject({
+      ok: false,
+      refusal: {
+        code: 'agent_session_owner_unrecoverable',
+        message: expect.stringContaining('not signed in (rig)'),
+        ownerVerdict: 'exited'
+      }
+    })
+    expect(host.journalSnapshot(SESSION).submissions).toEqual([])
+    expect(statusRows(host)).toEqual([
+      expect.stringMatching(/stopped before it finished starting: .*not signed in \(rig\)/)
+    ])
+    expect(fence(host)).toBe(startedFence + 1)
+    expect(claude.children(SESSION)).toHaveLength(1)
+  })
+})
diff --git a/src/main/runtime/structured-claude-scripted-runtime-test-support.ts b/src/main/runtime/structured-claude-scripted-runtime-test-support.ts
index 3f971ce24b57..7b19d62f2c97 100644
--- a/src/main/runtime/structured-claude-scripted-runtime-test-support.ts
+++ b/src/main/runtime/structured-claude-scripted-runtime-test-support.ts
@@ -36,6 +36,8 @@ export type ScriptedClaudeChild = {
   }
   /** The CLI exits on its own: its root is gone, its tree unverifiable. */
   exit: (error: Error) => void
+  /** The CLI answers initialize now; only meaningful under `initHangs`. */
+  answerInit: () => void
 }
 
 export function createScriptedClaudeRuntime(sessionIds: readonly string[]) {
@@ -58,6 +60,7 @@ export function createScriptedClaudeRuntime(sessionIds: readonly string[]) {
     }
     const behavior = behaviors.get(sessionId) ?? {}
     let failInit = (_error: Error): void => {}
+    let answerInit = (): void => {}
     const answer = <T>(value: T, startup: boolean): Promise<T> =>
       behavior.stallsControlReads && !startup ? stall.then(() => value) : Promise.resolve(value)
     let settingsReads = 0
@@ -71,24 +74,32 @@ export function createScriptedClaudeRuntime(sessionIds: readonly string[]) {
         failInit(error)
         handlers.onExit?.(error)
       },
+      answerInit: () => answerInit(),
       connection: {
         pid: 5000 + children.length,
         closed: false,
         exitVerdict: { root: 'live', tree: 'unverifiable' },
         initializationResult: () => {
+          const initialized = { models: [{ value: 'sonnet', displayName: 'Sonnet' }] }
+          const announce = (): void =>
+            handlers.onMessage?.({
+              type: 'system',
+              subtype: 'init',
+              session_id: providerSessionId,
+              model: 'claude-sonnet-5',
+              apiKeySource: 'none'
+            })
           if (behavior.initHangs) {
-            return new Promise((_resolve, reject) => {
+            return new Promise((resolve, reject) => {
               failInit = reject
+              answerInit = () => {
+                announce()
+                resolve(initialized)
+              }
             })
           }
-          handlers.onMessage?.({
-            type: 'system',
-            subtype: 'init',
-            session_id: providerSessionId,
-            model: 'claude-sonnet-5',
-            apiKeySource: 'none'
-          })
-          return Promise.resolve({ models: [{ value: 'sonnet', displayName: 'Sonnet' }] })
+          announce()
+          return Promise.resolve(initialized)
         },
         getSettings: () => {
           child.calls.push('get_settings')

From 174437efafb659998400cbe9e65bab683dc9b50d Mon Sep 17 00:00:00 2001
From: Brennan Benson <79079362+brennanb2025@users.noreply.github.com>
Date: Wed, 23 Sep 2026 14:02:19 -0700
Subject: [PATCH 43/67] fix(native-chat): restart the release grace when a
 start writes its held prompts

A prompt held while Claude starts is written when the start lands, but
its turn opens only when Claude echoes it. The release clock stopped
counting it once the child read ready, so a tick landing in that gap
stopped the child before it ran the user's first message. The start
landing now restarts a pending release's full grace, the same grace a
message sent to a ready chat gets before it is released.

Co-Authored-By: Claude <noreply@anthropic.com>
---
 ...structured-agent-session-event-recovery.ts |  1 +
 .../structured-agent-session-holds.ts         |  7 ++++
 .../structured-agent-session-host.ts          |  1 +
 ...ructured-agent-session-provider-started.ts |  4 +++
 ...red-agent-session-starting-release.test.ts | 34 ++++++++++++++++++-
 5 files changed, 46 insertions(+), 1 deletion(-)

diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-event-recovery.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-event-recovery.ts
index fda92f144ce2..7bed05517561 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-event-recovery.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-event-recovery.ts
@@ -25,6 +25,7 @@ export class StructuredAgentSessionEventRecovery {
       publishFence: (sessionId: string, session: StructuredAgentSessionHostSession) => void
       publishStatus?: (sessionId: string) => void
       hasResumeCapableHolder: (sessionId: string) => boolean
+      restartReleaseGrace: (sessionId: string) => void
       serialize: <T>(sessionId: string, task: () => Promise<T>) => Promise<T>
       now: () => number
       attachContext: () => StructuredAgentSessionAttachContext
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-holds.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-holds.ts
index 992c736b4ce8..35d4d6ba421a 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-holds.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-holds.ts
@@ -105,6 +105,13 @@ export class StructuredAgentSessionHolds {
     return this.holders.hasResumeCapableHolder(sessionId)
   }
 
+  /** Work the child was holding just reached it; a pending release restarts its full grace. */
+  restartReleaseGrace(sessionId: string): void {
+    if (this.clock.isArmed(sessionId)) {
+      this.clock.arm(sessionId)
+    }
+  }
+
   isReleasePending(sessionId: string): boolean {
     return this.clock.isArmed(sessionId)
   }
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-host.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-host.ts
index cb15f81fffd7..9147c25579bc 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-host.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-host.ts
@@ -145,6 +145,7 @@ export class StructuredAgentSessionHost {
         this.subscribers.snapshot(sessionId, session.journal, session.fence),
       publishStatus: this.clientDelivery.publishStatusAndSettlement,
       hasResumeCapableHolder: (sessionId) => this.holds.hasResumeCapableHolder(sessionId),
+      restartReleaseGrace: (sessionId) => this.holds.restartReleaseGrace(sessionId),
       serialize: (sessionId, task) => this.serialize(sessionId, task),
       now: () => this.now(),
       attachContext: () => this.attachContext(),
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-provider-started.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-provider-started.ts
index 77807c0ca44e..55c718f967b9 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-provider-started.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-provider-started.ts
@@ -23,6 +23,7 @@ export type StructuredAgentSessionProviderStartedContext = {
   serialize: <T>(sessionId: string, task: () => Promise<T>) => Promise<T>
   now: () => number
   publishStatus?: (sessionId: string) => void
+  restartReleaseGrace: (sessionId: string) => void
   onBarrierError: (sessionId: string, error: unknown) => void
 }
 
@@ -41,6 +42,9 @@ export function settleStructuredAgentSessionProviderStarted(
       return
     }
     session.providerChildPhase = 'ready'
+    // Prompts held for the start are written now but open a turn only on their echo; a release
+    // tick in between would stop the child before it runs them.
+    context.restartReleaseGrace(event.sessionId)
     try {
       await persistStartedOptions(context, event)
     } catch (error) {
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-starting-release.test.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-starting-release.test.ts
index 4c660cc46997..df6e6cec4bf1 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-starting-release.test.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-starting-release.test.ts
@@ -35,11 +35,13 @@ let host: StructuredAgentSessionHost
 let adapter: ClaudeStructuredSessionAdapter
 let claude: ReturnType<typeof fakeClaude>
 let landInit: () => void
+let lifecycle: Promise<void>[]
 
 beforeEach(async () => {
   root = await mkdtemp(join(tmpdir(), 'orca-starting-release-'))
   resetHostTestOperationIds()
   claude = fakeClaude()
+  lifecycle = []
   const initLanded = new Promise<void>((resolve) => {
     landInit = resolve
   })
@@ -57,7 +59,7 @@ beforeEach(async () => {
     onEvent: (event) => {
       const mapped = structuredClaudeLifecycleEvent(event)
       if (mapped) {
-        void host.handleAdapterEvent(mapped)
+        lifecycle.push(host.handleAdapterEvent(mapped))
       }
     },
     // As the runtime wires it: a held prompt's outcome reaches the journal out of band.
@@ -88,6 +90,7 @@ beforeEach(async () => {
 })
 
 afterEach(async () => {
+  vi.useRealTimers()
   landInit()
   await adapter.closeAll()
   await host.flushAllStreamedEvents()
@@ -157,6 +160,35 @@ describe('a chat left while its Claude CLI is still starting', () => {
     await vi.waitFor(() => expect(dispatchState(held)).toBe('accepted'))
   })
 
+  it('gives the message it wrote at startup a full grace to open its turn', async () => {
+    vi.useFakeTimers({ toFake: ['setTimeout', 'clearTimeout'] })
+    await attachStarting()
+    const held = await send('sent while starting')
+    const connection = claude.connections[0]
+    // Claude echoes a prompt only when it starts that turn, which a loaded machine delays.
+    connection.send = async (message) => {
+      connection.sent.push(message)
+    }
+    host.release(SESSION, SURFACE)
+    await vi.advanceTimersByTimeAsync(GRACE_MS * 3 - 1)
+    expect(host.hasSession(SESSION)).toBe(true)
+
+    // Startup lands just before the clock's next tick.
+    landInit()
+    await adapter.drainStartup(SESSION)
+    await Promise.all(lifecycle)
+    expect(connection.sent).toEqual([expect.objectContaining({ type: 'user' })])
+    await vi.advanceTimersByTimeAsync(GRACE_MS - 1)
+
+    expect(host.hasSession(SESSION)).toBe(true)
+    expect(connection.closeCount).toBe(0)
+    connection.handlers.onMessage?.(connection.sent[0])
+    await host.flushStreamedEvents(SESSION)
+    await vi.advanceTimersByTimeAsync(GRACE_MS * 3)
+    expect(host.hasSession(SESSION)).toBe(true)
+    expect(dispatchState(held)).toBe('accepted')
+  })
+
   it('is released after the grace once its turn has finished', async () => {
     await attachStarting()
     landInit()

From 87f12fcc7efeed786bd9f29876f98ae24eb189aa Mon Sep 17 00:00:00 2001
From: Brennan Benson <79079362+brennanb2025@users.noreply.github.com>
Date: Wed, 23 Sep 2026 14:19:12 -0700
Subject: [PATCH 44/67] fix(native-chat): a starting child owns the send; the
 adapter holds the message for its start

A send that meets a child still proving its start is admitted against it, as it was before the
off-queue startup wait: the adapter holds the message until startup lands and rejects it with the
child's own diagnostic when the child dies first, the exit settlement writes that cause into the
chat, and the release clock keeps a starting session that holds a sent message. The startup watch,
the off-queue wait loop and their teardown phase are gone; the exit settlement still reads a start
that failed off the host's own phase when the provider omits the flag.

The scripted-CLI test now pins that contract end to end: a restart a send asked for whose CLI dies
at initialize leaves the message rejected with the diagnostic, one row naming it, and the fence
moved by two; a healthy CLI is restarted once and written to; a send during the first start is
held and written once initialize answers, or rejected with the diagnostic when the CLI dies.
---
 ...ructured-agent-session-close-retry.test.ts |   3 +-
 ...structured-agent-session-event-recovery.ts |   3 -
 ...ctured-agent-session-forget-status.test.ts |   3 +-
 .../structured-agent-session-host-lifetime.ts |   1 -
 ...structured-agent-session-host-mutations.ts |  37 ++---
 ...ctured-agent-session-host-runtime-state.ts |   3 -
 .../structured-agent-session-host-teardown.ts |   4 -
 .../structured-agent-session-host.ts          |   8 +-
 ...ructured-agent-session-provider-started.ts |   4 -
 ...ructured-agent-session-send-preparation.ts |  48 ++----
 ...session-send-restarts-failed-start.test.ts | 148 ++++++------------
 ...uctured-agent-session-send-startup-wait.ts |  96 ------------
 ...agent-session-startup-failure-exit.test.ts |   8 +-
 ...ctured-agent-session-startup-watch.test.ts |  67 --------
 .../structured-agent-session-startup-watch.ts |  91 -----------
 ...ent-session-teardown-handoff-drain.test.ts |  13 +-
 ...tructured-agent-session-unexpected-exit.ts |   5 -
 ...-structured-send-held-for-startup.test.ts} |  95 +++++------
 ...ed-claude-scripted-runtime-test-support.ts |   4 +-
 19 files changed, 140 insertions(+), 501 deletions(-)
 delete mode 100644 src/main/native-chat/agent-session-wire/structured-agent-session-send-startup-wait.ts
 delete mode 100644 src/main/native-chat/agent-session-wire/structured-agent-session-startup-watch.test.ts
 delete mode 100644 src/main/native-chat/agent-session-wire/structured-agent-session-startup-watch.ts
 rename src/main/runtime/{claude-structured-send-waits-for-startup.test.ts => claude-structured-send-held-for-startup.test.ts} (60%)

diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-close-retry.test.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-close-retry.test.ts
index 8e2dff7ceda9..b9e8f8e506d7 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-close-retry.test.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-close-retry.test.ts
@@ -126,8 +126,7 @@ function attachContext(
       mintEventSink: () => eventSink,
       adoptEventSink: () => undefined,
       probeOwner: async () => ({ outcome: 'pid-absent' }),
-      discardEventSink: () => undefined,
-      startup: { dropped: () => undefined }
+      discardEventSink: () => undefined
     },
     sessions,
     subscribers: {
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-event-recovery.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-event-recovery.ts
index 5a5481c4aff5..0c87a9780e73 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-event-recovery.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-event-recovery.ts
@@ -6,7 +6,6 @@ import type {
 import type { StructuredAgentSessionSinkBarrier } from './structured-agent-session-event-sink'
 import type { StructuredAgentSessionHolds } from './structured-agent-session-holds'
 import { settleStructuredAgentSessionProviderStarted } from './structured-agent-session-provider-started'
-import type { StructuredAgentSessionStartupWatch } from './structured-agent-session-startup-watch'
 import {
   isStructuredAgentSessionRecoveryTicketCurrent,
   settleUnexpectedStructuredAgentSessionExit
@@ -29,8 +28,6 @@ export class StructuredAgentSessionEventRecovery {
       /** The one restart every asker shares; the holds put an unheld child on the idle clock. */
       ensureProviderChild: StructuredAgentSessionHolds['ensureProviderChild']
       onBarrierError: (sessionId: string, error: unknown) => void
-      /** Answered by both settlements, for a send waiting on the child's start. */
-      startup: Pick<StructuredAgentSessionStartupWatch, 'proven' | 'exited'>
     }
   ) {}
 
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-forget-status.test.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-forget-status.test.ts
index 1d8ac48daa92..20531bd64653 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-forget-status.test.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-forget-status.test.ts
@@ -182,8 +182,7 @@ function attachContext(
       mintEventSink: () => eventSink,
       adoptEventSink: () => undefined,
       probeOwner: async () => ({ outcome: 'pid-absent' }),
-      discardEventSink: () => undefined,
-      startup: { dropped: () => undefined }
+      discardEventSink: () => undefined
     },
     sessions,
     subscribers: { reset: () => undefined, snapshot: () => undefined, publish: () => undefined },
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-host-lifetime.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-host-lifetime.ts
index 1dfef071a311..aee8a8825766 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-host-lifetime.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-host-lifetime.ts
@@ -43,7 +43,6 @@ export async function forgetStructuredAgentSession(
   await context.sessions.get(sessionId)?.journal.close()
   context.sessions.delete(sessionId)
   context.forgetStatus(sessionId)
-  context.runtimeState.startup.dropped(sessionId)
 }
 
 function hasProviderChild(
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-host-mutations.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-host-mutations.ts
index 5ac8d1e6efdf..373a38f9853c 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-host-mutations.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-host-mutations.ts
@@ -27,9 +27,10 @@ import {
   admitAndRunAgentSessionMutation,
   type AgentSessionMutationRequest
 } from './structured-agent-session-mutation-admission'
-import { structuredAgentSessionSendBlock } from './structured-agent-session-send-preparation'
-import { runStructuredAgentSessionSend } from './structured-agent-session-send-startup-wait'
-import type { StructuredAgentSessionStartupWatch } from './structured-agent-session-startup-watch'
+import {
+  prepareStructuredAgentSessionSend,
+  structuredAgentSessionSendBlock
+} from './structured-agent-session-send-preparation'
 import {
   cancelPlan,
   promptPlan,
@@ -56,8 +57,6 @@ export type StructuredAgentSessionMutationContext = {
   /** Makes a closed session's journal readable again, inside the caller's serialize, for a send
    *  the ledger answers without an owner. */
   restoreReadable: (sessionId: string) => Promise<boolean>
-  /** Where a send waits, off the session's queue, for an owner that has not proven its start. */
-  startup: Pick<StructuredAgentSessionStartupWatch, 'awaitVerdict'>
   now: () => number
 }
 
@@ -96,22 +95,18 @@ export function sendStructuredAgentSessionTurn(
   }
 ): Promise<AgentSessionMutationResult<AgentSessionSendResult>> {
   const plan = sendPlan(params)
-  return runStructuredAgentSessionSend(context, params.envelope, (prepareSession) =>
-    mutate(
-      context,
-      caller,
-      params.envelope,
-      {
-        ...plan,
-        run: (ctx) => {
-          const blocked = structuredAgentSessionSendBlock(
-            context.deps.store.getRecord(ctx.sessionId)
-          )
-          return blocked ? Promise.resolve(blocked) : plan.run(ctx)
-        }
-      },
-      prepareSession
-    )
+  return mutate(
+    context,
+    caller,
+    params.envelope,
+    {
+      ...plan,
+      run: (ctx) => {
+        const blocked = structuredAgentSessionSendBlock(context.deps.store.getRecord(ctx.sessionId))
+        return blocked ? Promise.resolve(blocked) : plan.run(ctx)
+      }
+    },
+    (ledger, record) => prepareStructuredAgentSessionSend(context, params.envelope, ledger, record)
   )
 }
 
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-host-runtime-state.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-host-runtime-state.ts
index e20d8d2dfff9..e0ea81c6b056 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-host-runtime-state.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-host-runtime-state.ts
@@ -8,12 +8,9 @@ import {
 import type { StructuredAgentSessionHostDeps } from './structured-agent-session-host'
 import { StructuredAgentSessionLeaseRenewer } from './structured-agent-session-lease-renewer'
 import { resolveStructuredSessionRecovery } from './structured-agent-session-recovery-resolution'
-import { StructuredAgentSessionStartupWatch } from './structured-agent-session-startup-watch'
 
 export class StructuredAgentSessionHostRuntimeState {
   private readonly eventSinks = new Map<string, DeferredStructuredAgentSessionEventSink>()
-  /** Where a caller that must not act on an unproven child waits for its start to be settled. */
-  readonly startup = new StructuredAgentSessionStartupWatch()
   private readonly leaseRenewer: StructuredAgentSessionLeaseRenewer
   private readonly onEventSinkFailure?: (sessionId: string, error: unknown) => void
 
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-host-teardown.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-host-teardown.ts
index 41b0dafd9a62..604edbe63c4e 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-host-teardown.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-host-teardown.ts
@@ -60,9 +60,6 @@ export function structuredAgentSessionHostTeardownPhases(collaborators: {
   runtimeState: {
     stopLeaseRenewal: () => void
     flushAllEventSinks: () => Promise<void>
-    /** Sends still waiting on a child's start: those of an evicted session were answered by its
-     *  eviction; a session retained on failure keeps its child, and its senders are told here. */
-    startup: { dispose: () => void }
   }
   handoffs: { stopTuiHistoryCatchup: () => void; drain: () => Promise<void> }
   tasks: { drainAttaches: () => Promise<void> }
@@ -93,7 +90,6 @@ export function structuredAgentSessionHostTeardownPhases(collaborators: {
       name: 'evict-owned-sessions',
       run: () => withPhaseTimeout(collaborators.evictOwnedSessions, CHILD_EVICTION_TIMEOUT_MS)
     },
-    { name: 'release-startup-waits', run: () => collaborators.runtimeState.startup.dispose() },
     {
       name: 'record-resume-markers',
       run: () =>
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-host.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-host.ts
index 20b02f2597bf..9b3544dae074 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-host.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-host.ts
@@ -149,8 +149,7 @@ export class StructuredAgentSessionHost {
       serialize: (sessionId, task) => this.tasks.trackAttach(this.serialize(sessionId, task)),
       now: () => this.now(),
       ensureProviderChild: (id, options) => this.holds.ensureProviderChild(id, options),
-      onBarrierError: (sessionId, error) => deps.onEventSinkError?.({ sessionId, error }),
-      startup: this.runtimeState.startup
+      onBarrierError: (sessionId, error) => deps.onEventSinkError?.({ sessionId, error })
     })
     this.restartResume = createStructuredAgentSessionRestartResume(deps, this.sessions, {
       ...structuredAgentSessionRestartResumeSurfaces(this, this.now),
@@ -270,7 +269,8 @@ export class StructuredAgentSessionHost {
 
   private mutationContext(): StructuredAgentSessionMutationContext {
     return {
-      ...this.lifetimeContext(),
+      deps: this.deps,
+      sessions: this.sessions,
       publish: (sessionId, journal) => this.subscribers.publish(sessionId, journal),
       flushStreamedEvents: this.flushStreamedEvents,
       hasPendingStreamedEvents: (id) => this.runtimeState.hasPendingStreamedEvents(id),
@@ -278,7 +278,7 @@ export class StructuredAgentSessionHost {
       serialize: (sessionId, task) => this.serialize(sessionId, task),
       holds: this.holds,
       restoreReadable: (sessionId) => this.restore.restoreReadableUnderSerialize(sessionId),
-      startup: this.runtimeState.startup
+      now: () => this.now()
     }
   }
 
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-provider-started.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-provider-started.ts
index 21947a239575..77807c0ca44e 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-provider-started.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-provider-started.ts
@@ -16,7 +16,6 @@ import type {
   StructuredAgentSessionHostSession
 } from './structured-agent-session-host-types'
 import { nativeSessionOptionsFromReport } from './structured-agent-session-option-restoration'
-import type { StructuredAgentSessionStartupWatch } from './structured-agent-session-startup-watch'
 
 export type StructuredAgentSessionProviderStartedContext = {
   deps: StructuredAgentSessionHostDeps
@@ -24,8 +23,6 @@ export type StructuredAgentSessionProviderStartedContext = {
   serialize: <T>(sessionId: string, task: () => Promise<T>) => Promise<T>
   now: () => number
   publishStatus?: (sessionId: string) => void
-  /** Told the child proved its start, for a send waiting to be admitted against it. */
-  startup?: Pick<StructuredAgentSessionStartupWatch, 'proven'>
   onBarrierError: (sessionId: string, error: unknown) => void
 }
 
@@ -44,7 +41,6 @@ export function settleStructuredAgentSessionProviderStarted(
       return
     }
     session.providerChildPhase = 'ready'
-    context.startup?.proven(event.sessionId, event)
     try {
       await persistStartedOptions(context, event)
     } catch (error) {
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-send-preparation.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-send-preparation.ts
index 7c026d1e83a2..6d60ee3452c3 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-send-preparation.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-send-preparation.ts
@@ -18,11 +18,9 @@
 // simple: the owner this send (or a hold just ahead of it) replaced is the one the client was
 // current as of, so the send is admitted at the fence the restart published.
 //
-// An owner is not an owner until it has proven its start. A publish-first attach answers before
-// the CLI has, so a send admitted right behind it would be dispatched into a child that may die
-// next and learn of that only as a delivery nobody can confirm. The serialized step therefore
-// admits nothing against a `starting` child: it registers for the verdict and returns, and
-// `structured-agent-session-send-startup-wait` waits off the queue and admits again.
+// A child that has not proven its start is still the owner: the send is admitted against it and
+// the adapter holds the message until startup lands, or rejects it with the child's own reason
+// when the child dies first. The exit settlement writes that reason into the chat.
 
 import type { AgentSessionRecord } from '../../../shared/agent-session-record'
 import type {
@@ -36,7 +34,6 @@ import type { StructuredAgentSessionHostSession } from './structured-agent-sessi
 import type { StructuredAgentSessionMutationContext } from './structured-agent-session-host-mutations'
 import type { AgentSessionMutationSessionPreparation } from './structured-agent-session-mutation-admission'
 import { isResumableStructuredAgentSessionRecord } from './structured-agent-session-resume-eligibility'
-import type { StructuredAgentSessionStartupVerdict } from './structured-agent-session-startup-watch'
 import { rewindRefusal } from './structured-rewind-refusal'
 
 /**
@@ -105,25 +102,17 @@ export function structuredAgentSessionSendNeedsOwner(
   )
 }
 
-export type SendPreparationContext = Pick<
+type SendPreparationContext = Pick<
   StructuredAgentSessionMutationContext,
-  'deps' | 'sessions' | 'holds' | 'restoreReadable' | 'publish' | 'startup'
+  'deps' | 'sessions' | 'holds' | 'restoreReadable' | 'publish'
 >
 
-/** The owner this send met has not proven its start. Nothing was placed; the send waits for the
- *  verdict off the queue and admits again. `restarted` when this send's own step spawned it. */
-export type StructuredAgentSessionSendStartupWait = {
-  startup: Promise<StructuredAgentSessionStartupVerdict>
-  restarted: boolean
-}
-
 export async function prepareStructuredAgentSessionSend(
   context: SendPreparationContext,
   envelope: AgentSessionMutationEnvelope,
   ledger: 'admit' | 'replay',
-  record: AgentSessionRecord,
-  mayRestart = true
-): Promise<AgentSessionMutationSessionPreparation | StructuredAgentSessionSendStartupWait> {
+  record: AgentSessionRecord
+): Promise<AgentSessionMutationSessionPreparation> {
   const { sessionId } = record
   if (ledger !== 'admit') {
     if (!context.sessions.has(sessionId)) {
@@ -131,30 +120,13 @@ export async function prepareStructuredAgentSessionSend(
     }
     return { ok: true, envelope }
   }
-  const needsOwner = structuredAgentSessionSendNeedsOwner(context.sessions.get(sessionId), record)
-  if (needsOwner && mayRestart) {
+  if (structuredAgentSessionSendNeedsOwner(context.sessions.get(sessionId), record)) {
     const refusal = await restartOwnerForSend(context, envelope)
     if (refusal) {
       return { ok: false, refusal }
     }
   }
-  const session = context.sessions.get(sessionId)
-  // A `starting` child with no acquisition generation is one no settlement can ever match.
-  if (
-    session?.hasProviderChild &&
-    session.providerChildPhase === 'starting' &&
-    session.acquisitionGeneration !== null
-  ) {
-    return {
-      startup: context.startup.awaitVerdict(sessionId, {
-        fence: session.fence,
-        acquisitionGeneration: session.acquisitionGeneration
-      }),
-      // No child at the check and one now: this step's ensure spawned it, inside the serialize.
-      restarted: needsOwner
-    }
-  }
-  return { ok: true, envelope: admitAtResumedFence(session, envelope) }
+  return { ok: true, envelope: admitAtResumedFence(context.sessions.get(sessionId), envelope) }
 }
 
 /** One restart attempt. Answers with the refusal that ends the send, or null when the send goes
@@ -186,7 +158,7 @@ async function restartOwnerForSend(
 
 /** The client stops on the code; the message says why, and the verdict — when the failed attach
  *  proved its child gone — tells a client that nothing is running for the session. */
-export function ownerUnrecoverableRefusal(cause: AgentSessionWireRefusal): AgentSessionWireRefusal {
+function ownerUnrecoverableRefusal(cause: AgentSessionWireRefusal): AgentSessionWireRefusal {
   return {
     code: 'agent_session_owner_unrecoverable',
     message: providerRestartFailureOutcome(cause.message),
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-send-restarts-failed-start.test.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-send-restarts-failed-start.test.ts
index 57c3331f9177..c89c21cec6cb 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-send-restarts-failed-start.test.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-send-restarts-failed-start.test.ts
@@ -3,9 +3,10 @@
 // child back: the host restarts it before admitting the write and delivers against the new owner,
 // instead of parking the message behind a lease nothing would ever re-acquire.
 //
-// A child is published before it has proven its start, so the send waits for that proof before it
-// is admitted: admitted once the child is `ready`, refused with the child's own reason when it
-// exits first. Nothing here ever dispatches into a child that may be about to die.
+// A child is published before it has proven its start, and it owns the send from that moment: the
+// message is admitted against it and the adapter holds it for the start. When the child exits
+// first, the exit settlement retires the message and writes the cause into the chat, once, and
+// the next send is a fresh restart.
 
 import { mkdtemp, rm } from 'node:fs/promises'
 import { tmpdir } from 'node:os'
@@ -34,7 +35,6 @@ let store: AgentSessionRecordStore
 let host: StructuredAgentSessionHost
 let acquire: Mock<StructuredAgentSessionAdapter['acquire']>
 let dispatch: Mock<StructuredAgentSessionAdapter['dispatch']>
-let hostErrors: unknown[]
 let generation = 0
 
 function sendEnvelope(
@@ -53,9 +53,19 @@ function sendEnvelope(
   }
 }
 
-function send(text: string, fence = store.getRecord(SESSION)?.lease.runtimeFence ?? 0) {
+/** A send is admitted against the child it meets, proven or not; the adapter holds the rest. */
+async function send(
+  text: string,
+  fence = store.getRecord(SESSION)?.lease.runtimeFence ?? 0
+): Promise<string> {
   const body = hostTestMessage(text)
-  return host.send(CALLER, { envelope: sendEnvelope(fence, body), body })
+  const sent = await host.send(CALLER, { envelope: sendEnvelope(fence, body), body })
+  expect(sent, JSON.stringify(sent)).toMatchObject({
+    ok: true,
+    replayed: false,
+    value: { submission: { dispatchState: 'pending' } }
+  })
+  return sent.ok ? sent.value.clientMessageId : ''
 }
 
 /** The child of the current acquisition, as the adapter would identify it in a lifecycle event. */
@@ -86,22 +96,22 @@ function exitBeforeProof(): Promise<void> {
   })
 }
 
-/** The send's serialized step has run and left it waiting, off the queue, on the child's start. */
-function sendIsWaitingOnStartup(): Promise<void> {
-  return vi.waitFor(() => expect(host['runtimeState'].startup['waiters'].has(SESSION)).toBe(true))
-}
-
 function journalStatuses(): string[] {
   return host
     .journalSnapshot(SESSION)
     .items.flatMap((item) => (item.body.kind === 'status' ? [item.body.text] : []))
 }
 
+function submission(clientMessageId: string) {
+  return host
+    .journalSnapshot(SESSION)
+    .submissions.find((entry) => entry.clientMessageId === clientMessageId)
+}
+
 beforeEach(async () => {
   root = await mkdtemp(join(tmpdir(), 'orca-send-after-failed-start-'))
   resetHostTestOperationIds()
   generation = 0
-  hostErrors = []
   acquire = vi.fn(async ({ fence, spawnToken }) => ({
     process: { hostId: 'local', pid: 4242, processStartTimeMs: 1_700_000_000_000, spawnToken },
     link: {
@@ -131,8 +141,7 @@ beforeEach(async () => {
     journalRoot: root,
     claimKeyId: 'key-1',
     mintSpawnToken: () => `spawn-${generation + 1}`,
-    now: () => NOW,
-    onEventSinkError: ({ error }) => hostErrors.push(error)
+    now: () => NOW
   })
   await expect(host.attach(CALLER, hostTestAttachParams(null))).resolves.toMatchObject({
     ok: true
@@ -152,115 +161,76 @@ describe('a send into a published session whose child ended before startup', ()
     expect(acquire).toHaveBeenCalledOnce()
   })
 
-  it('restarts the child, waits for it to prove its start, then delivers against it', async () => {
+  it('restarts the child and admits the message against it before it has proven its start', async () => {
     const releasedFence = store.getRecord(SESSION)?.lease.runtimeFence ?? 0
 
-    const first = send('hello again', releasedFence)
-    await sendIsWaitingOnStartup()
-    expect(acquire).toHaveBeenCalledTimes(2)
-    expect(store.getRecord(SESSION)?.lease.claimStatus).toBe('live')
-    // Restarted, but not admitted: the child has proven nothing yet.
-    expect(dispatch).not.toHaveBeenCalled()
-
-    await proveStarted()
+    await send('hello again', releasedFence)
 
     // The client was current as of the lost owner, so the send is rebased onto the fence the
     // resume published and admitted once, with no stale round trip.
-    await expect(first).resolves.toMatchObject({
-      ok: true,
-      replayed: false,
-      value: { submission: { dispatchState: 'pending' } }
-    })
+    expect(acquire).toHaveBeenCalledTimes(2)
+    expect(store.getRecord(SESSION)?.lease.claimStatus).toBe('live')
     expect(dispatch).toHaveBeenCalledOnce()
     const current = store.getRecord(SESSION)?.lease.runtimeFence ?? 0
     expect(current).toBeGreaterThan(releasedFence)
 
-    // The next send meets a live, proven owner and restarts nothing.
-    await expect(send('and again', current)).resolves.toMatchObject({
-      ok: true,
-      value: { submission: { dispatchState: 'pending' } }
-    })
+    // Once proven, the next send meets a live owner and restarts nothing.
+    await proveStarted()
+    await send('and again', current)
     expect(acquire).toHaveBeenCalledTimes(2)
+    expect(dispatch).toHaveBeenCalledTimes(2)
   })
 
-  it('refuses with the cause when the restarted child exits before proving its start', async () => {
+  it('retires the held message with the cause when the restarted child exits before proving its start', async () => {
     const releasedFence = store.getRecord(SESSION)?.lease.runtimeFence ?? 0
     const rowsBefore = journalStatuses().length
 
-    const sent = send('still not signed in', releasedFence)
-    await sendIsWaitingOnStartup()
+    const held = await send('still not signed in', releasedFence)
     await exitBeforeProof()
 
-    await expect(sent).resolves.toMatchObject({
-      ok: false,
-      refusal: {
-        code: 'agent_session_owner_unrecoverable',
-        message: `This chat's agent could not be restarted: ${EXIT_REASON}. Retry, or start a new chat.`,
-        ownerVerdict: 'exited'
-      }
-    })
-    // Never dispatched, so never left in doubt; one row in the chat names the cause.
-    expect(dispatch).not.toHaveBeenCalled()
-    expect(journalSnapshotSubmissions()).toEqual([])
+    // The exit retires the message this host admitted, so nothing pins the session, and one row
+    // in the chat names the cause.
+    expect(submission(held)).toMatchObject({ dispatchState: 'unknown', recovered: true })
+    expect(
+      host.journalSnapshot(SESSION).submissions.filter((e) => e.dispatchState === 'pending')
+    ).toEqual([])
     expect(journalStatuses().slice(rowsBefore)).toEqual([
       expect.stringMatching(/stopped before it finished starting: .*not signed in/)
     ])
-    expect(hostErrors).toContainEqual(
-      expect.objectContaining({ message: expect.stringContaining(EXIT_REASON) })
-    )
     // The failed restart moved the fence twice: the acquisition, and the exit that released it.
     expect(store.getRecord(SESSION)?.lease.runtimeFence).toBe(releasedFence + 2)
     expect(store.getRecord(SESSION)?.lease.claimStatus).toBe('released')
     // One spawn per user action: nothing restarted it a second time.
     expect(acquire).toHaveBeenCalledTimes(2)
 
-    // Retry is a fresh action: it restarts once and, once proven, is delivered.
-    const retried = send('signed in now')
-    await vi.waitFor(() => expect(acquire).toHaveBeenCalledTimes(3))
-    await proveStarted()
-    await expect(retried).resolves.toMatchObject({ ok: true })
-    expect(dispatch).toHaveBeenCalledOnce()
+    // Retry is a fresh action: it restarts once and is admitted against the new child.
+    await send('signed in now')
+    expect(acquire).toHaveBeenCalledTimes(3)
+    expect(dispatch).toHaveBeenCalledTimes(2)
+    expect(journalStatuses().slice(rowsBefore)).toHaveLength(1)
   })
-
-  function journalSnapshotSubmissions() {
-    return host.journalSnapshot(SESSION).submissions
-  }
 })
 
 describe('a send while the child of the first start is still proving itself', () => {
-  it('waits, and is admitted once the child proves its start', async () => {
-    const sent = send('hello')
+  it('is admitted against the starting child, and nothing restarts it', async () => {
+    await send('hello')
 
-    await sendIsWaitingOnStartup()
-    expect(dispatch).not.toHaveBeenCalled()
+    expect(dispatch).toHaveBeenCalledOnce()
     expect(acquire).toHaveBeenCalledOnce()
 
     await proveStarted()
 
-    await expect(sent).resolves.toMatchObject({
-      ok: true,
-      value: { submission: { dispatchState: 'pending' } }
-    })
-    expect(dispatch).toHaveBeenCalledOnce()
     expect(acquire).toHaveBeenCalledOnce()
+    expect(journalStatuses()).toEqual([])
   })
 
-  it('is refused with the cause when that child exits first, and restarts nothing', async () => {
+  it('is retired with the cause when that child exits first, and restarts nothing', async () => {
     const fence = store.getRecord(SESSION)?.lease.runtimeFence ?? 0
-    const sent = send('hello')
-    await sendIsWaitingOnStartup()
+    const held = await send('hello')
 
     await exitBeforeProof()
 
-    await expect(sent).resolves.toMatchObject({
-      ok: false,
-      refusal: {
-        code: 'agent_session_owner_unrecoverable',
-        message: expect.stringContaining(EXIT_REASON),
-        ownerVerdict: 'exited'
-      }
-    })
-    expect(dispatch).not.toHaveBeenCalled()
+    expect(submission(held)).toMatchObject({ dispatchState: 'unknown', recovered: true })
     expect(acquire).toHaveBeenCalledOnce()
     expect(journalStatuses()).toEqual([
       expect.stringMatching(/stopped before it finished starting: .*not signed in/)
@@ -268,24 +238,10 @@ describe('a send while the child of the first start is still proving itself', ()
     expect(store.getRecord(SESSION)?.lease.runtimeFence).toBe(fence + 1)
   })
 
-  it('answers retryably, and spawns nothing, when the session is closed under it', async () => {
-    const sent = send('hello')
-    await sendIsWaitingOnStartup()
-
-    await host.close(SESSION)
-
-    await expect(sent).resolves.toMatchObject({
-      ok: false,
-      refusal: { code: 'agent_session_ownership_unknown' }
-    })
-    expect(dispatch).not.toHaveBeenCalled()
-    expect(acquire).toHaveBeenCalledOnce()
-  })
-
   it('leaves a send against a proven child alone', async () => {
     await proveStarted()
 
-    await expect(send('hello')).resolves.toMatchObject({ ok: true })
+    await send('hello')
 
     expect(acquire).toHaveBeenCalledOnce()
     expect(dispatch).toHaveBeenCalledOnce()
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-send-startup-wait.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-send-startup-wait.ts
deleted file mode 100644
index 4673023227a2..000000000000
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-send-startup-wait.ts
+++ /dev/null
@@ -1,96 +0,0 @@
-// A send's admission, run again behind the verdict on an owner that had not proven its start.
-//
-// The serialized step in `structured-agent-session-send-preparation` admits nothing against a
-// `starting` child: the `started` and `ended` events that decide it are settled on the same
-// per-session queue, so waiting there would wait on itself. The step registers for the verdict
-// and returns, and this loop — off the queue — waits, then admits again on `ready`, or ends the
-// send with the child's own reason when it exited first. Each admission re-derives everything,
-// so a verdict that arrived late or for a child since replaced costs one more step, never a
-// wrong answer.
-
-import type {
-  AgentSessionMutationEnvelope,
-  AgentSessionMutationResult,
-  AgentSessionWireRefusal
-} from '../../../shared/agent-session-wire'
-import type { AgentSessionMutationRequest } from './structured-agent-session-mutation-admission'
-import {
-  ownerUnrecoverableRefusal,
-  prepareStructuredAgentSessionSend,
-  type SendPreparationContext,
-  type StructuredAgentSessionSendStartupWait
-} from './structured-agent-session-send-preparation'
-
-type SendPreparationStep = NonNullable<AgentSessionMutationRequest<unknown>['prepareSession']>
-
-/** What a step that must wait answers admission with. The loop below never surfaces it — it waits
- *  instead — but a caller that did not would still hold a true, retryable answer. */
-const OWNER_STARTING: AgentSessionWireRefusal = {
-  code: 'agent_session_ownership_unknown',
-  message: "This chat's agent is still starting."
-}
-
-/**
- * Runs `admit` — one serialized admission, with this send's preparation as its `prepareSession`
- * — until the send has its answer. A step that met an owner still proving its start placed
- * nothing; its verdict settles on the session's own queue, so it is awaited here, off it, and the
- * send is admitted again once the owner is `ready`. An owner that exits first ends the send the
- * way a restart that failed outright does, carrying the child's own reason; the exit settlement
- * wrote that reason into the chat, so no second row is written here.
- */
-export async function runStructuredAgentSessionSend<TValue>(
-  context: SendPreparationContext,
-  envelope: AgentSessionMutationEnvelope,
-  admit: (prepareSession: SendPreparationStep) => Promise<AgentSessionMutationResult<TValue>>
-): Promise<AgentSessionMutationResult<TValue>> {
-  const { sessionId } = envelope
-  // One spawn per user action, however many verdicts this send waits behind.
-  let mayRestart = true
-  const waits: StructuredAgentSessionSendStartupWait[] = []
-  const prepare: SendPreparationStep = async (ledger, record) => {
-    const prepared = await prepareStructuredAgentSessionSend(
-      context,
-      envelope,
-      ledger,
-      record,
-      mayRestart
-    )
-    if (!('startup' in prepared)) {
-      return prepared
-    }
-    waits.push(prepared)
-    return { ok: false, refusal: OWNER_STARTING }
-  }
-  for (;;) {
-    const result = await admit(prepare)
-    const wait = waits.pop()
-    if (!wait) {
-      return result
-    }
-    mayRestart &&= !wait.restarted
-    const verdict = await wait.startup
-    if (verdict.verdict === 'ready') {
-      continue
-    }
-    if (verdict.verdict === 'gone') {
-      return {
-        ok: false,
-        refusal: {
-          code: 'agent_session_ownership_unknown',
-          message: "This chat's agent was stopped before it finished starting."
-        }
-      }
-    }
-    // The adapter proved the exit, whatever the lease's bookkeeping says of it.
-    const refusal = ownerUnrecoverableRefusal({
-      code: 'agent_session_operation_invalid',
-      message: verdict.reason,
-      ownerVerdict: 'exited'
-    })
-    context.deps.onEventSinkError?.({
-      sessionId,
-      error: new Error(`${refusal.code}: ${verdict.reason}`)
-    })
-    return { ok: false, refusal }
-  }
-}
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-startup-failure-exit.test.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-startup-failure-exit.test.ts
index 722637d6e80c..cc34741f9d43 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-startup-failure-exit.test.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-startup-failure-exit.test.ts
@@ -104,12 +104,8 @@ describe('a provider that ends before it finished starting', () => {
 
   it("reads a start that failed off the host's own phase when the provider omits the flag", async () => {
     const session = { ...startedSession(), providerChildPhase: 'starting' as const }
-    const exited = vi.fn()
 
-    const ticket = await settleUnexpectedStructuredAgentSessionExit(
-      { ...contextFor(session), startup: { exited } },
-      ended
-    )
+    const ticket = await settleUnexpectedStructuredAgentSessionExit(contextFor(session), ended)
 
     expect(ticket).toBeNull()
     expect(session.journal.appendLifecycleBatch).toHaveBeenCalledWith(
@@ -121,7 +117,5 @@ describe('a provider that ends before it finished starting', () => {
         ]
       })
     )
-    // A send waiting on this child learns it exited, with the child's own reason.
-    expect(exited).toHaveBeenCalledWith(SESSION, expect.objectContaining(ended), REASON)
   })
 })
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-startup-watch.test.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-startup-watch.test.ts
deleted file mode 100644
index 32b18aa3e1d9..000000000000
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-startup-watch.test.ts
+++ /dev/null
@@ -1,67 +0,0 @@
-import { describe, expect, it } from 'vitest'
-import { StructuredAgentSessionStartupWatch } from './structured-agent-session-startup-watch'
-
-const SESSION = 'session-1'
-const CHILD = { fence: 3, acquisitionGeneration: 'generation-3' }
-
-describe('the startup watch', () => {
-  it('answers ready to a waiter on the child that proved its start', async () => {
-    const watch = new StructuredAgentSessionStartupWatch()
-    const verdict = watch.awaitVerdict(SESSION, CHILD)
-
-    watch.proven(SESSION, CHILD)
-
-    await expect(verdict).resolves.toEqual({ verdict: 'ready' })
-  })
-
-  it('answers exited, with the reason, to a waiter on the child that exited', async () => {
-    const watch = new StructuredAgentSessionStartupWatch()
-    const verdict = watch.awaitVerdict(SESSION, CHILD)
-
-    watch.exited(SESSION, CHILD, 'not signed in')
-
-    await expect(verdict).resolves.toEqual({ verdict: 'exited', reason: 'not signed in' })
-  })
-
-  it('ignores a verdict on another child of the same session', async () => {
-    const watch = new StructuredAgentSessionStartupWatch()
-    const verdict = watch.awaitVerdict(SESSION, CHILD)
-    let settled = false
-    void verdict.then(() => {
-      settled = true
-    })
-
-    watch.proven(SESSION, { fence: 2, acquisitionGeneration: 'generation-2' })
-    watch.exited(SESSION, { fence: 3, acquisitionGeneration: 'generation-2' }, 'other')
-    await Promise.resolve()
-
-    expect(settled).toBe(false)
-    watch.dropped(SESSION)
-    await expect(verdict).resolves.toEqual({ verdict: 'gone' })
-  })
-
-  it('answers gone to every waiter of a dropped session, and to all on dispose', async () => {
-    const watch = new StructuredAgentSessionStartupWatch()
-    const first = watch.awaitVerdict(SESSION, CHILD)
-    const second = watch.awaitVerdict(SESSION, { fence: 4, acquisitionGeneration: 'generation-4' })
-    const other = watch.awaitVerdict('session-2', CHILD)
-
-    watch.dropped(SESSION)
-    await expect(first).resolves.toEqual({ verdict: 'gone' })
-    await expect(second).resolves.toEqual({ verdict: 'gone' })
-
-    watch.dispose()
-    await expect(other).resolves.toEqual({ verdict: 'gone' })
-  })
-
-  it('settles each waiter once', async () => {
-    const watch = new StructuredAgentSessionStartupWatch()
-    const verdict = watch.awaitVerdict(SESSION, CHILD)
-
-    watch.proven(SESSION, CHILD)
-    watch.exited(SESSION, CHILD, 'later')
-    watch.dropped(SESSION)
-
-    await expect(verdict).resolves.toEqual({ verdict: 'ready' })
-  })
-})
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-startup-watch.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-startup-watch.ts
deleted file mode 100644
index 5d9b1c096537..000000000000
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-startup-watch.ts
+++ /dev/null
@@ -1,91 +0,0 @@
-// The verdict on a provider child's start, for a caller that must not act on an unproven one.
-//
-// A publish-first attach hands the host a child that has answered nothing yet. Whether it proves
-// its start or dies first arrives later, as a `started` or `ended` event settled on the session's
-// own queue. A send admitted against that child would be dispatched into a process that may be
-// about to die, and learn of the death only as a delivery nobody can confirm. So the send
-// registers here and waits OFF the queue: the settlement that flips the child to `ready` answers
-// `ready`, the exit settlement answers `exited` with the child's own reason, and a close, an
-// eviction or a replacement answers `gone`. There is no timer — a child either proves its start
-// or exits, and the host observes both.
-
-export type StructuredAgentSessionProviderChildIdentity = {
-  fence: number
-  acquisitionGeneration: string
-}
-
-export type StructuredAgentSessionStartupVerdict =
-  | { verdict: 'ready' }
-  | { verdict: 'exited'; reason: string }
-  /** The child was stopped, evicted or replaced before it proved anything. */
-  | { verdict: 'gone' }
-
-type StartupWaiter = {
-  child: StructuredAgentSessionProviderChildIdentity
-  settle: (verdict: StructuredAgentSessionStartupVerdict) => void
-}
-
-export class StructuredAgentSessionStartupWatch {
-  private readonly waiters = new Map<string, Set<StartupWaiter>>()
-
-  /** For a caller inside the session's serialize: the verdict settles on a later step of that
-   *  queue, so it cannot land before this registers. Settles exactly once. */
-  awaitVerdict(
-    sessionId: string,
-    child: StructuredAgentSessionProviderChildIdentity
-  ): Promise<StructuredAgentSessionStartupVerdict> {
-    return new Promise((settle) => {
-      const waiting = this.waiters.get(sessionId) ?? new Set()
-      waiting.add({ child, settle })
-      this.waiters.set(sessionId, waiting)
-    })
-  }
-
-  proven(sessionId: string, child: StructuredAgentSessionProviderChildIdentity): void {
-    this.settle(sessionId, child, { verdict: 'ready' })
-  }
-
-  exited(
-    sessionId: string,
-    child: StructuredAgentSessionProviderChildIdentity,
-    reason: string
-  ): void {
-    this.settle(sessionId, child, { verdict: 'exited', reason })
-  }
-
-  /** The session's entry is gone or replaced: no child it held will prove anything now. */
-  dropped(sessionId: string): void {
-    this.settle(sessionId, null, { verdict: 'gone' })
-  }
-
-  dispose(): void {
-    for (const sessionId of this.waiters.keys()) {
-      this.dropped(sessionId)
-    }
-  }
-
-  private settle(
-    sessionId: string,
-    child: StructuredAgentSessionProviderChildIdentity | null,
-    verdict: StructuredAgentSessionStartupVerdict
-  ): void {
-    const waiting = this.waiters.get(sessionId)
-    if (!waiting) {
-      return
-    }
-    for (const waiter of waiting) {
-      if (
-        child &&
-        (waiter.child.fence !== child.fence ||
-          waiter.child.acquisitionGeneration !== child.acquisitionGeneration)
-      ) {
-        continue
-      }
-      waiting.delete(waiter)
-      waiter.settle(verdict)
-    }
-    if (waiting.size === 0) {
-      this.waiters.delete(sessionId)
-    }
-  }
-}
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-teardown-handoff-drain.test.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-teardown-handoff-drain.test.ts
index 617fadfaa16c..76adcb82e6fd 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-teardown-handoff-drain.test.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-teardown-handoff-drain.test.ts
@@ -153,11 +153,7 @@ describe('structured agent-session host teardown', () => {
     const noop = async (): Promise<void> => undefined
     const phases = structuredAgentSessionHostTeardownPhases({
       holds: { dispose: noop },
-      runtimeState: {
-        stopLeaseRenewal: () => undefined,
-        flushAllEventSinks: noop,
-        startup: { dispose: () => undefined }
-      },
+      runtimeState: { stopLeaseRenewal: () => undefined, flushAllEventSinks: noop },
       handoffs: { stopTuiHistoryCatchup: () => undefined, drain: noop },
       tasks: { drainAttaches: noop },
       evictOwnedSessions: noop,
@@ -172,7 +168,6 @@ describe('structured agent-session host teardown', () => {
       'drain-handoffs',
       'drain-attaches',
       'evict-owned-sessions',
-      'release-startup-waits',
       'record-resume-markers',
       'flush-event-sinks'
     ])
@@ -186,11 +181,7 @@ describe('structured agent-session host teardown', () => {
     const flush = vi.fn(async () => cleaned())
     const phases = structuredAgentSessionHostTeardownPhases({
       holds: { dispose: cleaned },
-      runtimeState: {
-        stopLeaseRenewal: () => {},
-        flushAllEventSinks: flush,
-        startup: { dispose: () => undefined }
-      },
+      runtimeState: { stopLeaseRenewal: () => {}, flushAllEventSinks: flush },
       handoffs: { stopTuiHistoryCatchup: () => {}, drain: cleaned },
       tasks: { drainAttaches: cleaned },
       evictOwnedSessions: cleaned,
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-unexpected-exit.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-unexpected-exit.ts
index 72f382905d3b..06740bfab25c 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-unexpected-exit.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-unexpected-exit.ts
@@ -16,7 +16,6 @@ import {
   unfinishedStructuredAgentSessionWorkWasInterrupted
 } from './structured-agent-session-dead-generation-settlement'
 import type { StructuredAgentSessionTurnVerdict } from './structured-agent-session-stale-turn-verdict'
-import type { StructuredAgentSessionStartupWatch } from './structured-agent-session-startup-watch'
 
 type UnexpectedExitLifecycleEvent = StructuredAgentSessionEndedEvent & {
   cause: 'unexpected-exit'
@@ -49,8 +48,6 @@ export type StructuredAgentSessionUnexpectedExitContext<
   serialize: <T>(sessionId: string, task: () => Promise<T>) => Promise<T>
   now: () => number
   onBarrierError?: (sessionId: string, error: unknown) => void
-  /** Told the child exited, with its reason, for a send waiting to be admitted against it. */
-  startup?: Pick<StructuredAgentSessionStartupWatch, 'exited'>
 }
 
 export async function settleUnexpectedStructuredAgentSessionExit<
@@ -78,7 +75,6 @@ export async function settleUnexpectedStructuredAgentSessionExit<
     if (!record || record.lease.handoffStage !== null) {
       // The handoff coordinator owns an already-started transition.
       session.hasProviderChild = false
-      context.startup?.exited(unexpectedEvent.sessionId, unexpectedEvent, unexpectedEvent.reason)
       context.publishStatus?.(unexpectedEvent.sessionId)
       return null
     }
@@ -144,7 +140,6 @@ export async function settleUnexpectedStructuredAgentSessionExit<
         context.onBarrierError?.(unexpectedEvent.sessionId, error)
       } finally {
         session.hasProviderChild = false
-        context.startup?.exited(unexpectedEvent.sessionId, unexpectedEvent, unexpectedEvent.reason)
         context.publishStatus?.(unexpectedEvent.sessionId)
         if (released) {
           session.fence = released.lease.runtimeFence
diff --git a/src/main/runtime/claude-structured-send-waits-for-startup.test.ts b/src/main/runtime/claude-structured-send-held-for-startup.test.ts
similarity index 60%
rename from src/main/runtime/claude-structured-send-waits-for-startup.test.ts
rename to src/main/runtime/claude-structured-send-held-for-startup.test.ts
index a6e1a3865b36..208329187056 100644
--- a/src/main/runtime/claude-structured-send-waits-for-startup.test.ts
+++ b/src/main/runtime/claude-structured-send-held-for-startup.test.ts
@@ -1,9 +1,9 @@
 // A Claude chat is published the moment its child spawns, before the CLI has answered initialize.
 // A send in that window — into a fresh start, or into the restart a send itself asked for after
-// a start that failed — is admitted only once the child has proven its start. When the CLI dies
-// first, the send is refused with the CLI's own diagnostic, the chat shows it once, and nothing
-// is left as a delivery nobody can confirm. Against the production runtime, adapter, record
-// store and host, with only the CLI process scripted.
+// a start that failed — is admitted and held until the child proves its start. When the CLI dies
+// first, the held message is rejected with the CLI's own diagnostic, the chat shows the cause
+// once, and nothing is left as a delivery nobody can confirm. Against the production runtime,
+// adapter, record store and host, with only the CLI process scripted.
 
 import { afterEach, describe, expect, it, vi } from 'vitest'
 import { computeAgentSessionPayloadFingerprint } from '../../shared/agent-session-mutation-envelope'
@@ -12,7 +12,7 @@ import type { StructuredAgentSessionHost } from '../native-chat/agent-session-wi
 import { waitForStructuredAgentSessionRecovery } from './structured-agent-session-runtime'
 import { createScriptedClaudeRuntime } from './structured-claude-scripted-runtime-test-support'
 
-const SESSION = 'claude-send-waits'
+const SESSION = 'claude-send-held'
 const CALLER = { callerKey: 'client-1' }
 const DIAGNOSTIC = 'claude stream-json exited (code 1): claude: not signed in (rig)'
 
@@ -24,9 +24,9 @@ afterEach(async () => {
   claude = createScriptedClaudeRuntime([SESSION])
 })
 
-function send(host: StructuredAgentSessionHost, text: string) {
+async function send(host: StructuredAgentSessionHost, text: string): Promise<string> {
   const body = hostTestMessage(text)
-  return host.send(CALLER, {
+  const sent = await host.send(CALLER, {
     envelope: {
       sessionId: SESSION,
       clientOperationId: `${Date.now()}-${(++operations).toString(16).padStart(32, '0')}`,
@@ -39,6 +39,13 @@ function send(host: StructuredAgentSessionHost, text: string) {
     },
     body
   })
+  // Admitted and held for the start, never refused: the message shows as sent.
+  expect(sent, JSON.stringify(sent)).toMatchObject({
+    ok: true,
+    replayed: false,
+    value: { submission: { dispatchState: 'pending' } }
+  })
+  return sent.ok ? sent.value.clientMessageId : ''
 }
 
 function fence(host: StructuredAgentSessionHost): number {
@@ -51,9 +58,10 @@ function statusRows(host: StructuredAgentSessionHost): string[] {
     .items.flatMap((item) => (item.body.kind === 'status' ? [item.body.text] : []))
 }
 
-/** The send's serialized step has run and left it waiting, off the queue, on the child's start. */
-function sendIsWaitingOnStartup(host: StructuredAgentSessionHost): Promise<void> {
-  return vi.waitFor(() => expect(host['runtimeState'].startup['waiters'].has(SESSION)).toBe(true))
+function submission(host: StructuredAgentSessionHost, clientMessageId: string) {
+  return host
+    .journalSnapshot(SESSION)
+    .submissions.find((entry) => entry.clientMessageId === clientMessageId)
 }
 
 /** The CLI keeps dying at startup: the latest child exits with the diagnostic once it exists. */
@@ -67,7 +75,7 @@ async function failLatestStart(host: StructuredAgentSessionHost, count: number):
 }
 
 describe('a send into a Claude chat whose CLI keeps failing at startup', () => {
-  it('restarts once, is refused with the diagnostic when that start dies too, then delivers once the CLI is healthy', async () => {
+  it('restarts once, rejects the held message with the diagnostic when that start dies too, then delivers once the CLI is healthy', async () => {
     claude.behave(SESSION, { initHangs: true })
     const host = await claude.install()
     await expect(host.attach(CALLER, claude.attachParams(SESSION, null))).resolves.toMatchObject({
@@ -77,22 +85,19 @@ describe('a send into a Claude chat whose CLI keeps failing at startup', () => {
     expect(statusRows(host)).toEqual([expect.stringContaining('not signed in')])
     const releasedFence = fence(host)
 
-    // The send asks for the child back; the CLI dies again before it answers initialize.
-    const sent = send(host, 'hello?')
-    await sendIsWaitingOnStartup(host)
+    // The send asks for the child back and is held for its start; the CLI dies again first.
+    const held = await send(host, 'hello?')
+    expect(claude.children(SESSION)).toHaveLength(2)
+    expect(host.deps.store.getRecord(SESSION)?.lease.claimStatus).toBe('live')
     await failLatestStart(host, 2)
 
-    const refused = await sent
-    expect(refused, JSON.stringify(refused)).toMatchObject({
-      ok: false,
-      refusal: {
-        code: 'agent_session_owner_unrecoverable',
-        message: `This chat's agent could not be restarted: ${DIAGNOSTIC}. Retry, or start a new chat.`,
-        ownerVerdict: 'exited'
-      }
-    })
-    // Not admitted, so not a delivery in doubt; one row for this attempt names the cause.
-    expect(host.journalSnapshot(SESSION).submissions).toEqual([])
+    // Rejected with the cause, not left in doubt; one row for this attempt names it.
+    await vi.waitFor(() =>
+      expect(submission(host, held)).toMatchObject({
+        dispatchState: 'rejected',
+        reason: expect.stringContaining('not signed in (rig)')
+      })
+    )
     expect(statusRows(host)).toEqual([
       expect.stringContaining('not signed in'),
       expect.stringMatching(/stopped before it finished starting: .*not signed in \(rig\)/)
@@ -100,58 +105,58 @@ describe('a send into a Claude chat whose CLI keeps failing at startup', () => {
     // The restart moved the fence twice: its acquisition, and the exit that released it.
     expect(fence(host)).toBe(releasedFence + 2)
     expect(claude.children(SESSION)).toHaveLength(2)
+    expect(claude.child(SESSION).calls).not.toContain('send')
 
-    // The user signs in and retries: one restart, proven, delivered.
+    // The user signs in and retries: one restart, proven, written to the CLI.
     claude.behave(SESSION, {})
-    const delivered = await send(host, 'hello again')
-    expect(delivered, JSON.stringify(delivered)).toMatchObject({ ok: true, replayed: false })
+    await send(host, 'hello again')
     expect(claude.children(SESSION)).toHaveLength(3)
     expect(fence(host)).toBe(releasedFence + 3)
+    await vi.waitFor(() => expect(claude.child(SESSION).calls).toContain('send'))
     await vi.waitFor(() =>
       expect(host.deps.store.getRecord(SESSION)?.lease.claimStatus).toBe('live')
     )
+    expect(statusRows(host)).toHaveLength(2)
   })
 })
 
 describe('a send while the first Claude start is still answering initialize', () => {
-  it('waits, and is admitted once the CLI proves its start', async () => {
+  it('is held, and written once the CLI proves its start', async () => {
     claude.behave(SESSION, { initHangs: true })
     const host = await claude.install()
     await host.attach(CALLER, claude.attachParams(SESSION, null))
 
-    const sent = send(host, 'hello')
-    await sendIsWaitingOnStartup(host)
+    await send(host, 'hello')
+    expect(claude.child(SESSION).calls).not.toContain('send')
 
-    // The CLI answers: startup lands and the waiting send is admitted against the proven child.
+    // The CLI answers: startup lands and the held message is written to the proven child.
     claude.child(SESSION).answerInit()
 
-    await expect(sent).resolves.toMatchObject({ ok: true, replayed: false })
+    await vi.waitFor(() => expect(claude.child(SESSION).calls).toContain('send'))
     expect(claude.children(SESSION)).toHaveLength(1)
+    expect(statusRows(host)).toEqual([])
   })
 
-  it('is refused with the diagnostic when the CLI dies first, and restarts nothing', async () => {
+  it('is rejected with the diagnostic when the CLI dies first, and restarts nothing', async () => {
     claude.behave(SESSION, { initHangs: true })
     const host = await claude.install()
     await host.attach(CALLER, claude.attachParams(SESSION, null))
     const startedFence = fence(host)
 
-    const sent = send(host, 'hello')
-    await sendIsWaitingOnStartup(host)
+    const held = await send(host, 'hello')
     await failLatestStart(host, 1)
 
-    await expect(sent).resolves.toMatchObject({
-      ok: false,
-      refusal: {
-        code: 'agent_session_owner_unrecoverable',
-        message: expect.stringContaining('not signed in (rig)'),
-        ownerVerdict: 'exited'
-      }
-    })
-    expect(host.journalSnapshot(SESSION).submissions).toEqual([])
+    await vi.waitFor(() =>
+      expect(submission(host, held)).toMatchObject({
+        dispatchState: 'rejected',
+        reason: expect.stringContaining('not signed in (rig)')
+      })
+    )
     expect(statusRows(host)).toEqual([
       expect.stringMatching(/stopped before it finished starting: .*not signed in \(rig\)/)
     ])
     expect(fence(host)).toBe(startedFence + 1)
     expect(claude.children(SESSION)).toHaveLength(1)
+    expect(claude.child(SESSION).calls).not.toContain('send')
   })
 })
diff --git a/src/main/runtime/structured-claude-scripted-runtime-test-support.ts b/src/main/runtime/structured-claude-scripted-runtime-test-support.ts
index 77a5a359bb64..bf57b42b2da8 100644
--- a/src/main/runtime/structured-claude-scripted-runtime-test-support.ts
+++ b/src/main/runtime/structured-claude-scripted-runtime-test-support.ts
@@ -125,7 +125,9 @@ export function createScriptedClaudeRuntime(sessionIds: readonly string[]) {
         interrupt: async () => undefined,
         cancelAsyncMessage: async () => {},
         stopTask: async () => {},
-        send: async () => {},
+        send: async () => {
+          child.calls.push('send')
+        },
         close: async () => {
           child.connection.closed = true
           return !behavior.closeUnproven

From 87d21f4a5df17a6b4d4241e0449287552f042814 Mon Sep 17 00:00:00 2001
From: Brennan Benson <79079362+brennanb2025@users.noreply.github.com>
Date: Wed, 23 Sep 2026 16:06:54 -0700
Subject: [PATCH 45/67] fix(native-chat): a failed send restart says why, and
 offers a new chat only when nothing can restart it

The refusal a send gets when the host cannot restart the chat's agent is renamed
agent_session_owner_restart_failed and now reads "<Agent> couldn't restart: <reason>." with the
restart's own cause. "Start a new chat to continue." is added only when the resume was refused
because this host has no record to restart from or cannot run the one it has. Any other failure,
such as a CLI that is not signed in, leaves the chat retryable: the outbox stops auto-retrying, and
a manual Retry or a new send tries the restart again, since a refusal before admission leaves no
ledger row.
---
 ...gent-session-dead-generation-settlement.ts | 18 ++--
 ...ctured-agent-session-refusal-retry.test.ts |  4 +-
 ...red-agent-session-send-preparation.test.ts | 85 +++++++++++++++----
 ...ructured-agent-session-send-preparation.ts | 69 +++++++++------
 ...e-structured-agent-session-outbox.test.tsx | 14 ++-
 src/shared/agent-session-refusal-retry.ts     |  4 +-
 src/shared/agent-session-wire-refusals.ts     |  2 +-
 7 files changed, 139 insertions(+), 57 deletions(-)

diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-dead-generation-settlement.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-dead-generation-settlement.ts
index fda95a0ce739..e507bfffb0c1 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-dead-generation-settlement.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-dead-generation-settlement.ts
@@ -33,12 +33,18 @@ export function unexpectedProviderExitOutcome(reason?: string): string {
 }
 
 /** A restart that produced no child, answered to the send that asked for it; its cause is the
- *  whole story, and nothing is remembered, so the next try is a fresh one. */
-export function providerRestartFailureOutcome(reason?: string): string {
-  const detail = exitReasonDetail(reason)
-  return detail
-    ? `This chat's agent could not be restarted: ${detail}. Retry, or start a new chat.`
-    : "This chat's agent stopped and could not be restarted. Retry, or start a new chat."
+ *  whole story, and nothing is remembered, so the next try is a fresh one. A new chat is offered
+ *  only when the host holds nothing this chat could restart from. */
+export function ownerRestartFailedOutcome(input: {
+  agentName: string
+  reason?: string
+  resumable: boolean
+}): string {
+  const detail = exitReasonDetail(input.reason)
+  const failed = detail
+    ? `${input.agentName} couldn't restart: ${detail}.`
+    : `${input.agentName} couldn't restart.`
+  return input.resumable ? failed : `${failed} Start a new chat to continue.`
 }
 
 /** A start that never finished has no response to interrupt; its cause is the whole story. */
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-refusal-retry.test.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-refusal-retry.test.ts
index 4cf6111952b3..97f5321e8072 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-refusal-retry.test.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-refusal-retry.test.ts
@@ -251,7 +251,7 @@ const UNREACHABLE = new Set<Pair>([
   // Send reconstructs doubt from its global tombstone instead of refusing it.
   'agentSession.send:agent_session_operation_unknown',
   // Only a send restarts a lost owner.
-  'agentSession.setOption:agent_session_owner_unrecoverable'
+  'agentSession.setOption:agent_session_owner_restart_failed'
 ])
 
 describe('agentSessionRefusalOperationState host oracle', () => {
@@ -386,7 +386,7 @@ describe('agentSessionRefusalOperationState host oracle', () => {
       await assertHostAgreement(
         unrecoverable,
         { method: 'agentSession.send', operationId: operationId() },
-        'agent_session_owner_unrecoverable'
+        'agent_session_owner_restart_failed'
       )
     )
 
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-send-preparation.test.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-send-preparation.test.ts
index cee652cabecf..1d0dd7bffec0 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-send-preparation.test.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-send-preparation.test.ts
@@ -391,20 +391,18 @@ describe('a send with no live owner', () => {
     expect(host['holds'].isReleasePending(SESSION)).toBe(false)
   })
 
-  it('refuses for good when the owner cannot be restarted, saying why in the answer and in the chat', async () => {
+  it("refuses with the restart's own cause, in the answer and in the chat", async () => {
     await loseOwner()
-    acquire.mockRejectedValue(new Error('no provider thread to resume'))
-    const params = sendParams('nothing to resume')
+    acquire.mockRejectedValue(new Error('Not signed in. Run codex login'))
+    const params = sendParams('while signed out')
 
     const result = await host.send(CALLER, params)
 
-    expect(result).toMatchObject({
+    expect(result).toEqual({
       ok: false,
       refusal: {
-        code: 'agent_session_owner_unrecoverable',
-        message: expect.stringMatching(
-          /no provider thread to resume.*Retry, or start a new chat\.$/
-        ),
+        code: 'agent_session_owner_restart_failed',
+        message: "Codex couldn't restart: Not signed in. Run codex login.",
         // The failed attach proved its child gone: nothing runs for this session.
         ownerVerdict: 'exited'
       }
@@ -412,24 +410,79 @@ describe('a send with no live owner', () => {
     expect(dispatch).not.toHaveBeenCalled()
     expect(hostErrors).not.toEqual([])
     expect(
-      agentSessionRefusalOperationState('agentSession.send', 'agent_session_owner_unrecoverable')
+      agentSessionRefusalOperationState('agentSession.send', 'agent_session_owner_restart_failed')
     ).toBe('settled-rejected')
+    // Refused before admission: the ledger holds nothing a resend would replay.
+    expect(store.getOperationRow(CALLER.callerKey, params.envelope.clientOperationId)).toBeNull()
     // The same status row a failed start leaves, so the reason outlives the error strip.
-    expect(journalStatuses()).toEqual([expect.stringContaining('no provider thread to resume')])
+    expect(journalStatuses()).toEqual(["Codex couldn't restart: Not signed in. Run codex login."])
+  })
+
+  it('restarts again for a Retry of the refused send, under its own id or a new one', async () => {
+    await loseOwner()
+    acquire.mockRejectedValue(new Error('Not signed in'))
+    const params = sendParams('while signed out')
+    await expect(host.send(CALLER, params)).resolves.toMatchObject({
+      ok: false,
+      refusal: { code: 'agent_session_owner_restart_failed' }
+    })
 
     // A client that resends the same id gets another attempt, and the chat no second row.
     await expect(host.send(CALLER, params)).resolves.toMatchObject({
       ok: false,
-      refusal: { code: 'agent_session_owner_unrecoverable' }
+      refusal: { code: 'agent_session_owner_restart_failed' }
     })
     expect(acquire).toHaveBeenCalledTimes(2)
     expect(journalStatuses()).toHaveLength(1)
 
-    // Nothing is remembered: a Retry under a new id is a fresh attempt, and this one succeeds.
-    acquire.mockReset()
-    acquire.mockImplementation(spawnChild)
-    await expect(host.send(CALLER, sendParams('nothing to resume'))).resolves.toMatchObject({
-      ok: true
+    // The outbox's Retry rotates the id: also a fresh attempt.
+    await expect(host.send(CALLER, sendParams('while signed out'))).resolves.toMatchObject({
+      ok: false,
+      refusal: { code: 'agent_session_owner_restart_failed' }
+    })
+    expect(acquire).toHaveBeenCalledTimes(3)
+    expect(dispatch).not.toHaveBeenCalled()
+  })
+
+  it('restarts and delivers a later send once the cause clears', async () => {
+    await loseOwner()
+    acquire.mockRejectedValueOnce(new Error('Not signed in'))
+    await expect(host.send(CALLER, sendParams('while signed out'))).resolves.toMatchObject({
+      ok: false,
+      refusal: { code: 'agent_session_owner_restart_failed' }
+    })
+
+    // The user signed in; nothing about the failed attempt is remembered.
+    await expect(host.send(CALLER, sendParams('signed in now'))).resolves.toMatchObject({
+      ok: true,
+      replayed: false
+    })
+    expect(acquire).toHaveBeenCalledTimes(2)
+    expect(dispatch).toHaveBeenCalledOnce()
+    expect(store.getRecord(SESSION)?.lease.claimStatus).toBe('live')
+  })
+
+  it('suggests a new chat only when this host has nothing to restart the chat from', async () => {
+    await loseOwner()
+    acquire.mockRejectedValue(new Error('Not signed in'))
+    const failed = await host.send(CALLER, sendParams('restart fails'))
+    expect(failed).toMatchObject({
+      ok: false,
+      refusal: { code: 'agent_session_owner_restart_failed' }
+    })
+    expect(failed.ok ? '' : failed.refusal.message).not.toMatch(/new chat/)
+
+    // The adapter cannot run this record where it lives: no retry would bring it back.
+    host.deps.adapter.supportsLocation = () => false
+    const unresumable = await host.send(CALLER, sendParams('cannot resume here'))
+
+    expect(unresumable).toMatchObject({
+      ok: false,
+      refusal: {
+        code: 'agent_session_owner_restart_failed',
+        message:
+          "Codex couldn't restart: This execution host cannot resume the requested structured agent session. Start a new chat to continue."
+      }
     })
   })
 
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-send-preparation.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-send-preparation.ts
index 6d60ee3452c3..0528ae1cda63 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-send-preparation.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-send-preparation.ts
@@ -5,8 +5,10 @@
 // yet" and resends forever — and only a surface hold could ever make a new child. Now the send
 // makes sure it has an owner as a step of its own serialized admission: a released lease where
 // resume is allowed gets a child first; anything else runs as it is and meets the lease check.
-// A restart that fails for good refuses with a code the client stops on, carrying the cause, and
-// writes that cause into the chat the way a start that failed does, so the user sees why.
+// A restart that fails refuses with a code the client stops auto-retrying on, carrying the
+// restart's own cause, and writes that cause into the chat the way a start that failed does, so
+// the user sees why. A manual Retry or a new send is a fresh attempt: a refusal before admission
+// leaves no ledger row behind.
 //
 // The ledger's answer comes first, so a send it already holds a row for restarts nothing:
 // admission replays or refuses it whoever owns the session now, and a closed session is made
@@ -29,7 +31,8 @@ import type {
 } from '../../../shared/agent-session-wire'
 import type { AgentSessionWireRefusalCode } from '../../../shared/agent-session-wire-refusals'
 import { boundJournalStatusText } from '../agent-session-journal/journal-prompt-body-bounds'
-import { providerRestartFailureOutcome } from './structured-agent-session-dead-generation-settlement'
+import { TUI_AGENT_DISPLAY_NAMES } from '../../../shared/tui-agent-display-names'
+import { ownerRestartFailedOutcome } from './structured-agent-session-dead-generation-settlement'
 import type { StructuredAgentSessionHostSession } from './structured-agent-session-host-types'
 import type { StructuredAgentSessionMutationContext } from './structured-agent-session-host-mutations'
 import type { AgentSessionMutationSessionPreparation } from './structured-agent-session-mutation-admission'
@@ -39,26 +42,30 @@ import { rewindRefusal } from './structured-rewind-refusal'
 /**
  * What a refused resume means for the send that ran it. `transient`: the resume met a lease
  * someone else is settling, which is not proof it cannot resume — the send runs as the lease
- * stands and admission reports it. `terminal`: the restart itself failed; the send answers with
- * the cause and stops the client's retry loop. A new wire code does not compile until it is
- * classified here.
+ * stands and admission reports it. `failed`: the restart itself failed; the send answers with the
+ * cause and stops the client's retry loop, and the user may clear the cause and retry.
+ * `unresumable`: this host has nothing to restart the chat from — no record, or none it can run —
+ * so only a new chat continues. A new wire code does not compile until it is classified here.
  */
-const RESUME_REFUSAL_OUTCOME: Record<AgentSessionWireRefusalCode, 'transient' | 'terminal'> = {
+const RESUME_REFUSAL_OUTCOME: Record<
+  AgentSessionWireRefusalCode,
+  'transient' | 'failed' | 'unresumable'
+> = {
   execution_owner_reconciling: 'transient',
   agent_session_conflict: 'transient',
   agent_session_checkpoint_stale: 'transient',
   agent_session_ownership_unknown: 'transient',
   agent_session_operation_capacity: 'transient',
-  structured_agent_session_unsupported: 'terminal',
-  agent_session_operation_conflict: 'terminal',
-  agent_session_operation_expired: 'terminal',
-  agent_session_operation_invalid: 'terminal',
-  agent_session_operation_unknown: 'terminal',
-  agent_session_item_revision_stale: 'terminal',
-  agent_session_already_resolved: 'terminal',
-  agent_session_identity_required: 'terminal',
-  agent_session_journal_unreadable: 'terminal',
-  agent_session_owner_unrecoverable: 'terminal'
+  structured_agent_session_unsupported: 'unresumable',
+  agent_session_operation_conflict: 'failed',
+  agent_session_operation_expired: 'failed',
+  agent_session_operation_invalid: 'failed',
+  agent_session_operation_unknown: 'failed',
+  agent_session_item_revision_stale: 'failed',
+  agent_session_already_resolved: 'failed',
+  agent_session_identity_required: 'unresumable',
+  agent_session_journal_unreadable: 'failed',
+  agent_session_owner_restart_failed: 'failed'
 }
 
 /** Why the record refuses any send right now, whoever owns it; null when a send may run. */
@@ -121,7 +128,7 @@ export async function prepareStructuredAgentSessionSend(
     return { ok: true, envelope }
   }
   if (structuredAgentSessionSendNeedsOwner(context.sessions.get(sessionId), record)) {
-    const refusal = await restartOwnerForSend(context, envelope)
+    const refusal = await restartOwnerForSend(context, envelope, record)
     if (refusal) {
       return { ok: false, refusal }
     }
@@ -134,7 +141,8 @@ export async function prepareStructuredAgentSessionSend(
  *  own bookkeeping, which is reported and never gates the user's action. */
 async function restartOwnerForSend(
   context: SendPreparationContext,
-  envelope: AgentSessionMutationEnvelope
+  envelope: AgentSessionMutationEnvelope,
+  record: AgentSessionRecord
 ): Promise<AgentSessionWireRefusal | null> {
   const { sessionId } = envelope
   let resumed: Awaited<ReturnType<typeof context.holds.ensureProviderChild>>
@@ -144,10 +152,11 @@ async function restartOwnerForSend(
     context.deps.onEventSinkError?.({ sessionId, error })
     return null
   }
-  if (resumed.ok || RESUME_REFUSAL_OUTCOME[resumed.refusal.code] === 'transient') {
+  const outcome = resumed.ok ? null : RESUME_REFUSAL_OUTCOME[resumed.refusal.code]
+  if (resumed.ok || outcome === 'transient') {
     return null
   }
-  const refusal = ownerUnrecoverableRefusal(resumed.refusal)
+  const refusal = ownerRestartFailedRefusal(record, resumed.refusal, outcome !== 'unresumable')
   context.deps.onEventSinkError?.({
     sessionId,
     error: new Error(`${resumed.refusal.code}: ${resumed.refusal.message}`)
@@ -156,12 +165,20 @@ async function restartOwnerForSend(
   return refusal
 }
 
-/** The client stops on the code; the message says why, and the verdict — when the failed attach
- *  proved its child gone — tells a client that nothing is running for the session. */
-function ownerUnrecoverableRefusal(cause: AgentSessionWireRefusal): AgentSessionWireRefusal {
+/** The client stops on the code; the message carries the restart's own cause, and the verdict —
+ *  when the failed attach proved its child gone — tells a client nothing runs for the session. */
+function ownerRestartFailedRefusal(
+  record: AgentSessionRecord,
+  cause: AgentSessionWireRefusal,
+  resumable: boolean
+): AgentSessionWireRefusal {
   return {
-    code: 'agent_session_owner_unrecoverable',
-    message: providerRestartFailureOutcome(cause.message),
+    code: 'agent_session_owner_restart_failed',
+    message: ownerRestartFailedOutcome({
+      agentName: TUI_AGENT_DISPLAY_NAMES[record.provider],
+      reason: cause.message,
+      resumable
+    }),
     ...(cause.ownerVerdict ? { ownerVerdict: cause.ownerVerdict } : {})
   }
 }
diff --git a/src/renderer/src/components/native-chat/use-structured-agent-session-outbox.test.tsx b/src/renderer/src/components/native-chat/use-structured-agent-session-outbox.test.tsx
index 9b67ee7f69fb..613a599c2a62 100644
--- a/src/renderer/src/components/native-chat/use-structured-agent-session-outbox.test.tsx
+++ b/src/renderer/src/components/native-chat/use-structured-agent-session-outbox.test.tsx
@@ -530,11 +530,10 @@ describe('useStructuredAgentSessionOutbox', () => {
   })
 
   it('stops on a host that could not restart the agent and shows its message', async () => {
-    const message =
-      "This chat's agent stopped and could not be restarted. Retry, or start a new chat."
+    const message = "Claude couldn't restart: Not logged in. Please run /login."
     mocks.call.mockResolvedValue({
       ok: false,
-      refusal: { code: 'agent_session_owner_unrecoverable', message }
+      refusal: { code: 'agent_session_owner_restart_failed', message }
     })
     const { result } = renderHook(() =>
       useStructuredAgentSessionOutbox({
@@ -554,7 +553,14 @@ describe('useStructuredAgentSessionOutbox', () => {
     expect(result.current.blockedClientMessageId).toBe(result.current.outbox[0]?.clientMessageId)
     // Settled, not pending: the refused id never ran, so a Retry is a new operation.
     const sentId: unknown = mocks.call.mock.calls[0]![2].envelope.clientOperationId
-    expect(result.current.outbox[0]?.clientMessageId).not.toBe(sentId)
+    const retryId = result.current.outbox[0]!.clientMessageId
+    expect(retryId).not.toBe(sentId)
+
+    // A manual Retry sends again, which is what asks the host for another restart.
+    act(() => result.current.retry(retryId))
+    await waitFor(() => expect(mocks.call).toHaveBeenCalledTimes(2))
+    const retriedId: unknown = mocks.call.mock.calls[1]![2].envelope.clientOperationId
+    expect(retriedId).toBe(retryId)
   })
 
   it('persists and dispatches an attachment-only structured send', async () => {
diff --git a/src/shared/agent-session-refusal-retry.ts b/src/shared/agent-session-refusal-retry.ts
index 73799d4f756d..75ce023b6ef2 100644
--- a/src/shared/agent-session-refusal-retry.ts
+++ b/src/shared/agent-session-refusal-retry.ts
@@ -17,8 +17,8 @@ export function agentSessionRefusalOperationState(
     return 'settled-rejected'
   }
   switch (code) {
-    // The host already tried to restart the owner for this send and could not.
-    case 'agent_session_owner_unrecoverable':
+    // The host tried to restart the owner for this send and could not; a Retry tries again.
+    case 'agent_session_owner_restart_failed':
     case 'agent_session_operation_conflict':
     case 'agent_session_operation_expired':
     case 'agent_session_operation_invalid':
diff --git a/src/shared/agent-session-wire-refusals.ts b/src/shared/agent-session-wire-refusals.ts
index c3ca6bdb710c..12cd63d44904 100644
--- a/src/shared/agent-session-wire-refusals.ts
+++ b/src/shared/agent-session-wire-refusals.ts
@@ -20,7 +20,7 @@ export const AGENT_SESSION_WIRE_REFUSAL_CODES = [
   'agent_session_journal_unreadable',
   'execution_owner_reconciling',
   // Older clients hold an unknown code as a blocked send with the host's message shown.
-  'agent_session_owner_unrecoverable'
+  'agent_session_owner_restart_failed'
 ] as const
 export type AgentSessionWireRefusalCode = (typeof AGENT_SESSION_WIRE_REFUSAL_CODES)[number]
 

From 689009be6d2bdd0cae4535718ae4be861d831f02 Mon Sep 17 00:00:00 2001
From: Brennan Benson <79079362+brennanb2025@users.noreply.github.com>
Date: Wed, 23 Sep 2026 16:56:25 -0700
Subject: [PATCH 46/67] fix(native-chat): a Claude start skips an option write
 the CLI never answers instead of faulting at the request deadline

---
 .../claude-agent-sdk-control-requests.ts      | 11 ++-
 .../claude/claude-structured-options.test.ts  | 26 +++++
 src/main/claude/claude-structured-options.ts  | 10 +-
 ...startup-unanswered-control-request.test.ts | 94 +++++++++++++++++++
 ...ed-claude-scripted-runtime-test-support.ts | 42 +++++++--
 5 files changed, 174 insertions(+), 9 deletions(-)
 create mode 100644 src/main/runtime/claude-structured-startup-unanswered-control-request.test.ts

diff --git a/src/main/claude/claude-agent-sdk-control-requests.ts b/src/main/claude/claude-agent-sdk-control-requests.ts
index 8ceb7a683814..ec8bd52590d1 100644
--- a/src/main/claude/claude-agent-sdk-control-requests.ts
+++ b/src/main/claude/claude-agent-sdk-control-requests.ts
@@ -16,6 +16,15 @@ export class ClaudeControlRequestError extends Error {
 
 export const CLAUDE_DEFAULT_REQUEST_TIMEOUT_MS = 30_000
 
+/** The deadline fired before the CLI answered. The request may still land, so this proves
+ *  nothing about it either way; it is neither the CLI refusing nor the transport closing. */
+export class ClaudeControlRequestTimeoutError extends Error {
+  constructor(readonly subtype: string) {
+    super(`claude ${subtype} request timed out`)
+    this.name = 'ClaudeControlRequestTimeoutError'
+  }
+}
+
 /** The SDK closes a query out from under an in-flight control request with this exact message. */
 const QUERY_CLOSED_MESSAGE = 'Query closed before response received'
 
@@ -70,7 +79,7 @@ export function runClaudeControl<T>(
     return request
   }
   const deadline = new Promise<never>((_resolve, reject) => {
-    timer = setTimeout(() => reject(new Error(`claude ${subtype} request timed out`)), timeoutMs)
+    timer = setTimeout(() => reject(new ClaudeControlRequestTimeoutError(subtype)), timeoutMs)
     timer.unref?.()
   })
   return Promise.race([request, deadline]).finally(() => {
diff --git a/src/main/claude/claude-structured-options.test.ts b/src/main/claude/claude-structured-options.test.ts
index 6b994c8bb2cf..59f1193eee5c 100644
--- a/src/main/claude/claude-structured-options.test.ts
+++ b/src/main/claude/claude-structured-options.test.ts
@@ -4,6 +4,7 @@ import {
   setClaudeStructuredOption
 } from './claude-structured-options'
 import type { ClaudeSession } from './claude-structured-session-state'
+import { ClaudeControlRequestTimeoutError } from './claude-agent-sdk-control-requests'
 import { ClaudeBackgroundTaskTracker } from './claude-background-task-tracker'
 import { ClaudeSlashCommandCatalog } from './claude-slash-command-catalog'
 import { createClaudeSessionStartupGate } from './claude-structured-session-startup-gate'
@@ -439,3 +440,28 @@ describe('Claude Fast mode reported by the session frame alone', () => {
     expect(result.current.fastMode).toBeUndefined()
   })
 })
+
+describe('Claude structured option restore under the request deadline', () => {
+  it('skips a write the CLI never answered and finishes the restore', async () => {
+    const session = sessionFor(async () => {
+      throw new ClaudeControlRequestTimeoutError('set_model')
+    })
+    session.options = new Map([['model', 'sonnet']])
+    vi.spyOn(console, 'warn').mockImplementation(() => {})
+
+    await expect(restoreClaudeStructuredSessionOptions(session, 10)).resolves.toBeUndefined()
+
+    expect([...session.restoreSkippedOptions]).toEqual(['model'])
+    expect(session.options.has('model')).toBe(false)
+  })
+
+  it("keeps a timed-out client write as the deadline's own error, not a rejection", async () => {
+    const session = sessionFor(async () => {
+      throw new ClaudeControlRequestTimeoutError('set_model')
+    })
+
+    await expect(
+      setClaudeStructuredOption(session, { key: 'model', value: 'sonnet' }, 10)
+    ).rejects.toBeInstanceOf(ClaudeControlRequestTimeoutError)
+  })
+})
diff --git a/src/main/claude/claude-structured-options.ts b/src/main/claude/claude-structured-options.ts
index fc57b247e90a..57496dd38433 100644
--- a/src/main/claude/claude-structured-options.ts
+++ b/src/main/claude/claude-structured-options.ts
@@ -1,5 +1,6 @@
 import type { EffortLevel, PermissionMode } from '@anthropic-ai/claude-agent-sdk'
 import { ClaudeControlRequestError } from './claude-stream-json-connection'
+import { ClaudeControlRequestTimeoutError } from './claude-agent-sdk-control-requests'
 import {
   AgentSessionOptionRejectedError,
   isAgentSessionOptionRejectedError
@@ -240,7 +241,14 @@ export async function restoreClaudeStructuredSessionOptions(
     try {
       await setClaudeStructuredOption(session, { key, value }, timeoutMs)
     } catch (error) {
-      if (!isAgentSessionOptionRejectedError(error)) {
+      // A write the CLI never answered is skipped the same way: startup has no deadline of its
+      // own, and a slow control answer must not fault a session whose child is otherwise fine.
+      // The child's current value stands, and the user can set the option again.
+      if (error instanceof ClaudeControlRequestTimeoutError) {
+        console.warn(
+          `[claude-structured] restore of ${key} for ${session.providerSessionId} was not answered in time; keeping the CLI's value`
+        )
+      } else if (!isAgentSessionOptionRejectedError(error)) {
         throw error
       }
       // A stale or unavailable preference must not poison every future acquire;
diff --git a/src/main/runtime/claude-structured-startup-unanswered-control-request.test.ts b/src/main/runtime/claude-structured-startup-unanswered-control-request.test.ts
new file mode 100644
index 000000000000..f1c9c222b020
--- /dev/null
+++ b/src/main/runtime/claude-structured-startup-unanswered-control-request.test.ts
@@ -0,0 +1,94 @@
+// A Claude start has no deadline of its own, but each option write the restore replays, and
+// startup's own settings read, is a control request under the ordinary request deadline. A CLI
+// that answers initialize and then never answers one of those used to fault the whole session
+// when that deadline fired: a start that was merely slow died with the deadline's error as its
+// cause. Now the unanswered request is skipped and startup lands on the CLI's own values. Against
+// the production runtime, adapter, record store and host, with only the CLI process scripted.
+
+import { afterEach, describe, expect, it, vi } from 'vitest'
+import { computeAgentSessionPayloadFingerprint } from '../../shared/agent-session-mutation-envelope'
+import { hostTestMessage } from '../native-chat/agent-session-wire/structured-agent-session-host-test-data'
+import type { StructuredAgentSessionHost } from '../native-chat/agent-session-wire/structured-agent-session-host'
+import { createScriptedClaudeRuntime } from './structured-claude-scripted-runtime-test-support'
+
+const SESSION = 'claude-startup-unanswered-control'
+const CALLER = { callerKey: 'client-1' }
+const DEADLINE_MS = 50
+
+let claude = createScriptedClaudeRuntime([SESSION])
+let operations = 0
+
+afterEach(async () => {
+  await claude.dispose()
+  claude = createScriptedClaudeRuntime([SESSION])
+})
+
+function record(host: StructuredAgentSessionHost) {
+  return host.deps.store.getRecord(SESSION)
+}
+
+function statusRows(host: StructuredAgentSessionHost): string[] {
+  return host
+    .journalSnapshot(SESSION)
+    .items.flatMap((item) => (item.body.kind === 'status' ? [item.body.text] : []))
+}
+
+async function send(host: StructuredAgentSessionHost, text: string): Promise<void> {
+  const body = hostTestMessage(text)
+  await expect(
+    host.send(CALLER, {
+      envelope: {
+        sessionId: SESSION,
+        clientOperationId: `${Date.now()}-${(++operations).toString(16).padStart(32, '0')}`,
+        expectedRuntimeFence: record(host)?.lease.runtimeFence ?? 0,
+        payloadFingerprint: computeAgentSessionPayloadFingerprint({
+          method: 'agentSession.send',
+          sessionId: SESSION,
+          fields: { body }
+        })
+      },
+      body
+    })
+  ).resolves.toMatchObject({ ok: true })
+}
+
+describe('a Claude start whose CLI answers initialize but not a control request', () => {
+  it('lands with the unanswered option write skipped, keeping the CLI value, instead of faulting at the deadline', async () => {
+    claude.behave(SESSION, { optionWritesHang: true, controlTimeoutMs: DEADLINE_MS })
+    vi.spyOn(console, 'warn').mockImplementation(() => {})
+    const host = await claude.install()
+    await expect(
+      host.attach(CALLER, claude.attachParams(SESSION, null, { options: { model: 'sonnet' } }))
+    ).resolves.toMatchObject({ ok: true })
+
+    // The restore asked; the CLI never answered; startup went on without it.
+    await vi.waitFor(() => expect(claude.child(SESSION).calls).toContain('set_model'))
+    await vi.waitFor(
+      () => expect(record(host)?.options).toEqual({ model: 'claude-sonnet-5', effort: 'high' }),
+      { timeout: DEADLINE_MS * 40 }
+    )
+    expect(host.deps.adapter.readOptionRestoreFailures?.(SESSION)).toEqual(['model'])
+    expect(record(host)?.lease.claimStatus).toBe('live')
+    expect(statusRows(host)).toEqual([])
+    expect(claude.children(SESSION)).toHaveLength(1)
+
+    // The proven child takes the next message.
+    await send(host, 'hello')
+    await vi.waitFor(() => expect(claude.child(SESSION).calls).toContain('send'))
+  })
+
+  it("lands with effort unknown when startup's own settings read goes unanswered", async () => {
+    claude.behave(SESSION, { startupSettingsReadHangs: true, controlTimeoutMs: DEADLINE_MS })
+    const host = await claude.install()
+    await expect(host.attach(CALLER, claude.attachParams(SESSION, null))).resolves.toMatchObject({
+      ok: true
+    })
+
+    await vi.waitFor(() => expect(record(host)?.options).toEqual({ model: 'claude-sonnet-5' }), {
+      timeout: DEADLINE_MS * 40
+    })
+    expect(record(host)?.lease.claimStatus).toBe('live')
+    expect(statusRows(host)).toEqual([])
+    expect(claude.children(SESSION)).toHaveLength(1)
+  })
+})
diff --git a/src/main/runtime/structured-claude-scripted-runtime-test-support.ts b/src/main/runtime/structured-claude-scripted-runtime-test-support.ts
index bf57b42b2da8..4836665d49a3 100644
--- a/src/main/runtime/structured-claude-scripted-runtime-test-support.ts
+++ b/src/main/runtime/structured-claude-scripted-runtime-test-support.ts
@@ -10,7 +10,9 @@ import type {
   ClaudeStreamJsonLaunch,
   openClaudeStreamJsonConnection
 } from '../claude/claude-stream-json-connection'
+import { runClaudeControl } from '../claude/claude-agent-sdk-control-requests'
 import { claudeSessionIdForOrcaSession } from '../claude/claude-structured-launch-resolution'
+import type { AgentSessionAttachParams } from '../native-chat/agent-session-wire/structured-agent-session-attach'
 import { hostTestAttachParams } from '../native-chat/agent-session-wire/structured-agent-session-host-test-data'
 import type { StructuredAgentSessionHost } from '../native-chat/agent-session-wire/structured-agent-session-host'
 import {
@@ -29,6 +31,12 @@ export type ScriptedClaudeBehavior = {
   exitsDuringSpawn?: { diagnostic: string; at: 'spawn' | 'start-time-read' }
   /** Closing cannot prove the descendant tree gone, as when it was never snapshottable. */
   closeUnproven?: boolean
+  /** Control requests run under this deadline, the way production's run under the default one. */
+  controlTimeoutMs?: number
+  /** Every option write (set_model, set_permission_mode, apply_flag_settings) goes unanswered. */
+  optionWritesHang?: boolean
+  /** Startup's own settings read goes unanswered. */
+  startupSettingsReadHangs?: boolean
 }
 
 export type ScriptedClaudeChild = {
@@ -72,6 +80,14 @@ export function createScriptedClaudeRuntime(sessionIds: readonly string[]) {
     let answerInit = (): void => {}
     const answer = <T>(value: T, startup: boolean): Promise<T> =>
       behavior.stallsControlReads && !startup ? stall.then(() => value) : Promise.resolve(value)
+    // Untimed unless the behavior sets a deadline; a hang then settles only on the child's exit.
+    const control = <T>(subtype: string, run: () => Promise<T>): Promise<T> =>
+      runClaudeControl(subtype, run, behavior.controlTimeoutMs ?? null)
+    const never = <T>(): Promise<T> => new Promise<T>(() => {})
+    const optionWrite = (subtype: string): Promise<void> => {
+      child.calls.push(subtype)
+      return control(subtype, () => (behavior.optionWritesHang ? never() : Promise.resolve()))
+    }
     let settingsReads = 0
     const child: ScriptedClaudeChild = {
       sessionId,
@@ -113,15 +129,22 @@ export function createScriptedClaudeRuntime(sessionIds: readonly string[]) {
         getSettings: () => {
           child.calls.push('get_settings')
           settingsReads += 1
-          return answer({ effective: { effortLevel: 'high' } }, settingsReads === 1)
+          const startup = settingsReads === 1
+          return control('get_settings', () =>
+            behavior.startupSettingsReadHangs && startup
+              ? never()
+              : answer({ effective: { effortLevel: 'high' } }, startup)
+          )
         },
         supportedModels: () => {
           child.calls.push('list_models')
-          return answer([{ value: 'sonnet', displayName: 'Sonnet' }], false)
+          return control('list_models', () =>
+            answer([{ value: 'sonnet', displayName: 'Sonnet' }], false)
+          )
         },
-        setModel: async () => {},
-        setPermissionMode: async () => {},
-        applyFlagSettings: async () => {},
+        setModel: () => optionWrite('set_model'),
+        setPermissionMode: () => optionWrite('set_permission_mode'),
+        applyFlagSettings: () => optionWrite('apply_flag_settings'),
         interrupt: async () => undefined,
         cancelAsyncMessage: async () => {},
         stopTask: async () => {},
@@ -184,7 +207,11 @@ export function createScriptedClaudeRuntime(sessionIds: readonly string[]) {
         readProcessStartTime
       })
     },
-    attachParams: (sessionId: string, expectedRuntimeFence: number | null) =>
+    attachParams: (
+      sessionId: string,
+      expectedRuntimeFence: number | null,
+      overrides: Partial<AgentSessionAttachParams> = {}
+    ) =>
       hostTestAttachParams(expectedRuntimeFence, {
         envelope: {
           sessionId,
@@ -200,7 +227,8 @@ export function createScriptedClaudeRuntime(sessionIds: readonly string[]) {
           kind: 'claude',
           sessionId: claudeSessionIdForOrcaSession(sessionId),
           leafUuid: null
-        }
+        },
+        ...overrides
       }),
     dispose: async (): Promise<void> => {
       releaseStalls()

From 62dafdb1dff785641382250634fb6c0505a01bd3 Mon Sep 17 00:00:00 2001
From: Brennan Benson <79079362+brennanb2025@users.noreply.github.com>
Date: Wed, 23 Sep 2026 17:07:25 -0700
Subject: [PATCH 47/67] test(native-chat): wait for the recovery's reserved
 lease, not the released one it replaces at once

---
 ...ured-agent-session-runtime-provider-started.test.ts | 10 ++++++++--
 1 file changed, 8 insertions(+), 2 deletions(-)

diff --git a/src/main/runtime/structured-agent-session-runtime-provider-started.test.ts b/src/main/runtime/structured-agent-session-runtime-provider-started.test.ts
index e7a2bb822b46..602507ef4d7e 100644
--- a/src/main/runtime/structured-agent-session-runtime-provider-started.test.ts
+++ b/src/main/runtime/structured-agent-session-runtime-provider-started.test.ts
@@ -64,12 +64,15 @@ describe('a Claude child proving its start', () => {
     await host.hold(HEALTHY, 'surface-1')
     await waitForStructuredAgentSessionRecovery()
 
-    // Its exit recovery reacquires, and that spawn never returns.
+    // Its exit recovery reacquires, and that spawn never returns. The exit hands the lease back
+    // and the restart queued behind it reserves it again at once, so `released` is not a state a
+    // poll can count on seeing; `reserved` with the spawn hanging is what "still acquiring" is.
     claude.behave(HEALTHY, { spawnHangs: true })
     claude.child(HEALTHY).exit(new Error('claude stream-json exited (code 1): crashed'))
     await vi.waitFor(() =>
-      expect(host.deps.store.getRecord(HEALTHY)?.lease.claimStatus).toBe('released')
+      expect(host.deps.store.getRecord(HEALTHY)?.lease.claimStatus).toBe('reserved')
     )
+    expect(claude.children(HEALTHY)).toHaveLength(1)
 
     await expect(host.attach(CALLER, claude.attachParams(STALLED, null))).resolves.toMatchObject({
       ok: true
@@ -80,6 +83,9 @@ describe('a Claude child proving its start', () => {
         effort: 'high'
       })
     )
+    // The other recovery is still where it was: reserved, with no child yet.
+    expect(host.deps.store.getRecord(HEALTHY)?.lease.claimStatus).toBe('reserved')
+    expect(claude.children(HEALTHY)).toHaveLength(1)
   })
 
   it('is drained by the runtime before teardown proceeds', async () => {

From 3af990a2d7a92c4ca792d79e2b840020523dd11f Mon Sep 17 00:00:00 2001
From: Brennan Benson <79079362+brennanb2025@users.noreply.github.com>
Date: Wed, 23 Sep 2026 17:41:38 -0700
Subject: [PATCH 48/67] fix(native-chat): a send whose restarted child dies
 before starting is rejected with the child's diagnostic

A child that never proved its start has accepted nothing: input is written
only after it initializes. A send admitted against such a child, whose
dispatch then found no session, settled unknown, twice, and the outbox took
Retry away. It now settles rejected with the child's own diagnostic, both
when the dispatch throws and when the exit settles the sends it left
unanswered, so the chat says why and offers Retry. A proven child's
unanswered sends stay in doubt, as before.
---
 .../claude-structured-session-adapter.ts      |   6 +-
 .../journal-pending-submission-recovery.ts    |  26 +++
 .../agent-session-journal/journal-store.ts    |  10 +-
 ...session-dead-generation-settlement.test.ts |   9 +-
 ...gent-session-dead-generation-settlement.ts |  12 +-
 ...structured-agent-session-host-mutations.ts |   1 +
 ...ctured-agent-session-mutation-admission.ts |   2 +
 ...agent-session-startup-failure-exit.test.ts |   3 +-
 .../structured-agent-session-turns.ts         |  15 +-
 ...ured-agent-session-unexpected-exit.test.ts |  11 +-
 ...-send-restart-dies-before-dispatch.test.ts | 188 ++++++++++++++++++
 11 files changed, 272 insertions(+), 11 deletions(-)
 create mode 100644 src/main/runtime/claude-structured-send-restart-dies-before-dispatch.test.ts

diff --git a/src/main/claude/claude-structured-session-adapter.ts b/src/main/claude/claude-structured-session-adapter.ts
index 0f269144ecde..e2b2bfd35b41 100644
--- a/src/main/claude/claude-structured-session-adapter.ts
+++ b/src/main/claude/claude-structured-session-adapter.ts
@@ -315,7 +315,11 @@ export class ClaudeStructuredSessionAdapter implements StructuredAgentSessionAda
   private session(sessionId: string): ClaudeSession {
     const session = this.sessions.get(sessionId)
     if (!session) {
-      throw new Error(`no live claude stream-json session for ${sessionId}`)
+      // A child that just exited is named by its own diagnostic, not by its absence.
+      throw (
+        this.exits.get(sessionId)?.error ??
+        new Error(`no live claude stream-json session for ${sessionId}`)
+      )
     }
     return session
   }
diff --git a/src/main/native-chat/agent-session-journal/journal-pending-submission-recovery.ts b/src/main/native-chat/agent-session-journal/journal-pending-submission-recovery.ts
index 006cc4ffa383..c4138ba22418 100644
--- a/src/main/native-chat/agent-session-journal/journal-pending-submission-recovery.ts
+++ b/src/main/native-chat/agent-session-journal/journal-pending-submission-recovery.ts
@@ -29,3 +29,29 @@ export async function markJournalPendingSubmissionsUnknown(
   }
   return unresolved.map((entry) => entry.clientMessageId)
 }
+
+/** Settles every submission a child that never proved its start left unanswered as `rejected`:
+ *  such a child accepted nothing, so each is provably unwritten and safe to send again. */
+export async function rejectJournalPendingSubmissions(
+  journal: AgentSessionJournal,
+  fence: number,
+  reason: string
+): Promise<string[]> {
+  const unwritten = journal
+    .submissions()
+    .filter(
+      (entry) =>
+        entry.dispatchState === 'pending' ||
+        (entry.dispatchState === 'unknown' && entry.recovered !== true)
+    )
+  for (const entry of unwritten) {
+    await journal.resolveDispatch({
+      clientMessageId: entry.clientMessageId,
+      state: 'rejected',
+      reason,
+      fence,
+      recovered: true
+    })
+  }
+  return unwritten.map((entry) => entry.clientMessageId)
+}
diff --git a/src/main/native-chat/agent-session-journal/journal-store.ts b/src/main/native-chat/agent-session-journal/journal-store.ts
index fb651518f15a..dd4612370253 100644
--- a/src/main/native-chat/agent-session-journal/journal-store.ts
+++ b/src/main/native-chat/agent-session-journal/journal-store.ts
@@ -24,7 +24,10 @@ import type { JournalReplacementItem } from './journal-epoch-replacement'
 import { readJournalSince } from './journal-cursor'
 import { readJournalRowsAfterCursor, type JournalLoad } from './journal-open'
 import { journalDatabaseFile } from './journal-paths'
-import { markJournalPendingSubmissionsUnknown } from './journal-pending-submission-recovery'
+import {
+  markJournalPendingSubmissionsUnknown,
+  rejectJournalPendingSubmissions
+} from './journal-pending-submission-recovery'
 import {
   applyJournalRow,
   createJournalReducerState,
@@ -279,6 +282,11 @@ export class AgentSessionJournal {
     return markJournalPendingSubmissionsUnknown(this, fence, reason)
   }
 
+  /** Reject unanswered sends after an owner that never proved its start ended: none was written. */
+  async rejectPendingSubmissions(fence: number, reason: string): Promise<string[]> {
+    return rejectJournalPendingSubmissions(this, fence, reason)
+  }
+
   /** The escape hatch for corruption, an unreconcilable prefix, a forked handle,
    *  and an unreadable schema. It invalidates every cursor; clients reload. */
   async rollEpoch(reason: AgentJournalEpochReason, fence: number): Promise<AgentJournalCursor> {
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-dead-generation-settlement.test.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-dead-generation-settlement.test.ts
index af51a9967d6a..7af5626c07b5 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-dead-generation-settlement.test.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-dead-generation-settlement.test.ts
@@ -185,7 +185,11 @@ describe('dead structured-session generation settlement', () => {
     const settledSnapshot = journal.snapshot()
     const closedJournal: Pick<
       AgentSessionJournal,
-      'snapshot' | 'submissions' | 'markPendingSubmissionsUnknown' | 'appendLifecycleBatch'
+      | 'snapshot'
+      | 'submissions'
+      | 'markPendingSubmissionsUnknown'
+      | 'rejectPendingSubmissions'
+      | 'appendLifecycleBatch'
     > = {
       snapshot: () => ({
         ...settledSnapshot,
@@ -195,6 +199,9 @@ describe('dead structured-session generation settlement', () => {
       markPendingSubmissionsUnknown: async () => {
         throw new Error('journal_closed')
       },
+      rejectPendingSubmissions: async () => {
+        throw new Error('journal_closed')
+      },
       appendLifecycleBatch: async () => {
         throw new Error('journal_closed')
       }
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-dead-generation-settlement.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-dead-generation-settlement.ts
index e507bfffb0c1..6d360e38771b 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-dead-generation-settlement.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-dead-generation-settlement.ts
@@ -4,6 +4,7 @@ import type {
   AgentJournalRenderItem
 } from '../../../shared/agent-session-journal-types'
 import { readAgentJournalTurn } from '../../../shared/agent-session-turn-record'
+import { dispatchWriteFailureReason } from '../../../shared/structured-agent-session-dispatch-rejection'
 import { partitionJournalLifecycleMutations } from '../agent-session-journal/journal-lifecycle-batch-partition'
 import type { JournalLifecycleMutationInput } from '../agent-session-journal/journal-row-builders'
 import {
@@ -70,6 +71,7 @@ type DeadGenerationSubmission = Pick<
 export type DeadGenerationJournal = {
   appendLifecycleBatch: AgentSessionJournal['appendLifecycleBatch']
   markPendingSubmissionsUnknown: AgentSessionJournal['markPendingSubmissionsUnknown']
+  rejectPendingSubmissions: AgentSessionJournal['rejectPendingSubmissions']
   snapshot: () => Pick<ReturnType<AgentSessionJournal['snapshot']>, 'items'>
   pendingSubmissions?: AgentSessionJournal['pendingSubmissions']
   submissions?: () => DeadGenerationSubmission[]
@@ -143,7 +145,15 @@ export async function settleStructuredAgentSessionDeadGeneration(input: {
     if (!showUnexpectedExitOutcome && !hasUnfinishedWork) {
       return true
     }
-    await input.journal.markPendingSubmissionsUnknown(input.fence, input.pendingSubmissionReason)
+    // A child that never proved its start accepted nothing — input is written only after it
+    // initializes — so every send it left unanswered is provably unwritten and is rejected with the
+    // child's own diagnostic. A proven child's unanswered sends stay in doubt.
+    await (input.exitedDuringStartup
+      ? input.journal.rejectPendingSubmissions(
+          input.fence,
+          dispatchWriteFailureReason(input.unexpectedExitReason ?? input.pendingSubmissionReason)
+        )
+      : input.journal.markPendingSubmissionsUnknown(input.fence, input.pendingSubmissionReason))
     const items = input.journal.snapshot().items
     const mutations: JournalLifecycleMutationInput[] = []
     if (showUnexpectedExitOutcome) {
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-host-mutations.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-host-mutations.ts
index 373a38f9853c..83ab9e495a88 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-host-mutations.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-host-mutations.ts
@@ -79,6 +79,7 @@ function mutate<TValue>(
       publish: (journal) => context.publish(envelope.sessionId, journal),
       flushStreamedEvents: context.flushStreamedEvents,
       hasPendingStreamedEvents: context.hasPendingStreamedEvents,
+      providerChildPhase: () => context.sessions.get(envelope.sessionId)?.providerChildPhase,
       now: () => context.now()
     })
   )
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-mutation-admission.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-mutation-admission.ts
index 81eedfd11890..b735427be0e8 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-mutation-admission.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-mutation-admission.ts
@@ -65,6 +65,7 @@ export type AgentSessionMutationRequest<TValue> = {
   publish: (journal: AgentSessionJournal) => void
   flushStreamedEvents: (sessionId: string) => Promise<void>
   hasPendingStreamedEvents?: (sessionId: string) => boolean
+  providerChildPhase?: AgentSessionTurnContext['providerChildPhase']
   now: () => number
 }
 
@@ -191,6 +192,7 @@ function turnContext<TValue>(
     flushStreamedEvents: () => request.flushStreamedEvents(request.envelope.sessionId),
     hasPendingStreamedEvents: () =>
       request.hasPendingStreamedEvents?.(request.envelope.sessionId) ?? false,
+    ...(request.providerChildPhase ? { providerChildPhase: request.providerChildPhase } : {}),
     now: () => request.now()
   }
 }
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-startup-failure-exit.test.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-startup-failure-exit.test.ts
index cc34741f9d43..0fd544ec9eea 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-startup-failure-exit.test.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-startup-failure-exit.test.ts
@@ -26,7 +26,8 @@ function startedSession(): StructuredAgentSessionUnexpectedExitSession & {
       // Nothing ran: the start failed before any response or acknowledged prompt.
       snapshot: () => ({ items: [] }),
       appendLifecycleBatch: vi.fn(async () => ({ epoch: 'epoch-1', sequence: 1 })),
-      markPendingSubmissionsUnknown: vi.fn(async () => [])
+      markPendingSubmissionsUnknown: vi.fn(async () => []),
+      rejectPendingSubmissions: vi.fn(async () => [])
     }
   }
 }
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-turns.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-turns.ts
index 4c9cc2213d5c..e3609930084f 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-turns.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-turns.ts
@@ -20,8 +20,10 @@ import type { AgentSessionJournal } from '../agent-session-journal/journal-store
 import { latestJournalDispatchObservation } from '../agent-session-journal/journal-dispatch-observation'
 import type {
   AgentSessionDispatchOutcome,
-  StructuredAgentSessionAdapter
+  StructuredAgentSessionAdapter,
+  StructuredAgentSessionProviderChildPhase
 } from './structured-agent-session-adapter'
+import { dispatchWriteFailureReason } from '../../../shared/structured-agent-session-dispatch-rejection'
 import { validatePendingPrompt } from './structured-agent-session-prompt-state'
 import { withTimeout } from '../../../shared/promise-timeout-fallback'
 import {
@@ -46,6 +48,8 @@ export type AgentSessionTurnContext = {
   hasPendingStreamedEvents?: () => boolean
   /** Re-derives authorization after submission persistence, immediately before provider dispatch. */
   beforeDispatch?: () => void
+  /** What the host holds about the child this dispatch is for, read at the moment it is needed. */
+  providerChildPhase?: () => StructuredAgentSessionProviderChildPhase | undefined
   now: () => number
 }
 
@@ -57,8 +61,10 @@ function invalid(message: string): { ok: false; refusal: AgentSessionWireRefusal
   return { ok: false, refusal: { code: 'agent_session_operation_invalid', message } }
 }
 
-/** A thrown adapter error is indistinguishable from a lost reply, so it settles
- *  as `unknown` rather than as a rejection. */
+/** A thrown adapter error is indistinguishable from a lost reply, so it settles as `unknown`
+ *  rather than as a rejection — unless the child had not proven its start. Such a child has
+ *  accepted nothing (input is written only after it initializes), so a dispatch it could not
+ *  take is provably unwritten and is rejected with the cause the adapter gave. */
 async function dispatchSafely(
   ctx: AgentSessionTurnContext,
   clientMessageId: string,
@@ -95,6 +101,9 @@ async function dispatchSafely(
     if (error instanceof AgentSessionPreDispatchError) {
       throw error
     }
+    if (ctx.providerChildPhase?.() === 'starting') {
+      return { state: 'rejected', reason: dispatchWriteFailureReason(error) }
+    }
     return { state: 'unknown', reason: error instanceof Error ? error.message : String(error) }
   }
 }
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-unexpected-exit.test.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-unexpected-exit.test.ts
index 8dc2112b18ad..f844dc9639cf 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-unexpected-exit.test.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-unexpected-exit.test.ts
@@ -136,7 +136,8 @@ describe('provider-exit recovery tickets', () => {
           items: [lifecycleItem('turn-1', 1, { state: 'running', startedAt: 1_000 })]
         }),
         appendLifecycleBatch,
-        markPendingSubmissionsUnknown: vi.fn(async () => [])
+        markPendingSubmissionsUnknown: vi.fn(async () => []),
+        rejectPendingSubmissions: vi.fn(async () => [])
       }
     } as unknown as StructuredAgentSessionHostSession
 
@@ -204,7 +205,8 @@ describe('provider-exit recovery tickets', () => {
       journal: {
         snapshot: () => ({ items }),
         appendLifecycleBatch,
-        markPendingSubmissionsUnknown: vi.fn(async () => [])
+        markPendingSubmissionsUnknown: vi.fn(async () => []),
+        rejectPendingSubmissions: vi.fn(async () => [])
       }
     } as unknown as StructuredAgentSessionHostSession
     const store = {
@@ -311,7 +313,8 @@ describe('provider-exit recovery tickets', () => {
         journal: {
           snapshot: () => ({ items }),
           appendLifecycleBatch,
-          markPendingSubmissionsUnknown: vi.fn(async () => [])
+          markPendingSubmissionsUnknown: vi.fn(async () => []),
+          rejectPendingSubmissions: vi.fn(async () => [])
         }
       }
 
@@ -368,6 +371,7 @@ describe('provider-exit recovery tickets', () => {
         snapshot: () => ({ items: [] }),
         appendLifecycleBatch: vi.fn(async () => ({ epoch: 'epoch-1', sequence: 1 })),
         markPendingSubmissionsUnknown,
+        rejectPendingSubmissions: vi.fn(async () => []),
         submissions: () => [{ clientMessageId: 'client-1', dispatchState: 'pending' }]
       }
     }
@@ -413,6 +417,7 @@ describe('provider-exit recovery tickets', () => {
       acquisitionGeneration: GENERATION,
       journal: {
         markPendingSubmissionsUnknown: vi.fn(async () => []),
+        rejectPendingSubmissions: vi.fn(async () => []),
         snapshot: () => ({
           items: [lifecycleItem('turn-failing', 1, { state: 'running', startedAt: 1 })]
         }),
diff --git a/src/main/runtime/claude-structured-send-restart-dies-before-dispatch.test.ts b/src/main/runtime/claude-structured-send-restart-dies-before-dispatch.test.ts
new file mode 100644
index 000000000000..e90c553679f8
--- /dev/null
+++ b/src/main/runtime/claude-structured-send-restart-dies-before-dispatch.test.ts
@@ -0,0 +1,188 @@
+// A send restarts a chat's Claude child and is admitted against it while it is still starting.
+// When that child dies before the send's dispatch reaches the adapter, the adapter has no session
+// to hold the message for, so the dispatch throws. A child that never proved its start accepted
+// nothing — input is only written after initialize — so the send settles `rejected` with the
+// child's own diagnostic, never as a delivery nobody can confirm, and a client that was
+// subscribed the whole time receives the failure row and the rejected submission over the wire.
+// Against the production runtime, adapter, record store and host, with only the CLI scripted.
+
+import { afterEach, describe, expect, it, vi } from 'vitest'
+import { computeAgentSessionPayloadFingerprint } from '../../shared/agent-session-mutation-envelope'
+import type { AgentSessionSubscribeEvent } from '../../shared/agent-session-wire'
+import { hostTestMessage } from '../native-chat/agent-session-wire/structured-agent-session-host-test-data'
+import type { StructuredAgentSessionHost } from '../native-chat/agent-session-wire/structured-agent-session-host'
+import { waitForStructuredAgentSessionRecovery } from './structured-agent-session-runtime'
+import { createScriptedClaudeRuntime } from './structured-claude-scripted-runtime-test-support'
+
+const SESSION = 'claude-send-restart-dies-first'
+const CALLER = { callerKey: 'client-1' }
+const DIAGNOSTIC = 'claude stream-json exited (code 1): claude: not signed in (rig)'
+
+let claude = createScriptedClaudeRuntime([SESSION])
+let operations = 0
+
+afterEach(async () => {
+  vi.restoreAllMocks()
+  await claude.dispose()
+  claude = createScriptedClaudeRuntime([SESSION])
+})
+
+function fence(host: StructuredAgentSessionHost): number {
+  return host.deps.store.getRecord(SESSION)?.lease.runtimeFence ?? 0
+}
+
+async function send(host: StructuredAgentSessionHost, text: string): Promise<string> {
+  const body = hostTestMessage(text)
+  const clientOperationId = `${Date.now()}-${(++operations).toString(16).padStart(32, '0')}`
+  const sent = await host.send(CALLER, {
+    envelope: {
+      sessionId: SESSION,
+      clientOperationId,
+      expectedRuntimeFence: fence(host),
+      payloadFingerprint: computeAgentSessionPayloadFingerprint({
+        method: 'agentSession.send',
+        sessionId: SESSION,
+        fields: { body }
+      })
+    },
+    body
+  })
+  expect(sent, JSON.stringify(sent)).toMatchObject({ ok: true, replayed: false })
+  return clientOperationId
+}
+
+function statusRows(host: StructuredAgentSessionHost): string[] {
+  return host
+    .journalSnapshot(SESSION)
+    .items.flatMap((item) => (item.body.kind === 'status' ? [item.body.text] : []))
+}
+
+function submission(host: StructuredAgentSessionHost, clientMessageId: string) {
+  return host
+    .journalSnapshot(SESSION)
+    .submissions.find((entry) => entry.clientMessageId === clientMessageId)
+}
+
+async function failLatestStart(host: StructuredAgentSessionHost, count: number): Promise<void> {
+  await vi.waitFor(() => expect(claude.children(SESSION)).toHaveLength(count))
+  claude.child(SESSION).exit(new Error(DIAGNOSTIC))
+  await waitForStructuredAgentSessionRecovery()
+  await vi.waitFor(() =>
+    expect(host.deps.store.getRecord(SESSION)?.lease.claimStatus).toBe('released')
+  )
+}
+
+/** The restarted child dies the instant the send's dispatch reaches the adapter. */
+function killChildAtDispatch(host: StructuredAgentSessionHost): void {
+  const adapter = host.deps.adapter
+  const dispatch = adapter.dispatch.bind(adapter)
+  vi.spyOn(adapter, 'dispatch').mockImplementationOnce((input) => {
+    claude.child(SESSION).exit(new Error(DIAGNOSTIC))
+    return dispatch(input)
+  })
+}
+
+/** Everything a subscriber received, flattened to the rows and submissions it was shown. */
+function received(events: AgentSessionSubscribeEvent[]) {
+  const statusTexts: string[] = []
+  const submissions = new Map<string, string>()
+  const fences: number[] = []
+  for (const event of events) {
+    if (event.type === 'end') {
+      continue
+    }
+    const page = event.type === 'batch' ? event.batch : event.page
+    for (const item of page.items) {
+      if (item.body.kind === 'status') {
+        statusTexts.push(item.body.text)
+      }
+    }
+    for (const entry of page.submissions) {
+      submissions.set(entry.clientMessageId, entry.dispatchState)
+    }
+    if (event.fence !== undefined) {
+      fences.push(event.fence)
+    }
+  }
+  return { statusTexts, submissions, fences }
+}
+
+describe('a send whose restarted Claude child dies before the dispatch reaches the adapter', () => {
+  it('settles rejected with the diagnostic, keeps one failure row, and a Retry is one new attempt', async () => {
+    claude.behave(SESSION, { initHangs: true })
+    const host = await claude.install()
+    await expect(host.attach(CALLER, claude.attachParams(SESSION, null))).resolves.toMatchObject({
+      ok: true
+    })
+    await failLatestStart(host, 1)
+    const releasedFence = fence(host)
+
+    killChildAtDispatch(host)
+    const sent = await send(host, 'hello?')
+    expect(claude.children(SESSION)).toHaveLength(2)
+    await waitForStructuredAgentSessionRecovery()
+    await vi.waitFor(() =>
+      expect(host.deps.store.getRecord(SESSION)?.lease.claimStatus).toBe('released')
+    )
+
+    // Provably not delivered, with the cause; not "unconfirmed".
+    await vi.waitFor(() =>
+      expect(submission(host, sent)).toMatchObject({
+        dispatchState: 'rejected',
+        reason: expect.stringContaining('not signed in (rig)')
+      })
+    )
+    expect(statusRows(host)).toEqual([
+      expect.stringContaining('not signed in'),
+      expect.stringMatching(/stopped before it finished starting: .*not signed in \(rig\)/)
+    ])
+    expect(fence(host)).toBe(releasedFence + 2)
+    expect(claude.children(SESSION)).toHaveLength(2)
+    expect(claude.child(SESSION).calls).not.toContain('send')
+
+    // Retry under a new id: one restart, and once the CLI is healthy the message is written.
+    claude.behave(SESSION, {})
+    await send(host, 'hello again')
+    expect(claude.children(SESSION)).toHaveLength(3)
+    await vi.waitFor(() => expect(claude.child(SESSION).calls).toContain('send'))
+    expect(claude.child(SESSION).calls.filter((call) => call === 'send')).toHaveLength(1)
+    expect(statusRows(host)).toHaveLength(2)
+  })
+
+  it('reaches a subscriber that was open across the restart and the exit', async () => {
+    claude.behave(SESSION, { initHangs: true })
+    const host = await claude.install()
+    await expect(host.attach(CALLER, claude.attachParams(SESSION, null))).resolves.toMatchObject({
+      ok: true
+    })
+    const events: AgentSessionSubscribeEvent[] = []
+    const unsubscribe = host.subscribe({
+      id: 'pane',
+      sessionId: SESSION,
+      emit: (event) => {
+        events.push(event)
+      }
+    })
+    try {
+      await failLatestStart(host, 1)
+      killChildAtDispatch(host)
+      const sent = await send(host, 'hello?')
+      await waitForStructuredAgentSessionRecovery()
+      await vi.waitFor(() =>
+        expect(host.deps.store.getRecord(SESSION)?.lease.claimStatus).toBe('released')
+      )
+
+      await vi.waitFor(() => {
+        const seen = received(events)
+        expect(seen.submissions.get(sent)).toBe('rejected')
+        expect(seen.statusTexts).toContainEqual(
+          expect.stringMatching(/stopped before it finished starting: .*not signed in \(rig\)/)
+        )
+        // The subscriber ended up on the fence the exit published, not the one the restart did.
+        expect(seen.fences.at(-1)).toBe(fence(host))
+      })
+    } finally {
+      unsubscribe()
+    }
+  })
+})

From c67badcab6f64ac035adceb23d0be40976d8424a Mon Sep 17 00:00:00 2001
From: Brennan Benson <79079362+brennanb2025@users.noreply.github.com>
Date: Wed, 23 Sep 2026 18:14:18 -0700
Subject: [PATCH 49/67] test(native-chat): expect a send held for a start that
 never proved itself to settle rejected

---
 ...-session-send-restarts-failed-start.test.ts | 18 +++++++++++++-----
 1 file changed, 13 insertions(+), 5 deletions(-)

diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-send-restarts-failed-start.test.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-send-restarts-failed-start.test.ts
index c89c21cec6cb..181b40660f8f 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-send-restarts-failed-start.test.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-send-restarts-failed-start.test.ts
@@ -5,7 +5,7 @@
 //
 // A child is published before it has proven its start, and it owns the send from that moment: the
 // message is admitted against it and the adapter holds it for the start. When the child exits
-// first, the exit settlement retires the message and writes the cause into the chat, once, and
+// first, the exit settlement rejects the message and writes the cause into the chat, once, and
 // the next send is a fresh restart.
 
 import { mkdtemp, rm } from 'node:fs/promises'
@@ -188,9 +188,13 @@ describe('a send into a published session whose child ended before startup', ()
     const held = await send('still not signed in', releasedFence)
     await exitBeforeProof()
 
-    // The exit retires the message this host admitted, so nothing pins the session, and one row
-    // in the chat names the cause.
-    expect(submission(held)).toMatchObject({ dispatchState: 'unknown', recovered: true })
+    // The child never proved its start, so it accepted nothing: the exit rejects the message this
+    // host admitted, so nothing pins the session and Retry stays offered, and one row names the cause.
+    expect(submission(held)).toMatchObject({
+      dispatchState: 'rejected',
+      reason: expect.stringContaining(EXIT_REASON),
+      recovered: true
+    })
     expect(
       host.journalSnapshot(SESSION).submissions.filter((e) => e.dispatchState === 'pending')
     ).toEqual([])
@@ -230,7 +234,11 @@ describe('a send while the child of the first start is still proving itself', ()
 
     await exitBeforeProof()
 
-    expect(submission(held)).toMatchObject({ dispatchState: 'unknown', recovered: true })
+    expect(submission(held)).toMatchObject({
+      dispatchState: 'rejected',
+      reason: expect.stringContaining(EXIT_REASON),
+      recovered: true
+    })
     expect(acquire).toHaveBeenCalledOnce()
     expect(journalStatuses()).toEqual([
       expect.stringMatching(/stopped before it finished starting: .*not signed in/)

From 238fa2275a673992df09a30907849619e427fe92 Mon Sep 17 00:00:00 2001
From: Brennan Benson <79079362+brennanb2025@users.noreply.github.com>
Date: Wed, 23 Sep 2026 18:14:24 -0700
Subject: [PATCH 50/67] fix(claude): write a prompt held after startup already
 drained, instead of stranding it pending

---
 .../claude-structured-session-startup-gate.ts |  9 +++++++++
 .../claude-structured-session-startup.test.ts | 19 +++++++++++++++++++
 2 files changed, 28 insertions(+)

diff --git a/src/main/claude/claude-structured-session-startup-gate.ts b/src/main/claude/claude-structured-session-startup-gate.ts
index e8739f933dd1..af169b5c4908 100644
--- a/src/main/claude/claude-structured-session-startup-gate.ts
+++ b/src/main/claude/claude-structured-session-startup-gate.ts
@@ -80,6 +80,10 @@ export async function holdClaudeStartupWrite(
     message: input.message,
     ...(input.settleLate ? { settleLate: input.settleLate } : {})
   })
+  // Startup finished writing what it held while the barrier ran; nothing else would drain this.
+  if (!claudeStartupHoldsWrites(session)) {
+    void drainClaudeStartupWrites(session)
+  }
   return { state: 'admitted' }
 }
 
@@ -89,6 +93,11 @@ export async function openClaudeStartupGate(session: ClaudeSession): Promise<voi
     return
   }
   gate.state = 'proven'
+  await drainClaudeStartupWrites(session)
+}
+
+async function drainClaudeStartupWrites(session: ClaudeSession): Promise<void> {
+  const gate = session.startup
   gate.draining = true
   try {
     for (let held = gate.held.shift(); held; held = gate.held.shift()) {
diff --git a/src/main/claude/claude-structured-session-startup.test.ts b/src/main/claude/claude-structured-session-startup.test.ts
index 37e9f9fc3de9..32d1aac3bb23 100644
--- a/src/main/claude/claude-structured-session-startup.test.ts
+++ b/src/main/claude/claude-structured-session-startup.test.ts
@@ -113,6 +113,25 @@ describe('Claude structured session publishes before the CLI answers initialize'
     await adapter.closeAll()
   })
 
+  it('writes a prompt whose admission barrier was still running when startup landed', async () => {
+    const claude = fakeClaude({ initDelayMs: SLOW_INIT_MS })
+    const { adapter } = startingAdapter(claude)
+    await adapter.acquire(ACQUIRE)
+    let passBarrier = (): void => {}
+    const barrier = new Promise<void>((resolve) => {
+      passBarrier = resolve
+    })
+
+    const dispatched = adapter.dispatch({ ...PROMPT, beforeDispatch: () => barrier })
+    await vi.advanceTimersByTimeAsync(SLOW_INIT_MS)
+    await adapter.drainStartup('session-1')
+    passBarrier()
+
+    await expect(dispatched).resolves.toEqual({ state: 'admitted' })
+    expect(claude.connections[0].sent.filter((message) => message.type === 'user')).toHaveLength(1)
+    await adapter.closeAll()
+  })
+
   it('ends the session with the exit reason when the CLI dies before init, and rejects held prompts', async () => {
     const claude = fakeClaude({
       initDelayMs: SLOW_INIT_MS,

From 77e38e074e19fad635687f4d5f003a23bdf9e58a Mon Sep 17 00:00:00 2001
From: Brennan Benson <79079362+brennanb2025@users.noreply.github.com>
Date: Wed, 23 Sep 2026 18:16:34 -0700
Subject: [PATCH 51/67] test(native-chat): pin that a send to a child that died
 before starting is answered rejected

---
 ...de-structured-send-restart-dies-before-dispatch.test.ts | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/src/main/runtime/claude-structured-send-restart-dies-before-dispatch.test.ts b/src/main/runtime/claude-structured-send-restart-dies-before-dispatch.test.ts
index e90c553679f8..79ef4caa02e3 100644
--- a/src/main/runtime/claude-structured-send-restart-dies-before-dispatch.test.ts
+++ b/src/main/runtime/claude-structured-send-restart-dies-before-dispatch.test.ts
@@ -20,6 +20,8 @@ const DIAGNOSTIC = 'claude stream-json exited (code 1): claude: not signed in (r
 
 let claude = createScriptedClaudeRuntime([SESSION])
 let operations = 0
+/** The dispatch state each send was answered with, before any exit settled it. */
+const answered = new Map<string, string>()
 
 afterEach(async () => {
   vi.restoreAllMocks()
@@ -48,6 +50,9 @@ async function send(host: StructuredAgentSessionHost, text: string): Promise<str
     body
   })
   expect(sent, JSON.stringify(sent)).toMatchObject({ ok: true, replayed: false })
+  if (sent.ok) {
+    answered.set(clientOperationId, sent.value.submission.dispatchState)
+  }
   return clientOperationId
 }
 
@@ -119,6 +124,8 @@ describe('a send whose restarted Claude child dies before the dispatch reaches t
 
     killChildAtDispatch(host)
     const sent = await send(host, 'hello?')
+    // The send's own answer already says it was not delivered; it does not wait for the exit.
+    expect(answered.get(sent)).toBe('rejected')
     expect(claude.children(SESSION)).toHaveLength(2)
     await waitForStructuredAgentSessionRecovery()
     await vi.waitFor(() =>

From 501b901b9136b3b4e9fa144b59fefd7ed73e299c Mon Sep 17 00:00:00 2001
From: Brennan Benson <79079362+brennanb2025@users.noreply.github.com>
Date: Wed, 23 Sep 2026 18:17:49 -0700
Subject: [PATCH 52/67] test(native-chat): leave the cast exit-session fixtures
 as they were, since a proven exit never rejects

---
 .../structured-agent-session-unexpected-exit.test.ts        | 6 ++----
 1 file changed, 2 insertions(+), 4 deletions(-)

diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-unexpected-exit.test.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-unexpected-exit.test.ts
index f844dc9639cf..e864a1bc22b5 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-unexpected-exit.test.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-unexpected-exit.test.ts
@@ -136,8 +136,7 @@ describe('provider-exit recovery tickets', () => {
           items: [lifecycleItem('turn-1', 1, { state: 'running', startedAt: 1_000 })]
         }),
         appendLifecycleBatch,
-        markPendingSubmissionsUnknown: vi.fn(async () => []),
-        rejectPendingSubmissions: vi.fn(async () => [])
+        markPendingSubmissionsUnknown: vi.fn(async () => [])
       }
     } as unknown as StructuredAgentSessionHostSession
 
@@ -205,8 +204,7 @@ describe('provider-exit recovery tickets', () => {
       journal: {
         snapshot: () => ({ items }),
         appendLifecycleBatch,
-        markPendingSubmissionsUnknown: vi.fn(async () => []),
-        rejectPendingSubmissions: vi.fn(async () => [])
+        markPendingSubmissionsUnknown: vi.fn(async () => [])
       }
     } as unknown as StructuredAgentSessionHostSession
     const store = {

From dcdee460198b39cef9faf14677bb10d024676011 Mon Sep 17 00:00:00 2001
From: Brennan Benson <79079362+brennanb2025@users.noreply.github.com>
Date: Wed, 23 Sep 2026 18:43:57 -0700
Subject: [PATCH 53/67] fix(claude): a saved option the CLI never answered
 stays saved instead of being replaced by the CLI's value

A start skips an option write the CLI does not answer within the request
deadline, and then persisted what the CLI reported in its place, so a slow
answer silently replaced the user's saved model or dropped their saved
permission mode. Silence is not a refusal: the unanswered option is now
recorded apart from a rejected one, the live child keeps running on the
CLI's value, and the saved choice stays on the record for the next start to
retry. An option the CLI rejects is still dropped as before.
---
 ...claude-structured-dispatch-test-support.ts |  1 +
 .../claude/claude-structured-options.test.ts  |  6 +++--
 src/main/claude/claude-structured-options.ts  |  6 ++++-
 .../claude-structured-session-publication.ts  |  1 +
 .../claude-structured-session-startup.test.ts |  3 ++-
 .../claude-structured-session-startup.ts      |  5 ++--
 .../claude/claude-structured-session-state.ts |  2 ++
 .../structured-agent-session-adapter.ts       |  2 ++
 ...ctured-agent-session-option-restoration.ts | 12 ++++++++--
 ...ructured-agent-session-provider-started.ts |  3 +++
 ...startup-unanswered-control-request.test.ts | 24 ++++++++++++-------
 11 files changed, 48 insertions(+), 17 deletions(-)

diff --git a/src/main/claude/claude-structured-dispatch-test-support.ts b/src/main/claude/claude-structured-dispatch-test-support.ts
index 854d4be96203..2bc81a50082b 100644
--- a/src/main/claude/claude-structured-dispatch-test-support.ts
+++ b/src/main/claude/claude-structured-dispatch-test-support.ts
@@ -27,6 +27,7 @@ export function sessionFor(send: Mock = vi.fn().mockResolvedValue(undefined)): C
     reportedModelMutation: 0,
     confirmedOptions: new Set(),
     restoreSkippedOptions: new Set(),
+    restoreUnansweredOptions: new Set(),
     capabilities: [],
     events: undefined,
     translator: null,
diff --git a/src/main/claude/claude-structured-options.test.ts b/src/main/claude/claude-structured-options.test.ts
index 59f1193eee5c..7e7dc51869ce 100644
--- a/src/main/claude/claude-structured-options.test.ts
+++ b/src/main/claude/claude-structured-options.test.ts
@@ -39,6 +39,7 @@ function sessionFor(setModel: ClaudeSession['connection']['setModel']): ClaudeSe
     reportedModelMutation: 0,
     confirmedOptions: new Set(),
     restoreSkippedOptions: new Set(),
+    restoreUnansweredOptions: new Set(),
     capabilities: [],
     events: undefined,
     translator: null,
@@ -442,7 +443,7 @@ describe('Claude Fast mode reported by the session frame alone', () => {
 })
 
 describe('Claude structured option restore under the request deadline', () => {
-  it('skips a write the CLI never answered and finishes the restore', async () => {
+  it('skips a write the CLI never answered and finishes the restore, keeping it unanswered rather than refused', async () => {
     const session = sessionFor(async () => {
       throw new ClaudeControlRequestTimeoutError('set_model')
     })
@@ -451,7 +452,8 @@ describe('Claude structured option restore under the request deadline', () => {
 
     await expect(restoreClaudeStructuredSessionOptions(session, 10)).resolves.toBeUndefined()
 
-    expect([...session.restoreSkippedOptions]).toEqual(['model'])
+    expect([...session.restoreUnansweredOptions]).toEqual(['model'])
+    expect([...session.restoreSkippedOptions]).toEqual([])
     expect(session.options.has('model')).toBe(false)
   })
 
diff --git a/src/main/claude/claude-structured-options.ts b/src/main/claude/claude-structured-options.ts
index 57496dd38433..d1d0333de133 100644
--- a/src/main/claude/claude-structured-options.ts
+++ b/src/main/claude/claude-structured-options.ts
@@ -244,11 +244,15 @@ export async function restoreClaudeStructuredSessionOptions(
       // A write the CLI never answered is skipped the same way: startup has no deadline of its
       // own, and a slow control answer must not fault a session whose child is otherwise fine.
       // The child's current value stands, and the user can set the option again.
+      // Silence is not a refusal: the saved choice stays saved and the next start retries it.
       if (error instanceof ClaudeControlRequestTimeoutError) {
         console.warn(
           `[claude-structured] restore of ${key} for ${session.providerSessionId} was not answered in time; keeping the CLI's value`
         )
-      } else if (!isAgentSessionOptionRejectedError(error)) {
+        session.restoreUnansweredOptions.add(key)
+        continue
+      }
+      if (!isAgentSessionOptionRejectedError(error)) {
         throw error
       }
       // A stale or unavailable preference must not poison every future acquire;
diff --git a/src/main/claude/claude-structured-session-publication.ts b/src/main/claude/claude-structured-session-publication.ts
index 0ae9e9a8e5e1..6264648e98b8 100644
--- a/src/main/claude/claude-structured-session-publication.ts
+++ b/src/main/claude/claude-structured-session-publication.ts
@@ -61,6 +61,7 @@ export function createClaudeSessionPublication(input: {
       reportedModelMutation: 0,
       confirmedOptions: new Set(),
       restoreSkippedOptions: new Set(),
+      restoreUnansweredOptions: new Set(),
       translator: input.translator,
       events: input.events,
       ...(input.unbindReadingControl ? { unbindReadingControl: input.unbindReadingControl } : {}),
diff --git a/src/main/claude/claude-structured-session-startup.test.ts b/src/main/claude/claude-structured-session-startup.test.ts
index 32d1aac3bb23..96d714fdf65d 100644
--- a/src/main/claude/claude-structured-session-startup.test.ts
+++ b/src/main/claude/claude-structured-session-startup.test.ts
@@ -88,7 +88,8 @@ describe('Claude structured session publishes before the CLI answers initialize'
       acquisitionGeneration: expect.any(String),
       // What the restore just proved, carried so the host never asks the CLI again.
       reportedOptions: expect.objectContaining({ model: 'opus' }),
-      restoreSkippedOptions: []
+      restoreSkippedOptions: [],
+      restoreUnansweredOptions: []
     })
     // The restore wrote the saved model before `started`, and the held prompt only after it.
     expect(order).toEqual(['set_model'])
diff --git a/src/main/claude/claude-structured-session-startup.ts b/src/main/claude/claude-structured-session-startup.ts
index 6250e851912b..0ddfc94cc4ca 100644
--- a/src/main/claude/claude-structured-session-startup.ts
+++ b/src/main/claude/claude-structured-session-startup.ts
@@ -51,7 +51,7 @@ export function createClaudeInitProof(): ClaudeInitProof {
 
 export type StructuredAgentSessionStartedOptions = Pick<
   StructuredAgentSessionStartedEvent,
-  'reportedOptions' | 'restoreSkippedOptions'
+  'reportedOptions' | 'restoreSkippedOptions' | 'restoreUnansweredOptions'
 >
 
 export type ClaudeStartupFacts = {
@@ -184,7 +184,8 @@ export async function settleClaudeSessionStartup(input: {
           session,
           readClaudeModels(facts.initialization)
         ).current,
-        restoreSkippedOptions: [...session.restoreSkippedOptions]
+        restoreSkippedOptions: [...session.restoreSkippedOptions],
+        restoreUnansweredOptions: [...session.restoreUnansweredOptions]
       })
       await openClaudeStartupGate(session)
     }
diff --git a/src/main/claude/claude-structured-session-state.ts b/src/main/claude/claude-structured-session-state.ts
index 9e04e439e1da..a4ae7ee70c0e 100644
--- a/src/main/claude/claude-structured-session-state.ts
+++ b/src/main/claude/claude-structured-session-state.ts
@@ -155,6 +155,8 @@ export type ClaudeSession = {
   /** Options whose recorded value the provider reported, not merely accepted. */
   confirmedOptions: Set<string>
   restoreSkippedOptions: Set<string>
+  /** Saved options whose restore write the CLI never answered; the saved choice is kept. */
+  restoreUnansweredOptions: Set<string>
   /** CLI-advertised protocol capabilities from init; gates interrupt-receipt handling. */
   capabilities: readonly string[]
   backgroundTasks: ClaudeBackgroundTaskTracker
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-adapter.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-adapter.ts
index bdc7dd27d7c7..068091ae979a 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-adapter.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-adapter.ts
@@ -153,6 +153,8 @@ export type StructuredAgentSessionStartedEvent = {
   reportedOptions: AgentSessionOptionsResult['current']
   /** Saved options the restore could not apply; the host drops them rather than persist them. */
   restoreSkippedOptions: readonly string[]
+  /** Saved options the CLI never answered a restore write for; the host keeps the saved value. */
+  restoreUnansweredOptions?: readonly string[]
 }
 
 export type StructuredAgentSessionLifecycleEvent =
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-option-restoration.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-option-restoration.ts
index d3461a7e9ee3..aeaf76d41148 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-option-restoration.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-option-restoration.ts
@@ -21,10 +21,12 @@ export async function readNativeSessionOptions(input: {
 }
 
 /** The record's options once the provider has reported: its model, effort and Fast replace the
- *  saved ones, other saved options stay, and any the restore could not apply are dropped. */
+ *  saved ones, other saved options stay, and any the restore could not apply are dropped. A
+ *  restore write the provider never answered proves nothing, so that saved choice is kept. */
 export function nativeSessionOptionsFromReport(input: {
   reported: AgentSessionOptionsResult['current']
   restoreSkipped: readonly string[]
+  restoreUnanswered?: readonly string[]
   priorOptions?: Readonly<Record<string, string>>
 }): Readonly<Record<string, string>> {
   const { reported, priorOptions } = input
@@ -39,10 +41,16 @@ export function nativeSessionOptionsFromReport(input: {
     reported.fastMode === undefined
       ? undefined
       : encodeStructuredAgentSessionOptionValue('fastMode', reported.fastMode)
+  const kept = Object.fromEntries(
+    (input.restoreUnanswered ?? []).flatMap((key) =>
+      priorOptions?.[key] === undefined ? [] : [[key, priorOptions[key]]]
+    )
+  )
   return {
     ...restored,
     model: reported.model,
     ...(reported.effort ? { effort: reported.effort } : {}),
-    ...(fastMode !== undefined && fastMode !== null ? { fastMode } : {})
+    ...(fastMode !== undefined && fastMode !== null ? { fastMode } : {}),
+    ...kept
   }
 }
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-provider-started.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-provider-started.ts
index 55c718f967b9..09dba75a243c 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-provider-started.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-provider-started.ts
@@ -74,6 +74,9 @@ async function persistStartedOptions(
     options: nativeSessionOptionsFromReport({
       reported: event.reportedOptions,
       restoreSkipped: event.restoreSkippedOptions,
+      ...(event.restoreUnansweredOptions
+        ? { restoreUnanswered: event.restoreUnansweredOptions }
+        : {}),
       ...(record.options ? { priorOptions: record.options } : {})
     }),
     now: context.now()
diff --git a/src/main/runtime/claude-structured-startup-unanswered-control-request.test.ts b/src/main/runtime/claude-structured-startup-unanswered-control-request.test.ts
index f1c9c222b020..8053eb3e2da1 100644
--- a/src/main/runtime/claude-structured-startup-unanswered-control-request.test.ts
+++ b/src/main/runtime/claude-structured-startup-unanswered-control-request.test.ts
@@ -2,7 +2,8 @@
 // startup's own settings read, is a control request under the ordinary request deadline. A CLI
 // that answers initialize and then never answers one of those used to fault the whole session
 // when that deadline fired: a start that was merely slow died with the deadline's error as its
-// cause. Now the unanswered request is skipped and startup lands on the CLI's own values. Against
+// cause. Now the unanswered request is skipped and startup lands on the CLI's own values, while
+// the saved choice stays saved for the next start to retry. Against
 // the production runtime, adapter, record store and host, with only the CLI process scripted.
 
 import { afterEach, describe, expect, it, vi } from 'vitest'
@@ -53,22 +54,27 @@ async function send(host: StructuredAgentSessionHost, text: string): Promise<voi
 }
 
 describe('a Claude start whose CLI answers initialize but not a control request', () => {
-  it('lands with the unanswered option write skipped, keeping the CLI value, instead of faulting at the deadline', async () => {
+  it('lands with the unanswered option write skipped instead of faulting at the deadline, and keeps the saved choice', async () => {
     claude.behave(SESSION, { optionWritesHang: true, controlTimeoutMs: DEADLINE_MS })
     vi.spyOn(console, 'warn').mockImplementation(() => {})
     const host = await claude.install()
+    const saved = { model: 'sonnet', permissionMode: 'plan' }
     await expect(
-      host.attach(CALLER, claude.attachParams(SESSION, null, { options: { model: 'sonnet' } }))
+      host.attach(CALLER, claude.attachParams(SESSION, null, { options: saved }))
     ).resolves.toMatchObject({ ok: true })
 
     // The restore asked; the CLI never answered; startup went on without it.
     await vi.waitFor(() => expect(claude.child(SESSION).calls).toContain('set_model'))
-    await vi.waitFor(
-      () => expect(record(host)?.options).toEqual({ model: 'claude-sonnet-5', effort: 'high' }),
-      { timeout: DEADLINE_MS * 40 }
-    )
-    expect(host.deps.adapter.readOptionRestoreFailures?.(SESSION)).toEqual(['model'])
-    expect(record(host)?.lease.claimStatus).toBe('live')
+    await vi.waitFor(() => expect(claude.child(SESSION).calls).toContain('set_permission_mode'))
+    await vi.waitFor(() => expect(record(host)?.lease.claimStatus).toBe('live'), {
+      timeout: DEADLINE_MS * 40
+    })
+    // The live child runs on the CLI's own model; silence is not a refusal, so the saved
+    // choice is neither replaced by that value nor dropped, and the next start retries it.
+    await vi.waitFor(() => expect(record(host)?.options).toEqual({ ...saved, effort: 'high' }), {
+      timeout: DEADLINE_MS * 40
+    })
+    expect(host.deps.adapter.readOptionRestoreFailures?.(SESSION)).toEqual([])
     expect(statusRows(host)).toEqual([])
     expect(claude.children(SESSION)).toHaveLength(1)
 

From 26453aa544cde9a5d4e7244d2b31f43eddc231b9 Mon Sep 17 00:00:00 2001
From: Brennan Benson <79079362+brennanb2025@users.noreply.github.com>
Date: Wed, 23 Sep 2026 19:06:23 -0700
Subject: [PATCH 54/67] fix(native-chat): a rejected send opens no turn, so the
 row naming why it failed is not folded away

A send whose restarted child died before starting is rejected, and the
exit writes a row naming the cause. The chat's local clock had watched the
send go pending and stop, so it gave the message "Worked for 0s"; that
settled a turn that never ran, and the fold hid every non-prose row after
the message behind it, including the one naming the cause. The row only
appeared when a later send moved the turn anchor, which read as two rows
for one Retry. The host's journal already says the send was rejected; it
now answers that such a message opened no turn, which outranks the local
clock on desktop and mobile alike. A rejected send whose journal does
record a turn keeps its duration.
---
 .../native-chat-transcript-slots.test.ts      | 49 ++++++++++++++++++-
 ...ructured-agent-session-turn-timing.test.ts | 43 ++++++++++++++++
 .../structured-agent-session-turn-timing.ts   |  9 +++-
 3 files changed, 99 insertions(+), 2 deletions(-)

diff --git a/src/renderer/src/components/native-chat/native-chat-transcript-slots.test.ts b/src/renderer/src/components/native-chat/native-chat-transcript-slots.test.ts
index 7c665ab6804a..ecb6a183f4ea 100644
--- a/src/renderer/src/components/native-chat/native-chat-transcript-slots.test.ts
+++ b/src/renderer/src/components/native-chat/native-chat-transcript-slots.test.ts
@@ -1,6 +1,10 @@
 import { describe, expect, it } from 'vitest'
 import type { NativeChatMessage } from '../../../../shared/native-chat-types'
-import type { NativeChatTurnStatus } from '../../../../shared/native-chat-turn-status'
+import {
+  selectNativeChatTurnStatuses,
+  type NativeChatTurnStatus
+} from '../../../../shared/native-chat-turn-status'
+import { selectStructuredAgentSettledTurns } from '../../../../shared/structured-agent-session-turn-timing'
 import type { NativeChatResolvedPrompt } from './native-chat-resolution-receipt'
 import type { NativeChatTurnDiff } from './native-chat-turn-diffs'
 import {
@@ -158,3 +162,46 @@ describe('transcript slots', () => {
     expect(nativeChatSlotIndexOf(slots, undefined)).toBe(-1)
   })
 })
+
+describe('a send the host rejected', () => {
+  const DIAGNOSTIC =
+    'The provider stopped before it finished starting: claude stream-json exited (code 1): claude: not signed in.'
+
+  // The restarted child died before starting, so the send was rejected and the exit wrote why.
+  // The local clock had watched the send go pending and stop; that must not settle a turn that
+  // never ran and fold the one row naming the cause behind a "Worked for 0s".
+  it('leaves the row naming the cause on screen', () => {
+    const messages = [
+      text('orca:first-start', DIAGNOSTIC, 'system'),
+      text('orca:dead', 'Reply with exactly: DEAD', 'user'),
+      text('orca:restart-exit', DIAGNOSTIC, 'system')
+    ]
+    const settledByTurn = selectStructuredAgentSettledTurns(
+      [],
+      [
+        {
+          clientMessageId: 'dead',
+          fence: 5,
+          payloadFingerprint: 'fp',
+          dispatchState: 'rejected',
+          providerItemId: null,
+          reason: 'provider_write_failed: claude: not signed in',
+          submittedAt: 1,
+          resolvedAt: 2
+        }
+      ]
+    )
+    const turnStatuses = selectNativeChatTurnStatuses(
+      { 'orca:dead': { startedAt: 900, workedSeconds: 0 } },
+      { activeTurnKey: 'orca:dead', isWorking: false, thinking: false, settledByTurn }
+    )
+
+    const slots = build(messages, { turnStatuses })
+
+    expect(slots.map((slot) => [slot.message.id, slot.folded, slot.status])).toEqual([
+      ['orca:first-start', false, undefined],
+      ['orca:dead', false, undefined],
+      ['orca:restart-exit', false, undefined]
+    ])
+  })
+})
diff --git a/src/shared/structured-agent-session-turn-timing.test.ts b/src/shared/structured-agent-session-turn-timing.test.ts
index ad727e37c8e3..ba9af94258ff 100644
--- a/src/shared/structured-agent-session-turn-timing.test.ts
+++ b/src/shared/structured-agent-session-turn-timing.test.ts
@@ -338,3 +338,46 @@ describe('structuredAgentTurnLocalStartedAt with the host clock', () => {
     expect(structuredAgentTurnLocalStartedAt(timing, 3_600_000, 40_000)).toBe(3_600_000)
   })
 })
+
+describe('a rejected send', () => {
+  const rejected = (clientMessageId: string) => ({
+    clientMessageId,
+    fence: 5,
+    payloadFingerprint: 'fp',
+    dispatchState: 'rejected' as const,
+    providerItemId: null,
+    reason: 'provider_write_failed: claude: not signed in',
+    submittedAt: 1,
+    resolvedAt: 2
+  })
+
+  // The local clock saw the send go pending and stop, which would read as "Worked for 0s"; the
+  // host says the provider never got the message, so no turn ran and nothing may fold under it.
+  it('opened no turn, whatever the local clock observed', () => {
+    const settled = selectStructuredAgentSettledTurns([user('orca:dead')], [rejected('dead')])
+    expect(settled.get('orca:dead')).toBeNull()
+
+    const statuses = selectNativeChatTurnStatuses(
+      { 'orca:dead': { startedAt: 900, workedSeconds: 0 } },
+      { activeTurnKey: 'orca:dead', isWorking: false, thinking: false, settledByTurn: settled }
+    )
+    expect(statuses.completedByTurn['orca:dead']).toBeUndefined()
+    expect(statuses.active).toBeNull()
+  })
+
+  it('keeps the duration of a turn the journal does record for it', () => {
+    const settled = selectStructuredAgentSettledTurns(
+      [
+        user('orca:ran'),
+        lifecycle('t1', {
+          state: 'interrupted',
+          userItemId: 'orca:ran',
+          startedAt: 10_000,
+          completedAt: 14_000
+        })
+      ],
+      [rejected('ran')]
+    )
+    expect(settled.get('orca:ran')).toEqual({ startedAt: 10_000, workedSeconds: 4 })
+  })
+})
diff --git a/src/shared/structured-agent-session-turn-timing.ts b/src/shared/structured-agent-session-turn-timing.ts
index e8dc89750dec..3f480013886d 100644
--- a/src/shared/structured-agent-session-turn-timing.ts
+++ b/src/shared/structured-agent-session-turn-timing.ts
@@ -165,7 +165,8 @@ export function structuredAgentTurnLocalStartedAt(
 /** What a chat surface hands to the shared turn-status selector: every turn the
  *  host recorded, with its duration or null. A null still outranks the local
  *  clock, so a turn whose end the host never observed shows no duration on the
- *  surface that watched it, exactly as it will after a reload. */
+ *  surface that watched it, exactly as it will after a reload. A rejected send
+ *  never reached the provider, so it opened no turn and its message shows none. */
 export function selectStructuredAgentSettledTurns(
   items: readonly AgentJournalRenderItem[],
   submissions: readonly AgentJournalSubmission[] = []
@@ -180,5 +181,11 @@ export function selectStructuredAgentSettledTurns(
         : { startedAt: timing.startedAt, workedSeconds }
     )
   }
+  for (const submission of submissions) {
+    const userItemId = agentJournalSubmissionKey(submission.clientMessageId)
+    if (submission.dispatchState === 'rejected' && !settled.has(userItemId)) {
+      settled.set(userItemId, null)
+    }
+  }
   return settled
 }

From f8bee36b15db5cfdbd3790d3f8b405d696fce41d Mon Sep 17 00:00:00 2001
From: Brennan Benson <79079362+brennanb2025@users.noreply.github.com>
Date: Wed, 23 Sep 2026 19:11:28 -0700
Subject: [PATCH 55/67] fix(native-chat): a send whose restart died starting
 leaves the same row as any start that died

One failed attempt already leaves one row, but which row depended on when
the child died. A child that died after the send was admitted left "The
provider stopped before it finished starting: <cause>."; one that died
before the send was admitted left "Claude couldn't restart: <cause>." So the
same failure read two ways from one Retry to the next. When the refused
restart proved its child exited, the send now writes the startup-failure row
itself, as its comment always said it did. The refusal under the composer
still says the restart failed; a restart that failed for a reason other than
a child exiting keeps its own wording.
---
 ...uctured-agent-session-send-preparation.test.ts |  4 +++-
 .../structured-agent-session-send-preparation.ts  | 15 +++++++++++++--
 2 files changed, 16 insertions(+), 3 deletions(-)

diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-send-preparation.test.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-send-preparation.test.ts
index 1d0dd7bffec0..a467a318c808 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-send-preparation.test.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-send-preparation.test.ts
@@ -415,7 +415,9 @@ describe('a send with no live owner', () => {
     // Refused before admission: the ledger holds nothing a resend would replay.
     expect(store.getOperationRow(CALLER.callerKey, params.envelope.clientOperationId)).toBeNull()
     // The same status row a failed start leaves, so the reason outlives the error strip.
-    expect(journalStatuses()).toEqual(["Codex couldn't restart: Not signed in. Run codex login."])
+    expect(journalStatuses()).toEqual([
+      'The provider stopped before it finished starting: Not signed in. Run codex login.'
+    ])
   })
 
   it('restarts again for a Retry of the refused send, under its own id or a new one', async () => {
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-send-preparation.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-send-preparation.ts
index 0528ae1cda63..e4a332f7acf8 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-send-preparation.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-send-preparation.ts
@@ -32,7 +32,10 @@ import type {
 import type { AgentSessionWireRefusalCode } from '../../../shared/agent-session-wire-refusals'
 import { boundJournalStatusText } from '../agent-session-journal/journal-prompt-body-bounds'
 import { TUI_AGENT_DISPLAY_NAMES } from '../../../shared/tui-agent-display-names'
-import { ownerRestartFailedOutcome } from './structured-agent-session-dead-generation-settlement'
+import {
+  ownerRestartFailedOutcome,
+  providerStartupFailureOutcome
+} from './structured-agent-session-dead-generation-settlement'
 import type { StructuredAgentSessionHostSession } from './structured-agent-session-host-types'
 import type { StructuredAgentSessionMutationContext } from './structured-agent-session-host-mutations'
 import type { AgentSessionMutationSessionPreparation } from './structured-agent-session-mutation-admission'
@@ -161,7 +164,15 @@ async function restartOwnerForSend(
     sessionId,
     error: new Error(`${resumed.refusal.code}: ${resumed.refusal.message}`)
   })
-  await recordFailedRestart(context, envelope, refusal.message)
+  // A restart whose child died starting leaves the row any start that died leaves, so the chat
+  // reads the same whether the send met that death before admission or after it.
+  await recordFailedRestart(
+    context,
+    envelope,
+    resumed.refusal.ownerVerdict === 'exited'
+      ? providerStartupFailureOutcome(resumed.refusal.message)
+      : refusal.message
+  )
   return refusal
 }
 

From 6349aee4ff8d93929ddc2c6c6889bf5371cb2434 Mon Sep 17 00:00:00 2001
From: Brennan Benson <79079362+brennanb2025@users.noreply.github.com>
Date: Wed, 23 Sep 2026 19:12:06 -0700
Subject: [PATCH 56/67] fix(native-chat): a send rejected because the agent
 never started names the cause under the composer

When the child a send was admitted against died before starting, the host
rejected the send with the child's diagnostic behind the internal transport
marker. The client rightly hides that marker's detail, so the red line read
"Couldn't reach the agent" while the cause sat in the record. A startup
death is not a failed write: the host now words that rejection the way the
chat row does, "The provider stopped before it finished starting: <cause>.",
at every site that rejects for it. Desktop and mobile show a reason in words
verbatim already, and older clients do too, so no client change is needed.
Real write failures keep the marker and the generic copy.
---
 .../claude-structured-session-startup-gate.ts |   5 +-
 ...gent-session-dead-generation-settlement.ts |  11 +-
 .../structured-agent-session-turns.ts         |   4 +-
 ...e-structured-send-held-for-startup.test.ts |   6 +-
 ...-send-restart-dies-before-dispatch.test.ts | 106 +++++++++++++++++-
 ...nt-session-outbox-rejection-cause.test.tsx |  71 ++++++++++++
 ...red-agent-session-send-disposition.test.ts |   7 ++
 7 files changed, 201 insertions(+), 9 deletions(-)
 create mode 100644 src/renderer/src/components/native-chat/use-structured-agent-session-outbox-rejection-cause.test.tsx

diff --git a/src/main/claude/claude-structured-session-startup-gate.ts b/src/main/claude/claude-structured-session-startup-gate.ts
index af169b5c4908..020d625b5257 100644
--- a/src/main/claude/claude-structured-session-startup-gate.ts
+++ b/src/main/claude/claude-structured-session-startup-gate.ts
@@ -7,6 +7,7 @@
 import type { AgentSessionDispatchOutcome } from '../native-chat/agent-session-wire/structured-agent-session-adapter'
 import { AgentSessionPreDispatchError } from '../native-chat/agent-session-wire/structured-agent-session-operation-settlement'
 import { dispatchWriteFailureReason } from '../../shared/structured-agent-session-dispatch-rejection'
+import { providerStartupFailureRejection } from '../native-chat/agent-session-wire/structured-agent-session-dead-generation-settlement'
 import { claudeUserMessageWasProvablyUnwritten } from './claude-agent-sdk-user-message-queue'
 import {
   forgetRetiredWaiter,
@@ -41,7 +42,7 @@ export function createClaudeSessionStartupGate(): ClaudeSessionStartupGate {
 
 export function claudeStartupFailureReason(session: ClaudeSession): string | null {
   return session.startup.state === 'failed'
-    ? dispatchWriteFailureReason(session.startup.failure ?? new Error('claude startup failed'))
+    ? providerStartupFailureRejection(session.startup.failure ?? undefined)
     : null
 }
 
@@ -150,5 +151,5 @@ export function failClaudeStartupGate(session: ClaudeSession, error: Error): voi
     gate.state = 'failed'
     gate.failure = error
   }
-  rejectClaudeStartupWrites(session, dispatchWriteFailureReason(error))
+  rejectClaudeStartupWrites(session, providerStartupFailureRejection(error))
 }
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-dead-generation-settlement.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-dead-generation-settlement.ts
index 6d360e38771b..1b5f73fdbdae 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-dead-generation-settlement.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-dead-generation-settlement.ts
@@ -4,7 +4,6 @@ import type {
   AgentJournalRenderItem
 } from '../../../shared/agent-session-journal-types'
 import { readAgentJournalTurn } from '../../../shared/agent-session-turn-record'
-import { dispatchWriteFailureReason } from '../../../shared/structured-agent-session-dispatch-rejection'
 import { partitionJournalLifecycleMutations } from '../agent-session-journal/journal-lifecycle-batch-partition'
 import type { JournalLifecycleMutationInput } from '../agent-session-journal/journal-row-builders'
 import {
@@ -56,6 +55,14 @@ export function providerStartupFailureOutcome(reason?: string): string {
     : 'The provider stopped before it finished starting.'
 }
 
+/** Why a send a child that never started left unwritten was rejected. The child's own diagnostic is
+ *  the cause the user can act on, so it is the reason, in the words the chat row uses. */
+export function providerStartupFailureRejection(cause?: unknown): string {
+  return providerStartupFailureOutcome(
+    cause === undefined ? undefined : cause instanceof Error ? cause.message : String(cause)
+  )
+}
+
 function exitReasonDetail(reason: string | undefined): string | undefined {
   return reason
     ?.slice(0, MAX_UNEXPECTED_EXIT_REASON_CHARS)
@@ -151,7 +158,7 @@ export async function settleStructuredAgentSessionDeadGeneration(input: {
     await (input.exitedDuringStartup
       ? input.journal.rejectPendingSubmissions(
           input.fence,
-          dispatchWriteFailureReason(input.unexpectedExitReason ?? input.pendingSubmissionReason)
+          providerStartupFailureRejection(input.unexpectedExitReason)
         )
       : input.journal.markPendingSubmissionsUnknown(input.fence, input.pendingSubmissionReason))
     const items = input.journal.snapshot().items
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-turns.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-turns.ts
index e3609930084f..28d7846f10d2 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-turns.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-turns.ts
@@ -23,7 +23,7 @@ import type {
   StructuredAgentSessionAdapter,
   StructuredAgentSessionProviderChildPhase
 } from './structured-agent-session-adapter'
-import { dispatchWriteFailureReason } from '../../../shared/structured-agent-session-dispatch-rejection'
+import { providerStartupFailureRejection } from './structured-agent-session-dead-generation-settlement'
 import { validatePendingPrompt } from './structured-agent-session-prompt-state'
 import { withTimeout } from '../../../shared/promise-timeout-fallback'
 import {
@@ -102,7 +102,7 @@ async function dispatchSafely(
       throw error
     }
     if (ctx.providerChildPhase?.() === 'starting') {
-      return { state: 'rejected', reason: dispatchWriteFailureReason(error) }
+      return { state: 'rejected', reason: providerStartupFailureRejection(error) }
     }
     return { state: 'unknown', reason: error instanceof Error ? error.message : String(error) }
   }
diff --git a/src/main/runtime/claude-structured-send-held-for-startup.test.ts b/src/main/runtime/claude-structured-send-held-for-startup.test.ts
index 208329187056..19e058110553 100644
--- a/src/main/runtime/claude-structured-send-held-for-startup.test.ts
+++ b/src/main/runtime/claude-structured-send-held-for-startup.test.ts
@@ -95,7 +95,8 @@ describe('a send into a Claude chat whose CLI keeps failing at startup', () => {
     await vi.waitFor(() =>
       expect(submission(host, held)).toMatchObject({
         dispatchState: 'rejected',
-        reason: expect.stringContaining('not signed in (rig)')
+        // Worded for the user: the red line under the composer shows it as it stands.
+        reason: `The provider stopped before it finished starting: ${DIAGNOSTIC}.`
       })
     )
     expect(statusRows(host)).toEqual([
@@ -149,7 +150,8 @@ describe('a send while the first Claude start is still answering initialize', ()
     await vi.waitFor(() =>
       expect(submission(host, held)).toMatchObject({
         dispatchState: 'rejected',
-        reason: expect.stringContaining('not signed in (rig)')
+        // Worded for the user: the red line under the composer shows it as it stands.
+        reason: `The provider stopped before it finished starting: ${DIAGNOSTIC}.`
       })
     )
     expect(statusRows(host)).toEqual([
diff --git a/src/main/runtime/claude-structured-send-restart-dies-before-dispatch.test.ts b/src/main/runtime/claude-structured-send-restart-dies-before-dispatch.test.ts
index 79ef4caa02e3..651963b298e1 100644
--- a/src/main/runtime/claude-structured-send-restart-dies-before-dispatch.test.ts
+++ b/src/main/runtime/claude-structured-send-restart-dies-before-dispatch.test.ts
@@ -33,6 +33,23 @@ function fence(host: StructuredAgentSessionHost): number {
   return host.deps.store.getRecord(SESSION)?.lease.runtimeFence ?? 0
 }
 
+function attempt(host: StructuredAgentSessionHost, text: string) {
+  const body = hostTestMessage(text)
+  return host.send(CALLER, {
+    envelope: {
+      sessionId: SESSION,
+      clientOperationId: `${Date.now()}-${(++operations).toString(16).padStart(32, '0')}`,
+      expectedRuntimeFence: fence(host),
+      payloadFingerprint: computeAgentSessionPayloadFingerprint({
+        method: 'agentSession.send',
+        sessionId: SESSION,
+        fields: { body }
+      })
+    },
+    body
+  })
+}
+
 async function send(host: StructuredAgentSessionHost, text: string): Promise<string> {
   const body = hostTestMessage(text)
   const clientOperationId = `${Date.now()}-${(++operations).toString(16).padStart(32, '0')}`
@@ -136,7 +153,8 @@ describe('a send whose restarted Claude child dies before the dispatch reaches t
     await vi.waitFor(() =>
       expect(submission(host, sent)).toMatchObject({
         dispatchState: 'rejected',
-        reason: expect.stringContaining('not signed in (rig)')
+        // Worded for the user: the red line under the composer shows it as it stands.
+        reason: `The provider stopped before it finished starting: ${DIAGNOSTIC}.`
       })
     )
     expect(statusRows(host)).toEqual([
@@ -193,3 +211,89 @@ describe('a send whose restarted Claude child dies before the dispatch reaches t
     }
   })
 })
+
+describe('a chat whose Claude CLI keeps failing to start, seen by a subscriber open throughout', () => {
+  const STARTUP_FAILURE =
+    'The provider stopped before it finished starting: claude stream-json exited (code 1): claude: not signed in (rig).'
+
+  /** Status rows a subscriber has been shown, one per row whatever frame carried it. */
+  function shownRows(events: AgentSessionSubscribeEvent[]): Map<string, string> {
+    const rows = new Map<string, string>()
+    for (const event of events) {
+      if (event.type === 'end') {
+        continue
+      }
+      const page = event.type === 'batch' ? event.batch : event.page
+      for (const item of page.items) {
+        if (item.body.kind === 'status') {
+          rows.set(item.itemId, item.body.text)
+        }
+      }
+    }
+    return rows
+  }
+
+  it('shows one row naming the cause per failed attempt, admitted or refused, and none once the CLI is fixed', async () => {
+    claude.behave(SESSION, { initHangs: true })
+    const host = await claude.install()
+    const events: AgentSessionSubscribeEvent[] = []
+    await expect(host.attach(CALLER, claude.attachParams(SESSION, null))).resolves.toMatchObject({
+      ok: true
+    })
+    const unsubscribe = host.subscribe({
+      id: 'pane',
+      sessionId: SESSION,
+      emit: (event) => {
+        events.push(event)
+      }
+    })
+    try {
+      await failLatestStart(host, 1)
+      await vi.waitFor(() => expect([...shownRows(events).values()]).toEqual([STARTUP_FAILURE]))
+
+      // Send: admitted against the restarted child, which dies before starting.
+      killChildAtDispatch(host)
+      const sent = await attempt(host, 'hello?')
+      await waitForStructuredAgentSessionRecovery()
+      expect(sent).toMatchObject({
+        ok: true,
+        value: { submission: { dispatchState: 'rejected', reason: STARTUP_FAILURE } }
+      })
+      await vi.waitFor(() =>
+        expect([...shownRows(events).values()]).toEqual([STARTUP_FAILURE, STARTUP_FAILURE])
+      )
+
+      // Retry while still broken: this restart dies before its child is handed over, so the send
+      // is refused before admission. Still one row, saying the same thing.
+      claude.behave(SESSION, {
+        exitsDuringSpawn: {
+          diagnostic: 'claude stream-json exited (code 1): claude: not signed in (rig)',
+          at: 'start-time-read'
+        }
+      })
+      await expect(attempt(host, 'hello?')).resolves.toMatchObject({
+        ok: false,
+        refusal: {
+          code: 'agent_session_owner_restart_failed',
+          message: expect.stringMatching(/couldn't restart: .*not signed in \(rig\)/)
+        }
+      })
+      await waitForStructuredAgentSessionRecovery()
+      await vi.waitFor(() =>
+        expect([...shownRows(events).values()]).toEqual([
+          STARTUP_FAILURE,
+          STARTUP_FAILURE,
+          STARTUP_FAILURE
+        ])
+      )
+
+      // The CLI is fixed: Retry delivers and adds no row.
+      claude.behave(SESSION, {})
+      await expect(attempt(host, 'hello?')).resolves.toMatchObject({ ok: true })
+      await vi.waitFor(() => expect(claude.child(SESSION).calls).toContain('send'))
+      expect(shownRows(events).size).toBe(3)
+    } finally {
+      unsubscribe()
+    }
+  })
+})
diff --git a/src/renderer/src/components/native-chat/use-structured-agent-session-outbox-rejection-cause.test.tsx b/src/renderer/src/components/native-chat/use-structured-agent-session-outbox-rejection-cause.test.tsx
new file mode 100644
index 000000000000..d66f579ed0d8
--- /dev/null
+++ b/src/renderer/src/components/native-chat/use-structured-agent-session-outbox-rejection-cause.test.tsx
@@ -0,0 +1,71 @@
+// @vitest-environment happy-dom
+
+import { act, renderHook, waitFor } from '@testing-library/react'
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+
+const mocks = vi.hoisted(() => ({
+  call: vi.fn()
+}))
+
+vi.mock('@/runtime/structured-agent-session-client', () => ({
+  callStructuredAgentSession: mocks.call
+}))
+
+import { useStructuredAgentSessionOutbox } from './use-structured-agent-session-outbox'
+
+// What the host answers when the child it restarted for this send died before starting.
+const REASON =
+  'The provider stopped before it finished starting: claude stream-json exited (code 1): claude: not signed in.'
+
+function rejectedResultFor(clientMessageId: string) {
+  return {
+    ok: true,
+    replayed: false,
+    fence: 3,
+    cursor: { epoch: 'epoch-1', sequence: 4 },
+    value: {
+      clientMessageId,
+      submission: {
+        clientMessageId,
+        fence: 3,
+        payloadFingerprint: 'fingerprint',
+        dispatchState: 'rejected',
+        providerItemId: null,
+        reason: REASON,
+        submittedAt: 10,
+        resolvedAt: 11
+      }
+    }
+  }
+}
+
+describe('a send the host rejected because the agent never started', () => {
+  beforeEach(() => {
+    vi.clearAllMocks()
+    localStorage.clear()
+  })
+
+  it('names the cause under the composer and keeps the message for Retry', async () => {
+    mocks.call.mockImplementationOnce(
+      async (
+        _target: unknown,
+        _method: unknown,
+        params: { envelope: { clientOperationId: string } }
+      ) => rejectedResultFor(params.envelope.clientOperationId)
+    )
+    const { result } = renderHook(() =>
+      useStructuredAgentSessionOutbox({
+        sessionId: 'session-1',
+        target: { kind: 'local' },
+        fence: 1,
+        submissions: []
+      })
+    )
+
+    act(() => expect(result.current.send('hello')).toBe(true))
+
+    await waitFor(() => expect(result.current.error).toBe(REASON))
+    expect(result.current.outbox[0]?.state).toBe('queued')
+    expect(result.current.blockedClientMessageId).toBe(result.current.outbox[0]?.clientMessageId)
+  })
+})
diff --git a/src/shared/structured-agent-session-send-disposition.test.ts b/src/shared/structured-agent-session-send-disposition.test.ts
index b567c2a8dd26..66a7a9b32fa8 100644
--- a/src/shared/structured-agent-session-send-disposition.test.ts
+++ b/src/shared/structured-agent-session-send-disposition.test.ts
@@ -84,6 +84,13 @@ describe('what a rejection shows the user', () => {
     )
   })
 
+  it('names the cause of a start that died before it could take the message', () => {
+    // The host words this reason for the user: the child's own diagnostic, nothing internal.
+    const reason =
+      'The provider stopped before it finished starting: claude stream-json exited (code 1): claude: not signed in.'
+    expect(notice(reason)).toBe(reason)
+  })
+
   it('claims no cause when the rejection names none', () => {
     expect(notice(null)).toBe('Message was not sent.')
   })

From 060b15991d05faa6f0afee3361620ea49bcc2e77 Mon Sep 17 00:00:00 2001
From: Brennan Benson <79079362+brennanb2025@users.noreply.github.com>
Date: Wed, 23 Sep 2026 19:31:09 -0700
Subject: [PATCH 57/67] fix(claude): a saved option the CLI never answered
 survives a later change to a different option

The saved choice a start could not apply was kept on the record, but the next
option the user set persisted only what the child had applied, so changing the
permission mode or effort, or clearing the chat, silently dropped the saved
model. The adapter now reports which saved options are still unanswered, every
option write keeps those saved values, and a write the child accepts for that
option retires it.
---
 .../claude/claude-structured-options.test.ts  | 16 +++++++++
 src/main/claude/claude-structured-options.ts  |  3 ++
 .../claude-structured-session-adapter.ts      |  4 +++
 ...structured-agent-session-adapter-router.ts |  3 ++
 .../structured-agent-session-adapter.ts       |  2 ++
 ...ctured-agent-session-mutation-admission.ts |  7 +++-
 ...ctured-agent-session-option-restoration.ts | 33 +++++++++++------
 ...startup-unanswered-control-request.test.ts | 36 +++++++++++++++++++
 8 files changed, 92 insertions(+), 12 deletions(-)

diff --git a/src/main/claude/claude-structured-options.test.ts b/src/main/claude/claude-structured-options.test.ts
index 7e7dc51869ce..d10e726af38e 100644
--- a/src/main/claude/claude-structured-options.test.ts
+++ b/src/main/claude/claude-structured-options.test.ts
@@ -457,6 +457,22 @@ describe('Claude structured option restore under the request deadline', () => {
     expect(session.options.has('model')).toBe(false)
   })
 
+  it('stops keeping the saved choice once the user sets that option on the child', async () => {
+    const setModel = vi
+      .fn<ClaudeSession['connection']['setModel']>()
+      .mockRejectedValueOnce(new ClaudeControlRequestTimeoutError('set_model'))
+      .mockResolvedValue(undefined)
+    const session = sessionFor(setModel)
+    session.options = new Map([['model', 'sonnet']])
+    vi.spyOn(console, 'warn').mockImplementation(() => {})
+    await restoreClaudeStructuredSessionOptions(session, 10)
+
+    await expect(
+      setClaudeStructuredOption(session, { key: 'model', value: 'opus' }, 10)
+    ).resolves.toEqual({ model: 'opus' })
+    expect([...session.restoreUnansweredOptions]).toEqual([])
+  })
+
   it("keeps a timed-out client write as the deadline's own error, not a rejection", async () => {
     const session = sessionFor(async () => {
       throw new ClaudeControlRequestTimeoutError('set_model')
diff --git a/src/main/claude/claude-structured-options.ts b/src/main/claude/claude-structured-options.ts
index d1d0333de133..f4bb05ee03ab 100644
--- a/src/main/claude/claude-structured-options.ts
+++ b/src/main/claude/claude-structured-options.ts
@@ -161,6 +161,8 @@ export async function setClaudeStructuredOption(
       }
       session.options.set('model', input.value)
       session.options.set('fastMode', 'false')
+      session.restoreUnansweredOptions.delete('model')
+      session.restoreUnansweredOptions.delete('fastMode')
       session.confirmedOptions.delete('effort')
       session.confirmedOptions.delete('fastMode')
       // The requested model is already accepted; a cleanup failure cannot reject that write.
@@ -207,6 +209,7 @@ export async function setClaudeStructuredOption(
     input.key,
     input.key === 'fastMode' && typeof adopted === 'boolean' ? String(adopted) : input.value
   )
+  session.restoreUnansweredOptions.delete(input.key)
   // Only a readback that agreed is adoption evidence; one that disagreed or could
   // not be taken records the value but must not also claim the provider vouched for it.
   if (adopted !== null && adopted === decodedInput) {
diff --git a/src/main/claude/claude-structured-session-adapter.ts b/src/main/claude/claude-structured-session-adapter.ts
index e2b2bfd35b41..46da63d5ec6e 100644
--- a/src/main/claude/claude-structured-session-adapter.ts
+++ b/src/main/claude/claude-structured-session-adapter.ts
@@ -272,6 +272,10 @@ export class ClaudeStructuredSessionAdapter implements StructuredAgentSessionAda
     ...(this.sessions.get(sessionId)?.restoreSkippedOptions ?? [])
   ]
 
+  readOptionRestoreUnanswered = (sessionId: string): readonly string[] => [
+    ...(this.sessions.get(sessionId)?.restoreUnansweredOptions ?? [])
+  ]
+
   releaseAcquisition = (input: { sessionId: string }): Promise<boolean> =>
     releaseClaudeAcquisition({
       sessionId: input.sessionId,
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-adapter-router.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-adapter-router.ts
index 012611680254..6ba8fe359513 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-adapter-router.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-adapter-router.ts
@@ -128,6 +128,9 @@ export class StructuredAgentSessionAdapterRouter implements StructuredAgentSessi
   readOptionRestoreFailures = (sessionId: string): readonly string[] =>
     this.owner(sessionId).readOptionRestoreFailures?.(sessionId) ?? []
 
+  readOptionRestoreUnanswered = (sessionId: string): readonly string[] =>
+    this.owner(sessionId).readOptionRestoreUnanswered?.(sessionId) ?? []
+
   historyFilePath = (input: { identity: AgentSessionJournalIdentity }) =>
     this.requireAgent(input.identity).historyFilePath?.(input) ?? Promise.resolve(null)
 
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-adapter.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-adapter.ts
index 068091ae979a..87e6cbc7adcf 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-adapter.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-adapter.ts
@@ -293,6 +293,8 @@ export type StructuredAgentSessionAdapter = {
   readOptions?(input: { sessionId: string; fence: number }): Promise<AgentSessionOptionsResult>
   /** Option keys skipped after a provider rejected their persisted restore value. */
   readOptionRestoreFailures?(sessionId: string): readonly string[]
+  /** Saved option keys whose restore write the provider never answered and nothing since set. */
+  readOptionRestoreUnanswered?(sessionId: string): readonly string[]
   /** Transcript path for journal recovery. Omit to let the existing session-file
    *  resolver discover it from the provider session id. */
   historyFilePath?(input: { identity: AgentSessionJournalIdentity }): Promise<string | null>
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-mutation-admission.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-mutation-admission.ts
index b735427be0e8..faeccccdd149 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-mutation-admission.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-mutation-admission.ts
@@ -25,6 +25,7 @@ import type { AgentSessionRecordStore } from '../../runtime/agent-session-record
 import type { AgentSessionJournal } from '../agent-session-journal/journal-store'
 import type { StructuredAgentSessionAdapter } from './structured-agent-session-adapter'
 import type { MutationPlan } from './structured-agent-session-mutation-plans'
+import { withUnansweredSavedOptions } from './structured-agent-session-option-restoration'
 import { runSettledAgentSessionMutation } from './structured-agent-session-operation-settlement'
 import { resolveAgentSessionReplayOutcome } from './structured-agent-session-replay-outcome'
 import type { AgentSessionTurnContext } from './structured-agent-session-turns'
@@ -183,7 +184,11 @@ function turnContext<TValue>(
         .replaceSessionOptions({
           sessionId: request.envelope.sessionId,
           fence,
-          options,
+          options: withUnansweredSavedOptions(
+            options,
+            request.store.getRecord(request.envelope.sessionId)?.options,
+            request.adapter.readOptionRestoreUnanswered?.(request.envelope.sessionId) ?? []
+          ),
           now: request.now()
         })
         .then(() => undefined),
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-option-restoration.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-option-restoration.ts
index aeaf76d41148..9185b6c89b76 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-option-restoration.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-option-restoration.ts
@@ -41,16 +41,27 @@ export function nativeSessionOptionsFromReport(input: {
     reported.fastMode === undefined
       ? undefined
       : encodeStructuredAgentSessionOptionValue('fastMode', reported.fastMode)
-  const kept = Object.fromEntries(
-    (input.restoreUnanswered ?? []).flatMap((key) =>
-      priorOptions?.[key] === undefined ? [] : [[key, priorOptions[key]]]
-    )
+  return withUnansweredSavedOptions(
+    {
+      ...restored,
+      model: reported.model,
+      ...(reported.effort ? { effort: reported.effort } : {}),
+      ...(fastMode !== undefined && fastMode !== null ? { fastMode } : {})
+    },
+    priorOptions,
+    input.restoreUnanswered ?? []
   )
-  return {
-    ...restored,
-    model: reported.model,
-    ...(reported.effort ? { effort: reported.effort } : {}),
-    ...(fastMode !== undefined && fastMode !== null ? { fastMode } : {}),
-    ...kept
-  }
+}
+
+/** Options to persist with every saved choice the child never answered a restore write for kept
+ *  as saved, so a write the child does apply cannot silently drop one. */
+export function withUnansweredSavedOptions(
+  options: Readonly<Record<string, string>>,
+  saved: Readonly<Record<string, string>> | undefined,
+  unanswered: readonly string[]
+): Readonly<Record<string, string>> {
+  const kept = unanswered.flatMap((key) =>
+    saved?.[key] === undefined ? [] : [[key, saved[key]] as const]
+  )
+  return kept.length === 0 ? options : { ...options, ...Object.fromEntries(kept) }
 }
diff --git a/src/main/runtime/claude-structured-startup-unanswered-control-request.test.ts b/src/main/runtime/claude-structured-startup-unanswered-control-request.test.ts
index 8053eb3e2da1..7bf1320d8ec3 100644
--- a/src/main/runtime/claude-structured-startup-unanswered-control-request.test.ts
+++ b/src/main/runtime/claude-structured-startup-unanswered-control-request.test.ts
@@ -83,6 +83,42 @@ describe('a Claude start whose CLI answers initialize but not a control request'
     await vi.waitFor(() => expect(claude.child(SESSION).calls).toContain('send'))
   })
 
+  it('keeps the unanswered saved choice when the user later changes a different option', async () => {
+    const behavior = { optionWritesHang: true, controlTimeoutMs: DEADLINE_MS }
+    claude.behave(SESSION, behavior)
+    vi.spyOn(console, 'warn').mockImplementation(() => {})
+    const host = await claude.install()
+    await expect(
+      host.attach(CALLER, claude.attachParams(SESSION, null, { options: { model: 'sonnet' } }))
+    ).resolves.toMatchObject({ ok: true })
+    await vi.waitFor(
+      () => expect(record(host)?.options).toEqual({ model: 'sonnet', effort: 'high' }),
+      {
+        timeout: DEADLINE_MS * 40
+      }
+    )
+
+    // The CLI answers again; the user sets another option on the running child.
+    behavior.optionWritesHang = false
+    const value = 'plan'
+    const changed = await host.setOption(CALLER, {
+      envelope: {
+        sessionId: SESSION,
+        clientOperationId: `${Date.now()}-${(++operations).toString(16).padStart(32, '0')}`,
+        expectedRuntimeFence: record(host)?.lease.runtimeFence ?? 0,
+        payloadFingerprint: computeAgentSessionPayloadFingerprint({
+          method: 'agentSession.setOption',
+          sessionId: SESSION,
+          fields: { key: 'permissionMode', value }
+        })
+      },
+      key: 'permissionMode',
+      value
+    })
+    expect(changed, JSON.stringify(changed)).toMatchObject({ ok: true })
+    expect(record(host)?.options).toMatchObject({ model: 'sonnet', permissionMode: 'plan' })
+  })
+
   it("lands with effort unknown when startup's own settings read goes unanswered", async () => {
     claude.behave(SESSION, { startupSettingsReadHangs: true, controlTimeoutMs: DEADLINE_MS })
     const host = await claude.install()

From 015ff03f7b21d89fd1de9e6e608f4bbc1470d633 Mon Sep 17 00:00:00 2001
From: Brennan Benson <79079362+brennanb2025@users.noreply.github.com>
Date: Wed, 23 Sep 2026 19:32:53 -0700
Subject: [PATCH 58/67] fix(claude): a send that meets a child whose exit
 already settled names that exit's cause

When the child a send was admitted against died starting and its exit
finished settling before the send reached it, the send was rejected with
"no live claude stream-json session for <id>", now shown under the composer
as the cause. The adapter keeps a settled exit's diagnostic until the chat is
acquired or closed again, so that send names what the CLI said. A refused
restart whose child died at spawn or while its start time was read is pinned
to leave one row in the words any failed start uses.
---
 .../claude-structured-session-adapter.ts      | 18 +++++--
 ...-send-restart-dies-before-dispatch.test.ts | 52 +++++++++++++++++++
 2 files changed, 66 insertions(+), 4 deletions(-)

diff --git a/src/main/claude/claude-structured-session-adapter.ts b/src/main/claude/claude-structured-session-adapter.ts
index 46da63d5ec6e..5dd699242562 100644
--- a/src/main/claude/claude-structured-session-adapter.ts
+++ b/src/main/claude/claude-structured-session-adapter.ts
@@ -56,6 +56,9 @@ export class ClaudeStructuredSessionAdapter implements StructuredAgentSessionAda
   private readonly sessions = new Map<string, ClaudeSession>()
   private readonly acquisitions = new ClaudeAcquisitionRegistry()
   private readonly exits = new Map<string, ClaudeSessionExit>()
+  /** The diagnostic of a settled exit, until the id is acquired or closed again: the host learns
+   *  of the exit only after its settlement, and a send already past admission must name it. */
+  private readonly settledExitErrors = new Map<string, Error>()
 
   constructor(private readonly deps: ClaudeStructuredSessionAdapterDeps) {}
 
@@ -64,8 +67,9 @@ export class ClaudeStructuredSessionAdapter implements StructuredAgentSessionAda
   rewindSupport: NonNullable<StructuredAgentSessionAdapter['rewindSupport']> = () =>
     this.deps.readTranscriptLeaf ? { supported: true } : { supported: false, reason: 'unsupported' }
 
-  acquire = (input: StructuredAgentSessionAcquireInput): Promise<AgentSessionAcquisition> =>
-    acquireClaudeSession({
+  acquire = (input: StructuredAgentSessionAcquireInput): Promise<AgentSessionAcquisition> => {
+    this.settledExitErrors.delete(input.identity.sessionId)
+    return acquireClaudeSession({
       input,
       deps: this.deps,
       sessions: this.sessions,
@@ -78,6 +82,7 @@ export class ClaudeStructuredSessionAdapter implements StructuredAgentSessionAda
         settleExit: (sessionId, exit) => this.settleUnexpectedExit(sessionId, exit)
       }
     })
+  }
 
   private deliver(attempt: ClaudeAcquisitionAttempt, sessionId: string, event: () => void): void {
     if (!attempt.published) {
@@ -149,6 +154,7 @@ export class ClaudeStructuredSessionAdapter implements StructuredAgentSessionAda
         return
       }
       this.exits.delete(sessionId)
+      this.settledExitErrors.set(sessionId, exit.error)
       const ended: ClaudeStructuredSessionEvent = {
         type: 'ended',
         sessionId,
@@ -291,6 +297,7 @@ export class ClaudeStructuredSessionAdapter implements StructuredAgentSessionAda
     })
 
   closeSession = (sessionId: string): Promise<boolean> => {
+    this.settledExitErrors.delete(sessionId)
     if (this.exits.has(sessionId)) {
       return this.releaseAcquisition({ sessionId })
     }
@@ -307,14 +314,16 @@ export class ClaudeStructuredSessionAdapter implements StructuredAgentSessionAda
     })
   }
 
-  closeAll = (): Promise<void> =>
-    closeAllClaudeSessions({
+  closeAll = (): Promise<void> => {
+    this.settledExitErrors.clear()
+    return closeAllClaudeSessions({
       sessions: this.sessions,
       acquisitions: this.acquisitions,
       exits: this.exits,
       closeSession: this.closeSession,
       closeExit: (sessionId) => this.releaseAcquisition({ sessionId })
     })
+  }
 
   private session(sessionId: string): ClaudeSession {
     const session = this.sessions.get(sessionId)
@@ -322,6 +331,7 @@ export class ClaudeStructuredSessionAdapter implements StructuredAgentSessionAda
       // A child that just exited is named by its own diagnostic, not by its absence.
       throw (
         this.exits.get(sessionId)?.error ??
+        this.settledExitErrors.get(sessionId) ??
         new Error(`no live claude stream-json session for ${sessionId}`)
       )
     }
diff --git a/src/main/runtime/claude-structured-send-restart-dies-before-dispatch.test.ts b/src/main/runtime/claude-structured-send-restart-dies-before-dispatch.test.ts
index 651963b298e1..0d4b49096379 100644
--- a/src/main/runtime/claude-structured-send-restart-dies-before-dispatch.test.ts
+++ b/src/main/runtime/claude-structured-send-restart-dies-before-dispatch.test.ts
@@ -174,6 +174,58 @@ describe('a send whose restarted Claude child dies before the dispatch reaches t
     expect(statusRows(host)).toHaveLength(2)
   })
 
+  it('names the diagnostic even when the exit was fully processed before the dispatch arrived', async () => {
+    claude.behave(SESSION, { initHangs: true })
+    const host = await claude.install()
+    await expect(host.attach(CALLER, claude.attachParams(SESSION, null))).resolves.toMatchObject({
+      ok: true
+    })
+    await failLatestStart(host, 1)
+    const adapter = host.deps.adapter
+    const dispatch = adapter.dispatch.bind(adapter)
+    vi.spyOn(adapter, 'dispatch').mockImplementationOnce(async (input) => {
+      claude.child(SESSION).exit(new Error(DIAGNOSTIC))
+      // The adapter settles and publishes the exit; the host's own settlement waits behind this send.
+      await new Promise((resolve) => setTimeout(resolve, 300))
+      return dispatch(input)
+    })
+
+    const sent = await send(host, 'hello?')
+    expect(answered.get(sent)).toBe('rejected')
+    await waitForStructuredAgentSessionRecovery()
+    expect(submission(host, sent)).toMatchObject({
+      dispatchState: 'rejected',
+      reason: `The provider stopped before it finished starting: ${DIAGNOSTIC}.`
+    })
+    expect(statusRows(host)).toHaveLength(2)
+  })
+
+  // A restart refused because its child died before it was handed over leaves one row, from the
+  // send, in the words any failed start uses.
+  it.each(['spawn', 'start-time-read'] as const)(
+    'leaves one row for a restart whose child exits at %s',
+    async (at) => {
+      claude.behave(SESSION, { initHangs: true })
+      const host = await claude.install()
+      await expect(host.attach(CALLER, claude.attachParams(SESSION, null))).resolves.toMatchObject({
+        ok: true
+      })
+      await failLatestStart(host, 1)
+
+      claude.behave(SESSION, { exitsDuringSpawn: { diagnostic: DIAGNOSTIC, at } })
+      await expect(attempt(host, 'hello?')).resolves.toMatchObject({
+        ok: false,
+        refusal: { code: 'agent_session_owner_restart_failed' }
+      })
+      await waitForStructuredAgentSessionRecovery()
+
+      expect(statusRows(host)).toEqual([
+        `The provider stopped before it finished starting: ${DIAGNOSTIC}.`,
+        `The provider stopped before it finished starting: ${DIAGNOSTIC}.`
+      ])
+    }
+  )
+
   it('reaches a subscriber that was open across the restart and the exit', async () => {
     claude.behave(SESSION, { initHangs: true })
     const host = await claude.install()

From acd929e524aaa472a504af45ca1cdf980b6f08e6 Mon Sep 17 00:00:00 2001
From: Brennan Benson <79079362+brennanb2025@users.noreply.github.com>
Date: Wed, 23 Sep 2026 19:36:48 -0700
Subject: [PATCH 59/67] test(native-chat): pin the words an exit settlement
 rejects a never-started send with

The startup gate and the dispatch reject a send first in every existing
scenario, so the exit settlement's own rejection had no test of its wording.
---
 ...session-dead-generation-settlement.test.ts | 28 +++++++++++++++++++
 1 file changed, 28 insertions(+)

diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-dead-generation-settlement.test.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-dead-generation-settlement.test.ts
index 7af5626c07b5..fc6a62e385a7 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-dead-generation-settlement.test.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-dead-generation-settlement.test.ts
@@ -4,6 +4,7 @@ import { join } from 'node:path'
 import { afterEach, beforeEach, describe, expect, it } from 'vitest'
 import { openAgentSessionJournal } from '../agent-session-journal/journal-store-factory'
 import type { AgentJournalRenderItem } from '../../../shared/agent-session-journal-types'
+import { dispatchRejectionReasonIsInternal } from '../../../shared/structured-agent-session-dispatch-rejection'
 import type { AgentSessionJournal } from '../agent-session-journal/journal-store'
 import {
   captureUnfinishedStructuredAgentSessionWork,
@@ -255,6 +256,33 @@ describe('dead structured-session generation settlement', () => {
       })
     ])
   })
+
+  it('rejects a send a child that never started left pending with its diagnostic, in words', async () => {
+    await journal.appendSubmission({
+      clientMessageId: 'client-held',
+      payloadFingerprint: 'fingerprint',
+      body: { kind: 'message', role: 'user', blocks: [{ type: 'text', text: 'hello?' }] },
+      fence: 7
+    })
+
+    await settleStructuredAgentSessionDeadGeneration({
+      journal,
+      sessionId: SESSION,
+      fence: 7,
+      settlementId: `provider-exit:${SESSION}:7:generation-1`,
+      pendingSubmissionReason: 'provider_closed_before_acknowledgement',
+      verdict: { state: 'interrupted', completedAt: 1_000 },
+      unexpectedExitReason: 'claude stream-json exited (code 1): not signed in',
+      exitedDuringStartup: true
+    })
+
+    const reason =
+      'The provider stopped before it finished starting: claude stream-json exited (code 1): not signed in.'
+    expect(journal.submissions()).toEqual([
+      expect.objectContaining({ clientMessageId: 'client-held', dispatchState: 'rejected', reason })
+    ])
+    expect(dispatchRejectionReasonIsInternal(reason)).toBe(false)
+  })
 })
 
 describe('whether a dead generation interrupted anything', () => {

From f2d5c85ab3c305daa3c69dc0460025233bf24d19 Mon Sep 17 00:00:00 2001
From: Brennan Benson <79079362+brennanb2025@users.noreply.github.com>
Date: Wed, 23 Sep 2026 19:41:08 -0700
Subject: [PATCH 60/67] fix(claude): derive which saved options are still
 unanswered from what the child applied

A write that lands already puts its option in the session's applied set, so
the unanswered list is that list minus what has since been applied, rather
than a second copy every option write must remember to edit. Session
fixtures built without the new set no longer throw on an ordinary write.
---
 .../claude/claude-structured-options.test.ts  |  3 ++-
 src/main/claude/claude-structured-options.ts  |  8 +++++---
 .../claude-structured-session-adapter.ts      | 19 +++++++++----------
 .../claude-structured-session-startup.ts      |  7 +++++--
 4 files changed, 21 insertions(+), 16 deletions(-)

diff --git a/src/main/claude/claude-structured-options.test.ts b/src/main/claude/claude-structured-options.test.ts
index d10e726af38e..4e6c4efbc139 100644
--- a/src/main/claude/claude-structured-options.test.ts
+++ b/src/main/claude/claude-structured-options.test.ts
@@ -1,5 +1,6 @@
 import { describe, expect, it, vi } from 'vitest'
 import {
+  claudeRestoreUnansweredOptions,
   restoreClaudeStructuredSessionOptions,
   setClaudeStructuredOption
 } from './claude-structured-options'
@@ -470,7 +471,7 @@ describe('Claude structured option restore under the request deadline', () => {
     await expect(
       setClaudeStructuredOption(session, { key: 'model', value: 'opus' }, 10)
     ).resolves.toEqual({ model: 'opus' })
-    expect([...session.restoreUnansweredOptions]).toEqual([])
+    expect(claudeRestoreUnansweredOptions(session)).toEqual([])
   })
 
   it("keeps a timed-out client write as the deadline's own error, not a rejection", async () => {
diff --git a/src/main/claude/claude-structured-options.ts b/src/main/claude/claude-structured-options.ts
index f4bb05ee03ab..1bfc15fb2aaf 100644
--- a/src/main/claude/claude-structured-options.ts
+++ b/src/main/claude/claude-structured-options.ts
@@ -161,8 +161,6 @@ export async function setClaudeStructuredOption(
       }
       session.options.set('model', input.value)
       session.options.set('fastMode', 'false')
-      session.restoreUnansweredOptions.delete('model')
-      session.restoreUnansweredOptions.delete('fastMode')
       session.confirmedOptions.delete('effort')
       session.confirmedOptions.delete('fastMode')
       // The requested model is already accepted; a cleanup failure cannot reject that write.
@@ -209,7 +207,6 @@ export async function setClaudeStructuredOption(
     input.key,
     input.key === 'fastMode' && typeof adopted === 'boolean' ? String(adopted) : input.value
   )
-  session.restoreUnansweredOptions.delete(input.key)
   // Only a readback that agreed is adoption evidence; one that disagreed or could
   // not be taken records the value but must not also claim the provider vouched for it.
   if (adopted !== null && adopted === decodedInput) {
@@ -227,6 +224,11 @@ export async function setClaudeStructuredOption(
   return Object.fromEntries(session.options)
 }
 
+/** Saved options whose restore write went unanswered and that no later write has applied. */
+export function claudeRestoreUnansweredOptions(session: ClaudeSession | undefined): string[] {
+  return [...(session?.restoreUnansweredOptions ?? [])].filter((key) => !session?.options.has(key))
+}
+
 export async function restoreClaudeStructuredSessionOptions(
   session: ClaudeSession,
   timeoutMs: number | undefined
diff --git a/src/main/claude/claude-structured-session-adapter.ts b/src/main/claude/claude-structured-session-adapter.ts
index 5dd699242562..4ea01845f852 100644
--- a/src/main/claude/claude-structured-session-adapter.ts
+++ b/src/main/claude/claude-structured-session-adapter.ts
@@ -11,7 +11,10 @@ import { releaseClaudeAcquisition } from './claude-structured-acquisition-releas
 import { acquireClaudeSession } from './claude-structured-session-acquisition'
 import { failClaudeStartupGate } from './claude-structured-session-startup-gate'
 import { supportsClaudeStructuredLocation } from './claude-structured-location-support'
-import { setClaudeStructuredSessionOption } from './claude-structured-options'
+import {
+  claudeRestoreUnansweredOptions,
+  setClaudeStructuredSessionOption
+} from './claude-structured-options'
 import { readClaudeStructuredSessionOptions } from './claude-structured-session-options'
 import {
   ClaudeAcquisitionRegistry,
@@ -56,8 +59,7 @@ export class ClaudeStructuredSessionAdapter implements StructuredAgentSessionAda
   private readonly sessions = new Map<string, ClaudeSession>()
   private readonly acquisitions = new ClaudeAcquisitionRegistry()
   private readonly exits = new Map<string, ClaudeSessionExit>()
-  /** The diagnostic of a settled exit, until the id is acquired or closed again: the host learns
-   *  of the exit only after its settlement, and a send already past admission must name it. */
+  /** A settled exit's diagnostic, kept for a send admitted before the host heard of the exit. */
   private readonly settledExitErrors = new Map<string, Error>()
 
   constructor(private readonly deps: ClaudeStructuredSessionAdapterDeps) {}
@@ -278,9 +280,8 @@ export class ClaudeStructuredSessionAdapter implements StructuredAgentSessionAda
     ...(this.sessions.get(sessionId)?.restoreSkippedOptions ?? [])
   ]
 
-  readOptionRestoreUnanswered = (sessionId: string): readonly string[] => [
-    ...(this.sessions.get(sessionId)?.restoreUnansweredOptions ?? [])
-  ]
+  readOptionRestoreUnanswered = (sessionId: string): readonly string[] =>
+    claudeRestoreUnansweredOptions(this.sessions.get(sessionId))
 
   releaseAcquisition = (input: { sessionId: string }): Promise<boolean> =>
     releaseClaudeAcquisition({
@@ -314,16 +315,14 @@ export class ClaudeStructuredSessionAdapter implements StructuredAgentSessionAda
     })
   }
 
-  closeAll = (): Promise<void> => {
-    this.settledExitErrors.clear()
-    return closeAllClaudeSessions({
+  closeAll = (): Promise<void> =>
+    closeAllClaudeSessions({
       sessions: this.sessions,
       acquisitions: this.acquisitions,
       exits: this.exits,
       closeSession: this.closeSession,
       closeExit: (sessionId) => this.releaseAcquisition({ sessionId })
     })
-  }
 
   private session(sessionId: string): ClaudeSession {
     const session = this.sessions.get(sessionId)
diff --git a/src/main/claude/claude-structured-session-startup.ts b/src/main/claude/claude-structured-session-startup.ts
index 0ddfc94cc4ca..61b2fa54ba6f 100644
--- a/src/main/claude/claude-structured-session-startup.ts
+++ b/src/main/claude/claude-structured-session-startup.ts
@@ -16,7 +16,10 @@ import {
   readClaudeModels,
   type ClaudeInitObservation
 } from './claude-structured-init-proof'
-import { restoreClaudeStructuredSessionOptions } from './claude-structured-options'
+import {
+  claudeRestoreUnansweredOptions,
+  restoreClaudeStructuredSessionOptions
+} from './claude-structured-options'
 import {
   claudeStructuredSessionPublicationOptions,
   prepareClaudeStructuredSessionAcquisitionOptions,
@@ -185,7 +188,7 @@ export async function settleClaudeSessionStartup(input: {
           readClaudeModels(facts.initialization)
         ).current,
         restoreSkippedOptions: [...session.restoreSkippedOptions],
-        restoreUnansweredOptions: [...session.restoreUnansweredOptions]
+        restoreUnansweredOptions: claudeRestoreUnansweredOptions(session)
       })
       await openClaudeStartupGate(session)
     }

From 64f24849a8f5effd820756e3ab9bd43de5506b8a Mon Sep 17 00:00:00 2001
From: Brennan Benson <79079362+brennanb2025@users.noreply.github.com>
Date: Wed, 23 Sep 2026 19:51:34 -0700
Subject: [PATCH 61/67] fix(native-chat): a cleared chat starts from a saved
 choice the child never answered

Clearing a chat seeded the replacement from the values the child reported,
so a saved model or effort whose restore write the CLI never answered was
replaced by the CLI's own value in the new chat, even though the retired
record kept it. The replacement now keeps those saved values too, and its
start retries them.
---
 .../structured-conversation-command.test.ts   | 21 ++++++++++++++++
 .../structured-conversation-command.ts        | 25 ++++++++++++-------
 2 files changed, 37 insertions(+), 9 deletions(-)

diff --git a/src/main/native-chat/agent-session-wire/structured-conversation-command.test.ts b/src/main/native-chat/agent-session-wire/structured-conversation-command.test.ts
index 68939c0889df..5c82843be9f1 100644
--- a/src/main/native-chat/agent-session-wire/structured-conversation-command.test.ts
+++ b/src/main/native-chat/agent-session-wire/structured-conversation-command.test.ts
@@ -163,6 +163,27 @@ describe('host conversation commands', () => {
     })
   })
 
+  // The replacement's start then retries it, as the source's next start would have.
+  it('starts the replacement from a saved choice the child never answered, not the live value', async () => {
+    await store.replaceSessionOptions({
+      sessionId: HOST_TEST_SESSION,
+      fence: store.getRecord(HOST_TEST_SESSION)!.lease.runtimeFence,
+      options: { model: 'test-model', effort: 'low' },
+      now: HOST_TEST_NOW
+    })
+    adapter.readOptionRestoreUnanswered = (sessionId) =>
+      sessionId === HOST_TEST_SESSION ? ['effort'] : []
+    const attach = vi.spyOn(host, 'attach')
+    expect(await host.conversationCommand(caller, commandParams('clear'))).toMatchObject({
+      ok: true
+    })
+    expect(attach.mock.calls[0]?.[1].options).toEqual({ model: 'test-model', effort: 'low' })
+    expect(store.getRecord(HOST_TEST_SESSION)?.options).toEqual({
+      model: 'test-model',
+      effort: 'low'
+    })
+  })
+
   it('clears with a fresh record and effective options, retaining old history and idempotent mapping', async () => {
     const before = store.getRecord(HOST_TEST_SESSION)!
     const params = commandParams('clear')
diff --git a/src/main/native-chat/agent-session-wire/structured-conversation-command.ts b/src/main/native-chat/agent-session-wire/structured-conversation-command.ts
index 8157a32669b2..fbe8b1f70126 100644
--- a/src/main/native-chat/agent-session-wire/structured-conversation-command.ts
+++ b/src/main/native-chat/agent-session-wire/structured-conversation-command.ts
@@ -15,6 +15,7 @@ import {
   type AgentSessionAttachParams
 } from './structured-agent-session-attach'
 import { admitAndRunAgentSessionMutation } from './structured-agent-session-mutation-admission'
+import { withUnansweredSavedOptions } from './structured-agent-session-option-restoration'
 import type { StructuredAgentSessionMutationContext } from './structured-agent-session-host-mutations'
 import type { StructuredAgentSessionCaller } from './structured-agent-session-host-types'
 import type { StructuredAgentSessionHost } from './structured-agent-session-host'
@@ -116,15 +117,21 @@ export function runStructuredConversationCommand(
           if (command === 'clear' && !prior) {
             try {
               const options = await ctx.adapter.readOptions?.({ sessionId, fence: ctx.fence })
-              effectiveOptions = {
-                ...record.options,
-                ...(options
-                  ? {
-                      model: options.current.model,
-                      ...(options.current.effort ? { effort: options.current.effort } : {})
-                    }
-                  : {})
-              }
+              // The replacement starts from the live values, except a saved choice the child
+              // never answered, which its start retries.
+              effectiveOptions = withUnansweredSavedOptions(
+                {
+                  ...record.options,
+                  ...(options
+                    ? {
+                        model: options.current.model,
+                        ...(options.current.effort ? { effort: options.current.effort } : {})
+                      }
+                    : {})
+                },
+                record.options,
+                ctx.adapter.readOptionRestoreUnanswered?.(sessionId) ?? []
+              )
             } catch {
               return {
                 ok: false,

From 17b41b5eaa0c57f347c5a0e283a943cfae5528a4 Mon Sep 17 00:00:00 2001
From: Brennan Benson <79079362+brennanb2025@users.noreply.github.com>
Date: Wed, 23 Sep 2026 19:51:36 -0700
Subject: [PATCH 62/67] fix(claude): closing a chat forgets its exit's
 diagnostic even when the exit settles during the close

The diagnostic was dropped when the close began, but closing over an exit
that was still settling finishes that settlement, which kept it again, so a
closed or deleted chat held it until its next acquire. It is now dropped once
the close finishes. Pins that an acquire and a close each retire it.
---
 .../claude-structured-session-adapter.test.ts | 34 +++++++++++++++++++
 .../claude-structured-session-adapter.ts      |  7 ++--
 2 files changed, 39 insertions(+), 2 deletions(-)

diff --git a/src/main/claude/claude-structured-session-adapter.test.ts b/src/main/claude/claude-structured-session-adapter.test.ts
index c8e8cb1f82d6..84111fb3e9ee 100644
--- a/src/main/claude/claude-structured-session-adapter.test.ts
+++ b/src/main/claude/claude-structured-session-adapter.test.ts
@@ -669,6 +669,40 @@ describe('ClaudeStructuredSessionAdapter acquisition cleanup', () => {
     )
   })
 
+  it('names a settled exit to a late caller until the chat is acquired again', async () => {
+    const claude = fakeClaude()
+    const adapter = await acquired(claude)
+    claude.connections[0].handlers.onExit?.(new Error('claude stream-json exited: not logged in'))
+    await adapter.drainObservedExits()
+    expect(() => adapter.readOptions({ sessionId: 'session-1', fence: 7 })).toThrow('not logged in')
+
+    await adapter.acquire({ identity: identityFor(), fence: 8, spawnToken: 'spawn-10' })
+    await expect(adapter.releaseAcquisition({ sessionId: 'session-1' })).resolves.toBe(true)
+    expect(() => adapter.readOptions({ sessionId: 'session-1', fence: 8 })).toThrow(
+      'no live claude stream-json session'
+    )
+  })
+
+  it('forgets an exit the chat was closed over, even one that settles during the close', async () => {
+    const claude = fakeClaude()
+    const adapter = await acquired(claude)
+    const connection = claude.connections[0]
+    const proof = Promise.withResolvers<boolean>()
+    connection.close = vi
+      .fn<FakeConnection['close']>()
+      .mockImplementationOnce(() => proof.promise)
+      .mockResolvedValue(true)
+    connection.handlers.onExit?.(new Error('claude stream-json exited: not logged in'))
+    await tick()
+
+    const closing = adapter.closeSession('session-1')
+    proof.resolve(true)
+    await expect(closing).resolves.toBe(true)
+    expect(() => adapter.readOptions({ sessionId: 'session-1', fence: 7 })).toThrow(
+      'no live claude stream-json session'
+    )
+  })
+
   it('does not report a second release as successful while retained exit evidence is unproven', async () => {
     const claude = fakeClaude({ unprovenCloseVerdict: { root: 'exited', tree: 'unverifiable' } })
     const adapter = await acquired(claude)
diff --git a/src/main/claude/claude-structured-session-adapter.ts b/src/main/claude/claude-structured-session-adapter.ts
index 4ea01845f852..cad4da9ca560 100644
--- a/src/main/claude/claude-structured-session-adapter.ts
+++ b/src/main/claude/claude-structured-session-adapter.ts
@@ -297,8 +297,11 @@ export class ClaudeStructuredSessionAdapter implements StructuredAgentSessionAda
       ...(this.deps.onEvent ? { onEvent: this.deps.onEvent } : {})
     })
 
-  closeSession = (sessionId: string): Promise<boolean> => {
-    this.settledExitErrors.delete(sessionId)
+  closeSession = (sessionId: string): Promise<boolean> =>
+    // After the close, not before: releasing an exit still settling settles it on the way.
+    this.closeSessionProcess(sessionId).finally(() => this.settledExitErrors.delete(sessionId))
+
+  private closeSessionProcess(sessionId: string): Promise<boolean> {
     if (this.exits.has(sessionId)) {
       return this.releaseAcquisition({ sessionId })
     }

From a88d95b709964bdd9a126952bd427f2447fcde8b Mon Sep 17 00:00:00 2001
From: Brennan Benson <79079362+brennanb2025@users.noreply.github.com>
Date: Wed, 23 Sep 2026 20:09:47 -0700
Subject: [PATCH 63/67] refactor(claude): keep a saved option the CLI never
 answered as the wanted value, not a list beside it

A restore cleared the session's wanted options and added back only the writes
the CLI answered, so an unanswered one lost the user's value and every later
writer had to be told to put it back: the start report, each option change and
/clear each carried a list of unanswered keys. The restore now keeps the saved
value as wanted and unconfirmed, so what the session reports and persists
already carries it, and the list, its adapter method and the started-event
field are gone. A refused option is still dropped.

/clear now starts the replacement from the record's options instead of reading
the child's live values, which can be a model the CLI fell back to.
---
 ...claude-structured-dispatch-test-support.ts |   1 -
 .../claude/claude-structured-options.test.ts  |  50 +++----
 src/main/claude/claude-structured-options.ts  |  16 +--
 .../claude-structured-session-adapter.ts      |   8 +-
 .../claude-structured-session-publication.ts  |   1 -
 .../claude-structured-session-startup.test.ts |   3 +-
 .../claude-structured-session-startup.ts      |  10 +-
 .../claude/claude-structured-session-state.ts |   2 -
 ...structured-agent-session-adapter-router.ts |   3 -
 .../structured-agent-session-adapter.ts       |   4 -
 ...ctured-agent-session-mutation-admission.ts |   7 +-
 ...ctured-agent-session-option-restoration.ts |  33 +----
 ...ructured-agent-session-provider-started.ts |   3 -
 .../structured-conversation-command.test.ts   |  11 +-
 .../structured-conversation-command.ts        |  37 +----
 ...startup-unanswered-control-request.test.ts | 132 ++++++++++++++++--
 ...ed-claude-scripted-runtime-test-support.ts |   8 +-
 src/shared/agent-session-record.ts            |   2 +-
 18 files changed, 183 insertions(+), 148 deletions(-)

diff --git a/src/main/claude/claude-structured-dispatch-test-support.ts b/src/main/claude/claude-structured-dispatch-test-support.ts
index 2bc81a50082b..854d4be96203 100644
--- a/src/main/claude/claude-structured-dispatch-test-support.ts
+++ b/src/main/claude/claude-structured-dispatch-test-support.ts
@@ -27,7 +27,6 @@ export function sessionFor(send: Mock = vi.fn().mockResolvedValue(undefined)): C
     reportedModelMutation: 0,
     confirmedOptions: new Set(),
     restoreSkippedOptions: new Set(),
-    restoreUnansweredOptions: new Set(),
     capabilities: [],
     events: undefined,
     translator: null,
diff --git a/src/main/claude/claude-structured-options.test.ts b/src/main/claude/claude-structured-options.test.ts
index 4e6c4efbc139..128905cdd778 100644
--- a/src/main/claude/claude-structured-options.test.ts
+++ b/src/main/claude/claude-structured-options.test.ts
@@ -1,15 +1,18 @@
 import { describe, expect, it, vi } from 'vitest'
 import {
-  claudeRestoreUnansweredOptions,
   restoreClaudeStructuredSessionOptions,
   setClaudeStructuredOption
 } from './claude-structured-options'
 import type { ClaudeSession } from './claude-structured-session-state'
-import { ClaudeControlRequestTimeoutError } from './claude-agent-sdk-control-requests'
+import {
+  ClaudeControlRequestError,
+  ClaudeControlRequestTimeoutError
+} from './claude-agent-sdk-control-requests'
 import { ClaudeBackgroundTaskTracker } from './claude-background-task-tracker'
 import { ClaudeSlashCommandCatalog } from './claude-slash-command-catalog'
 import { createClaudeSessionStartupGate } from './claude-structured-session-startup-gate'
 import {
+  claudeStructuredSessionOptionsFrom,
   observeClaudeFastModeFacts,
   readClaudeStructuredSessionOptions
 } from './claude-structured-session-options'
@@ -40,7 +43,6 @@ function sessionFor(setModel: ClaudeSession['connection']['setModel']): ClaudeSe
     reportedModelMutation: 0,
     confirmedOptions: new Set(),
     restoreSkippedOptions: new Set(),
-    restoreUnansweredOptions: new Set(),
     capabilities: [],
     events: undefined,
     translator: null,
@@ -444,34 +446,34 @@ describe('Claude Fast mode reported by the session frame alone', () => {
 })
 
 describe('Claude structured option restore under the request deadline', () => {
-  it('skips a write the CLI never answered and finishes the restore, keeping it unanswered rather than refused', async () => {
+  it('keeps a saved choice the CLI never answered as wanted but unconfirmed, and drops a refused one', async () => {
     const session = sessionFor(async () => {
       throw new ClaudeControlRequestTimeoutError('set_model')
     })
-    session.options = new Map([['model', 'sonnet']])
+    session.connection.applyFlagSettings = async () => {
+      throw new ClaudeControlRequestTimeoutError('apply_flag_settings')
+    }
+    session.connection.setPermissionMode = async () => {
+      throw new ClaudeControlRequestError('set_permission_mode', 'unknown mode')
+    }
+    // Startup already read the CLI's own model and effort, and vouched for them.
+    session.reportedOptions = { model: 'claude-sonnet-5', effort: 'medium' }
+    session.confirmedOptions.add('effort')
+    session.options = new Map([
+      ['model', 'sonnet'],
+      ['effort', 'high'],
+      ['permissionMode', 'plan']
+    ])
     vi.spyOn(console, 'warn').mockImplementation(() => {})
 
     await expect(restoreClaudeStructuredSessionOptions(session, 10)).resolves.toBeUndefined()
 
-    expect([...session.restoreUnansweredOptions]).toEqual(['model'])
-    expect([...session.restoreSkippedOptions]).toEqual([])
-    expect(session.options.has('model')).toBe(false)
-  })
-
-  it('stops keeping the saved choice once the user sets that option on the child', async () => {
-    const setModel = vi
-      .fn<ClaudeSession['connection']['setModel']>()
-      .mockRejectedValueOnce(new ClaudeControlRequestTimeoutError('set_model'))
-      .mockResolvedValue(undefined)
-    const session = sessionFor(setModel)
-    session.options = new Map([['model', 'sonnet']])
-    vi.spyOn(console, 'warn').mockImplementation(() => {})
-    await restoreClaudeStructuredSessionOptions(session, 10)
-
-    await expect(
-      setClaudeStructuredOption(session, { key: 'model', value: 'opus' }, 10)
-    ).resolves.toEqual({ model: 'opus' })
-    expect(claudeRestoreUnansweredOptions(session)).toEqual([])
+    expect(Object.fromEntries(session.options)).toEqual({ model: 'sonnet', effort: 'high' })
+    expect([...session.restoreSkippedOptions]).toEqual(['permissionMode'])
+    expect(claudeStructuredSessionOptionsFrom(session, null).current).toEqual({
+      model: 'sonnet',
+      effort: 'high'
+    })
   })
 
   it("keeps a timed-out client write as the deadline's own error, not a rejection", async () => {
diff --git a/src/main/claude/claude-structured-options.ts b/src/main/claude/claude-structured-options.ts
index 1bfc15fb2aaf..d4b833bbad8a 100644
--- a/src/main/claude/claude-structured-options.ts
+++ b/src/main/claude/claude-structured-options.ts
@@ -224,11 +224,6 @@ export async function setClaudeStructuredOption(
   return Object.fromEntries(session.options)
 }
 
-/** Saved options whose restore write went unanswered and that no later write has applied. */
-export function claudeRestoreUnansweredOptions(session: ClaudeSession | undefined): string[] {
-  return [...(session?.restoreUnansweredOptions ?? [])].filter((key) => !session?.options.has(key))
-}
-
 export async function restoreClaudeStructuredSessionOptions(
   session: ClaudeSession,
   timeoutMs: number | undefined
@@ -246,15 +241,14 @@ export async function restoreClaudeStructuredSessionOptions(
     try {
       await setClaudeStructuredOption(session, { key, value }, timeoutMs)
     } catch (error) {
-      // A write the CLI never answered is skipped the same way: startup has no deadline of its
-      // own, and a slow control answer must not fault a session whose child is otherwise fine.
-      // The child's current value stands, and the user can set the option again.
-      // Silence is not a refusal: the saved choice stays saved and the next start retries it.
+      // A write the CLI never answered must not fault a start that is otherwise fine. Silence is
+      // not a refusal, so the choice stays wanted, unconfirmed, and the next start retries it.
       if (error instanceof ClaudeControlRequestTimeoutError) {
         console.warn(
-          `[claude-structured] restore of ${key} for ${session.providerSessionId} was not answered in time; keeping the CLI's value`
+          `[claude-structured] restore of ${key} for ${session.providerSessionId} was not answered in time; keeping it unconfirmed`
         )
-        session.restoreUnansweredOptions.add(key)
+        session.options.set(key, value)
+        session.confirmedOptions.delete(key)
         continue
       }
       if (!isAgentSessionOptionRejectedError(error)) {
diff --git a/src/main/claude/claude-structured-session-adapter.ts b/src/main/claude/claude-structured-session-adapter.ts
index cad4da9ca560..33068849cc33 100644
--- a/src/main/claude/claude-structured-session-adapter.ts
+++ b/src/main/claude/claude-structured-session-adapter.ts
@@ -11,10 +11,7 @@ import { releaseClaudeAcquisition } from './claude-structured-acquisition-releas
 import { acquireClaudeSession } from './claude-structured-session-acquisition'
 import { failClaudeStartupGate } from './claude-structured-session-startup-gate'
 import { supportsClaudeStructuredLocation } from './claude-structured-location-support'
-import {
-  claudeRestoreUnansweredOptions,
-  setClaudeStructuredSessionOption
-} from './claude-structured-options'
+import { setClaudeStructuredSessionOption } from './claude-structured-options'
 import { readClaudeStructuredSessionOptions } from './claude-structured-session-options'
 import {
   ClaudeAcquisitionRegistry,
@@ -280,9 +277,6 @@ export class ClaudeStructuredSessionAdapter implements StructuredAgentSessionAda
     ...(this.sessions.get(sessionId)?.restoreSkippedOptions ?? [])
   ]
 
-  readOptionRestoreUnanswered = (sessionId: string): readonly string[] =>
-    claudeRestoreUnansweredOptions(this.sessions.get(sessionId))
-
   releaseAcquisition = (input: { sessionId: string }): Promise<boolean> =>
     releaseClaudeAcquisition({
       sessionId: input.sessionId,
diff --git a/src/main/claude/claude-structured-session-publication.ts b/src/main/claude/claude-structured-session-publication.ts
index 6264648e98b8..0ae9e9a8e5e1 100644
--- a/src/main/claude/claude-structured-session-publication.ts
+++ b/src/main/claude/claude-structured-session-publication.ts
@@ -61,7 +61,6 @@ export function createClaudeSessionPublication(input: {
       reportedModelMutation: 0,
       confirmedOptions: new Set(),
       restoreSkippedOptions: new Set(),
-      restoreUnansweredOptions: new Set(),
       translator: input.translator,
       events: input.events,
       ...(input.unbindReadingControl ? { unbindReadingControl: input.unbindReadingControl } : {}),
diff --git a/src/main/claude/claude-structured-session-startup.test.ts b/src/main/claude/claude-structured-session-startup.test.ts
index 96d714fdf65d..32d1aac3bb23 100644
--- a/src/main/claude/claude-structured-session-startup.test.ts
+++ b/src/main/claude/claude-structured-session-startup.test.ts
@@ -88,8 +88,7 @@ describe('Claude structured session publishes before the CLI answers initialize'
       acquisitionGeneration: expect.any(String),
       // What the restore just proved, carried so the host never asks the CLI again.
       reportedOptions: expect.objectContaining({ model: 'opus' }),
-      restoreSkippedOptions: [],
-      restoreUnansweredOptions: []
+      restoreSkippedOptions: []
     })
     // The restore wrote the saved model before `started`, and the held prompt only after it.
     expect(order).toEqual(['set_model'])
diff --git a/src/main/claude/claude-structured-session-startup.ts b/src/main/claude/claude-structured-session-startup.ts
index 61b2fa54ba6f..6250e851912b 100644
--- a/src/main/claude/claude-structured-session-startup.ts
+++ b/src/main/claude/claude-structured-session-startup.ts
@@ -16,10 +16,7 @@ import {
   readClaudeModels,
   type ClaudeInitObservation
 } from './claude-structured-init-proof'
-import {
-  claudeRestoreUnansweredOptions,
-  restoreClaudeStructuredSessionOptions
-} from './claude-structured-options'
+import { restoreClaudeStructuredSessionOptions } from './claude-structured-options'
 import {
   claudeStructuredSessionPublicationOptions,
   prepareClaudeStructuredSessionAcquisitionOptions,
@@ -54,7 +51,7 @@ export function createClaudeInitProof(): ClaudeInitProof {
 
 export type StructuredAgentSessionStartedOptions = Pick<
   StructuredAgentSessionStartedEvent,
-  'reportedOptions' | 'restoreSkippedOptions' | 'restoreUnansweredOptions'
+  'reportedOptions' | 'restoreSkippedOptions'
 >
 
 export type ClaudeStartupFacts = {
@@ -187,8 +184,7 @@ export async function settleClaudeSessionStartup(input: {
           session,
           readClaudeModels(facts.initialization)
         ).current,
-        restoreSkippedOptions: [...session.restoreSkippedOptions],
-        restoreUnansweredOptions: claudeRestoreUnansweredOptions(session)
+        restoreSkippedOptions: [...session.restoreSkippedOptions]
       })
       await openClaudeStartupGate(session)
     }
diff --git a/src/main/claude/claude-structured-session-state.ts b/src/main/claude/claude-structured-session-state.ts
index a4ae7ee70c0e..9e04e439e1da 100644
--- a/src/main/claude/claude-structured-session-state.ts
+++ b/src/main/claude/claude-structured-session-state.ts
@@ -155,8 +155,6 @@ export type ClaudeSession = {
   /** Options whose recorded value the provider reported, not merely accepted. */
   confirmedOptions: Set<string>
   restoreSkippedOptions: Set<string>
-  /** Saved options whose restore write the CLI never answered; the saved choice is kept. */
-  restoreUnansweredOptions: Set<string>
   /** CLI-advertised protocol capabilities from init; gates interrupt-receipt handling. */
   capabilities: readonly string[]
   backgroundTasks: ClaudeBackgroundTaskTracker
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-adapter-router.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-adapter-router.ts
index 6ba8fe359513..012611680254 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-adapter-router.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-adapter-router.ts
@@ -128,9 +128,6 @@ export class StructuredAgentSessionAdapterRouter implements StructuredAgentSessi
   readOptionRestoreFailures = (sessionId: string): readonly string[] =>
     this.owner(sessionId).readOptionRestoreFailures?.(sessionId) ?? []
 
-  readOptionRestoreUnanswered = (sessionId: string): readonly string[] =>
-    this.owner(sessionId).readOptionRestoreUnanswered?.(sessionId) ?? []
-
   historyFilePath = (input: { identity: AgentSessionJournalIdentity }) =>
     this.requireAgent(input.identity).historyFilePath?.(input) ?? Promise.resolve(null)
 
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-adapter.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-adapter.ts
index 87e6cbc7adcf..bdc7dd27d7c7 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-adapter.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-adapter.ts
@@ -153,8 +153,6 @@ export type StructuredAgentSessionStartedEvent = {
   reportedOptions: AgentSessionOptionsResult['current']
   /** Saved options the restore could not apply; the host drops them rather than persist them. */
   restoreSkippedOptions: readonly string[]
-  /** Saved options the CLI never answered a restore write for; the host keeps the saved value. */
-  restoreUnansweredOptions?: readonly string[]
 }
 
 export type StructuredAgentSessionLifecycleEvent =
@@ -293,8 +291,6 @@ export type StructuredAgentSessionAdapter = {
   readOptions?(input: { sessionId: string; fence: number }): Promise<AgentSessionOptionsResult>
   /** Option keys skipped after a provider rejected their persisted restore value. */
   readOptionRestoreFailures?(sessionId: string): readonly string[]
-  /** Saved option keys whose restore write the provider never answered and nothing since set. */
-  readOptionRestoreUnanswered?(sessionId: string): readonly string[]
   /** Transcript path for journal recovery. Omit to let the existing session-file
    *  resolver discover it from the provider session id. */
   historyFilePath?(input: { identity: AgentSessionJournalIdentity }): Promise<string | null>
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-mutation-admission.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-mutation-admission.ts
index faeccccdd149..b735427be0e8 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-mutation-admission.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-mutation-admission.ts
@@ -25,7 +25,6 @@ import type { AgentSessionRecordStore } from '../../runtime/agent-session-record
 import type { AgentSessionJournal } from '../agent-session-journal/journal-store'
 import type { StructuredAgentSessionAdapter } from './structured-agent-session-adapter'
 import type { MutationPlan } from './structured-agent-session-mutation-plans'
-import { withUnansweredSavedOptions } from './structured-agent-session-option-restoration'
 import { runSettledAgentSessionMutation } from './structured-agent-session-operation-settlement'
 import { resolveAgentSessionReplayOutcome } from './structured-agent-session-replay-outcome'
 import type { AgentSessionTurnContext } from './structured-agent-session-turns'
@@ -184,11 +183,7 @@ function turnContext<TValue>(
         .replaceSessionOptions({
           sessionId: request.envelope.sessionId,
           fence,
-          options: withUnansweredSavedOptions(
-            options,
-            request.store.getRecord(request.envelope.sessionId)?.options,
-            request.adapter.readOptionRestoreUnanswered?.(request.envelope.sessionId) ?? []
-          ),
+          options,
           now: request.now()
         })
         .then(() => undefined),
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-option-restoration.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-option-restoration.ts
index 9185b6c89b76..d3461a7e9ee3 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-option-restoration.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-option-restoration.ts
@@ -21,12 +21,10 @@ export async function readNativeSessionOptions(input: {
 }
 
 /** The record's options once the provider has reported: its model, effort and Fast replace the
- *  saved ones, other saved options stay, and any the restore could not apply are dropped. A
- *  restore write the provider never answered proves nothing, so that saved choice is kept. */
+ *  saved ones, other saved options stay, and any the restore could not apply are dropped. */
 export function nativeSessionOptionsFromReport(input: {
   reported: AgentSessionOptionsResult['current']
   restoreSkipped: readonly string[]
-  restoreUnanswered?: readonly string[]
   priorOptions?: Readonly<Record<string, string>>
 }): Readonly<Record<string, string>> {
   const { reported, priorOptions } = input
@@ -41,27 +39,10 @@ export function nativeSessionOptionsFromReport(input: {
     reported.fastMode === undefined
       ? undefined
       : encodeStructuredAgentSessionOptionValue('fastMode', reported.fastMode)
-  return withUnansweredSavedOptions(
-    {
-      ...restored,
-      model: reported.model,
-      ...(reported.effort ? { effort: reported.effort } : {}),
-      ...(fastMode !== undefined && fastMode !== null ? { fastMode } : {})
-    },
-    priorOptions,
-    input.restoreUnanswered ?? []
-  )
-}
-
-/** Options to persist with every saved choice the child never answered a restore write for kept
- *  as saved, so a write the child does apply cannot silently drop one. */
-export function withUnansweredSavedOptions(
-  options: Readonly<Record<string, string>>,
-  saved: Readonly<Record<string, string>> | undefined,
-  unanswered: readonly string[]
-): Readonly<Record<string, string>> {
-  const kept = unanswered.flatMap((key) =>
-    saved?.[key] === undefined ? [] : [[key, saved[key]] as const]
-  )
-  return kept.length === 0 ? options : { ...options, ...Object.fromEntries(kept) }
+  return {
+    ...restored,
+    model: reported.model,
+    ...(reported.effort ? { effort: reported.effort } : {}),
+    ...(fastMode !== undefined && fastMode !== null ? { fastMode } : {})
+  }
 }
diff --git a/src/main/native-chat/agent-session-wire/structured-agent-session-provider-started.ts b/src/main/native-chat/agent-session-wire/structured-agent-session-provider-started.ts
index 09dba75a243c..55c718f967b9 100644
--- a/src/main/native-chat/agent-session-wire/structured-agent-session-provider-started.ts
+++ b/src/main/native-chat/agent-session-wire/structured-agent-session-provider-started.ts
@@ -74,9 +74,6 @@ async function persistStartedOptions(
     options: nativeSessionOptionsFromReport({
       reported: event.reportedOptions,
       restoreSkipped: event.restoreSkippedOptions,
-      ...(event.restoreUnansweredOptions
-        ? { restoreUnanswered: event.restoreUnansweredOptions }
-        : {}),
       ...(record.options ? { priorOptions: record.options } : {})
     }),
     now: context.now()
diff --git a/src/main/native-chat/agent-session-wire/structured-conversation-command.test.ts b/src/main/native-chat/agent-session-wire/structured-conversation-command.test.ts
index 5c82843be9f1..a261c6dd1517 100644
--- a/src/main/native-chat/agent-session-wire/structured-conversation-command.test.ts
+++ b/src/main/native-chat/agent-session-wire/structured-conversation-command.test.ts
@@ -163,16 +163,19 @@ describe('host conversation commands', () => {
     })
   })
 
-  // The replacement's start then retries it, as the source's next start would have.
-  it('starts the replacement from a saved choice the child never answered, not the live value', async () => {
+  // What the child reports can be a value it fell back to, such as a model whose restore write it
+  // never answered; the replacement's start replays the choice, as the source's next start would.
+  it('starts the replacement from the options the user chose, not the values the child reports', async () => {
     await store.replaceSessionOptions({
       sessionId: HOST_TEST_SESSION,
       fence: store.getRecord(HOST_TEST_SESSION)!.lease.runtimeFence,
       options: { model: 'test-model', effort: 'low' },
       now: HOST_TEST_NOW
     })
-    adapter.readOptionRestoreUnanswered = (sessionId) =>
-      sessionId === HOST_TEST_SESSION ? ['effort'] : []
+    adapter.readOptions = async () => ({
+      models: [],
+      current: { model: 'fallback-model', effort: 'high' }
+    })
     const attach = vi.spyOn(host, 'attach')
     expect(await host.conversationCommand(caller, commandParams('clear'))).toMatchObject({
       ok: true
diff --git a/src/main/native-chat/agent-session-wire/structured-conversation-command.ts b/src/main/native-chat/agent-session-wire/structured-conversation-command.ts
index fbe8b1f70126..022343d94070 100644
--- a/src/main/native-chat/agent-session-wire/structured-conversation-command.ts
+++ b/src/main/native-chat/agent-session-wire/structured-conversation-command.ts
@@ -15,7 +15,6 @@ import {
   type AgentSessionAttachParams
 } from './structured-agent-session-attach'
 import { admitAndRunAgentSessionMutation } from './structured-agent-session-mutation-admission'
-import { withUnansweredSavedOptions } from './structured-agent-session-option-restoration'
 import type { StructuredAgentSessionMutationContext } from './structured-agent-session-host-mutations'
 import type { StructuredAgentSessionCaller } from './structured-agent-session-host-types'
 import type { StructuredAgentSessionHost } from './structured-agent-session-host'
@@ -113,39 +112,6 @@ export function runStructuredConversationCommand(
             state: 'unknown' as const,
             ...(replacementSessionId ? { replacementSessionId } : {})
           }
-          let effectiveOptions = record.options
-          if (command === 'clear' && !prior) {
-            try {
-              const options = await ctx.adapter.readOptions?.({ sessionId, fence: ctx.fence })
-              // The replacement starts from the live values, except a saved choice the child
-              // never answered, which its start retries.
-              effectiveOptions = withUnansweredSavedOptions(
-                {
-                  ...record.options,
-                  ...(options
-                    ? {
-                        model: options.current.model,
-                        ...(options.current.effort ? { effort: options.current.effort } : {})
-                      }
-                    : {})
-                },
-                record.options,
-                ctx.adapter.readOptionRestoreUnanswered?.(sessionId) ?? []
-              )
-            } catch {
-              return {
-                ok: false,
-                refusal: {
-                  code: 'agent_session_operation_invalid',
-                  message:
-                    'Could not read the current session configuration. Try again when the provider is connected.'
-                }
-              }
-            }
-          }
-          if (effectiveOptions && command === 'clear') {
-            await ctx.persistOptions(effectiveOptions)
-          }
           await store.setConversationCommand(sessionId, ctx.fence, prepared)
           let error: string | undefined
           if (command === 'clear' && replacementSessionId) {
@@ -167,7 +133,8 @@ export function runStructuredConversationCommand(
               agent: record.provider,
               runtimeKind: 'native',
               launchArgs: record.launchArgs,
-              options: effectiveOptions
+              // The options the user chose, which any restart of this chat would replay too.
+              options: record.options
             }
             attach.envelope.payloadFingerprint = computeAgentSessionPayloadFingerprint({
               method: 'agentSession.attach',
diff --git a/src/main/runtime/claude-structured-startup-unanswered-control-request.test.ts b/src/main/runtime/claude-structured-startup-unanswered-control-request.test.ts
index 7bf1320d8ec3..30531b4a6933 100644
--- a/src/main/runtime/claude-structured-startup-unanswered-control-request.test.ts
+++ b/src/main/runtime/claude-structured-startup-unanswered-control-request.test.ts
@@ -6,8 +6,10 @@
 // the saved choice stays saved for the next start to retry. Against
 // the production runtime, adapter, record store and host, with only the CLI process scripted.
 
+import { createHash } from 'node:crypto'
 import { afterEach, describe, expect, it, vi } from 'vitest'
 import { computeAgentSessionPayloadFingerprint } from '../../shared/agent-session-mutation-envelope'
+import { claudeSessionIdForOrcaSession } from '../claude/claude-structured-launch-resolution'
 import { hostTestMessage } from '../native-chat/agent-session-wire/structured-agent-session-host-test-data'
 import type { StructuredAgentSessionHost } from '../native-chat/agent-session-wire/structured-agent-session-host'
 import { createScriptedClaudeRuntime } from './structured-claude-scripted-runtime-test-support'
@@ -28,6 +30,48 @@ function record(host: StructuredAgentSessionHost) {
   return host.deps.store.getRecord(SESSION)
 }
 
+function operationId(): string {
+  return `${Date.now()}-${(++operations).toString(16).padStart(32, '0')}`
+}
+
+async function setOption(
+  host: StructuredAgentSessionHost,
+  key: string,
+  value: string
+): Promise<void> {
+  const changed = await host.setOption(CALLER, {
+    envelope: {
+      sessionId: SESSION,
+      clientOperationId: operationId(),
+      expectedRuntimeFence: record(host)?.lease.runtimeFence ?? 0,
+      payloadFingerprint: computeAgentSessionPayloadFingerprint({
+        method: 'agentSession.setOption',
+        sessionId: SESSION,
+        fields: { key, value }
+      })
+    },
+    key,
+    value
+  })
+  expect(changed, JSON.stringify(changed)).toMatchObject({ ok: true })
+}
+
+/** What the picker is handed: the value it shows, and which ones the CLI vouched for. */
+async function picker(host: StructuredAgentSessionHost) {
+  const { model, effort, confirmed } = (await host.readOptions(SESSION)).current
+  return { model, effort, confirmed }
+}
+
+/** The CLI opens a turn by naming the model it is actually running. */
+function turnReportsModel(model: string): void {
+  claude.child(SESSION).handlers.onMessage?.({
+    type: 'system',
+    subtype: 'init',
+    session_id: claudeSessionIdForOrcaSession(SESSION),
+    model
+  })
+}
+
 function statusRows(host: StructuredAgentSessionHost): string[] {
   return host
     .journalSnapshot(SESSION)
@@ -100,23 +144,91 @@ describe('a Claude start whose CLI answers initialize but not a control request'
 
     // The CLI answers again; the user sets another option on the running child.
     behavior.optionWritesHang = false
-    const value = 'plan'
-    const changed = await host.setOption(CALLER, {
+    await setOption(host, 'permissionMode', 'plan')
+    expect(record(host)?.options).toMatchObject({ model: 'sonnet', permissionMode: 'plan' })
+  })
+
+  it('replays the unanswered saved model after a turn reports another model, another option changes, and the chat is cleared', async () => {
+    const clearOperation = operationId()
+    const replacement = `clear-${createHash('sha256')
+      .update(JSON.stringify([SESSION, CALLER.callerKey, clearOperation]))
+      .digest('hex')
+      .slice(0, 40)}`
+    claude = createScriptedClaudeRuntime([SESSION, replacement])
+    const behavior = { optionWritesHang: true, controlTimeoutMs: DEADLINE_MS }
+    claude.behave(SESSION, behavior)
+    vi.spyOn(console, 'warn').mockImplementation(() => {})
+    const host = await claude.install()
+    await expect(
+      host.attach(CALLER, claude.attachParams(SESSION, null, { options: { model: 'sonnet' } }))
+    ).resolves.toMatchObject({ ok: true })
+    await vi.waitFor(
+      () => expect(record(host)?.options).toEqual({ model: 'sonnet', effort: 'high' }),
+      { timeout: DEADLINE_MS * 40 }
+    )
+    // The picker offers the saved model, which nothing has vouched for yet.
+    expect(await picker(host)).toEqual({ model: 'sonnet', effort: 'high', confirmed: ['effort'] })
+
+    // A turn shows the child running the CLI's own model: the picker follows it, the record
+    // keeps what the user chose.
+    turnReportsModel('claude-sonnet-5')
+    expect(await picker(host)).toEqual({
+      model: 'claude-sonnet-5',
+      effort: 'high',
+      confirmed: ['model', 'effort']
+    })
+    expect(record(host)?.options).toEqual({ model: 'sonnet', effort: 'high' })
+
+    behavior.optionWritesHang = false
+    await setOption(host, 'permissionMode', 'plan')
+    expect(record(host)?.options).toEqual({ model: 'sonnet', permissionMode: 'plan' })
+
+    const cleared = await host.conversationCommand(CALLER, {
+      command: 'clear',
       envelope: {
         sessionId: SESSION,
-        clientOperationId: `${Date.now()}-${(++operations).toString(16).padStart(32, '0')}`,
+        clientOperationId: clearOperation,
         expectedRuntimeFence: record(host)?.lease.runtimeFence ?? 0,
         payloadFingerprint: computeAgentSessionPayloadFingerprint({
-          method: 'agentSession.setOption',
+          method: 'agentSession.conversationCommand',
           sessionId: SESSION,
-          fields: { key: 'permissionMode', value }
+          fields: { command: 'clear' }
         })
-      },
-      key: 'permissionMode',
-      value
+      }
     })
-    expect(changed, JSON.stringify(changed)).toMatchObject({ ok: true })
-    expect(record(host)?.options).toMatchObject({ model: 'sonnet', permissionMode: 'plan' })
+    expect(cleared, JSON.stringify(cleared)).toMatchObject({
+      ok: true,
+      value: { replacementSessionId: replacement }
+    })
+    // The cleared chat's start replays the saved model rather than the one the turn reported.
+    await vi.waitFor(() => expect(claude.child(replacement).calls).toContain('set_model'))
+    await vi.waitFor(() =>
+      expect(host.deps.store.getRecord(replacement)?.options).toEqual({
+        model: 'sonnet',
+        effort: 'high',
+        permissionMode: 'plan'
+      })
+    )
+    expect(record(host)?.options).toEqual({ model: 'sonnet', permissionMode: 'plan' })
+  })
+
+  it('replaces the unanswered saved model with the one the user then sets', async () => {
+    const behavior = { optionWritesHang: true, controlTimeoutMs: DEADLINE_MS }
+    claude.behave(SESSION, behavior)
+    vi.spyOn(console, 'warn').mockImplementation(() => {})
+    const host = await claude.install()
+    await expect(
+      host.attach(CALLER, claude.attachParams(SESSION, null, { options: { model: 'sonnet' } }))
+    ).resolves.toMatchObject({ ok: true })
+    await vi.waitFor(() => expect(record(host)?.options).toMatchObject({ model: 'sonnet' }), {
+      timeout: DEADLINE_MS * 40
+    })
+    turnReportsModel('claude-sonnet-5')
+
+    behavior.optionWritesHang = false
+    await setOption(host, 'model', 'opus')
+    expect(record(host)?.options).toEqual({ model: 'opus' })
+    expect((await picker(host)).model).toBe('opus')
   })
 
   it("lands with effort unknown when startup's own settings read goes unanswered", async () => {
diff --git a/src/main/runtime/structured-claude-scripted-runtime-test-support.ts b/src/main/runtime/structured-claude-scripted-runtime-test-support.ts
index 4836665d49a3..02438d59664b 100644
--- a/src/main/runtime/structured-claude-scripted-runtime-test-support.ts
+++ b/src/main/runtime/structured-claude-scripted-runtime-test-support.ts
@@ -139,7 +139,13 @@ export function createScriptedClaudeRuntime(sessionIds: readonly string[]) {
         supportedModels: () => {
           child.calls.push('list_models')
           return control('list_models', () =>
-            answer([{ value: 'sonnet', displayName: 'Sonnet' }], false)
+            answer(
+              [
+                { value: 'sonnet', displayName: 'Sonnet' },
+                { value: 'opus', displayName: 'Opus' }
+              ],
+              false
+            )
           )
         },
         setModel: () => optionWrite('set_model'),
diff --git a/src/shared/agent-session-record.ts b/src/shared/agent-session-record.ts
index 2248647c3c22..4e9edcf4c5d0 100644
--- a/src/shared/agent-session-record.ts
+++ b/src/shared/agent-session-record.ts
@@ -129,7 +129,7 @@ export type AgentSessionRecord = {
   provider: AgentSessionHandleProvider
   providerHandleChain: AgentSessionProviderHandleLink[]
   accountHome: AgentSessionAccountHome
-  /** Provider options acknowledged for the next turn, restored across owner replacement. */
+  /** Provider options the user chose, replayed whenever a new owner starts the session. */
   options?: Record<string, string>
   rewind?: AgentSessionRewindRecord
   conversationCommand?: AgentSessionConversationCommandRecord

From ff1c8382ee9dc337d0bd2be4d3bf6ff28407bec5 Mon Sep 17 00:00:00 2001
From: Brennan Benson <79079362+brennanb2025@users.noreply.github.com>
Date: Wed, 23 Sep 2026 20:49:27 -0700
Subject: [PATCH 64/67] test(claude): wait for the start to finish before
 changing the saved model

The record holds the saved model from creation, so waiting for it returned at
once and the option write could reach Claude while it was still starting,
which refuses it. Wait for the effort the finished start reports instead.
---
 ...structured-startup-unanswered-control-request.test.ts | 9 ++++++---
 1 file changed, 6 insertions(+), 3 deletions(-)

diff --git a/src/main/runtime/claude-structured-startup-unanswered-control-request.test.ts b/src/main/runtime/claude-structured-startup-unanswered-control-request.test.ts
index 30531b4a6933..38d0de314d26 100644
--- a/src/main/runtime/claude-structured-startup-unanswered-control-request.test.ts
+++ b/src/main/runtime/claude-structured-startup-unanswered-control-request.test.ts
@@ -220,9 +220,12 @@ describe('a Claude start whose CLI answers initialize but not a control request'
     await expect(
       host.attach(CALLER, claude.attachParams(SESSION, null, { options: { model: 'sonnet' } }))
     ).resolves.toMatchObject({ ok: true })
-    await vi.waitFor(() => expect(record(host)?.options).toMatchObject({ model: 'sonnet' }), {
-      timeout: DEADLINE_MS * 40
-    })
+    // The record holds the saved model from creation; only the start's own report (effort) says
+    // startup finished, and an option write before then is refused as still starting.
+    await vi.waitFor(
+      () => expect(record(host)?.options).toEqual({ model: 'sonnet', effort: 'high' }),
+      { timeout: DEADLINE_MS * 40 }
+    )
     turnReportsModel('claude-sonnet-5')
 
     behavior.optionWritesHang = false

From e9e77073e0f47e075e51f6984a102158848d1895 Mon Sep 17 00:00:00 2001
From: Brennan Benson <79079362+brennanb2025@users.noreply.github.com>
Date: Wed, 23 Sep 2026 20:51:26 -0700
Subject: [PATCH 65/67] fix(i18n): translate the still-starting chat notice

The notice that a structured chat is still starting was only in English.
---
 src/renderer/src/i18n/locales/es.json | 7 +++++++
 src/renderer/src/i18n/locales/fr.json | 7 +++++++
 src/renderer/src/i18n/locales/ja.json | 7 +++++++
 src/renderer/src/i18n/locales/ko.json | 7 +++++++
 src/renderer/src/i18n/locales/zh.json | 7 +++++++
 5 files changed, 35 insertions(+)

diff --git a/src/renderer/src/i18n/locales/es.json b/src/renderer/src/i18n/locales/es.json
index 887ba1980035..67db5baaa2d5 100644
--- a/src/renderer/src/i18n/locales/es.json
+++ b/src/renderer/src/i18n/locales/es.json
@@ -14617,6 +14617,13 @@
           "delete": "Eliminar"
         }
       },
+      "native": {
+        "chat": {
+          "NativeChatStructuredSessionStatus": {
+            "starting": "{{value0}} todavía se está iniciando. Los mensajes esperan hasta que esté listo; cierra este chat para abandonarlo."
+          }
+        }
+      },
       "ComposerParentWorktreePicker": {
         "label": "Worktree padre",
         "noParent": "Sin worktree padre",
diff --git a/src/renderer/src/i18n/locales/fr.json b/src/renderer/src/i18n/locales/fr.json
index d9c5dd5004db..2d43791c0e64 100644
--- a/src/renderer/src/i18n/locales/fr.json
+++ b/src/renderer/src/i18n/locales/fr.json
@@ -15964,6 +15964,13 @@
         "expiredCompact": "Expiré",
         "typeMarkdown": "Markdown",
         "typeHtml": "HTML"
+      },
+      "native": {
+        "chat": {
+          "NativeChatStructuredSessionStatus": {
+            "starting": "{{value0}} est encore en cours de démarrage. Les messages attendent qu'il soit prêt ; fermez ce chat pour y renoncer."
+          }
+        }
       }
     },
     "i18n": {
diff --git a/src/renderer/src/i18n/locales/ja.json b/src/renderer/src/i18n/locales/ja.json
index 4fe965ac48ed..5f21d78eba10 100644
--- a/src/renderer/src/i18n/locales/ja.json
+++ b/src/renderer/src/i18n/locales/ja.json
@@ -14617,6 +14617,13 @@
           "delete": "削除"
         }
       },
+      "native": {
+        "chat": {
+          "NativeChatStructuredSessionStatus": {
+            "starting": "{{value0}} はまだ起動中です。準備ができるまでメッセージは待機します。中止するには、このチャットを閉じてください。"
+          }
+        }
+      },
       "ComposerParentWorktreePicker": {
         "label": "親ワークツリー",
         "noParent": "親なし",
diff --git a/src/renderer/src/i18n/locales/ko.json b/src/renderer/src/i18n/locales/ko.json
index 88ba5814432b..aefde7f8b9a0 100644
--- a/src/renderer/src/i18n/locales/ko.json
+++ b/src/renderer/src/i18n/locales/ko.json
@@ -14694,6 +14694,13 @@
           "delete": "삭제"
         }
       },
+      "native": {
+        "chat": {
+          "NativeChatStructuredSessionStatus": {
+            "starting": "{{value0}}이(가) 아직 시작 중입니다. 준비될 때까지 메시지는 대기합니다. 중단하려면 이 채팅을 닫으세요."
+          }
+        }
+      },
       "ComposerParentWorktreePicker": {
         "label": "상위 워크트리",
         "noParent": "상위 워크트리 없음",
diff --git a/src/renderer/src/i18n/locales/zh.json b/src/renderer/src/i18n/locales/zh.json
index 592a734e077e..bd7f3e1febdc 100644
--- a/src/renderer/src/i18n/locales/zh.json
+++ b/src/renderer/src/i18n/locales/zh.json
@@ -14697,6 +14697,13 @@
           "delete": "删除"
         }
       },
+      "native": {
+        "chat": {
+          "NativeChatStructuredSessionStatus": {
+            "starting": "{{value0}} 仍在启动中。消息会等它就绪后再发送；关闭此聊天即可放弃。"
+          }
+        }
+      },
       "ComposerParentWorktreePicker": {
         "label": "父工作树",
         "noParent": "无父工作树",

From 1b6712519999afba0b1bd9cb116f8501d6cb854c Mon Sep 17 00:00:00 2001
From: Brennan Benson <79079362+brennanb2025@users.noreply.github.com>
Date: Wed, 23 Sep 2026 21:06:24 -0700
Subject: [PATCH 66/67] test(claude): pin the failed acquisition's own
 reading-control release

The merge re-pointed this test at a child that exits after publish, where the
exit path also releases the binding, so it passed with the acquisition's release
deleted. A child that exits before publish leaves only that release. Also drops
the create 'init' phase, which lost its last producer when rewind stopped
proving before publish.
---
 ...structured-session-reading-control.test.ts | 20 ++++++++++---------
 .../agent-session-instrumentation.ts          |  1 -
 .../observability/instrumentation.test.ts     |  7 +++----
 3 files changed, 14 insertions(+), 14 deletions(-)

diff --git a/src/main/claude/claude-structured-session-reading-control.test.ts b/src/main/claude/claude-structured-session-reading-control.test.ts
index b66bd8885c0e..ac07baad22e2 100644
--- a/src/main/claude/claude-structured-session-reading-control.test.ts
+++ b/src/main/claude/claude-structured-session-reading-control.test.ts
@@ -89,13 +89,16 @@ describe('Claude structured reading control', () => {
   })
 
   it('unbinds when acquisition fails after the connection opens', async () => {
-    // A child that exits before acquire returns is refused, not handed over as live.
-    const claude = fakeClaude({ exitBeforeInit: 'claude stream-json exited (code 1)' })
-    const adapter = adapterFor(claude, {
-      resumesTranscript: true,
-      continuesChain: true,
-      resumeLeafUuid: 'tip'
-    })
+    // The child exits before publish, so only the failed acquisition can release the binding.
+    const claude = fakeClaude()
+    const open = claude.openConnection
+    claude.openConnection = async (launch, handlers = {}) => {
+      const connection = await open(launch, handlers)
+      claude.connections[0].closed = true
+      handlers.onExit?.(new Error('claude stream-json exited (code 1)'))
+      return connection
+    }
+    const adapter = adapterFor(claude)
     const events = controlledSink()
 
     await expect(
@@ -106,8 +109,7 @@ describe('Claude structured reading control', () => {
         events: events.sink
       })
     ).rejects.toThrow('exited (code 1)')
-    // The published session's exit path and the failed acquisition both release it; unbind is idempotent.
-    expect(events.unbind).toHaveBeenCalled()
+    expect(events.unbind).toHaveBeenCalledOnce()
   })
 
   it('unbinds when the published provider exits unexpectedly', async () => {
diff --git a/src/main/observability/agent-session-instrumentation.ts b/src/main/observability/agent-session-instrumentation.ts
index 85ecd4f0d452..dc57bd69d0e4 100644
--- a/src/main/observability/agent-session-instrumentation.ts
+++ b/src/main/observability/agent-session-instrumentation.ts
@@ -9,7 +9,6 @@ export type AgentSessionCreatePhase =
   | 'acquire_owner'
   | 'auth_settle'
   | 'spawn'
-  | 'init'
   | 'restore_options'
   | 'publish'
 
diff --git a/src/main/observability/instrumentation.test.ts b/src/main/observability/instrumentation.test.ts
index 62894c0ef9c1..9bdbfd91d026 100644
--- a/src/main/observability/instrumentation.test.ts
+++ b/src/main/observability/instrumentation.test.ts
@@ -258,7 +258,7 @@ describe('agentSession.create tracing', () => {
   it('emits one span with the closed phase vocabulary and no user content attributes', async () => {
     await withAgentSessionSpan(async (span) => {
       addAgentSessionCreatePhaseAttributes(span, {
-        totalDurationMs: 66,
+        totalDurationMs: 57,
         phases: [
           { phase: 'reconcile_leases', startedAtMs: 0, durationMs: 1 },
           { phase: 'resolve_recovery', startedAtMs: 1, durationMs: 2 },
@@ -268,9 +268,8 @@ describe('agentSession.create tracing', () => {
           { phase: 'acquire_owner', startedAtMs: 15, durationMs: 6 },
           { phase: 'auth_settle', startedAtMs: 21, durationMs: 7 },
           { phase: 'spawn', startedAtMs: 28, durationMs: 8 },
-          { phase: 'init', startedAtMs: 36, durationMs: 9 },
-          { phase: 'restore_options', startedAtMs: 45, durationMs: 10 },
-          { phase: 'publish', startedAtMs: 55, durationMs: 11 }
+          { phase: 'restore_options', startedAtMs: 36, durationMs: 10 },
+          { phase: 'publish', startedAtMs: 46, durationMs: 11 }
         ]
       })
     })

From 634f65bd617c5f3f8015061ba4e41df1ff46e53d Mon Sep 17 00:00:00 2001
From: Brennan Benson <79079362+brennanb2025@users.noreply.github.com>
Date: Thu, 24 Sep 2026 15:05:16 -0700
Subject: [PATCH 67/67] refactor(claude): move unexpected-exit handling into
 the exit lifecycle module

The adapter crossed the 300-line limit once main's context-usage change
landed beside this branch's growth. The two methods that turn a Claude
process exit into an ended event now live next to the existing exit
helpers; behavior is unchanged.
---
 .../claude-structured-session-adapter.ts      | 104 ++++--------------
 ...laude-structured-session-exit-lifecycle.ts |  97 +++++++++++++++-
 2 files changed, 116 insertions(+), 85 deletions(-)

diff --git a/src/main/claude/claude-structured-session-adapter.ts b/src/main/claude/claude-structured-session-adapter.ts
index 9c1b00ca6396..d28b07dc16d3 100644
--- a/src/main/claude/claude-structured-session-adapter.ts
+++ b/src/main/claude/claude-structured-session-adapter.ts
@@ -9,7 +9,6 @@ import { dispatchClaudeTurn } from './claude-structured-dispatch'
 import { StructuredSessionCompaction } from '../native-chat/agent-session-wire/structured-session-compaction'
 import { releaseClaudeAcquisition } from './claude-structured-acquisition-release'
 import { acquireClaudeSession } from './claude-structured-session-acquisition'
-import { failClaudeStartupGate } from './claude-structured-session-startup-gate'
 import { supportsClaudeStructuredLocation } from './claude-structured-location-support'
 import { setClaudeStructuredSessionOption } from './claude-structured-options'
 import { readClaudeStructuredSessionOptions } from './claude-structured-session-options'
@@ -21,15 +20,12 @@ import {
   type ClaudeStructuredSessionAdapterDeps,
   type ClaudeStructuredSessionEvent
 } from './claude-structured-session-state'
-import {
-  closeAllClaudeSessions,
-  closeClaudeSession,
-  claudeRootExitObserved,
-  settleClaudeExitedSession
-} from './claude-structured-session-close'
+import { closeAllClaudeSessions, closeClaudeSession } from './claude-structured-session-close'
 import {
   drainClaudeObservedExits,
-  persistClaudeSessionHandle
+  observeClaudeSessionExit,
+  settleClaudeUnexpectedExit,
+  type ClaudeExitLifecycle
 } from './claude-structured-session-exit-lifecycle'
 import type { AgentSessionBackgroundTaskState } from '../../shared/agent-session-wire'
 import { resolveClaudeProviderHistoryWindow } from './claude-structured-history-window'
@@ -56,10 +52,18 @@ export class ClaudeStructuredSessionAdapter implements StructuredAgentSessionAda
   private readonly sessions = new Map<string, ClaudeSession>()
   private readonly acquisitions = new ClaudeAcquisitionRegistry()
   private readonly exits = new Map<string, ClaudeSessionExit>()
-  /** A settled exit's diagnostic, kept for a send admitted before the host heard of the exit. */
   private readonly settledExitErrors = new Map<string, Error>()
+  private readonly exitLifecycle: ClaudeExitLifecycle
 
-  constructor(private readonly deps: ClaudeStructuredSessionAdapterDeps) {}
+  constructor(private readonly deps: ClaudeStructuredSessionAdapterDeps) {
+    this.exitLifecycle = {
+      sessions: this.sessions,
+      exits: this.exits,
+      settledExitErrors: this.settledExitErrors,
+      deps,
+      emit: (session, event) => this.emit(session, event)
+    }
+  }
 
   supportsLocation = supportsClaudeStructuredLocation
 
@@ -80,8 +84,10 @@ export class ClaudeStructuredSessionAdapter implements StructuredAgentSessionAda
       callbacks: {
         deliver: (attempt, sessionId, event) => this.deliver(attempt, sessionId, event),
         emit: (session, _events, event) => this.emit(session, event),
-        handleExit: (sessionId, attempt, error) => this.handleExit(sessionId, attempt, error),
-        settleExit: (sessionId, exit) => this.settleUnexpectedExit(sessionId, exit)
+        handleExit: (sessionId, attempt, error) =>
+          observeClaudeSessionExit(this.exitLifecycle, sessionId, attempt, error),
+        settleExit: (sessionId, exit) =>
+          settleClaudeUnexpectedExit(this.exitLifecycle, sessionId, exit)
       }
     })
   }
@@ -99,36 +105,6 @@ export class ClaudeStructuredSessionAdapter implements StructuredAgentSessionAda
     }
   }
 
-  private handleExit(sessionId: string, attempt: ClaudeAcquisitionAttempt, error: Error): void {
-    const session = this.sessions.get(sessionId)
-    if (!session || session.connection !== attempt.connection) {
-      return
-    }
-    this.sessions.delete(sessionId)
-    failClaudeStartupGate(session, error)
-    // Re-enter the provider's close ladder before publishing lifecycle recovery.
-    // An exit callback is root evidence only; the retained tree proof must run
-    // before the host releases and reacquires this exact child.
-    const closePromise = session.connection.close().catch(() => false)
-    const exit: ClaudeSessionExit = {
-      connection: session.connection,
-      session,
-      error,
-      closePromise
-    }
-    this.exits.set(sessionId, exit)
-    exit.publication = closePromise
-      .then((proven) => {
-        // A failed startup keeps the failed-create bar: a first-hand root exit releases it.
-        const startupFailed = session.startup.state === 'failed'
-        if (!proven && !(startupFailed && claudeRootExitObserved(session.connection))) {
-          return undefined
-        }
-        return this.settleUnexpectedExit(sessionId, exit)
-      })
-      .catch(() => undefined)
-  }
-
   /** Resolves once every first-hand exit observed so far has published its
    *  lifecycle event — or has failed its tree proof and stayed indexed for a
    *  retry. Publication trails observation by the close ladder and the
@@ -140,47 +116,6 @@ export class ClaudeStructuredSessionAdapter implements StructuredAgentSessionAda
   drainStartup = (sessionId: string): Promise<void> =>
     this.sessions.get(sessionId)?.startup.settled ?? Promise.resolve()
 
-  /** Lifecycle recovery is published only after the child tree proof is true. */
-  private settleUnexpectedExit(sessionId: string, exit: ClaudeSessionExit): Promise<void> {
-    exit.settlementPromise ??= (async () => {
-      exit.session.unbindReadingControl?.()
-      if (this.exits.get(sessionId) !== exit) {
-        settleClaudeExitedSession(exit.session)
-        return
-      }
-      // Persist the last completed turn before publishing the lifecycle
-      // event that lets the host release and reacquire this exact child.
-      await persistClaudeSessionHandle(sessionId, exit.session, this.deps).catch(
-        (error: unknown) => {
-          // Recovery still publishes: the record keeps its last durable point, and the loss is logged.
-          console.warn('[claude-resume-point] exit cursor was not persisted:', { sessionId, error })
-        }
-      )
-      if (this.exits.get(sessionId) !== exit) {
-        settleClaudeExitedSession(exit.session)
-        return
-      }
-      this.exits.delete(sessionId)
-      this.settledExitErrors.set(sessionId, exit.error)
-      const ended: ClaudeStructuredSessionEvent = {
-        type: 'ended',
-        sessionId,
-        reason: exit.error.message,
-        cause: 'unexpected-exit',
-        fence: exit.session.fence,
-        acquisitionGeneration: exit.session.acquisitionGeneration,
-        observedAt: this.deps.now?.() ?? Date.now(),
-        ...(exit.session.startup.state === 'proven' ? {} : { startupUnproven: true })
-      }
-      try {
-        this.emit(exit.session, ended)
-      } finally {
-        settleClaudeExitedSession(exit.session)
-      }
-    })()
-    return exit.settlementPromise
-  }
-
   /** Restart reconciliation reads the transcript a resume replays; these maps track liveness. */
   providerHistoryWindow: NonNullable<StructuredAgentSessionAdapter['providerHistoryWindow']> = (
     input
@@ -292,7 +227,8 @@ export class ClaudeStructuredSessionAdapter implements StructuredAgentSessionAda
       sessions: this.sessions,
       acquisitions: this.acquisitions,
       exits: this.exits,
-      onExitProven: (sessionId, exit) => this.settleUnexpectedExit(sessionId, exit),
+      onExitProven: (sessionId, exit) =>
+        settleClaudeUnexpectedExit(this.exitLifecycle, sessionId, exit),
       ...(this.deps.persistHandle ? { persistHandle: this.deps.persistHandle } : {}),
       ...(this.deps.onBackgroundTasksChanged
         ? { onBackgroundTasksChanged: this.deps.onBackgroundTasksChanged }
diff --git a/src/main/claude/claude-structured-session-exit-lifecycle.ts b/src/main/claude/claude-structured-session-exit-lifecycle.ts
index f8a4f6bf8e61..fb1ab1943b4b 100644
--- a/src/main/claude/claude-structured-session-exit-lifecycle.ts
+++ b/src/main/claude/claude-structured-session-exit-lifecycle.ts
@@ -1,10 +1,105 @@
 import { settledClaudeTurnEndLeaf } from './claude-structured-resume-point'
+import {
+  claudeRootExitObserved,
+  settleClaudeExitedSession
+} from './claude-structured-session-close'
+import { failClaudeStartupGate } from './claude-structured-session-startup-gate'
 import type {
+  ClaudeAcquisitionAttempt,
   ClaudeSession,
   ClaudeSessionExit,
-  ClaudeStructuredSessionAdapterDeps
+  ClaudeStructuredSessionAdapterDeps,
+  ClaudeStructuredSessionEvent
 } from './claude-structured-session-state'
 
+export type ClaudeExitLifecycle = {
+  sessions: Map<string, ClaudeSession>
+  exits: Map<string, ClaudeSessionExit>
+  /** A settled exit's diagnostic, kept for a send admitted before the host heard of the exit. */
+  settledExitErrors: Map<string, Error>
+  deps: Pick<ClaudeStructuredSessionAdapterDeps, 'persistHandle' | 'now'>
+  emit: (session: ClaudeSession, event: ClaudeStructuredSessionEvent) => void
+}
+
+export function observeClaudeSessionExit(
+  lifecycle: ClaudeExitLifecycle,
+  sessionId: string,
+  attempt: ClaudeAcquisitionAttempt,
+  error: Error
+): void {
+  const session = lifecycle.sessions.get(sessionId)
+  if (!session || session.connection !== attempt.connection) {
+    return
+  }
+  lifecycle.sessions.delete(sessionId)
+  failClaudeStartupGate(session, error)
+  // Re-enter the provider's close ladder before publishing lifecycle recovery.
+  // An exit callback is root evidence only; the retained tree proof must run
+  // before the host releases and reacquires this exact child.
+  const closePromise = session.connection.close().catch(() => false)
+  const exit: ClaudeSessionExit = {
+    connection: session.connection,
+    session,
+    error,
+    closePromise
+  }
+  lifecycle.exits.set(sessionId, exit)
+  exit.publication = closePromise
+    .then((proven) => {
+      // A failed startup keeps the failed-create bar: a first-hand root exit releases it.
+      const startupFailed = session.startup.state === 'failed'
+      if (!proven && !(startupFailed && claudeRootExitObserved(session.connection))) {
+        return undefined
+      }
+      return settleClaudeUnexpectedExit(lifecycle, sessionId, exit)
+    })
+    .catch(() => undefined)
+}
+
+/** Lifecycle recovery is published only after the child tree proof is true. */
+export function settleClaudeUnexpectedExit(
+  lifecycle: ClaudeExitLifecycle,
+  sessionId: string,
+  exit: ClaudeSessionExit
+): Promise<void> {
+  const { exits, deps } = lifecycle
+  exit.settlementPromise ??= (async () => {
+    exit.session.unbindReadingControl?.()
+    if (exits.get(sessionId) !== exit) {
+      settleClaudeExitedSession(exit.session)
+      return
+    }
+    // Persist the last completed turn before publishing the lifecycle
+    // event that lets the host release and reacquire this exact child.
+    await persistClaudeSessionHandle(sessionId, exit.session, deps).catch((error: unknown) => {
+      // Recovery still publishes: the record keeps its last durable point, and the loss is logged.
+      console.warn('[claude-resume-point] exit cursor was not persisted:', { sessionId, error })
+    })
+    if (exits.get(sessionId) !== exit) {
+      settleClaudeExitedSession(exit.session)
+      return
+    }
+    exits.delete(sessionId)
+    lifecycle.settledExitErrors.set(sessionId, exit.error)
+    const ended: ClaudeStructuredSessionEvent = {
+      type: 'ended',
+      sessionId,
+      reason: exit.error.message,
+      cause: 'unexpected-exit',
+      fence: exit.session.fence,
+      acquisitionGeneration: exit.session.acquisitionGeneration,
+      observedAt: deps.now?.() ?? Date.now(),
+      ...(exit.session.startup.state === 'proven' ? {} : { startupUnproven: true })
+    }
+    try {
+      lifecycle.emit(exit.session, ended)
+    } finally {
+      settleClaudeExitedSession(exit.session)
+    }
+  })()
+  return exit.settlementPromise
+}
+
 /** Wait for each first-hand exit's publication, including exits observed while waiting. */
 export async function drainClaudeObservedExits(
   exits: Map<string, ClaudeSessionExit>