Native chat: a message stopped before the agent got it reaches the agent with your next send

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

@@ -109,7 +109,12 @@ describe('ACP Stop names a turn', () => {
     expect(rig.sent('session/cancel')).toHaveLength(2)
     expect(rig.settled).toEqual(
       expect.arrayContaining([
-        expect.objectContaining({ clientMessageId: 'follow-up', state: 'rejected' })
+        // Held by Orca, never prompted: proof it never reached the agent.
+        expect.objectContaining({
+          clientMessageId: 'follow-up',
+          state: 'rejected',
+          rejection: { kind: 'cancelled', neverReachedAgent: true }
+        })
       ])
     )
   })
@@ -221,7 +226,7 @@ describe('ACP connection loss', () => {
     ).toEqual({
       state: 'rejected',
       reason: 'Grok stopped before this message was sent.',
-      rejection: { kind: 'providerExited' }
+      rejection: { kind: 'providerExited', neverReachedAgent: true }
     })
     // The next start's stop of the old child is one Orca asked for; it does not rename the crash.
     await expect(rig.acquire()).rejects.toMatchObject({

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

@@ -330,13 +330,14 @@ export class AcpStructuredSessionAdapter implements StructuredAgentSessionAdapte
     void this.stop(session.sessionId, false)
   }
 
+  /** Only for a send refused before its prompt was written. */
   private rejected(
     session: AcpStructuredSession,
     kind: 'providerExited'
   ): AgentSessionDispatchOutcome {
     return {
       state: 'rejected',
-      ...agentSessionFailureWords(agentSessionFailureFact(kind), {
+      ...agentSessionFailureWords(agentSessionFailureFact(kind, { neverReachedAgent: true }), {
         surface: 'rejection',
         agentName: acpAgentName(session.spec.agent)
       })

src/main/acp/acp-structured-turns.ts

@@ -156,7 +156,10 @@ export class AcpStructuredTurns {
   private withdrawSteers(): boolean {
     const withdrawn = this.steers.splice(0)
     for (const send of withdrawn) {
-      this.reject(send.clientMessageId, agentSessionFailureFact('cancelled'))
+      this.reject(
+        send.clientMessageId,
+        agentSessionFailureFact('cancelled', { neverReachedAgent: true })
+      )
     }
     return withdrawn.length > 0
   }

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

@@ -134,7 +134,11 @@ export async function dispatchClaudeTurn(
   }
   const startupFailure = claudeStartupFailureFact(session)
   if (startupFailure) {
-    return { state: 'rejected', ...claudeDispatchRejection(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.

src/main/claude/claude-structured-queued-stop.test.ts

@@ -199,6 +199,16 @@ describe('Stop with a follow-up Claude queued behind the running turn', () => {
     expect(bySessionStart).toEqual(byInit)
   })
 
+  // Claude may already hold a swept send in the stopped turn, so it is never re-sent as history.
+  it('settles the swept follow-up without proof it never reached Claude', async () => {
+    const { settlements } = await stopWithQueuedFollowUp(
+      claudeCli({ initProof: 'init', capabilities: CAPABILITIES }),
+      () => {}
+    )
+    expect(settlements[0]).toMatchObject({ state: 'rejected' })
+    expect(JSON.stringify(settlements[0])).not.toContain('neverReachedAgent')
+  })
+
   it('keeps what a turn advertised when a later frame names nothing', async () => {
     const result = await stopWithQueuedFollowUp(
       claudeCli({ initProof: 'session-start' }),

src/main/codex/codex-structured-dispatch-admission.test.ts

@@ -158,7 +158,8 @@ describe('codex dispatch admission', () => {
       reason: "Codex didn't accept this message: thread not found.",
       rejection: {
         kind: 'providerRejected',
-        detail: { text: 'thread not found', audience: 'person' }
+        detail: { text: 'thread not found', audience: 'person' },
+        neverReachedAgent: true
       }
     })
 

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

@@ -593,7 +593,7 @@ describe('CodexStructuredSessionAdapter.dispatch', () => {
       // Built without Codex's own words, so nothing is quoted and no detail is invented.
       state: 'rejected',
       reason: "Codex didn't accept this message.",
-      rejection: { kind: 'providerRejected' }
+      rejection: { kind: 'providerRejected', neverReachedAgent: true }
     })
   })
 

src/main/codex/codex-structured-turn-end-settlement.test.ts

@@ -78,10 +78,12 @@ describe('a Codex send its turn ended without echoing', () => {
     rig.turns.end('interrupted')
 
     expect(rig.settlements).toEqual([
+      // Codex took it into a turn: no proof it never reached Codex.
       expect.objectContaining({
         sessionId: 'session-1',
         clientMessageId: 'client-1',
-        state: 'rejected'
+        state: 'rejected',
+        rejection: { kind: 'cancelled' }
       })
     ])
     expect(rig.categoryOf(rig.settlements[0])).toBe('withdrawn')

src/main/codex/codex-structured-turn-start.ts

@@ -170,11 +170,15 @@ export async function dispatchCodexTurn(
     if (isCodexAppServerRequestError(error) || isCodexAppServerUnsupportedError(error)) {
       // Codex answered and declined, so no echo for this write can arrive.
       session.dispatchEchoes.disarm(input.clientMessageId)
-      // Codex's own words, when it gave any, are the one part of the error a person can use.
+      // Codex's own words, when it gave any, are the one part of the error a person can use. A
+      // declined request recorded nothing, so stopped messages it carried are owed again.
       return {
         state: 'rejected',
         ...codexDispatchRejection(
-          agentSessionFailureFact('providerRejected', { detail: providerDiagnosticOf(error) })
+          agentSessionFailureFact('providerRejected', {
+            detail: providerDiagnosticOf(error),
+            neverReachedAgent: true
+          })
         )
       }
     }

src/main/codex/codex-structured-turn-steer.test.ts

@@ -171,7 +171,8 @@ describe('a Codex send while a turn runs', () => {
       reason: "Codex didn't accept this message: thread not found.",
       rejection: {
         kind: 'providerRejected',
-        detail: { text: 'thread not found', audience: 'person' }
+        detail: { text: 'thread not found', audience: 'person' },
+        neverReachedAgent: true
       }
     })
     expect(methods()).toEqual(['thread/start', 'turn/steer', 'turn/start'])

src/main/native-chat/agent-session-journal/journal-dispatch-reducer.ts

@@ -54,6 +54,7 @@ export function applyJournalDispatchRow(
   if (row.state === 'pending') {
     submission.handedOverAt = row.ts
     placeHandedOverMessage(state, submission, row)
+    foldStoppedHistoryCarried(state, row)
   } else if (row.state === 'rejected') {
     placeRejectedMessage(state, submission, row)
   }
@@ -77,6 +78,20 @@ export function applyJournalDispatchRow(
   })
 }
 
+/** A send is handed over once, so its one pending row names what it carries; a malformed id is
+ *  dropped. */
+function foldStoppedHistoryCarried(
+  state: JournalReducerState,
+  row: Extract<JournalRow, { kind: 'dispatch' }>
+): void {
+  const carried = Array.isArray(row.carries)
+    ? row.carries.filter((id): id is string => typeof id === 'string' && id.length > 0)
+    : []
+  if (carried.length > 0) {
+    state.stoppedHistoryCarried.set(row.clientMessageId, carried)
+  }
+}
+
 /** A stored answered turn. One malformed, or naming a way of joining this build does not know, is
  *  read as no turn: it was written knowing the field, so it is not an older row. */
 function readAnsweredTurn(value: unknown): AgentJournalAnsweredTurn | null {

src/main/native-chat/agent-session-journal/journal-reducer.ts

@@ -71,6 +71,8 @@ export type JournalReducerState = {
   latestAcceptedTurnSequence: number
   /** The latest person's Stop event and Resume, what the queue's pause is derived from. */
   queuePauseMarks: JournalQueuePauseMarks
+  /** Host-only: each handed-over send's stopped-message history, from its latest `pending` row. */
+  stoppedHistoryCarried: Map<string, readonly string[]>
 }
 
 export function createJournalReducerState(sessionId: string, epoch: string): JournalReducerState {
@@ -92,7 +94,8 @@ export function createJournalReducerState(sessionId: string, epoch: string): Jou
     appliedSettlementIds: new Set(),
     derivedTurnScope: new JournalDerivedTurnScope(),
     latestAcceptedTurnSequence: 0,
-    queuePauseMarks: createJournalQueuePauseMarks()
+    queuePauseMarks: createJournalQueuePauseMarks(),
+    stoppedHistoryCarried: new Map()
   }
 }
 

src/main/native-chat/agent-session-journal/journal-restart-reconciliation.test.ts

@@ -190,6 +190,38 @@ describe('reconcileJournalSubmissionsAgainstHistory', () => {
     expect(journal.submissions()[0]?.dispatchState).toBe('unknown')
   })
 
+  it('leaves a send that carried stopped history unknown: its provider copy leads with that history', async () => {
+    const journal = await open()
+    for (const clientMessageId of ['stopped', 'cm_1']) {
+      await journal.appendSubmission({
+        clientMessageId,
+        payloadFingerprint: digestPayload(clientMessageId),
+        body: userMessage(clientMessageId),
+        fence: 1,
+        handoverRecorded: true
+      })
+    }
+    await journal.resolveDispatch({
+      clientMessageId: 'cm_1',
+      state: 'pending',
+      fence: 1,
+      turnScope: AGENT_JOURNAL_THREAD_SCOPE,
+      carries: ['stopped']
+    })
+    const restarted = await open()
+    await restarted.markPendingSubmissionsUnknown(2)
+
+    const settled = await reconcileJournalSubmissionsAgainstHistory({
+      journal: restarted,
+      fence: 2,
+      history: window([])
+    })
+
+    expect(settled).toEqual([])
+    expect(restarted.submission('cm_1')?.dispatchState).toBe('unknown')
+    expect(restarted.stoppedHistoryCarried().get('cm_1')).toEqual(['stopped'])
+  })
+
   it('leaves multi-block text sends unknown because Claude joins them before recording history', async () => {
     const journal = await reopenAfterCrash(
       {

src/main/native-chat/agent-session-journal/journal-restart-reconciliation.ts

@@ -55,7 +55,10 @@ function comparableSubmissions(journal: AgentSessionJournal): AgentJournalSubmis
     if (
       (submission.dispatchState !== 'pending' && submission.dispatchState !== 'unknown') ||
       // Never handed over, so provider history cannot hold it.
-      isQueuedAgentJournalSubmission(submission)
+      isQueuedAgentJournalSubmission(submission) ||
+      // The provider's copy leads with the stopped history it carried, so its fingerprint cannot
+      // match; like an attachment's, its absence is no evidence and it stays `unknown`.
+      journal.stoppedHistoryCarried().has(submission.clientMessageId)
     ) {
       return false
     }

src/main/native-chat/agent-session-journal/journal-row-builders.ts

@@ -145,7 +145,8 @@ export function journalDispatchRowBuilder(
       : {}),
     ...journalRowBase(state().epoch, seq, input.fence, ts),
     ...(input.recovered ? { recovered: input.recovered } : {}),
-    ...(input.state === 'pending' ? { turnScope: input.turnScope } : {})
+    ...(input.state === 'pending' ? { turnScope: input.turnScope } : {}),
+    ...(input.state === 'pending' && input.carries?.length ? { carries: [...input.carries] } : {})
   })
 }
 

src/main/native-chat/agent-session-journal/journal-row-schema.ts

@@ -181,6 +181,9 @@ export type JournalDispatchRow = JournalRowBase & {
   reason: string | null
   /** On `pending`: the turn the message was handed into, which becomes its row's scope. */
   turnScope?: AgentJournalTurnScope
+  /** On `pending`: the stopped messages this send carries to the agent as history, by client
+   *  message id in the order they were sent. Host-only; older readers keep the key and ignore it. */
+  carries?: string[]
   /** On `rejected`: why, typed. Older readers keep the key and ignore it; a malformed one is
    *  dropped when read, never the row. */
   rejection?: AgentSessionFailureFact

src/main/native-chat/agent-session-journal/journal-stop-acceptance.ts

@@ -2,7 +2,8 @@
 // event, and the command receipt that names that event. Nothing of it is durable unless all of it
 // is, so a Stop whose acceptance fails withdraws nothing and interrupts nothing.
 
-import type { AgentJournalDispatchRejection } from '../../../shared/agent-session-failure-words'
+import { agentSessionFailureFact } from '../../../shared/agent-session-failure'
+import { agentSessionFailureWords } from '../../../shared/agent-session-failure-words'
 import type { AgentJournalCursor } from '../../../shared/agent-session-journal-types'
 import { journalQueuedRejectionRowBuilders } from './journal-pending-submission-recovery'
 import type { JournalReducerState } from './journal-reducer'
@@ -13,10 +14,14 @@ import { journalStopEventRowBuilder } from './journal-stop-and-resume-rows'
 export type JournalStopAcceptanceInput = {
   event: Omit<JournalStopEvent, 'at'>
   fence: number
-  /** What every queued send is rejected with. */
-  withdrawal: AgentJournalDispatchRejection
 }
 
+// Only host-held sends are withdrawn, so each carries proof it never reached the agent.
+const STOP_WITHDRAWAL = agentSessionFailureWords(
+  agentSessionFailureFact('cancelled', { neverReachedAgent: true }),
+  { surface: 'rejection' }
+)
+
 export type JournalStopAcceptance = {
   /** Where the Stop event landed. */
   mark: AgentJournalCursor
@@ -54,7 +59,7 @@ export class JournalStopAcceptor {
         turnId = input.event.turnId ?? this.deps.liveTurnId()
         const event = { ...input.event, ...(turnId !== null ? { turnId } : {}) }
         return [
-          ...journalQueuedRejectionRowBuilders(state, input.fence, input.withdrawal),
+          ...journalQueuedRejectionRowBuilders(state, input.fence, STOP_WITHDRAWAL),
           journalStopEventRowBuilder(state, event, input.fence)
         ]
       },

src/main/native-chat/agent-session-journal/journal-store-collaborators.ts

@@ -8,6 +8,7 @@ import type {
   AgentSessionJournalIdentity
 } from '../../../shared/agent-session-journal-types'
 import type { JournalHostDatabase } from './journal-host-database'
+import { JournalContextController } from './journal-context-controller'
 import { JournalEpochController } from './journal-epoch-controller'
 import { JournalItemAppender } from './journal-item-appender'
 import { JournalLifecycleBatchAppender } from './journal-lifecycle-batch-appender'
@@ -58,6 +59,7 @@ export type JournalStoreCollaborators = {
   stepWriter: JournalStepWriter
   queuedMessages: JournalQueuedMessages
   stopMarks: JournalStopMarks
+  context: JournalContextController
   stops: JournalStopAcceptor
   /** Restores the store's state from disk. Owned here because it needs the same
    *  collaborators the constructor just built. */
@@ -125,6 +127,11 @@ export function createJournalStoreCollaborators(host: JournalStoreHost): Journal
     epochController,
     queuedMessages,
     stopMarks: new JournalStopMarks({ state: host.state }),
+    context: new JournalContextController({
+      state: host.state,
+      writer: rowWriter,
+      cards: queuedMessages
+    }),
     stops: new JournalStopAcceptor({
       writer: rowWriter,
       state: host.state,

src/main/native-chat/agent-session-journal/journal-store-contracts.ts

@@ -40,7 +40,12 @@ export type ResolveDispatchInput = {
   (
     | { state: 'accepted'; providerIdentity: AgentJournalItemIdentity | null }
     /** The turn the message is handed into — the live root turn, or `thread` when none runs. */
-    | { state: 'pending'; turnScope: AgentJournalTurnScope }
+    | {
+        state: 'pending'
+        turnScope: AgentJournalTurnScope
+        /** The stopped messages this send carries as history (`JournalDispatchRow.carries`). */
+        carries?: readonly string[]
+      }
     /** `reason` is what released clients print, `rejection` what newer ones read: both from
      *  `agentSessionFailureWords`, never written by hand. */
     | ({

src/main/native-chat/agent-session-journal/journal-store.ts

@@ -74,7 +74,7 @@ import type { JournalItemAppender } from './journal-item-appender'
 import type { JournalLifecycleBatchAppender } from './journal-lifecycle-batch-appender'
 import type { JournalStepWriter } from './journal-step-writer'
 import type { JournalStopMarks } from './journal-stop-marks'
-import { JournalContextController } from './journal-context-controller'
+import type { JournalContextController } from './journal-context-controller'
 import type { JournalStopAcceptor } from './journal-stop-acceptance'
 
 export { AgentSessionJournalError } from './journal-write-guards'
@@ -146,11 +146,7 @@ export class AgentSessionJournal {
     this.stopMarks = collaborators.stopMarks
     this.stops = collaborators.stops
     this.restore = collaborators.restore
-    this.context = new JournalContextController({
-      state: () => this.state,
-      writer: this.rowWriter,
-      cards: this.queuedMessages
-    })
+    this.context = collaborators.context
   }
 
   get epoch(): string {
@@ -216,6 +212,10 @@ export class AgentSessionJournal {
   itemBody = (itemId: string): AgentJournalItemBody | null =>
     this.state.items.get(itemId)?.body ?? null
 
+  /** Host-only: the stopped messages each handed-over send carried, by its client message id. */
+  stoppedHistoryCarried = (): ReadonlyMap<string, readonly string[]> =>
+    this.state.stoppedHistoryCarried
+
   /** One reduced item with its attribution, for a writer that needs the turn a row joined. */
   item = (itemId: string): AgentJournalRenderItem | null => this.state.items.get(itemId) ?? null
 

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

@@ -6,8 +6,6 @@
 // reachable only through `mutateWithChatStop`, which queues that step in the same synchronous call
 // as the mutation. Once saved, a failure is answered from the Stop's receipt and noted on the chat.
 
-import { agentSessionFailureFact } from '../../../shared/agent-session-failure'
-import { agentSessionFailureWords } from '../../../shared/agent-session-failure-words'
 import type {
   AgentSessionCancelResult,
   AgentSessionMutationEnvelope,
@@ -83,10 +81,7 @@ export function mutateWithChatStop<TValue>(
         caller: caller.callerKey,
         ...(target.eventTurnId !== null ? { turnId: target.eventTurnId } : {})
       },
-      fence: ctx.fence,
-      withdrawal: agentSessionFailureWords(agentSessionFailureFact('cancelled'), {
-        surface: 'rejection'
-      })
+      fence: ctx.fence
     })
     return accepted.ok
       ? { ok: true, value: { settled: target.queued, turnId: accepted.value.turnId } }