dsh-code 0.7.0 → 0.9.0

package/src/render/projection.ts

@@ -22,12 +22,22 @@ import type {} from '@deepseek-ai/dsh-plan-mode'
 import type {} from '@deepseek-ai/dsh-permission-presets'
 import type {} from '@deepseek-ai/dsh-sandbox-policy'
 import type {} from '@deepseek-ai/dsh-session-title'
-import { toolArgumentsPreview } from './tool-preview.ts'
+import { toolArgumentsPreview, toolPromptPreview } from './tool-preview.ts'
 import { toolResultDetail, type ToolDetail } from './tool-detail.ts'
 
 /** In-flight UI buffers are tails; the assembled assistant message is authoritative. */
 const MAX_STREAMING_CHARS = 65_536
 
+/**
+ * Upper bound on remembered `compaction/summary` shadow prices waiting for a
+ * matching `compaction/end`. Compactions are sequential and rare, so a few
+ * slots suffice; an aborted compaction (summary without end) otherwise leaves
+ * an unbounded residue in `anchors.compactionTokens`. An evicted price
+ * degrades to the documented `lastPruneTokens` fallback, exactly like a
+ * missing summary.
+ */
+const MAX_COMPACTION_SUMMARY_RESIDUE = 16
+
 /** Append one delta without retaining an unbounded duplicate of the live reply. */
 function appendStreamingTail(current: string, delta: string): string {
   const next = current + delta
@@ -75,6 +85,8 @@ export interface ToolEntry {
   arguments: string
   /** Bounded human-meaningful arguments preview for the tool card. */
   preview: string
+  /** Bounded delegation prompt (subagent cards' second row), '' when none. */
+  prompt: string
   /** Execution state; `running` until the paired result lands. */
   state: 'running' | 'done' | 'error'
   /** Bounded first text block of the result, empty until it lands. */
@@ -273,9 +285,21 @@ export interface TranscriptView {
   /**
    * Fold-internal timing anchors, never rendered: open step and tool-call
    * start timestamps the next `assistant/message` / `tool/result` resolves
-   * against. Keyed `turn:step` and by call id.
+   * against. Keyed `turn:step` and by call id. `turnSteps`/`turnTools`
+   * track which step/tool anchors still belong to the open turn so
+   * `turn/end` (and a superseding `step/start`) can sweep anchors an
+   * interruption left behind; `turnFiles` keys mutated paths by turn.
    */
-  readonly anchors: { stepStart: Map<string, number>; toolStart: Map<string, number>; firstChunkAt: Map<string, number>; compactionTokens: Map<string, number>; lastPruneTokens: number; turnFiles: Map<number, Set<string>> }
+  readonly anchors: {
+    stepStart: Map<string, number>
+    toolStart: Map<string, number>
+    firstChunkAt: Map<string, number>
+    compactionTokens: Map<string, number>
+    lastPruneTokens: number
+    turnFiles: Map<number, Set<string>>
+    turnSteps: Map<number, string>
+    turnTools: Map<number, Set<string>>
+  }
 }
 
 /** Join the text blocks of a content list; non-text blocks contribute nothing. */
@@ -323,7 +347,7 @@ export function createTranscriptView(): TranscriptView {
     goal: undefined,
     pending: { 'next-turn': [], 'next-step': [] },
     stats: { turns: 0, steps: 0, llmMs: 0, toolMs: 0, usage: { inputTokens: 0, outputTokens: 0, cacheReadTokens: 0 }, lastPromptTokens: 0, contextWindow: 0, contextSegments: { system: 0, prompt: 0, assistant: 0, thinking: 0, tools: 0 }, ttftMs: 0, ttftSteps: 0, decodeMs: 0, decodeTokens: 0, reasoningEffort: '' },
-    anchors: { stepStart: new Map(), toolStart: new Map(), firstChunkAt: new Map(), compactionTokens: new Map(), lastPruneTokens: 0, turnFiles: new Map() },
+    anchors: { stepStart: new Map(), toolStart: new Map(), firstChunkAt: new Map(), compactionTokens: new Map(), lastPruneTokens: 0, turnFiles: new Map(), turnSteps: new Map(), turnTools: new Map() },
   }
 }
 
@@ -449,6 +473,9 @@ export function projectEvent(view: TranscriptView, event: SessionEvent): Transcr
       view.anchors.stepStart.delete(key)
       const firstChunk = view.anchors.firstChunkAt.get(key)
       view.anchors.firstChunkAt.delete(key)
+      // The assembled message consumes the turn's current step anchor; a
+      // later `turn/end` sweep then has nothing left to clean for this step.
+      if (view.anchors.turnSteps.get(event.data.turn) === key) view.anchors.turnSteps.delete(event.data.turn)
       const usage = event.data.usage
       const totals = view.stats.usage
       const text = textOf(event.data.message.content)
@@ -487,6 +514,11 @@ export function projectEvent(view: TranscriptView, event: SessionEvent): Transcr
     case 'tool/call': {
       const data = event.data
       view.anchors.toolStart.set(data.callId, event.time)
+      // Remember the call's turn so `turn/end` can sweep a start that never
+      // pairs with a result (an interrupted tool otherwise leaks its anchor).
+      const turnTools = view.anchors.turnTools.get(data.turn) ?? new Set<string>()
+      turnTools.add(data.callId)
+      view.anchors.turnTools.set(data.turn, turnTools)
       return {
         ...view,
         entries: [...view.entries, {
@@ -495,6 +527,7 @@ export function projectEvent(view: TranscriptView, event: SessionEvent): Transcr
           name: data.name,
           arguments: data.arguments,
           preview: toolArgumentsPreview(data.arguments, data.name),
+          prompt: toolPromptPreview(data.name, data.arguments),
           state: 'running',
           summary: '',
           detail: undefined,
@@ -513,6 +546,13 @@ export function projectEvent(view: TranscriptView, event: SessionEvent): Transcr
       const block = event.data.message.content[0]
       const started = view.anchors.toolStart.get(block.toolCallId)
       view.anchors.toolStart.delete(block.toolCallId)
+      // Deregister the call from its turn's registry so `turn/end` does not
+      // sweep a start that already paired with a result.
+      const turnTools = view.anchors.turnTools.get(event.data.turn)
+      if (turnTools !== undefined) {
+        turnTools.delete(block.toolCallId)
+        if (turnTools.size === 0) view.anchors.turnTools.delete(event.data.turn)
+      }
       const rawText = textOf(block.content)
       const summary = boundContextSummary(rawText)
       // The verbose expansion self-serves from the persisted presentation
@@ -555,14 +595,28 @@ export function projectEvent(view: TranscriptView, event: SessionEvent): Transcr
         todos: [],
         stats: { ...view.stats, turns: view.stats.turns + 1 },
       }
-    case 'step/start':
-      view.anchors.stepStart.set(`${event.data.turn}:${event.data.step}`, event.time)
+    case 'step/start': {
+      // A step supersedes the turn's previous step: if that step never
+      // assembled a message (interrupted), its timing anchors are stale the
+      // moment the next step opens and are swept here instead of leaking.
+      const key = `${event.data.turn}:${event.data.step}`
+      const previous = view.anchors.turnSteps.get(event.data.turn)
+      if (previous !== undefined && previous !== key) {
+        view.anchors.stepStart.delete(previous)
+        view.anchors.firstChunkAt.delete(previous)
+      }
+      view.anchors.turnSteps.set(event.data.turn, key)
+      view.anchors.stepStart.set(key, event.time)
       return { ...view, stats: { ...view.stats, steps: view.stats.steps + 1 } }
+    }
     case 'turn/end': {
       const reason = event.data.reason
       const appended: TranscriptEntry[] = []
       if (reason.kind === 'error') {
-        appended.push({ kind: 'error', text: `${reason.error.code}: ${reason.error.message}` })
+        const recovery = reason.error.code === 'MISSING_CREDENTIAL'
+          ? ' · open /model to add an API key'
+          : ''
+        appended.push({ kind: 'error', text: `${reason.error.code}: ${reason.error.message}${recovery}` })
       } else {
         // Non-error outcomes deserve their own durable row (the web renders
         // distinct max-tokens / abort / interruption nodes); `completed` stays
@@ -583,6 +637,20 @@ export function projectEvent(view: TranscriptView, event: SessionEvent): Transcr
       const files = view.anchors.turnFiles.get(event.data.turn)
       view.anchors.turnFiles.delete(event.data.turn)
       if (files !== undefined && files.size > 0) appended.push({ kind: 'files', paths: [...files].slice(0, 12) })
+      // Derivable boundary sweep: the turn is over, so any step/tool anchors
+      // it left behind (interruptions that never produced their message or
+      // result) can never be resolved and are reclaimed now.
+      const stepKey = view.anchors.turnSteps.get(event.data.turn)
+      if (stepKey !== undefined) {
+        view.anchors.stepStart.delete(stepKey)
+        view.anchors.firstChunkAt.delete(stepKey)
+        view.anchors.turnSteps.delete(event.data.turn)
+      }
+      const turnToolSet = view.anchors.turnTools.get(event.data.turn)
+      if (turnToolSet !== undefined) {
+        for (const callId of turnToolSet) view.anchors.toolStart.delete(callId)
+        view.anchors.turnTools.delete(event.data.turn)
+      }
       if (appended.length === 0) return { ...view, busy: false, busySince: 0 }
       return { ...view, busy: false, busySince: 0, entries: [...view.entries, ...appended] }
     }
@@ -651,7 +719,12 @@ export function projectEvent(view: TranscriptView, event: SessionEvent): Transcr
       return { ...view, title: event.data.title }
     case 'compaction/summary':
       // Remember the shadow price so the matching `compaction/end` row can
-      // state what the compaction reclaimed.
+      // state what the compaction reclaimed. The map is capped so an aborted
+      // compaction (summary without end) cannot leave an unbounded residue.
+      if (view.anchors.compactionTokens.size >= MAX_COMPACTION_SUMMARY_RESIDUE) {
+        const oldest = view.anchors.compactionTokens.keys().next().value
+        if (oldest !== undefined) view.anchors.compactionTokens.delete(oldest)
+      }
       view.anchors.compactionTokens.set(event.data.compactionId, event.data.shadowedTokenCount)
       return view
     case 'compaction/prune':
@@ -730,13 +803,595 @@ export function projectEvent(view: TranscriptView, event: SessionEvent): Transcr
   }
 }
 
+/**
+ * Mutable replay accumulator: folds a persisted log into the identical view
+ * `projectEvent` would produce, but in near-linear time. Where `projectEvent`
+ * is copy-on-write — every append/scan rebuilds the whole `entries` array, so
+ * folding a full log costs O(N²) — the accumulator appends by push, resolves
+ * id-keyed updates (tool/result, command/done, retry-started) through index
+ * maps, and tombstones retired pending rows, so the whole log folds in O(N)
+ * plus one compaction pass when tombstones exist.
+ *
+ * Index maps never delete: every appended row registers its index, so an id
+ * lookup miss provably means no matching row exists and the update is an O(1)
+ * no-op (a malicious/orphan-heavy log cannot force per-orphan full-array
+ * scans). Each id maps to ALL of its indices, so a duplicate id updates every
+ * matching row exactly like the copy-on-write reducer.
+ *
+ * @internal Exported only so tests can (a) prove replay ≡ sequential
+ * `projectEvent` folds and (b) assert the linear complexity deterministically
+ * via {@link ReplayAccumulator.ops}, which counts entry-level container work
+ * instead of relying on wall-clock thresholds. No public consumer.
+ */
+export interface ReplayAccumulator {
+  /** Working entry list; `undefined` marks a retired pending row (tombstone). */
+  entries: (TranscriptEntry | undefined)[]
+  /** callId → every index into `entries` holding a `tool` row with that id. */
+  toolIndex: Map<string, number[]>
+  /** commandId → every index into `entries` holding a `command` row with that id. */
+  commandIndex: Map<string, number[]>
+  /** retryId → every index into `entries` holding a `retry` row with that id. */
+  retryIndex: Map<string, number[]>
+  /** messageId → every index into `entries` holding a `pending` row with that id. */
+  pendingIndex: Map<string, number[]>
+  /** Tombstone count; zero means `entries` is already the final array. */
+  removedCount: number
+  /** Mutable inbox id lists, mirroring `view.pending` order per target. */
+  pendingTurn: string[]
+  pendingStep: string[]
+  streaming: string
+  streamingReasoning: string
+  todos: readonly TodoItem[]
+  busy: boolean
+  busySince: number
+  model: string
+  plan: boolean
+  permission: string
+  title: string
+  sandbox: string
+  goal: GoalFold | undefined
+  stats: TranscriptStats
+  stepStart: Map<string, number>
+  toolStart: Map<string, number>
+  firstChunkAt: Map<string, number>
+  compactionTokens: Map<string, number>
+  lastPruneTokens: number
+  turnFiles: Map<number, Set<string>>
+  turnSteps: Map<number, string>
+  turnTools: Map<number, Set<string>>
+  /** Entry-level container operations performed so far (test instrumentation). */
+  ops: number
+}
+
+/** @internal A fresh replay accumulator whose state mirrors `createTranscriptView()`. */
+export function createReplayAccumulator(): ReplayAccumulator {
+  return {
+    entries: [],
+    toolIndex: new Map(),
+    commandIndex: new Map(),
+    retryIndex: new Map(),
+    pendingIndex: new Map(),
+    removedCount: 0,
+    pendingTurn: [],
+    pendingStep: [],
+    streaming: '',
+    streamingReasoning: '',
+    todos: [],
+    busy: false,
+    busySince: 0,
+    model: '',
+    plan: false,
+    permission: '',
+    title: '',
+    sandbox: '',
+    goal: undefined,
+    stats: { turns: 0, steps: 0, llmMs: 0, toolMs: 0, usage: { inputTokens: 0, outputTokens: 0, cacheReadTokens: 0 }, lastPromptTokens: 0, contextWindow: 0, contextSegments: { system: 0, prompt: 0, assistant: 0, thinking: 0, tools: 0 }, ttftMs: 0, ttftSteps: 0, decodeMs: 0, decodeTokens: 0, reasoningEffort: '' },
+    stepStart: new Map(),
+    toolStart: new Map(),
+    firstChunkAt: new Map(),
+    compactionTokens: new Map(),
+    lastPruneTokens: 0,
+    turnFiles: new Map(),
+    turnSteps: new Map(),
+    turnTools: new Map(),
+    ops: 0,
+  }
+}
+
+/** Append one entry (O(1)) and account the push. */
+function appendReplayEntry(acc: ReplayAccumulator, entry: TranscriptEntry): void {
+  acc.entries.push(entry)
+  acc.ops += 1
+}
+
+/**
+ * Get (or create) the index list an id owns. Lists are never removed: every
+ * appended row registers its index, so a lookup miss later proves no matching
+ * row exists and the caller can no-op in O(1).
+ */
+function indexList(map: Map<string, number[]>, id: string): number[] {
+  let list = map.get(id)
+  if (list === undefined) {
+    list = []
+    map.set(id, list)
+  }
+  return list
+}
+
+/**
+ * Apply an id-keyed update to every row that registered the id, mirroring the
+ * copy-on-write reducer's full-array map semantics (all matching rows update,
+ * in order). Each registered index is O(1), so a duplicate id costs
+ * O(#duplicates) — never a full-array scan. The kind+id re-check is defensive:
+ * registered indices are valid by construction, because tool/command/retry
+ * rows are never removed and tombstones never shift indices.
+ */
+function updateReplayById<T extends TranscriptEntry>(
+  acc: ReplayAccumulator,
+  map: Map<string, number[]>,
+  id: string,
+  isMatch: (entry: T) => boolean,
+  update: (entry: T) => T,
+): void {
+  const list = map.get(id)
+  if (list === undefined) return // miss provably means no matching row
+  for (const index of list) {
+    const entry = acc.entries[index]
+    if (entry === undefined || !isMatch(entry as T)) continue
+    acc.entries[index] = update(entry as T)
+    acc.ops += 1
+  }
+}
+
+/** Tombstone a retired pending row, keeping every other index stable. */
+function retireReplayEntry(acc: ReplayAccumulator, index: number): void {
+  if (acc.entries[index] !== undefined) {
+    acc.entries[index] = undefined
+    acc.removedCount += 1
+    acc.ops += 1
+  }
+}
+
+/**
+ * Fold one session event into a replay accumulator. This mirrors
+ * {@link projectEvent} case for case — same stats arithmetic, same anchor
+ * set/delete behavior, same entry shapes — so the finished view is identical
+ * to a sequential fold; only the `entries` container operations are mutable.
+ *
+ * @internal Test-instrumentation path; `projectEvents` is the public entry.
+ */
+export function replayProjectEvent(acc: ReplayAccumulator, event: SessionEvent): void {
+  switch (event.type) {
+    case 'user/message': {
+      const message = event.data
+      for (const target of ['next-turn', 'next-step'] as const) {
+        const ids = target === 'next-turn' ? acc.pendingTurn : acc.pendingStep
+        const index = ids.indexOf(message.id)
+        acc.ops += index < 0 ? ids.length : index + 1
+        if (index < 0) continue
+        ids.splice(index, 1)
+        acc.ops += 1
+        // Retire every pending row carrying this message id (duplicate ids
+        // included), exactly like the reducer's full-array filter.
+        const list = acc.pendingIndex.get(message.id)
+        if (list !== undefined) {
+          for (const entryIndex of list) retireReplayEntry(acc, entryIndex)
+          acc.ops += 1
+        }
+      }
+      const text = textOf(message.content)
+      if (message.source.kind === 'user') {
+        appendReplayEntry(acc, { kind: 'user', text, notice: false })
+        acc.stats = {
+          ...acc.stats,
+          contextSegments: {
+            ...acc.stats.contextSegments,
+            prompt: acc.stats.contextSegments.prompt + estimateTokens(text),
+          },
+        }
+        return
+      }
+      const notice = message.source.kind === 'plugin' && message.source.form === 'notice'
+        ? message.source.summary
+        : message.source.kind
+      const summary = boundContextSummary(notice)
+      appendReplayEntry(acc, { kind: 'user', text: summary, notice: true })
+      acc.stats = {
+        ...acc.stats,
+        contextSegments: {
+          ...acc.stats.contextSegments,
+          system: acc.stats.contextSegments.system + estimateTokens(summary),
+        },
+      }
+      return
+    }
+    case 'agent/inbox/spliced': {
+      const { target, start, removedCount = 0, inserted } = event.data
+      const ids = target === 'next-turn' ? acc.pendingTurn : acc.pendingStep
+      const removed = ids.slice(start, start + removedCount)
+      acc.ops += removed.length
+      ids.splice(start, removedCount)
+      acc.ops += removed.length
+      for (const id of removed) {
+        const list = acc.pendingIndex.get(id)
+        if (list === undefined) continue
+        for (const entryIndex of list) {
+          const entry = acc.entries[entryIndex]
+          if (entry !== undefined && entry.kind === 'pending' && entry.target === target) {
+            retireReplayEntry(acc, entryIndex)
+          }
+        }
+      }
+      for (const message of inserted) {
+        appendReplayEntry(acc, { kind: 'pending', messageId: message.id, target, text: pendingText(message.content) })
+        indexList(acc.pendingIndex, message.id).push(acc.entries.length - 1)
+        ids.push(message.id)
+        acc.ops += 1
+      }
+      return
+    }
+    case 'assistant/chunk': {
+      const chunk = event.data.chunk
+      const key = `${event.data.turn}:${event.data.step}`
+      const delta = chunk.type === 'text-delta' || chunk.type === 'reasoning-delta' ? chunk.text : ''
+      if (delta !== '' && !acc.firstChunkAt.has(key)) {
+        acc.firstChunkAt.set(key, event.time)
+        const started = acc.stepStart.get(key)
+        if (started !== undefined) {
+          acc.stats = {
+            ...acc.stats,
+            ttftMs: acc.stats.ttftMs + Math.max(0, event.time - started),
+            ttftSteps: acc.stats.ttftSteps + 1,
+          }
+        }
+      }
+      if (chunk.type === 'text-delta') {
+        acc.streaming = appendStreamingTail(acc.streaming, chunk.text)
+        return
+      }
+      if (chunk.type === 'reasoning-delta') {
+        acc.streamingReasoning = appendStreamingTail(acc.streamingReasoning, chunk.text)
+        return
+      }
+      return
+    }
+    case 'assistant/message': {
+      const key = `${event.data.turn}:${event.data.step}`
+      const started = acc.stepStart.get(key)
+      acc.stepStart.delete(key)
+      const firstChunk = acc.firstChunkAt.get(key)
+      acc.firstChunkAt.delete(key)
+      if (acc.turnSteps.get(event.data.turn) === key) acc.turnSteps.delete(event.data.turn)
+      const usage = event.data.usage
+      const totals = acc.stats.usage
+      const text = textOf(event.data.message.content)
+      const reasoning = reasoningOf(event.data.message.content)
+      acc.streaming = ''
+      acc.streamingReasoning = ''
+      appendReplayEntry(acc, { kind: 'assistant', text, reasoning })
+      acc.stats = {
+        ...acc.stats,
+        llmMs: acc.stats.llmMs + (started === undefined ? 0 : Math.max(0, event.time - started)),
+        usage: usage === undefined ? totals : {
+          inputTokens: totals.inputTokens + usage.inputTokens + (usage.cacheReadTokens ?? 0) + (usage.cacheWriteTokens ?? 0),
+          outputTokens: totals.outputTokens + usage.outputTokens,
+          cacheReadTokens: totals.cacheReadTokens + (usage.cacheReadTokens ?? 0),
+        },
+        lastPromptTokens: usage === undefined ? acc.stats.lastPromptTokens
+          : usage.inputTokens + (usage.cacheReadTokens ?? 0) + (usage.cacheWriteTokens ?? 0),
+        decodeMs: acc.stats.decodeMs + (firstChunk === undefined ? 0 : Math.max(0, event.time - firstChunk)),
+        decodeTokens: acc.stats.decodeTokens + (firstChunk === undefined || usage === undefined ? 0 : usage.outputTokens),
+        contextSegments: {
+          ...acc.stats.contextSegments,
+          thinking: acc.stats.contextSegments.thinking + estimateTokens(reasoning),
+          assistant: acc.stats.contextSegments.assistant + estimateTokens(text),
+        },
+      }
+      return
+    }
+    case 'tool/call': {
+      const data = event.data
+      acc.toolStart.set(data.callId, event.time)
+      const turnTools = acc.turnTools.get(data.turn) ?? new Set<string>()
+      turnTools.add(data.callId)
+      acc.turnTools.set(data.turn, turnTools)
+      appendReplayEntry(acc, {
+        kind: 'tool',
+        callId: data.callId,
+        name: data.name,
+        arguments: data.arguments,
+        preview: toolArgumentsPreview(data.arguments, data.name),
+        prompt: toolPromptPreview(data.name, data.arguments),
+        state: 'running',
+        summary: '',
+        detail: undefined,
+      })
+      indexList(acc.toolIndex, data.callId).push(acc.entries.length - 1)
+      acc.stats = {
+        ...acc.stats,
+        contextSegments: {
+          ...acc.stats.contextSegments,
+          tools: acc.stats.contextSegments.tools
+            + (typeof data.arguments === 'string' ? estimateTokens(data.arguments) : 0),
+        },
+      }
+      return
+    }
+    case 'tool/result': {
+      const block = event.data.message.content[0]
+      const started = acc.toolStart.get(block.toolCallId)
+      acc.toolStart.delete(block.toolCallId)
+      const turnTools = acc.turnTools.get(event.data.turn)
+      if (turnTools !== undefined) {
+        turnTools.delete(block.toolCallId)
+        if (turnTools.size === 0) acc.turnTools.delete(event.data.turn)
+      }
+      const rawText = textOf(block.content)
+      const summary = boundContextSummary(rawText)
+      const detail = toolResultDetail(event.data.meta, rawText)
+      if (detail?.kind === 'diff') {
+        const set = acc.turnFiles.get(event.data.turn) ?? new Set<string>()
+        for (const diff of detail.diffs) set.add(diff.path)
+        acc.turnFiles.set(event.data.turn, set)
+      }
+      const update = (entry: ToolEntry): ToolEntry => ({
+        ...entry,
+        state: block.isError === true ? 'error' as const : 'done' as const,
+        summary,
+        detail,
+      })
+      // Every matching row updates (duplicate callIds included); an id with no
+      // registered index is a provable no-op — no full-array fallback scan.
+      updateReplayById<ToolEntry>(acc, acc.toolIndex, block.toolCallId, entry => entry.callId === block.toolCallId, update)
+      acc.stats = {
+        ...acc.stats,
+        toolMs: acc.stats.toolMs + (started === undefined ? 0 : Math.max(0, event.time - started)),
+        contextSegments: {
+          ...acc.stats.contextSegments,
+          tools: acc.stats.contextSegments.tools + estimateTokens(rawText),
+        },
+      }
+      return
+    }
+    case 'todo/write':
+      acc.todos = event.data.todos
+      return
+    case 'turn/start': {
+      const wasBusy = acc.busy
+      acc.busy = true
+      acc.busySince = wasBusy ? acc.busySince : event.time
+      acc.todos = []
+      acc.stats = { ...acc.stats, turns: acc.stats.turns + 1 }
+      return
+    }
+    case 'step/start': {
+      const key = `${event.data.turn}:${event.data.step}`
+      const previous = acc.turnSteps.get(event.data.turn)
+      if (previous !== undefined && previous !== key) {
+        acc.stepStart.delete(previous)
+        acc.firstChunkAt.delete(previous)
+      }
+      acc.turnSteps.set(event.data.turn, key)
+      acc.stepStart.set(key, event.time)
+      acc.stats = { ...acc.stats, steps: acc.stats.steps + 1 }
+      return
+    }
+    case 'turn/end': {
+      const reason = event.data.reason
+      const appended: TranscriptEntry[] = []
+      if (reason.kind === 'error') {
+        const recovery = reason.error.code === 'MISSING_CREDENTIAL'
+          ? ' · open /model to add an API key'
+          : ''
+        appended.push({ kind: 'error', text: `${reason.error.code}: ${reason.error.message}${recovery}` })
+      } else {
+        const marker = reason.kind === 'aborted'
+          ? reason.reason.kind === 'user' ? 'turn cancelled by the user' : `turn cancelled (${reason.reason.kind})`
+          : reason.kind === 'max-tokens'
+            ? 'turn hit the output-token ceiling (max-tokens)'
+            : reason.kind === 'blocked'
+              ? 'turn ended blocked'
+              : reason.kind === 'interrupted'
+                ? 'turn was interrupted by a restart'
+                : undefined
+        if (marker !== undefined) appended.push({ kind: 'turn-marker', text: marker })
+      }
+      const files = acc.turnFiles.get(event.data.turn)
+      acc.turnFiles.delete(event.data.turn)
+      if (files !== undefined && files.size > 0) appended.push({ kind: 'files', paths: [...files].slice(0, 12) })
+      const stepKey = acc.turnSteps.get(event.data.turn)
+      if (stepKey !== undefined) {
+        acc.stepStart.delete(stepKey)
+        acc.firstChunkAt.delete(stepKey)
+        acc.turnSteps.delete(event.data.turn)
+      }
+      const turnToolSet = acc.turnTools.get(event.data.turn)
+      if (turnToolSet !== undefined) {
+        for (const callId of turnToolSet) acc.toolStart.delete(callId)
+        acc.turnTools.delete(event.data.turn)
+      }
+      acc.busy = false
+      acc.busySince = 0
+      for (const entry of appended) appendReplayEntry(acc, entry)
+      return
+    }
+    case 'llm/retry': {
+      const data = event.data
+      appendReplayEntry(acc, {
+        kind: 'retry',
+        retryId: data.retryId,
+        attempt: data.retry,
+        max: 'maxRetries' in data ? data.maxRetries : data.retry,
+        code: data.failure.code,
+        delayMs: data.delayMs,
+        state: 'running',
+      })
+      indexList(acc.retryIndex, data.retryId).push(acc.entries.length - 1)
+      return
+    }
+    case 'llm/retry-started': {
+      const data = event.data
+      updateReplayById<RetryEntry>(acc, acc.retryIndex, data.retryId, entry => entry.retryId === data.retryId, entry => ({ ...entry, state: 'done' as const }))
+      return
+    }
+    case 'sandbox/mode':
+      acc.sandbox = event.data.mode
+      return
+    case 'goal/change': {
+      const data = event.data
+      const clip = (text: string): string => (text.length > 60 ? `${text.slice(0, 59)}…` : text)
+      if (data.operation === 'clear') {
+        acc.goal = undefined
+        appendReplayEntry(acc, { kind: 'turn-marker', text: '◎ goal cleared' })
+        return
+      }
+      const goal: GoalFold = {
+        objective: data.goal.objective,
+        phase: data.goal.phase,
+        rounds: data.roundsStarted,
+        max: data.goal.maxGoalRounds,
+        blocked: data.goal.blockedReason?.message ?? '',
+      }
+      const line = data.operation === 'create'
+        ? `◎ goal: ${clip(data.goal.objective)}`
+        : data.operation === 'complete'
+          ? '◎ goal complete'
+          : data.operation === 'pause'
+            ? '◎ goal paused'
+            : data.operation === 'resume'
+              ? '◎ goal resumed'
+              : data.operation === 'block'
+                ? `◎ goal blocked: ${clip(goal.blocked)}`
+                : undefined
+      acc.goal = goal
+      if (line !== undefined) appendReplayEntry(acc, { kind: 'turn-marker', text: line })
+      return
+    }
+    case 'session/title':
+      acc.title = event.data.title
+      return
+    case 'compaction/summary':
+      if (acc.compactionTokens.size >= MAX_COMPACTION_SUMMARY_RESIDUE) {
+        const oldest = acc.compactionTokens.keys().next().value
+        if (oldest !== undefined) acc.compactionTokens.delete(oldest)
+      }
+      acc.compactionTokens.set(event.data.compactionId, event.data.shadowedTokenCount)
+      return
+    case 'compaction/prune':
+      acc.lastPruneTokens = event.data.shadowedTokenCount
+      return
+    case 'compaction/end': {
+      const ok = event.data.error === undefined
+      const tokens = acc.compactionTokens.get(event.data.compactionId) ?? acc.lastPruneTokens
+      acc.compactionTokens.delete(event.data.compactionId)
+      appendReplayEntry(acc, { kind: 'compaction', ok, tokens, error: event.data.error ?? '' })
+      return
+    }
+    case 'request/context':
+      acc.stats = { ...acc.stats, contextWindow: event.data.contextWindow ?? acc.stats.contextWindow }
+      return
+    case 'request/header': {
+      const config = event.data.header.config
+      acc.model = `${config.provider}/${config.model}`
+      acc.stats = {
+        ...acc.stats,
+        reasoningEffort: config.reasoningEffort === undefined ? '' : String(config.reasoningEffort),
+        contextSegments: {
+          ...acc.stats.contextSegments,
+          system: estimateTokens(event.data.header.system ?? ''),
+        },
+      }
+      return
+    }
+    case 'plan/mode':
+      acc.plan = event.data.active
+      return
+    case 'permission/preset':
+      acc.permission = event.data.preset
+      return
+    case 'command/run': {
+      const data = event.data
+      appendReplayEntry(acc, {
+        kind: 'command',
+        commandId: data.commandId,
+        name: data.name,
+        args: data.args ?? '',
+        state: 'running',
+        summary: '',
+      })
+      indexList(acc.commandIndex, data.commandId).push(acc.entries.length - 1)
+      return
+    }
+    case 'command/done': {
+      const data = event.data
+      const update = (candidate: CommandEntry): CommandEntry => ({
+        ...candidate,
+        state: data.kind === 'success' ? 'done' as const : 'error' as const,
+        summary: boundContextSummary(data.text ?? ''),
+      })
+      updateReplayById<CommandEntry>(acc, acc.commandIndex, data.commandId, entry => entry.commandId === data.commandId, update)
+      return
+    }
+    default:
+      return
+  }
+}
+
+/**
+ * Materialize the accumulated fold as a `TranscriptView`, compacting any
+ * retired tombstones. The anchors maps are handed through as-is (their
+ * content is identical to a sequential fold's).
+ *
+ * @internal Test-instrumentation path; `projectEvents` is the public entry.
+ */
+export function finishReplay(acc: ReplayAccumulator): TranscriptView {
+  const entries: readonly TranscriptEntry[] = acc.removedCount === 0
+    ? acc.entries as TranscriptEntry[]
+    : acc.entries.filter((entry): entry is TranscriptEntry => entry !== undefined)
+  if (acc.removedCount > 0) acc.ops += acc.entries.length
+  return {
+    entries,
+    streaming: acc.streaming,
+    streamingReasoning: acc.streamingReasoning,
+    todos: acc.todos,
+    busy: acc.busy,
+    busySince: acc.busySince,
+    model: acc.model,
+    plan: acc.plan,
+    permission: acc.permission,
+    title: acc.title,
+    sandbox: acc.sandbox,
+    goal: acc.goal,
+    pending: { 'next-turn': [...acc.pendingTurn], 'next-step': [...acc.pendingStep] },
+    stats: acc.stats,
+    anchors: {
+      stepStart: acc.stepStart,
+      toolStart: acc.toolStart,
+      firstChunkAt: acc.firstChunkAt,
+      compactionTokens: acc.compactionTokens,
+      lastPruneTokens: acc.lastPruneTokens,
+      turnFiles: acc.turnFiles,
+      turnSteps: acc.turnSteps,
+      turnTools: acc.turnTools,
+    },
+  }
+}
+
 /**
  * Fold a replayed event history into one view.
+ *
+ * Folding is near-linear in the log size: the mutable replay accumulator
+ * appends in place and resolves id-keyed updates through index maps, so a
+ * long persisted session replays without the O(N²) copy-on-write rebuilds a
+ * naive sequential fold would incur. The result is identical to folding
+ * {@link projectEvent} per event in order.
  * @param events - events in `seq` order.
  * @returns the folded view.
  */
 export function projectEvents(events: readonly SessionEvent[]): TranscriptView {
-  return events.reduce(projectEvent, createTranscriptView())
+  const acc = createReplayAccumulator()
+  for (const event of events) replayProjectEvent(acc, event)
+  return finishReplay(acc)
 }
 
 /**
@@ -748,8 +1403,11 @@ export function projectEvents(events: readonly SessionEvent[]): TranscriptView {
  * the inbox claims or cancels them durably (`agent/inbox/spliced` removals,
  * `user/message` retirement), and an append-only `<Static>` flush cannot
  * erase a row that vanishes from the view — the retired row would ghost on
- * screen until the next source-backed replay. Everything else (including a
- * completed tail) is final: later events only APPEND new rows.
+ * screen until the next source-backed replay. Running commands join the
+ * mutable boundary for the same reason in reverse: `command/done` mutates the
+ * row's state/summary, so a flushed row would keep its stale running mark
+ * until a resize-triggered replay. Everything else (including a completed
+ * tail) is final: later events only APPEND new rows.
  * @param entries - the view's transcript entries in order.
  * @returns the count of entries safe to flush (0 for an empty transcript).
  */
@@ -759,6 +1417,7 @@ export function settledEntryCount(entries: readonly TranscriptEntry[]): number {
     if (entry.kind === 'pending') return index
     if (entry.kind === 'tool' && entry.state === 'running') return index
     if (entry.kind === 'retry' && entry.state === 'running') return index
+    if (entry.kind === 'command' && entry.state === 'running') return index
   }
   return entries.length
 }