Wait for agent readiness without blocking native chat

config/scripts/vitest-sqlite-runtime-files.mjs

@@ -2,6 +2,7 @@ import { SQLITE_DATABASE_RUNTIME_INCLUDE } from './vitest-sqlite-database-runtim
 
 // Real SQLite fixtures keep Node publication and close semantics.
 export const SQLITE_RUNTIME_INCLUDE = [
+  'tests/e2e/native-chat-startup-option-pickers.unit.test.ts',
   ...SQLITE_DATABASE_RUNTIME_INCLUDE,
   'src/main/ipc/repos/project-host-setup-wsl-move-fence.test.ts',
   'src/main/ipc/repos/repo-ipc-wsl-move-fence.test.ts',
@@ -141,6 +142,8 @@ export const SQLITE_RUNTIME_INCLUDE = [
   'src/main/native-chat/agent-session-wire/structured-agent-session-provider-restore.test.ts',
   'src/main/native-chat/agent-session-wire/structured-agent-session-provider-started-catalog.test.ts',
   'src/main/native-chat/agent-session-wire/structured-agent-session-provider-started.test.ts',
+  'src/main/native-chat/agent-session-wire/structured-agent-session-provider-open.test.ts',
+  'src/main/native-chat/agent-session-wire/structured-agent-session-ready-operation-order.test.ts',
   'src/main/native-chat/agent-session-wire/structured-agent-session-queued-action-receipts.test.ts',
   'src/main/native-chat/agent-session-wire/structured-agent-session-queued-gate.test.ts',
   'src/main/native-chat/agent-session-wire/structured-agent-session-queued-newer-orca.test.ts',
@@ -185,6 +188,8 @@ export const SQLITE_RUNTIME_INCLUDE = [
   'src/main/native-chat/agent-session-wire/structured-agent-session-start-failure-writer.test.ts',
   'src/main/native-chat/agent-session-wire/structured-agent-session-startup-attempt-host.test.ts',
   'src/main/native-chat/agent-session-wire/structured-agent-session-startup-attempt-registrations.test.ts',
+  'src/main/native-chat/agent-session-wire/structured-agent-session-startup-picks.test.ts',
+  'src/main/native-chat/agent-session-wire/structured-agent-session-startup-permission-mode.test.ts',
   'src/main/native-chat/agent-session-wire/structured-agent-session-startup-reconcile-failure.test.ts',
   'src/main/native-chat/agent-session-wire/structured-agent-session-status-feed-child-work.test.ts',
   'src/main/native-chat/agent-session-wire/structured-agent-session-status-feed-child.test.ts',

src/main/acp/acp-structured-host-option-hang.test.ts

@@ -68,21 +68,26 @@ describe('a Grok model pick Grok never answers', () => {
   })
 
   it('fails at its bound, frees the chat, and keeps what Grok answers late', async () => {
-    const { rig, host } = await openAttachedHostRig({ optionWriteTimeoutMs: 100 })
+    const { rig, host, store, fence } = await openAttachedHostRig({ optionWriteTimeoutMs: 100 })
     const picking = pick(host, 'grok-4.6')
     await waitFor(() => expect(framesOf(rig.child(), 'session/set_config_option')).toHaveLength(1))
     expect(failed(await within(picking, 2_000))).toBe(true)
     // The chat's queue moved on: a later operation runs.
     expect(await within(host.readOptions(SESSION), 1_000)).not.toBe('pending')
     const [frame] = framesOf(rig.child(), 'session/set_config_option')
+    const savedModel = store.getRecord(SESSION)?.options?.model
     rig.child().agent.reply(frame!, {
       configOptions: GROK_CONFIG_OPTIONS.map((option) =>
         option.id === 'model' ? { ...option, currentValue: 'grok-4.6' } : option
       )
     })
     await waitFor(async () =>
-      expect((await host.readOptions(SESSION)).current).toMatchObject({ model: 'grok-4.6' })
+      expect(
+        (await rig.adapter.readOptions({ sessionId: SESSION, fence: fence() })).current.model
+      ).toBe('grok-4.6')
     )
+    expect((await host.readOptions(SESSION)).current.model).toBe(savedModel)
+    expect(store.getRecord(SESSION)?.options?.model).toBe(savedModel)
     await host.close(SESSION, 'user-close')
   })
 })

src/main/acp/acp-structured-session-adapter-resume.test.ts

@@ -334,7 +334,7 @@ describe('reattaching a Grok chat the journal holds', () => {
         handle: { nativeId: PROVIDER_SESSION },
         replaces: { key: 'acp-key-saved-1', reason: 'restore-failed', replacedAt: 5_000 }
       })
-      expect(acquired.link.supersedesKey).toBeUndefined()
+      expect(acquired.link?.supersedesKey).toBeUndefined()
       expect(rig.sent('session/new')).toHaveLength(1)
       const rows = await notRestoredRows(rig)
       expect(rows).toHaveLength(1)

src/main/claude/claude-structured-applied-options.test.ts

@@ -5,7 +5,8 @@ import {
   acquired,
   adapterFor,
   fakeClaude,
-  identityFor
+  identityFor,
+  claudeOpened
 } from './claude-structured-session-test-support'
 
 /** Verbatim rows from Claude Code 2.1.280's list_models: `default` is the CLI's own
@@ -134,12 +135,10 @@ describe('Claude model before the first turn', () => {
     const events: ClaudeStructuredSessionEvent[] = []
     const adapter = await acquired(startedWithoutATurn(SETTINGS.noOverride), {}, events)
 
-    const started = events.find((event) => event.type === 'started')
+    const started = await claudeOpened(adapter, 'session-1')
     expect(started).toMatchObject({ reportedOptions: { model: 'opus[1m]' } })
     // Saved, it would be restored on every reopen past a later settings.json change.
-    expect(started?.type === 'started' ? started.reportedOptions : null).not.toHaveProperty(
-      'effort'
-    )
+    expect(started.reportedOptions).not.toHaveProperty('effort')
     const reported = events.find((event) => event.type === 'options-reported')
     expect(
       reported?.type === 'options-reported' ? reported.reportedOptions : null
@@ -174,8 +173,8 @@ describe('Claude model before the first turn', () => {
     })
 
     // `started` is persisted as the session's options; opus's effort must not ride along onto haiku.
-    const started = events.find((event) => event.type === 'started')
+    const started = await claudeOpened(adapter, 'session-1')
     expect(started).toMatchObject({ reportedOptions: { model: 'haiku' } })
-    expect(started?.type === 'started' ? started.reportedOptions.effort : null).toBeUndefined()
+    expect(started.reportedOptions.effort).toBeUndefined()
   })
 })

src/main/claude/claude-structured-dispatch-test-support.ts

@@ -5,7 +5,8 @@ import type { ClaudeSession } from './claude-structured-session-state'
 import { ClaudeBackgroundTaskTracker } from './claude-background-task-tracker'
 import { ClaudeChildWorkDecoder } from './claude-child-work-decoder'
 import { ClaudeSlashCommandCatalog } from './claude-slash-command-catalog'
-import { createClaudeSessionStartup } from './claude-structured-session-startup-state'
+import { createClaudeInitProof } from './claude-structured-init-proof'
+import { claudeProviderHandleLink } from './claude-structured-owner-identity'
 
 export function sessionFor(send: Mock = vi.fn().mockResolvedValue(undefined)): ClaudeSession {
   return {
@@ -34,7 +35,19 @@ export function sessionFor(send: Mock = vi.fn().mockResolvedValue(undefined)): C
     capabilities: [],
     events: undefined,
     translator: null,
-    startup: { ...createClaudeSessionStartup(), state: 'proven' }
+    link: claudeProviderHandleLink({
+      sessionId: 'provider-session',
+      leafUuid: null,
+      resumed: false,
+      fence: 1,
+      observedAt: 1
+    }),
+    initialization: {
+      proof: createClaudeInitProof(),
+      account: undefined,
+      resumesTranscript: false,
+      onLateRefusal: () => {}
+    }
   }
 }
 

src/main/claude/claude-structured-dispatch-waiters.ts

@@ -15,7 +15,7 @@ export function forgetRetiredWaiter(session: ClaudeSession, waiter: ClaudeDispat
  * starts — an interval bounded only by the previous turn. Elapsed time is
  * therefore not evidence about delivery, and nothing here expires. Waiters end
  * by provider and process facts instead: an echo, a `command_lifecycle` frame,
- * the CLI's idle after `started` (`claude-command-lifecycle.ts`), a failed
+ * the CLI's idle after open (`claude-command-lifecycle.ts`), a failed
  * write, or child exit.
  */
 export function waitForReplay(

src/main/claude/claude-structured-dispatch.ts

@@ -28,10 +28,6 @@ import {
   claudeUserMessageWasProvablyUnwritten
 } from './claude-agent-sdk-user-message-queue'
 import { AgentSessionPreDispatchError } from '../native-chat/agent-session-wire/structured-agent-session-operation-settlement'
-import {
-  claudeStartupFailureFact,
-  failClaudeStartup
-} from './claude-structured-session-startup-state'
 
 const MAX_ACTIVE_DISPATCH_WAITERS = 64
 
@@ -99,7 +95,6 @@ export function releaseClaudeDispatchWaitersInDoubt(
  *  CLI's idle has not. Retired rather than dropped: their identities stay joinable, bounded by
  *  `MAX_RETIRED_DISPATCH_WAITERS`. */
 export function retireClaudeDispatchWaiters(session: ClaudeSession): void {
-  failClaudeStartup(session, new Error('claude stream-json ended before startup completed'))
   for (const waiter of session.dispatchWaiters.splice(0)) {
     retireWaiter(session, waiter)
     waiter.resolve(null)
@@ -132,14 +127,6 @@ export async function dispatchClaudeTurn(
   if (session.dispatchWaiters.length >= MAX_ACTIVE_DISPATCH_WAITERS) {
     return { state: 'rejected', ...claudeDispatchRejection(agentSessionFailureFact('queueFull')) }
   }
-  const startupFailure = claudeStartupFailureFact(session)
-  if (startupFailure) {
-    // Refused before the write, so the agent never saw it.
-    return {
-      state: 'rejected',
-      ...claudeDispatchRejection({ ...startupFailure, neverReachedAgent: true })
-    }
-  }
   // 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)

src/main/claude/claude-structured-effort-default-at-rest.test.ts

@@ -27,7 +27,8 @@ import {
   fakeClaude,
   identityFor,
   recordingJournalSink,
-  claudeStartupSettled
+  claudeStartupSettled,
+  claudeOpened
 } from './claude-structured-session-test-support'
 
 const SESSION = 'session-1'
@@ -396,14 +397,13 @@ describe('Claude effort default at rest', () => {
   it("never saves the applied effort as the chat's pick, yet shows it at rest", async () => {
     const store = new AgentModelCatalogStore()
     const events: ClaudeStructuredSessionEvent[] = []
-    await startChild(store, undefined, events)
+    const adapter = await startChild(store, undefined, events)
 
-    const started = events.find((event) => event.type === 'started')
-    const reported = started?.type === 'started' ? started.reportedOptions : null
+    const reported = (await claudeOpened(adapter, SESSION)).reportedOptions
     expect(reported).not.toHaveProperty('effort')
     // The record the start persists names the listed row the catalog learned under.
     const record = restingRecord(
-      nativeSessionOptionsFromReport({ reported: reported!, restoreSkipped: [] })
+      nativeSessionOptionsFromReport({ reported: reported, restoreSkipped: [] })
     )
     expect(record.options).toEqual({ model: 'opus[1m]' })
     expect((await readAtRest(store, record)).current.effort).toBe('medium')

src/main/claude/claude-structured-event-delivery.ts

@@ -45,13 +45,6 @@ export function emitClaudeStructuredSessionEvent({
   const retired =
     event.type === 'message' && session ? retireClaudeLaunchedModel(session, event.message) : null
   if (session && retired !== null) {
-    deps.onEvent?.({
-      type: 'options-skipped',
-      sessionId: event.sessionId,
-      fence: session.fence,
-      acquisitionGeneration: session.acquisitionGeneration,
-      options: { model: retired }
-    })
     resetClaudeRetiredModel(session, deps, event.sessionId, retired)
   }
   publishChildWork(event.sessionId, session, event.type === 'message' ? event.message : null)

src/main/claude/claude-structured-options.test.ts

@@ -5,7 +5,8 @@ import { ClaudeControlRequestTimeoutError } from './claude-agent-sdk-control-req
 import { ClaudeBackgroundTaskTracker } from './claude-background-task-tracker'
 import { ClaudeChildWorkDecoder } from './claude-child-work-decoder'
 import { ClaudeSlashCommandCatalog } from './claude-slash-command-catalog'
-import { createClaudeSessionStartup } from './claude-structured-session-startup-state'
+import { createClaudeInitProof } from './claude-structured-init-proof'
+import { claudeProviderHandleLink } from './claude-structured-owner-identity'
 import {
   observeClaudeFastModeFacts,
   readClaudeStructuredSessionOptions
@@ -43,7 +44,19 @@ function sessionFor(setModel: ClaudeSession['connection']['setModel']): ClaudeSe
     capabilities: [],
     events: undefined,
     translator: null,
-    startup: { ...createClaudeSessionStartup(), state: 'proven' }
+    link: claudeProviderHandleLink({
+      sessionId: 'provider-session',
+      leafUuid: null,
+      resumed: false,
+      fence: 1,
+      observedAt: 1
+    }),
+    initialization: {
+      proof: createClaudeInitProof(),
+      account: undefined,
+      resumesTranscript: false,
+      onLateRefusal: () => {}
+    }
   }
 }
 

src/main/claude/claude-structured-options.ts

@@ -47,15 +47,6 @@ export function setClaudeStructuredSessionOption(
   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; options can be changed once it is ready.',
-        'providerStarting'
-      )
-    )
-  }
   return setClaudeStructuredOption(session, input, timeoutMs)
 }
 

src/main/claude/claude-structured-prompt-ownership.ts

@@ -65,7 +65,7 @@ export async function cancelClaudeStructuredTurn(input: {
   const acquisitionGeneration = session.acquisitionGeneration
   // A CLI still starting answers no interrupt: Stop ends its child next (`stopEndsSession`), and
   // that end settles every message it was handed and never echoed as stopped.
-  if (request.prompt || session.startup.state === 'pending') {
+  if (request.prompt) {
     return { cancelled: false }
   }
   const requestedTurnId = request.turnId