fix(native-chat): after a Stop whose exit can't be confirmed, the next message retries the stop instead of failing

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

@@ -28,6 +28,10 @@ import type { StructuredAgentSessionAttachContext } from './structured-agent-ses
 import { attachStructuredAgentSessionUnderSerialize } from './structured-agent-session-attach-orchestration'
 import { failedCreateRefusal } from './structured-agent-session-failed-create-refusal'
 import { adapterSupportsRecord } from './structured-agent-session-provider-support'
+import {
+  finishOwedStructuredAgentSessionWindDownUnderSerialize,
+  type StructuredAgentSessionLifetimeContext
+} from './structured-agent-session-host-lifetime'
 import {
   structuredAgentSessionResumeOperationId,
   structuredAgentSessionResumeParams
@@ -48,6 +52,48 @@ export type StructuredAgentSessionResumeOutcome =
 /** The attach's caller key: the ledger row a start settles is Orca's own. */
 const AGENT_START_CALLER_KEY = 'trusted-local:agent-start'
 
+/**
+ * Every operation that reaches the provider finishes a stop an earlier attempt left owed first: the
+ * child that stop could not prove gone takes no input, and none may start beside it. Still
+ * unproven, the operation is refused with the exit `unverifiable`, never assumed `exited`.
+ */
+export async function finishOwedStructuredAgentSessionStop(
+  context: StructuredAgentSessionLifetimeContext,
+  sessionId: string
+): Promise<StructuredAgentSessionResumeOutcome> {
+  if (await finishOwedStructuredAgentSessionWindDownUnderSerialize(context, sessionId)) {
+    return { ok: true }
+  }
+  return {
+    ok: false,
+    refusal: refuse(
+      'agent_session_ownership_unknown',
+      { reason: 'previousExitUnverifiable', ownerVerdict: 'unverifiable' },
+      "Orca could not prove this chat's previous agent process exited."
+    )
+  }
+}
+
+/** The same, for an operation the running child performs, which starts none: only an exit still
+ *  unproven, its child still on record, holds it back. A proven exit owes only bookkeeping, which
+ *  gates no such operation: its retry was reported, and the operation goes on as with none owed. */
+export async function finishOwedStructuredAgentSessionStopForProviderWrite(
+  context: StructuredAgentSessionLifetimeContext,
+  sessionId: string
+): Promise<StructuredAgentSessionResumeOutcome> {
+  const settled = await finishOwedStructuredAgentSessionStop(context, sessionId)
+  return settled.ok || context.sessions.get(sessionId)?.child ? settled : { ok: true }
+}
+
+export function isStructuredAgentSessionPreviousExitUnverifiable(
+  refusal: AgentSessionWireRefusal
+): boolean {
+  return (
+    refusal.code === 'agent_session_ownership_unknown' &&
+    refusal.details?.reason === 'previousExitUnverifiable'
+  )
+}
+
 /**
  * Gives the session a provider child if it has none, for a caller inside its serialize — which is
  * what makes "if it has none" exact: two askers run this in turn, and the second finds the first
@@ -58,6 +104,10 @@ export async function ensureStructuredAgentSessionAgent(
   sessionId: string,
   startedFor?: string
 ): Promise<StructuredAgentSessionResumeOutcome> {
+  const settled = await finishOwedStructuredAgentSessionStop(context, sessionId)
+  if (!settled.ok) {
+    return settled
+  }
   if (context.sessions.get(sessionId)?.child) {
     return { ok: true }
   }