feat(native-chat): the chat reads "Stopping…" from your Stop until the turn actually ends

mobile/src/files/MobileFileExplorerPanel.tsx

@@ -28,7 +28,8 @@ import {
   resetDirectoryLoadRevisions,
   type DirectoryLoadRevisions
 } from './directory-load-revisions'
-import { directoryCacheFromFileList, isMobileMethodUnavailableError } from './file-list-fallback'
+import { isMobileMethodUnavailableError } from '../transport/mobile-method-unavailable'
+import { directoryCacheFromFileList } from './file-list-fallback'
 import { fileDirectoryRead, legacyFileListRead } from './mobile-file-explorer-operations'
 import { fileExplorerStyles as styles } from './mobile-file-explorer-styles'
 import { MobileFileExplorerRow } from './mobile-file-explorer-row'

mobile/src/files/file-explorer-reply-schema.ts

@@ -31,7 +31,7 @@ export const fileDirectoryEntriesSchema = salvagingArray(
  * The capped flat list an older desktop answers when `files.readDir` is not allowlisted.
  *
  * `files` and `truncated` are both required and both read unguarded: directoryCacheFromFileList
- * walks `files` and splits each `relativePath` (file-list-fallback.ts:48), and
+ * walks `files` and splits each `relativePath` (file-list-fallback.ts:34), and
  * MobileFileExplorerPanel.tsx:136 publishes `truncated` into the state that draws the "Showing
  * first 5000" note. A row without a string `relativePath` drops — it can name no directory — where
  * main crashed the whole fallback on it.

mobile/src/files/file-list-fallback.test.ts

@@ -1,22 +1,7 @@
 import { describe, expect, it } from 'vitest'
-import { directoryCacheFromFileList, isMobileMethodUnavailableError } from './file-list-fallback'
+import { directoryCacheFromFileList } from './file-list-fallback'
 import { getDirectoryCacheState } from './file-tree'
 
-describe('isMobileMethodUnavailableError', () => {
-  it('detects old-desktop allowlist and missing-method failures', () => {
-    expect(isMobileMethodUnavailableError('forbidden', undefined)).toBe(true)
-    expect(isMobileMethodUnavailableError('method_not_found', undefined)).toBe(true)
-    expect(
-      isMobileMethodUnavailableError(
-        'some_code',
-        "Method 'files.readDir' is not available to mobile clients"
-      )
-    ).toBe(true)
-    expect(isMobileMethodUnavailableError('internal', 'boom')).toBe(false)
-    expect(isMobileMethodUnavailableError(undefined, undefined)).toBe(false)
-  })
-})
-
 describe('directoryCacheFromFileList', () => {
   it('synthesizes every ancestor directory from flat paths', () => {
     const cache = directoryCacheFromFileList([

mobile/src/files/file-list-fallback.ts

@@ -15,20 +15,6 @@ export type LegacyFilesListResult = {
   truncated: boolean
 }
 
-// Same detection shape as isMobileGitUnavailable in mobile-git-status.ts:
-// 'forbidden' = method exists but is not mobile-allowlisted on the old
-// desktop; 'method_not_found' = desktop predates the method entirely.
-export function isMobileMethodUnavailableError(
-  code: string | undefined,
-  message: string | undefined
-): boolean {
-  return (
-    code === 'forbidden' ||
-    code === 'method_not_found' ||
-    message?.includes('not available to mobile clients') === true
-  )
-}
-
 // Takes only the member it reads: the explorer's reply reader checks `relativePath` and passes the
 // rest of each row through, so naming the whole row here would re-declare what it deliberately did not.
 export function directoryCacheFromFileList(

mobile/src/session/MobileNativeChatLiveLine.android.test.ts

@@ -56,7 +56,13 @@ describe('MobileNativeChatLiveLine on Android', () => {
     act(() => {
       renderer = create(
         createElement(MobileNativeChatLiveLine, {
-          line: { thinking: true, activityText: null, reasoning: block, reasoningExpanded: true },
+          line: {
+            thinking: true,
+            stopping: false,
+            activityText: null,
+            reasoning: block,
+            reasoningExpanded: true
+          },
           onToggleReasoning: vi.fn(),
           fontScale: 1
         })
@@ -78,7 +84,13 @@ describe('MobileNativeChatLiveLine on Android', () => {
   it('keeps the sheet through the block ending, and never opens one for the next by itself', () => {
     const line = (reasoning: NativeChatLiveReasoning | null) =>
       createElement(MobileNativeChatLiveLine, {
-        line: { thinking: true, activityText: null, reasoning, reasoningExpanded: true },
+        line: {
+          thinking: true,
+          stopping: false,
+          activityText: null,
+          reasoning,
+          reasoningExpanded: true
+        },
         onToggleReasoning: vi.fn(),
         fontScale: 1
       })
@@ -103,7 +115,13 @@ describe('MobileNativeChatLiveLine on Android', () => {
   it('opens no sheet for the next block when the first ends with the sheet open', () => {
     const line = (reasoning: NativeChatLiveReasoning | null) =>
       createElement(MobileNativeChatLiveLine, {
-        line: { thinking: true, activityText: null, reasoning, reasoningExpanded: true },
+        line: {
+          thinking: true,
+          stopping: false,
+          activityText: null,
+          reasoning,
+          reasoningExpanded: true
+        },
         onToggleReasoning: vi.fn(),
         fontScale: 1
       })

mobile/src/session/MobileNativeChatLiveLine.test.ts

@@ -61,6 +61,7 @@ describe('MobileNativeChatLiveLine', () => {
   function element(
     fields: {
       thinking?: boolean
+      stopping?: boolean
       activityText?: string | null
       reasoning?: NativeChatLiveReasoning | null
       reasoningExpanded?: boolean
@@ -69,6 +70,7 @@ describe('MobileNativeChatLiveLine', () => {
     return createElement(MobileNativeChatLiveLine, {
       line: {
         thinking: true,
+        stopping: false,
         activityText: null,
         reasoning: null,
         reasoningExpanded: false,
@@ -110,6 +112,11 @@ describe('MobileNativeChatLiveLine', () => {
     expect(labels(render({ activityText: 'Running pnpm test' }))).toEqual(['Running pnpm test'])
   })
 
+  it("reads Stopping over provider activity once a person's Stop is ending the turn", () => {
+    const root = render({ thinking: false, activityText: 'Running pnpm test', stopping: true })
+    expect(labels(root)).toEqual(['Stopping…'])
+  })
+
   it('announces what it says to assistive tech, and is no button while it discloses nothing', () => {
     const line = header(render())
     expect(line.props.accessibilityLiveRegion).toBe('polite')

mobile/src/session/MobileNativeChatLiveLine.tsx

@@ -10,8 +10,9 @@ import { MobileNativeChatMessageActionsSheet } from './MobileNativeChatMessageAc
 import { MobileNativeChatReasoningBody } from './MobileNativeChatReasoningRow'
 import type { MobileNativeChatLiveLine as LiveLine } from './use-mobile-native-chat-turn-disclosure'
 
-/** The live turn's tail line: a spinner beside what the provider says it is doing, else
- *  "Thinking", else "Working…". The clock stays in the turn bar. While the agent's open reasoning
+/** The live turn's tail line: a spinner beside "Stopping…" once the person's Stop is ending the
+ *  turn, else what the provider says it is doing, else "Thinking", else "Working…". The clock
+ *  stays in the turn bar. While the agent's open reasoning
  *  block has text it is also that block's disclosure, and the block's row draws nothing.
  *  Desktop parity: `NativeChatTurnActivityLine`. */
 export function MobileNativeChatLiveLine({

mobile/src/session/MobileNativeChatOverlay.test.ts

@@ -25,6 +25,8 @@ type Tick = {
   streamingText?: string
   streamLive?: boolean
   identity?: string
+  /** The host says a person's Stop is ending the turn. */
+  stopping?: boolean
 }
 
 function overlayElement(tick: Tick): ReturnType<typeof createElement> {
@@ -34,6 +36,11 @@ function overlayElement(tick: Tick): ReturnType<typeof createElement> {
     nativeChatSession: { messages: tick.messages ?? [], status: 'ready' },
     nativeChatAgent: 'claude',
     nativeChatAgentWorking: tick.streamLive ?? false,
+    nativeChatTurnIndicator: {
+      thinking: false,
+      activityText: null,
+      stopping: tick.stopping ?? false
+    },
     nativeChatStreamingText: tick.streamingText,
     nativeChatStreamLive: tick.streamLive ?? false,
     nativeChatStreamScopeKey: tick.identity ?? 'tab-a',
@@ -185,3 +192,28 @@ describe('MobileNativeChatOverlay streaming gate', () => {
     expect(streaming()).toBeNull()
   })
 })
+
+describe("MobileNativeChatOverlay while a person's Stop ends the turn", () => {
+  let renderer: ReactTestRenderer | null = null
+
+  afterEach(() => {
+    act(() => renderer?.unmount())
+    renderer = null
+  })
+
+  async function steerHeld(tick: Tick): Promise<unknown> {
+    await act(async () => {
+      renderer = create(overlayElement(tick))
+    })
+    const view = renderer!.root.find((node) => node.type === 'ChatView')
+    return view.props.queuedSlot?.cards?.props?.steerHeld
+  }
+
+  it("holds the queued cards' Steer while the agent works and the host says Stopping", async () => {
+    expect(await steerHeld({ streamLive: true, stopping: true })).toBe(true)
+  })
+
+  it('leaves Steer to the cards otherwise', async () => {
+    expect(await steerHeld({ streamLive: true, stopping: false })).toBe(false)
+  })
+})

mobile/src/session/MobileNativeChatOverlay.tsx

@@ -68,7 +68,10 @@ export function MobileNativeChatOverlay({
     onEdit: queued.edit,
     pause: queued.pause,
     onResume: queued.resume,
-    sessionKey: queued.sessionKey
+    sessionKey: queued.sessionKey,
+    // Nothing steers into a turn a Stop is ending; the host holds such a send until it ends.
+    // The indicator's `stopping` is the display status, decided once in the session hook.
+    steerHeld: controller.nativeChatTurnIndicator?.stopping === true
   })
   if (!controller.showNativeChat) {
     return null

mobile/src/session/MobileNativeChatQueuedMessages.test.tsx

@@ -156,6 +156,25 @@ describe('MobileNativeChatQueuedMessages', () => {
     expect(nodeTypes(rows[1]!)).toContain('CornerDownRight')
   })
 
+  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)
+    const mounted = await mount({
+      cards: [card({ messageId: 'w' })],
+      onSend,
+      onDelete,
+      steerHeld: true
+    })
+    const steer = mounted.root.findByProps({
+      accessibilityLabel: 'Submit without interrupting the model'
+    })
+    expect(steer.props.disabled).toBe(true)
+    expect(steer.props.accessibilityState).toEqual({ disabled: true })
+    const trash = mounted.root.findByProps({ accessibilityLabel: 'Delete this queued message' })
+    await act(async () => trash.props.onPress())
+    expect(onDelete).toHaveBeenCalledWith('w')
+  })
+
   it('deletes a card from its trash button', async () => {
     const onDelete = vi.fn(async () => true)
     const mounted = await mount({ cards: [card({ messageId: 'w' })], onDelete })

mobile/src/session/MobileNativeChatQueuedMessages.tsx

@@ -34,6 +34,8 @@ export type MobileNativeChatQueuedMessagesProps = {
   /** The whole queue's pause: the box's first row, with Resume. */
   pause?: MobileQueuePause
   onResume?: () => Promise<boolean>
+  /** The chat reads Stopping: no card steers into the turn a Stop is ending. */
+  steerHeld?: boolean
 }
 
 /** The host-held queued drafts, as one box of compact rows between transcript and
@@ -44,7 +46,8 @@ export function MobileNativeChatQueuedMessages({
   onDelete,
   onEdit,
   pause,
-  onResume
+  onResume,
+  steerHeld = false
 }: MobileNativeChatQueuedMessagesProps): React.JSX.Element | null {
   // One in-flight action per card; a second tap must not double-consume. The ref
   // closes the same-frame double tap the disabled state cannot.
@@ -136,7 +139,7 @@ export function MobileNativeChatQueuedMessages({
               </View>
               <Pressable
                 accessibilityRole="button"
-                accessibilityState={{ disabled: busy }}
+                accessibilityState={{ disabled: busy || steerHeld }}
                 accessibilityLabel={
                   returned
                     ? 'Send this message again'
@@ -147,9 +150,9 @@ export function MobileNativeChatQueuedMessages({
                 style={({ pressed }) => [
                   styles.textAction,
                   pressed && styles.pressed,
-                  busy && styles.disabled
+                  (busy || steerHeld) && styles.disabled
                 ]}
-                disabled={busy}
+                disabled={busy || steerHeld}
                 onPress={() => void run(card.messageId, onSend)}
               >
                 {steers ? (

mobile/src/session/MobileNativeChatStopButton.tsx

@@ -0,0 +1,28 @@
+import { Pressable, Text } from 'react-native'
+import { Square } from 'lucide-react-native'
+import { NATIVE_CHAT_TURN_STATUS_COPY } from '../../../src/shared/native-chat-turn-status'
+import { colors } from '../theme/mobile-theme'
+import { styles } from './mobile-native-chat-view-styles'
+
+/** The chat header's Stop. `held`: this phone's own Stop request is still in flight. */
+export function MobileNativeChatStopButton({
+  onStop,
+  held
+}: {
+  onStop?: () => void
+  held: boolean
+}): React.JSX.Element {
+  const label = held ? NATIVE_CHAT_TURN_STATUS_COPY.stopping : 'Stop'
+  return (
+    <Pressable
+      style={({ pressed }) => [styles.stopButton, pressed && styles.pressed]}
+      onPress={onStop}
+      disabled={held}
+      hitSlop={8}
+      accessibilityLabel={held ? label : 'Stop the agent'}
+    >
+      <Square size={13} color={colors.statusRed} strokeWidth={2.4} fill={colors.statusRed} />
+      <Text style={styles.stopLabel}>{label}</Text>
+    </Pressable>
+  )
+}

mobile/src/session/MobileNativeChatView.test.ts

@@ -151,6 +151,55 @@ describe('MobileNativeChatView', () => {
     })
   }
 
+  it("holds Stop and says Stopping while this phone's own Stop request is in flight", async () => {
+    await render({
+      structuredActivityUi: true,
+      agentWorking: true,
+      canStop: true,
+      turnIndicator: {
+        thinking: false,
+        activityText: null,
+        stopping: true,
+        stopRequestInFlight: true
+      }
+    })
+    const stop = renderer!.root.find(
+      (node) => node.type === 'Pressable' && node.props.accessibilityLabel === 'Stopping…'
+    )
+    expect(stop.props.disabled).toBe(true)
+  })
+
+  it.each([
+    ['queue', 'Queue a message to run after the stop'],
+    ['send', 'Send a message to run after the stop']
+  ] as const)(
+    'tells the composer a message sent now runs after the stop (%s)',
+    async (afterStop, placeholder) => {
+      await render({
+        structuredActivityUi: true,
+        agentWorking: true,
+        canStop: true,
+        turnIndicator: { thinking: false, activityText: null, stopping: true, afterStop }
+      })
+      const composer = renderer!.root.find((node) => node.type === 'Composer')
+      expect(composer.props.placeholder).toBe(placeholder)
+    }
+  )
+
+  // A Stop the provider took and never answered ends only at a repeat Stop.
+  it('keeps Stop for the repeat that escalates while the host alone says Stopping', async () => {
+    await render({
+      structuredActivityUi: true,
+      agentWorking: true,
+      canStop: true,
+      turnIndicator: { thinking: false, activityText: null, stopping: true }
+    })
+    const stop = renderer!.root.find(
+      (node) => node.type === 'Pressable' && node.props.accessibilityLabel === 'Stop the agent'
+    )
+    expect(stop.props.disabled).toBe(false)
+  })
+
   /** Ids of the rows the list is currently rendering. */
   it('keeps Stop hidden during a structured dispatch until a provider turn can be cancelled', async () => {
     const props = { structuredActivityUi: true, agentWorking: true, canStop: false }