fix(native-chat): match glue against each pending send's own boundary

src/renderer/src/components/native-chat/NativeChatInteractiveCard.test.tsx

@@ -5,7 +5,7 @@ import '@testing-library/jest-dom/vitest'
 import { act, cleanup, fireEvent, render, screen } from '@testing-library/react'
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
 import type { NativeChatMessage } from '../../../../shared/native-chat-types'
-import { applyCommandMarkerBoundaries } from './native-chat-pending'
+import { applyCommandMarkerBoundaries } from './native-chat-command-marker'
 import type { NativeChatInteractiveSend } from './use-native-chat-interactive-send'
 
 const INITIAL_PROMPT = JSON.stringify({

src/renderer/src/components/native-chat/NativeChatView.tsx

@@ -18,21 +18,23 @@ import {
   shouldShowNativeChatWorking
 } from './native-chat-working-suppression'
 import {
-  applyCommandMarkerBoundaries,
   appendPendingSendCache,
-  commandMarkersAsMessages,
-  appendCommandMarkerCache,
   launchPromptAsMessage,
   pendingSendsAsMessages,
   nextNativeChatPendingSendId,
   prunePendingSends,
-  readCommandMarkerCache,
   readPendingSendCache,
   shouldPruneLaunchPrompt,
   writePendingSendCache,
-  type NativeChatCommandMarker,
   type NativeChatPendingSend
 } from './native-chat-pending'
+import {
+  appendCommandMarkerCache,
+  applyCommandMarkerBoundaries,
+  commandMarkersAsMessages,
+  readCommandMarkerCache,
+  type NativeChatCommandMarker
+} from './native-chat-command-marker'
 import {
   deriveNativeChatStreamingText,
   nativeChatStreamingMessage

src/renderer/src/components/native-chat/native-chat-command-marker.ts

@@ -0,0 +1,111 @@
+// Locally-recorded slash commands (e.g. `/clear`). They dispatch into the
+// agent's TUI rather than the conversation, so native chat renders its own
+// marker line and applies their transcript boundaries — kept out of the
+// optimistic-send pruning in native-chat-pending.ts, which is a separate rule.
+
+import type { NativeChatMessage } from '../../../../shared/native-chat-types'
+import { setBoundedScopeCacheEntry } from './native-chat-composer-scope-cache'
+
+/** A locally-recorded slash command (e.g. `/clear`). Slash commands dispatch to
+ *  the agent's TUI and are not chat turns, so we surface a small system line as
+ *  feedback that the command ran rather than echoing a user bubble. */
+export type NativeChatCommandMarker = {
+  id: string
+  /** The command as typed, e.g. `/clear`. */
+  command: string
+  sentAt: number
+}
+
+export type NativeChatCommandMarkerScope = {
+  paneKey: string
+  agent: string
+  sessionId: string | null
+}
+
+const COMMAND_MARKER_LIMIT = 8
+const commandMarkerCache = new Map<string, NativeChatCommandMarker[]>()
+let commandMarkerCounter = 0
+
+function commandMarkerScopeKey(scope: NativeChatCommandMarkerScope): string {
+  return `${scope.paneKey}\0${scope.agent}\0${scope.sessionId ?? ''}`
+}
+
+export function readCommandMarkerCache(
+  scope: NativeChatCommandMarkerScope
+): NativeChatCommandMarker[] {
+  return [...(commandMarkerCache.get(commandMarkerScopeKey(scope)) ?? [])]
+}
+
+export function appendCommandMarkerCache(
+  scope: NativeChatCommandMarkerScope,
+  command: string,
+  sentAt = Date.now()
+): NativeChatCommandMarker[] {
+  commandMarkerCounter += 1
+  const key = commandMarkerScopeKey(scope)
+  // Why: native/TUI view switches remount the chat surface, but slash commands
+  // are not transcript turns, so their local feedback needs a pane-scoped cache.
+  const next = [
+    ...(commandMarkerCache.get(key) ?? []),
+    { id: `${sentAt}-${commandMarkerCounter}`, command, sentAt }
+  ].slice(-COMMAND_MARKER_LIMIT)
+  // Why: the per-key array is capped at 8, but the KEY (paneKey\0agent\0sessionId,
+  // sessionId changes on every /clear) is ephemeral and was never evicted, so it
+  // grew one entry per (pane, session) for the renderer's whole life. LRU-bound
+  // the key count (mirrors the #7566 draft/attachment caches in this folder).
+  setBoundedScopeCacheEntry(commandMarkerCache, key, next)
+  return [...next]
+}
+
+export function clearCommandMarkerCacheForTests(): void {
+  commandMarkerCache.clear()
+  commandMarkerCounter = 0
+}
+
+function isClearCommand(command: string): boolean {
+  return command.trim().toLowerCase().split(/\s+/)[0] === '/clear'
+}
+
+function latestClearSentAt(markers: readonly NativeChatCommandMarker[]): number | null {
+  let latest: number | null = null
+  for (const marker of markers) {
+    if (isClearCommand(marker.command) && (latest === null || marker.sentAt > latest)) {
+      latest = marker.sentAt
+    }
+  }
+  return latest
+}
+
+export function applyCommandMarkerBoundaries(
+  messages: readonly NativeChatMessage[],
+  markers: readonly NativeChatCommandMarker[]
+): NativeChatMessage[] {
+  const clearSentAt = latestClearSentAt(markers)
+  if (clearSentAt === null) {
+    return messages as NativeChatMessage[]
+  }
+  // Why: `/clear` mutates the TUI/transcript asynchronously. Hide the current
+  // transcript immediately so native chat reflects the command before the agent
+  // writes a replacement session or truncates the file.
+  return messages.filter((message) => message.timestamp !== null && message.timestamp > clearSentAt)
+}
+
+/** Render command markers as compact `system` messages. The `system` role draws
+ *  as a muted aside (not a user bubble); the text avoids the harness noise
+ *  prefixes so stripNoiseMessages keeps it. */
+export function commandMarkersAsMessages(
+  markers: readonly NativeChatCommandMarker[]
+): NativeChatMessage[] {
+  return markers.map((marker) => ({
+    id: `command:${marker.id}`,
+    role: 'system' as const,
+    blocks: [{ type: 'text' as const, text: `Ran ${marker.command}` }],
+    timestamp: marker.sentAt,
+    source: 'scrape' as const
+  }))
+}
+
+/** True when a message id was minted for a slash-command marker. */
+export function isCommandMarkerId(id: string): boolean {
+  return id.startsWith('command:')
+}

src/renderer/src/components/native-chat/native-chat-pending-occurrence.ts

@@ -79,17 +79,21 @@ export function advancedNativeChatUserContentCounts(
   return advanced
 }
 
-/** User texts that already have a later non-user turn (ready to prune echoes). */
-export function advancedNativeChatUserTexts(
+/** A transcript user turn, kept identifiable so a caller can decide which
+ *  pending sends it is allowed to represent. */
+export type NativeChatUserRow = { id: string; text: string }
+
+/** User rows that already have a later non-user turn (ready to prune echoes). */
+export function advancedNativeChatUserRows(
   messages: readonly NativeChatMessage[]
-): readonly string[] {
-  const advanced: string[] = []
-  const waiting: string[] = []
+): readonly NativeChatUserRow[] {
+  const advanced: NativeChatUserRow[] = []
+  const waiting: NativeChatUserRow[] = []
   for (const message of messages) {
     if (message.role === 'user') {
       const text = normalizedNativeChatUserMessageText(message)
       if (text) {
-        waiting.push(text)
+        waiting.push({ id: message.id, text })
       }
       continue
     }
@@ -99,18 +103,18 @@ export function advancedNativeChatUserTexts(
   return advanced
 }
 
-/** All user texts (for hiding optimistic echoes once the turn exists). */
-export function matchingNativeChatUserTexts(
+/** All user rows (for hiding optimistic echoes once the turn exists). */
+export function matchingNativeChatUserRows(
   messages: readonly NativeChatMessage[]
-): readonly string[] {
-  const texts: string[] = []
+): readonly NativeChatUserRow[] {
+  const rows: NativeChatUserRow[] = []
   for (const message of messages) {
     const text = normalizedNativeChatUserMessageText(message)
     if (text) {
-      texts.push(text)
+      rows.push({ id: message.id, text })
     }
   }
-  return texts
+  return rows
 }
 
 /**
@@ -149,32 +153,49 @@ export function countLeadingPendingTextsGluedToUserText(
   return 0
 }
 
+/** A transcript row a glue match may consume, carrying the send boundaries it
+ *  satisfies — this matcher has no clock of its own. */
+export type NativeChatGluedUserRow = {
+  text: string
+  /** Indices into `pending` this row landed after. A row that already existed
+   *  when a send was issued can never be that send's echo. */
+  representablePendingIndices: ReadonlySet<number>
+}
+
 /**
  * Mark pending entries represented only by multi-send glue (2+ consecutive
  * optimistic texts concatenated into one transcript user row). Exact single
  * matches stay in the content-key/occurrence path so repeated prompts and
  * send boundaries keep their existing semantics.
- *
- * `userTexts` must already be filtered to rows after the oldest entry's send
- * boundary — this matcher has no clock of its own.
  */
-export function selectPendingIndicesRepresentedByUserTexts(
+export function selectPendingIndicesRepresentedByUserRows(
   pending: readonly NativeChatPendingOccurrence[],
-  userTexts: readonly string[]
+  rows: readonly NativeChatGluedUserRow[]
 ): Set<number> {
   const represented = new Set<number>()
-  if (pending.length < 2 || userTexts.length === 0) {
+  if (pending.length < 2 || rows.length === 0) {
     return represented
   }
   const remaining = pending.map((entry, index) => ({
     index,
     text: normalizeNativeChatPendingText(entry.text)
   }))
-  for (const userText of userTexts) {
-    const open = remaining.filter((entry) => !represented.has(entry.index) && entry.text.length > 0)
+  for (const row of rows) {
+    const open: typeof remaining = []
+    for (const entry of remaining) {
+      if (represented.has(entry.index) || entry.text.length === 0) {
+        continue
+      }
+      // Glue consumes a leading run, so a send this row predates ends the run
+      // rather than being skipped over — adjacency is what makes it glue.
+      if (!row.representablePendingIndices.has(entry.index)) {
+        break
+      }
+      open.push(entry)
+    }
     const gluedCount = countLeadingPendingTextsGluedToUserText(
       open.map((entry) => entry.text),
-      userText
+      row.text
     )
     // Why: gluedCount === 1 is an exact match — leave it to occurrence counting.
     if (gluedCount < 2) {

src/renderer/src/components/native-chat/native-chat-pending.test.ts

@@ -2,24 +2,26 @@ import { describe, expect, it } from 'vitest'
 import type { NativeChatMessage } from '../../../../shared/native-chat-types'
 import {
   appendPendingSendCache,
-  appendCommandMarkerCache,
-  applyCommandMarkerBoundaries,
-  clearCommandMarkerCacheForTests,
   clearPendingSendCacheForTests,
-  commandMarkersAsMessages,
-  isCommandMarkerId,
   isLaunchPromptMessageId,
   isPendingMessageId,
   launchPromptAsMessage,
   nextNativeChatPendingSendId,
   pendingSendsAsMessages,
   prunePendingSends,
-  readCommandMarkerCache,
   readPendingSendCache,
   shouldPruneLaunchPrompt,
   writePendingSendCache,
   type NativeChatPendingSend
 } from './native-chat-pending'
+import {
+  appendCommandMarkerCache,
+  applyCommandMarkerBoundaries,
+  clearCommandMarkerCacheForTests,
+  commandMarkersAsMessages,
+  isCommandMarkerId,
+  readCommandMarkerCache
+} from './native-chat-command-marker'
 import { stripNoiseMessages } from './native-chat-noise'
 
 function userMessage(id: string, text: string, timestamp = 1): NativeChatMessage {
@@ -330,6 +332,47 @@ describe('glued rapid sends', () => {
     expect(prunePendingSends(pending, history)).toEqual(pending)
     expect(pendingSendsAsMessages(pending, history)).toHaveLength(2)
   })
+
+  // A row that already existed when a send was issued can never be that send's
+  // echo — for EVERY queued send, not just the oldest one the glue run starts at.
+  it('keeps a queued send whose own boundary is newer than the glued row (STA-4477)', () => {
+    const gluedRow = userMessage('glue-row', 'fix the bug', 6000)
+    const messages = [
+      GLUE_BOUNDARY,
+      gluedRow,
+      assistantMessage('glue-answer', 'fixed', 6100),
+      userMessage('later-history', 'anything', 6200)
+    ]
+    // 'fix the' was queued before the row landed; 'bug' only after it.
+    const pending = [
+      gluePending('p1', 'fix the'),
+      {
+        id: 'p2',
+        text: 'bug',
+        sentAt: 7000,
+        afterMessageId: 'glue-answer',
+        afterMessageTimestamp: 6100
+      }
+    ]
+
+    expect(prunePendingSends(pending, messages)).toEqual(pending)
+    expect(pendingSendsAsMessages(pending, messages)).toHaveLength(2)
+  })
+
+  it('still retires the leading run the glued row did land after (STA-4477)', () => {
+    const gluedRow = userMessage('glue-row', 'first second', 6000)
+    const messages = [GLUE_BOUNDARY, gluedRow, assistantMessage('glue-answer', 'done', 6100)]
+    const third = {
+      id: 'p3',
+      text: 'third',
+      sentAt: 7000,
+      afterMessageId: 'glue-row',
+      afterMessageTimestamp: gluedRow.timestamp
+    }
+    const pending = [gluePending('p1', 'first'), gluePending('p2', 'second'), third]
+
+    expect(prunePendingSends(pending, messages)).toEqual([third])
+  })
 })
 
 describe('pendingSendsAsMessages', () => {