fix(native-chat): keep a message accepted before a quit or crash as a held card

mobile/src/session/MobileNativeChatQueuedMessages.tsx

@@ -25,8 +25,8 @@ const RESUME_KEY = '\u0000resume'
 
 export type MobileNativeChatQueuedMessagesProps = {
   cards?: MobileQueuedMessageCard[]
-  /** Steer for a waiting card, the paused queue's included; plain Send for a card whose own send
-   *  failed, or a returned one. */
+  /** Steer for a waiting card, the paused queue's included; plain Send for a card held on its own
+   *  (its send failed, or the host kept it unsent), or a returned one. */
   onSend?: (messageId: string) => Promise<boolean>
   onDelete?: (messageId: string) => Promise<boolean>
   /** Copy the card's text into the composer, then delete the card. */

mobile/src/session/mobile-native-chat-controller-contract.ts

@@ -67,8 +67,8 @@ export type MobileNativeChatController = {
   }) => Promise<boolean>
   handleNativeChatRespondPermission: (text: string) => Promise<boolean>
   handleNativeChatStop: () => void
-  /** Host-held queued drafts shown as cards above the composer (structured lane,
-   *  capable host only; empty otherwise). */
+  /** Host-held queued drafts shown as cards above the composer (structured lane; any host
+   *  that publishes them). */
   nativeChatQueued: MobileStructuredQueuedMessageControls
   nativeChatFilePaths: string[]
   loadNativeChatFiles: (query: string) => void

mobile/src/session/mobile-native-chat-pending-echo.ts

@@ -23,7 +23,7 @@ export type MobileNativeChatSendOrigin = {
   baselineTailMessageId: string | null
   baselineResolved: boolean
   /** Queued-draft cards already on screen at send time, so an earlier identical
-   *  card cannot confirm this send. Structured lane on a queue-capable host only. */
+   *  card cannot confirm this send. Structured lane, on any host that publishes cards. */
   baselineQueuedMessageIds?: readonly string[]
 }
 

mobile/src/session/mobile-structured-queued-message-cards.test.ts

@@ -2,7 +2,10 @@ import { describe, expect, it } from 'vitest'
 import { agentSessionFailureFact } from '../../../src/shared/agent-session-failure'
 import { agentSessionFailureWords } from '../../../src/shared/agent-session-failure-words'
 import { DISPATCH_REJECTED_HOST_RESTARTED } from '../../../src/shared/structured-agent-session-dispatch-rejection'
-import { QUEUED_MESSAGE_PAUSED_SEND_FAILED } from '../../../src/shared/agent-session-wire'
+import {
+  QUEUED_MESSAGE_PAUSED_KEPT,
+  QUEUED_MESSAGE_PAUSED_SEND_FAILED
+} from '../../../src/shared/agent-session-wire'
 import type { AgentSessionQueuedMessage } from '../../../src/shared/agent-session-wire'
 import {
   mobileQueueHasResumableCard,
@@ -99,6 +102,26 @@ describe('mobileQueuedMessageCards', () => {
     expect(resumable([failed])).toBe(false)
     expect(resumable([failed, waiting])).toBe(true)
     expect(resumable([waiting, { ...returned, position: 3 }])).toBe(true)
+    // A kept card is held on its own, like a failed one: the drain goes past it.
+    const kept = draft({ messageId: 'k', paused: true, pausedReason: QUEUED_MESSAGE_PAUSED_KEPT })
+    expect(resumable([kept])).toBe(false)
+    expect(resumable([kept, waiting])).toBe(true)
+  })
+
+  // The host kept it unsent across a restart or a close; the cards behind it are not held by it.
+  it('captions a kept card as not sent yet, and leaves the cards behind it plainly queued', () => {
+    const cards = mobileQueuedMessageCards(
+      [
+        draft({ messageId: 'k', paused: true, pausedReason: QUEUED_MESSAGE_PAUSED_KEPT }),
+        draft({ messageId: 'b', position: 2 })
+      ],
+      [],
+      { pendingPrompt: false }
+    )
+    expect(cards.map(({ caption, needsAttention }) => ({ caption, needsAttention }))).toEqual([
+      { caption: 'Not sent yet — tap Send to send it', needsAttention: false },
+      { caption: null, needsAttention: false }
+    ])
   })
 
   it('words the paused queue by reason, and one this build does not know as a plain pause', () => {

mobile/src/session/mobile-structured-queued-message-cards.ts

@@ -8,6 +8,7 @@ import { agentSessionWriteNoticeEnglish } from '../../../src/shared/agent-sessio
 import { dispatchWasWithdrawn } from '../../../src/shared/structured-agent-session-dispatch-rejection'
 import { structuredAgentSessionAttemptFailureParts } from '../../../src/shared/structured-agent-session-send-disposition'
 import {
+  QUEUED_MESSAGE_PAUSED_KEPT,
   QUEUED_MESSAGE_PAUSED_SEND_FAILED,
   type AgentSessionQueuedMessage,
   type AgentSessionQueuePause
@@ -48,11 +49,15 @@ function returnedCaption(
   )
 }
 
-/** One card's own hold: only a failed conversion; the queue's pause is the list's first row. */
+/** One card's own hold: a failed conversion, or a send the host kept; the queue's pause is the
+ *  list's first row. */
 function pausedCaption(reason: string | undefined): string {
   if (reason === QUEUED_MESSAGE_PAUSED_SEND_FAILED) {
     return "Couldn't send — tap Send to retry"
   }
+  if (reason === QUEUED_MESSAGE_PAUSED_KEPT) {
+    return 'Not sent yet — tap Send to send it'
+  }
   // Absent or unknown (newer host) marker: a plain pause, promising no release rule.
   return 'Paused'
 }

mobile/src/session/mobile-structured-send-delivery.test.ts

@@ -125,6 +125,34 @@ describe('mobileStructuredSendDelivery', () => {
     })
   })
 
+  it('answers a send the host kept as a card like a queued one, first send or replay', () => {
+    // The card shows the text, so neither an error nor a composer hand-back may repeat it.
+    const kept: StructuredAgentSessionMutationCallResult<AgentSessionSendResult> = {
+      status: 'accepted',
+      value: {
+        clientMessageId: 'msg-1',
+        submission: {
+          clientMessageId: 'msg-1',
+          fence: 3,
+          payloadFingerprint: 'fingerprint',
+          dispatchState: 'rejected',
+          providerItemId: null,
+          reason: 'Orca restarted before this was sent.',
+          submittedAt: 10,
+          resolvedAt: 10,
+          keptAsQueuedMessageId: 'msg-1'
+        }
+      }
+    }
+    for (const retained of [false, true]) {
+      expect(mobileStructuredSendDelivery(kept, retained)).toEqual({
+        outcome: 'queued',
+        operationIdSpent: true,
+        error: null
+      })
+    }
+  })
+
   it('shows a provider content rejection verbatim', () => {
     expect(
       mobileStructuredSendDelivery(accepted('rejected', 'Claude does not support .bmp'))

mobile/src/session/mobile-structured-send-delivery.ts

@@ -20,6 +20,7 @@
 //     and keeping the id would only refuse every later send of the same text:
 //     a host that refuses the replay's request shape itself (an older host's
 //     strict schema turning `delivery` away), and an id the host has expired.
+//     A rejection the host kept as a card answers as `queued`: the card holds the text.
 //   unknown — the one answer that KEEPS its id, whether it came from the host or
 //     from an ack-loss on the way back. The message may be with the provider, so
 //     the retry has to stay a replay. Rotating here is what sent one message to a
@@ -96,6 +97,11 @@ export function mobileStructuredSendDelivery(
   if (!submission || submission.dispatchState === 'unknown') {
     return { outcome: 'unknown', operationIdSpent: false, error: null }
   }
+  if (submission.dispatchState === 'rejected' && submission.keptAsQueuedMessageId !== undefined) {
+    // The host kept it as a card, which holds the text: no error, and nothing handed back to the
+    // composer, so the words never show twice.
+    return { outcome: 'queued', operationIdSpent: true, error: null }
+  }
   if (submission.dispatchState === 'rejected') {
     return {
       outcome: 'rejected',

mobile/src/session/use-mobile-structured-agent-session-queued.test.tsx

@@ -568,12 +568,28 @@ describe('mobile structured queued messages', () => {
       expect(hook!.queued.cards.map((card) => card.messageId)).toEqual(['same-id'])
     })
 
-    it('shows no cards from an incapable host even if a list arrives', async () => {
-      await mountSession(
-        LEGACY,
-        snapshotEvent({ queuedMessages: [queuedDraft({ messageId: 'draft-1' })] })
+    // A host that does not queue sends still keeps a message it accepted and never sent across a
+    // restart or a close, and publishes it as a card; only queueing a new send is gated.
+    it('shows the cards a host that does not queue sends publishes', async () => {
+      await mountSession(LEGACY)
+      act(() =>
+        listener?.(
+          batchEvent(
+            [
+              queuedDraft({ messageId: 'kept-1', paused: true, pausedReason: 'kept' }),
+              queuedDraft({ messageId: 'behind', position: 2 })
+            ],
+            [],
+            { reason: 'restarted' }
+          )
+        )
       )
-      expect(hook!.queued.cards).toEqual([])
+      expect(hook!.queued.cards.map(({ messageId, caption }) => ({ messageId, caption }))).toEqual([
+        { messageId: 'kept-1', caption: 'Not sent yet — tap Send to send it' },
+        { messageId: 'behind', caption: null }
+      ])
+      // The kept card is held on its own, so Resume would send the card behind it.
+      expect(hook!.queued.pause).toEqual({ reason: 'restarted' })
     })
   })
 

mobile/src/session/use-mobile-structured-agent-session.ts

@@ -61,7 +61,7 @@ type StructuredMobileSession = ReturnType<typeof useMobileStructuredAgentOptions
     respondPermission: (optionId: string) => Promise<boolean>
     respondQuestion: (answer: string) => Promise<boolean>
     cancelPrompt: (prompt?: { itemId: string; expectedRevision: number }) => Promise<boolean>
-    /** The queued-draft cards and their actions; empty and inert off capable hosts. */
+    /** The queued-draft cards and their actions, from any host that publishes them. */
     queued: MobileStructuredQueuedMessageControls
   }
 
@@ -97,7 +97,7 @@ export function useMobileStructuredAgentSession(args: {
     onSendError,
     hostSupport
   } = args
-  // Old host ⇒ exactly today's behavior: no delivery field, no cards, plain Stop.
+  // Only a host that queues sends gets the delivery field; any host's published cards show.
   const queueCapable = hostSupport?.queuedMessages === true
   const promptCancelSupported = hostSupport?.promptCancel ?? null
   const hostAnswersRepeatedStops = hostSupport?.quietRepeatedStop ?? null
@@ -196,7 +196,6 @@ export function useMobileStructuredAgentSession(args: {
     [state.items]
   )
   const queued = useMobileStructuredQueuedMessageControls({
-    queueCapable,
     sessionKey,
     queuedMessages,
     queuePause,

mobile/src/session/use-mobile-structured-queued-message-controls.ts

@@ -1,8 +1,10 @@
 // The queued-draft surface the structured session exposes: cards derived from
-// the published list and the Send-now / Delete / Edit actions. All of it is
-// gated on the host capability — an incapable host gets no cards and no new
-// fields. Nothing here is durable: the host owns the queue, and the published
-// list is the only truth a card action ever needs.
+// the published list and the Send-now / Delete / Edit actions. Shown whatever
+// the queue capability says: a host that does not queue sends still publishes a
+// message it kept across a restart or a close, and only queueing a new send is
+// gated. A host older than the queue publishes no list, so shows no cards.
+// Nothing here is durable: the host owns the queue, and the published list is
+// the only truth a card action ever needs.
 
 import { useCallback, useMemo } from 'react'
 import type { AgentJournalSubmission } from '../../../src/shared/agent-session-journal-types'
@@ -26,7 +28,7 @@ import type { MobileStructuredAgentMutate } from './use-mobile-structured-agent-
 export type MobileQueuedMessageEdit = (messageId: string, onCopied?: () => void) => Promise<boolean>
 
 export type MobileStructuredQueuedMessageControls = {
-  /** Host-held drafts as cards above the composer; empty off capable hosts. */
+  /** Host-held drafts as cards above the composer. */
   cards: MobileQueuedMessageCard[]
   /** Send-now: dispatch this draft into or ahead of the running turn. */
   send: (messageId: string) => Promise<boolean>
@@ -43,7 +45,6 @@ export type MobileStructuredQueuedMessageControls = {
 }
 
 export function useMobileStructuredQueuedMessageControls(args: {
-  queueCapable: boolean
   sessionKey: string
   queuedMessages: MobileQueuedMessageFeed
   queuePause: MobileQueuePause
@@ -63,21 +64,18 @@ export function useMobileStructuredQueuedMessageControls(args: {
     onActionResolved,
     onSendError,
     pendingPrompt,
-    queueCapable,
     queuedMessages,
     queuePause,
     sessionKey,
     submissions
   } = args
   const cards = useMemo(
     () =>
-      queueCapable
-        ? mobileQueuedMessageCards(queuedMessages, submissions, {
-            pendingPrompt,
-            queuePaused: queuePause !== null
-          })
-        : [],
-    [pendingPrompt, queueCapable, queuePause, queuedMessages, submissions]
+      mobileQueuedMessageCards(queuedMessages, submissions, {
+        pendingPrompt,
+        queuePaused: queuePause !== null
+      }),
+    [pendingPrompt, queuePause, queuedMessages, submissions]
   )
   const resolved = useCallback(
     (accepted: boolean): boolean => {
@@ -160,6 +158,6 @@ export function useMobileStructuredQueuedMessageControls(args: {
     [mutate, resolved]
   )
   // The header shows only while Resume would send something, as on desktop.
-  const pause = queueCapable && mobileQueueHasResumableCard(cards) ? queuePause : null
+  const pause = mobileQueueHasResumableCard(cards) ? queuePause : null
   return { cards, send, delete: deleteDraft, edit, pause, resume, sessionKey }
 }

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

@@ -35,6 +35,13 @@ export function applyJournalDispatchRow(
   } else {
     delete submission.rejection
   }
+  if (
+    row.state === 'rejected' &&
+    typeof row.keptAsQueuedMessageId === 'string' &&
+    row.keptAsQueuedMessageId.length > 0
+  ) {
+    submission.keptAsQueuedMessageId = row.keptAsQueuedMessageId
+  }
   if (row.state === 'rejected' && row.answeredInTurn !== undefined) {
     submission.answeredInTurn = readAnsweredTurn(row.answeredInTurn)
   } else {

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

@@ -10,27 +10,34 @@ import {
 } from '../../../shared/structured-agent-session-dispatch-rejection'
 import { rejectedDraftSettlement } from './journal-dispatch-settlement'
 
-function settle(kind: SubmissionRejectionKind) {
-  return rejectedDraftSettlement(
-    agentSessionFailureWords(agentSessionFailureFact(kind), { surface: 'rejection' })
-  )
+function settle(kind: SubmissionRejectionKind, origin?: 'client' | 'host') {
+  return rejectedDraftSettlement({
+    ...agentSessionFailureWords(agentSessionFailureFact(kind), { surface: 'rejection' }),
+    origin
+  })
 }
 
 describe('what a rejection does to the draft it was consumed from', () => {
   it("a Stop's withdrawal sends it back to waiting, under the queue's pause rather than a hold of its own", () => {
-    expect(settle('cancelled')).toEqual({ state: 'waiting' })
+    expect(settle('cancelled')).toEqual({ state: 'waiting', kept: false })
     expect(rejectedDraftSettlement({ reason: DISPATCH_REJECTED_CANCELLED })).toEqual({
-      state: 'waiting'
+      state: 'waiting',
+      kept: false
     })
+    expect(settle('notDelivered')).toEqual({ state: 'waiting', kept: false })
   })
 
-  it('a restart or close before hand-over sends it back to waiting too', () => {
-    for (const kind of ['hostRestarted', 'chatClosed', 'notDelivered'] as const) {
-      expect(settle(kind)).toEqual({ state: 'waiting' })
+  // A Send the person asked for and the host never handed over waits for them; the queue's own
+  // hand-off, or one from a build that recorded no origin, waits under the queue's pause.
+  it('a restart or close before hand-over sends it back to waiting, kept only when the person sent it', () => {
+    for (const kind of ['hostRestarted', 'chatClosed'] as const) {
+      expect(settle(kind, 'client')).toEqual({ state: 'waiting', kept: true })
+      expect(settle(kind, 'host')).toEqual({ state: 'waiting', kept: false })
+      expect(settle(kind)).toEqual({ state: 'waiting', kept: false })
     }
-    expect(rejectedDraftSettlement({ reason: DISPATCH_REJECTED_HOST_RESTARTED })).toEqual({
-      state: 'waiting'
-    })
+    expect(
+      rejectedDraftSettlement({ reason: DISPATCH_REJECTED_HOST_RESTARTED, origin: 'client' })
+    ).toEqual({ state: 'waiting', kept: true })
   })
 
   it('a failure returns the card for the user to act on', () => {

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

@@ -30,22 +30,27 @@ export function consumedSubmissionWasRejected(
 }
 
 /** What a consumed draft becomes when its submission is rejected. */
-export type RejectedDraftSettlement = { state: 'returned' } | { state: 'waiting' }
+export type RejectedDraftSettlement = { state: 'returned' } | { state: 'waiting'; kept: boolean }
 
 /**
- * Where no one failed the user — a Stop withdrew it, or a restart or close
- * interrupted it before hand-over — the draft goes back to waiting at its own
- * position, under whatever pauses the queue: the Stop's own pause, or the
- * restart's, derived from the host instance. A returned card would block the
- * drafts behind it on a failure that never happened. A failure returns the
- * card with its refusal for the user to act on.
+ * Where no one failed the user, the draft goes back to waiting at its own position, under whatever
+ * pauses the queue: a Stop's, or the restart's, derived from the host instance. A Send the person
+ * asked for (`origin` client) that a restart or a close cut short is kept (`kept`) until they send
+ * it again, as the host keeps every message a person sent and it never handed over; the queue's
+ * own hand-off is not theirs, so it waits as any queued card does: under the restart's pause after
+ * a restart, and plainly queued after a close in the same process. A returned card would block the drafts
+ * behind it on a failure that never happened. A failure returns the card with its refusal for the
+ * user to act on.
  */
 export function rejectedDraftSettlement(
-  rejection: Pick<AgentJournalSubmission, 'reason'> & { rejection?: unknown }
+  rejected: Pick<AgentJournalSubmission, 'reason' | 'origin'> & { rejection?: unknown }
 ): RejectedDraftSettlement {
-  return classifyDispatchRejection(rejection).verdict === null
-    ? { state: 'waiting' }
-    : { state: 'returned' }
+  const { verdict, kind } = classifyDispatchRejection(rejected)
+  if (verdict !== null) {
+    return { state: 'returned' }
+  }
+  const cutShort = kind === 'hostRestarted' || kind === 'chatClosed'
+  return { state: 'waiting', kept: cutShort && rejected.origin === 'client' }
 }
 
 /** True when committing this row NEWLY settles the submission to `rejected` —