Sleep stops a workspace's native chat agents

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

@@ -250,13 +250,13 @@ export class AcpStructuredSessionAdapter implements StructuredAgentSessionAdapte
     input
   ) => stopAcpChildren(this.live(input.sessionId), input.fence, input.taskIds, input.acknowledge)
 
-  backgroundTaskStops: NonNullable<StructuredAgentSessionAdapter['backgroundTaskStops']> = (
-    sessionId
-  ) => acpChildStopCapabilities(this.sessions.get(sessionId))
+  backgroundTaskStops = (id: string) => acpChildStopCapabilities(this.sessions.get(id))
 
   closeSession = (sessionId: string): Promise<boolean> => this.close(sessionId)
   disposeSession = (sessionId: string): Promise<boolean> => this.close(sessionId)
   releaseAcquisition = (input: { sessionId: string }) => this.close(input.sessionId)
+  hasOwnedAcquisition = (sessionId: string): boolean =>
+    this.sessions.has(sessionId) || this.starts.failedSessionIds().includes(sessionId)
   /** After a sink failure: the exit is recovered as unexpected. */
   forceCloseSession = (sessionId: string): Promise<boolean> => this.stop(sessionId, false)
 

src/main/claude/claude-structured-session-acquisition.ts

@@ -286,9 +286,9 @@ export async function acquireClaudeSession({
       sessions,
       attempt,
       translator,
-      prompts
+      prompts,
+      releaseAcquisition: () => acquisitions.deleteIfCurrent(sessionId, attempt)
     })
-    acquisitions.deleteIfCurrent(sessionId, attempt)
     throw acquisitionError
   } finally {
     attempt.finish()

src/main/claude/claude-structured-session-adapter.ts

@@ -262,6 +262,10 @@ export class ClaudeStructuredSessionAdapter implements StructuredAgentSessionAda
 
   releaseAcquisition = (input: { sessionId: string }): Promise<boolean> =>
     this.afterClose(input.sessionId, () => this.releaseProviderSession(input.sessionId))
+  hasOwnedAcquisition = (sessionId: string): boolean =>
+    this.acquisitions.get(sessionId) !== undefined ||
+    this.sessions.has(sessionId) ||
+    this.exits.has(sessionId)
 
   /** A close clears the session's tasks outside `emit`; its ending still reaches the host. */
   private async afterClose(sessionId: string, close: () => Promise<boolean>): Promise<boolean> {

src/main/claude/claude-structured-session-close.ts

@@ -43,13 +43,15 @@ export function claudeAcquisitionCleanupError(
     : new AgentSessionAcquisitionExitUnprovenError(cause)
 }
 
+/** An unproven exit keeps the acquisition so a later stop can still prove its root gone. */
 export async function resolveClaudeAcquisitionError(input: {
   error: unknown
   sessionId: string
   sessions: Map<string, ClaudeSession>
   attempt: ClaudeAcquisitionAttempt
   translator: ClaudeJournalTranslator | null
   prompts: ClaudePromptRegistry
+  releaseAcquisition: () => void
 }): Promise<unknown> {
   let acquisitionError = input.error
   if (input.sessions.get(input.sessionId)?.connection !== input.attempt.connection) {
@@ -64,6 +66,9 @@ export async function resolveClaudeAcquisitionError(input: {
       acquisitionError = claudeAcquisitionCleanupError(input.attempt.connection, input.error)
     }
   }
+  if (!(acquisitionError instanceof AgentSessionAcquisitionExitUnprovenError)) {
+    input.releaseAcquisition()
+  }
   return acquisitionError
 }
 
@@ -283,6 +288,10 @@ export async function closeClaudeSession(input: {
     )
     // Why: cancellation must preserve the same actionable verdict as published-session close.
     if (!(cleanupError instanceof AgentSessionAcquisitionExitUnprovenError)) {
+      // A proved-dead attempt cannot remain the owner blocking the next start.
+      if (attempt) {
+        input.acquisitions.deleteIfCurrent(input.sessionId, attempt)
+      }
       throw cleanupError
     }
     return false

src/main/codex/codex-app-server-connection.test.ts

@@ -796,18 +796,14 @@ describe('openCodexAppServerConnection', () => {
       },
       spawnImpl
     )
-    child.kill.mockImplementation(() => {
-      child.emit('exit', null, 'SIGKILL')
-      return true
-    })
-
     const inFlight = rejection(connection.request('turn/start'))
     child.stdout.write(`${JSON.stringify(frame)}\n`)
 
     expect((await inFlight).message).toContain('structured sink failed')
-    expect(exits).toEqual([expect.stringContaining('structured sink failed')])
+    expect(exits).toHaveLength(0)
     expect(connection.closed).toBe(true)
-    await vi.waitFor(() => expect(child.kill).toHaveBeenCalledWith('SIGKILL'))
+    child.emit('exit', null, 'SIGKILL')
+    expect(exits).toEqual([expect.stringContaining('structured sink failed')])
     await connection.close()
   })
 
@@ -869,20 +865,16 @@ describe('openCodexAppServerConnection', () => {
       { onExit: (error) => exits.push(error.message) },
       spawnImpl
     )
-    child.kill.mockImplementation(() => {
-      child.emit('exit', null, 'SIGKILL')
-      return true
-    })
-
     const inFlight = rejection(connection.request('turn/start'))
     child.stdin.emit('error', new Error('write EPIPE'))
 
     expect((await inFlight).message).toContain('EPIPE')
-    expect(exits).toHaveLength(1)
+    expect(exits).toHaveLength(0)
     // A child nobody can write to is not a live session: the owner must see the
     // connection as gone rather than keep issuing calls that can only time out.
     expect(connection.closed).toBe(true)
-    await vi.waitFor(() => expect(child.kill).toHaveBeenCalledWith('SIGKILL'))
+    child.emit('exit', null, 'SIGKILL')
+    expect(exits).toHaveLength(1)
     expect((await rejection(connection.request('turn/start'))).message).toContain('EPIPE')
     await connection.close()
   })

src/main/codex/codex-app-server-connection.ts

@@ -51,7 +51,7 @@ export async function openCodexAppServerConnection(
     site: 'codex-app-server-teardown',
     ...(handlers.onOutput ? { onOutput: handlers.onOutput } : {})
   })
-  const { child, terminateTree: terminateProcessTree } = managed
+  const { child } = managed
 
   let nextRequestId = 1
   let closing = false
@@ -71,7 +71,7 @@ export async function openCodexAppServerConnection(
     writeResponse,
     onProtocolFailure: (error) => {
       handleUnexpectedEnd(error)
-      void terminateProcessTree()
+      void managed.close()
     }
   })
 
@@ -108,7 +108,7 @@ export async function openCodexAppServerConnection(
       return
     }
     handleUnexpectedEnd(error)
-    void terminateProcessTree()
+    void managed.close()
   })
 
   const recordReader = createProviderRecordReader({
@@ -129,7 +129,7 @@ export async function openCodexAppServerConnection(
     },
     onFatal: (error) => {
       handleUnexpectedEnd(error)
-      void terminateProcessTree()
+      void managed.close()
     }
   })
 

src/main/codex/codex-structured-session-adapter.ts

@@ -334,6 +334,8 @@ export class CodexStructuredSessionAdapter implements StructuredAgentSessionAdap
   closeAll = (): Promise<void> => this.teardown.closeAll()
   releaseAcquisition = (input: { sessionId: string }): Promise<boolean> =>
     this.teardown.close(input.sessionId)
+  hasOwnedAcquisition = (sessionId: string): boolean =>
+    this.acquisitions.get(sessionId) !== undefined || this.sessions.has(sessionId)
 
   private session(sessionId: string): CodexSession {
     return requireLiveCodexSession(this.sessions, sessionId)

src/main/grok/grok-transcript-import.ts

@@ -11,6 +11,10 @@ export const GROK_TRANSCRIPT_IMPORT = directoryTranscriptImport({
     resolveGrokHomeDir()
   ],
   findTranscript: async ({ providerSessionId, store, workspaceCwd, strictErrors }) =>
-    (await findGrokChatHistoryByCwd({ sessionId: providerSessionId, cwd: workspaceCwd, sessionsDir: store })) ??
+    (await findGrokChatHistoryByCwd({
+      sessionId: providerSessionId,
+      cwd: workspaceCwd,
+      sessionsDir: store
+    })) ??
     resolveSessionFilePath('grok', providerSessionId, { grokSessionsDir: store, strictErrors })
 })

src/main/native-chat/agent-session-journal/adopted-transcript-source.ts

@@ -36,7 +36,9 @@ export function adoptedTranscriptSourceObserver(input: {
   maxSourceBytes: number
 }) {
   let sessionId: string | null =
-    input.agent === 'claude' || input.agent === 'codex' ? sessionIdFromFileName(input.filePath) : null
+    input.agent === 'claude' || input.agent === 'codex'
+      ? sessionIdFromFileName(input.filePath)
+      : null
   let cwd: string | null = null
   let sawCodexMetadata = false
   return {

src/main/native-chat/agent-session-journal/journal-legacy-import.ts

@@ -10,7 +10,11 @@
 // never be spliced into a sequence space that a structured session is also
 // writing; a later structured resume rolls the epoch again and rebuilds.
 
-import { adoptedTranscriptSourceObserver, validateAdoptedOpenCodeSource, type AdoptedTranscriptSource } from './adopted-transcript-source'
+import {
+  adoptedTranscriptSourceObserver,
+  validateAdoptedOpenCodeSource,
+  type AdoptedTranscriptSource
+} from './adopted-transcript-source'
 import { createReadStream } from 'node:fs'
 import type { AgentType } from '../../../shared/agent-status-types'
 import type {
@@ -215,10 +219,14 @@ async function decodeReplacementItems(input: {
   source?: AdoptedTranscriptSource
   limits: JournalPayloadLimits
 }): Promise<{ items: JournalReplacementItem[]; consumedBytes: number }> {
-  const source = input.source ? adoptedTranscriptSourceObserver({
-    agent: input.agent, filePath: input.filePath, source: input.source,
-    maxSourceBytes: MAX_LEGACY_IMPORT_RECORD_BYTES
-  }) : null
+  const source = input.source
+    ? adoptedTranscriptSourceObserver({
+        agent: input.agent,
+        filePath: input.filePath,
+        source: input.source,
+        maxSourceBytes: MAX_LEGACY_IMPORT_RECORD_BYTES
+      })
+    : null
   const tracker = createLegacyIdentityTracker({
     transcriptAgent: input.transcriptAgent,
     agent: input.agent,

src/main/native-chat/agent-session-wire/structured-agent-session-acquisition-route.ts

@@ -0,0 +1,114 @@
+import { stopAgentSessionProviderRoot } from './structured-agent-session-provider-exit-proof'
+import type { StructuredAgentSessionAcquisitionReceipt } from './structured-agent-session-startup-attempt-contract'
+import type { StructuredAgentRegistration } from './structured-agent-registry'
+import type {
+  StructuredAgentSessionAcquireInput,
+  StructuredAgentSessionAdapter
+} from './structured-agent-session-adapter'
+
+export type SessionRoute = {
+  registration: StructuredAgentRegistration
+  state: 'acquiring' | 'live' | 'stopped'
+  acquisition?: StructuredAgentSessionAcquisitionReceipt
+}
+
+/** The route retains the actual startup identity until its exit is durably acknowledged. */
+export async function acquireSessionRoute(
+  input: StructuredAgentSessionAcquireInput,
+  registration: StructuredAgentRegistration,
+  routes: Map<string, SessionRoute>,
+  isClosed: () => boolean
+) {
+  const route: SessionRoute = {
+    registration,
+    state: 'acquiring',
+    ...(input.attemptId && input.launch
+      ? {
+          acquisition: {
+            attemptId: input.attemptId,
+            fence: input.fence,
+            spawnToken: input.spawnToken,
+            location: input.launch.location
+          }
+        }
+      : {})
+  }
+  routes.set(input.identity.sessionId, route)
+  try {
+    const acquired = await registration.adapter.acquire({
+      ...input,
+      onSpawned: async (process) => {
+        if (route.acquisition) {
+          route.acquisition.process = process
+        }
+        await input.onSpawned?.(process)
+      }
+    })
+    if (route.acquisition) {
+      route.acquisition.process = acquired.process
+    }
+    if (isClosed()) {
+      throw new Error('structured session adapter router is closed')
+    }
+    route.state = 'live'
+    return acquired
+  } catch (error) {
+    if (
+      routes.get(input.identity.sessionId) === route &&
+      !registration.adapter.hasOwnedAcquisition?.(input.identity.sessionId)
+    ) {
+      routes.delete(input.identity.sessionId)
+    }
+    throw error
+  }
+}
+
+/** Releases only the actual routed acquisition, retaining its observed exit until acknowledged. */
+export async function releaseSessionRoute(
+  input: { sessionId: string },
+  routes: Map<string, SessionRoute>,
+  adapters: () => StructuredAgentSessionAdapter[]
+): Promise<boolean> {
+  const route = routes.get(input.sessionId)
+  if (route) {
+    if (route.state === 'stopped') {
+      return true
+    }
+    if (!route.registration.adapter.hasOwnedAcquisition?.(input.sessionId)) {
+      if (routes.get(input.sessionId) === route) {
+        routes.delete(input.sessionId)
+      }
+      return false
+    }
+    try {
+      let exitReport: Error | undefined
+      const stopped = await stopAgentSessionProviderRoot(
+        () => route.registration.adapter.releaseAcquisition?.(input) ?? Promise.resolve(false),
+        (error) => {
+          exitReport = error
+        }
+      )
+      if (stopped && routes.get(input.sessionId) === route) {
+        route.state = 'stopped'
+      }
+      if (exitReport) {
+        throw exitReport
+      }
+      return stopped
+    } catch (error) {
+      if (
+        routes.get(input.sessionId) === route &&
+        route.state !== 'stopped' &&
+        !route.registration.adapter.hasOwnedAcquisition?.(input.sessionId)
+      ) {
+        routes.delete(input.sessionId)
+      }
+      throw error
+    }
+  }
+  let released = false
+  for (const candidate of adapters()) {
+    released = (await candidate.releaseAcquisition?.(input)) === true || released
+  }
+  return released
+}

src/main/native-chat/agent-session-wire/structured-agent-session-adapter-router.test.ts

@@ -39,6 +39,7 @@ function adapterOf(
   return {
     acquire: vi.fn(async ({ fence, spawnToken }) => acquisition(fence, spawnToken)),
     releaseAcquisition,
+    hasOwnedAcquisition: () => true,
     dispatch: vi.fn(),
     cancelTurn: vi.fn(),
     answerPrompt: vi.fn(),
@@ -47,7 +48,7 @@ function adapterOf(
 }
 
 describe('StructuredAgentSessionAdapterRouter.releaseAcquisition', () => {
-  it('drops the owner even when its release reports a typed failure', async () => {
+  it('retains the actual owner after an unproved release for a scoped retry', async () => {
     const failure = new Error('root exited')
     const claude = adapterOf(vi.fn().mockRejectedValueOnce(failure).mockResolvedValue(false))
     const codex = adapterOf(vi.fn(async () => false))
@@ -56,10 +57,9 @@ describe('StructuredAgentSessionAdapterRouter.releaseAcquisition', () => {
     await router.acquire({ identity, fence: 1, spawnToken: 'spawn-1' })
 
     await expect(router.releaseAcquisition({ sessionId: 'session-1' })).rejects.toBe(failure)
-    // With no owner left, a later release asks every adapter instead of the stale one.
     await expect(router.releaseAcquisition({ sessionId: 'session-1' })).resolves.toBe(false)
     expect(claude.releaseAcquisition).toHaveBeenCalledTimes(2)
-    expect(codex.releaseAcquisition).toHaveBeenCalledTimes(1)
+    expect(codex.releaseAcquisition).not.toHaveBeenCalled()
   })
 })
 
@@ -359,10 +359,9 @@ describe('StructuredAgentSessionAdapterRouter.closeAll', () => {
     await router.closeAll()
     resolveAcquire(acquisition(2, 'spawn-2'))
 
-    // The route is NOT published behind a closed adapter, so nothing routes back out to it — and
-    // with no route the router has nothing to stop and no stop to report.
+    // Shutdown preserves the stop receipt for an acquisition that resolves behind it.
     await expect(acquiring).rejects.toThrow('router is closed')
-    await expect(router.closeSession('session-1')).resolves.toBe(false)
+    await expect(router.closeSession('session-1')).resolves.toBe(true)
     expect(closeSession).not.toHaveBeenCalled()
   })
 })