@flamingo-stack/openframe-frontend-core 0.0.498-1506.4000.1 → 0.0.498

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

@@ -12,11 +12,11 @@
  *   ┌──────────────────────────────────────────────────────────────┐
  *   │ useNatsDialogSubscription   live tail of agent events        │
  *   │            ↓                                                 │
- *   │   onEvent → decodeNatsChunk → ChatStreamEvent                │
+ *   │   onEvent → processChunk                                     │
  *   │            ↓                                                 │
- *   │ createChatStreamReducer     THE master accumulation path     │
- *   │   (via ChatDialogStore + useChatStreamReducer wrapper —      │
- *   │    messages, phase, token usage, approvals all live there)   │
+ *   │ useRealtimeChunkProcessor   chunk → MessageSegment[]         │
+ *   │            ↓                                                 │
+ *   │   onSegmentsUpdate → updates assistant message in state      │
  *   │                                                              │
  *   │ useChunkCatchup             back-fill missed chunks after    │
  *   │                              activation / reconnect          │
@@ -24,38 +24,53 @@
  *   │ config.publishUserMessage   consumer-owned send (HTTP/NATS)  │
  *   └──────────────────────────────────────────────────────────────┘
  *
- * Phase 3 of the chat unification: the adapter's local message-mutation
- * layer (`updateTrailingAssistant` / `appendToTrailingAssistant` /
- * `upsertTrailingCompaction` / `applyToolExecutionToMessages` and the
- * chunk-callback body that drove them) is DELETED — those semantics live in
- * `../stream/chat-stream-reducer` + `../stream/message-mutations` now. The
- * adapter owns only what is genuinely transport/host wiring: dialog-list
- * management, history fetch, catchup orchestration, the NATS subscription,
- * and the publish path.
- *
  * Two operating modes, distinguished by the presence of `fetchDialogs`:
  *
  *   1. **Bare-transport mode** (current Tauri Fae Chat usage):
  *      consumer supplies `config.dialogId` explicitly and owns dialog
- *      management above the adapter.
+ *      management above the adapter. The adapter does no list/select
+ *      bookkeeping — every dialog field on the return value falls back
+ *      to an empty default. This is the original v0 API; preserved
+ *      byte-compatible so existing pinned consumers keep working.
  *
  *   2. **Managed-dialog mode** (openframe-frontend, EmbeddableChat
- *      sidebar): consumer supplies `fetchDialogs`, `fetchDialogMessages`,
- *      `createDialog`, etc. and the adapter owns the dialog state machine.
+ *      sidebar): consumer supplies `fetchDialogs`,
+ *      `fetchDialogMessages`, `createDialog`, etc. and the adapter
+ *      owns the dialog state machine. The active dialog id, the list,
+ *      pagination cursors, token usage hydration, and history merge
+ *      all live inside this hook. The host renders the sidebar via
+ *      `EmbeddableChat`'s built-in `<ChatSidebar>` slot and calls
+ *      `selectDialog` / `startNewDialog` from there.
+ *
+ * The two modes are NOT mutually exclusive — passing `config.dialogId`
+ * alongside `fetchDialogs` forces the adapter into controlled mode (the
+ * external id wins) while still using the host's list fetchers for the
+ * sidebar.
+ *
+ * Why publish is consumer-owned: the NATS module exposes a low-level
+ * `publishBytes/String/Json` but the actual user-message endpoint varies
+ * by deployment (REST POST in some, NATS subject in others). The adapter
+ * stays agnostic — caller wires up "user typed something, do X" via
+ * the `publishUserMessage` callback.
  *
  * The `active` option gates the live subscription so the unified chat
  * shell can keep both adapters mounted while only paying network cost
  * for the currently-displayed mode.
  */
 
-import { useCallback, useEffect, useMemo, useRef, useState } from 'react'
+import {
+  useCallback,
+  useEffect,
+  useMemo,
+  useRef,
+  useState,
+  type MutableRefObject,
+} from 'react'
 import { useNatsDialogSubscription } from './use-nats-dialog-subscription'
+import { useRealtimeChunkProcessor } from './use-realtime-chunk-processor'
 import { useChunkCatchup } from './use-chunk-catchup'
-import { decodeNatsChunk } from '../../../chat-protocol/nats-decoder'
-import { createChatDialogStore, DEFAULT_DIALOG_SIDE } from '../stream/chat-dialog-store'
-import { useChatStreamReducer } from '../stream/use-chat-stream-reducer'
 import { processHistoricalMessagesWithErrors } from '../utils/process-historical-messages'
-import { extractIncompleteTailState } from '../utils/extract-incomplete-message-state'
+import { extractIncompleteMessageState } from '../utils/extract-incomplete-message-state'
 import type {
   ChunkData,
   FetchChunksFunction,
@@ -63,7 +78,11 @@ import type {
   MessageProcessingOptions,
   MessageSegment,
   NatsMessageType,
+  StreamingPhase,
   ChatApprovalStatus,
+  SegmentsUpdateMetadata,
+  ToolExecutionSegment,
+  ApprovalBatchExecutionState,
 } from '../types'
 import type {
   ChatConnectionState,
@@ -75,16 +94,6 @@ import type {
 import type { DialogItem } from '../types/component.types'
 import type { ChatRef } from '../chat-ref.types'
 
-// Legacy public home of the pure message-mutation helpers ("exported for
-// host reuse"). Canonical implementation moved to the stream module in
-// Phase 3 — these re-exports keep the import path stable until Phase 4
-// migrates consumers.
-export {
-  appendToTrailingAssistant,
-  applyToolExecutionToMessages,
-  upsertTrailingCompaction,
-} from '../stream/message-mutations'
-
 // =============================================================================
 // Config + options
 // =============================================================================
@@ -201,19 +210,19 @@ export interface UseNatsChatAdapterConfig {
   topics?: NatsMessageType[]
 
   /**
-   * Mirrors the reducer's `batchApprovalsEnabled`. Default `true` —
-   * single batch card per APPROVAL_REQUEST with `toolCalls[]`. Set
-   * `false` to fall back to legacy per-tool cards.
+   * Mirrors `UseRealtimeChunkProcessorOptions.batchApprovalsEnabled`.
+   * Default `true` — single batch card per APPROVAL_REQUEST with
+   * `toolCalls[]`. Set `false` to fall back to legacy per-tool cards.
    */
   batchApprovalsEnabled?: boolean
 
   /**
-   * Approval types rendered as actionable cards inline. Mirrors the
-   * reducer's `displayApprovalTypes` (default `['CLIENT']`) and is
-   * forwarded to the history processor so both paths agree. Hosts whose
-   * backend emits other types (e.g. `USER`) MUST set this — otherwise
-   * those approvals are escalated to a callback this adapter doesn't
-   * surface and the card never renders.
+   * Approval types rendered as actionable cards inline. Mirrors
+   * `UseRealtimeChunkProcessorOptions.displayApprovalTypes` (default
+   * `['CLIENT']`) and is forwarded to the history processor so both paths
+   * agree. Hosts whose backend emits other types (e.g. `USER`) MUST set this
+   * — otherwise those approvals are escalated to a callback this adapter
+   * doesn't surface and the card never renders.
    */
   displayApprovalTypes?: string[]
 
@@ -236,7 +245,7 @@ export interface UseNatsChatAdapterConfig {
    * Messages must arrive in the same wire shape the openframe backend
    * emits (HistoricalMessage with messageData[]); the adapter feeds
    * them through `processHistoricalMessagesWithErrors` to produce
-   * reducer-compatible messages.
+   * accumulator-compatible segments.
    */
   fetchDialogMessages?: (
     params: FetchDialogMessagesParams,
@@ -274,9 +283,9 @@ export interface UseNatsChatAdapterConfig {
   unarchiveDialog?: (dialogId: string) => Promise<void>
 
   /**
-   * Approve a pending tool-call request. Wired into the reducer's
-   * approval-card callbacks so card buttons fire this directly. When
-   * omitted, approval cards render disabled buttons.
+   * Approve a pending tool-call request. Wired into the segment
+   * accumulator's `onApprove` so approval-card buttons fire this
+   * directly. When omitted, approval cards render disabled buttons.
    */
   approveRequest?: (requestId: string) => Promise<void>
 
@@ -335,9 +344,264 @@ export interface UseNatsChatAdapterOptions {
 }
 
 // =============================================================================
-// Historical-message mapping helpers (host-facing)
+// Internal helpers
 // =============================================================================
 
+function nextId(role: 'user' | 'assistant'): string {
+  // Date.now() + counter sliver keeps ids monotonic even when two
+  // messages are produced inside the same ms tick (user + assistant
+  // placeholder fire back-to-back from a single sendMessage call).
+  return `${role}-${Date.now()}-${Math.random().toString(36).slice(2, 7)}`
+}
+
+/**
+ * Replace (or append) the trailing assistant message with the latest
+ * accumulated segments. Mirrors the use-chat.ts pattern so render
+ * behaviour matches the SSE adapter exactly.
+ */
+function updateTrailingAssistant(
+  prev: UnifiedChatMessage[],
+  segments: MessageSegment[],
+): UnifiedChatMessage[] {
+  const last = prev[prev.length - 1]
+  if (!last || last.role !== 'assistant') {
+    // No placeholder exists — append a fresh assistant message.
+    return [
+      ...prev,
+      {
+        id: nextId('assistant'),
+        role: 'assistant',
+        content: '',
+        segments,
+      },
+    ]
+  }
+  return [
+    ...prev.slice(0, -1),
+    { ...last, segments },
+  ]
+}
+
+/**
+ * Realtime user/direct/system chunks can be replays of rows already on
+ * screen (our own optimistic send echoed back, catchup replaying the tail
+ * over just-loaded history, reconnect back-fill).
+ *
+ * Dedup layers, in priority order:
+ *  1. `streamSeq` identity (JetStream) — exact, never confuses a genuinely
+ *     repeated text with a replay; tracked in a per-dialog seen-set.
+ *  2. One-shot optimistic-echo consumption — `sendMessage` records the text
+ *     it optimistically rendered; the backend's MESSAGE_REQUEST echo removes
+ *     exactly one entry.
+ *  3. Content match over a SHORT same-author tail window — only for
+ *     seq-less transports (plain NATS replay over just-loaded history, where
+ *     the persisted twin sits at most a couple of rows up). Same-author so
+ *     an admin message can never suppress a user's identical text.
+ */
+const CONTENT_DEDUP_WINDOW = 4
+const SYSTEM_DEDUP_WINDOW = 10
+
+function hasRecentMessage(
+  prev: UnifiedChatMessage[],
+  predicate: (message: UnifiedChatMessage) => boolean,
+  window: number,
+): boolean {
+  const start = Math.max(0, prev.length - window)
+  for (let i = prev.length - 1; i >= start; i--) {
+    if (predicate(prev[i])) return true
+  }
+  return false
+}
+
+/**
+ * Append-mode counterpart of `updateTrailingAssistant` for post-MESSAGE_END
+ * continuation chunks (`SegmentsUpdateMetadata.append`). The processor emits
+ * single text/thinking fragments there — replacing the bubble with them (the
+ * old behaviour, which dropped the metadata) wiped everything the bubble
+ * already showed. Coalesces trailing fragments of the same type, mirroring
+ * the accumulator.
+ *
+ * Exported for host reuse (custom stores wiring the same processor) + tests.
+ */
+export function appendToTrailingAssistant(
+  prev: UnifiedChatMessage[],
+  segments: MessageSegment[],
+): UnifiedChatMessage[] {
+  if (segments.length === 0) return prev
+  const last = prev[prev.length - 1]
+  if (!last || last.role !== 'assistant') {
+    return [
+      ...prev,
+      { id: nextId('assistant'), role: 'assistant', content: '', segments },
+    ]
+  }
+  const merged = [...(last.segments ?? [])]
+  for (const seg of segments) {
+    const tail = merged[merged.length - 1]
+    if (seg.type === 'text' && tail?.type === 'text') {
+      merged[merged.length - 1] = { type: 'text', text: tail.text + seg.text }
+    } else if (seg.type === 'thinking' && tail?.type === 'thinking') {
+      merged[merged.length - 1] = { type: 'thinking', text: tail.text + seg.text }
+    } else if (seg.type === 'guide' && tail?.type === 'guide') {
+      merged[merged.length - 1] = { type: 'guide', text: tail.text + seg.text }
+    } else if (seg.type === 'approval_batch') {
+      // Approval deltas must be IDEMPOTENT: the escalated-result emit can be
+      // seen twice (live + catch-up replay over hydrated history), so upsert
+      // by request id instead of raw-appending a duplicate card.
+      const idx = merged.findIndex(
+        (m) => m.type === 'approval_batch' && m.data.approvalRequestId === seg.data.approvalRequestId,
+      )
+      if (idx !== -1) merged[idx] = seg
+      else merged.push(seg)
+    } else if (seg.type === 'approval_request') {
+      // Legacy cards share one requestId across an unfolded batch — key on
+      // (requestId, command) so each tool's card upserts its own twin.
+      const idx = merged.findIndex(
+        (m) =>
+          m.type === 'approval_request' &&
+          m.data.requestId === seg.data.requestId &&
+          m.data.command === seg.data.command,
+      )
+      if (idx !== -1) merged[idx] = seg
+      else merged.push(seg)
+    } else {
+      // Other non-text segments are pushed RAW on purpose: EXECUTING↔EXECUTED
+      // pairing and batch merging are `applyToolExecutionToMessages`'s job
+      // (post-END tool chunks never reach this helper — the processor routes
+      // them to onToolExecuted). Running the accumulator here would
+      // double-apply those rules.
+      merged.push(seg)
+    }
+  }
+  return [...prev.slice(0, -1), { ...last, segments: merged }]
+}
+
+/**
+ * Upsert a standalone context-compaction segment into the trailing assistant
+ * bubble. Compaction emissions arrive as the accumulator's CUMULATIVE array —
+ * only the compaction segment itself may be applied, or interleaved
+ * continuation text would duplicate. A `completed` segment replaces the last
+ * `started` one in place.
+ *
+ * Exported for host reuse + tests.
+ */
+export function upsertTrailingCompaction(
+  prev: UnifiedChatMessage[],
+  segments: MessageSegment[],
+): UnifiedChatMessage[] {
+  const compaction = [...segments].reverse().find((s) => s.type === 'context_compaction')
+  if (!compaction) return prev
+  const last = prev[prev.length - 1]
+  if (!last || last.role !== 'assistant') {
+    return [
+      ...prev,
+      { id: nextId('assistant'), role: 'assistant', content: '', segments: [compaction] },
+    ]
+  }
+  const existing = last.segments ?? []
+  // LAST 'started' segment (not first): with repeated compactions in one
+  // bubble the earlier ones are already completed-in-place, so the newest
+  // 'started' is the only one this completion can belong to.
+  const startedIdx = existing.map((s) => s.type === 'context_compaction' && s.status === 'started').lastIndexOf(true)
+  const merged =
+    startedIdx !== -1
+      ? existing.map((s, i) => (i === startedIdx ? compaction : s))
+      : [...existing, compaction]
+  return [...prev.slice(0, -1), { ...last, segments: merged }]
+}
+
+/**
+ * Cross-message tool-execution updater for post-MESSAGE_END tool chunks
+ * (approved commands executing after the approval bubble, async batch
+ * results). Scans messages from the end:
+ *  1) an `approval_batch` whose `toolCalls` contains the execution id →
+ *     merge into its `executions` map;
+ *  2) a matching `tool_execution` segment (same id, or EXECUTING with the
+ *     same tool for legacy id-less backends) → update in place;
+ *  3) no match → append the segment to the trailing assistant bubble.
+ *
+ * Exported for host reuse + tests.
+ */
+export function applyToolExecutionToMessages(
+  prev: UnifiedChatMessage[],
+  segment: ToolExecutionSegment,
+): UnifiedChatMessage[] {
+  const toolData = segment.data
+  const execId = toolData.toolExecutionRequestId
+
+  for (let i = prev.length - 1; i >= 0; i--) {
+    const message = prev[i]
+    if (message.role !== 'assistant' || !message.segments) continue
+
+    for (let j = message.segments.length - 1; j >= 0; j--) {
+      const seg = message.segments[j]
+
+      if (
+        execId &&
+        seg.type === 'approval_batch' &&
+        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 }
+        const nextSegments = [...message.segments]
+        nextSegments[j] = {
+          ...seg,
+          data: { ...seg.data, executions: { ...(seg.data.executions ?? {}), [execId]: nextExec } },
+        }
+        const next = [...prev]
+        next[i] = { ...message, segments: nextSegments }
+        return next
+      }
+
+      if (seg.type === 'tool_execution') {
+        // KNOWN LIMIT (id-less chunks only — current backends always send
+        // toolExecutionRequestId): the fuzzy fallback pairs only with a
+        // segment still EXECUTING, so a replayed id-less EXECUTING/EXECUTED
+        // arriving after the pair completed matches nothing and falls to the
+        // append below (duplicate card). Widening the predicate to EXECUTED
+        // twins would instead swallow a LEGITIMATE second run of the same
+        // tool — without ids the two are indistinguishable, and losing a
+        // real run is worse than a duplicate card on a legacy transport.
+        const matches = execId
+          ? seg.data.toolExecutionRequestId === execId
+          : seg.data.type === 'EXECUTING_TOOL' &&
+            seg.data.integratedToolType === toolData.integratedToolType &&
+            seg.data.toolFunction === toolData.toolFunction
+        if (!matches) continue
+        // Never downgrade a completed segment back to EXECUTING (replayed
+        // EXECUTING chunk after its EXECUTED already landed).
+        if (toolData.type === 'EXECUTING_TOOL' && seg.data.type === 'EXECUTED_TOOL') {
+          return prev
+        }
+        const nextSegments = [...message.segments]
+        nextSegments[j] = {
+          type: 'tool_execution',
+          data: {
+            ...toolData,
+            toolTitle: toolData.toolTitle ?? seg.data.toolTitle,
+            toolExplanation: toolData.toolExplanation ?? seg.data.toolExplanation,
+            parameters: toolData.parameters || seg.data.parameters,
+          },
+        }
+        const next = [...prev]
+        next[i] = { ...message, segments: nextSegments }
+        return next
+      }
+    }
+  }
+
+  return appendToTrailingAssistant(prev, [segment])
+}
+
 /**
  * Map `ProcessedMessage` (lib's historical-message format) into
  * `UnifiedChatMessage` (the unified-chat-state contract). Only `user`
@@ -407,9 +671,6 @@ export function historicalToUnified(
 // Hook
 // =============================================================================
 
-/** Store key for the draft ("no dialog selected") state. */
-const DRAFT_DIALOG_KEY = '__draft__'
-
 export function useNatsChatAdapter(
   config: UseNatsChatAdapterConfig,
   options: UseNatsChatAdapterOptions = {},
@@ -465,109 +726,56 @@ export function useNatsChatAdapter(
   const currentDialogIdRef = useRef<string | null>(dialogId)
   currentDialogIdRef.current = dialogId
 
-  // ─── Approval handlers ────────────────────────────────────────────────────
-  // Defined before the reducer so the reducer's create-options can wire the
-  // approval-card buttons. Optimistically flip status before the network
-  // round-trip so the card reflects the user's choice immediately.
-
-  const handleApproveRef = useRef<(requestId: string) => Promise<void>>(async () => {})
-  const handleRejectRef = useRef<(requestId: string, reason?: string) => Promise<void>>(
-    async () => {},
-  )
-
-  // Reducer-card adapters. The card contract is `(requestId?) => void |
-  // Promise<void>` — single optional arg; narrow at the boundary.
-  const accumApprove = useCallback((requestId?: string): void | Promise<void> => {
-    if (!requestId) return
-    return handleApproveRef.current(requestId)
-  }, [])
-  const accumReject = useCallback((requestId?: string): void | Promise<void> => {
-    if (!requestId) return
-    return handleRejectRef.current(requestId)
-  }, [])
+  // ─── Message thread + streaming phase ─────────────────────────────────────
+
+  const [messages, setMessages] = useState<UnifiedChatMessage[]>([])
+  const [streamingPhase, setStreamingPhase] = useState<StreamingPhase>('idle')
+  // Live mirror for click handlers that must read the CURRENT phase without
+  // re-creating on every phase change (handleApprove's scoped revert).
+  const streamingPhaseRef = useRef(streamingPhase)
+  streamingPhaseRef.current = streamingPhase
+  // Gate: suppress onAgentBusy while the initial catchup replays historical
+  // chunks. A dead tail (approval approved / tool started, then Stop or a
+  // crash — no continuation ever persisted) replays its APPROVAL_RESULT /
+  // EXECUTING_TOOL chunks on every dialog (re)open, and the releasing
+  // MESSAGE_END never replays — locking the composer forever. Live chunks
+  // after catchup lock normally; a reopened mid-execution dialog re-locks on
+  // the next live chunk instead.
+  // A COUNTER, not a boolean: the initial-catchup window and a reconnect
+  // back-fill window can overlap (reconnect during the initial fetch), and
+  // with a boolean whichever finished FIRST dropped the other's suppression
+  // mid-replay. Each window increments on entry / decrements in its finally.
+  const suppressAgentBusyRef = useRef(0)
+
+  // True when the trailing assistant loaded from history is an INCOMPLETE
+  // turn (mid-stream / mid-approval tail). The catchup replay re-streams that
+  // turn from its MESSAGE_START, and the replayed stream must ADOPT (replace)
+  // the partial history bubble. Any other MESSAGE_START over a non-empty
+  // trailing assistant is a NEW turn (observer / second device / post-approval
+  // continuation) and must open a fresh bubble instead of overwriting the
+  // completed one. Consumed (reset) by the first MESSAGE_START.
+  const adoptTrailingAssistantRef = useRef(false)
 
-  // ─── THE reducer (master stream reader) ───────────────────────────────────
-  // One `ChatDialogStore` per adapter instance; one reducer per dialog.
-  // Approval statuses are request-id-keyed and GLOBAL across dialogs (a
-  // resolved approval must not resurrect as actionable after a dialog
-  // switch), so the adapter accumulates them into a ref that seeds every
-  // newly-created per-dialog reducer.
-
-  const storeRef = useRef(createChatDialogStore())
-  const globalApprovalStatusesRef = useRef<Record<string, ChatApprovalStatus>>({})
-  const dialogKey = dialogId ?? DRAFT_DIALOG_KEY
-
-  const { state, applyEvent, mutate } = useChatStreamReducer({
-    store: storeRef.current,
-    dialogId: dialogKey,
-    createReducerOptions: () => ({
-      transport: 'nats',
-      batchApprovalsEnabled,
-      ...(displayApprovalTypes ? { displayApprovalTypes } : {}),
-      approvalStatuses: globalApprovalStatusesRef.current,
-      callbacks: { onApprove: accumApprove, onReject: accumReject },
-    }),
-  })
-
-  // Accumulate resolved statuses globally (render-time merge is cheap and
-  // keeps the ref current for the next dialog's reducer seed).
-  globalApprovalStatusesRef.current = {
-    ...globalApprovalStatusesRef.current,
-    ...state.approvalStatuses,
-  }
-
-  // Live handleApprove/handleReject bodies (need `mutate` + state access).
-  handleApproveRef.current = async (requestId: string) => {
-    if (!approveRequestCallback) return
-    // Approval hands the turn back to the agent — lock the composer now
-    // rather than waiting for the APPROVAL_RESULT/EXECUTING_TOOL chunks.
-    // Remember whether THIS click took the lock: if the phase was already
-    // busy (another approval's command executing), a failure of this
-    // request must not release a lock it doesn't own.
-    const store = storeRef.current
-    const key = dialogKey
-    const tookLock = store.mutate(key, DEFAULT_DIALOG_SIDE, (r) => {
-      const took = r.state.streamingPhase === 'idle'
-      r.setApprovalStatus(requestId, 'approved')
-      if (took) r.setPhase('thinking')
-      return took
-    })
-    try {
-      await approveRequestCallback(requestId)
-    } catch (err) {
-      // Revert the optimistic flip on failure so the user can retry.
-      store.mutate(key, DEFAULT_DIALOG_SIDE, (r) => {
-        r.setApprovalStatus(requestId, null)
-        if (tookLock && r.state.streamingPhase === 'thinking') r.setPhase('idle')
-      })
-      console.error('[useNatsChatAdapter] approveRequest failed:', err)
-    }
-  }
-  handleRejectRef.current = async (requestId: string, reason?: string) => {
-    if (!rejectRequestCallback) return
-    // Deliberately NO phase lock here (asymmetric with approve): rejection
-    // keeps the composer free so the user can type a correction right away —
-    // the reducer's `approved`-only agent-busy gate is the same asymmetry.
-    const store = storeRef.current
-    const key = dialogKey
-    store.mutate(key, DEFAULT_DIALOG_SIDE, (r) => r.setApprovalStatus(requestId, 'rejected'))
-    try {
-      await rejectRequestCallback(requestId, reason)
-    } catch (err) {
-      store.mutate(key, DEFAULT_DIALOG_SIDE, (r) => r.setApprovalStatus(requestId, null))
-      console.error('[useNatsChatAdapter] rejectRequest failed:', err)
-    }
-  }
+  // Set after the first successful NATS connect. Later 'connected' events are
+  // RECONNECTS: plain NATS replays nothing, so the adapter must back-fill the
+  // disconnect gap via `resetAndCatchUp` or those chunks are lost forever.
+  const hasConnectedOnceRef = useRef(false)
 
-  // Decode + apply — the ONLY chunk entry point (catchup routes the live
-  // tail through here too, so buffering/dedupe stay consistent).
-  const processChunk = useCallback(
-    (chunk: unknown) => {
-      const event = decodeNatsChunk(chunk)
-      if (event) applyEvent(event)
-    },
-    [applyEvent],
-  )
+  // Exact-identity dedup for participant chunks (user/direct/system): the
+  // JetStream streamSeq of every rendered participant row. Cleared per
+  // dialog. See the dedup-layers note above `hasRecentMessage`.
+  const seenParticipantSeqsRef = useRef<Set<number>>(new Set())
+  // Texts `sendMessage` rendered optimistically and whose MESSAGE_REQUEST
+  // echo hasn't come back yet — the echo consumes exactly ONE entry, so a
+  // genuinely repeated send ("yes", "yes") still renders twice.
+  const pendingEchoTextsRef = useRef<string[]>([])
+
+  // Approval status map. Used both to dedupe pending segments at render
+  // time and to feed `processHistoricalMessagesWithErrors` so previously
+  // resolved approvals don't re-render as actionable on dialog switch.
+  const [approvalStatuses, setApprovalStatuses] = useState<
+    Record<string, ChatApprovalStatus>
+  >({})
 
   // ─── Dialog list state (managed-dialog mode only) ─────────────────────────
 
@@ -582,15 +790,383 @@ export function useNatsChatAdapter(
   const [messagesNextCursor, setMessagesNextCursor] = useState<string | null>(null)
   const [isMessagesLoading, setIsMessagesLoading] = useState<boolean>(false)
 
+  // ─── Token usage (Mingo per-dialog cumulative) ────────────────────────────
+
+  const [dialogTokenUsage, setDialogTokenUsage] = useState<DialogTokenUsage | null>(
+    null,
+  )
+
+  // ─── Live model metadata (from streaming `metadata` frames) ───────────────
+  // Refines the composer's model badge per-turn. Falls back to the config
+  // baseline (`modelProvider`/`modelLabel`) until the first frame lands.
+  const [liveModel, setLiveModel] = useState<{
+    provider: string | null
+    modelLabel: string | null
+    contextWindowMaxTokens: number | null
+  } | null>(null)
+
   // ─── Connection state ─────────────────────────────────────────────────────
 
   const [connectionState, setConnectionState] =
     useState<ChatConnectionState>('connecting')
 
-  // Set after the first successful NATS connect. Later 'connected' events are
-  // RECONNECTS: plain NATS replays nothing, so the adapter must back-fill the
-  // disconnect gap via `resetAndCatchUp` or those chunks are lost forever.
-  const hasConnectedOnceRef = useRef(false)
+  // ─── Approval handlers ────────────────────────────────────────────────────
+  // Optimistically flip status before the network round-trip so the
+  // accumulator's render reflects the user's choice immediately.
+
+  const handleApprove = useCallback(
+    async (requestId: string) => {
+      if (!approveRequestCallback) return
+      setApprovalStatuses((prev) => ({ ...prev, [requestId]: 'approved' }))
+      // Approval hands the turn back to the agent — lock the composer now
+      // rather than waiting for the APPROVAL_RESULT/EXECUTING_TOOL chunks.
+      // Remember whether THIS click took the lock: if the phase was already
+      // busy (another approval's command executing), a failure of this
+      // request must not release a lock it doesn't own.
+      const tookLock = streamingPhaseRef.current === 'idle'
+      setStreamingPhase((p) => (p === 'idle' ? 'thinking' : p))
+      try {
+        await approveRequestCallback(requestId)
+      } catch (err) {
+        // Revert the optimistic flip on failure so the user can retry.
+        setApprovalStatuses((prev) => {
+          const next = { ...prev }
+          delete next[requestId]
+          return next
+        })
+        if (tookLock) {
+          setStreamingPhase((p) => (p === 'thinking' ? 'idle' : p))
+        }
+        console.error('[useNatsChatAdapter] approveRequest failed:', err)
+      }
+    },
+    [approveRequestCallback],
+  )
+
+  const handleReject = useCallback(
+    async (requestId: string, reason?: string) => {
+      if (!rejectRequestCallback) return
+      // Deliberately NO phase lock here (asymmetric with handleApprove):
+      // rejection keeps the composer free so the user can type a correction
+      // right away — see the matching `approved`-only onAgentBusy guard in
+      // use-realtime-chunk-processor's approval_result case. If the agent
+      // does stream an acknowledgment, MESSAGE_START locks the composer then.
+      setApprovalStatuses((prev) => ({ ...prev, [requestId]: 'rejected' }))
+      try {
+        await rejectRequestCallback(requestId, reason)
+      } catch (err) {
+        setApprovalStatuses((prev) => {
+          const next = { ...prev }
+          delete next[requestId]
+          return next
+        })
+        console.error('[useNatsChatAdapter] rejectRequest failed:', err)
+      }
+    },
+    [rejectRequestCallback],
+  )
+
+  // Stable refs so the accumulator's callbacks don't churn on re-render.
+  const handleApproveRef = useRef(handleApprove)
+  handleApproveRef.current = handleApprove
+  const handleRejectRef = useRef(handleReject)
+  handleRejectRef.current = handleReject
+
+  // Accumulator-compatible adapters. The lib's accumulator contract is
+  // `(requestId?: string) => void | Promise<void>` — single optional arg,
+  // no rejection reason. Our public API surface widens that to require a
+  // string + accept a reason, so we narrow here at the boundary. Reason
+  // is unavailable from button-click callers (the accumulator doesn't
+  // pass it) so we only forward the requestId; consumers that need
+  // structured reject reasons can call `rejectRequest` directly.
+  const accumApprove = useCallback((requestId?: string): void | Promise<void> => {
+    if (!requestId) return
+    return handleApproveRef.current(requestId)
+  }, [])
+  const accumReject = useCallback((requestId?: string): void | Promise<void> => {
+    if (!requestId) return
+    return handleRejectRef.current(requestId)
+  }, [])
+
+  // Stable callback ref so `useRealtimeChunkProcessor`'s options object
+  // doesn't churn every render and tear down the accumulator state.
+  const callbacksRef: MutableRefObject<{
+    onSegmentsUpdate: (segments: MessageSegment[], meta?: SegmentsUpdateMetadata) => void
+    onStreamStart: () => void
+    onStreamEnd: () => void
+    onAgentBusy: () => void
+    onError: () => void
+    onTokenUsage: (data: DialogTokenUsage) => void
+    onMetadata: (meta: {
+      modelDisplayName?: string
+      modelName: string
+      providerName: string
+      contextWindow: number
+    }) => void
+    onToolExecuted: (segment: ToolExecutionSegment) => void
+    onApprovalResolved: (
+      requestId: string,
+      status: ChatApprovalStatus,
+      approvalType: string,
+      resolvedByName?: string | null,
+    ) => void
+    onUserMessage: (
+      text: string,
+      meta?: { ownerType?: string; displayName?: string; userId?: string; streamSeq?: number; contextItems?: Array<{ type: string; id: string }> },
+    ) => void
+    onDirectMessage: (
+      text: string,
+      meta?: { ownerType?: string; displayName?: string; userId?: string; streamSeq?: number },
+    ) => void
+    onSystemMessage: (text: string, meta?: { streamSeq?: number }) => void
+  }> = useRef({
+    onSegmentsUpdate: (segments: MessageSegment[], meta?: SegmentsUpdateMetadata) => {
+      // Standalone compaction updates carry the accumulator's cumulative
+      // array — apply only the compaction segment (upsert) or interleaved
+      // continuation text would duplicate.
+      if (meta?.append && meta.isCompacting) {
+        setMessages((prev) => upsertTrailingCompaction(prev, segments))
+        return
+      }
+      // Post-MESSAGE_END continuation fragments append into the existing
+      // bubble; replacing (the pre-fix behaviour, which dropped `meta`)
+      // wiped the completed reply and left only the newest fragment.
+      if (meta?.append) {
+        setMessages((prev) => appendToTrailingAssistant(prev, segments))
+        return
+      }
+      setMessages((prev) => updateTrailingAssistant(prev, segments))
+    },
+    onStreamStart: () => {
+      setStreamingPhase('streaming')
+      // A new stream must never overwrite a COMPLETED trailing assistant
+      // bubble (observer tab / second device / post-approval continuation
+      // turn). Open a fresh bubble unless the trailing assistant is empty
+      // (our own optimistic placeholder) or is the incomplete history tail
+      // the catchup replay is legitimately re-streaming (adopt-once flag).
+      const adoptTail = adoptTrailingAssistantRef.current
+      adoptTrailingAssistantRef.current = false
+      setMessages((prev) => {
+        const last = prev[prev.length - 1]
+        if (!last || last.role !== 'assistant' || adoptTail) return prev
+        const hasContent = (last.segments?.length ?? 0) > 0 || last.content !== ''
+        if (!hasContent) return prev
+        return [
+          ...prev,
+          { id: nextId('assistant'), role: 'assistant', content: '', segments: [] },
+        ]
+      })
+    },
+    onStreamEnd: () => setStreamingPhase('idle'),
+    // Agent is executing (approved) commands outside an open stream — keep
+    // the composer locked exactly like the in-stream phases. An open stream
+    // keeps ownership: only 'idle' upgrades to 'thinking'. Suppressed during
+    // initial catchup so a replayed dead tail can't lock a finished dialog.
+    onAgentBusy: () => {
+      if (suppressAgentBusyRef.current > 0) return
+      setStreamingPhase((p) => (p === 'idle' ? 'thinking' : p))
+    },
+    // Terminal turn failures can arrive without a MESSAGE_END; unlock the
+    // composer unless an open stream still owns the phase (in-stream errors
+    // are followed by the stream's own MESSAGE_END).
+    onError: () => setStreamingPhase((p) => (p === 'streaming' ? p : 'idle')),
+    // Live cumulative token counter for the active dialog — drives the
+    // composer's "X / Y tokens used" tail as the assistant streams.
+    onTokenUsage: (data: DialogTokenUsage) => setDialogTokenUsage(data),
+    // Per-turn model badge (provider/label/context window).
+    onMetadata: (meta) =>
+      setLiveModel({
+        provider: meta.providerName || null,
+        modelLabel: meta.modelDisplayName || meta.modelName || null,
+        contextWindowMaxTokens: meta.contextWindow || null,
+      }),
+    // Post-MESSAGE_END tool chunks (approved commands executing after the
+    // approval bubble, async batch results). Routed through the cross-message
+    // updater — the accumulator was reset at MESSAGE_END, so the old
+    // fallthrough replaced the whole trailing bubble with one tool segment.
+    onToolExecuted: (segment: ToolExecutionSegment) => {
+      setMessages((prev) => applyToolExecutionToMessages(prev, segment))
+    },
+    // Cross-message approval status flip. Wiring this also makes the
+    // processor skip its cumulative re-emit for resolved approvals — which,
+    // post-MESSAGE_END, was an empty array that blanked the trailing bubble.
+    onApprovalResolved: (requestId, status, _approvalType, resolvedByName) => {
+      setMessages((prev) => {
+        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
+      })
+      // Mirror into the status map so history re-processing (dialog reopen,
+      // pagination) renders the card resolved instead of actionable.
+      setApprovalStatuses((prev) =>
+        prev[requestId] === status ? prev : { ...prev, [requestId]: status },
+      )
+    },
+    // MESSAGE_REQUEST echo — a user message from THIS or another session.
+    onUserMessage: (text, meta) => {
+      if (!text) return
+      // Layer 1 FIRST: exact event identity. A seq we've handled is a
+      // replay; a fresh seq is appended with NO content matching, so
+      // genuinely repeated texts from other participants always render.
+      // Must run (and RECORD) before the echo consume below — the echo
+      // branch early-returns, and skipping the record there let an
+      // at-least-once redelivery of the same event pass as fresh (and eat
+      // a second pending echo entry).
+      const seq = meta?.streamSeq
+      if (typeof seq === 'number') {
+        if (seenParticipantSeqsRef.current.has(seq)) return
+        seenParticipantSeqsRef.current.add(seq)
+      }
+      // Layer 2: our own optimistic echo — consume exactly one recorded send.
+      if (meta?.ownerType !== 'ADMIN') {
+        const echoIdx = pendingEchoTextsRef.current.indexOf(text)
+        if (echoIdx !== -1) {
+          pendingEchoTextsRef.current.splice(echoIdx, 1)
+          return
+        }
+      }
+      const authorType = meta?.ownerType === 'ADMIN' ? 'admin' : 'user'
+      setMessages((prev) => {
+        // Layer 3: seq-less transports only — same-author content twin in the
+        // immediate tail (replay over just-loaded history).
+        if (
+          typeof seq !== 'number' &&
+          hasRecentMessage(
+            prev,
+            (m) => m.role === 'user' && (m.authorType ?? 'user') === authorType && m.content === text,
+            CONTENT_DEDUP_WINDOW,
+          )
+        ) {
+          return prev
+        }
+        return [
+          ...prev,
+          {
+            id: nextId('user'),
+            role: 'user',
+            content: text,
+            ...(meta?.displayName ? { name: meta.displayName } : {}),
+            authorType,
+            ...(meta?.contextItems && meta.contextItems.length > 0
+              ? {
+                  contextItems: meta.contextItems.map((ci) => ({
+                    type: ci.type,
+                    id: ci.id,
+                    label: (ci as { label?: string }).label ?? ci.id,
+                  })),
+                }
+              : {}),
+          },
+        ]
+      })
+    },
+    // Technician / admin direct message into the dialog.
+    onDirectMessage: (text, meta) => {
+      if (!text) return
+      const seq = meta?.streamSeq
+      if (typeof seq === 'number') {
+        if (seenParticipantSeqsRef.current.has(seq)) return
+        seenParticipantSeqsRef.current.add(seq)
+      }
+      setMessages((prev) => {
+        // Seq-less fallback matches only prior ADMIN-authored twins — a
+        // client's identical text must never suppress the technician's.
+        if (
+          typeof seq !== 'number' &&
+          hasRecentMessage(
+            prev,
+            (m) => m.role === 'user' && m.authorType === 'admin' && m.content === text,
+            CONTENT_DEDUP_WINDOW,
+          )
+        ) {
+          return prev
+        }
+        return [
+          ...prev,
+          {
+            id: `direct-${Date.now()}-${Math.random().toString(36).slice(2, 7)}`,
+            role: 'user',
+            content: text,
+            name: meta?.displayName ?? 'Admin',
+            authorType: 'admin',
+          },
+        ]
+      })
+    },
+    // System notice — rendered as a name-only row (same shape the history
+    // processor produces via `pushStandaloneMessages`).
+    onSystemMessage: (text, meta) => {
+      if (!text) return
+      const seq = meta?.streamSeq
+      if (typeof seq === 'number') {
+        if (seenParticipantSeqsRef.current.has(seq)) return
+        seenParticipantSeqsRef.current.add(seq)
+      }
+      setMessages((prev) => {
+        if (
+          typeof seq !== 'number' &&
+          hasRecentMessage(prev, (m) => m.authorType === 'system' && m.name === text, SYSTEM_DEDUP_WINDOW)
+        ) {
+          return prev
+        }
+        return [
+          ...prev,
+          {
+            id: `system-${Date.now()}-${Math.random().toString(36).slice(2, 7)}`,
+            role: 'user',
+            content: '',
+            name: text,
+            authorType: 'system',
+          },
+        ]
+      })
+    },
+  })
+
+  // Real-time chunk → segment processor. Approval handlers route through
+  // the refs so a config change (e.g. callback identity churn from the
+  // host) doesn't tear down the accumulator.
+  const { processChunk, reset: resetAccumulator } = useRealtimeChunkProcessor({
+    callbacks: {
+      onSegmentsUpdate: (segments, meta) => callbacksRef.current.onSegmentsUpdate(segments, meta),
+      onStreamStart: () => callbacksRef.current.onStreamStart(),
+      onStreamEnd: () => callbacksRef.current.onStreamEnd(),
+      onAgentBusy: () => callbacksRef.current.onAgentBusy(),
+      onError: () => callbacksRef.current.onError(),
+      onTokenUsage: (data) => callbacksRef.current.onTokenUsage(data),
+      onMetadata: (meta) => callbacksRef.current.onMetadata(meta),
+      onToolExecuted: (segment) => callbacksRef.current.onToolExecuted(segment),
+      onApprovalResolved: (requestId, status, approvalType, resolvedByName) =>
+        callbacksRef.current.onApprovalResolved(requestId, status, approvalType, resolvedByName),
+      onUserMessage: (text, meta) => callbacksRef.current.onUserMessage(text, meta),
+      onDirectMessage: (text, meta) => callbacksRef.current.onDirectMessage(text, meta),
+      onSystemMessage: (text, meta) => callbacksRef.current.onSystemMessage(text, meta),
+      onApprove: accumApprove,
+      onReject: accumReject,
+    },
+    batchApprovalsEnabled,
+    approvalStatuses,
+    ...(displayApprovalTypes ? { displayApprovalTypes } : {}),
+  })
 
   // History catchup — back-fills chunks emitted while the adapter was
   // inactive or before the WS came online.
@@ -610,8 +1186,8 @@ export function useNatsChatAdapter(
   // ─── Historical message hydration ─────────────────────────────────────────
   // When the active dialog changes AND a `fetchDialogMessages` callback
   // is wired, load the first page of history, process it through the
-  // history decoder + envelope, and seed the reducer. Streaming chunks for
-  // the same dialog then append on top.
+  // accumulator, and seed `messages`. Streaming chunks for the same
+  // dialog then append on top.
 
   // Monotonic guard: each history load captures a sequence number; when a
   // response resolves, it only applies if it's still the latest request. This
@@ -624,7 +1200,6 @@ export function useNatsChatAdapter(
       if (!fetchDialogMessages) return
       historyLoadSeqRef.current += 1
       const seq = historyLoadSeqRef.current
-      const store = storeRef.current
       setIsMessagesLoading(true)
       try {
         const result = await fetchDialogMessages({
@@ -642,50 +1217,34 @@ export function useNatsChatAdapter(
             chatTypeFilter,
             onApprove: accumApprove,
             onReject: accumReject,
-            approvalStatuses: store.getSnapshot(id).approvalStatuses,
+            approvalStatuses,
             batchApprovalsEnabled,
             ...(displayApprovalTypes ? { displayApprovalTypes } : {}),
           },
         )
         const unified = mapProcessedToUnified(rawProcessed)
-        store.mutate(id, DEFAULT_DIALOG_SIDE, (r) => {
-          if (cursor === undefined) {
-            // First page — replace. When the trailing assistant is an
-            // INCOMPLETE turn, the catchup replay will re-stream it from its
-            // MESSAGE_START — let that stream adopt (replace) the partial
-            // bubble instead of opening a duplicate one.
-            // Gated on an ACTIVE catchup buffer: when the catchup already
-            // finalized before this history page resolved, no replay is
-            // coming to consume the flag — arming it anyway would hand the
-            // adoption to the NEXT genuine turn, which would overwrite the
-            // partial bubble instead of opening a fresh one.
-            // `extractIncompleteTailState` (not the single-row extractor):
-            // one logical turn can span several trailing assistant bubbles,
-            // so the unfinished artifact may sit above the last row.
-            r.armAdoptTrailingAssistant(
-              isBufferingActive() && extractIncompleteTailState(rawProcessed) !== undefined,
-            )
-            // `initializeWithState`, NOT the raw `setMessages` setter: it also
-            // derives `resumed` from the restored thread, and that flag is what
-            // makes a chunk arriving with no preceding `turn-start` APPEND to
-            // the hydrated bubble instead of replacing its segments. With
-            // `setMessages` the reducer still looked cold, so the first such
-            // chunk — routine, since the turn can open server-side before we
-            // subscribe, and the chunk store expires past ~10 min so the replay
-            // may deliver nothing — wiped the restored bubble. A pending
-            // approval card in that bubble went with it, leaving the agent
-            // blocked on a control the user could no longer see. The SSE
-            // adapter always hydrated through this door; now both do.
-            r.initializeWithState(unified)
-          } else {
-            // Older page — prepend.
-            r.prependMessages(unified)
-          }
-          if (result.tokenUsage !== undefined) {
-            r.setDialogTokenUsage(result.tokenUsage ?? null)
-          }
-        })
+        if (cursor === undefined) {
+          // First page — replace. When the trailing assistant is an
+          // INCOMPLETE turn, the catchup replay will re-stream it from its
+          // MESSAGE_START — let that stream adopt (replace) the partial
+          // bubble instead of opening a duplicate one.
+          // Gated on an ACTIVE catchup buffer: when the catchup already
+          // finalized before this history page resolved, no replay is coming
+          // to consume the flag — arming it anyway would hand the adoption
+          // to the NEXT genuine turn, which would overwrite the partial
+          // bubble instead of opening a fresh one.
+          adoptTrailingAssistantRef.current =
+            isBufferingActive() &&
+            extractIncompleteMessageState(rawProcessed[rawProcessed.length - 1]) !== undefined
+          setMessages(unified)
+        } else {
+          // Older page — prepend.
+          setMessages((prev) => [...unified, ...prev])
+        }
         setMessagesNextCursor(result.nextCursor)
+        if (result.tokenUsage !== undefined) {
+          setDialogTokenUsage(result.tokenUsage)
+        }
       } catch (err) {
         console.error('[useNatsChatAdapter] fetchDialogMessages failed:', err)
       } finally {
@@ -701,6 +1260,7 @@ export function useNatsChatAdapter(
       messagesPageSize,
       assistantName,
       chatTypeFilter,
+      approvalStatuses,
       batchApprovalsEnabled,
       displayApprovalTypes,
       accumApprove,
@@ -721,19 +1281,20 @@ export function useNatsChatAdapter(
     // this an in-flight response could repopulate the just-cleared state.
     historyLoadSeqRef.current += 1
 
-    // Clean slate for the (re)entered dialog: thread, per-turn kernel,
-    // participant dedup sets, seq gate, phase. Approval statuses survive
-    // per-reducer AND get topped up with the adapter's global map (request
-    // ids are dialog-independent).
-    storeRef.current.mutate(dialogKey, DEFAULT_DIALOG_SIDE, (r) => {
-      r.resetForDialogSwitch()
-      // Canonical precedence lives in the reducer: persisted (the adapter's
-      // global map) fills gaps, stream-learned statuses always win.
-      r.mergeApprovalStatuses(globalApprovalStatusesRef.current)
-    })
+    // Drop accumulator + message state for the previous dialog.
+    resetAccumulator()
+    adoptTrailingAssistantRef.current = false
+    seenParticipantSeqsRef.current.clear()
+    pendingEchoTextsRef.current = []
+    setMessages([])
+    setMessagesNextCursor(null)
+    setDialogTokenUsage(null)
+    // Clear per-dialog live model metadata too — otherwise the composer briefly
+    // shows the previous dialog's provider/model until the next chunk streams.
+    setLiveModel(null)
+    setStreamingPhase('idle')
     // No load runs when there's no active dialog, so clear the flag here;
     // otherwise the superseded load's guarded `finally` leaves it stuck on.
-    setMessagesNextCursor(null)
     setIsMessagesLoading(false)
 
     if (!active || !dialogId) return
@@ -741,7 +1302,7 @@ export function useNatsChatAdapter(
     // Hydrate history first; then catchup will fold in any chunks that
     // landed between the history snapshot and the live tail.
     void loadDialogHistory(dialogId)
-  }, [active, dialogId, dialogKey, loadDialogHistory])
+  }, [active, dialogId, loadDialogHistory, resetAccumulator])
 
   // Trigger initial chunk backfill whenever a fresh dialog activates.
   // Runs alongside history hydration — history seeds processed messages,
@@ -749,14 +1310,8 @@ export function useNatsChatAdapter(
   // was already snapshotted.
   useEffect(() => {
     if (!active || !dialogId) return
-    const store = storeRef.current
-    // Gate agent-busy locks for the replay window: a dead tail (approval
-    // approved / tool started, then Stop or a crash) replays its
-    // APPROVAL_RESULT / EXECUTING_TOOL chunks on every dialog (re)open, and
-    // the releasing MESSAGE_END never replays — locking the composer
-    // forever. The suppression is a COUNTER inside the reducer: the
-    // initial-catchup window and a reconnect back-fill window can overlap.
-    store.mutate(dialogId, DEFAULT_DIALOG_SIDE, (r) => r.adjustAgentBusySuppression(1))
+    // Gate onAgentBusy for the replay window (see suppressAgentBusyRef).
+    suppressAgentBusyRef.current += 1
     resetChunkTracking()
     startInitialBuffering()
     catchUpChunks()
@@ -764,15 +1319,16 @@ export function useNatsChatAdapter(
         console.error('[useNatsChatAdapter] initial catchup failed:', err)
       })
       .finally(() => {
-        store.mutate(dialogId, DEFAULT_DIALOG_SIDE, (r) => {
-          r.adjustAgentBusySuppression(-1)
-          // The adopt-once flag targets the replayed MESSAGE_START of the
-          // incomplete history tail. When the replay produced none (chunk
-          // store expired past its ~10-min retention / empty), the armed
-          // flag would survive and make the NEXT genuine turn adopt-and-
-          // overwrite the partial bubble.
-          r.armAdoptTrailingAssistant(false)
-        })
+        suppressAgentBusyRef.current = Math.max(0, suppressAgentBusyRef.current - 1)
+        // The adopt-once flag targets the replayed MESSAGE_START of the
+        // incomplete history tail. When the replay produced none (chunk
+        // store expired past its ~10-min retention / empty), the armed flag
+        // would survive and make the NEXT genuine turn (post-approval
+        // continuation, second device) adopt-and-overwrite the partial
+        // bubble. Scoped: only the still-active dialog clears its own flag.
+        if (dialogId === currentDialogIdRef.current) {
+          adoptTrailingAssistantRef.current = false
+        }
       })
   }, [active, dialogId, resetChunkTracking, startInitialBuffering, catchUpChunks])
 
@@ -805,13 +1361,7 @@ export function useNatsChatAdapter(
         hasConnectedOnceRef.current = true
         return
       }
-      const store = storeRef.current
-      const reconnectDialogId = dialogId
-      if (reconnectDialogId) {
-        store.mutate(reconnectDialogId, DEFAULT_DIALOG_SIDE, (r) =>
-          r.adjustAgentBusySuppression(1),
-        )
-      }
+      suppressAgentBusyRef.current += 1
       // Buffer live deliveries for the WHOLE back-fill, including the history
       // await — otherwise chunks landing mid-fetch are processed unbuffered
       // (advancing lastSequenceId + dedup keys) and the history replace then
@@ -825,27 +1375,28 @@ export function useNatsChatAdapter(
           // so the chunk back-fill can't recover them — the persisted history
           // page is the only source. Then replay the unsaved chunk tail on
           // top of the fresh snapshot.
-          if (reconnectDialogId && fetchDialogMessages) {
-            await loadDialogHistory(reconnectDialogId)
+          if (dialogId && fetchDialogMessages) {
+            await loadDialogHistory(dialogId)
           }
           // The user may have switched dialogs during the await — the new
           // dialog's own effects run their catchup cycle; re-running it here
-          // would reset that cycle mid-flight.
-          if (reconnectDialogId !== currentDialogIdRef.current) return
+          // (via refs it would target the NEW dialog) would reset that cycle
+          // mid-flight.
+          if (dialogId !== currentDialogIdRef.current) return
           await resetAndCatchUp()
         } catch (err) {
           console.error('[useNatsChatAdapter] reconnect catchup failed:', err)
         } finally {
-          if (reconnectDialogId) {
-            store.mutate(reconnectDialogId, DEFAULT_DIALOG_SIDE, (r) => {
-              r.adjustAgentBusySuppression(-1)
-              // The adopt-once flag targets the replayed MESSAGE_START of the
-              // incomplete tail — but on reconnect that START was already
-              // consumed live and is dedup-skipped by the replay, so it never
-              // fires. Clear the flag or the NEXT genuine turn adopts (and
-              // overwrites) the completed trailing bubble.
-              r.armAdoptTrailingAssistant(false)
-            })
+          suppressAgentBusyRef.current = Math.max(0, suppressAgentBusyRef.current - 1)
+          // The adopt-once flag targets the replayed MESSAGE_START of the
+          // incomplete tail — but on reconnect that START was already
+          // consumed live and is dedup-skipped by the replay, so it never
+          // fires onStreamStart. Clear the flag or the NEXT genuine turn
+          // adopts (and overwrites) the completed trailing bubble. Scoped:
+          // a stale back-fill must not clear the NEW dialog's freshly armed
+          // flag.
+          if (dialogId === currentDialogIdRef.current) {
+            adoptTrailingAssistantRef.current = false
           }
         }
       })()
@@ -925,30 +1476,52 @@ export function useNatsChatAdapter(
     ): Promise<void> => {
       const hidden = sendOptions?.hidden ?? false
 
+      // Record the text so the backend's MESSAGE_REQUEST echo consumes this
+      // send instead of rendering a duplicate row (cap keeps the list from
+      // growing if a backend never echoes).
+      pendingEchoTextsRef.current.push(text)
+      if (pendingEchoTextsRef.current.length > 5) pendingEchoTextsRef.current.shift()
+
       // Optimistically append the user bubble + an empty assistant
-      // placeholder, record the echo text, and flip the phase — all inside
-      // the reducer. The assistant body fills in as NATS chunks land.
-      mutate((r) => r.pushOptimisticSend(text, hidden))
+      // placeholder. The assistant body fills in as NATS chunks land.
+      setMessages((prev) => [
+        ...prev,
+        {
+          id: nextId('user'),
+          role: 'user',
+          content: text,
+          ...(hidden ? { hidden: true } : {}),
+        },
+        {
+          id: nextId('assistant'),
+          role: 'assistant',
+          content: '',
+          segments: [],
+        },
+      ])
+      setStreamingPhase('thinking')
 
       await publishUserMessage(text, { hidden, dialogId })
     },
-    [mutate, publishUserMessage, dialogId],
+    [publishUserMessage, dialogId],
   )
 
   const stopMessage = useCallback(() => {
     // Best-effort UI flip. The actual backend cancellation is gated on
     // the host-supplied callback.
-    mutate((r) => r.setPhase('idle'))
+    setStreamingPhase('idle')
     if (stopGenerationCallback && dialogId) {
       void stopGenerationCallback(dialogId).catch((err) => {
         console.error('[useNatsChatAdapter] stopGeneration failed:', err)
       })
     }
-  }, [mutate, stopGenerationCallback, dialogId])
+  }, [stopGenerationCallback, dialogId])
 
   const clearMessages = useCallback(() => {
-    mutate((r) => r.clearThread())
-  }, [mutate])
+    setMessages([])
+    resetAccumulator()
+    setStreamingPhase('idle')
+  }, [resetAccumulator])
 
   const selectDialog = useCallback(
     (id: string | null) => {
@@ -999,7 +1572,6 @@ export function useNatsChatAdapter(
       try {
         await deleteDialogCallback(id)
         setDialogs((prev) => prev.filter((d) => d.id !== id))
-        storeRef.current.remove(id)
         if (isManagedMode && internalDialogId === id) {
           setInternalDialogId(null)
         }
@@ -1086,7 +1658,6 @@ export function useNatsChatAdapter(
 
   // ─── Return shape ─────────────────────────────────────────────────────────
 
-  const { messages, streamingPhase, dialogTokenUsage = null, liveModel = null } = state
   const isLoading = streamingPhase !== 'idle'
   const hasMoreDialogs = dialogsNextCursor != null
   const hasMoreMessages = messagesNextCursor != null