@chances-ai/tui 12.0.0 → 14.0.0

package/dist/view-model.d.ts

@@ -1,19 +1,49 @@
 import type { ApprovalMode, ApprovalState, EventBus } from "@chances-ai/runtime";
 import type { PermissionDecision, PermissionRequest } from "@chances-ai/tools";
-export type LineKind = "user" | "assistant" | "tool" | "tool-result" | "error" | "info";
+import { type FrameScheduler } from "./frame-scheduler.js";
+/** (5.9) Extract the `linesDiff` block (from the first `@@ -d` hunk header to
+ *  the end) out of a write/edit permission summary, or null when the summary
+ *  carries no diff (single-line edits, "diff preview skipped", non-write tools). */
+export declare function extractDiff(summary: string): string | null;
+export type LineKind = "user" | "assistant" | "tool" | "error" | "info";
 export interface Line {
     kind: LineKind;
+    /** user/assistant/info/error body — OR, for a `tool` line, the pure arg
+     *  summary from `formatToolCall`. */
     text: string;
+    /** `tool`: undefined while running, then the result's ok/err. */
     ok?: boolean;
+    /** `tool`: raw tool name (drives the ⏺ header + display-name mapping). */
+    toolName?: string;
+    /** `tool`: correlates the call / permission / result bus events. */
+    callId?: string;
+    /** `tool`: result preview shown under the ⎿ branch. */
+    result?: string;
+    /** `tool`: raw `linesDiff` text for write/edit, rendered under ⎿ (5.9). */
+    diff?: string;
+    /** `tool`: whether `diff` is whole-file-anchored (write) vs snippet (edit). */
+    anchored?: boolean;
 }
 interface Pending {
     req: PermissionRequest;
     resolve: (decision: PermissionDecision) => void;
 }
+export interface ChatViewModelOptions {
+    /** (5.8) Injectable frame coalescer. Production uses the default ~16 ms
+     *  `setTimeout` batcher; tests inject a manual queue for determinism. */
+    scheduler?: FrameScheduler;
+    /** (5.8) See `config.tui.toolResultPreviewLines`. Default 12. */
+    toolResultPreviewLines?: number;
+}
 /**
  * Observable view-model. The Ink tree subscribes via useSyncExternalStore and
  * never touches domain objects directly — the only inputs are bus events and the
  * permission resolver. This is the seam that keeps the UI decoupled from core.
+ *
+ * (5.8) Rendering is split into a committed prefix (frozen scrollback fed to
+ * Ink `<Static>`, rendered once) and a small live tail (re-rendered each
+ * frame). Streamed `assistant:delta` re-renders are coalesced to one per frame
+ * via {@link FrameScheduler}; every structural event force-flushes immediately.
  */
 export declare class ChatViewModel {
     private readonly approval?;
@@ -23,27 +53,126 @@ export declare class ChatViewModel {
     /** (5.3) True while the Shift+Tab-into-yolo confirmation overlay is up.
      *  app.tsx renders the red confirm box; `resolveYoloConfirm` clears it. */
     yoloConfirmPending: boolean;
+    /**
+     * (5.8) Count of leading `lines` that are committed (frozen). Lines
+     * `[0, committedCount)` are append-only — an index's content never changes
+     * once committed — and feed Ink `<Static>`. Lines `[committedCount, end)`
+     * are the live tail. Advanced ONLY forward (monotonic) so `<Static>` never
+     * has to un-render anything. The only line that ever mutates in place is an
+     * open assistant line (text grows per delta) and it is always live.
+     */
+    committedCount: number;
+    /**
+     * (5.8) Bumped by `clearLines()` and used as the Ink `<Static key>`. Ink
+     * `<Static>` can't be emptied by replacing its items, so `/clear` remounts
+     * it under a fresh key (needs `ink >= 7.0.3`, which fixes the
+     * remount-with-different-key drop-new-items bug).
+     */
+    clearGeneration: number;
     private version;
     private readonly listeners;
     private assistantOpen;
     private busUnsubscribers;
+    private readonly scheduler;
+    private readonly toolResultPreviewLines;
+    /** Non-null while a coalesced delta frame is queued (see `scheduleBump`). */
+    private pendingFrame;
+    /**
+     * (5.9) Diff blocks parsed from `tool:permission` summaries, keyed by callId,
+     * awaiting their `tool:result` so they can be attached to the tool line and
+     * rendered under the `⎿` branch. Emitted before `gate.evaluate` for every
+     * write/edit call (engine.ts:763) — so this populates even under
+     * auto-edit/yolo, giving transcript diffs in all approval modes with zero
+     * engine/contract change. Cleared on detach/clear so it can't leak.
+     */
+    private readonly diffStash;
     /**
      * (5.3) Optional session approval-mode holder. When wired (interactive
      * `chat`), the footer reflects `approvalMode` and Shift+Tab / `/approval`
      * mutate it. Left undefined in tests that don't exercise modes — every
      * approval method then no-ops and `approvalMode` reads `"default"`.
+     *
+     * (5.8) `options` injects the frame scheduler + tool-result preview length;
+     * both default so existing callers (`new ChatViewModel()`,
+     * `new ChatViewModel(approval)`) keep working unchanged.
      */
-    constructor(approval?: ApprovalState | undefined);
+    constructor(approval?: ApprovalState | undefined, options?: ChatViewModelOptions);
     subscribe: (fn: () => void) => (() => void);
     getSnapshot: () => number;
+    /**
+     * (5.8) The frozen scrollback prefix — fed to Ink `<Static>` and rendered
+     * once. Guaranteed append-only: the element at index `i` never changes once
+     * it appears here. A fresh array is returned each call, but the prefix
+     * content is stable, which is all `<Static>` relies on.
+     */
+    committedLines(): Line[];
+    /** (5.8) The live tail re-rendered each frame: the open assistant line while
+     *  streaming, or an in-flight tool / tool-result line awaiting its terminal
+     *  event. Usually 0–1 entries. */
+    liveLines(): Line[];
+    /** (5.9) The still-live `tool` line for a callId (normally the last line).
+     *  Returns a mutable ref so `tool:result` can fill it in place — safe because
+     *  it is in the live region (index ≥ committedCount), not yet committed. */
+    private findLiveTool;
+    /**
+     * (5.9 codex R2 MUST-1) Advance `committedCount` toward `target` but NEVER
+     * past the earliest still-running tool line (`kind:"tool"` with `ok ===
+     * undefined`). A sync/background subagent emits its own `tool:call` /
+     * `assistant:delta` frames on the SAME bus BETWEEN a parent `task` tool's
+     * call and its result; without this clamp those frames would commit the
+     * parent's tool line, after which `findLiveTool` could no longer fill it
+     * (mutating a committed line breaks the `<Static>` append-only invariant) and
+     * the parent result would spawn a duplicate empty block. Keeping every
+     * unresolved tool line live until its result arrives makes the fill always
+     * append-only-safe. `turn:end` force-commits unconditionally (the turn is
+     * over). Monotonic: `target ≥ committedCount`, and the result is in
+     * `[committedCount, target]`.
+     */
+    private commitThrough;
     private bump;
+    /**
+     * (5.8) Coalesce a streamed-token re-render onto the next frame. The first
+     * delta in a window arms the scheduler; later deltas in the same window are
+     * no-ops (the text is already accumulated on the line), so N tokens cause
+     * at most one render per frame instead of N.
+     */
+    private scheduleBump;
+    /** (5.8) Drop a queued delta frame if one is pending. */
+    private cancelPendingBump;
+    /**
+     * (5.8) Immediate notify that first drops any pending coalesced delta frame.
+     * Used by every structural mutation (finished message, tool call/result,
+     * turn boundary, user action) so the UI never renders a structural change
+     * behind a stale token-stream frame, and a cancelled frame can't fire into a
+     * later epoch.
+     */
+    private forceFlush;
+    /**
+     * Push a standalone, immutable line and commit everything (it and any prior
+     * live tail are terminal-on-creation).
+     *
+     * Closing `assistantOpen` here means a standalone line pushed while a stream
+     * is open ends that stream: the next `assistant:delta` opens a FRESH line
+     * rather than appending to the committed one — so the committed line is
+     * genuinely final (append-only holds; see the interleaving regression test).
+     * That a mid-stream user submit / mode-cycle visually splits the assistant
+     * message is a pre-existing interaction behavior (NOT a v13 regression — the
+     * pre-v13 `pushUser` closed the stream the same way); richer mid-turn input
+     * handling (queueing) is a v15 interaction-model concern, out of v13 scope.
+     */
+    private pushCommitted;
     pushUser(text: string): void;
     pushInfo(text: string): void;
     pushError(text: string): void;
     /** Empties the rendered scrollback — used by `/clear` so the user sees a
      * fresh view alongside the session.clearTurns() that drops the conversation
      * history. The view-model and the underlying session are intentionally
-     * separate operations; the slash command sequences both. */
+     * separate operations; the slash command sequences both.
+     *
+     * (5.8) Because Ink `<Static>` keeps everything ever handed to it, emptying
+     * `lines` is not enough — `clearGeneration` is bumped so app.tsx can remount
+     * `<Static>` under a fresh key. Any pending delta frame is dropped so it
+     * can't fire into the cleared epoch. */
     clearLines(): void;
     attach(bus: EventBus): void;
     /**
@@ -56,6 +185,9 @@ export declare class ChatViewModel {
      * prompt that will never reach a user. Any *future* call to
      * `requestPermission` on this detached VM short-circuits the same
      * way — same reasoning.
+     *
+     * (5.8) Also drops any pending coalesced frame so a scheduled bump
+     * can't fire into a remounted/stale epoch.
      */
     detach(): void;
     private detached;

package/dist/view-model.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"view-model.d.ts","sourceRoot":"","sources":["../src/view-model.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,aAAa,EAAE,QAAQ,EAAE,MAAM,qBAAqB,CAAC;AACjF,OAAO,KAAK,EAAE,kBAAkB,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAC;AAE/E,MAAM,MAAM,QAAQ,GAAG,MAAM,GAAG,WAAW,GAAG,MAAM,GAAG,aAAa,GAAG,OAAO,GAAG,MAAM,CAAC;AACxF,MAAM,WAAW,IAAI;IACnB,IAAI,EAAE,QAAQ,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;IACb,EAAE,CAAC,EAAE,OAAO,CAAC;CACd;AAED,UAAU,OAAO;IACf,GAAG,EAAE,iBAAiB,CAAC;IACvB,OAAO,EAAE,CAAC,QAAQ,EAAE,kBAAkB,KAAK,IAAI,CAAC;CACjD;AAED;;;;GAIG;AACH,qBAAa,aAAa;IAmBZ,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAC;IAlBtC,KAAK,EAAE,IAAI,EAAE,CAAM;IACnB,IAAI,UAAS;IACb,OAAO,EAAE,OAAO,GAAG,IAAI,CAAQ;IAC/B;+EAC2E;IAC3E,kBAAkB,UAAS;IAE3B,OAAO,CAAC,OAAO,CAAK;IACpB,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAyB;IACnD,OAAO,CAAC,aAAa,CAAS;IAC9B,OAAO,CAAC,gBAAgB,CAAyB;IAEjD;;;;;OAKG;gBAC0B,QAAQ,CAAC,EAAE,aAAa,YAAA;IAErD,SAAS,GAAI,IAAI,MAAM,IAAI,KAAG,CAAC,MAAM,IAAI,CAAC,CAGxC;IAEF,WAAW,QAAO,MAAM,CAAiB;IAEzC,OAAO,CAAC,IAAI;IAKZ,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI;IAM5B,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI;IAM5B,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI;IAM7B;;;gEAG4D;IAC5D,UAAU,IAAI,IAAI;IAMlB,MAAM,CAAC,GAAG,EAAE,QAAQ,GAAG,IAAI;IA4C3B;;;;;;;;;;OAUG;IACH,MAAM,IAAI,IAAI;IAUd,OAAO,CAAC,QAAQ,CAAS;IAEzB;4EACwE;IACxE,iBAAiB,GAAI,KAAK,iBAAiB,KAAG,OAAO,CAAC,kBAAkB,CAAC,CAMvE;IAEF;;;;;;;OAOG;IACH,iBAAiB,CAAC,QAAQ,EAAE,kBAAkB,GAAG,IAAI;IAmBrD,oEAAoE;IACpE,IAAI,YAAY,IAAI,YAAY,CAE/B;IAED;;;;;OAKG;IACH,iBAAiB,IAAI,IAAI;IAazB,gFAAgF;IAChF,kBAAkB,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI;CAS3C"}
+{"version":3,"file":"view-model.d.ts","sourceRoot":"","sources":["../src/view-model.ts"],"names":[],"mappings":"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"}

package/dist/view-model.js

@@ -1,7 +1,26 @@
+import { defaultFrameScheduler, } from "./frame-scheduler.js";
+import { formatToolCall } from "./tool-line.js";
+/** (5.9) Extract the `linesDiff` block (from the first `@@ -d` hunk header to
+ *  the end) out of a write/edit permission summary, or null when the summary
+ *  carries no diff (single-line edits, "diff preview skipped", non-write tools). */
+export function extractDiff(summary) {
+    const lines = summary.split("\n");
+    const idx = lines.findIndex((l) => /^@@ -\d/.test(l));
+    return idx < 0 ? null : lines.slice(idx).join("\n");
+}
+/** (5.8) Default count of leading tool-result lines shown inline before the
+ *  rest collapses to a `… +N more lines` note. Overridable via
+ *  `config.tui.toolResultPreviewLines`. */
+const DEFAULT_TOOL_RESULT_PREVIEW_LINES = 12;
 /**
  * Observable view-model. The Ink tree subscribes via useSyncExternalStore and
  * never touches domain objects directly — the only inputs are bus events and the
  * permission resolver. This is the seam that keeps the UI decoupled from core.
+ *
+ * (5.8) Rendering is split into a committed prefix (frozen scrollback fed to
+ * Ink `<Static>`, rendered once) and a small live tail (re-rendered each
+ * frame). Streamed `assistant:delta` re-renders are coalesced to one per frame
+ * via {@link FrameScheduler}; every structural event force-flushes immediately.
  */
 export class ChatViewModel {
     approval;
@@ -11,51 +30,195 @@ export class ChatViewModel {
     /** (5.3) True while the Shift+Tab-into-yolo confirmation overlay is up.
      *  app.tsx renders the red confirm box; `resolveYoloConfirm` clears it. */
     yoloConfirmPending = false;
+    /**
+     * (5.8) Count of leading `lines` that are committed (frozen). Lines
+     * `[0, committedCount)` are append-only — an index's content never changes
+     * once committed — and feed Ink `<Static>`. Lines `[committedCount, end)`
+     * are the live tail. Advanced ONLY forward (monotonic) so `<Static>` never
+     * has to un-render anything. The only line that ever mutates in place is an
+     * open assistant line (text grows per delta) and it is always live.
+     */
+    committedCount = 0;
+    /**
+     * (5.8) Bumped by `clearLines()` and used as the Ink `<Static key>`. Ink
+     * `<Static>` can't be emptied by replacing its items, so `/clear` remounts
+     * it under a fresh key (needs `ink >= 7.0.3`, which fixes the
+     * remount-with-different-key drop-new-items bug).
+     */
+    clearGeneration = 0;
     version = 0;
     listeners = new Set();
     assistantOpen = false;
     busUnsubscribers = [];
+    scheduler;
+    toolResultPreviewLines;
+    /** Non-null while a coalesced delta frame is queued (see `scheduleBump`). */
+    pendingFrame = null;
+    /**
+     * (5.9) Diff blocks parsed from `tool:permission` summaries, keyed by callId,
+     * awaiting their `tool:result` so they can be attached to the tool line and
+     * rendered under the `⎿` branch. Emitted before `gate.evaluate` for every
+     * write/edit call (engine.ts:763) — so this populates even under
+     * auto-edit/yolo, giving transcript diffs in all approval modes with zero
+     * engine/contract change. Cleared on detach/clear so it can't leak.
+     */
+    diffStash = new Map();
     /**
      * (5.3) Optional session approval-mode holder. When wired (interactive
      * `chat`), the footer reflects `approvalMode` and Shift+Tab / `/approval`
      * mutate it. Left undefined in tests that don't exercise modes — every
      * approval method then no-ops and `approvalMode` reads `"default"`.
+     *
+     * (5.8) `options` injects the frame scheduler + tool-result preview length;
+     * both default so existing callers (`new ChatViewModel()`,
+     * `new ChatViewModel(approval)`) keep working unchanged.
      */
-    constructor(approval) {
+    constructor(approval, options) {
         this.approval = approval;
+        this.scheduler = options?.scheduler ?? defaultFrameScheduler;
+        this.toolResultPreviewLines =
+            options?.toolResultPreviewLines ?? DEFAULT_TOOL_RESULT_PREVIEW_LINES;
     }
     subscribe = (fn) => {
         this.listeners.add(fn);
         return () => this.listeners.delete(fn);
     };
     getSnapshot = () => this.version;
+    /**
+     * (5.8) The frozen scrollback prefix — fed to Ink `<Static>` and rendered
+     * once. Guaranteed append-only: the element at index `i` never changes once
+     * it appears here. A fresh array is returned each call, but the prefix
+     * content is stable, which is all `<Static>` relies on.
+     */
+    committedLines() {
+        return this.lines.slice(0, this.committedCount);
+    }
+    /** (5.8) The live tail re-rendered each frame: the open assistant line while
+     *  streaming, or an in-flight tool / tool-result line awaiting its terminal
+     *  event. Usually 0–1 entries. */
+    liveLines() {
+        return this.lines.slice(this.committedCount);
+    }
+    /** (5.9) The still-live `tool` line for a callId (normally the last line).
+     *  Returns a mutable ref so `tool:result` can fill it in place — safe because
+     *  it is in the live region (index ≥ committedCount), not yet committed. */
+    findLiveTool(callId) {
+        for (let i = this.lines.length - 1; i >= this.committedCount; i--) {
+            const l = this.lines[i];
+            if (l && l.kind === "tool" && l.callId === callId)
+                return l;
+        }
+        return undefined;
+    }
+    /**
+     * (5.9 codex R2 MUST-1) Advance `committedCount` toward `target` but NEVER
+     * past the earliest still-running tool line (`kind:"tool"` with `ok ===
+     * undefined`). A sync/background subagent emits its own `tool:call` /
+     * `assistant:delta` frames on the SAME bus BETWEEN a parent `task` tool's
+     * call and its result; without this clamp those frames would commit the
+     * parent's tool line, after which `findLiveTool` could no longer fill it
+     * (mutating a committed line breaks the `<Static>` append-only invariant) and
+     * the parent result would spawn a duplicate empty block. Keeping every
+     * unresolved tool line live until its result arrives makes the fill always
+     * append-only-safe. `turn:end` force-commits unconditionally (the turn is
+     * over). Monotonic: `target ≥ committedCount`, and the result is in
+     * `[committedCount, target]`.
+     */
+    commitThrough(target) {
+        let limit = target;
+        for (let i = this.committedCount; i < target; i++) {
+            const l = this.lines[i];
+            if (l && l.kind === "tool" && l.ok === undefined) {
+                limit = i;
+                break;
+            }
+        }
+        if (limit > this.committedCount)
+            this.committedCount = limit;
+    }
     bump() {
         this.version++;
         for (const l of this.listeners)
             l();
     }
-    pushUser(text) {
-        this.lines.push({ kind: "user", text });
-        this.assistantOpen = false;
+    /**
+     * (5.8) Coalesce a streamed-token re-render onto the next frame. The first
+     * delta in a window arms the scheduler; later deltas in the same window are
+     * no-ops (the text is already accumulated on the line), so N tokens cause
+     * at most one render per frame instead of N.
+     */
+    scheduleBump() {
+        if (this.pendingFrame !== null)
+            return;
+        this.pendingFrame = this.scheduler.schedule(() => {
+            this.pendingFrame = null;
+            this.bump();
+        });
+    }
+    /** (5.8) Drop a queued delta frame if one is pending. */
+    cancelPendingBump() {
+        if (this.pendingFrame !== null) {
+            this.scheduler.cancel(this.pendingFrame);
+            this.pendingFrame = null;
+        }
+    }
+    /**
+     * (5.8) Immediate notify that first drops any pending coalesced delta frame.
+     * Used by every structural mutation (finished message, tool call/result,
+     * turn boundary, user action) so the UI never renders a structural change
+     * behind a stale token-stream frame, and a cancelled frame can't fire into a
+     * later epoch.
+     */
+    forceFlush() {
+        this.cancelPendingBump();
         this.bump();
     }
-    pushInfo(text) {
-        this.lines.push({ kind: "info", text });
+    /**
+     * Push a standalone, immutable line and commit everything (it and any prior
+     * live tail are terminal-on-creation).
+     *
+     * Closing `assistantOpen` here means a standalone line pushed while a stream
+     * is open ends that stream: the next `assistant:delta` opens a FRESH line
+     * rather than appending to the committed one — so the committed line is
+     * genuinely final (append-only holds; see the interleaving regression test).
+     * That a mid-stream user submit / mode-cycle visually splits the assistant
+     * message is a pre-existing interaction behavior (NOT a v13 regression — the
+     * pre-v13 `pushUser` closed the stream the same way); richer mid-turn input
+     * handling (queueing) is a v15 interaction-model concern, out of v13 scope.
+     */
+    pushCommitted(line) {
         this.assistantOpen = false;
-        this.bump();
+        this.lines.push(line);
+        this.committedCount = this.lines.length;
+    }
+    pushUser(text) {
+        this.pushCommitted({ kind: "user", text });
+        this.forceFlush();
+    }
+    pushInfo(text) {
+        this.pushCommitted({ kind: "info", text });
+        this.forceFlush();
     }
     pushError(text) {
-        this.lines.push({ kind: "error", text });
-        this.assistantOpen = false;
-        this.bump();
+        this.pushCommitted({ kind: "error", text });
+        this.forceFlush();
     }
     /** Empties the rendered scrollback — used by `/clear` so the user sees a
      * fresh view alongside the session.clearTurns() that drops the conversation
      * history. The view-model and the underlying session are intentionally
-     * separate operations; the slash command sequences both. */
+     * separate operations; the slash command sequences both.
+     *
+     * (5.8) Because Ink `<Static>` keeps everything ever handed to it, emptying
+     * `lines` is not enough — `clearGeneration` is bumped so app.tsx can remount
+     * `<Static>` under a fresh key. Any pending delta frame is dropped so it
+     * can't fire into the cleared epoch. */
     clearLines() {
+        this.cancelPendingBump();
         this.lines = [];
+        this.committedCount = 0;
+        this.clearGeneration++;
         this.assistantOpen = false;
+        this.diffStash.clear();
         this.bump();
     }
     attach(bus) {
@@ -69,36 +232,92 @@ export class ChatViewModel {
         this.busUnsubscribers = [
             bus.on("turn:start", () => {
                 this.busy = true;
-                this.bump();
+                this.forceFlush();
             }),
             bus.on("turn:end", () => {
                 this.busy = false;
-                this.bump();
+                // Flush the whole live region: the turn is over, nothing more will
+                // change any trailing line.
+                this.committedCount = this.lines.length;
+                this.forceFlush();
             }),
             bus.on("assistant:delta", (e) => {
                 if (!this.assistantOpen) {
+                    // Commit any prior live tail before the new narration line opens
+                    // (but not past an unresolved tool line — see `commitThrough`).
+                    this.commitThrough(this.lines.length);
                     this.lines.push({ kind: "assistant", text: "" });
                     this.assistantOpen = true;
                 }
                 this.lines[this.lines.length - 1].text += e.text;
-                this.bump();
+                // Coalesce: at most one render per frame for a fast token stream.
+                this.scheduleBump();
             }),
             bus.on("assistant:message", () => {
+                // The streamed line is final — commit it (not past an unresolved tool).
                 this.assistantOpen = false;
-                this.bump();
+                this.commitThrough(this.lines.length);
+                this.forceFlush();
             }),
             bus.on("tool:call", (e) => {
-                this.lines.push({ kind: "tool", text: `${e.name} ${JSON.stringify(e.args)}` });
+                // A tool-using turn emits NO `assistant:message`, so closing the open
+                // assistant line here is what commits the narration (codex R1 MF-2).
+                // (5.9) One line per tool call: the same line later gains its result /
+                // diff (filled in `tool:result` while still LIVE), so the `⏺` dot can
+                // reflect the final ok/err without ever mutating a committed line.
                 this.assistantOpen = false;
-                this.bump();
+                this.lines.push({
+                    kind: "tool",
+                    toolName: e.name,
+                    text: formatToolCall(e.name, e.args),
+                    callId: e.callId,
+                });
+                // Commit prior lines, but not past an earlier still-running tool line
+                // (e.g. the parent `task` line while a subagent streams).
+                this.commitThrough(this.lines.length - 1);
+                this.forceFlush();
+            }),
+            bus.on("tool:permission", (e) => {
+                // (5.9) Stash the diff for the matching tool:result. No UI change here —
+                // the prompt overlay reads `vm.pending.req.summary` directly.
+                const diff = extractDiff(e.summary);
+                if (diff !== null)
+                    this.diffStash.set(e.callId, { diff, anchored: e.name === "write" });
             }),
             bus.on("tool:result", (e) => {
-                this.lines.push({ kind: "tool-result", ok: e.ok, text: clip(e.output) });
-                this.bump();
+                // (5.9) Fill the still-live tool line (append-only safe) and commit the
+                // now-complete block. Attach any stashed diff (write/edit).
+                const stash = this.diffStash.get(e.callId);
+                this.diffStash.delete(e.callId);
+                const line = this.findLiveTool(e.callId);
+                const result = previewToolResult(e.output, this.toolResultPreviewLines);
+                if (line) {
+                    line.ok = e.ok;
+                    line.result = result;
+                    if (stash) {
+                        line.diff = stash.diff;
+                        line.anchored = stash.anchored;
+                    }
+                }
+                else {
+                    // No matching live call line (defensive) — push a standalone block.
+                    this.lines.push({
+                        kind: "tool",
+                        toolName: e.name,
+                        text: "",
+                        ok: e.ok,
+                        result,
+                        ...(stash ? { diff: stash.diff, anchored: stash.anchored } : {}),
+                    });
+                }
+                // The filled line is now resolved; commit up to it (but still not past
+                // any EARLIER unresolved tool line — e.g. an outer parent task).
+                this.commitThrough(this.lines.length);
+                this.forceFlush();
             }),
             bus.on("error", (e) => {
-                this.lines.push({ kind: "error", text: `${e.code}: ${e.message}` });
-                this.bump();
+                this.pushCommitted({ kind: "error", text: `${e.code}: ${e.message}` });
+                this.forceFlush();
             }),
         ];
     }
@@ -112,11 +331,16 @@ export class ChatViewModel {
      * prompt that will never reach a user. Any *future* call to
      * `requestPermission` on this detached VM short-circuits the same
      * way — same reasoning.
+     *
+     * (5.8) Also drops any pending coalesced frame so a scheduled bump
+     * can't fire into a remounted/stale epoch.
      */
     detach() {
         for (const unsubscribe of this.busUnsubscribers.splice(0))
             unsubscribe();
         this.detached = true;
+        this.cancelPendingBump();
+        this.diffStash.clear();
         if (this.pending) {
             const p = this.pending;
             this.pending = null;
@@ -131,7 +355,7 @@ export class ChatViewModel {
             return Promise.resolve({ allow: false });
         return new Promise((resolve) => {
             this.pending = { req, resolve };
-            this.bump();
+            this.forceFlush();
         });
     };
     /**
@@ -153,10 +377,10 @@ export class ChatViewModel {
                 : decision.feedback
                     ? "denied with feedback"
                     : "denied";
-            this.lines.push({ kind: "info", text: `${verb}: ${p.req.summary}` });
+            this.pushCommitted({ kind: "info", text: `${verb}: ${p.req.summary}` });
             p.resolve(decision);
         }
-        this.bump();
+        this.forceFlush();
     }
     // -- approval mode (5.3) ----------------------------------------------------
     /** The current session approval mode (`"default"` when unwired). */
@@ -175,12 +399,12 @@ export class ChatViewModel {
         const next = this.approval.next();
         if (next === "yolo" && !this.approval.isYoloConfirmed()) {
             this.yoloConfirmPending = true;
-            this.bump();
+            this.forceFlush();
             return;
         }
         this.approval.set(next);
-        this.lines.push({ kind: "info", text: `approval mode → ${next}` });
-        this.bump();
+        this.pushCommitted({ kind: "info", text: `approval mode → ${next}` });
+        this.forceFlush();
     }
     /** Resolve the yolo confirm overlay. `confirm` latches yolo for the session. */
     resolveYoloConfirm(confirm) {
@@ -188,12 +412,49 @@ export class ChatViewModel {
         if (confirm && this.approval) {
             this.approval.confirmYolo();
             this.approval.set("yolo");
-            this.lines.push({ kind: "info", text: "approval mode → yolo (all tool calls auto-approved)" });
+            this.pushCommitted({
+                kind: "info",
+                text: "approval mode → yolo (all tool calls auto-approved)",
+            });
         }
-        this.bump();
+        this.forceFlush();
     }
 }
-function clip(s, n = 400) {
-    return s.length > n ? s.slice(0, n) + "…" : s;
+/** Secondary guard for {@link previewToolResult}: a generous total-character
+ *  ceiling so a single very long line (e.g. minified JSON with no newlines)
+ *  can't blow up the live render even though it passes the line-count check.
+ *  Far larger than the old hard 400-char clip — it only bites pathological
+ *  single lines, never normal multi-line diffs / command output. The full
+ *  output is already on disk when it overflowed (the result banner). */
+const MAX_PREVIEW_CHARS = 8000;
+/**
+ * (5.8) Line-aware tool-result preview: show the first `maxLines` content
+ * lines, then collapse the rest to a `… +N more lines` note. Replaces the old
+ * hard 400-char clip, which truncated multi-line diffs / command output
+ * mid-line. When a tool's full output overflowed it was already persisted to
+ * disk and the path is part of `output` (the banner), so nothing is lost.
+ *
+ * A single trailing newline is not counted as a hidden line (codex R2
+ * SHOULD-FIX): `"a\nb\n"` is two content lines, not three. After the
+ * line-aware pass, {@link MAX_PREVIEW_CHARS} caps a pathological single huge
+ * line (codex R2 NICE).
+ */
+function previewToolResult(output, maxLines) {
+    const lines = output.split("\n");
+    // A terminal "\n" yields a final empty segment that isn't a content line.
+    const contentLineCount = lines.length > 0 && lines[lines.length - 1] === "" ? lines.length - 1 : lines.length;
+    let preview;
+    if (contentLineCount <= maxLines) {
+        preview = output;
+    }
+    else {
+        const hidden = contentLineCount - maxLines;
+        preview = `${lines.slice(0, maxLines).join("\n")}\n… +${hidden} more line${hidden === 1 ? "" : "s"}`;
+    }
+    if (preview.length > MAX_PREVIEW_CHARS) {
+        const hiddenChars = preview.length - MAX_PREVIEW_CHARS;
+        preview = `${preview.slice(0, MAX_PREVIEW_CHARS)}… +${hiddenChars} more characters`;
+    }
+    return preview;
 }
 //# sourceMappingURL=view-model.js.map