fix(claude): open structured chat without a startup deadline, and make Retry start fresh

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'
 
@@ -46,33 +55,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 = setTimeout(() => reject(new ClaudeControlRequestTimeoutError(subtype)), 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 +103,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>
   /** The `/context` breakdown; older CLIs reject the request and the caller shows nothing. */
   getContextUsage: (options?: ClaudeControlOptions) => Promise<unknown>
@@ -144,8 +155,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),
     getContextUsage: (options) =>
       runClaudeControl('get_context_usage', () => query.getContextUsage(), options?.timeoutMs),
     getSettings: (options) => {

src/main/claude/claude-stream-json-connection.test.ts

@@ -515,10 +515,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)
@@ -567,17 +569,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 () => {

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' }
   }
 }
 

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)
@@ -257,6 +269,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 () => {
@@ -268,13 +295,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))

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
   }

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,14 +58,16 @@ 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,
     resolveWorkspacePath: async (id) => `/repos/${id}`,
     resolveCommand: () => '/usr/local/bin/claude',
     resolveAuthPolicy: () => ({ stripAuthEnv }),
     resolvePermissionMode: () => claudeStructuredPermissionModeForSettings({ agentDefaultArgs }),
+    hasTranscript,
     ...(resolveEnv ? { resolveEnv } : {})
   })
 }
@@ -115,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,
@@ -149,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')
     // Claude owns where the conversation continues; a stored leaf would cut or branch it.
@@ -202,6 +206,37 @@ describe('claude structured launch resolution', () => {
     expect(launch.options).not.toHaveProperty('resumeSessionAt')
   })
 
+  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,
+      resumesTranscript: false,
+      // Launching the id fresh does not start a new conversation: the child continues the chain.
+      continuesChain: true
+    })
+  })
+
   // 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([