@flamingo-stack/openframe-frontend-core 0.0.512-1640.4221.1 → 0.0.512

package/src/components/chat/entity-cards/dispatch.tsx

@@ -1026,26 +1026,34 @@ const FINANCIAL_CARD_CONFIGS: Record<string, FinancialCardConfig> = {
   balance_sheet: { label: 'Balance sheet', icon: () => <BankIcon size={24} /> },
   cash_flow: { label: 'Cash flow', icon: () => <CoinsExchangeCurrencyIcon size={24} /> },
 }
-function financialRegistryEntries(): Record<string, ChatCardRegistryEntry> {
+/** Expand a per-family config map into registry entries — ONE loop shell
+ *  for every card family (financial, github, program, roadmap); adding a
+ *  family is a config map + one `registryEntries(...)` call. */
+function registryEntries<C>(
+  configs: Record<string, C>,
+  build: (cfg: C) => ChatCardRegistryEntry,
+): Record<string, ChatCardRegistryEntry> {
   const out: Record<string, ChatCardRegistryEntry> = {}
-  for (const [docType, cfg] of Object.entries(FINANCIAL_CARD_CONFIGS)) {
-    out[docType] = {
-      mode: 'no-fetch',
-      label: cfg.label,
-      bareInline: true,
-      render: (chatRef, opts) => (
-        <GenericFinancialChatCard
-          chatRef={chatRef}
-          icon={cfg.icon()}
-          isNewTab={opts.isNewTab}
-          discuss={opts.discuss}
-        />
-      ),
-    }
-  }
+  for (const [docType, cfg] of Object.entries(configs)) out[docType] = build(cfg)
   return out
 }
 
+function financialRegistryEntries(): Record<string, ChatCardRegistryEntry> {
+  return registryEntries(FINANCIAL_CARD_CONFIGS, (cfg) => ({
+    mode: 'no-fetch',
+    label: cfg.label,
+    bareInline: true,
+    render: (chatRef, opts) => (
+      <GenericFinancialChatCard
+        chatRef={chatRef}
+        icon={cfg.icon()}
+        isNewTab={opts.isNewTab}
+        discuss={opts.discuss}
+      />
+    ),
+  }))
+}
+
 interface GitHubCardConfig {
   label: string
   kind: GitHubActivityKind
@@ -1059,19 +1067,15 @@ const GITHUB_CARD_CONFIGS: Record<string, GitHubCardConfig> = {
   github_pr_review_public: { label: 'GitHub review (public)', kind: 'pr_review' },
 }
 function githubRegistryEntries(): Record<string, ChatCardRegistryEntry> {
-  const out: Record<string, ChatCardRegistryEntry> = {}
-  for (const [docType, cfg] of Object.entries(GITHUB_CARD_CONFIGS)) {
-    out[docType] = {
-      mode: 'no-fetch',
-      label: cfg.label,
-      bareInline: true,
-      render: (chatRef, opts) => (
-        <GitHubChatCard chatRef={chatRef} kind={cfg.kind} isNewTab={opts.isNewTab}
-          discuss={opts.discuss} />
-      ),
-    }
-  }
-  return out
+  return registryEntries(GITHUB_CARD_CONFIGS, (cfg) => ({
+    mode: 'no-fetch',
+    label: cfg.label,
+    bareInline: true,
+    render: (chatRef, opts) => (
+      <GitHubChatCard chatRef={chatRef} kind={cfg.kind} isNewTab={opts.isNewTab}
+        discuss={opts.discuss} />
+    ),
+  }))
 }
 
 type ProgramConfigKey = 'podcast' | 'webinar' | 'event'
@@ -1086,28 +1090,24 @@ const PROGRAM_CARD_CONFIGS: Record<string, ProgramCardConfig> = {
   event: { label: 'Event', configKey: 'event', contentRefType: 'event' },
 }
 function programRegistryEntries(): Record<string, ChatCardRegistryEntry> {
-  const out: Record<string, ChatCardRegistryEntry> = {}
-  for (const [docType, cfg] of Object.entries(PROGRAM_CARD_CONFIGS)) {
-    out[docType] = {
-      mode: 'fetch',
-      label: cfg.label,
-      contentRefType: cfg.contentRefType,
-      bareInline: true,
-      skeleton: () => <ProgramCardSkeleton size="sm" />,
-      render: (item, chatRef, opts) => (
-        <ProgramChatCard
-          item={item}
-          chatRef={chatRef}
-          isNewTab={opts.isNewTab}
-          discuss={opts.discuss}
-          configKey={cfg.configKey}
-          label={cfg.configKey.charAt(0).toUpperCase() + cfg.configKey.slice(1)}
-          ogPlaceholder={opts?.extras?.buildOgPlaceholderUrl?.(item?.title ?? '') ?? null}
-        />
-      ),
-    }
-  }
-  return out
+  return registryEntries(PROGRAM_CARD_CONFIGS, (cfg) => ({
+    mode: 'fetch',
+    label: cfg.label,
+    contentRefType: cfg.contentRefType,
+    bareInline: true,
+    skeleton: () => <ProgramCardSkeleton size="sm" />,
+    render: (item, chatRef, opts) => (
+      <ProgramChatCard
+        item={item}
+        chatRef={chatRef}
+        isNewTab={opts.isNewTab}
+        discuss={opts.discuss}
+        configKey={cfg.configKey}
+        label={cfg.configKey.charAt(0).toUpperCase() + cfg.configKey.slice(1)}
+        ogPlaceholder={opts?.extras?.buildOgPlaceholderUrl?.(item?.title ?? '') ?? null}
+      />
+    ),
+  }))
 }
 
 type RoadmapCardType = 'roadmap_item' | 'delivery_item' | 'internal_task'
@@ -1135,27 +1135,23 @@ const ROADMAP_CARD_CONFIGS: Record<string, RoadmapEntryConfig> = {
   },
 }
 function roadmapRegistryEntries(): Record<string, ChatCardRegistryEntry> {
-  const out: Record<string, ChatCardRegistryEntry> = {}
-  for (const [docType, cfg] of Object.entries(ROADMAP_CARD_CONFIGS)) {
-    out[docType] = {
-      mode: 'fetch',
-      label: cfg.label,
-      contentRefType: cfg.contentRefType,
-      bareInline: true,
-      ...(cfg.noComposedHref ? { noComposedHref: true } : {}),
-      skeleton: () => <RoadmapCardSkeleton size="sm" />,
-      render: (item, chatRef, opts) => (
-        <RoadmapChatCard
-          item={item}
-          chatRef={chatRef}
-          isNewTab={opts.isNewTab}
-          discuss={opts.discuss}
-          cardType={cfg.cardType}
-        />
-      ),
-    }
-  }
-  return out
+  return registryEntries(ROADMAP_CARD_CONFIGS, (cfg) => ({
+    mode: 'fetch',
+    label: cfg.label,
+    contentRefType: cfg.contentRefType,
+    bareInline: true,
+    ...(cfg.noComposedHref ? { noComposedHref: true } : {}),
+    skeleton: () => <RoadmapCardSkeleton size="sm" />,
+    render: (item, chatRef, opts) => (
+      <RoadmapChatCard
+        item={item}
+        chatRef={chatRef}
+        isNewTab={opts.isNewTab}
+        discuss={opts.discuss}
+        cardType={cfg.cardType}
+      />
+    ),
+  }))
 }
 
 const CHAT_CARD_REGISTRY: Record<string, ChatCardRegistryEntry> = {
@@ -1668,6 +1664,23 @@ export function ChatCardLoader({
       {children}
     </ChatCardNavWrap>
   )
+  // ONE render tail for both modes — bare-inline cards skip the discuss
+  // wrapper; everything else gets the ChatCardWithDiscuss chrome. Kept
+  // here (not per-branch) so the two paths can never drift on the
+  // discuss-menu wiring.
+  const finish = (node: React.ReactNode) =>
+    entry.bareInline ? (
+      <>{navWrap(node)}</>
+    ) : (
+      <ChatCardWithDiscuss
+        chatRef={finalChatRef}
+        onDiscuss={onDiscuss}
+        onDisplay={onDisplay}
+        displayAction={entry.displayAction}
+      >
+        {navWrap(node)}
+      </ChatCardWithDiscuss>
+    )
   if (entry.mode === 'no-fetch') {
     // Synthetic-ref gate. `chat-message-enhanced.tsx` builds a minimal
     // `{ type, id, title: cardId, url: null }` ChatRef when the LLM
@@ -1690,19 +1703,7 @@ export function ChatCardLoader({
     // Fetch-mode types already handle this gracefully: a synthetic
     // id leads to a fetch miss → `!item` → null at line ~1034.
     if (!finalChatRef.sourceRepo) return null
-    if (entry.bareInline) {
-      return navWrap(entry.render(finalChatRef, renderOpts))
-    }
-    return (
-      <ChatCardWithDiscuss
-        chatRef={finalChatRef}
-        onDiscuss={onDiscuss}
-        onDisplay={onDisplay}
-        displayAction={entry.displayAction}
-      >
-        {navWrap(entry.render(finalChatRef, renderOpts))}
-      </ChatCardWithDiscuss>
-    )
+    return finish(entry.render(finalChatRef, renderOpts))
   }
   if (isLoading) return <>{entry.skeleton()}</>
   if (!item) {
@@ -1742,19 +1743,7 @@ export function ChatCardLoader({
     }
     return null
   }
-  if (entry.bareInline) {
-    return <>{navWrap(entry.render(item, finalChatRef, renderOpts))}</>
-  }
-  return (
-    <ChatCardWithDiscuss
-      chatRef={finalChatRef}
-      onDiscuss={onDiscuss}
-      onDisplay={onDisplay}
-      displayAction={entry.displayAction}
-    >
-      {navWrap(entry.render(item, finalChatRef, renderOpts))}
-    </ChatCardWithDiscuss>
-  )
+  return finish(entry.render(item, finalChatRef, renderOpts))
 }
 
 // =============================================================================

package/src/components/chat/hooks/use-sse-chat-adapter.ts

@@ -254,21 +254,21 @@ export function useSseChatAdapter(
 
   // Approve/reject pass the transport's boolean outcome through so batch
   // approve-all loops can mark a FAILED row (expired proposal, network
-  // error) instead of leaving its execution loader spinning.
-  const cardApprove = useCallback((reqId?: string): void | Promise<boolean> => {
-    if (!reqId) return
-    return sendMessageRef.current('', {
-      hidden: true,
-      approvalAction: { proposalId: reqId, action: 'approve' },
-    })
-  }, [])
-  const cardReject = useCallback((reqId?: string): void | Promise<boolean> => {
-    if (!reqId) return
-    return sendMessageRef.current('', {
-      hidden: true,
-      approvalAction: { proposalId: reqId, action: 'reject' },
-    })
-  }, [])
+  // error) instead of leaving its execution loader spinning. ONE factory
+  // — the two handlers differ only in the action literal.
+  const cardResolve = useCallback(
+    (action: 'approve' | 'reject') =>
+      (reqId?: string): void | Promise<boolean> => {
+        if (!reqId) return
+        return sendMessageRef.current('', {
+          hidden: true,
+          approvalAction: { proposalId: reqId, action },
+        })
+      },
+    [],
+  )
+  const cardApprove = useMemo(() => cardResolve('approve'), [cardResolve])
+  const cardReject = useMemo(() => cardResolve('reject'), [cardResolve])
 
   const createReducerOptions = useCallback(
     (): ChatStreamReducerOptions => ({

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

@@ -1978,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,28 +134,30 @@ export function appendToTrailingAssistant(
   return [...prev.slice(0, -1), { ...last, segments: merged }]
 }
 
+// =============================================================================
+// Segment-projection kernel — shared scaffolding + single-rule predicates
+// =============================================================================
+
 /**
- * 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.
+ * 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.
  */
-export function projectBatchStatusToMessages(
+function mapSegments(
   prev: UnifiedChatMessage[],
-  anchorId: string,
-  status: ChatApprovalStatus,
+  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) => {
-      if (s.type !== 'approval_batch') return s
-      if (s.data.approvalRequestId !== anchorId || s.status === status) return s
-      msgChanged = true
-      return { ...s, status }
+      const out = fn(s)
+      if (out !== s) msgChanged = true
+      return out
     })
     if (!msgChanged) return m
     changed = true
@@ -164,6 +166,107 @@ export function projectBatchStatusToMessages(
   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
@@ -174,36 +277,17 @@ export function projectBatchRowFailureToMessages(
   prev: UnifiedChatMessage[],
   rowRequestId: string,
 ): 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_batch' ||
-        !s.data.toolCalls?.some((c) => c.toolExecutionRequestId === rowRequestId)
-      ) {
-        return s
-      }
-      const existing = s.data.executions?.[rowRequestId]
-      if (existing?.status === 'done') return s
-      msgChanged = true
-      return {
-        ...s,
-        data: {
-          ...s.data,
-          executions: {
-            ...(s.data.executions ?? {}),
-            [rowRequestId]: { status: 'done' as const, success: false },
-          },
-        },
-      }
-    })
-    if (!msgChanged) return m
-    changed = true
-    return { ...m, segments: segs }
+  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 })
   })
-  return changed ? next : prev
 }
 
 /**
@@ -314,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
@@ -376,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[],
@@ -387,60 +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') {
-        const isAnchor = s.data.approvalRequestId === requestId
-        // Wire-native chat batches: each ROW is its own proposal
-        // (`toolExecutionRequestId` = proposalId) resolving through its
-        // own per-proposal confirm — a resolution for a row ticks that
-        // row's execution icon (check on approved, cross on rejected/
-        // failed) without touching the batch status (flipped
-        // optimistically at click time via
-        // `projectBatchStatusToMessages`). The anchor id is the
-        // server-minted `batch:<first proposalId>` — NEVER a row id
-        // (see ApprovalBatchFrame.batchId) — so `isAnchor` flips the
-        // batch status only.
-        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
-        }
-        msgChanged = true
-        return {
-          ...s,
-          status: nextStatus,
-          resolvedByName: nextResolvedBy,
-          data: {
-            ...s.data,
-            ...(nextExecutions ? { executions: nextExecutions } : {}),
-          },
-        }
-      }
-      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/utils/message-segment-accumulator.ts

@@ -23,6 +23,11 @@ import type {
   ChatApprovalStatus,
   ExecutingToolState,
 } from '../types'
+import {
+  applyApprovalStatusToSegment,
+  nextBatchExecution,
+  withBatchExecution,
+} from '../stream/message-mutations'
 
 export interface AccumulatorCallbacks {
   /** See `ApprovalResolutionHandler` (message.types) — the SSOT for the
@@ -247,25 +252,13 @@ export class MessageSegmentAccumulator {
       if (!hasCall) return seg
 
       const prev: ApprovalBatchExecutionState | undefined = seg.data.executions?.[execId]
-      // Never downgrade a done slot back to executing (redelivered EXECUTING
-      // after its EXECUTED already landed) — matched, but unchanged.
-      if (toolData.type === 'EXECUTING_TOOL' && prev?.status === 'done') {
-        matched = true
-        return seg
-      }
-      const next: ApprovalBatchExecutionState =
-        toolData.type === 'EXECUTED_TOOL'
-          ? { status: 'done', result: toolData.result, success: toolData.success }
-          : { status: 'executing', result: prev?.result, success: prev?.success }
-
+      // Shared rule (`nextBatchExecution` from message-mutations): the
+      // never-downgrade guard + EXECUTED/EXECUTING ternary — one
+      // implementation with the message-array projection.
+      const next = nextBatchExecution(prev, toolData)
       matched = true
-      return {
-        ...seg,
-        data: {
-          ...seg.data,
-          executions: { ...(seg.data.executions ?? {}), [execId]: next },
-        },
-      }
+      if (next === null) return seg
+      return withBatchExecution(seg, execId, next)
     })
     return matched
   }
@@ -432,15 +425,14 @@ export class MessageSegmentAccumulator {
    * resolved card shows "by {name}"; omit it to leave any existing value untouched.
    */
   updateApprovalStatus(requestId: string, status: ChatApprovalStatus, resolvedByName?: string | null): MessageSegment[] {
-    this.segments = this.segments.map(segment => {
-      if (segment.type === 'approval_request' && segment.data.requestId === requestId) {
-        return { ...segment, status }
-      }
-      if (segment.type === 'approval_batch' && segment.data.approvalRequestId === requestId) {
-        return { ...segment, status, resolvedByName: resolvedByName ?? segment.resolvedByName }
-      }
-      return segment
-    })
+    // ONE rule, two containers: `applyApprovalStatusToSegment` is the
+    // same predicate the message-array projection uses
+    // (`projectApprovalResolutionToMessages`) — anchor status flip AND
+    // batch-row execution tick, so this flat-list path can never drift
+    // from the projection again (it previously missed the row case).
+    this.segments = this.segments.map((segment) =>
+      applyApprovalStatusToSegment(segment, requestId, status, resolvedByName),
+    )
     return this.getSegments()
   }