dsh-code 0.3.0 → 0.5.0

package/src/render/lines.ts

@@ -0,0 +1,207 @@
+/** Width-safe styled physical rows for bounded terminal panels. */
+
+import type { TranscriptEntry } from './projection.ts'
+import type { ToolDetail } from './tool-detail.ts'
+import { renderMarkdown, visibleColumns, type MdStyle } from './markdown.ts'
+import { formatTokens } from './status.ts'
+import { displayText } from './text.ts'
+
+/** Presentation classes mapped to Ink colors by the app boundary. */
+export type LineStyle = MdStyle | 'brand' | 'success' | 'error' | 'warn' | 'dimItalic'
+
+/** One styled run within a physical terminal row. */
+export interface StyledSegment {
+  text: string
+  style: LineStyle
+}
+
+/** One row guaranteed not to exceed the requested terminal width. */
+export interface StyledLine {
+  segments: readonly StyledSegment[]
+}
+
+/** Construct one segment without leaking mutable objects into cached rows. */
+export function lineSegment(text: string, style: LineStyle = 'plain'): StyledSegment {
+  return { text, style }
+}
+
+/** Append a character while merging adjacent runs with the same style. */
+function appendSegment(target: StyledSegment[], text: string, style: LineStyle): void {
+  const previous = target[target.length - 1]
+  if (previous?.style === style) {
+    target[target.length - 1] = { text: previous.text + text, style }
+    return
+  }
+  target.push({ text, style })
+}
+
+/**
+ * Sanitize and hard-wrap styled content into exact physical rows.
+ * Tabs become two visible spaces because terminal tab stops are contextual
+ * and therefore cannot participate in a deterministic row budget.
+ */
+export function styledLines(segments: readonly StyledSegment[], columns: number): readonly StyledLine[] {
+  const width = Math.max(1, Math.floor(columns))
+  const lines: StyledLine[] = []
+  let current: StyledSegment[] = []
+  let used = 0
+  const flush = (): void => {
+    lines.push({ segments: current })
+    current = []
+    used = 0
+  }
+
+  for (const segment of segments) {
+    const safe = displayText(segment.text).replaceAll('\t', '  ').replaceAll('\r', '')
+    for (const char of safe) {
+      if (char === '\n') {
+        flush()
+        continue
+      }
+      const cells = visibleColumns(char)
+      if (used > 0 && used + cells > width) flush()
+      appendSegment(current, char, segment.style)
+      used += cells
+    }
+  }
+  if (current.length > 0 || lines.length === 0) flush()
+  return lines
+}
+
+/** Plain/dim text convenience over {@link styledLines}. */
+export function textLines(text: string, columns: number, style: LineStyle = 'plain'): readonly StyledLine[] {
+  return styledLines([lineSegment(text, style)], columns)
+}
+
+/** Markdown rows re-hardened so a single long word cannot escape the budget. */
+export function markdownLines(text: string, columns: number): readonly StyledLine[] {
+  const width = Math.max(1, Math.floor(columns))
+  const parsed = renderMarkdown(displayText(text), Math.max(10, width))
+  return parsed.flatMap(line => styledLines(
+    line.segments.map(segment => lineSegment(segment.text, segment.style)),
+    width,
+  ))
+}
+
+/** Expanded structured tool detail as scrollable, width-safe rows. */
+function toolDetailLines(detail: ToolDetail, columns: number): readonly StyledLine[] {
+  switch (detail.kind) {
+    case 'diff':
+      return detail.diffs.flatMap(diff => [
+        ...styledLines([
+          lineSegment('  ── ', 'dim'),
+          lineSegment(diff.path, 'dim'),
+          lineSegment(diff.truncated ? ' (diff truncated)' : '', 'dim'),
+        ], columns),
+        ...diff.lines.flatMap(line => styledLines([
+          lineSegment(`  ${line.mark}${line.text}`, line.mark === '+' ? 'success' : line.mark === '-' ? 'error' : 'dim'),
+        ], columns)),
+      ])
+    case 'read':
+      return [
+        ...textLines(
+          `  ── ${detail.path} · lines ${detail.offset}-${detail.lines.length > 0 ? detail.lines[detail.lines.length - 1]!.number : detail.offset - 1} of ${detail.totalLines}${detail.truncated ? ' (window truncated)' : ''}`,
+          columns,
+          'dim',
+        ),
+        ...detail.lines.flatMap(line => textLines(`  ${String(line.number).padStart(5, ' ')} | ${line.text}`, columns, 'dim')),
+      ]
+    case 'web-search':
+      return [
+        ...detail.sources.flatMap(source => [
+          ...styledLines([
+            lineSegment(`  ? ${source.title ?? source.url}`, 'brand'),
+            lineSegment(` - ${source.url}`, 'dim'),
+          ], columns),
+          ...(source.snippet === '' ? [] : textLines(`    ${source.snippet}`, columns, 'dim')),
+        ]),
+        ...textLines(`  ${detail.sources.length} sources${detail.truncated ? ' (capped)' : ''}`, columns, 'dim'),
+      ]
+    case 'web-fetch':
+      return textLines(`  ${detail.url} · HTTP ${detail.statusCode}`, columns, 'dim')
+    case 'raw':
+      return [
+        ...textLines(`  ${detail.text}`, columns, 'dim'),
+        ...textLines(detail.truncated ? '  … (output truncated)' : '  (end of output)', columns, 'dim'),
+      ]
+    default: {
+      const exhaustive: never = detail
+      return exhaustive
+    }
+  }
+}
+
+/**
+ * Convert one durable transcript entry to its complete scrollable row model.
+ * The source entry stays intact; only the caller's visible slice is rendered.
+ */
+export function transcriptEntryLines(entry: TranscriptEntry, columns: number): readonly StyledLine[] {
+  const width = Math.max(1, Math.floor(columns))
+  switch (entry.kind) {
+    case 'user':
+      return styledLines([
+        lineSegment(entry.notice ? '⤷ ' : '❯ ', entry.notice ? 'dim' : 'brand'),
+        lineSegment(entry.text, entry.notice ? 'dim' : 'plain'),
+      ], width)
+    case 'assistant':
+      return [
+        ...(entry.reasoning === ''
+          ? []
+          : styledLines([
+            lineSegment('  ✻ ', 'dimItalic'),
+            lineSegment(entry.reasoning, 'dimItalic'),
+          ], width)),
+        ...markdownLines(entry.text, width),
+      ]
+    case 'tool': {
+      const mark = entry.state === 'running' ? '●' : entry.state === 'error' ? '⨯' : '⏺'
+      const markStyle: LineStyle = entry.state === 'running' ? 'brand' : entry.state === 'error' ? 'error' : 'success'
+      return [
+        ...styledLines([
+          lineSegment(`${mark} `, markStyle),
+          lineSegment(entry.name, 'brand'),
+          lineSegment(entry.preview === '' ? '' : ` ${entry.preview}`, 'dim'),
+        ], width),
+        ...(entry.summary === '' ? [] : textLines(`  ⎿ ${entry.summary}`, width, entry.state === 'error' ? 'error' : 'dim')),
+        ...(entry.detail === undefined ? [] : toolDetailLines(entry.detail, width)),
+      ]
+    }
+    case 'command': {
+      const mark = entry.state === 'running' ? '●' : entry.state === 'error' ? '⨯' : '⏺'
+      const markStyle: LineStyle = entry.state === 'running' ? 'brand' : entry.state === 'error' ? 'error' : 'success'
+      return [
+        ...styledLines([
+          lineSegment(`${mark} `, markStyle),
+          lineSegment(`/${entry.name}`, 'brand'),
+          lineSegment(entry.args === '' ? '' : ` ${entry.args}`, 'dim'),
+        ], width),
+        ...(entry.summary === '' ? [] : textLines(`  ⎿ ${entry.summary}`, width, entry.state === 'error' ? 'error' : 'dim')),
+      ]
+    }
+    case 'turn-marker':
+      return textLines(`  ⏹ ${entry.text}`, width, 'dim')
+    case 'compaction':
+      return textLines(entry.ok
+        ? `  ⧉ compacted ~${formatTokens(entry.tokens)} tokens`
+        : `  ⧉ compaction failed: ${entry.error}`, width, 'dim')
+    case 'retry':
+      return textLines(
+        `  ↻ retry ${entry.attempt}/${entry.max} · ${entry.code} · ${Math.round(entry.delayMs / 100) / 10}s`,
+        width,
+        entry.state === 'running' ? 'warn' : 'dim',
+      )
+    case 'files':
+      return entry.paths.length === 0
+        ? textLines('  ⎄ no changed files', width, 'dim')
+        : [
+          ...textLines(`  ⎄ ${entry.paths.length} changed file${entry.paths.length === 1 ? '' : 's'}`, width, 'dim'),
+          ...entry.paths.flatMap(path => textLines(`    ${path}`, width, 'dim')),
+        ]
+    case 'error':
+      return textLines(entry.text, width, 'error')
+    default: {
+      const exhaustive: never = entry
+      return exhaustive
+    }
+  }
+}

package/src/render/markdown.ts

@@ -166,11 +166,18 @@ const ORDERED = /^\s*(\d+)[.)]\s+(.*)$/u
 /** Render markdown text into styled lines of at most `width` columns. */
 export function renderMarkdown(text: string, width: number): readonly MdLine[] {
   const lines: MdLine[] = []
+  let separatorPending = false
   const push = (segments: readonly MdSegment[]): void => {
     for (const wrapped of wrapSegments(segments, Math.max(10, width))) {
       lines.push({ segments: merge(wrapped) })
     }
   }
+  const startBlock = (): void => {
+    if (separatorPending && lines.length > 0 && lines.at(-1)?.segments.length !== 0) {
+      lines.push({ segments: [] })
+    }
+    separatorPending = false
+  }
   const raw = text.replaceAll('\r', '')
   const source = raw.split('\n')
   let index = 0
@@ -178,6 +185,14 @@ export function renderMarkdown(text: string, width: number): readonly MdLine[] {
     const line = source[index] ?? ''
     index += 1
 
+    // Preserve one deliberate row between source blocks. Repeated blank
+    // lines collapse, and leading/trailing whitespace never grows output.
+    if (line.trim() === '') {
+      separatorPending = lines.length > 0
+      continue
+    }
+    startBlock()
+
     // Fenced code block: verbatim lines in code style, language label first.
     const fence = FENCE.exec(line)
     if (fence !== null) {
@@ -191,7 +206,6 @@ export function renderMarkdown(text: string, width: number): readonly MdLine[] {
       continue
     }
 
-    if (line.trim() === '') continue
     if (RULE.test(line.trim())) {
       push([seg(`  ${'─'.repeat(Math.max(1, Math.floor(width / 4)))}`, 'dim')])
       continue

package/src/render/projection.ts

@@ -9,13 +9,29 @@
 
 import { boundContextSummary, type ContentBlock } from '@deepseek-ai/dsh-llm'
 import type { SessionEvent, TodoItem } from '@deepseek-ai/dsh-session'
-// Type-only imports merge the plugin-owned SessionEventMap variants (command/*
-// from dsh-commands, plan/mode, permission/preset) into the union this reducer
-// switches on.
+// Type-only imports merge the plugin-owned SessionEventMap variants
+// (command/*, compaction/*, goal/change, llm/retry*, plan/mode,
+// permission/preset, sandbox/mode, session/title) into the union this
+// reducer switches on.
 import type {} from '@deepseek-ai/dsh-commands'
+import type {} from '@deepseek-ai/dsh-compaction'
+import type {} from '@deepseek-ai/dsh-goal'
+import type {} from '@deepseek-ai/dsh-llm-retry'
 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 { 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
+
+/** Append one delta without retaining an unbounded duplicate of the live reply. */
+function appendStreamingTail(current: string, delta: string): string {
+  const next = current + delta
+  return next.length <= MAX_STREAMING_CHARS ? next : next.slice(-MAX_STREAMING_CHARS)
+}
 
 /** One user prompt line. */
 export interface UserEntry {
@@ -51,6 +67,12 @@ export interface ToolEntry {
   state: 'running' | 'done' | 'error'
   /** Bounded first text block of the result, empty until it lands. */
   summary: string
+  /**
+   * Bounded expansion payload for the verbose transcript (Ctrl+O), derived
+   * from the tool's persisted presentation metadata; undefined until the
+   * result lands and only when something renderable exists.
+   */
+  detail: ToolDetail | undefined
 }
 
 /** One slash-command execution dispatched through `ctx.commands`. */
@@ -75,8 +97,62 @@ export interface ErrorEntry {
   text: string
 }
 
+/** One non-error turn outcome surfaced from `turn/end`. */
+export interface TurnMarkerEntry {
+  kind: 'turn-marker'
+  /** Human-readable outcome line, dim-rendered. */
+  text: string
+}
+
+/** One completed compaction lifecycle surfaced from `compaction/end`. */
+export interface CompactionEntry {
+  kind: 'compaction'
+  /** True when the compaction completed, false when it failed. */
+  ok: boolean
+  /** Heuristic tokens shadowed by the compaction (summary or prune price). */
+  tokens: number
+  /** Failure text when `ok` is false, empty otherwise. */
+  error: string
+}
+
+/** One provider-routed model-request retry (the `llm/retry` pair). */
+export interface RetryEntry {
+  kind: 'retry'
+  /** Correlation id shared with the matching `llm/retry-started`. */
+  retryId: string
+  /** Attempt ordinal and its cap. */
+  attempt: number
+  max: number
+  /** Failure code that triggered the retry. */
+  code: string
+  /** Backoff wait before the next attempt, in ms. */
+  delayMs: number
+  /** `running` while the backoff waits, `done` once the attempt started. */
+  state: 'running' | 'done'
+}
+
+/** Turn-tail deliverables: files mutated by the turn's diff-bearing tools. */
+export interface FilesEntry {
+  kind: 'files'
+  /** Unique mutated paths in call order, bounded. */
+  paths: readonly string[]
+}
+
 /** Ordered transcript items the renderer draws. */
-export type TranscriptEntry = UserEntry | AssistantEntry | ToolEntry | CommandEntry | ErrorEntry
+export type TranscriptEntry = UserEntry | AssistantEntry | ToolEntry | CommandEntry | ErrorEntry | TurnMarkerEntry | CompactionEntry | RetryEntry | FilesEntry
+
+/** The live goal the status line badges, folded from `goal/change`. */
+export interface GoalFold {
+  /** Human-requested completion objective. */
+  objective: string
+  /** Durable lifecycle phase. */
+  phase: 'active' | 'paused' | 'blocked' | 'complete'
+  /** Highest admitted continuation round and its cap. */
+  rounds: number
+  max: number
+  /** Blocked explanation, empty outside the blocked phase. */
+  blocked: string
+}
 
 /** Cumulative token accounting folded from `assistant/message` usage reports. */
 export interface UsageTotals {
@@ -100,20 +176,34 @@ export interface TranscriptStats {
   toolMs: number
   /** Cumulative token accounting; input stays 0 until a report lands. */
   usage: UsageTotals
+  /** Prompt-side size of the most recent reported request (context pressure). */
+  lastPromptTokens: number
+  /** Newest advertised route capacity, 0 when no adapter ever advertised one. */
+  contextWindow: number
+  /** Summed first-token waits: `step/start` → first non-empty chunk, in ms. */
+  ttftMs: number
+  /** Steps that produced a first chunk (the TTFT average's denominator). */
+  ttftSteps: number
+  /** Summed decode spans: first chunk → `assistant/message`, in ms. */
+  decodeMs: number
+  /** Completion tokens over timed decode spans (the tok/s numerator). */
+  decodeTokens: number
 }
 
 /** The complete TUI transcript view for one session. */
 export interface TranscriptView {
   /** Settled entries in log order. */
   entries: readonly TranscriptEntry[]
-  /** Text accumulated from `assistant/chunk` deltas since the last flush. */
+  /** Bounded text tail accumulated from `assistant/chunk` deltas since the last flush. */
   streaming: string
-  /** Thinking accumulated from `assistant/chunk` reasoning deltas since the last flush. */
+  /** Bounded thinking tail accumulated from reasoning deltas since the last flush. */
   streamingReasoning: string
   /** Latest whole-list todo snapshot from `todo/write`, empty when none. */
   todos: readonly TodoItem[]
   /** True while a durable turn is open (`turn/start` … `turn/end`). */
   busy: boolean
+  /** `turn/start` time of the open turn (0 while idle) — the web TurnStatus clock anchor. */
+  busySince: number
   /** Figures the status line renders. */
   stats: TranscriptStats
   /**
@@ -127,12 +217,18 @@ export interface TranscriptView {
   plan: boolean
   /** Active permission preset folded from the last `permission/preset` event, empty before one. */
   permission: string
+  /** Latest session title folded from the last `session/title` event, empty before one. */
+  title: string
+  /** Sandbox-mode override folded from the last `sandbox/mode` event, empty when never switched. */
+  sandbox: string
+  /** Current long-running goal folded from the last `goal/change`, undefined when cleared. */
+  goal: GoalFold | undefined
   /**
    * 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.
    */
-  readonly anchors: { stepStart: Map<string, number>; toolStart: Map<string, number> }
+  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>> }
 }
 
 /** Join the text blocks of a content list; non-text blocks contribute nothing. */
@@ -153,11 +249,15 @@ export function createTranscriptView(): TranscriptView {
     streamingReasoning: '',
     todos: [],
     busy: false,
+    busySince: 0,
     model: '',
     plan: false,
     permission: '',
-    stats: { turns: 0, steps: 0, llmMs: 0, toolMs: 0, usage: { inputTokens: 0, outputTokens: 0, cacheReadTokens: 0 } },
-    anchors: { stepStart: new Map(), toolStart: new Map() },
+    title: '',
+    sandbox: '',
+    goal: undefined,
+    stats: { turns: 0, steps: 0, llmMs: 0, toolMs: 0, usage: { inputTokens: 0, outputTokens: 0, cacheReadTokens: 0 }, lastPromptTokens: 0, contextWindow: 0, ttftMs: 0, ttftSteps: 0, decodeMs: 0, decodeTokens: 0 },
+    anchors: { stepStart: new Map(), toolStart: new Map(), firstChunkAt: new Map(), compactionTokens: new Map(), lastPruneTokens: 0, turnFiles: new Map() },
   }
 }
 
@@ -184,11 +284,27 @@ export function projectEvent(view: TranscriptView, event: SessionEvent): Transcr
     }
     case 'assistant/chunk': {
       const chunk = event.data.chunk
+      // First-token latency: the first non-empty delta of a step anchors the
+      // TTFT (empty keep-alive deltas do not count as tokens).
+      const key = `${event.data.turn}:${event.data.step}`
+      const delta = chunk.type === 'text-delta' || chunk.type === 'reasoning-delta' ? chunk.text : ''
+      let stats = view.stats
+      if (delta !== '' && !view.anchors.firstChunkAt.has(key)) {
+        view.anchors.firstChunkAt.set(key, event.time)
+        const started = view.anchors.stepStart.get(key)
+        if (started !== undefined) {
+          stats = {
+            ...stats,
+            ttftMs: stats.ttftMs + Math.max(0, event.time - started),
+            ttftSteps: stats.ttftSteps + 1,
+          }
+        }
+      }
       if (chunk.type === 'text-delta') {
-        return { ...view, streaming: view.streaming + chunk.text }
+        return { ...view, streaming: appendStreamingTail(view.streaming, chunk.text), stats }
       }
       if (chunk.type === 'reasoning-delta') {
-        return { ...view, streamingReasoning: view.streamingReasoning + chunk.text }
+        return { ...view, streamingReasoning: appendStreamingTail(view.streamingReasoning, chunk.text), stats }
       }
       return view
     }
@@ -197,6 +313,8 @@ export function projectEvent(view: TranscriptView, event: SessionEvent): Transcr
       const key = `${event.data.turn}:${event.data.step}`
       const started = view.anchors.stepStart.get(key)
       view.anchors.stepStart.delete(key)
+      const firstChunk = view.anchors.firstChunkAt.get(key)
+      view.anchors.firstChunkAt.delete(key)
       const usage = event.data.usage
       const totals = view.stats.usage
       return {
@@ -216,6 +334,12 @@ export function projectEvent(view: TranscriptView, event: SessionEvent): Transcr
             outputTokens: totals.outputTokens + usage.outputTokens,
             cacheReadTokens: totals.cacheReadTokens + (usage.cacheReadTokens ?? 0),
           },
+          lastPromptTokens: usage === undefined ? view.stats.lastPromptTokens
+            : usage.inputTokens + (usage.cacheReadTokens ?? 0) + (usage.cacheWriteTokens ?? 0),
+          // Decode span and its tokens pair up: an un-timed step (no first
+          // chunk landed) contributes neither, so the rate stays honest.
+          decodeMs: view.stats.decodeMs + (firstChunk === undefined ? 0 : Math.max(0, event.time - firstChunk)),
+          decodeTokens: view.stats.decodeTokens + (firstChunk === undefined || usage === undefined ? 0 : usage.outputTokens),
         },
       }
     }
@@ -232,6 +356,7 @@ export function projectEvent(view: TranscriptView, event: SessionEvent): Transcr
           preview: toolArgumentsPreview(data.arguments, data.name),
           state: 'running',
           summary: '',
+          detail: undefined,
         }],
       }
     }
@@ -239,10 +364,21 @@ 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)
-      const summary = boundContextSummary(textOf(block.content))
+      const rawText = textOf(block.content)
+      const summary = boundContextSummary(rawText)
+      // The verbose expansion self-serves from the persisted presentation
+      // metadata (diffs, read windows, web sources) with the bounded raw text
+      // as the universal fallback — the capable-UI degradation ladder.
+      const detail = toolResultDetail(event.data.meta, rawText)
+      // Turn-tail deliverables: a diff-bearing mutation records its paths.
+      if (detail?.kind === 'diff') {
+        const set = view.anchors.turnFiles.get(event.data.turn) ?? new Set<string>()
+        for (const diff of detail.diffs) set.add(diff.path)
+        view.anchors.turnFiles.set(event.data.turn, set)
+      }
       const entries = view.entries.map((entry) => {
         if (entry.kind !== 'tool' || entry.callId !== block.toolCallId) return entry
-        return { ...entry, state: block.isError === true ? 'error' as const : 'done' as const, summary }
+        return { ...entry, state: block.isError === true ? 'error' as const : 'done' as const, summary, detail }
       })
       return {
         ...view,
@@ -262,6 +398,7 @@ export function projectEvent(view: TranscriptView, event: SessionEvent): Transcr
       return {
         ...view,
         busy: true,
+        busySince: view.busy ? view.busySince : event.time,
         todos: [],
         stats: { ...view.stats, turns: view.stats.turns + 1 },
       }
@@ -270,13 +407,119 @@ export function projectEvent(view: TranscriptView, event: SessionEvent): Transcr
       return { ...view, stats: { ...view.stats, steps: view.stats.steps + 1 } }
     case 'turn/end': {
       const reason = event.data.reason
-      if (reason.kind !== 'error') return { ...view, busy: false }
+      const appended: TranscriptEntry[] = []
+      if (reason.kind === 'error') {
+        appended.push({ kind: 'error', text: `${reason.error.code}: ${reason.error.message}` })
+      } else {
+        // Non-error outcomes deserve their own durable row (the web renders
+        // distinct max-tokens / abort / interruption nodes); `completed` stays
+        // silent so an ordinary turn never grows a marker.
+        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 })
+      }
+      // Deliverables ride the turn tail (the web's turnTail chips): the
+      // turn's mutated files flush as one bounded row, then the set resets.
+      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) })
+      if (appended.length === 0) return { ...view, busy: false, busySince: 0 }
+      return { ...view, busy: false, busySince: 0, entries: [...view.entries, ...appended] }
+    }
+    case 'llm/retry': {
+      const data = event.data
       return {
         ...view,
-        busy: false,
-        entries: [...view.entries, { kind: 'error', text: `${reason.error.code}: ${reason.error.message}` }],
+        entries: [...view.entries, {
+          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',
+        }],
       }
     }
+    case 'llm/retry-started': {
+      const data = event.data
+      const entries = view.entries.map((entry) => {
+        if (entry.kind !== 'retry' || entry.retryId !== data.retryId) return entry
+        return { ...entry, state: 'done' as const }
+      })
+      return { ...view, entries }
+    }
+    case 'sandbox/mode':
+      // Log-only override switch; last write wins for the status badge.
+      return { ...view, sandbox: event.data.mode }
+    case 'goal/change': {
+      const data = event.data
+      const clip = (text: string): string => (text.length > 60 ? `${text.slice(0, 59)}…` : text)
+      if (data.operation === 'clear') {
+        return {
+          ...view,
+          goal: undefined,
+          entries: [...view.entries, { kind: 'turn-marker', text: '◎ goal cleared' }],
+        }
+      }
+      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
+      return {
+        ...view,
+        goal,
+        entries: line === undefined ? view.entries : [...view.entries, { kind: 'turn-marker', text: line }],
+      }
+    }
+    case 'session/title':
+      // Latest-wins title snapshot, log-only; the status line prefers it.
+      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.
+      view.anchors.compactionTokens.set(event.data.compactionId, event.data.shadowedTokenCount)
+      return view
+    case 'compaction/prune':
+      // A model-free prune carries no compaction id; its price serves the next
+      // `compaction/end` that cannot find a summary price.
+      return { ...view, anchors: { ...view.anchors, lastPruneTokens: event.data.shadowedTokenCount } }
+    case 'compaction/end': {
+      const ok = event.data.error === undefined
+      const tokens = view.anchors.compactionTokens.get(event.data.compactionId) ?? view.anchors.lastPruneTokens
+      view.anchors.compactionTokens.delete(event.data.compactionId)
+      return {
+        ...view,
+        entries: [...view.entries, { kind: 'compaction', ok, tokens, error: event.data.error ?? '' }],
+      }
+    }
+    case 'request/context':
+      // Route capacity, logged only when it changes; last one wins.
+      return {
+        ...view,
+        stats: { ...view.stats, contextWindow: event.data.contextWindow ?? view.stats.contextWindow },
+      }
     case 'request/header': {
       // The session's own model record: the latest snapshot's provider/model
       // pair, exactly what a resumed TUI restores as the selection.
@@ -327,3 +570,23 @@ export function projectEvent(view: TranscriptView, event: SessionEvent): Transcr
 export function projectEvents(events: readonly SessionEvent[]): TranscriptView {
   return events.reduce(projectEvent, createTranscriptView())
 }
+
+/**
+ * How many leading transcript entries can never change again: only a
+ * `running` tool or retry can still mutate in place — everything before the
+ * first one (including a completed tail: later events only APPEND new rows)
+ * is final. The renderer currently draws the whole transcript dynamically
+ * (a `<Static>` flush proved unstable with CJK wrapping on real terminals);
+ * this boundary stays as the append-only contract for when flushing is
+ * reintroduced.
+ * @param entries - the view's transcript entries in order.
+ * @returns the count of entries safe to flush (0 for an empty transcript).
+ */
+export function settledEntryCount(entries: readonly TranscriptEntry[]): number {
+  for (let index = 0; index < entries.length; index++) {
+    const entry = entries[index]
+    if (entry.kind === 'tool' && entry.state === 'running') return index
+    if (entry.kind === 'retry' && entry.state === 'running') return index
+  }
+  return entries.length
+}