@flamingo-stack/openframe-frontend-core 0.0.510 → 0.0.511-snapshot.20260804140004

package/src/components/chat/remark-mention-chips.ts

@@ -15,9 +15,12 @@
  * intact, and the marker disappears before any rehype-raw HTML pass.
  *
  * Grammar:
- *   - marker: `[a-z]+` — the backend `ContextItemType.marker()` short form
+ *   - marker: `[a-zA-Z]+` — the backend `ContextItemType.marker()` short form
  *     (`device`, `script`, `ticket`, `organization`, `user`, `kb`, `policy`,
- *     `query`, …). Always lowercase.
+ *     `query`, `scheduledScript`, …). Mostly lowercase, but NOT guaranteed to be:
+ *     the marker is matched verbatim by the backend's `MentionParser`, and
+ *     `SCHEDULED_SCRIPT` ships as camelCase `scheduledScript` — a lowercase-only
+ *     grammar silently dropped that whole token (no chip, raw text in the bubble).
  *   - id: charset `[A-Za-z0-9_.+/=-]` (UUIDs with hyphens, fleet numeric ids,
  *     base64 global ids, etc.; matches the composer's `MENTION_TOKEN`) — but the
  *     id may NOT END in `.` or `-`, so a trailing SENTENCE period/dash isn't
@@ -35,7 +38,7 @@ import type { Plugin } from 'unified'
 import type { Root, Text, Link } from 'mdast'
 import { visit, SKIP } from 'unist-util-visit'
 
-const MENTION_REGEX = /(^|[^\w@])@([a-z]+):([A-Za-z0-9_.+/=-]*[A-Za-z0-9_+/=])/g
+const MENTION_REGEX = /(^|[^\w@])@([a-zA-Z]+):([A-Za-z0-9_.+/=-]*[A-Za-z0-9_+/=])/g
 
 export const remarkMentionChips: Plugin<[], Root> = () => {
   return (tree: Root) => {

package/src/components/chat/remark-strip-citations.ts

@@ -0,0 +1,39 @@
+/**
+ * Remark plugin that strips bare numeric citation tokens — `[1]`,
+ * `[2, 3]` — from assistant chat markdown.
+ *
+ * RAG models habitually cite retrieved sources with bracketed indices
+ * next to entity mentions (`[card://delivery_item:x] [1] **Title**`).
+ * The chat surfaces sources as chips and entities as inline cards, so
+ * the naked indices are pure noise — and when a card fetch misses they
+ * were the ONLY thing left on the line (observed live: candidate lists
+ * rendering as "[1]" + bold title).
+ *
+ * Deliberately conservative:
+ *   - text leaves only (code/inline-code nodes are never visited);
+ *   - 1–2 digit indices, optionally comma-separated;
+ *   - the token must be delimiter-bounded on BOTH sides (start/whitespace
+ *     before; whitespace/punctuation/end after) so technical prose like
+ *     `array[1]` or `foo[12]bar` is untouched.
+ */
+
+import type { Plugin } from "unified"
+import type { Root, Text } from "mdast"
+import { visit } from "unist-util-visit"
+
+const CITATION_REGEX = /(^|\s)\[\d{1,2}(?:\s*,\s*\d{1,2})*\](?=[\s.,;:!?)\]]|$)/g
+
+export const remarkStripCitations: Plugin<[], Root> = () => {
+  return (tree: Root) => {
+    visit(tree, "text", (node: Text) => {
+      if (!node.value || !node.value.includes("[")) return
+      const withoutCitations = node.value.replace(CITATION_REGEX, "$1")
+      // No citation matched → leave the node untouched, INCLUDING its
+      // whitespace (collapsing unconditionally would rewrite deliberate
+      // spacing in prose like `array[1]  value`).
+      if (withoutCitations === node.value) return
+      // Collapse doubled spaces the removal can leave mid-sentence.
+      node.value = withoutCitations.replace(/ {2,}/g, " ")
+    })
+  }
+}

package/src/components/chat/stream/__tests__/chat-stream-reducer-approval-batch.test.ts

@@ -0,0 +1,196 @@
+/**
+ * Wire-native approval batches on the SSE kernel.
+ *
+ * The SERVER groups a multi-proposal turn into ONE `approval_batch`
+ * frame; the decoder surfaces it as an `approval-request` event
+ * carrying `toolCalls` (one row per proposal, row id = proposal id).
+ * These tests pin the reducer contracts:
+ *
+ *   - a batch event renders ONE `approval_batch` segment (no per-
+ *     proposal cards, no adjacency heuristics);
+ *   - batch onApprove flips status optimistically and resolves EVERY
+ *     row sequentially through the per-proposal callback;
+ *   - each `approval-resolved` (per proposal id) ticks that row's
+ *     execution icon; the anchor row also carries the status flip;
+ *   - a single-proposal event keeps the classic `approval_request`
+ *     card (editable per-card flow).
+ */
+
+import { describe, it, expect, vi } from 'vitest'
+import { createChatStreamReducer } from '../chat-stream-reducer'
+import { createSseFrameDecoder } from '../../../../chat-protocol/decode'
+import type { ApprovalBatchSegment } from '../../types'
+
+const batchEvent = {
+  type: 'approval-request' as const,
+  // Anchor is DISTINCT from every row's proposal id (server emits
+  // `batch:<first proposalId>`) — the optimistic click flip keys on it
+  // and must never pre-tick a row's execution.
+  requestId: 'batch:prop-1',
+  approvalType: 'chat',
+  toolCalls: [
+    {
+      toolExecutionRequestId: 'prop-1',
+      toolName: 'delete_clickup_task',
+      toolTitle: 'Delete ClickUp task — Fix Website Header',
+      requiresApproval: true,
+      toolCallArguments: { Task: '86aaa', Title: 'Fix Website Header' },
+    },
+    {
+      toolExecutionRequestId: 'prop-2',
+      toolName: 'delete_clickup_task',
+      toolTitle: 'Delete ClickUp task — Fix Website Header (2)',
+      requiresApproval: true,
+      toolCallArguments: { Task: '86bbb', Title: 'Fix Website Header' },
+    },
+  ],
+}
+
+function findBatch(r: ReturnType<typeof createChatStreamReducer>): ApprovalBatchSegment {
+  const trailing = r.state.messages[r.state.messages.length - 1]
+  const batch = trailing.segments?.find(
+    (s): s is ApprovalBatchSegment => s.type === 'approval_batch',
+  )
+  expect(batch).toBeTruthy()
+  return batch as ApprovalBatchSegment
+}
+
+describe('SSE kernel — wire-native approval batch', () => {
+  it('renders ONE approval_batch segment for a toolCalls event', () => {
+    const r = createChatStreamReducer({ transport: 'sse' })
+    r.beginSseSend({ text: 'delete both', assistantName: 'Mingo AI' })
+    r.apply(batchEvent)
+    const trailing = r.state.messages[r.state.messages.length - 1]
+    expect(
+      trailing.segments?.filter((s) => s.type === 'approval_request').length ?? 0,
+    ).toBe(0)
+    const batch = findBatch(r)
+    expect(batch.status).toBe('pending')
+    expect(batch.data.approvalRequestId).toBe('batch:prop-1')
+    expect(batch.data.toolCalls.map((c) => c.toolExecutionRequestId)).toEqual([
+      'prop-1',
+      'prop-2',
+    ])
+  })
+
+  it('onApprove flips status optimistically and resolves every row sequentially', async () => {
+    const onApprove = vi.fn().mockResolvedValue(undefined)
+    const r = createChatStreamReducer({ transport: 'sse', callbacks: { onApprove } })
+    r.beginSseSend({ text: 'delete both', assistantName: 'Mingo AI' })
+    r.apply(batchEvent)
+    const batch = findBatch(r)
+    await batch.onApprove?.(batch.data.approvalRequestId)
+    expect(onApprove.mock.calls.map((c) => c[0])).toEqual(['prop-1', 'prop-2'])
+    const after = findBatch(r)
+    expect(after.status).toBe('approved')
+    // REGRESSION PIN: the optimistic flip must NOT pre-tick any row's
+    // execution — a pre-ticked green check would mask a failed confirm
+    // (observed when the anchor doubled as row 1's proposal id).
+    expect(after.data.executions ?? {}).toEqual({})
+  })
+
+  it('a failed row confirm (false) ticks that row cross, others still attempted', async () => {
+    const onApprove = vi
+      .fn()
+      .mockResolvedValueOnce(false) // row 1 confirm fails (e.g. expired)
+      .mockResolvedValueOnce(true)
+    const r = createChatStreamReducer({ transport: 'sse', callbacks: { onApprove } })
+    r.beginSseSend({ text: 'delete both', assistantName: 'Mingo AI' })
+    r.apply(batchEvent)
+    const batch = findBatch(r)
+    await batch.onApprove?.(batch.data.approvalRequestId)
+    expect(onApprove).toHaveBeenCalledTimes(2)
+    const after = findBatch(r)
+    expect(after.data.executions?.['prop-1']).toEqual({ status: 'done', success: false })
+    expect(after.data.executions?.['prop-2']).toBeUndefined()
+  })
+
+  it('per-proposal approval-resolved events tick the matching row execution', () => {
+    const r = createChatStreamReducer({ transport: 'sse' })
+    r.beginSseSend({ text: 'delete both', assistantName: 'Mingo AI' })
+    r.apply(batchEvent)
+    r.apply({ type: 'approval-resolved', requestId: 'prop-2', status: 'approved', ok: true })
+    let batch = findBatch(r)
+    expect(batch.data.executions?.['prop-2']).toEqual({ status: 'done', success: true })
+    expect(batch.data.executions?.['prop-1']).toBeUndefined()
+    r.apply({ type: 'approval-resolved', requestId: 'prop-1', status: 'approved', ok: true })
+    batch = findBatch(r)
+    expect(batch.data.executions?.['prop-1']).toEqual({ status: 'done', success: true })
+    // Status flips at CLICK time (anchor never matches a row id, and no
+    // decision frame carries the anchor) — row resolutions alone leave
+    // the pending status untouched.
+    expect(batch.status).toBe('pending')
+  })
+
+  it('a single proposal keeps the classic approval_request card', () => {
+    const r = createChatStreamReducer({ transport: 'sse' })
+    r.beginSseSend({ text: 'delete it', assistantName: 'Mingo AI' })
+    r.apply({
+      type: 'approval-request',
+      requestId: 'prop-solo',
+      approvalType: 'delete_clickup_task',
+      command: 'Delete ClickUp task',
+      fields: [{ label: 'Task', value: '86ccc' }],
+    })
+    const trailing = r.state.messages[r.state.messages.length - 1]
+    expect(trailing.segments?.some((s) => s.type === 'approval_batch')).toBe(false)
+    expect(trailing.segments?.some((s) => s.type === 'approval_request')).toBe(true)
+  })
+})
+
+describe('decoder — approval_batch frame mapping', () => {
+  it('maps the wire frame to ONE batched approval-request event', () => {
+    const frame = {
+      kind: 'approval_batch',
+      batchId: 'batch:prop-1',
+      proposals: [
+        {
+          proposalId: 'prop-1',
+          toolName: 'delete_clickup_task',
+          title: 'Delete ClickUp task',
+          fields: [
+            { label: 'Task', value: '86aaa' },
+            { label: 'Title', value: 'Fix Website Header' },
+          ],
+        },
+        {
+          proposalId: 'prop-2',
+          toolName: 'delete_clickup_task',
+          title: 'Delete ClickUp task',
+          fields: [{ label: 'Task', value: '86bbb' }],
+        },
+      ],
+    }
+    const decoder = createSseFrameDecoder()
+    const bytes = new TextEncoder().encode(JSON.stringify(frame) + '\0')
+    const events = decoder.push(bytes)
+    const approval = events.find((e) => e.type === 'approval-request') as
+      | { requestId: string; toolCalls?: Array<Record<string, unknown>> }
+      | undefined
+    expect(approval).toBeTruthy()
+    expect(approval!.requestId).toBe('batch:prop-1')
+    expect(approval!.toolCalls?.length).toBe(2)
+    expect(approval!.toolCalls?.[0].toolExecutionRequestId).toBe('prop-1')
+    // Title field drives the row's disambiguating toolTitle.
+    expect(approval!.toolCalls?.[0].toolTitle).toContain('Fix Website Header')
+    expect(approval!.toolCalls?.[1].toolExecutionRequestId).toBe('prop-2')
+  })
+
+  it('a colliding anchor id (misbehaving server) still cannot pre-tick a row execution', async () => {
+    // Defense-in-depth pin: the click-time flip uses the STATUS-ONLY
+    // projection, so even a server that (incorrectly) reuses a row's
+    // proposal id as the batchId cannot mark that row done before its
+    // confirm actually resolves.
+    const onApprove = vi.fn().mockResolvedValue(undefined)
+    const r = createChatStreamReducer({ transport: 'sse', callbacks: { onApprove } })
+    r.beginSseSend({ text: 'delete both', assistantName: 'Mingo AI' })
+    r.apply({ ...batchEvent, requestId: 'prop-1' })
+    const batch = findBatch(r)
+    await batch.onApprove?.(batch.data.approvalRequestId)
+    const after = findBatch(r)
+    expect(after.status).toBe('approved')
+    // The flip itself wrote NO execution for prop-1 — its icon state
+    // comes only from the confirm result / approval-resolved event.
+    expect(after.data.executions ?? {}).toEqual({})
+  })
+})

package/src/components/chat/stream/chat-stream-reducer.ts

@@ -60,6 +60,7 @@ import { parseScrollAnchor, type ScrollAnchor } from '../utils/scroll-anchor'
 import { escapeThinkingTags } from '../../../chat-protocol/decode'
 import { buildChatRefKey } from '../types/chat.types'
 import type {
+  ApprovalBatchSegment,
   ApprovalRequestSegment,
   ChatApprovalStatus,
   MessageSegment,
@@ -93,6 +94,8 @@ import {
   mergeToolExecutionIfPresent,
   nextId,
   projectApprovalResolutionToMessages,
+  projectBatchRowFailureToMessages,
+  projectBatchStatusToMessages,
   updateTrailingAssistant,
   upsertTrailingCompaction,
 } from './message-mutations'
@@ -1526,12 +1529,68 @@ export function createChatStreamReducer(
           onReject: callbacks.onReject,
         }
         const last = messages[messages.length - 1]
-        if (last && last.role === 'assistant') {
+        if (!last || last.role !== 'assistant') break
+        // ── WIRE-NATIVE BATCH ─────────────────────────────────────────
+        // The SERVER groups a multi-proposal turn into ONE
+        // `approval_batch` frame (decoded to `event.toolCalls`) — the
+        // client performs NO adjacency heuristics. Render the bulk-
+        // approval component: one Approve/Reject resolving every row
+        // sequentially through its own per-proposal confirm; per-row
+        // execution icons ticked by each `approval-resolved` event
+        // (see `projectApprovalResolutionToMessages`). Single-proposal
+        // turns keep the classic editable per-card flow below.
+        if (event.toolCalls && event.toolCalls.length > 0) {
+          const rows = event.toolCalls
+          const anchorId = event.requestId
+          const ids = rows.map((c) => c.toolExecutionRequestId)
+          const batchSegment: ApprovalBatchSegment = {
+            type: 'approval_batch',
+            status: 'pending',
+            data: {
+              approvalRequestId: anchorId,
+              approvalType: event.approvalType ?? 'chat',
+              toolCalls: rows,
+              executions: {},
+            },
+            // Optimistic status flip so the per-row loaders show while
+            // the sequential per-proposal confirms run (the anchor id is
+            // NEVER a row id — see ApprovalBatchFrame.batchId — so the
+            // flip cannot pre-tick a row's execution). A confirm that
+            // reports failure (`false` — expired proposal, network
+            // error) ticks THAT row's cross so no loader spins forever;
+            // remaining rows still get their attempt.
+            ...(() => {
+              const resolveBatch =
+                (status: 'approved' | 'rejected', confirm: typeof callbacks.onApprove) =>
+                async () => {
+                  // STATUS-ONLY projection (defense-in-depth): even a
+                  // batchId colliding with a row id cannot pre-tick an
+                  // execution here — rows resolve exclusively via their
+                  // own confirm results / approval-resolved events.
+                  setMessagesInternal(projectBatchStatusToMessages(messages, anchorId, status))
+                  for (const id of ids) {
+                    const ok = await confirm?.(id)
+                    if (ok === false) {
+                      setMessagesInternal(projectBatchRowFailureToMessages(messages, id))
+                    }
+                  }
+                }
+              return {
+                onApprove: resolveBatch('approved', callbacks.onApprove),
+                onReject: resolveBatch('rejected', callbacks.onReject),
+              }
+            })(),
+          }
           setMessagesInternal([
             ...messages.slice(0, -1),
-            { ...last, segments: [...(last.segments ?? []), segment] },
+            { ...last, segments: [...(last.segments ?? []), batchSegment] },
           ])
+          break
         }
+        setMessagesInternal([
+          ...messages.slice(0, -1),
+          { ...last, segments: [...(last.segments ?? []), segment] },
+        ])
         break
       }
       case 'approval-resolved':
@@ -1919,6 +1978,12 @@ export function createChatStreamReducer(
       setMessagesInternal(
         projectApprovalResolutionToMessages(messages, requestId, status, resolvedByName),
       )
+      // Status-map mirror — kept in lockstep with the other two flip
+      // paths (SSE approval-resolved at ~1240, NATS at ~1950): the map
+      // restores status when a replayed approval-request event
+      // re-renders the card, and a flip applied through THIS path must
+      // survive that replay the same way.
+      mirrorApprovalStatus(requestId, status)
       return segments
     },
     getPendingEscalated() {

package/src/components/chat/stream/message-mutations.ts

@@ -134,6 +134,162 @@ export function appendToTrailingAssistant(
   return [...prev.slice(0, -1), { ...last, segments: merged }]
 }
 
+// =============================================================================
+// Segment-projection kernel — shared scaffolding + single-rule predicates
+// =============================================================================
+
+/**
+ * Map every assistant message's segments through `fn`, preserving the
+ * REFERENTIAL-STABILITY CONTRACT in ONE place: `fn` returns the SAME
+ * segment reference to signal "unchanged"; untouched messages (and the
+ * whole array on a global no-op) keep their prior references. Every
+ * segment projection below rides this scaffold instead of re-implementing
+ * the changed-flag dance.
+ */
+function mapSegments(
+  prev: UnifiedChatMessage[],
+  fn: (s: MessageSegment) => MessageSegment,
+): UnifiedChatMessage[] {
+  let changed = false
+  const next = prev.map((m) => {
+    if (m.role !== 'assistant' || !m.segments) return m
+    let msgChanged = false
+    const segs = m.segments.map((s) => {
+      const out = fn(s)
+      if (out !== s) msgChanged = true
+      return out
+    })
+    if (!msgChanged) return m
+    changed = true
+    return { ...m, segments: segs }
+  })
+  return changed ? next : prev
+}
+
+/**
+ * THE approval-resolution rule for a single segment — one predicate for
+ * both containers (the message-array projections here AND the flat
+ * segment list in `MessageSegmentAccumulator.updateApprovalStatus`), so
+ * the two paths can never drift:
+ *   - `approval_request` matched on `data.requestId` → status flip;
+ *   - `approval_batch` anchor (`data.approvalRequestId`, the server's
+ *     `batch:<first proposalId>` — never a row id) → status flip;
+ *   - `approval_batch` ROW (`toolCalls[].toolExecutionRequestId`) →
+ *     tick that row's execution (check on approved, cross otherwise)
+ *     without touching the batch status.
+ * Returns the SAME reference when nothing matched or changed.
+ */
+export function applyApprovalStatusToSegment(
+  s: MessageSegment,
+  requestId: string,
+  status: ChatApprovalStatus,
+  resolvedByName?: string | null,
+): MessageSegment {
+  if (s.type === 'approval_request' && s.data.requestId === requestId && s.status !== status) {
+    return { ...s, status }
+  }
+  if (s.type !== 'approval_batch') return s
+  const isAnchor = s.data.approvalRequestId === requestId
+  const hasRow = s.data.toolCalls?.some((c) => c.toolExecutionRequestId === requestId)
+  if (!isAnchor && !hasRow) return s
+  const nextResolvedBy = resolvedByName ?? s.resolvedByName
+  const nextExecutions = hasRow
+    ? {
+        ...(s.data.executions ?? {}),
+        [requestId]: { status: 'done' as const, success: status === 'approved' },
+      }
+    : s.data.executions
+  const nextStatus = isAnchor ? status : s.status
+  if (
+    s.status === nextStatus &&
+    nextResolvedBy === s.resolvedByName &&
+    nextExecutions === s.data.executions
+  ) {
+    return s
+  }
+  return {
+    ...s,
+    status: nextStatus,
+    resolvedByName: nextResolvedBy,
+    data: {
+      ...s.data,
+      ...(nextExecutions ? { executions: nextExecutions } : {}),
+    },
+  }
+}
+
+/**
+ * Next state for a batch row's execution slot from a tool-execution
+ * chunk — folds the never-downgrade guard (redelivered EXECUTING after
+ * EXECUTED landed) and the EXECUTED/EXECUTING ternary into ONE rule
+ * shared by the message projection and the accumulator. Returns null
+ * for the no-op case (caller keeps prior references).
+ */
+export function nextBatchExecution(
+  prevExec: ApprovalBatchExecutionState | undefined,
+  toolData: ToolExecutionData,
+): ApprovalBatchExecutionState | null {
+  if (toolData.type === 'EXECUTING_TOOL' && prevExec?.status === 'done') return null
+  return toolData.type === 'EXECUTED_TOOL'
+    ? { status: 'done', result: toolData.result, success: toolData.success }
+    : { status: 'executing', result: prevExec?.result, success: prevExec?.success }
+}
+
+/** The executions-map triple-spread — one home for the write shape. */
+export function withBatchExecution<S extends { data: { executions?: Record<string, ApprovalBatchExecutionState> } }>(
+  seg: S,
+  execId: string,
+  state: ApprovalBatchExecutionState,
+): S {
+  return {
+    ...seg,
+    data: { ...seg.data, executions: { ...(seg.data.executions ?? {}), [execId]: state } },
+  }
+}
+
+/**
+ * Flip ONLY an approval_batch segment's status — no execution writes.
+ * The click-time optimistic flip uses this instead of
+ * `projectApprovalResolutionToMessages` as defense-in-depth: even if a
+ * (misbehaving) server emitted a batchId colliding with a row's
+ * proposal id, the flip could not pre-tick that row's execution to a
+ * false success before its confirm actually ran.
+ */
+export function projectBatchStatusToMessages(
+  prev: UnifiedChatMessage[],
+  anchorId: string,
+  status: ChatApprovalStatus,
+): UnifiedChatMessage[] {
+  return mapSegments(prev, (s) => {
+    if (s.type !== 'approval_batch') return s
+    if (s.data.approvalRequestId !== anchorId || s.status === status) return s
+    return { ...s, status }
+  })
+}
+
+/**
+ * Mark ONE batch row's confirm as FAILED (expired proposal, network
+ * error): tick its execution icon to the failure cross so the row's
+ * loader doesn't spin forever. Batch status is untouched — other rows
+ * may still be resolving.
+ */
+export function projectBatchRowFailureToMessages(
+  prev: UnifiedChatMessage[],
+  rowRequestId: string,
+): UnifiedChatMessage[] {
+  return mapSegments(prev, (s) => {
+    if (
+      s.type !== 'approval_batch' ||
+      !s.data.toolCalls?.some((c) => c.toolExecutionRequestId === rowRequestId)
+    ) {
+      return s
+    }
+    const existing = s.data.executions?.[rowRequestId]
+    if (existing?.status === 'done') return s
+    return withBatchExecution(s, rowRequestId, { status: 'done', success: false })
+  })
+}
+
 /**
  * Upsert a standalone context-compaction segment into the trailing assistant
  * bubble. Compaction emissions arrive as the accumulator's CUMULATIVE array —
@@ -242,23 +398,16 @@ export function mergeToolExecutionIfPresent(
         seg.data.toolCalls.some((c) => c.toolExecutionRequestId === execId)
       ) {
         const prevExec: ApprovalBatchExecutionState | undefined = seg.data.executions?.[execId]
-        // Never downgrade a done batch slot back to executing (JetStream
-        // redelivery of the EXECUTING chunk after EXECUTED landed). Returning
-        // prev = matched-with-no-change, so the caller doesn't append either.
-        if (toolData.type === 'EXECUTING_TOOL' && prevExec?.status === 'done') {
-          return prev
-        }
-        const nextExec: ApprovalBatchExecutionState =
-          toolData.type === 'EXECUTED_TOOL'
-            ? { status: 'done', result: toolData.result, success: toolData.success }
-            : { status: 'executing', result: prevExec?.result, success: prevExec?.success }
+        // Shared rule (`nextBatchExecution`): folds the never-downgrade
+        // guard (JetStream redelivery of EXECUTING after EXECUTED
+        // landed — null = matched-with-no-change, caller doesn't append
+        // either) and the EXECUTED/EXECUTING ternary.
+        const nextExec = nextBatchExecution(prevExec, toolData)
+        if (nextExec === null) return prev
         // Value-level no-op (replayed duplicate) → prior references.
         if (sameExecutionState(prevExec, nextExec)) return prev
         const nextSegments = [...message.segments]
-        nextSegments[j] = {
-          ...seg,
-          data: { ...seg.data, executions: { ...(seg.data.executions ?? {}), [execId]: nextExec } },
-        }
+        nextSegments[j] = withBatchExecution(seg, execId, nextExec)
         const next = [...prev]
         next[i] = { ...message, segments: nextSegments }
         return next
@@ -304,10 +453,10 @@ export function mergeToolExecutionIfPresent(
 }
 
 /**
- * Cross-message approval status flip (absorbed from the NATS adapter's
- * `onApprovalResolved` handler). Idempotent + reference-preserving: only the
- * messages/segments whose status (or resolvedByName) actually changes are
- * cloned; a no-op returns `prev`.
+ * Project an approval resolution onto the thread — the ONE rule lives in
+ * `applyApprovalStatusToSegment` (shared with the accumulator's flat
+ * segment list); this is just its message-array projection via
+ * `mapSegments`.
  */
 export function projectApprovalResolutionToMessages(
   prev: UnifiedChatMessage[],
@@ -315,26 +464,7 @@ export function projectApprovalResolutionToMessages(
   status: ChatApprovalStatus,
   resolvedByName?: string | null,
 ): UnifiedChatMessage[] {
-  let changed = false
-  const next = prev.map((m) => {
-    if (m.role !== 'assistant' || !m.segments) return m
-    let msgChanged = false
-    const segs = m.segments.map((s) => {
-      if (s.type === 'approval_request' && s.data.requestId === requestId && s.status !== status) {
-        msgChanged = true
-        return { ...s, status }
-      }
-      if (s.type === 'approval_batch' && s.data.approvalRequestId === requestId) {
-        const nextResolvedBy = resolvedByName ?? s.resolvedByName
-        if (s.status === status && nextResolvedBy === s.resolvedByName) return s
-        msgChanged = true
-        return { ...s, status, resolvedByName: nextResolvedBy }
-      }
-      return s
-    })
-    if (!msgChanged) return m
-    changed = true
-    return { ...m, segments: segs }
-  })
-  return changed ? next : prev
+  return mapSegments(prev, (s) =>
+    applyApprovalStatusToSegment(s, requestId, status, resolvedByName),
+  )
 }

package/src/components/chat/types/component.types.ts

@@ -4,7 +4,9 @@
 
 import type { ComponentType, HTMLAttributes, ReactNode, TextareaHTMLAttributes } from 'react'
 import type { ApprovalBlockVariant, AssistantType, AuthorType, ChatApprovalStatus, ConnectionStatus } from './chat.types'
-import type { ApprovalRequestData, Message, MessageSegment, ToolExecutionData } from './message.types'
+import type { ApprovalRequestData, Message, MessageSegment, ToolExecutionData,
+  ApprovalResolutionHandler,
+} from './message.types'
 import type { ChatRef } from '../chat-ref.types'
 import type { ChatContextItem } from './context-item.types'
 import type { MspOrganizationCardProps } from '../msp-organization-card'
@@ -129,8 +131,8 @@ export interface ChatMessageEnhancedProps extends Omit<HTMLAttributes<HTMLDivEle
   timestamp?: Date
   showAvatar?: boolean
   isTyping?: boolean
-  onApprove?: (requestId?: string) => void | Promise<void>
-  onReject?: (requestId?: string) => void | Promise<void>
+  onApprove?: ApprovalResolutionHandler
+  onReject?: ApprovalResolutionHandler
   /**
    * Per-row metadata for inline entity-card rendering (v6.1 §B.2.6+§B.2.7).
    * Keyed by `<documentType>:<primaryKey>`. When present AND
@@ -259,8 +261,8 @@ export interface ChatMessageListProps extends HTMLAttributes<HTMLDivElement> {
   approvalVariant?: ApprovalBlockVariant
   assistantIcon?: React.ReactNode
   pendingApprovals?: MessageSegment[]
-  onApprove?: (requestId?: string) => void | Promise<void>
-  onReject?: (requestId?: string) => void | Promise<void>
+  onApprove?: ApprovalResolutionHandler
+  onReject?: ApprovalResolutionHandler
   // Infinite scroll for loading older messages
   hasNextPage?: boolean
   isFetchingNextPage?: boolean
@@ -518,8 +520,8 @@ export interface ToolExecutionDisplayProps extends HTMLAttributes<HTMLDivElement
 
 export interface ApprovalRequestMessageProps extends HTMLAttributes<HTMLDivElement> {
   data: ApprovalRequestData
-  onApprove?: (requestId?: string) => void | Promise<void>
-  onReject?: (requestId?: string) => void | Promise<void>
+  onApprove?: ApprovalResolutionHandler
+  onReject?: ApprovalResolutionHandler
   status?: ChatApprovalStatus
   disabled?: boolean
   /** Chat identity. Accepted for parity with the batch card; does NOT drive