@flamingo-stack/openframe-frontend-core 0.0.508 → 0.0.509

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

@@ -12,11 +12,11 @@
  *   ┌──────────────────────────────────────────────────────────────┐
  *   │ useNatsDialogSubscription   live tail of agent events        │
  *   │            ↓                                                 │
- *   │   onEvent → processChunk                                     │
+ *   │   onEvent → decodeNatsChunk → ChatStreamEvent                │
  *   │            ↓                                                 │
- *   │ useRealtimeChunkProcessor   chunk → MessageSegment[]         │
- *   │            ↓                                                 │
- *   │   onSegmentsUpdate → updates assistant message in state      │
+ *   │ createChatStreamReducer     THE master accumulation path     │
+ *   │   (via ChatDialogStore + useChatStreamReducer wrapper —      │
+ *   │    messages, phase, token usage, approvals all live there)   │
  *   │                                                              │
  *   │ useChunkCatchup             back-fill missed chunks after    │
  *   │                              activation / reconnect          │
@@ -24,53 +24,38 @@
  *   │ 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. 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.
+ *      management above the adapter.
  *
  *   2. **Managed-dialog mode** (openframe-frontend, EmbeddableChat
- *      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.
+ *      sidebar): consumer supplies `fetchDialogs`, `fetchDialogMessages`,
+ *      `createDialog`, etc. and the adapter owns the dialog state machine.
  *
  * 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,
-  type MutableRefObject,
-} from 'react'
+import { useCallback, useEffect, useMemo, useRef, useState } 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 { extractIncompleteMessageState } from '../utils/extract-incomplete-message-state'
+import { extractIncompleteTailState } from '../utils/extract-incomplete-message-state'
 import type {
   ChunkData,
   FetchChunksFunction,
@@ -78,11 +63,7 @@ import type {
   MessageProcessingOptions,
   MessageSegment,
   NatsMessageType,
-  StreamingPhase,
   ChatApprovalStatus,
-  SegmentsUpdateMetadata,
-  ToolExecutionSegment,
-  ApprovalBatchExecutionState,
 } from '../types'
 import type {
   ChatConnectionState,
@@ -94,6 +75,16 @@ 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
 // =============================================================================
@@ -210,19 +201,19 @@ export interface UseNatsChatAdapterConfig {
   topics?: NatsMessageType[]
 
   /**
-   * Mirrors `UseRealtimeChunkProcessorOptions.batchApprovalsEnabled`.
-   * Default `true` — single batch card per APPROVAL_REQUEST with
-   * `toolCalls[]`. Set `false` to fall back to legacy per-tool cards.
+   * 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.
    */
   batchApprovalsEnabled?: boolean
 
   /**
-   * 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.
+   * 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.
    */
   displayApprovalTypes?: string[]
 
@@ -245,7 +236,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
-   * accumulator-compatible segments.
+   * reducer-compatible messages.
    */
   fetchDialogMessages?: (
     params: FetchDialogMessagesParams,
@@ -283,9 +274,9 @@ export interface UseNatsChatAdapterConfig {
   unarchiveDialog?: (dialogId: string) => Promise<void>
 
   /**
-   * 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.
+   * 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.
    */
   approveRequest?: (requestId: string) => Promise<void>
 
@@ -344,264 +335,9 @@ export interface UseNatsChatAdapterOptions {
 }
 
 // =============================================================================
-// Internal helpers
+// Historical-message mapping helpers (host-facing)
 // =============================================================================
 
-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`
@@ -671,6 +407,9 @@ 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 = {},
@@ -726,56 +465,109 @@ export function useNatsChatAdapter(
   const currentDialogIdRef = useRef<string | null>(dialogId)
   currentDialogIdRef.current = dialogId
 
-  // ─── 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)
+  // ─── 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.
 
-  // 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)
+  const handleApproveRef = useRef<(requestId: string) => Promise<void>>(async () => {})
+  const handleRejectRef = useRef<(requestId: string, reason?: string) => Promise<void>>(
+    async () => {},
+  )
 
-  // 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>
-  >({})
+  // 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)
+  }, [])
+
+  // ─── 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)
+    }
+  }
+
+  // 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],
+  )
 
   // ─── Dialog list state (managed-dialog mode only) ─────────────────────────
 
@@ -790,383 +582,15 @@ 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')
 
-  // ─── 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 } : {}),
-  })
+  // 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)
 
   // History catchup — back-fills chunks emitted while the adapter was
   // inactive or before the WS came online.
@@ -1186,8 +610,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
-  // accumulator, and seed `messages`. Streaming chunks for the same
-  // dialog then append on top.
+  // history decoder + envelope, and seed the reducer. 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
@@ -1200,6 +624,7 @@ export function useNatsChatAdapter(
       if (!fetchDialogMessages) return
       historyLoadSeqRef.current += 1
       const seq = historyLoadSeqRef.current
+      const store = storeRef.current
       setIsMessagesLoading(true)
       try {
         const result = await fetchDialogMessages({
@@ -1217,34 +642,50 @@ export function useNatsChatAdapter(
             chatTypeFilter,
             onApprove: accumApprove,
             onReject: accumReject,
-            approvalStatuses,
+            approvalStatuses: store.getSnapshot(id).approvalStatuses,
             batchApprovalsEnabled,
             ...(displayApprovalTypes ? { displayApprovalTypes } : {}),
           },
         )
         const unified = mapProcessedToUnified(rawProcessed)
-        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])
-        }
+        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)
+          }
+        })
         setMessagesNextCursor(result.nextCursor)
-        if (result.tokenUsage !== undefined) {
-          setDialogTokenUsage(result.tokenUsage)
-        }
       } catch (err) {
         console.error('[useNatsChatAdapter] fetchDialogMessages failed:', err)
       } finally {
@@ -1260,7 +701,6 @@ export function useNatsChatAdapter(
       messagesPageSize,
       assistantName,
       chatTypeFilter,
-      approvalStatuses,
       batchApprovalsEnabled,
       displayApprovalTypes,
       accumApprove,
@@ -1281,20 +721,19 @@ export function useNatsChatAdapter(
     // this an in-flight response could repopulate the just-cleared state.
     historyLoadSeqRef.current += 1
 
-    // 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')
+    // 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)
+    })
     // 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
@@ -1302,7 +741,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, loadDialogHistory, resetAccumulator])
+  }, [active, dialogId, dialogKey, loadDialogHistory])
 
   // Trigger initial chunk backfill whenever a fresh dialog activates.
   // Runs alongside history hydration — history seeds processed messages,
@@ -1310,8 +749,14 @@ export function useNatsChatAdapter(
   // was already snapshotted.
   useEffect(() => {
     if (!active || !dialogId) return
-    // Gate onAgentBusy for the replay window (see suppressAgentBusyRef).
-    suppressAgentBusyRef.current += 1
+    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))
     resetChunkTracking()
     startInitialBuffering()
     catchUpChunks()
@@ -1319,16 +764,15 @@ export function useNatsChatAdapter(
         console.error('[useNatsChatAdapter] initial catchup failed:', err)
       })
       .finally(() => {
-        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
-        }
+        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)
+        })
       })
   }, [active, dialogId, resetChunkTracking, startInitialBuffering, catchUpChunks])
 
@@ -1361,7 +805,13 @@ export function useNatsChatAdapter(
         hasConnectedOnceRef.current = true
         return
       }
-      suppressAgentBusyRef.current += 1
+      const store = storeRef.current
+      const reconnectDialogId = dialogId
+      if (reconnectDialogId) {
+        store.mutate(reconnectDialogId, DEFAULT_DIALOG_SIDE, (r) =>
+          r.adjustAgentBusySuppression(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
@@ -1375,28 +825,27 @@ 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 (dialogId && fetchDialogMessages) {
-            await loadDialogHistory(dialogId)
+          if (reconnectDialogId && fetchDialogMessages) {
+            await loadDialogHistory(reconnectDialogId)
           }
           // The user may have switched dialogs during the await — the new
           // dialog's own effects run their catchup cycle; re-running it here
-          // (via refs it would target the NEW dialog) would reset that cycle
-          // mid-flight.
-          if (dialogId !== currentDialogIdRef.current) return
+          // would reset that cycle mid-flight.
+          if (reconnectDialogId !== currentDialogIdRef.current) return
           await resetAndCatchUp()
         } catch (err) {
           console.error('[useNatsChatAdapter] reconnect catchup failed:', err)
         } finally {
-          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
+          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)
+            })
           }
         }
       })()
@@ -1476,52 +925,30 @@ 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. 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')
+      // 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))
 
       await publishUserMessage(text, { hidden, dialogId })
     },
-    [publishUserMessage, dialogId],
+    [mutate, publishUserMessage, dialogId],
   )
 
   const stopMessage = useCallback(() => {
     // Best-effort UI flip. The actual backend cancellation is gated on
     // the host-supplied callback.
-    setStreamingPhase('idle')
+    mutate((r) => r.setPhase('idle'))
     if (stopGenerationCallback && dialogId) {
       void stopGenerationCallback(dialogId).catch((err) => {
         console.error('[useNatsChatAdapter] stopGeneration failed:', err)
       })
     }
-  }, [stopGenerationCallback, dialogId])
+  }, [mutate, stopGenerationCallback, dialogId])
 
   const clearMessages = useCallback(() => {
-    setMessages([])
-    resetAccumulator()
-    setStreamingPhase('idle')
-  }, [resetAccumulator])
+    mutate((r) => r.clearThread())
+  }, [mutate])
 
   const selectDialog = useCallback(
     (id: string | null) => {
@@ -1572,6 +999,7 @@ 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)
         }
@@ -1658,6 +1086,7 @@ 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