diff --git a/mobile/src/session/MobileNativeChatComposer.test.ts b/mobile/src/session/MobileNativeChatComposer.test.ts
index 1d1b0288467a..3c8afe2cefd6 100644
--- a/mobile/src/session/MobileNativeChatComposer.test.ts
+++ b/mobile/src/session/MobileNativeChatComposer.test.ts
@@ -84,7 +84,9 @@ describe('MobileNativeChatComposer', () => {
 
     await act(async () => sendButton().props.onPress())
 
-    expect(onSend).toHaveBeenCalledWith(' hello')
+    // Verbatim: the send seam trims for the wire, so a rejected send can hand
+    // back the draft byte-for-byte (#14819).
+    expect(onSend).toHaveBeenCalledWith(' hello ')
     expect(onChangeText).not.toHaveBeenCalled()
   })
 
@@ -120,7 +122,7 @@ describe('MobileNativeChatComposer', () => {
       )
     })
     await act(async () => sendButton().props.onPress())
-    expect(onSend).toHaveBeenCalledWith(' /clear is prose')
+    expect(onSend).toHaveBeenCalledWith(' /clear is prose ')
   })
 
   it('locks the option pickers while a composer send is in flight', async () => {
@@ -219,7 +221,7 @@ describe('MobileNativeChatComposer', () => {
 
     await act(async () => sendButton().props.onPress())
 
-    expect(onSend).toHaveBeenCalledWith(' hello')
+    expect(onSend).toHaveBeenCalledWith(' hello ')
     expect(onChangeText).not.toHaveBeenCalled()
   })
 
diff --git a/mobile/src/session/MobileNativeChatComposer.tsx b/mobile/src/session/MobileNativeChatComposer.tsx
index 9b289b4b6e81..ee937369ea7e 100644
--- a/mobile/src/session/MobileNativeChatComposer.tsx
+++ b/mobile/src/session/MobileNativeChatComposer.tsx
@@ -151,7 +151,9 @@ export function MobileNativeChatComposer({
     sendingRef.current = true
     setSending(true)
     try {
-      const accepted = await onSend(value.trimEnd())
+      // Raw, not trimmed: the send seam owns the wire trim, and a rejection has
+      // to hand the user back exactly what they typed (#14819).
+      const accepted = await onSend(value)
       if (accepted) {
         setCursor(0)
       }
diff --git a/mobile/src/session/mobile-native-chat-pending-baseline.test.ts b/mobile/src/session/mobile-native-chat-pending-baseline.test.ts
new file mode 100644
index 000000000000..1abdc714e849
--- /dev/null
+++ b/mobile/src/session/mobile-native-chat-pending-baseline.test.ts
@@ -0,0 +1,164 @@
+import { describe, expect, it } from 'vitest'
+import type { NativeChatMessage } from '../../../src/shared/native-chat-types'
+import { rebaseMobileNativeChatPendingBaselines } from './mobile-native-chat-pending-baseline'
+import type { MobileNativeChatPendingMessage } from './mobile-native-chat-pending-echo'
+
+function userTurn(id: string, text: string, timestamp: number): NativeChatMessage {
+  return { id, role: 'user', blocks: [{ type: 'text', text }], timestamp, source: 'transcript' }
+}
+
+function assistantTurn(id: string, text: string, timestamp: number): NativeChatMessage {
+  return {
+    id,
+    role: 'assistant',
+    blocks: [{ type: 'text', text }],
+    timestamp,
+    source: 'transcript'
+  }
+}
+
+function unresolved(
+  id: string,
+  text: string,
+  expectedOccurrence = 1
+): MobileNativeChatPendingMessage {
+  return { id, text, expectedOccurrence, baselineTailMessageId: null, baselineResolved: false }
+}
+
+describe('rebaseMobileNativeChatPendingBaselines', () => {
+  const history = [userTurn('m1', 'run the tests', 1000), assistantTurn('m2', 'passed', 1100)]
+
+  it('returns the same array when every baseline is already resolved', () => {
+    const pending: MobileNativeChatPendingMessage[] = [
+      {
+        id: 'p1',
+        text: 'hi',
+        expectedOccurrence: 1,
+        baselineTailMessageId: 'm2',
+        baselineResolved: true
+      }
+    ]
+    expect(rebaseMobileNativeChatPendingBaselines(history, pending)).toBe(pending)
+  })
+
+  it('gives an unresolved send the loaded tail as its glue boundary', () => {
+    expect(
+      rebaseMobileNativeChatPendingBaselines(history, [unresolved('p1', 'run the tests')])
+    ).toEqual([
+      {
+        id: 'p1',
+        text: 'run the tests',
+        // NOT recounted against this read: the read may already carry this send's
+        // own echo, and counting it as history would strand the bubble forever.
+        expectedOccurrence: 1,
+        baselineTailMessageId: 'm2',
+        baselineResolved: true
+      }
+    ])
+  })
+
+  it('pins to null when the authoritative transcript is empty', () => {
+    expect(rebaseMobileNativeChatPendingBaselines([], [unresolved('p1', 'hi')])).toEqual([
+      {
+        id: 'p1',
+        text: 'hi',
+        expectedOccurrence: 1,
+        baselineTailMessageId: null,
+        baselineResolved: true
+      }
+    ])
+  })
+
+  it('keeps the ordinals the queue already assigned', () => {
+    expect(
+      rebaseMobileNativeChatPendingBaselines(history, [
+        unresolved('p1', 'run the tests', 1),
+        unresolved('p2', 'run the tests', 2)
+      ]).map((item) => item.expectedOccurrence)
+    ).toEqual([1, 2])
+  })
+
+  it('leaves already-resolved neighbours untouched', () => {
+    const resolved: MobileNativeChatPendingMessage = {
+      id: 'p1',
+      text: 'run the tests',
+      expectedOccurrence: 9,
+      baselineTailMessageId: 'm1',
+      baselineResolved: true
+    }
+    const rebased = rebaseMobileNativeChatPendingBaselines(history, [
+      resolved,
+      unresolved('p2', 'run the tests', 2)
+    ])
+    expect(rebased[0]).toBe(resolved)
+    expect(rebased[1]).toEqual({
+      id: 'p2',
+      text: 'run the tests',
+      expectedOccurrence: 2,
+      baselineTailMessageId: 'm2',
+      baselineResolved: true
+    })
+  })
+
+  // An unsettled read still shows this session's own retained history, so a send
+  // made across a reconnect already owns a real boundary. Moving it onto the read
+  // that follows pushes it past the send's own echo and strands the bubble.
+  it('never moves a tail the send actually captured', () => {
+    const captured: MobileNativeChatPendingMessage = {
+      id: 'p1',
+      text: 'run the tests',
+      expectedOccurrence: 1,
+      baselineTailMessageId: 'm1',
+      baselineResolved: false
+    }
+    const rebased = rebaseMobileNativeChatPendingBaselines(history, [captured])
+    expect(rebased[0]?.baselineTailMessageId).toBe('m1')
+    expect(rebased[0]?.baselineResolved).toBe(true)
+  })
+
+  // An image echo counts image turns AFTER its tail, so moving a real tail onto
+  // this read would discard an echo the read already carries.
+  it('keeps a caption-less image echo on the tail it actually captured', () => {
+    const images = {
+      ...unresolved('p1', ''),
+      baselineTailMessageId: 'm1',
+      images: ['file:///a.png']
+    }
+    const rebased = rebaseMobileNativeChatPendingBaselines(history, [images])
+    expect(rebased[0]?.baselineTailMessageId).toBe('m1')
+    expect(rebased[0]?.expectedOccurrence).toBe(1)
+    expect(rebased[0]?.baselineResolved).toBe(true)
+  })
+
+  // A captioned image echo binds by an ordinal counted over the whole transcript.
+  // Pinning a tail without recounting leaves it matching nothing, forever.
+  it('leaves a captioned image echo entirely alone', () => {
+    const rebased = rebaseMobileNativeChatPendingBaselines(history, [
+      { ...unresolved('p1', 'here'), images: ['file:///a.png'] }
+    ])
+    expect(rebased[0]?.baselineTailMessageId).toBe(null)
+    expect(rebased[0]?.expectedOccurrence).toBe(1)
+    expect(rebased[0]?.baselineResolved).toBe(true)
+  })
+
+  // A supplied tail would sit at or after this send's own echo, and an image
+  // echo counts turns AFTER its tail — so it would exclude the very row it is
+  // waiting for, and image entries have no other retirement path.
+  it('never supplies a tail to a caption-less image echo either', () => {
+    const rebased = rebaseMobileNativeChatPendingBaselines(history, [
+      { ...unresolved('p1', ''), images: ['file:///a.png'] },
+      { ...unresolved('p2', '', 2), images: ['file:///b.png'] }
+    ])
+    expect(rebased.map((item) => item.baselineTailMessageId)).toEqual([null, null])
+    expect(rebased.map((item) => item.expectedOccurrence)).toEqual([1, 2])
+    expect(rebased.every((item) => item.baselineResolved)).toBe(true)
+  })
+
+  // Same rule for a text-empty entry with no images: it reconciles by counting
+  // image-source turns after its tail, so a supplied tail strands it too.
+  it('never supplies a tail to a text-empty entry', () => {
+    const rebased = rebaseMobileNativeChatPendingBaselines(history, [unresolved('p1', '   ')])
+    expect(rebased[0]?.baselineTailMessageId).toBe(null)
+    expect(rebased[0]?.baselineResolved).toBe(true)
+  })
+})
diff --git a/mobile/src/session/mobile-native-chat-pending-baseline.ts b/mobile/src/session/mobile-native-chat-pending-baseline.ts
new file mode 100644
index 000000000000..903bf9d8f324
--- /dev/null
+++ b/mobile/src/session/mobile-native-chat-pending-baseline.ts
@@ -0,0 +1,53 @@
+import type { NativeChatMessage } from '../../../src/shared/native-chat-types'
+import { normalizeReconcileText } from './mobile-native-chat-draft-reconcile'
+import type { MobileNativeChatPendingMessage } from './mobile-native-chat-pending-echo'
+
+/**
+ * Give the sends that never saw a transcript the boundary they lack, on the
+ * first settled read.
+ *
+ * Such a send has no row to judge candidates against — which held it out of
+ * matching entirely, stranding it as a queued bubble and, worse, as a permanent
+ * glue barrier for its neighbours.
+ *
+ * Only a send that captured NO tail is pinned. An unsettled read still shows
+ * this session's own retained history (see `createNativeChatTranscriptRetention`
+ * — a reconnect or a failed read keeps the conversation on screen rather than
+ * blanking it), so a send made then already owns a correct boundary. Moving it
+ * onto this read would push it past the send's own echo and strand the bubble
+ * for good.
+ *
+ * The ordinal is deliberately NOT recounted. The read can already carry the
+ * send's own echo — a re-subscribe returns whatever exists now — and nothing
+ * local separates that echo from an identical older prompt: the transport writes
+ * keystrokes into a TUI and carries no message id, and row timestamps come from
+ * the host while the send time comes from the phone. Counting it as history puts
+ * the ordinal one past anything the transcript can supply.
+ *
+ * And only a TEXT-bearing send is given one. The glue matcher is the sole
+ * consumer that a supplied tail helps; every other one is harmed by it. An image
+ * echo reconciles by counting turns AFTER its tail, so a tail taken from a read
+ * that already carries its echo excludes that echo and the bubble can never
+ * retire — image entries have no other retirement path. A captioned one is worse
+ * still: it binds by an ordinal counted over the whole transcript, so a tail
+ * without a matching recount leaves it claiming nothing at all.
+ */
+export function rebaseMobileNativeChatPendingBaselines(
+  messages: readonly NativeChatMessage[],
+  current: MobileNativeChatPendingMessage[]
+): MobileNativeChatPendingMessage[] {
+  if (current.every((item) => item.baselineResolved)) {
+    return current
+  }
+  const baselineTailMessageId = messages.at(-1)?.id ?? null
+  return current.map((item) => {
+    if (item.baselineResolved) {
+      return item
+    }
+    const reconcilesAgainstItsOwnTail =
+      Boolean(item.images?.length) || normalizeReconcileText(item.text) === ''
+    return item.baselineTailMessageId !== null || reconcilesAgainstItsOwnTail
+      ? { ...item, baselineResolved: true }
+      : { ...item, baselineResolved: true, baselineTailMessageId }
+  })
+}
diff --git a/mobile/src/session/mobile-native-chat-pending-echo.ts b/mobile/src/session/mobile-native-chat-pending-echo.ts
index b18136a9d473..7466eae905f7 100644
--- a/mobile/src/session/mobile-native-chat-pending-echo.ts
+++ b/mobile/src/session/mobile-native-chat-pending-echo.ts
@@ -5,6 +5,11 @@ export type MobileNativeChatPendingMessage = {
   /** Local preview URIs carried by the send for its optimistic echo. */
   images?: string[]
   baselineTailMessageId: string | null
+  /** Whether the transcript this baseline was captured from was already this
+   *  session's own history. A send issued mid-hydration is captured unresolved
+   *  and rebased onto the first authoritative read instead of reconciling
+   *  against rows that may belong to another tab. */
+  baselineResolved: boolean
 }
 
 export type MobileNativeChatSendOrigin = {
@@ -13,6 +18,7 @@ export type MobileNativeChatSendOrigin = {
   normalizedText: string
   baselineOccurrences: number
   baselineTailMessageId: string | null
+  baselineResolved: boolean
 }
 
 type PendingByKey = Record<string, MobileNativeChatPendingMessage[]>
@@ -56,6 +62,7 @@ export function appendMobileNativeChatPending(
             ? expectedImageEchoOrdinal
             : origin.baselineOccurrences + earlierOutstanding + 1,
         baselineTailMessageId: origin.baselineTailMessageId,
+        baselineResolved: origin.baselineResolved,
         ...(images?.length ? { images } : {})
       }
     ]
diff --git a/mobile/src/session/mobile-native-chat-pending-retirement.test.ts b/mobile/src/session/mobile-native-chat-pending-retirement.test.ts
new file mode 100644
index 000000000000..1c865e2853c5
--- /dev/null
+++ b/mobile/src/session/mobile-native-chat-pending-retirement.test.ts
@@ -0,0 +1,323 @@
+import { describe, expect, it, vi } from 'vitest'
+import type { NativeChatMessage } from '../../../src/shared/native-chat-types'
+import type { MobileNativeChatPendingMessage } from './mobile-native-chat-pending-echo'
+import {
+  GLUE_SLIDE_BUDGET,
+  retireLandedMobileNativeChatPending,
+  selectGluedPendingIds
+} from './mobile-native-chat-pending-retirement'
+
+const NO_IMAGE_ECHOES: ReadonlySet<string> = new Set()
+
+function userTurn(id: string, text: string, timestamp: number): NativeChatMessage {
+  return { id, role: 'user', blocks: [{ type: 'text', text }], timestamp, source: 'transcript' }
+}
+
+function assistantTurn(id: string, text: string, timestamp: number): NativeChatMessage {
+  return {
+    id,
+    role: 'assistant',
+    blocks: [{ type: 'text', text }],
+    timestamp,
+    source: 'transcript'
+  }
+}
+
+/** A send captured with `tail` as the last transcript message it could see. */
+function pendingSend(
+  id: string,
+  text: string,
+  tail: string | null,
+  expectedOccurrence = 1,
+  baselineResolved = true
+): MobileNativeChatPendingMessage {
+  return { id, text, expectedOccurrence, baselineTailMessageId: tail, baselineResolved }
+}
+
+function retiredIds(
+  messages: readonly NativeChatMessage[],
+  pending: readonly MobileNativeChatPendingMessage[]
+): string[] {
+  return [...selectGluedPendingIds(messages, pending)].sort()
+}
+
+describe('selectGluedPendingIds', () => {
+  it('retires both bubbles when two rapid sends collapse into one user row', () => {
+    const messages = [
+      assistantTurn('m1', 'ready', 1000),
+      userTurn('m2', 'run the tests again', 5000)
+    ]
+    const pending = [pendingSend('p1', 'run the tests', 'm1'), pendingSend('p2', 'again', 'm1')]
+    expect(retiredIds(messages, pending)).toEqual(['p1', 'p2'])
+  })
+
+  it('retires a glued row that concatenated with no separator at all', () => {
+    const messages = [
+      assistantTurn('m1', 'ready', 1000),
+      userTurn('m2', 'run the testsagain', 5000)
+    ]
+    const pending = [pendingSend('p1', 'run the tests', 'm1'), pendingSend('p2', 'again', 'm1')]
+    expect(retiredIds(messages, pending)).toEqual(['p1', 'p2'])
+  })
+
+  it('retires three collapsed prompts in one row', () => {
+    const messages = [assistantTurn('m1', 'ready', 1000), userTurn('m2', 'one two three', 5000)]
+    const pending = [
+      pendingSend('p1', 'one', 'm1'),
+      pendingSend('p2', 'two', 'm1'),
+      pendingSend('p3', 'three', 'm1')
+    ]
+    expect(retiredIds(messages, pending)).toEqual(['p1', 'p2', 'p3'])
+  })
+
+  it('matches across tab, newline and repeated-space separators', () => {
+    const messages = [
+      assistantTurn('m1', 'ready', 1000),
+      userTurn('m2', 'run the tests\t\n  again', 5000)
+    ]
+    const pending = [
+      pendingSend('p1', ' run the tests\n', 'm1'),
+      pendingSend('p2', '\tagain ', 'm1')
+    ]
+    expect(retiredIds(messages, pending)).toEqual(['p1', 'p2'])
+  })
+
+  it('matches prompts that themselves contain the separator', () => {
+    const messages = [
+      assistantTurn('m1', 'ready', 1000),
+      userTurn('m2', 'fix the bug and run the tests', 5000)
+    ]
+    const pending = [
+      pendingSend('p1', 'fix the bug', 'm1'),
+      pendingSend('p2', 'and run the tests', 'm1')
+    ]
+    expect(retiredIds(messages, pending)).toEqual(['p1', 'p2'])
+  })
+
+  it('matches when one pending is a strict prefix of the next', () => {
+    const messages = [assistantTurn('m1', 'ready', 1000), userTurn('m2', 'run run the tests', 5000)]
+    const pending = [pendingSend('p1', 'run', 'm1'), pendingSend('p2', 'run the tests', 'm1')]
+    expect(retiredIds(messages, pending)).toEqual(['p1', 'p2'])
+  })
+
+  it('matches identical prompts sent twice and three times', () => {
+    const twice = [assistantTurn('m1', 'ready', 1000), userTurn('m2', 'hi hi', 5000)]
+    expect(
+      retiredIds(twice, [pendingSend('p1', 'hi', 'm1', 1), pendingSend('p2', 'hi', 'm1', 2)])
+    ).toEqual(['p1', 'p2'])
+
+    const thrice = [assistantTurn('m1', 'ready', 1000), userTurn('m2', 'hi hi hi', 5000)]
+    expect(
+      retiredIds(thrice, [
+        pendingSend('p1', 'hi', 'm1', 1),
+        pendingSend('p2', 'hi', 'm1', 2),
+        pendingSend('p3', 'hi', 'm1', 3)
+      ])
+    ).toEqual(['p1', 'p2', 'p3'])
+  })
+
+  it('retires two separate glued rows against their own runs', () => {
+    const messages = [
+      assistantTurn('m1', 'ready', 1000),
+      userTurn('m2', 'one two', 5000),
+      userTurn('m3', 'three four', 6000)
+    ]
+    const pending = [
+      pendingSend('p1', 'one', 'm1'),
+      pendingSend('p2', 'two', 'm1'),
+      pendingSend('p3', 'three', 'm2'),
+      pendingSend('p4', 'four', 'm2')
+    ]
+    expect(retiredIds(messages, pending)).toEqual(['p1', 'p2', 'p3', 'p4'])
+  })
+
+  // FP1: the concatenation already exists in history, older than the sends.
+  it('never lets a transcript row that predates the sends retire them', () => {
+    const messages = [
+      userTurn('m1', 'run the tests again', 1),
+      assistantTurn('m2', 'done', 2),
+      assistantTurn('m3', 'anything else?', 3)
+    ]
+    const pending = [pendingSend('p1', 'run the tests', 'm3'), pendingSend('p2', 'again', 'm3')]
+    expect(retiredIds(messages, pending)).toEqual([])
+  })
+
+  // FP2: an old turn reads like the concatenation of two much later sends.
+  it('never lets an older turn retire sends captured after it', () => {
+    const messages = [userTurn('m1', 'fix the bug', 1000), assistantTurn('m2', 'fixed', 1100)]
+    const pending = [pendingSend('p1', 'fix the', 'm2'), pendingSend('p2', 'bug', 'm2')]
+    expect(retiredIds(messages, pending)).toEqual([])
+  })
+
+  it('rejects a row the pending run only prefixes', () => {
+    const messages = [
+      assistantTurn('m1', 'ready', 1000),
+      userTurn('m2', 'run the tests again with coverage', 5000)
+    ]
+    const pending = [pendingSend('p1', 'run the tests', 'm1'), pendingSend('p2', 'again', 'm1')]
+    expect(retiredIds(messages, pending)).toEqual([])
+  })
+
+  it('rejects a run that only partly spells the row', () => {
+    const messages = [assistantTurn('m1', 'ready', 1000), userTurn('m2', 'run the tests', 5000)]
+    const pending = [pendingSend('p1', 'run the tests', 'm1'), pendingSend('p2', 'again', 'm1')]
+    // A lone exact match is an ordinary landing, not glue.
+    expect(retiredIds(messages, pending)).toEqual([])
+  })
+
+  it('rejects glue when a send in the run cannot resolve its own tail', () => {
+    const messages = [assistantTurn('m1', 'ready', 1000), userTurn('m2', 'one two', 5000)]
+    const pending = [pendingSend('p1', 'one', 'm1'), pendingSend('p2', 'two', 'paginated-away')]
+    expect(retiredIds(messages, pending)).toEqual([])
+  })
+
+  it('treats a null tail as "transcript was empty", so any row can glue', () => {
+    const messages = [userTurn('m1', 'one two', 5000)]
+    const pending = [pendingSend('p1', 'one', null), pendingSend('p2', 'two', null)]
+    expect(retiredIds(messages, pending)).toEqual(['p1', 'p2'])
+  })
+
+  // Unresolved baselines are held out of matching until the drafts hook rebases
+  // them onto the first authoritative read — see mobile-native-chat-pending-baseline.
+  it('holds out sends whose baseline has not been rebased onto a real transcript', () => {
+    const messages = [userTurn('m1', 'one two', 1000)]
+    const pending = [
+      pendingSend('p1', 'one', null, 1, false),
+      pendingSend('p2', 'two', null, 1, false)
+    ]
+    expect(retiredIds(messages, pending)).toEqual([])
+  })
+
+  // A head that can never match must not freeze the run behind it: one stuck
+  // bubble would otherwise disable glue retirement for the rest of the session.
+  it('glues a later pair even when the head of the run can never match', () => {
+    const messages = [
+      userTurn('m0', 'unrelated', 1000),
+      userTurn('m1', 'fix the bug', 5000),
+      userTurn('m2', 'ship the fix', 6000)
+    ]
+    const stuckHead = pendingSend('p0', 'bug', 'm0')
+    const pair = [pendingSend('p1', 'ship the', 'm0'), pendingSend('p2', 'fix', 'm0')]
+    expect(retiredIds(messages, [stuckHead, ...pair])).toEqual(['p1', 'p2'])
+  })
+
+  // Nothing bounds how many sends pile onto the agent's input line, so the
+  // slide's budget must never truncate a genuine glue.
+  it('retires a glued run far longer than the slide budget', () => {
+    const words = Array.from({ length: 12 }, (_, index) => `w${index}`)
+    const messages = [assistantTurn('m1', 'ready', 1000), userTurn('m2', words.join(' '), 5000)]
+    const pending = words.map((word, index) => pendingSend(`p${index}`, word, 'm1'))
+    expect(retiredIds(messages, pending)).toHaveLength(words.length)
+  })
+
+  it('skips a caption-less image echo instead of gluing it', () => {
+    const messages = [assistantTurn('m1', 'ready', 1000), userTurn('m2', 'one two', 5000)]
+    const pending = [
+      pendingSend('p1', '', 'm1'),
+      pendingSend('p2', 'one', 'm1'),
+      pendingSend('p3', 'two', 'm1')
+    ]
+    expect(retiredIds(messages, pending)).toEqual(['p2', 'p3'])
+  })
+
+  it('keeps a captioned image echo and its neighbors until the preview is rebound', () => {
+    const messages = [assistantTurn('m1', 'ready', 1000), userTurn('m2', 'one two', 5000)]
+    const pending = [
+      { ...pendingSend('p1', 'one', 'm1'), images: ['file:///a.png'] },
+      pendingSend('p2', 'two', 'm1')
+    ]
+    expect(retiredIds(messages, pending)).toEqual([])
+    expect(
+      retireLandedMobileNativeChatPending(messages, pending, NO_IMAGE_ECHOES).map((item) => item.id)
+    ).toEqual(['p1', 'p2'])
+  })
+
+  it('does nothing for a single pending send', () => {
+    const messages = [assistantTurn('m1', 'ready', 1000), userTurn('m2', 'one two', 5000)]
+    expect(retiredIds(messages, [pendingSend('p1', 'one', 'm1')])).toEqual([])
+  })
+
+  // The cursor slides past a head that cannot match, so a turn may try several
+  // start positions — but one inspection budget covers the whole slide, keeping
+  // the work linear in the run length rather than quadratic. The attempt already
+  // in flight is allowed to overshoot the remaining budget, deliberately: that is
+  // what guarantees a genuine long glue is never truncated.
+  it('keeps segment inspection linear in the run length per transcript turn', () => {
+    const pendingCount = 96
+    const turnCount = 12
+    const text = `${'a '.repeat(pendingCount)}x`
+    const messages = [
+      assistantTurn('tail', 'ready', 1000),
+      ...Array.from({ length: turnCount }, (_, index) => userTurn(`m${index}`, text, 2000 + index))
+    ]
+    const pending = Array.from({ length: pendingCount }, (_, index) =>
+      pendingSend(`p${index}`, 'a', 'tail', index + 1)
+    )
+    const startsWith = vi.spyOn(String.prototype, 'startsWith')
+    let segmentChecks = 0
+    try {
+      expect(retiredIds(messages, pending)).toEqual([])
+      segmentChecks = startsWith.mock.calls.length
+    } finally {
+      startsWith.mockRestore()
+    }
+    expect(segmentChecks).toBeLessThanOrEqual(turnCount * (2 * pendingCount + GLUE_SLIDE_BUDGET))
+  })
+})
+
+describe('retireLandedMobileNativeChatPending', () => {
+  it('retires exact landings by ordinal and glued rows in the same pass', () => {
+    const messages = [
+      assistantTurn('m1', 'ready', 1000),
+      userTurn('m2', 'standalone', 4000),
+      userTurn('m3', 'run the tests again', 5000)
+    ]
+    const pending = [
+      pendingSend('p0', 'standalone', 'm1'),
+      pendingSend('p1', 'run the tests', 'm2'),
+      pendingSend('p2', 'again', 'm2')
+    ]
+    expect(retireLandedMobileNativeChatPending(messages, pending, NO_IMAGE_ECHOES)).toEqual([])
+  })
+
+  // The drafts effect early-outs on `next === current`; a fresh array on the
+  // no-op path would re-enter it on every transcript frame.
+  it('returns the input array itself when nothing retires', () => {
+    const messages = [assistantTurn('m1', 'ready', 1000)]
+    const pending = [pendingSend('p1', 'one', 'm1'), pendingSend('p2', 'two', 'm1')]
+    expect(retireLandedMobileNativeChatPending(messages, pending, NO_IMAGE_ECHOES)).toBe(pending)
+  })
+
+  it('keeps sends whose glue candidate predates them', () => {
+    const messages = [userTurn('m1', 'fix the bug', 1000), assistantTurn('m2', 'fixed', 1100)]
+    const pending = [pendingSend('p1', 'fix the', 'm2'), pendingSend('p2', 'bug', 'm2')]
+    expect(
+      retireLandedMobileNativeChatPending(messages, pending, NO_IMAGE_ECHOES).map((item) => item.id)
+    ).toEqual(['p1', 'p2'])
+  })
+
+  it('does not glue former neighbors across an exact-landed send', () => {
+    const messages = [
+      assistantTurn('m0', 'ready', 1000),
+      userTurn('m1', 'middle', 2000),
+      userTurn('m2', 'one two', 3000)
+    ]
+    const pending = [
+      pendingSend('p1', 'one', 'm0'),
+      pendingSend('p2', 'middle', 'm0'),
+      pendingSend('p3', 'two', 'm0')
+    ]
+    expect(
+      retireLandedMobileNativeChatPending(messages, pending, NO_IMAGE_ECHOES).map((item) => item.id)
+    ).toEqual(['p1', 'p3'])
+  })
+
+  it('keeps image echoes until their preview is rebound', () => {
+    const messages = [assistantTurn('m1', 'ready', 1000)]
+    const pending = [{ ...pendingSend('p1', 'photo', 'm1'), images: ['file:///a.png'] }]
+    expect(
+      retireLandedMobileNativeChatPending(messages, pending, NO_IMAGE_ECHOES).map((item) => item.id)
+    ).toEqual(['p1'])
+    expect(retireLandedMobileNativeChatPending(messages, pending, new Set(['p1']))).toEqual([])
+  })
+})
diff --git a/mobile/src/session/mobile-native-chat-pending-retirement.ts b/mobile/src/session/mobile-native-chat-pending-retirement.ts
new file mode 100644
index 000000000000..ffdde70ddd4d
--- /dev/null
+++ b/mobile/src/session/mobile-native-chat-pending-retirement.ts
@@ -0,0 +1,173 @@
+import type { NativeChatMessage } from '../../../src/shared/native-chat-types'
+import {
+  countImageSourceTurnsAfter,
+  normalizeReconcileText,
+  normalizedUserText
+} from './mobile-native-chat-draft-reconcile'
+import type { MobileNativeChatPendingMessage } from './mobile-native-chat-pending-echo'
+
+const SPACE = ' '
+const NO_PENDING_IDS: ReadonlySet<string> = new Set()
+// Slack the cursor slide may spend re-trying later start positions, on top of
+// one free pass over the run. Nothing bounds how many sends accumulate on the
+// agent's input line — that ends when the agent accepts input again — so the
+// budget must never truncate a genuine glue: the first attempt covers the whole
+// run and always fits. It only stops a run of identical prefix-matching sends
+// from making the scan quadratic.
+export const GLUE_SLIDE_BUDGET = 8
+
+type UserTurn = { index: number; text: string }
+type GlueSegment = { text: string; tail: number } | null
+
+/** Pending ids represented by post-send transcript rows that glued adjacent sends. */
+export function selectGluedPendingIds(
+  messages: readonly NativeChatMessage[],
+  pending: readonly MobileNativeChatPendingMessage[],
+  excludedPendingIds: ReadonlySet<string> = NO_PENDING_IDS
+): ReadonlySet<string> {
+  const retired = new Set<string>()
+  if (pending.length < 2) {
+    return retired
+  }
+  const messageIndexById = new Map<string, number>()
+  const turns: UserTurn[] = []
+  for (const [index, message] of messages.entries()) {
+    messageIndexById.set(message.id, index)
+    const text = normalizedUserText(message)
+    if (text) {
+      turns.push({ index, text })
+    }
+  }
+  const segments: GlueSegment[] = pending.map((item) => {
+    const text = normalizeReconcileText(item.text)
+    const tail =
+      item.baselineTailMessageId === null
+        ? -1
+        : (messageIndexById.get(item.baselineTailMessageId) ?? null)
+    return excludedPendingIds.has(item.id) ||
+      !item.baselineResolved ||
+      item.images?.length ||
+      text === '' ||
+      tail === null
+      ? null
+      : { text, tail }
+  })
+
+  // Barriers preserve original adjacency after exact landings retire.
+  let runStart = 0
+  while (runStart < pending.length) {
+    while (runStart < pending.length && segments[runStart] === null) {
+      runStart += 1
+    }
+    let runEnd = runStart
+    while (runEnd < pending.length && segments[runEnd] !== null) {
+      runEnd += 1
+    }
+    let cursor = runStart
+    for (const turn of turns) {
+      if (cursor >= runEnd - 1) {
+        break
+      }
+      // A send that can never match must not freeze the run behind it. One
+      // permanently unretirable head — a pair whose own glued row arrived with
+      // the read, or a send the count pass claimed against an older row — would
+      // otherwise disable glue retirement for every later pair, for the rest of
+      // the session. Slide past it; the cursor stays monotonic, so a later turn
+      // can never claim a send an earlier one already took.
+      let budget = runEnd - runStart + GLUE_SLIDE_BUDGET
+      let start = cursor
+      let matched = 0
+      for (; start <= runEnd - 2 && budget > 0; start++) {
+        const attempt = matchGluedRun(turn, segments, start, runEnd)
+        budget -= attempt.inspected
+        matched = attempt.matched
+        if (matched > 0) {
+          break
+        }
+      }
+      if (matched === 0) {
+        continue
+      }
+      for (let index = start; index < start + matched; index++) {
+        retired.add(pending[index]!.id)
+      }
+      cursor = start + matched
+    }
+    runStart = runEnd + 1
+  }
+  return retired
+}
+
+/** Length of the exact glued run at `start`, plus the segments it had to read. */
+function matchGluedRun(
+  turn: UserTurn,
+  segments: readonly GlueSegment[],
+  start: number,
+  end: number
+): { matched: number; inspected: number } {
+  let at = 0
+  let matched = 0
+  let inspected = 0
+  for (let index = start; index < end; index++) {
+    const segment = segments[index]!
+    inspected += 1
+    // Every send carries its OWN boundary: a row that already existed when this
+    // send was issued can never be part of its echo, however well it reads.
+    if (turn.index <= segment.tail) {
+      return { matched: 0, inspected }
+    }
+    if (at > 0 && turn.text[at] === SPACE) {
+      at += 1
+    }
+    if (!turn.text.startsWith(segment.text, at)) {
+      return { matched: 0, inspected }
+    }
+    at += segment.text.length
+    matched += 1
+    if (at === turn.text.length) {
+      // A lone exact match is an ordinary landing, which the count pass owns.
+      return { matched: matched > 1 ? matched : 0, inspected }
+    }
+  }
+  return { matched: 0, inspected }
+}
+
+/** Retires exact and glued transcript landings while preserving pending order. */
+export function retireLandedMobileNativeChatPending(
+  messages: readonly NativeChatMessage[],
+  current: MobileNativeChatPendingMessage[],
+  landedImagePendingIds: ReadonlySet<string>
+): MobileNativeChatPendingMessage[] {
+  const landedCounts = new Map<string, number>()
+  for (const message of messages) {
+    const text = normalizedUserText(message)
+    if (text) {
+      landedCounts.set(text, (landedCounts.get(text) ?? 0) + 1)
+    }
+  }
+  const landedPendingIds = new Set<string>()
+  for (const item of current) {
+    if (landedImagePendingIds.has(item.id)) {
+      landedPendingIds.add(item.id)
+      continue
+    }
+    // Keep image echoes until their local preview reaches the authoritative message.
+    // An unresolved baseline has nothing to count against yet — `messages` is not
+    // known to be the transcript this send was issued into.
+    if (item.images?.length || !item.baselineResolved) {
+      continue
+    }
+    const landed =
+      item.text.trim() === ''
+        ? countImageSourceTurnsAfter(messages, item.baselineTailMessageId) >=
+          item.expectedOccurrence
+        : (landedCounts.get(normalizeReconcileText(item.text)) ?? 0) >= item.expectedOccurrence
+    if (landed) {
+      landedPendingIds.add(item.id)
+    }
+  }
+  const glued = selectGluedPendingIds(messages, current, landedPendingIds)
+  return landedPendingIds.size === 0 && glued.size === 0
+    ? current
+    : current.filter((item) => !landedPendingIds.has(item.id) && !glued.has(item.id))
+}
diff --git a/mobile/src/session/use-mobile-native-chat-controller.test.ts b/mobile/src/session/use-mobile-native-chat-controller.test.ts
index c04b560798d2..a6308d08be5c 100644
--- a/mobile/src/session/use-mobile-native-chat-controller.test.ts
+++ b/mobile/src/session/use-mobile-native-chat-controller.test.ts
@@ -96,7 +96,8 @@ const ORIGIN = {
   pendingKey: 'h\0w\0tab-1\0session-1',
   normalizedText: 'look',
   baselineOccurrences: 0,
-  baselineTailMessageId: null
+  baselineTailMessageId: null,
+  baselineResolved: true
 }
 
 describe('useMobileNativeChatController handleNativeChatSend', () => {
diff --git a/mobile/src/session/use-mobile-native-chat-controller.ts b/mobile/src/session/use-mobile-native-chat-controller.ts
index 46012dadbe41..27ad8049c1dd 100644
--- a/mobile/src/session/use-mobile-native-chat-controller.ts
+++ b/mobile/src/session/use-mobile-native-chat-controller.ts
@@ -111,7 +111,8 @@ export function useMobileNativeChatController(args: {
     // a null is indistinguishable from a host retraction, and peeking at the
     // terminal view would permanently decline the prefill.
     chatActive: showNativeChat,
-    transcriptLoading: nativeChatSession.transcriptLoading
+    transcriptLoading: nativeChatSession.transcriptLoading,
+    transcriptSettled: nativeChatSession.status === 'ready'
   })
 
   const nativeChatStatus = activeChatResolution ? activeSessionTab?.agentStatus : null
diff --git a/mobile/src/session/use-mobile-native-chat-drafts-glued-pending.test.ts b/mobile/src/session/use-mobile-native-chat-drafts-glued-pending.test.ts
new file mode 100644
index 000000000000..b5d1f92ec82f
--- /dev/null
+++ b/mobile/src/session/use-mobile-native-chat-drafts-glued-pending.test.ts
@@ -0,0 +1,359 @@
+import { createElement } from 'react'
+import { act, create } from 'react-test-renderer'
+import { afterEach, describe, expect, it } from 'vitest'
+import type { NativeChatMessage } from '../../../src/shared/native-chat-types'
+import { buildMobileNativeChatTransientData } from './mobile-native-chat-render-data'
+import { useMobileNativeChatDrafts } from './use-mobile-native-chat-drafts'
+
+type DraftState = ReturnType<typeof useMobileNativeChatDrafts>
+type TestRenderer = {
+  unmount(): void
+  update(element: ReturnType<typeof createElement>): void
+}
+
+function userTurn(id: string, text: string, timestamp: number): NativeChatMessage {
+  return { id, role: 'user', blocks: [{ type: 'text', text }], timestamp, source: 'transcript' }
+}
+
+function assistantTurn(id: string, text: string, timestamp: number): NativeChatMessage {
+  return {
+    id,
+    role: 'assistant',
+    blocks: [{ type: 'text', text }],
+    timestamp,
+    source: 'transcript'
+  }
+}
+
+function imageTurn(id: string, path: string, timestamp: number): NativeChatMessage {
+  return {
+    id,
+    role: 'user',
+    blocks: [{ type: 'text', text: `[Image: source: ${path}]` }],
+    timestamp,
+    source: 'transcript'
+  }
+}
+
+/** Texts of the optimistic bubbles the chat list actually renders. */
+function renderedPendingTexts(
+  messages: NativeChatMessage[],
+  state: DraftState | null
+): (string | undefined)[] {
+  const { data } = buildMobileNativeChatTransientData({
+    folded: messages,
+    streaming: null,
+    pending: state?.pending ?? []
+  })
+  return data
+    .filter((message) => !messages.some((existing) => existing.id === message.id))
+    .map((message) => message.blocks.find((block) => block.type === 'text')?.text)
+}
+
+describe('useMobileNativeChatDrafts glued pending sends', () => {
+  let renderer: TestRenderer | null = null
+  let state: DraftState | null = null
+
+  afterEach(() => {
+    act(() => renderer?.unmount())
+    renderer = null
+    state = null
+  })
+
+  function Harness({
+    messages,
+    transcriptLoading = false,
+    transcriptSettled = !transcriptLoading
+  }: {
+    messages: NativeChatMessage[]
+    transcriptLoading?: boolean
+    transcriptSettled?: boolean
+  }): null {
+    state = useMobileNativeChatDrafts({
+      hostId: 'host',
+      worktreeId: 'worktree',
+      tabId: 'tab',
+      sessionId: 'session',
+      messages,
+      transcriptLoading,
+      transcriptSettled
+    })
+    return null
+  }
+
+  async function mount(
+    messages: NativeChatMessage[],
+    transcriptLoading = false,
+    transcriptSettled = !transcriptLoading
+  ): Promise<void> {
+    await act(async () => {
+      renderer = create(createElement(Harness, { messages, transcriptLoading, transcriptSettled }))
+    })
+  }
+
+  async function update(
+    messages: NativeChatMessage[],
+    transcriptLoading = false,
+    transcriptSettled = !transcriptLoading
+  ): Promise<void> {
+    await act(async () =>
+      renderer?.update(createElement(Harness, { messages, transcriptLoading, transcriptSettled }))
+    )
+  }
+
+  function send(text: string): void {
+    const origin = state?.captureSendOrigin(text)
+    if (origin) {
+      state?.acceptSend(origin, text)
+    }
+  }
+
+  /** Two composer sends fired before either transcript echo lands. */
+  function rapidSend(first: string, second: string): void {
+    act(() => {
+      send(first)
+      send(second)
+    })
+  }
+
+  const pendingTexts = (): (string | undefined)[] | undefined =>
+    state?.pending.map((item) => item.text)
+
+  it('retires both bubbles when the rapid sends land as one glued user row', async () => {
+    const history = [assistantTurn('m1', 'ready', 1000)]
+    await mount(history)
+    rapidSend('run the tests', 'again')
+    expect(pendingTexts()).toEqual(['run the tests', 'again'])
+
+    const glued = [...history, userTurn('m2', 'run the tests again', 5000)]
+    await update(glued)
+    expect(state?.pending).toEqual([])
+    expect(renderedPendingTexts(glued, state)).toEqual([])
+  })
+
+  // FP1: the concatenation already sits in history, older than the sends.
+  it('keeps and renders both bubbles when the matching row predates the sends', async () => {
+    const history = [
+      userTurn('m1', 'run the tests again', 1000),
+      assistantTurn('m2', 'done', 2000),
+      assistantTurn('m3', 'anything else?', 3000)
+    ]
+    await mount(history)
+    rapidSend('run the tests', 'again')
+
+    await update([...history])
+    expect(pendingTexts()).toEqual(['run the tests', 'again'])
+    expect(renderedPendingTexts(history, state)).toEqual(['run the tests', 'again'])
+  })
+
+  // FP2: an older turn reads like the concatenation of two much later sends.
+  it('keeps and renders both bubbles when an older turn spells them out', async () => {
+    const history = [userTurn('m1', 'fix the bug', 1000), assistantTurn('m2', 'fixed', 1100)]
+    await mount(history)
+    rapidSend('fix the', 'bug')
+
+    await update([...history])
+    expect(pendingTexts()).toEqual(['fix the', 'bug'])
+    expect(renderedPendingTexts(history, state)).toEqual(['fix the', 'bug'])
+  })
+
+  it('still retires each bubble on its own when the sends do not glue', async () => {
+    const history = [assistantTurn('m1', 'ready', 1000)]
+    await mount(history)
+    rapidSend('run the tests', 'again')
+
+    const separate = [
+      ...history,
+      userTurn('m2', 'run the tests', 5000),
+      userTurn('m3', 'again', 5100)
+    ]
+    await update(separate)
+    expect(state?.pending).toEqual([])
+  })
+
+  it('keeps the second bubble when only the first send has echoed', async () => {
+    const history = [assistantTurn('m1', 'ready', 1000)]
+    await mount(history)
+    rapidSend('run the tests', 'again')
+
+    const partial = [...history, userTurn('m2', 'run the tests', 5000)]
+    await update(partial)
+    expect(pendingTexts()).toEqual(['again'])
+    expect(renderedPendingTexts(partial, state)).toEqual(['again'])
+  })
+
+  // STA-4492 / #14819: sends issued mid-hydration used to be marked permanently
+  // untrusted, so their glued row could never retire them and they also barred
+  // their neighbours from matching. The first authoritative read rebases them
+  // instead: history that arrives with it is still not theirs, but everything
+  // after it is.
+  describe('sends issued while the transcript is still hydrating', () => {
+    const loadedHistory = [userTurn('m1', 'run the tests again', 1000)]
+
+    it('keeps both bubbles when the loaded history only looks like their glue', async () => {
+      await mount([], true)
+      rapidSend('run the tests', 'again')
+
+      await update(loadedHistory)
+      expect(pendingTexts()).toEqual(['run the tests', 'again'])
+      expect(renderedPendingTexts(loadedHistory, state)).toEqual(['run the tests', 'again'])
+    })
+
+    it('retires both bubbles once their glued row lands after hydration', async () => {
+      await mount([], true)
+      rapidSend('run the tests', 'again')
+      await update(loadedHistory)
+
+      const glued = [...loadedHistory, userTurn('m2', 'run the tests again', 5000)]
+      await update(glued)
+      expect(state?.pending).toEqual([])
+      expect(renderedPendingTexts(glued, state)).toEqual([])
+    })
+
+    it('retires a hydration-time send on its own exact echo', async () => {
+      await mount([], true)
+      act(() => send('run the tests'))
+      await update(loadedHistory)
+      expect(pendingTexts()).toEqual(['run the tests'])
+
+      const echoed = [...loadedHistory, userTurn('m2', 'run the tests', 5000)]
+      await update(echoed)
+      expect(state?.pending).toEqual([])
+    })
+
+    it('stops barring a later pair from gluing once its own echo lands', async () => {
+      await mount([], true)
+      act(() => send('hold this'))
+      await update(loadedHistory)
+      rapidSend('fix the', 'bug')
+
+      const landed = [
+        ...loadedHistory,
+        userTurn('m2', 'hold this', 5000),
+        userTurn('m3', 'fix the bug', 5100)
+      ]
+      await update(landed)
+      expect(state?.pending).toEqual([])
+    })
+
+    // The read that resolves a hydration-time send can already contain that
+    // send's own echo — a re-subscribe returns whatever exists now — and nothing
+    // local tells that echo from an identical older prompt. Claiming the row is
+    // the lesser evil, not a free one: normally the real echo lands a round trip
+    // later, but a send that never landed and was claimed by an older identical
+    // row stops being tracked at all — worst for short repeats ("yes", "1").
+    // Holding instead costs a queued bubble that never clears AND a run that can
+    // never glue again, for the rest of the session.
+    it('retires a hydration-time send whose echo arrives with the read', async () => {
+      await mount([], true)
+      act(() => send('run the tests'))
+
+      const echoed = [userTurn('m1', 'run the tests', 1000), assistantTurn('m2', 'passed', 1100)]
+      await update(echoed)
+      expect(state?.pending).toEqual([])
+    })
+
+    // The same read seen one reconnect later: the send left, the agent echoed it,
+    // and only then did the first authoritative read land.
+    it('retires a hydration-time send after a reconnect delivered the read late', async () => {
+      await mount([], true)
+      act(() => send('run the tests'))
+      // Still loading: the first read never arrived before the drop.
+      await update([], true)
+
+      const afterReconnect = [
+        userTurn('m1', 'run the tests', 5000),
+        assistantTurn('m2', 'ok', 5100)
+      ]
+      await update(afterReconnect)
+      expect(state?.pending).toEqual([])
+
+      // Nothing later resurrects it, and the run stays glue-capable.
+      await update([...afterReconnect, assistantTurn('m3', 'all green', 6000)])
+      expect(state?.pending).toEqual([])
+    })
+
+    // A reconnect leaves this session's own retained history on screen, so sends
+    // made across it own a real boundary already. Moving it onto the read that
+    // follows would push it past their own glued row and strand both bubbles.
+    it('retires a pair sent across a reconnect whose glued row arrives with the read', async () => {
+      const retained = [userTurn('m1', 'earlier prompt', 1000), assistantTurn('m2', 'sure', 1100)]
+      await mount(retained)
+      // The read drops; the retained history stays visible and is still ours.
+      await update(retained, true)
+      rapidSend('run the tests', 'again')
+
+      const settled = [...retained, userTurn('m3', 'run the tests again', 5000)]
+      await update(settled)
+      expect(state?.pending).toEqual([])
+      expect(renderedPendingTexts(settled, state)).toEqual([])
+    })
+
+    // A send held here would sit as a live segment at the head of its run, so
+    // the cursor could never reach a later pair — the stuck bubble would take
+    // the whole feature down with it for the rest of the session.
+    // An image entry retires ONLY by binding its preview, so a supplied tail
+    // that excluded its own echo would leave the bubble — and the photo — stuck
+    // for the life of the session.
+    it('retires a photo whose image echo arrives with the read', async () => {
+      await mount([], true)
+      act(() => {
+        const origin = state?.captureSendOrigin('')
+        if (origin) {
+          state?.acceptSend(origin, '', ['file:///new.png'])
+        }
+      })
+
+      const withEcho = [assistantTurn('m1', 'ready', 1000), imageTurn('m2', '/tmp/new.png', 5000)]
+      await update(withEcho)
+      expect(state?.pending).toEqual([])
+      expect(state?.imagePreviewsByMessageId).toEqual({ m2: ['file:///new.png'] })
+    })
+
+    it('leaves a later pair able to glue after the late read resolved the first send', async () => {
+      await mount([], true)
+      act(() => send('run the tests'))
+      const afterReconnect = [userTurn('m1', 'run the tests', 5000)]
+      await update(afterReconnect)
+      expect(state?.pending).toEqual([])
+
+      rapidSend('fix the', 'bug')
+      const glued = [...afterReconnect, userTurn('m2', 'fix the bug', 6000)]
+      await update(glued)
+      expect(state?.pending).toEqual([])
+      expect(renderedPendingTexts(glued, state)).toEqual([])
+    })
+  })
+
+  // A read that failed is not a boundary: `messages` is empty because the history
+  // is unknown, not because the conversation is. Without that distinction the
+  // empty list reads as "the transcript was empty", and any row the successful
+  // read finally brings can claim these sends.
+  describe('sends issued before any read settled', () => {
+    it('keeps both bubbles when the late read carries only an older glue-alike', async () => {
+      await mount([], false, false)
+      rapidSend('fix the', 'bug')
+
+      const olderIdentical = [
+        userTurn('m1', 'fix the bug', 1000),
+        assistantTurn('m2', 'fixed', 1100)
+      ]
+      await update(olderIdentical)
+      expect(pendingTexts()).toEqual(['fix the', 'bug'])
+      expect(renderedPendingTexts(olderIdentical, state)).toEqual(['fix the', 'bug'])
+    })
+
+    it('still retires them once their own glued row lands', async () => {
+      await mount([], false, false)
+      rapidSend('fix the', 'bug')
+      const olderIdentical = [
+        userTurn('m1', 'fix the bug', 1000),
+        assistantTurn('m2', 'fixed', 1100)
+      ]
+      await update(olderIdentical)
+
+      await update([...olderIdentical, userTurn('m3', 'fix the bug', 5000)])
+      expect(state?.pending).toEqual([])
+    })
+  })
+})
diff --git a/mobile/src/session/use-mobile-native-chat-drafts-launch-draft.test.ts b/mobile/src/session/use-mobile-native-chat-drafts-launch-draft.test.ts
index 665d3ac1f2fe..0c8d3bf674a2 100644
--- a/mobile/src/session/use-mobile-native-chat-drafts-launch-draft.test.ts
+++ b/mobile/src/session/use-mobile-native-chat-drafts-launch-draft.test.ts
@@ -36,7 +36,8 @@ describe('useMobileNativeChatDrafts launch draft', () => {
     launchDraft = null,
     launchDraftCreatedAt = null,
     chatActive = true,
-    transcriptLoading = false
+    transcriptLoading = false,
+    transcriptSettled = !transcriptLoading
   }: {
     tabId: string
     sessionId?: string | null
@@ -45,6 +46,7 @@ describe('useMobileNativeChatDrafts launch draft', () => {
     launchDraftCreatedAt?: number | null
     chatActive?: boolean
     transcriptLoading?: boolean
+    transcriptSettled?: boolean
   }): null {
     state = useMobileNativeChatDrafts({
       hostId: 'host',
@@ -55,7 +57,8 @@ describe('useMobileNativeChatDrafts launch draft', () => {
       launchDraft,
       launchDraftCreatedAt,
       chatActive,
-      transcriptLoading
+      transcriptLoading,
+      transcriptSettled
     })
     return null
   }
diff --git a/mobile/src/session/use-mobile-native-chat-drafts.test.ts b/mobile/src/session/use-mobile-native-chat-drafts.test.ts
index daf451e53f92..2a5ff2d54c61 100644
--- a/mobile/src/session/use-mobile-native-chat-drafts.test.ts
+++ b/mobile/src/session/use-mobile-native-chat-drafts.test.ts
@@ -42,7 +42,8 @@ describe('useMobileNativeChatDrafts', () => {
     messages = [],
     launchDraft = null,
     chatActive = true,
-    transcriptLoading = false
+    transcriptLoading = false,
+    transcriptSettled = !transcriptLoading
   }: {
     tabId: string
     sessionId?: string | null
@@ -50,6 +51,7 @@ describe('useMobileNativeChatDrafts', () => {
     launchDraft?: string | null
     chatActive?: boolean
     transcriptLoading?: boolean
+    transcriptSettled?: boolean
   }): null {
     state = useMobileNativeChatDrafts({
       hostId: 'host',
@@ -59,7 +61,8 @@ describe('useMobileNativeChatDrafts', () => {
       messages,
       launchDraft,
       chatActive,
-      transcriptLoading
+      transcriptLoading,
+      transcriptSettled
     })
     return null
   }
diff --git a/mobile/src/session/use-mobile-native-chat-drafts.ts b/mobile/src/session/use-mobile-native-chat-drafts.ts
index 55fff5b42e39..784f025847bf 100644
--- a/mobile/src/session/use-mobile-native-chat-drafts.ts
+++ b/mobile/src/session/use-mobile-native-chat-drafts.ts
@@ -1,16 +1,16 @@
 import { useCallback, useEffect, useRef, useState, type Dispatch, type SetStateAction } from 'react'
 import type { NativeChatMessage } from '../../../src/shared/native-chat-types'
 import {
-  countImageSourceTurnsAfter,
   countUserTextOccurrences,
   findLandedImagePreviewEchoes,
   findLandedUnconfirmedSends,
   mergeLandedImagePreviewEchoes,
   migrateImagePreviewMessageIds,
   normalizeReconcileText,
-  normalizedUserText,
   type UnconfirmedSend
 } from './mobile-native-chat-draft-reconcile'
+import { rebaseMobileNativeChatPendingBaselines } from './mobile-native-chat-pending-baseline'
+import { retireLandedMobileNativeChatPending } from './mobile-native-chat-pending-retirement'
 import {
   appendMobileNativeChatPending,
   combineMobileNativeChatPending,
@@ -47,6 +47,10 @@ export function useMobileNativeChatDrafts(args: {
    *  transcript still belongs to the previously active tab), so it cannot be
    *  trusted to decline or retire the seed. */
   transcriptLoading?: boolean
+  /** `messages` is this session's own settled history — so an empty one really
+   *  is an empty conversation, not a read that failed or never ran. Only then
+   *  does a send's captured tail describe a real boundary. */
+  transcriptSettled: boolean
 }): {
   composerText: string
   setComposerText: Dispatch<SetStateAction<string>>
@@ -80,7 +84,8 @@ export function useMobileNativeChatDrafts(args: {
     launchDraft,
     launchDraftCreatedAt,
     chatActive = true,
-    transcriptLoading
+    transcriptLoading,
+    transcriptSettled
   } = args
   const draftKey = mobileNativeChatScopeKey(hostId, worktreeId, tabId)
   const pendingKey = draftKey && sessionId ? `${draftKey}\0${sessionId}` : null
@@ -138,10 +143,14 @@ export function useMobileNativeChatDrafts(args: {
         pendingKey,
         normalizedText,
         baselineOccurrences: countUserTextOccurrences(messagesRef.current, normalizedText),
-        baselineTailMessageId: messagesRef.current.at(-1)?.id ?? null
+        baselineTailMessageId: messagesRef.current.at(-1)?.id ?? null,
+        // Only a settled read makes this a boundary. Anything else — hydrating,
+        // or a read that failed — hands back an empty list that reads as "the
+        // conversation was empty", which lets any row claim this send later.
+        baselineResolved: transcriptSettled
       }
     },
-    [draftKey, pendingKey]
+    [draftKey, pendingKey, transcriptSettled]
   )
 
   // Why: over relay the send RPC can take seconds (or lose only its ack), and a
@@ -282,7 +291,16 @@ export function useMobileNativeChatDrafts(args: {
     if (pending.length === 0) {
       return
     }
-    const landedImagePreviews = findLandedImagePreviewEchoes(messages, pending)
+    // Only judge a send against a read known to be this session's. Note this
+    // does NOT give an image echo a boundary — the rebase deliberately leaves
+    // those on whatever they captured — so a caption-less photo sent before any
+    // read settled can still claim an older photo turn, exactly as it does on
+    // main. Fixing that needs a tail that excludes older image turns without
+    // excluding the send's own echo, which is a separate change.
+    const landedImagePreviews = findLandedImagePreviewEchoes(
+      messages,
+      pending.filter((item) => item.baselineResolved)
+    )
     const landedImagePendingIds = new Set(landedImagePreviews.map((preview) => preview.pendingId))
     if (landedImagePreviews.length > 0) {
       setImagePreviewsBySession((previous) =>
@@ -291,28 +309,13 @@ export function useMobileNativeChatDrafts(args: {
     }
     setPendingBySession((previous) => {
       const current = previous[pendingKey] ?? []
-      const landedCounts = new Map<string, number>()
-      for (const message of messages) {
-        const text = normalizedUserText(message)
-        if (text) {
-          landedCounts.set(text, (landedCounts.get(text) ?? 0) + 1)
-        }
-      }
-      // Image-only source-turn counts stay stable across reruns and ignore paginated history.
-      const next = current.filter((item) => {
-        if (landedImagePendingIds.has(item.id)) {
-          return false
-        }
-        // Keep image echoes until their local preview reaches the authoritative message.
-        if (item.images?.length) {
-          return true
-        }
-        return item.text.trim() === ''
-          ? countImageSourceTurnsAfter(messages, item.baselineTailMessageId) <
-              item.expectedOccurrence
-          : (landedCounts.get(normalizeReconcileText(item.text)) ?? 0) < item.expectedOccurrence
-      })
-      if (next.length === current.length) {
+      // Rebase before retiring: a send captured before the history was known has
+      // to own a real boundary before any row can be judged against it.
+      const rebased = transcriptSettled
+        ? rebaseMobileNativeChatPendingBaselines(messages, current)
+        : current
+      const next = retireLandedMobileNativeChatPending(messages, rebased, landedImagePendingIds)
+      if (next === current) {
         return previous
       }
       if (next.length > 0) {
@@ -322,7 +325,7 @@ export function useMobileNativeChatDrafts(args: {
       delete remaining[pendingKey]
       return remaining
     })
-  }, [messages, pending, pendingKey])
+  }, [messages, pending, pendingKey, transcriptSettled])
 
   return {
     composerText: draftKey ? (drafts[draftKey] ?? '') : '',
diff --git a/mobile/src/session/use-mobile-native-chat-message-send.test.ts b/mobile/src/session/use-mobile-native-chat-message-send.test.ts
index dd67cf46da8b..e22c601df315 100644
--- a/mobile/src/session/use-mobile-native-chat-message-send.test.ts
+++ b/mobile/src/session/use-mobile-native-chat-message-send.test.ts
@@ -4,6 +4,8 @@
 import { createElement } from 'react'
 import { act, create, type ReactTestRenderer } from 'react-test-renderer'
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+// Type-only, so it is erased before the `./mobile-native-chat-send` mock below applies.
+import type { MobileNativeChatSendOutcome } from './mobile-native-chat-send'
 
 const sendWithOutcome = vi.fn()
 const clearInputWrite = vi.fn()
@@ -36,6 +38,9 @@ describe('useMobileNativeChatMessageSend', () => {
   let renderer: ReactTestRenderer | null = null
   let api: Send | null = null
   const acceptSend = vi.fn()
+  const captureSendOrigin = vi.fn(() => ({ draftKey: 'k', pendingKey: 'p' }) as never)
+  const clearDraftForSend = vi.fn()
+  const restoreRejectedDraft = vi.fn()
   const holdUnconfirmedSend = vi.fn()
   const onCommandSend = vi.fn()
   const commandSendRef = { current: onCommandSend }
@@ -55,10 +60,10 @@ describe('useMobileNativeChatMessageSend', () => {
         deviceTokenRef: { current: 'device' },
         agentRef,
         commandSendRef,
-        captureSendOrigin: () => ({ draftKey: 'k', pendingKey: 'p' }) as never,
+        captureSendOrigin,
         readSeededLaunchDraftSeed,
-        clearDraftForSend: () => {},
-        restoreRejectedDraft: () => {},
+        clearDraftForSend,
+        restoreRejectedDraft,
         acceptSend,
         holdUnconfirmedSend,
         onSendError
@@ -71,10 +76,12 @@ describe('useMobileNativeChatMessageSend', () => {
   }
 
   const sentArgs = (): {
+    text?: string
     clearInputFirst?: boolean
     resolvedLaunchDraft?: { text: string; createdAt: number }
   } =>
     sendWithOutcome.mock.calls[0]![0] as {
+      text?: string
       clearInputFirst?: boolean
       resolvedLaunchDraft?: { text: string; createdAt: number }
     }
@@ -89,6 +96,9 @@ describe('useMobileNativeChatMessageSend', () => {
     typeCommandWithOutcome.mockReset()
     typeCommandWithOutcome.mockResolvedValue('accepted')
     acceptSend.mockReset()
+    captureSendOrigin.mockClear()
+    clearDraftForSend.mockReset()
+    restoreRejectedDraft.mockReset()
     holdUnconfirmedSend.mockReset()
     onCommandSend.mockReset()
     commandSendRef.current = onCommandSend
@@ -381,4 +391,53 @@ describe('useMobileNativeChatMessageSend', () => {
     expect(acquireMobileNativeChatTerminalWrite('term')).toBe(true)
     releaseMobileNativeChatTerminalWrite('term')
   })
+
+  // The host writes these bytes verbatim, so whitespace the match key drops must
+  // not reach the agent's input line and glue the next rapid send onto it (#14262).
+  it('trims trailing whitespace without changing leading prompt content', async () => {
+    mount(() => null)
+    await act(async () => {
+      await api!.send('  run the tests \n')
+    })
+    expect(sentArgs().text).toBe('  run the tests')
+    expect(captureSendOrigin).toHaveBeenCalledWith('  run the tests')
+    expect(acceptSend.mock.calls[0]![1]).toBe('  run the tests')
+  })
+
+  it('trims trailing whitespace on a question answer too', async () => {
+    mount(() => null)
+    await act(async () => {
+      await api!.answerQuestion('\n 1 ')
+    })
+    expect(sentArgs().text).toBe('\n 1')
+  })
+
+  // #14819: the trim is a wire concern only. A rejected send hands the composer
+  // back to the user, and it has to be the draft they typed, blank lines included.
+  it('restores the untrimmed draft when the send is rejected', async () => {
+    const draft = 'first line\n\nsecond line\n\n'
+    sendWithOutcome.mockResolvedValue('rejected')
+    mount(() => null)
+
+    await act(async () => {
+      await api!.send(draft)
+    })
+
+    expect(sentArgs().text).toBe('first line\n\nsecond line')
+    expect(restoreRejectedDraft.mock.calls[0]![1]).toBe(draft)
+    expect(clearDraftForSend.mock.calls[0]![1]).toBe(draft)
+  })
+
+  it('restores the untrimmed draft when the launch-draft pre-clear is rejected', async () => {
+    const draft = 'ship it   '
+    clearInputWrite.mockResolvedValue(false)
+    mount(() => ({ text: DRAFT, createdAt: 1 }))
+
+    await act(async () => {
+      await api!.send(draft)
+    })
+
+    expect(sendWithOutcome).not.toHaveBeenCalled()
+    expect(restoreRejectedDraft.mock.calls[0]![1]).toBe(draft)
+  })
 })
diff --git a/mobile/src/session/use-mobile-native-chat-message-send.ts b/mobile/src/session/use-mobile-native-chat-message-send.ts
index 17f34b86d27a..53b914657a33 100644
--- a/mobile/src/session/use-mobile-native-chat-message-send.ts
+++ b/mobile/src/session/use-mobile-native-chat-message-send.ts
@@ -85,12 +85,17 @@ export function useMobileNativeChatMessageSend(args: {
 
   const sendMessage = useCallback(
     async (
-      text: string,
+      draftText: string,
       images: string[] | undefined,
       syncComposer: boolean,
       recordControlSend: boolean,
       sharedDeadline?: number
     ): Promise<MobileNativeChatSendOutcome> => {
+      // The host writes trailing whitespace verbatim onto the agent's input line,
+      // where it can glue the next rapid send onto this one (#14262). Only the
+      // bytes that go out are trimmed: `draftText` is what the user typed, and a
+      // rejected send has to put back exactly that (#14819).
+      const text = draftText.trimEnd()
       const handle = handleRef.current
       const origin = captureSendOrigin(text)
       const agent = agentRef.current
@@ -124,7 +129,7 @@ export function useMobileNativeChatMessageSend(args: {
       // round trip is visible, and a lost ack must not strand the sent prompt
       // in the box. Only a definite rejection puts the text back.
       if (syncComposer) {
-        clearDraftForSend(origin, text)
+        clearDraftForSend(origin, draftText)
       }
       // Why: a parked launch draft is routinely multi-line, and one Ctrl+U clears
       // only one logical line. Size the clear to the text Orca injected, with
@@ -150,7 +155,7 @@ export function useMobileNativeChatMessageSend(args: {
         })
         if (!cleared) {
           if (syncComposer) {
-            restoreRejectedDraft(origin, text)
+            restoreRejectedDraft(origin, draftText)
           }
           onSendError('Message not sent')
           return 'rejected'
@@ -204,7 +209,7 @@ export function useMobileNativeChatMessageSend(args: {
       }
       if (outcome === 'rejected') {
         if (syncComposer) {
-          restoreRejectedDraft(origin, text)
+          restoreRejectedDraft(origin, draftText)
         }
         onSendError('Message not sent')
         return 'rejected'