fix(native-chat): a /compact sent while the agent works waits in line instead of being refused

config/tsconfig.node.json

@@ -15,6 +15,7 @@
     "../src/renderer/src/components/native-chat/structured-agent-question-projection.ts",
     "../src/renderer/src/components/native-chat/native-chat-subagent-delegation.ts",
     "../src/renderer/src/components/native-chat/structured-agent-session-queued-cards.ts",
+    "../src/renderer/src/components/native-chat/structured-agent-session-pending-sends.ts",
     "../src/renderer/src/components/native-chat/native-chat-composer-primary-action.ts",
     "../src/preload/**/*",
     "../src/shared/**/*",

mobile/src/session/MobileNativeChatQueuedMessages.test.tsx

@@ -157,6 +157,48 @@ describe('MobileNativeChatQueuedMessages', () => {
     expect(nodeTypes(rows[1]!)).toContain('CornerDownRight')
   })
 
+  it('a command card never steers: Send only while the agent is idle, and no menu', async () => {
+    const onSend = vi.fn(async () => true)
+    const mounted = await mount({
+      cards: [
+        card({ messageId: 'working', text: '/compact', command: true, waitsForAgent: true }),
+        card({ messageId: 'idle', text: '/compact', command: true })
+      ],
+      onSend
+    })
+    expect(texts(mounted).filter((text) => text === 'Send' || text === 'Steer')).toEqual(['Send'])
+    await act(async () => {
+      mounted.root.findByProps({ accessibilityLabel: 'Send this message' }).props.onPress()
+    })
+    expect(onSend).toHaveBeenCalledWith('idle')
+    // Its menu holds only Edit, which a command does not take.
+    expect(mounted.root.findAllByProps({ accessibilityLabel: 'More actions' })).toHaveLength(0)
+    expect(
+      mounted.root.findAllByProps({ accessibilityLabel: 'Delete this queued message' })
+    ).toHaveLength(2)
+  })
+
+  it("a paused command card's ways out are Delete and the queue's Resume", async () => {
+    const onResume = vi.fn(async () => true)
+    const onDelete = vi.fn(async () => true)
+    const mounted = await mount({
+      cards: [card({ messageId: 'compact', text: '/compact', command: true })],
+      pause: { reason: 'stopped' },
+      onResume,
+      onDelete
+    })
+    await act(async () => {
+      mounted.root
+        .findByProps({ accessibilityLabel: 'Resume sending the queued messages' })
+        .props.onPress()
+    })
+    expect(onResume).toHaveBeenCalledOnce()
+    await act(async () => {
+      mounted.root.findByProps({ accessibilityLabel: 'Delete this queued message' }).props.onPress()
+    })
+    expect(onDelete).toHaveBeenCalledWith('compact')
+  })
+
   it("holds Steer while a person's Stop ends the turn; Delete still works", async () => {
     const onSend = vi.fn(async () => true)
     const onDelete = vi.fn(async () => true)

mobile/src/session/MobileNativeChatQueuedMessages.tsx

@@ -110,7 +110,7 @@ export function MobileNativeChatQueuedMessages({
           const returned = card.state === 'returned'
           // "Steer" submits beside the running turn, the paused queue's cards too; a card whose
           // own send failed, or a returned one, is sent again.
-          const steers = !returned && !card.paused
+          const steers = !returned && !card.paused && !card.command
           return (
             <View
               key={card.messageId}
@@ -142,31 +142,34 @@ export function MobileNativeChatQueuedMessages({
                   </Text>
                 ) : null}
               </View>
-              <Pressable
-                accessibilityRole="button"
-                accessibilityState={{ disabled: busy || steerHeld }}
-                accessibilityLabel={
-                  returned
-                    ? 'Send this message again'
-                    : card.paused
-                      ? 'Send this message'
-                      : 'Submit without interrupting the model'
-                }
-                style={({ pressed }) => [
-                  styles.textAction,
-                  pressed && styles.pressed,
-                  (busy || steerHeld) && styles.disabled
-                ]}
-                disabled={busy || steerHeld}
-                onPress={() => void run(card.messageId, onSend)}
-              >
-                {steers ? (
-                  <CornerDownRight size={12} color={colors.textPrimary} strokeWidth={2} />
-                ) : (
-                  <Send size={12} color={colors.textPrimary} strokeWidth={2} />
-                )}
-                <Text style={styles.actionLabel}>{steers ? 'Steer' : 'Send'}</Text>
-              </Pressable>
+              {/* A command never steers: its Send shows only while the agent is idle. */}
+              {card.waitsForAgent ? null : (
+                <Pressable
+                  accessibilityRole="button"
+                  accessibilityState={{ disabled: busy || steerHeld }}
+                  accessibilityLabel={
+                    returned
+                      ? 'Send this message again'
+                      : steers
+                        ? 'Submit without interrupting the model'
+                        : 'Send this message'
+                  }
+                  style={({ pressed }) => [
+                    styles.textAction,
+                    pressed && styles.pressed,
+                    (busy || steerHeld) && styles.disabled
+                  ]}
+                  disabled={busy || steerHeld}
+                  onPress={() => void run(card.messageId, onSend)}
+                >
+                  {steers ? (
+                    <CornerDownRight size={12} color={colors.textPrimary} strokeWidth={2} />
+                  ) : (
+                    <Send size={12} color={colors.textPrimary} strokeWidth={2} />
+                  )}
+                  <Text style={styles.actionLabel}>{steers ? 'Steer' : 'Send'}</Text>
+                </Pressable>
+              )}
               <Pressable
                 accessibilityRole="button"
                 accessibilityState={{ disabled: busy }}
@@ -181,20 +184,23 @@ export function MobileNativeChatQueuedMessages({
               >
                 <Trash2 size={14} color={colors.textPrimary} strokeWidth={2} />
               </Pressable>
-              <Pressable
-                accessibilityRole="button"
-                accessibilityState={{ disabled: busy }}
-                accessibilityLabel="More actions"
-                style={({ pressed }) => [
-                  styles.iconAction,
-                  pressed && styles.pressed,
-                  busy && styles.disabled
-                ]}
-                disabled={busy}
-                onPress={() => setMenuFor(card.messageId)}
-              >
-                <MoreHorizontal size={14} color={colors.textPrimary} strokeWidth={2} />
-              </Pressable>
+              {/* The menu holds only Edit, which a command does not take. */}
+              {card.command ? null : (
+                <Pressable
+                  accessibilityRole="button"
+                  accessibilityState={{ disabled: busy }}
+                  accessibilityLabel="More actions"
+                  style={({ pressed }) => [
+                    styles.iconAction,
+                    pressed && styles.pressed,
+                    busy && styles.disabled
+                  ]}
+                  disabled={busy}
+                  onPress={() => setMenuFor(card.messageId)}
+                >
+                  <MoreHorizontal size={14} color={colors.textPrimary} strokeWidth={2} />
+                </Pressable>
+              )}
             </View>
           )
         })}

mobile/src/session/mobile-dictation-refused-start-routing.test.tsx

@@ -44,6 +44,7 @@ vi.mock('./use-mobile-native-chat-send-error', () => ({
     message: null,
     show: () => {},
     clear: () => {},
+    keepWhile: () => {},
     bannerMountedRef: { current: false }
   })
 }))

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

@@ -12,6 +12,7 @@ import type {
 } from '../../../src/shared/native-chat-turn-status'
 import type { NativeChatTurnJournal } from '../../../src/shared/native-chat-turn-membership'
 import type { MobileNativeChatSendOutcome } from './mobile-native-chat-send'
+import type { MobileNativeChatCommandRefusalCauses } from './use-mobile-native-chat-send-error'
 import type { MobileStructuredQueuedMessageControls } from './use-mobile-structured-queued-message-controls'
 import type { MobileStructuredBackgroundTasks } from './use-mobile-structured-background-tasks'
 import type { MobileNativeChatPendingMessage } from './use-mobile-native-chat-drafts'
@@ -45,6 +46,8 @@ export type MobileNativeChatController = {
   nativeChatSettledTurns: NativeChatSettledTurns | null
   /** Structured lane: the journal that places each transcript row in its turn. */
   nativeChatTurnJournal: NativeChatTurnJournal | null
+  /** What a refused command's line stands on. */
+  nativeChatCommandRefusalCauses: MobileNativeChatCommandRefusalCauses
   nativeChatCanStop: boolean
   nativeChatStreamingText?: string
   /** Agent mid-turn, regardless of whether chat is the visible view. */

mobile/src/session/mobile-native-chat-merged-snapshot-parity-hooks.test.tsx

@@ -88,6 +88,7 @@ const HOST_SUPPORT = {
   promptCancel: true,
   questionAnswers: true,
   queuedMessages: true,
+  queuedCommands: false,
   statusFeed: true,
   quietRepeatedStop: true
 }

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

@@ -0,0 +1,40 @@
+import type { MobileNativeChatSendOutcome } from './mobile-native-chat-send'
+import type { MobileNativeChatVisualSource } from './mobile-native-chat-visual-read'
+import type { MobileChatPermission } from './mobile-native-chat-permission'
+import type { MobileChatQuestion } from './mobile-native-chat-question'
+import type { MobileNativeChatSession } from './use-mobile-native-chat-session'
+import type { NativeChatLiveTurnIndicator } from '../../../src/shared/native-chat-turn-status'
+import type { useMobileStructuredAgentOptions } from './use-mobile-structured-agent-options'
+import type { useMobileStructuredAgentTurnTiming } from './use-mobile-structured-agent-turn-timing'
+import type { StructuredMobileSendAttachment } from './use-mobile-structured-send-with-outcome'
+import type { MobileNativeChatCommandRefusalCauses } from './use-mobile-native-chat-send-error'
+import type { MobileStructuredQueuedMessageControls } from './use-mobile-structured-queued-message-controls'
+import type { MobileStructuredBackgroundTasks } from './use-mobile-structured-background-tasks'
+
+export type StructuredMobileSession = ReturnType<typeof useMobileStructuredAgentOptions> &
+  ReturnType<typeof useMobileStructuredAgentTurnTiming> & {
+    session: MobileNativeChatSession
+    isWorking: boolean
+    turnId: string | null
+    /** What labels the live turn's one indicator row. */
+    turnIndicator: NativeChatLiveTurnIndicator
+    sendWithOutcome: (
+      text: string,
+      images?: string[],
+      deadline?: number,
+      attachments?: readonly StructuredMobileSendAttachment[]
+    ) => Promise<MobileNativeChatSendOutcome>
+    cancel: () => void
+    permission: MobileChatPermission | null
+    question: MobileChatQuestion | null
+    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, from any host that publishes them. */
+    queued: MobileStructuredQueuedMessageControls
+    commandRefusalCauses: MobileNativeChatCommandRefusalCauses
+    /** Running child work for the strip above the composer, as desktop shows it. */
+    backgroundTasks: MobileStructuredBackgroundTasks
+    /** Where this chat's `::orca-visual` lines read their HTML from; null without a client. */
+    visualSource: MobileNativeChatVisualSource | null
+  }

mobile/src/session/mobile-structured-agent-session-host-support.test.ts

@@ -2,6 +2,7 @@ import { describe, expect, it } from 'vitest'
 import {
   AGENT_SESSION_PROMPT_CANCEL_RUNTIME_CAPABILITY,
   AGENT_SESSION_QUESTION_ANSWERS_RUNTIME_CAPABILITY,
+  AGENT_SESSION_QUEUED_COMMANDS_RUNTIME_CAPABILITY,
   AGENT_SESSION_QUEUED_MESSAGES_RUNTIME_CAPABILITY,
   AGENT_SESSION_STATUS_FEED_RUNTIME_CAPABILITY,
   AGENT_SESSION_REPEATED_STOP_RUNTIME_CAPABILITY
@@ -14,6 +15,7 @@ describe('structuredAgentSessionHostSupport', () => {
       promptCancel: false,
       questionAnswers: false,
       queuedMessages: false,
+      queuedCommands: false,
       quietRepeatedStop: false,
       statusFeed: false
     }
@@ -27,6 +29,9 @@ describe('structuredAgentSessionHostSupport', () => {
     expect(
       structuredAgentSessionHostSupport([AGENT_SESSION_QUEUED_MESSAGES_RUNTIME_CAPABILITY])
     ).toEqual({ ...none, queuedMessages: true })
+    expect(
+      structuredAgentSessionHostSupport([AGENT_SESSION_QUEUED_COMMANDS_RUNTIME_CAPABILITY])
+    ).toEqual({ ...none, queuedCommands: true })
     expect(
       structuredAgentSessionHostSupport([AGENT_SESSION_REPEATED_STOP_RUNTIME_CAPABILITY])
     ).toEqual({ ...none, quietRepeatedStop: true })

mobile/src/session/mobile-structured-agent-session-host-support.ts

@@ -1,6 +1,7 @@
 import {
   AGENT_SESSION_PROMPT_CANCEL_RUNTIME_CAPABILITY,
   AGENT_SESSION_QUESTION_ANSWERS_RUNTIME_CAPABILITY,
+  AGENT_SESSION_QUEUED_COMMANDS_RUNTIME_CAPABILITY,
   AGENT_SESSION_QUEUED_MESSAGES_RUNTIME_CAPABILITY,
   AGENT_SESSION_STATUS_FEED_RUNTIME_CAPABILITY,
   AGENT_SESSION_REPEATED_STOP_RUNTIME_CAPABILITY
@@ -12,6 +13,8 @@ export type StructuredAgentSessionHostSupport = {
   questionAnswers: boolean
   /** Mid-turn sends queue as host-held drafts; an older host keeps today's immediate path. */
   queuedMessages: boolean
+  /** A /compact sent while the agent works waits as a card; an older host refuses it. */
+  queuedCommands: boolean
   /** The host publishes every session's status on one stream. A host from before phones could
    *  read it refuses the call, which reads the same as its absence. */
   statusFeed: boolean
@@ -26,6 +29,7 @@ export function structuredAgentSessionHostSupport(
     promptCancel: capabilities.includes(AGENT_SESSION_PROMPT_CANCEL_RUNTIME_CAPABILITY),
     questionAnswers: capabilities.includes(AGENT_SESSION_QUESTION_ANSWERS_RUNTIME_CAPABILITY),
     queuedMessages: capabilities.includes(AGENT_SESSION_QUEUED_MESSAGES_RUNTIME_CAPABILITY),
+    queuedCommands: capabilities.includes(AGENT_SESSION_QUEUED_COMMANDS_RUNTIME_CAPABILITY),
     statusFeed: capabilities.includes(AGENT_SESSION_STATUS_FEED_RUNTIME_CAPABILITY),
     quietRepeatedStop: capabilities.includes(AGENT_SESSION_REPEATED_STOP_RUNTIME_CAPABILITY)
   }

mobile/src/session/mobile-structured-composer-command.test.ts

@@ -32,7 +32,8 @@ function setup() {
       setOption: vi.fn(async () => true),
       conversationCommands: ['clear', 'compact']
     },
-    canRun: () => true,
+    busy: () => null,
+    waitsInLine: () => false,
     onError: vi.fn(),
     timeoutMs: 15000
   }
@@ -102,7 +103,7 @@ describe('mobile structured conversation commands', () => {
         input.text = '/compact instructions'
       }
       if (reason === 'pending work') {
-        input.canRun = () => false
+        input.busy = () => 'working'
       }
       expect(await dispatchMobileStructuredCommand(input)).toBe('rejected')
       expect(sendRequest).not.toHaveBeenCalled()
@@ -119,6 +120,84 @@ describe('mobile structured conversation commands', () => {
     expect(fields.command).toBe('clear')
     expect(asyncStorage.setItem).not.toHaveBeenCalled()
   })
+  it('a /compact the host holds in line skips the busy check, asks to wait, and shows nothing', async () => {
+    const { input, sendRequest } = setup()
+    sendRequest.mockResolvedValueOnce({
+      ok: true,
+      result: {
+        ok: true,
+        value: {
+          command: 'compact',
+          state: 'completed',
+          queued: { messageId: 'op', position: 1, state: 'waiting' }
+        }
+      }
+    })
+    input.busy = () => 'working'
+    input.waitsInLine = (command) => command === 'compact'
+    expect(await dispatchMobileStructuredCommand(input)).toBe('accepted')
+    const fields = requestFields(sendRequest.mock.calls[0])
+    expect(fields).toMatchObject({ command: 'compact', delivery: 'queue-if-active' })
+    expect(input.onError).not.toHaveBeenCalled()
+    // A /clear never waits: the busy check still answers it.
+    expect(await dispatchMobileStructuredCommand({ ...input, text: '/clear' })).toBe('rejected')
+    expect(sendRequest).toHaveBeenCalledOnce()
+  })
+  it('a /clear while the agent works says so in plain words', async () => {
+    const { input, sendRequest } = setup()
+    input.busy = () => 'working'
+    expect(await dispatchMobileStructuredCommand({ ...input, text: '/clear' })).toBe('rejected')
+    expect(input.onError).toHaveBeenLastCalledWith(
+      "The agent is still working. Run /clear when it's done.",
+      'working'
+    )
+    input.busy = () => 'prompt'
+    expect(await dispatchMobileStructuredCommand({ ...input, text: '/clear' })).toBe('rejected')
+    expect(input.onError).toHaveBeenLastCalledWith(
+      "Answer the agent's question or approval, then run /clear.",
+      'prompt'
+    )
+    input.busy = () => 'working'
+    expect(await dispatchMobileStructuredCommand(input)).toBe('rejected')
+    expect(input.onError).toHaveBeenLastCalledWith(
+      "The agent is still working. Run /compact when it's done.",
+      'working'
+    )
+    expect(sendRequest).not.toHaveBeenCalled()
+  })
+  it("a host's refusal names its cause only when the phone showed it at the press", async () => {
+    const { input, sendRequest } = setup()
+    const refused = {
+      ok: true,
+      result: {
+        ok: true,
+        value: {
+          command: 'compact',
+          state: 'completed',
+          error: "The agent is still working. Run /compact when it's done.",
+          failure: {
+            kind: 'commandRefused',
+            refusal: { code: 'agent_session_operation_invalid', details: { reason: 'turnActive' } }
+          }
+        }
+      }
+    }
+    sendRequest.mockResolvedValue(refused)
+    input.waitsInLine = () => true
+    input.busy = () => 'working'
+    expect(await dispatchMobileStructuredCommand(input)).toBe('rejected')
+    expect(input.onError).toHaveBeenLastCalledWith(
+      "The agent is still working. Run /compact when it's done.",
+      'working'
+    )
+    // Ahead of the phone: said as any failure, so it can't go before it is read.
+    input.busy = () => null
+    expect(await dispatchMobileStructuredCommand(input)).toBe('rejected')
+    expect(input.onError).toHaveBeenLastCalledWith(
+      "The agent is still working. Run /compact when it's done.",
+      undefined
+    )
+  })
   it('keeps ordinary messages on the existing send path', async () => {
     const { input, sendRequest } = setup()
     expect(await dispatchMobileStructuredCommand({ ...input, text: 'hello' })).toBeNull()