fix(native-chat): anchor literal image-marker stripping to a real image send (STA-4363)

mobile/src/session/MobileNativeChatOverlay.test.ts

@@ -24,12 +24,27 @@ type Tick = {
   streamingText?: string
   streamLive?: boolean
   identity?: string
+  /** The load-earlier affordance, which may over-report on a window filled to
+   *  exactly the limit. Deliberately NOT what the fold reads. */
+  hasMore?: boolean
+  /** The host's own paging answer. Only this may decide whether the oldest
+   *  visible row is a window head that lost its image-source run — an inferred
+   *  true here would erase an `[Image #n]` the user typed. */
+  earlierHistoryConfirmed?: boolean
+  /** The row the host answered about, while it is still on screen. */
+  windowHeadMessageId?: string
 }
 
 function overlayElement(tick: Tick): ReturnType<typeof createElement> {
   const controller = {
     showNativeChat: tick.show ?? true,
-    nativeChatSession: { messages: tick.messages ?? [], status: 'ready' },
+    nativeChatSession: {
+      messages: tick.messages ?? [],
+      status: 'ready',
+      hasMore: tick.hasMore ?? false,
+      earlierHistoryConfirmed: tick.earlierHistoryConfirmed ?? false,
+      windowHeadMessageId: tick.windowHeadMessageId
+    },
     nativeChatAgent: 'claude',
     nativeChatAgentWorking: tick.streamLive ?? false,
     nativeChatStreamingText: tick.streamingText,
@@ -172,3 +187,83 @@ describe('MobileNativeChatOverlay streaming gate', () => {
     expect(streaming()).toBeNull()
   })
 })
+
+// STA-4363, mobile half. The window-head rule strips a head turn's `[Image #n]`
+// run because the read window may have trimmed the source turns that vouch for
+// it — true only while older history exists. Desktop derives the head from its
+// read list, mobile from the merged list, so pin mobile's own derivation: a
+// pure-function test of the fold cannot see this call site stop guarding it.
+describe('MobileNativeChatOverlay window-head marker rule', () => {
+  function markerTurn(id: string, text: string, timestamp: number): NativeChatMessage {
+    return { id, role: 'user', blocks: [{ type: 'text', text }], timestamp, source: 'transcript' }
+  }
+
+  /** Mounts the overlay, reads the rows it handed the chat view, unmounts. Each
+   *  case owns its renderer, so nothing leaks between them. Inferred rather than
+   *  annotated: `react-test-renderer` ships no usable types here, so naming the
+   *  handle in a union with null yields a redundant `any` constituent. */
+  async function foldedFor(tick: Tick): Promise<NativeChatMessage[]> {
+    const mounted = create(overlayElement(tick))
+    await act(async () => {})
+    const folded = mounted.root.findAll((node) => node.type === 'ChatView')[0].props
+      .folded as NativeChatMessage[]
+    mounted.unmount()
+    return folded
+  }
+
+  async function foldedById(earlierHistoryConfirmed: boolean): Promise<Map<string, unknown>> {
+    const folded = await foldedFor({
+      earlierHistoryConfirmed,
+      windowHeadMessageId: earlierHistoryConfirmed ? 'u-head' : undefined,
+      messages: [
+        markerTurn('u-head', '[Image #1] hello', 1),
+        markerTurn('u-tail', '[Image #2] bye', 2)
+      ]
+    })
+    return new Map(folded.map((message) => [message.id, message.blocks]))
+  }
+
+  it('keeps the head turn’s literal markers when the window holds the whole conversation', async () => {
+    expect((await foldedById(false)).get('u-head')).toEqual([
+      { type: 'text', text: '[Image #1] hello' }
+    ])
+  })
+
+  it('strips the head turn’s markers only while older history is still pageable', async () => {
+    expect((await foldedById(true)).get('u-head')).toEqual([{ type: 'text', text: 'hello' }])
+  })
+
+  // `hasMore` also reports true for a window filled to exactly the limit, where
+  // nothing older exists. Riding it here would erase a marker the user typed at
+  // the true start of the conversation — the ticket's own defect. Mobile's window
+  // is 40, so that exact fill is reachable.
+  it('does not strip on an inferred paging answer the host never confirmed', async () => {
+    const folded = await foldedFor({
+      hasMore: true,
+      earlierHistoryConfirmed: false,
+      messages: [markerTurn('u-head', '[Image #1] hello', 1)]
+    })
+    expect(folded[0]?.blocks).toEqual([{ type: 'text', text: '[Image #1] hello' }])
+  })
+
+  // A live append past the window trims the front, so the row that slides up was
+  // already on screen rendered literally. Re-reading it as a window head would
+  // rewrite a message the user had seen — the ticket's own defect, on mobile's
+  // 40-turn window, during any active agent run.
+  it('does not strip a row that only became the head after a live trim', async () => {
+    const folded = await foldedFor({
+      earlierHistoryConfirmed: true,
+      // The recorded head has been trimmed away; nothing on screen is known to
+      // sit mid-run any more.
+      windowHeadMessageId: 'u-trimmed-away',
+      messages: [markerTurn('u-head', '[Image #1] hello', 1)]
+    })
+    expect(folded[0]?.blocks).toEqual([{ type: 'text', text: '[Image #1] hello' }])
+  })
+
+  it('leaves a turn below the head literal even while older history exists', async () => {
+    expect((await foldedById(true)).get('u-tail')).toEqual([
+      { type: 'text', text: '[Image #2] bye' }
+    ])
+  })
+})

mobile/src/session/MobileNativeChatOverlay.tsx

@@ -46,7 +46,10 @@ export function MobileNativeChatOverlay({
   keyboardInset
 }: Props): React.JSX.Element | null {
   const session = controller.nativeChatSession
-  const folded = useMemo(() => foldMobileNativeChatMessages(session.messages), [session.messages])
+  const folded = useMemo(
+    () => foldMobileNativeChatMessages(session.messages, session.windowHeadMessageId),
+    [session.messages, session.windowHeadMessageId]
+  )
   const streaming = useMobileNativeChatStreamingBubble(
     folded,
     controller.nativeChatStreamingText,

mobile/src/session/mobile-native-chat-draft-reconcile.test.ts

@@ -1,9 +1,11 @@
 import { describe, expect, it } from 'vitest'
 import type { NativeChatMessage } from '../../../src/shared/native-chat-types'
 import {
+  countUserTextOccurrences,
   findLandedImagePreviewEchoes,
   findLandedUnconfirmedSends,
   migrateImagePreviewMessageIds,
+  userTextOccurrenceCounts,
   type PendingImagePreviewEcho,
   type UnconfirmedSend
 } from './mobile-native-chat-draft-reconcile'
@@ -23,6 +25,73 @@ function pending(id: string, images: string[], expectedOccurrence = 1): PendingI
 }
 
 describe('mobile native chat image preview reconciliation', () => {
+  // Some hosts echo an image send as a user turn they kept no content for. The
+  // preview-binding path already accepts that shape and shows the photo, so the
+  // send must reconcile against it too — otherwise the send stays held and the
+  // 20s deadline warns "delivery unknown" about a message that plainly landed.
+  // Keyed under '' either way, so only a captionless send can reach it.
+  it('reconciles an image-only send against an echo the host left empty', () => {
+    const messages = [
+      {
+        id: 'base',
+        role: 'assistant' as const,
+        blocks: [{ type: 'text' as const, text: 'ready' }],
+        timestamp: null,
+        source: 'transcript' as const
+      },
+      {
+        id: 'echo',
+        role: 'user' as const,
+        blocks: [],
+        timestamp: null,
+        source: 'transcript' as const
+      }
+    ]
+    const unconfirmed: UnconfirmedSend = {
+      draftKey: 'draft',
+      pendingKey: 'pending-key',
+      text: '',
+      normalizedText: '',
+      imageCount: 1,
+      baselineTailMessageId: 'base',
+      deadline: null
+    }
+
+    expect(findLandedUnconfirmedSends(messages, [unconfirmed])).toEqual([unconfirmed])
+  })
+
+  // The empty turn says nothing about a caption, so a send that carried one must
+  // not claim it — that would retire a bubble whose text never landed.
+  it('does not let an empty echo claim a captioned image send', () => {
+    const messages = [
+      {
+        id: 'base',
+        role: 'assistant' as const,
+        blocks: [{ type: 'text' as const, text: 'ready' }],
+        timestamp: null,
+        source: 'transcript' as const
+      },
+      {
+        id: 'echo',
+        role: 'user' as const,
+        blocks: [],
+        timestamp: null,
+        source: 'transcript' as const
+      }
+    ]
+    const unconfirmed: UnconfirmedSend = {
+      draftKey: 'draft',
+      pendingKey: 'pending-key',
+      text: 'look at this',
+      normalizedText: 'look at this',
+      imageCount: 1,
+      baselineTailMessageId: 'base',
+      deadline: null
+    }
+
+    expect(findLandedUnconfirmedSends(messages, [unconfirmed])).toEqual([])
+  })
+
   it('reconciles a trailing-marker echo and hands its preview to that echo', () => {
     const messages = [
       userText('source', '[Image: source: /tmp/a.png]'),
@@ -37,6 +106,7 @@ describe('mobile native chat image preview reconciliation', () => {
       pendingKey: 'pending-key',
       text: 'look at this',
       normalizedText: 'look at this',
+      imageCount: 1,
       baselineTailMessageId: null,
       deadline: null
     }
@@ -58,6 +128,7 @@ describe('mobile native chat image preview reconciliation', () => {
       pendingKey: 'pending-key',
       text: 'look here',
       normalizedText: 'look here',
+      imageCount: 1,
       baselineTailMessageId: null,
       deadline: null
     }
@@ -68,6 +139,54 @@ describe('mobile native chat image preview reconciliation', () => {
     ])
   })
 
+  it('does not treat markerless text as an unknown-ack literal marker echo', () => {
+    const unconfirmed: UnconfirmedSend = {
+      draftKey: 'draft',
+      pendingKey: 'pending-key',
+      text: 'keep [Image #1] literal',
+      normalizedText: 'keep [Image #1] literal',
+      imageCount: 0,
+      baselineTailMessageId: null,
+      deadline: null
+    }
+
+    expect(findLandedUnconfirmedSends([userText('wrong', 'keep literal')], [unconfirmed])).toEqual(
+      []
+    )
+    expect(
+      findLandedUnconfirmedSends([userText('right', 'keep [Image #1] literal')], [unconfirmed])
+    ).toEqual([unconfirmed])
+  })
+
+  it('does not treat literal marker text as a markerless unknown-ack echo', () => {
+    const unconfirmed: UnconfirmedSend = {
+      draftKey: 'draft',
+      pendingKey: 'pending-key',
+      text: 'keep literal',
+      normalizedText: 'keep literal',
+      imageCount: 0,
+      baselineTailMessageId: null,
+      deadline: null
+    }
+
+    expect(
+      findLandedUnconfirmedSends([userText('wrong', 'keep [Image #1] literal')], [unconfirmed])
+    ).toEqual([])
+    expect(findLandedUnconfirmedSends([userText('right', 'keep literal')], [unconfirmed])).toEqual([
+      unconfirmed
+    ])
+  })
+
+  it('keeps no-image occurrence baselines separate from attached-image turns', () => {
+    const messages = [
+      userText('source', '[Image: source: /tmp/a.png]'),
+      userText('prompt', 'keep [Image #1] literal')
+    ]
+
+    expect(countUserTextOccurrences(messages, 'keep literal')).toBe(0)
+    expect(countUserTextOccurrences(messages, 'keep literal', 1)).toBe(1)
+  })
+
   it('reconciles multiple transcript text blocks with desktop separators', () => {
     const prompt: NativeChatMessage = {
       ...userText('prompt', 'unused'),
@@ -84,6 +203,24 @@ describe('mobile native chat image preview reconciliation', () => {
     ])
   })
 
+  it('hands a local preview to a marker-only transcript echo', () => {
+    expect(
+      findLandedImagePreviewEchoes(
+        [userText('prompt', '[Image #1]')],
+        [pending('pending', ['file:///a.jpg'])]
+      )
+    ).toEqual([{ pendingId: 'pending', messageId: 'prompt', images: ['file:///a.jpg'] }])
+  })
+
+  it('hands a captioned preview to a marker-only compatibility echo', () => {
+    expect(
+      findLandedImagePreviewEchoes(
+        [userText('prompt', 'look [Image #1] here')],
+        [{ ...pending('pending', ['file:///a.jpg']), text: 'look here' }]
+      )
+    ).toEqual([{ pendingId: 'pending', messageId: 'prompt', images: ['file:///a.jpg'] }])
+  })
+
   it('keeps separate adjacent image-only sends independently reconcilable', () => {
     const landed = findLandedImagePreviewEchoes(
       [
@@ -165,3 +302,22 @@ describe('mobile native chat image preview reconciliation', () => {
     ).toEqual({ [sessionKey]: { prompt: ['file:///a.jpg'] } })
   })
 })
+
+describe('userTextOccurrenceCounts', () => {
+  it('counts a literal marker turn under its verbatim text', () => {
+    expect(userTextOccurrenceCounts([userText('u1', 'keep [Image #1] literal')])).toEqual(
+      new Map([['keep [Image #1] literal', 1]])
+    )
+  })
+
+  // An attached-image turn must not retire a send that carried no images.
+  it('excludes a folded image turn from the literal landed counts', () => {
+    const counts = userTextOccurrenceCounts([
+      userText('s1', '[Image: source: /tmp/a.png]'),
+      userText('p1', '[Image #1] look')
+    ])
+
+    expect(counts.get('look')).toBeUndefined()
+    expect(counts.size).toBe(0)
+  })
+})