@pellux/goodvibes-tui 0.28.0 → 1.0.0

package/CHANGELOG.md

@@ -4,6 +4,139 @@ All notable changes to GoodVibes TUI.
 
 ---
 
+## [1.0.0] — 2026-07-03
+
+### Changes
+- d26fc23f ci: drop temporary renderer-excellence branch trigger after merge
+- 532c900b integrate renderer-excellence: renderer performance and correctness effort (v1.0.0 scope)
+- cdf5931d fix(input): normalize CR line endings from bracketed pastes
+- 1318959f chore(perf): re-capture baseline reference medians on a quiet box
+- 946a2c83 integrate WO-210 into renderer-excellence
+- 209ade5f perf(budgets): ratchet transcript.append_one 20ms->6ms; streaming tail proven non-material (WO-210)
+- c7e445c2 integrate WO-209 into renderer-excellence
+- df4d8d03 integrate WO-208 into renderer-excellence
+- f5476715 perf(conversation): per-message Line[] cache — append-one 45ms→0.9ms (WO-209)
+- 76539cd8 perf(renderer): WO-208 coalesce main.ts render() fan-out into one same-tick composite
+- 204342c4 refactor(renderer): delete the six dead exports parked during the R2 literal-ownership split
+- 9c1dbdae integrate WO-207 into renderer-excellence
+- ae660b2a integrate WO-206 into renderer-excellence
+- 6acd74f6 integrate WO-205 into renderer-excellence
+- c6eb004c feat(architecture): WO-206 no-unused-exports rule for src/renderer
+- 8997719b feat(renderer): WO-207 — palette unification across the renderer layer
+- 3ec18bb1 refactor(renderer): WO-205 dedup + dead code + honest picker
+- 43eb8165 ci: run full CI on renderer-excellence pushes for the v1.0.0 effort
+- 6e483f55 fix(renderer): diff panel keeps its shipped colors — the panels are the reference, not diff-view
+- 50755108 integrate WO-204 into renderer-excellence
+- 17425f6a integrate WO-203 into renderer-excellence
+- 68bc13c3 fix(renderer): WO-203 verified correctness fixes
+- 721f4d91 feat(renderer): WO-204 — restore conversation diff rendering, align diff surface colors
+- c5aff410 integrate WO-202 into renderer-excellence
+- 0f03a124 integrate WO-201 into renderer-excellence
+- e5ba2978 test(renderer): WO-201 golden contract expansion — splash, transcript scenes, all overlays
+- 210d5814 perf(scripts): WO-202 line-production benchmarks above the compositor
+- bf6459af fix(tests): skills delete test polls the rescanned state, not just file removal
+
+## [0.29.0] — 2026-07-03
+
+### Changes
+- 2842a791 perf(ci): parallelize the per-file test runner; raise the test job timeout
+- 218bb217 merge: panel-system remediation — 38 work orders, consoles not signposts (0.29.0)
+- a37c028e fix(input): WO-160 smoke findings — overlay write-back clobber, /ops view parity, panel-list honesty, modal viewport
+- 5741f633 fix(tests): isolate GitPanel non-repo test from the runner's in-tree TMPDIR
+- 6eaea7c4 fix(panels): WO-160 consistency sweep — alias tests, action-substitute signposts
+- 42164e34 fix(panels): cockpit c/i leave the key unconsumed on terminal or absent roster entries
+- 10247db1 feat(input): make Ctrl+O a real keybind for the Ops Control panel
+- ac598536 refactor(panels): route selected-row reads through getSelectedItem and ban raw [this.selectedIndex]
+- 34bac3f0 chore(panels): tighten hex-literal baseline to exact actual counts
+- 3d2caf90 integrate WO-153 into panel-ux-remediation
+- 1f0ed5ca integrate WO-152 into panel-ux-remediation
+- 8b6fbce6 integrate WO-151 into panel-ux-remediation
+- ce0b7cb8 fix(panels): closure-audit findings — incident/settings-sync filtered desyncs, subscription start signposts
+- ba7db35e feat(panels): WO-152 registry taxonomy, icons, always-register, lifecycle flags
+- 7cbdd4ec feat(panels): WO-153 filter-model convergence onto ScrollableListPanel
+- 40cb9153 feat(panels): WO-151 keybindings, help discoverability, one hint grammar
+- 782e7752 fix(panels): services test/detail act on the filtered selection
+- e8783a89 integrate WO-154 into panel-ux-remediation
+- cdb399b9 integrate WO-140 into panel-ux-remediation
+- 943089ea integrate WO-139 into panel-ux-remediation
+- d527c223 integrate WO-141 into panel-ux-remediation
+- a65ee307 integrate WO-150 into panel-ux-remediation
+- a73e874b feat(panels): WO-140 planning cluster polish (wrfc/project-planning/work-plan)
+- e1921ab8 feat(panels): WO-141 keep-panel hardening + residual signpost sweep
+- 8b018746 feat(panels): WO-139 provider-cost leftovers — subscription/local-auth/cost-tracker
+- da7b9550 feat(panels): WO-150 unify focus ownership in PanelManager
+- 4c569ae8 feat(shell): WO-154 main-UX shell splash, footer cost/compact, overlay posture
+- 7218349c fix(panels): wave 3a review findings — filtered-selection desyncs, residual signposts, dead constants
+- 1cc9f195 integrate WO-138 into panel-ux-remediation
+- 179a9a91 integrate WO-137 into panel-ux-remediation
+- 4df3036e integrate WO-136 into panel-ux-remediation
+- 20533671 integrate WO-135 into panel-ux-remediation
+- 2f116f82 integrate WO-134 into panel-ux-remediation
+- 595df267 integrate WO-133 into panel-ux-remediation
+- 490dc881 feat(panels): WO-137 diagnostics trio — security, debug, system-messages
+- 066fd91a feat(panels): WO-138 session-comm quad real actions (remote/communication/routes/qr)
+- a9a1ebe0 feat(panels): WO-134 Plugins + Hooks control rooms
+- e4380896 feat(panels): WO-136 Docs + Intelligence live actions
+- 8f6a3f45 feat(panels): WO-133 explorer + preview lazy loading, git decorations, diff/reload keys
+- 744dc460 feat(panels): WO-135 marketplace + skills real actions
+- a04c86e9 fix(panels): reserve summary row inside stacked scrollable section budgets
+- b2a43d9b fix(panels): reserve a row for the window-summary inside the scrollable budget
+- acb3e3b5 fix(panels): bind w to dispatch teamwork review from Tasks; stop git panel swallowing i on loaded repos
+- 4bc04330 integrate WO-130 into panel-ux-remediation
+- e15c010b integrate WO-128 into panel-ux-remediation
+- 3020d2e1 integrate WO-127 into panel-ux-remediation
+- 1a0c0d76 integrate WO-132 into panel-ux-remediation
+- 79ac40bd integrate WO-131 into panel-ux-remediation
+- 61092aa0 integrate WO-126 into panel-ux-remediation
+- f83d6820 feat(panels): WO-131 agent-runtime trio — tools + tasks + orchestration
+- 8dafc5c0 feat(panels): WO-132 Git + Diff consoles — stage/unstage/commit, explicit init confirm, self-loading diff panel
+- 24c5127e feat(panels): WO-128 plan dashboard revival
+- 2c8e8d1f feat(panels): WO-126 symbol outline on tree-sitter
+- 2d424e1c feat(panels): WO-130 Cockpit operator polish
+- 66c0deeb feat(panels): WO-127 eval console — baseline seed, live run, regressions
+- 1a53ef2c fix(panels): drop redundant slash-command guidance from knowledge review mode
+- 16ba104d fix(tests): operator-surfaces gate verifies forensics alias resolves to incident
+- a5b8f4e9 integrate FOLLOWUPS into panel-ux-remediation
+- f60988eb integrate WO-125 into panel-ux-remediation
+- 39996bfd integrate WO-124 into panel-ux-remediation
+- 78fb4916 integrate WO-123 into panel-ux-remediation
+- e5294103 integrate WO-122 into panel-ux-remediation
+- 371f4d60 integrate WO-121 into panel-ux-remediation
+- 1ff1e0ae integrate WO-120 into panel-ux-remediation
+- 933b09a3 feat(panels): WO-120 register ops-control panel and wire operator actions
+- 39bfc1a1 feat(panels): WO-125 wire worktree and sandbox lifecycle verbs to their registries
+- 4992fd03 feat(panels): WO-121 control-plane approvals console
+- ea1c47b0 feat(panels): WO-123 knowledge console replaces static command catalogue
+- 91273a60 feat(panels): WO-124 settings-sync console — resolve conflicts in-panel, Tab browse modes
+- 74f5d39d feat(panels): WO-122 policy governance console actions and depth
+- f4679a7e fix(panels): broaden hex-literal ratchet to 3/6/8-digit forms, clear remaining raw hex in fullscreen-primitives and diff-panel
+- 6e1b814c fix(panels): forensics resolves as alias to incident, not duplicate registration
+- 6a0f4405 fix(tests): operator-surfaces gate asserts merged provider-health id instead of retired providers id
+- 09d81371 fix(tests): retarget legacy-turn-bus ban from deleted context-visualizer-panel to its WO-113 successor token-budget-panel
+- e835a821 integrate WO-114 into panel-ux-remediation
+- 433b4c25 integrate WO-113 into panel-ux-remediation
+- 70466337 integrate WO-112 into panel-ux-remediation
+- a1ebf5da fix(tests): contract module count 30 after WO-110+WO-111 both deleted a module
+- fd25fb19 integrate WO-111 into panel-ux-remediation
+- 0d72a2ef integrate WO-110 into panel-ux-remediation
+- 0a344b60 WO-112: Provider console merge: providers + accounts into provider-health
+- d4c7c8b4 WO-111: Automation console merge: schedule + watchers into automation
+- 1fc22d27 WO-110: Agent console merge: agent-logs into inspector
+- 0d4858ff WO-114: Incident console merge: forensics into incident
+- a4cdfb3c WO-113: Context/token merge: context into tokens
+- fd8e84ef integrate WO-002 into panel-ux-remediation
+- 1a85ece3 WO-002: Panel palette and chrome sweep (extendPalette everywhere)
+- 1cd556da integrate WO-006 into panel-ux-remediation
+- d6effd51 integrate WO-005 into panel-ux-remediation
+- d7735d20 integrate WO-004 into panel-ux-remediation
+- 9b1de69a integrate WO-003 into panel-ux-remediation
+- e149323f integrate WO-001 into panel-ux-remediation
+- 45e90fa7 WO-006: Shared-test decongestion: per-panel spec modules
+- 2d7d5777 WO-001: Theme-token backbone + architecture-gate hex enforcement
+- 207cd46b WO-003: Action-callback plumbing pattern + ConfirmState generalization
+- abf6771b WO-005: session-maintenance evaluator dedup
+- 4fe16129 WO-004: Dead code and dead keybinding removal
+
 ## [0.28.0] — 2026-06-30
 
 Panel navigation & UI/UX overhaul, plus the accumulated post-0.27.0 UX fixes.

package/README.md

@@ -2,7 +2,7 @@
 
 [![CI](https://github.com/mgd34msu/goodvibes-tui/actions/workflows/ci.yml/badge.svg)](https://github.com/mgd34msu/goodvibes-tui/actions/workflows/ci.yml)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
-[![Version](https://img.shields.io/badge/version-0.28.0-blue.svg)](https://github.com/mgd34msu/goodvibes-tui)
+[![Version](https://img.shields.io/badge/version-1.0.0-blue.svg)](https://github.com/mgd34msu/goodvibes-tui)
 
 A terminal-native AI coding, operations, automation, knowledge, and integration console with a typed runtime, omnichannel surfaces, structured memory/knowledge, and a raw ANSI renderer.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pellux/goodvibes-tui",
-  "version": "0.28.0",
+  "version": "1.0.0",
   "description": "Terminal-native GoodVibes product for coding, operations, automation, knowledge, channels, and daemon-backed control-plane workflows.",
   "type": "module",
   "main": "src/main.ts",

package/src/core/conversation-line-cache.ts

@@ -0,0 +1,432 @@
+/**
+ * conversation-line-cache.ts — per-message Line[] production cache (WO-209).
+ *
+ * The measured defect (perf baseline 2026-07-03, transcript.build_1k): appending
+ * ONE message to an N-message conversation re-rendered all N messages
+ * (45.5 ms p50 / 71.4 MB / 695 k objects per rebuild), because
+ * ConversationManager.rebuildHistory() clears the buffer and calls
+ * appendConversationMessages() over the entire snapshot on every dirty flag —
+ * and markDirty() fires on every mutation. The marginal work for one appended
+ * message is ~1/1000th of that.
+ *
+ * This module memoises the per-message render. Each message's rendered output is
+ * a PURE function of its complete inputs:
+ *   - message identity + content (via a content signature; snapshots are fresh
+ *     structuredClone copies each call, so string content compares by value and
+ *     array-valued fields — user ContentPart[] and assistant toolCalls — are
+ *     serialised; a streaming assistant message mutates its content string in
+ *     place, which changes the signature and invalidates the entry)
+ *   - render width
+ *   - the four display-config values the render reads (line-number mode,
+ *     collapse threshold, showThinking, showReasoningSummary)
+ *   - the block-registry base at message start (the code-block collapseKey embeds
+ *     the GLOBAL block index — `code_${msgIdx}_${blockIdx}` — so a shift in an
+ *     earlier message's block count changes this message's keys)
+ *   - the absolute message index (embedded in every collapseKey and used for the
+ *     system-message kind lookup)
+ *   - the system-message kind (drives the error-navigation registry side effect)
+ *   - the live values of every collapseState key the render READS (recorded via a
+ *     proxy during a miss; a collapse toggle flips a recorded value and
+ *     invalidates exactly the owning message)
+ *
+ * Invalidation is by comparison of those complete inputs — the file-preview
+ * contentVersion precedent generalised: instead of a single version counter we
+ * compare the full input tuple, which is provably complete (a from-scratch
+ * rebuild reads nothing else).
+ *
+ * Correctness contract: a cache-served rebuild is BYTE-IDENTICAL to a cold
+ * appendConversationMessages() rebuild. This is guaranteed by construction — a
+ * miss renders through the exact same per-message render functions into an
+ * isolated scratch context, and the captured lines / block metas / error lines
+ * are replayed at the same buffer offsets a cold render would have produced.
+ */
+
+import { createEmptyLine, type Line } from '../types/grid.ts';
+import type { BlockMeta } from './conversation-types.ts';
+import type { ConversationRenderContext } from './conversation-rendering.ts';
+import {
+  renderConversationAssistantMessage,
+  renderConversationSystemMessage,
+  renderConversationToolMessage,
+  renderConversationUserMessage,
+} from './conversation-rendering.ts';
+import type { ConversationMessageSnapshot } from '@pellux/goodvibes-sdk/platform/core';
+// SystemMessageKind imported from runtime directly to avoid a cycle, mirroring
+// conversation-rendering.ts's own import.
+import type { SystemMessageKind } from '@/runtime/index.ts';
+
+type Message = ConversationMessageSnapshot;
+
+/** The display-config values every message render depends on. */
+interface RenderConfig {
+  readonly lineNumberMode: 'all' | 'code' | 'off';
+  readonly collapseThreshold: number;
+  readonly showThinking: boolean;
+  readonly showReasoningSummary: boolean;
+}
+
+/**
+ * Content signature: the render-relevant fields of a message, captured so an
+ * unchanged message is recognised without re-rendering. Array-valued fields are
+ * pre-serialised to strings so equality is a value comparison.
+ */
+interface ContentSig {
+  readonly role: Message['role'];
+  /** String content, or JSON of ContentPart[] for array-valued user content. */
+  readonly content: string;
+  readonly cancelled?: boolean;
+  readonly model?: string;
+  readonly provider?: string;
+  readonly reasoningContent?: string;
+  readonly reasoningSummary?: string;
+  readonly toolCallsJson?: string;
+  readonly callId?: string;
+  readonly toolName?: string;
+}
+
+/** Non-content inputs that key the cache entry. */
+interface KeyMeta {
+  readonly role: Message['role'];
+  readonly width: number;
+  readonly lineNumberMode: 'all' | 'code' | 'off';
+  readonly collapseThreshold: number;
+  readonly showThinking: boolean;
+  readonly showReasoningSummary: boolean;
+  readonly blockBase: number;
+  readonly kind: SystemMessageKind | undefined;
+}
+
+interface CacheEntry {
+  readonly keyMeta: KeyMeta;
+  readonly contentSig: ContentSig;
+  /** Rendered lines for this message, INCLUDING the trailing blank line. */
+  readonly lines: Line[];
+  /** Block metas with startLine RELATIVE to the message's first line. */
+  readonly blocks: BlockMeta[];
+  /** Error-navigation line offsets, RELATIVE to the message's first line. */
+  readonly errorRelLines: number[];
+  /** [collapseKey, value] pairs the render read; a change invalidates the entry. */
+  readonly collapseDeps: Array<[string, boolean | undefined]>;
+  /** Memoised rebase of blocks/errors at appliedBase (avoids realloc when the
+   *  message's buffer offset is unchanged across rebuilds — the common case). */
+  appliedBase: number;
+  appliedBlocks: BlockMeta[] | null;
+  appliedErrors: number[] | null;
+}
+
+/** Build the content signature for a message. */
+function contentSigOf(m: Message): ContentSig {
+  if (m.role === 'user') {
+    return {
+      role: 'user',
+      content: typeof m.content === 'string' ? m.content : JSON.stringify(m.content),
+      cancelled: m.cancelled,
+    };
+  }
+  if (m.role === 'assistant') {
+    return {
+      role: 'assistant',
+      content: m.content,
+      model: m.model,
+      provider: m.provider,
+      reasoningContent: m.reasoningContent,
+      reasoningSummary: m.reasoningSummary,
+      toolCallsJson: m.toolCalls ? JSON.stringify(m.toolCalls) : undefined,
+    };
+  }
+  if (m.role === 'system') {
+    return { role: 'system', content: m.content };
+  }
+  return { role: 'tool', content: m.content, callId: m.callId, toolName: m.toolName };
+}
+
+/**
+ * Compare a stored signature against a message WITHOUT allocating a new
+ * signature object on the hot (unchanged string-content) path. Array-valued
+ * fields fall back to JSON serialisation (rare).
+ */
+function contentUnchanged(sig: ContentSig, m: Message): boolean {
+  if (sig.role !== m.role) return false;
+  switch (m.role) {
+    case 'user':
+      return (
+        sig.content === (typeof m.content === 'string' ? m.content : JSON.stringify(m.content)) &&
+        sig.cancelled === m.cancelled
+      );
+    case 'assistant':
+      return (
+        sig.content === m.content &&
+        sig.model === m.model &&
+        sig.provider === m.provider &&
+        sig.reasoningContent === m.reasoningContent &&
+        sig.reasoningSummary === m.reasoningSummary &&
+        sig.toolCallsJson === (m.toolCalls ? JSON.stringify(m.toolCalls) : undefined)
+      );
+    case 'system':
+      return sig.content === m.content;
+    case 'tool':
+      return sig.content === m.content && sig.callId === m.callId && sig.toolName === m.toolName;
+    default:
+      return false;
+  }
+}
+
+/**
+ * Wrap the real collapseState so reads (.get/.has) are recorded while writes
+ * (.set — the auto-collapse default) pass straight through to the real map, so
+ * the persistent collapse defaults are established exactly as a cold render
+ * would establish them.
+ */
+function makeRecordingCollapseState(
+  real: Map<string, boolean>,
+  readKeys: Set<string>,
+): Map<string, boolean> {
+  return new Proxy(real, {
+    get(target, prop, receiver) {
+      if (prop === 'get') {
+        return (key: string): boolean | undefined => {
+          readKeys.add(key);
+          return target.get(key);
+        };
+      }
+      if (prop === 'has') {
+        return (key: string): boolean => {
+          readKeys.add(key);
+          return target.has(key);
+        };
+      }
+      void receiver;
+      const value = Reflect.get(target, prop, target);
+      return typeof value === 'function' ? value.bind(target) : value;
+    },
+  });
+}
+
+/** Dispatch a single message to its render function. */
+function renderOne(
+  ctx: ConversationRenderContext,
+  message: Message,
+  width: number,
+  absoluteIdx: number,
+  cfg: RenderConfig,
+): void {
+  if (message.role === 'user') {
+    renderConversationUserMessage(ctx, message, width);
+  } else if (message.role === 'assistant') {
+    renderConversationAssistantMessage(ctx, message, width, cfg.lineNumberMode, cfg.collapseThreshold, absoluteIdx);
+  } else if (message.role === 'system') {
+    renderConversationSystemMessage(ctx, message, width, absoluteIdx);
+  } else if (message.role === 'tool') {
+    renderConversationToolMessage(ctx, message, width, absoluteIdx);
+  }
+}
+
+/**
+ * MessageLineCache — per-message Line[] memoisation for ConversationManager.
+ *
+ * Keyed by absolute message index; each entry validates its COMPLETE input tuple
+ * before serving. A rebuild that reuses entries is byte-identical to a cold
+ * rebuild; the cache is a pure memoisation with no observable behaviour of its
+ * own beyond speed and reduced allocation churn.
+ */
+export class MessageLineCache {
+  private entries: Map<number, CacheEntry> = new Map();
+
+  /** Drop all cached entries (wholesale message replacement / reset). */
+  public clear(): void {
+    this.entries.clear();
+  }
+
+  /** Number of retained entries (for tests / diagnostics). */
+  public get size(): number {
+    return this.entries.size;
+  }
+
+  /**
+   * Render `messages` into `context`, reusing cached lines for unchanged
+   * messages. Mirrors appendConversationMessages exactly on a cold cache; a warm
+   * cache replays identical bytes at identical offsets.
+   *
+   * @param context               the live render context (real history buffer,
+   *                              block/error registries, collapse state, config).
+   * @param messages              the visible message slice to render.
+   * @param width                 render width.
+   * @param messageLineRegistry   absolute-index → first-line map, written here.
+   * @param msgIndexOffset        absolute index of messages[0] (post-clearDisplay slice).
+   * @param streamingPlaceholderAbsIdx  absolute index of the in-progress streaming
+   *                              placeholder to leave uncached (-1 when not streaming);
+   *                              the incremental streaming path owns its content.
+   */
+  public renderInto(
+    context: ConversationRenderContext,
+    messages: Message[],
+    width: number,
+    messageLineRegistry: number[],
+    msgIndexOffset: number,
+    streamingPlaceholderAbsIdx: number,
+  ): void {
+    const cfg: RenderConfig = {
+      lineNumberMode: context.configManager?.get('display.lineNumbers') ?? 'off',
+      collapseThreshold: context.configManager?.get('display.collapseThreshold') ?? 30,
+      showThinking: context.configManager?.get('display.showThinking') ?? false,
+      showReasoningSummary: context.configManager?.get('display.showReasoningSummary') ?? false,
+    };
+
+    const touched = new Set<number>();
+
+    for (let i = 0; i < messages.length; i++) {
+      const message = messages[i]!;
+      const absoluteIdx = msgIndexOffset + i;
+      const base = context.history.getLineCount();
+      const blockBase = context.blockRegistry.length;
+      messageLineRegistry[absoluteIdx] = base;
+
+      const uncacheable = absoluteIdx === streamingPlaceholderAbsIdx;
+      const kind = context.messageKindRegistry.get(absoluteIdx);
+
+      if (!uncacheable) {
+        const existing = this.entries.get(absoluteIdx);
+        if (existing && this.isValid(existing, message, width, cfg, blockBase, kind, context.collapseState)) {
+          this.applyEntry(context, existing, base);
+          touched.add(absoluteIdx);
+          continue;
+        }
+      }
+
+      const entry = this.renderScratch(context, message, width, absoluteIdx, cfg, blockBase, kind);
+      this.applyEntry(context, entry, base);
+      if (!uncacheable) {
+        this.entries.set(absoluteIdx, entry);
+        touched.add(absoluteIdx);
+      }
+    }
+
+    // Mark-and-sweep: a full rebuild renders every currently-visible message, so
+    // any entry not touched this pass is off-screen (or evicted by a shrink) and
+    // is dropped to bound memory to the visible set.
+    if (this.entries.size > touched.size) {
+      for (const key of this.entries.keys()) {
+        if (!touched.has(key)) this.entries.delete(key);
+      }
+    }
+  }
+
+  /** Validate a cached entry against the message's current complete inputs. */
+  private isValid(
+    entry: CacheEntry,
+    message: Message,
+    width: number,
+    cfg: RenderConfig,
+    blockBase: number,
+    kind: SystemMessageKind | undefined,
+    collapseState: Map<string, boolean>,
+  ): boolean {
+    const k = entry.keyMeta;
+    if (
+      k.role !== message.role ||
+      k.width !== width ||
+      k.lineNumberMode !== cfg.lineNumberMode ||
+      k.collapseThreshold !== cfg.collapseThreshold ||
+      k.showThinking !== cfg.showThinking ||
+      k.showReasoningSummary !== cfg.showReasoningSummary ||
+      k.blockBase !== blockBase ||
+      k.kind !== kind
+    ) {
+      return false;
+    }
+    if (!contentUnchanged(entry.contentSig, message)) return false;
+    for (const [key, value] of entry.collapseDeps) {
+      if (collapseState.get(key) !== value) return false;
+    }
+    return true;
+  }
+
+  /**
+   * Render a single message into an isolated scratch context, capturing its
+   * lines, block metas (message-relative), error-line offsets (message-relative),
+   * and the collapse-state reads it depends on. Collapse-default WRITES pass
+   * through to the real collapseState so persistent defaults match a cold render.
+   */
+  private renderScratch(
+    context: ConversationRenderContext,
+    message: Message,
+    width: number,
+    absoluteIdx: number,
+    cfg: RenderConfig,
+    blockBase: number,
+    kind: SystemMessageKind | undefined,
+  ): CacheEntry {
+    const scratchLines: Line[] = [];
+    const scratchHistory = {
+      addLine: (line: Line): void => { scratchLines.push(line); },
+      addLines: (lines: Line[]): void => { for (const line of lines) scratchLines.push(line); },
+      getLineCount: (): number => scratchLines.length,
+    };
+    // Pre-size to blockBase so blockRegistry.length (the global block index the
+    // collapseKey embeds) matches the live registry; slice(blockBase) recovers
+    // only this message's blocks afterwards.
+    const scratchBlocks: BlockMeta[] = new Array(blockBase);
+    const scratchErrors: number[] = [];
+    const readKeys = new Set<string>();
+    const recordingCollapse = makeRecordingCollapseState(context.collapseState, readKeys);
+
+    const scratchCtx: ConversationRenderContext = {
+      history: scratchHistory,
+      blockRegistry: scratchBlocks,
+      collapseState: recordingCollapse,
+      errorLineRegistry: scratchErrors,
+      messageKindRegistry: context.messageKindRegistry,
+      configManager: context.configManager,
+      splashOptions: context.splashOptions,
+    };
+
+    renderOne(scratchCtx, message, width, absoluteIdx, cfg);
+    // Trailing blank line, exactly as appendConversationMessages appends per message.
+    scratchLines.push(createEmptyLine(width));
+
+    const collapseDeps: Array<[string, boolean | undefined]> = [];
+    for (const key of readKeys) collapseDeps.push([key, context.collapseState.get(key)]);
+
+    return {
+      keyMeta: {
+        role: message.role,
+        width,
+        lineNumberMode: cfg.lineNumberMode,
+        collapseThreshold: cfg.collapseThreshold,
+        showThinking: cfg.showThinking,
+        showReasoningSummary: cfg.showReasoningSummary,
+        blockBase,
+        kind,
+      },
+      contentSig: contentSigOf(message),
+      lines: scratchLines,
+      blocks: scratchBlocks.slice(blockBase),
+      errorRelLines: scratchErrors,
+      collapseDeps,
+      appliedBase: -1,
+      appliedBlocks: null,
+      appliedErrors: null,
+    };
+  }
+
+  /**
+   * Replay an entry into the live context at buffer offset `base`. Line objects
+   * are shared (never mutated post-production — the compositor reads them into a
+   * separate back-buffer). Block/error rebasing is memoised per base so an
+   * unchanged message pays zero allocation across rebuilds.
+   */
+  private applyEntry(context: ConversationRenderContext, entry: CacheEntry, base: number): void {
+    context.history.addLines(entry.lines);
+
+    if (entry.appliedBase !== base || entry.appliedBlocks === null || entry.appliedErrors === null) {
+      entry.appliedBlocks = entry.blocks.map((b) => ({ ...b, startLine: b.startLine + base }));
+      entry.appliedErrors = entry.errorRelLines.map((e) => e + base);
+      entry.appliedBase = base;
+    }
+
+    const registry = context.blockRegistry;
+    for (const block of entry.appliedBlocks) registry.push(block);
+    const errors = context.errorLineRegistry;
+    for (const line of entry.appliedErrors) errors.push(line);
+  }
+}

package/src/core/conversation-rendering.ts

@@ -1,5 +1,6 @@
 import { UIFactory } from '../renderer/ui-factory.ts';
 import { renderMarkdownTracked } from '../renderer/markdown.ts';
+import { renderDiffView } from '../renderer/diff-view.ts';
 import { DARK_THEME } from '../renderer/theme.ts';
 import { renderToolCallBlock } from '../renderer/tool-call.ts';
 import { renderThinkingBlock } from '../renderer/thinking.ts';
@@ -41,7 +42,7 @@ function summarizeCallId(callId: string, maxLength = 24): string {
   return callId.length <= maxLength ? callId : `${callId.slice(0, maxLength - 1)}…`;
 }
 
-interface ConversationRenderContext {
+export interface ConversationRenderContext {
   readonly history: {
     addLine: (line: Line) => void;
     addLines: (lines: Line[]) => void;
@@ -231,6 +232,9 @@ export function renderConversationToolMessage(
   const hasHunk = contentLines.some((l) => l.startsWith('@@ '));
   const isDiff = hasDiffHeader && hasHunk;
   const blockType: 'diff' | 'tool' = isDiff ? 'diff' : 'tool';
+  // Parsed once, ahead of the collapse check, so it's available for the
+  // block-registry meta merge below regardless of collapsed/expanded state.
+  const diffParse = isDiff ? parseDiffForApply(message.content) : undefined;
 
   const isShort = message.content.length <= 200;
   const isCollapsed = isShort
@@ -271,6 +275,10 @@ export function renderConversationToolMessage(
       dim: true,
     });
     context.history.addLines(rendered);
+  } else if (isDiff) {
+    // No filename banner: the diff text's own --- / +++ headers already
+    // identify the file (matches the pre-v0.9.6 call site in tool-call.ts).
+    context.history.addLines(renderDiffView(message.content, width));
   } else {
     let contentToRender = message.content;
     const trimmed = contentToRender.trimStart();
@@ -295,8 +303,8 @@ export function renderConversationToolMessage(
     rawContent: message.content,
   };
 
-  if (isDiff) {
-    meta = { ...meta, ...parseDiffForApply(message.content) };
+  if (isDiff && diffParse) {
+    meta = { ...meta, ...diffParse };
   }
 
   context.blockRegistry.push(meta);