@vincemakes/kiso-code 0.1.14 → 0.1.15

package/dist/body.d.ts

@@ -0,0 +1,118 @@
+/**
+ * v2d — the body renderer: ONE writer for the stdout scroll region.
+ *
+ * The v2b/v2c body writes streamed directly (each event wrote its bytes),
+ * so the tool lines, thinking folds, and text deltas could interleave in
+ * the same frame — and a tool's life was scattered across several writes
+ * (the "leak"). v2d: every event handler ONLY mutates cell state; the
+ * Body's render loop is the only thing that writes the region.
+ *
+ * Frozen semantics: a completed cell prints its final form into the
+ * scroll region ONCE and is never touched again. The ACTIVE TAIL — the
+ * unfinished cells — renders at the region's bottom (between the frozen
+ * area and the dock) and redraws in place, CSI 2026 wrapped. State
+ * changes coalesce to ≥16ms frames; a 200ms heartbeat drives the running
+ * spinners and elapsed timers. An over-height tail (rare) overflows to
+ * freeze by completion order.
+ *
+ * Pipes / NO_COLOR: the Body runs in PASSTHROUGH — every mutation writes
+ * the v2b/v2c line-mode bytes immediately, byte-for-byte (the existing
+ * e2e guards it). The cell renderer never activates.
+ *
+ * The cell model is ours (UserCell / ThinkingCell / ToolCell / TextCell /
+ * NoticeCell / raw block) — deliberately NOT pi's Component interface
+ * shape (ADR-0040).
+ */
+/** One completed-or-active body line. The renderer's only state. */
+export type BodyCell = {
+    kind: "user";
+    text: string;
+    done: true;
+} | {
+    kind: "thinking";
+    text: string;
+    done: boolean;
+} | {
+    kind: "tool";
+    name: string;
+    input: string;
+    state: "pending" | "approval" | "running" | "done";
+    isError: boolean;
+    resultText: string;
+    startedAt: number | null;
+    doneAt: number | null;
+    done: boolean;
+} | {
+    kind: "text";
+    text: string;
+    done: boolean;
+} | {
+    kind: "notice";
+    text: string;
+    done: true;
+} | {
+    kind: "raw";
+    lines: string[];
+    done: true;
+} | {
+    kind: "terminal";
+    label: string;
+    line: string;
+    done: true;
+};
+export interface BodyOptions {
+    /** Is the cell renderer live? A color TTY with a real size — checked
+     *  per mutation (the TIOCSWINSZ can land after main constructs us). */
+    active: () => boolean;
+    /** The terminal height (rows) — live, for the region geometry. */
+    height: () => number;
+    /** The terminal width (cols) — live, for wrap estimates. */
+    width: () => number;
+    /** The input line's edit column — the render's cursor home. */
+    editCol: () => number;
+    /** The dock's redraw (the bottom three rows) — the body never writes
+     *  below the region, but the frame may call it to re-pin the chrome. */
+    onDock?: () => void;
+    /** The stdout writer — injectable for unit tests (default: stdout). */
+    write?: (s: string) => void;
+}
+export declare class Body {
+    #private;
+    constructor(opts: BodyOptions);
+    /** Teardown — flush a pending frame, stop the timers. */
+    close(): void;
+    /** The last COMPLETE thinking block, for /think. */
+    lastThinking(): string | null;
+    /** The last completed tool call, for /last. */
+    lastTool(): {
+        name: string;
+        input: Record<string, unknown>;
+        result: {
+            content: string;
+            isError: boolean;
+        };
+    } | null;
+    userLine(text: string): void;
+    thinkingAppend(text: string): void;
+    thinkingEnd(): void;
+    toolStart(name: string, callId: string, input: Record<string, unknown>): void;
+    toolApproval(callId: string): void;
+    toolRunning(callId: string): void;
+    toolSucceeded(callId: string): void;
+    toolFailed(callId: string, error: string): void;
+    toolResult(callId: string, result: {
+        content: string;
+        isError: boolean;
+    }): void;
+    textAppend(text: string): void;
+    textEnd(): void;
+    /** The terminal's status line + the rhythm gap (one blank). */
+    terminal(label: string, statusLine: string): void;
+    notice(text: string): void;
+    /** A pre-rendered block (the banner, the session line, slash-command
+     *  outputs) — frozen immediately. */
+    raw(lines: string[]): void;
+    /** The one writer. Frozen cells print once; the tail redraws in place,
+     *  CSI 2026 wrapped; the cursor lands at the input edit column. */
+    render(): void;
+}

package/dist/body.js

@@ -0,0 +1,419 @@
+/**
+ * v2d — the body renderer: ONE writer for the stdout scroll region.
+ *
+ * The v2b/v2c body writes streamed directly (each event wrote its bytes),
+ * so the tool lines, thinking folds, and text deltas could interleave in
+ * the same frame — and a tool's life was scattered across several writes
+ * (the "leak"). v2d: every event handler ONLY mutates cell state; the
+ * Body's render loop is the only thing that writes the region.
+ *
+ * Frozen semantics: a completed cell prints its final form into the
+ * scroll region ONCE and is never touched again. The ACTIVE TAIL — the
+ * unfinished cells — renders at the region's bottom (between the frozen
+ * area and the dock) and redraws in place, CSI 2026 wrapped. State
+ * changes coalesce to ≥16ms frames; a 200ms heartbeat drives the running
+ * spinners and elapsed timers. An over-height tail (rare) overflows to
+ * freeze by completion order.
+ *
+ * Pipes / NO_COLOR: the Body runs in PASSTHROUGH — every mutation writes
+ * the v2b/v2c line-mode bytes immediately, byte-for-byte (the existing
+ * e2e guards it). The cell renderer never activates.
+ *
+ * The cell model is ours (UserCell / ThinkingCell / ToolCell / TextCell /
+ * NoticeCell / raw block) — deliberately NOT pi's Component interface
+ * shape (ADR-0040).
+ */
+import { displayWidth } from "./editor.js";
+import { escapeTerminal, foldResult, foldThinking, palette, renderTerminalGap, renderToolSummary, } from "./render.js";
+/** The spinner glyphs, cycled by the heartbeat. */
+const SPINNER = ["◐", "◓", "◑", "◒"];
+const TOOL_SUMMARY_MAX = 60; // the tool line's parameter summary, chars
+const FRAME_MS = 16; // state changes coalesce to ≥16ms frames
+const HEARTBEAT_MS = 200; // spinner / elapsed cadence
+export class Body {
+    #active;
+    #opts;
+    #cells = [];
+    #nextFrozen = 0; // index of the first not-yet-printed cell
+    #frozenRows = 0; // rows of the region occupied by printed cells
+    #oldTailTop = 0; // the tail's previous first row — for the clear pass
+    #frameTimer = null;
+    #heartbeat = null;
+    #dirty = false;
+    #spinnerI = 0;
+    #lastThinking = null;
+    #lastTool = null;
+    #pendingCalls = new Map();
+    #pipeBuf = ""; // the passthrough's thinking buffer — the cell model needs no buffer
+    #toolCells = new Map(); // callId → cell index (parallel tools)
+    #write;
+    constructor(opts) {
+        this.#opts = opts;
+        this.#write = opts.write ?? ((s) => process.stdout.write(s));
+        this.#active = opts.active();
+        if (this.#isActive()) {
+            this.#heartbeat = setInterval(() => {
+                this.#spinnerI = (this.#spinnerI + 1) % SPINNER.length;
+                this.#dirty = true; // the running cells' glyph/elapsed advance
+                this.#scheduleFrame();
+            }, HEARTBEAT_MS);
+            this.#heartbeat.unref();
+        }
+    }
+    /** Live re-check — a TTY whose size lands after construction flips in. */
+    #isActive() {
+        this.#active = this.#opts.active();
+        return this.#active;
+    }
+    /** Teardown — flush a pending frame, stop the timers. */
+    close() {
+        if (this.#frameTimer !== null) {
+            clearTimeout(this.#frameTimer);
+            this.#frameTimer = null;
+        }
+        if (this.#heartbeat !== null) {
+            clearInterval(this.#heartbeat);
+            this.#heartbeat = null;
+        }
+        if (this.#dirty)
+            this.render();
+    }
+    /** The last COMPLETE thinking block, for /think. */
+    lastThinking() {
+        return this.#lastThinking;
+    }
+    /** The last completed tool call, for /last. */
+    lastTool() {
+        return this.#lastTool;
+    }
+    // ---- mutations (the ONLY way the CLI touches the body) ----
+    userLine(text) {
+        if (!this.#isActive()) {
+            this.#closeOpenThinking();
+            const p = palette();
+            this.#write(`${p.blue}you> ${escapeTerminal(text)}${p.reset}\n`);
+            return;
+        }
+        this.#closeOpenThinking();
+        this.#cells.push({ kind: "user", text, done: true });
+        this.#mark();
+    }
+    thinkingAppend(text) {
+        if (!this.#isActive()) {
+            this.#pipeBuf += text; // buffered; the fold prints at the block's end
+            return;
+        }
+        const last = this.#cells[this.#cells.length - 1];
+        if (last !== undefined && last.kind === "thinking" && !last.done) {
+            last.text += text;
+        }
+        else {
+            this.#cells.push({ kind: "thinking", text, done: false });
+        }
+        this.#mark();
+    }
+    thinkingEnd() {
+        const last = this.#cells[this.#cells.length - 1];
+        if (last !== undefined && last.kind === "thinking" && !last.done) {
+            last.done = true;
+            this.#lastThinking = last.text;
+            if (!this.#isActive())
+                process.stdout.write(foldThinking(last.text));
+            this.#mark();
+        }
+    }
+    toolStart(name, callId, input) {
+        const summary = JSON.stringify(input).slice(0, TOOL_SUMMARY_MAX);
+        // Registered BEFORE the passthrough branch — /last and the pipe
+        // summary need the call on BOTH paths.
+        this.#pendingCalls.set(callId, { name, input, result: { content: "", isError: false } });
+        if (!this.#isActive()) {
+            this.#closeOpenThinking();
+            process.stdout.write(`→ ${escapeTerminal(name)}(${escapeTerminal(JSON.stringify(input).slice(0, 200))})\n`);
+            return;
+        }
+        this.#toolCells.set(callId, this.#cells.length);
+        this.#cells.push({ kind: "tool", name, input: summary, state: "pending", isError: false, resultText: "", startedAt: null, doneAt: null, done: false });
+        this.#mark();
+    }
+    toolApproval(callId) {
+        if (!this.#isActive())
+            return;
+        const cell = this.#toolCell(callId);
+        if (cell !== null && cell.kind === "tool" && !cell.done)
+            cell.state = "approval";
+        this.#mark();
+    }
+    toolRunning(callId) {
+        if (!this.#isActive()) {
+            const p = palette();
+            process.stdout.write(`${p.dim}  running…${p.reset}\n`);
+            return;
+        }
+        const cell = this.#toolCell(callId);
+        if (cell !== null && cell.kind === "tool" && !cell.done) {
+            cell.state = "running";
+            cell.startedAt = Date.now();
+        }
+        this.#mark();
+    }
+    toolSucceeded(callId) {
+        if (!this.#isActive()) {
+            process.stdout.write(`  ok\n`);
+        }
+    }
+    toolFailed(callId, error) {
+        if (!this.#isActive()) {
+            const p = palette();
+            process.stdout.write(`${p.red}  failed: ${escapeTerminal(error.slice(0, 160))}${p.reset}\n`);
+        }
+    }
+    toolResult(callId, result) {
+        const call = this.#pendingCalls.get(callId);
+        if (call !== undefined) {
+            call.result = result;
+            this.#lastTool = { name: call.name, input: call.input, result };
+            this.#pendingCalls.delete(callId);
+        }
+        if (!this.#isActive()) {
+            // The v2b/v2c pipe bytes: the summary line + the [result] line.
+            const p = palette();
+            process.stdout.write(`${renderToolSummary(call?.name ?? "?", call?.input ?? {}, result)}\n` +
+                `${p.dim}${result.isError ? p.red : p.dim}  [result${result.isError ? " ✗" : ""}] ${foldResult(result.content)}${p.reset}\n`);
+            return;
+        }
+        const cell = this.#toolCell(callId);
+        this.#toolCells.delete(callId);
+        if (cell !== null && cell.kind === "tool" && !cell.done) {
+            cell.state = "done";
+            cell.isError = result.isError;
+            cell.resultText = result.content;
+            cell.doneAt = Date.now();
+            cell.done = true;
+        }
+        this.#mark();
+    }
+    textAppend(text) {
+        if (!this.#isActive()) {
+            this.#closeOpenThinking();
+            process.stdout.write(escapeTerminal(text));
+            return;
+        }
+        const last = this.#cells[this.#cells.length - 1];
+        if (last !== undefined && last.kind === "text" && !last.done) {
+            last.text += text;
+        }
+        else {
+            this.#closeOpenThinking();
+            this.#cells.push({ kind: "text", text, done: false });
+        }
+        this.#mark();
+    }
+    textEnd() {
+        if (!this.#isActive()) {
+            process.stdout.write("\n");
+            return;
+        }
+        const last = this.#cells[this.#cells.length - 1];
+        if (last !== undefined && last.kind === "text" && !last.done)
+            last.done = true;
+        this.#mark();
+    }
+    /** The terminal's status line + the rhythm gap (one blank). */
+    terminal(label, statusLine) {
+        if (!this.#isActive()) {
+            this.#closeOpenThinking();
+            // the v2c bytes: the terminal label (\ndone\n) + the status gap.
+            process.stdout.write(label + renderTerminalGap(statusLine));
+            return;
+        }
+        this.#closeOpenThinking();
+        this.#cells.push({ kind: "terminal", label: label.trim(), line: statusLine, done: true });
+        this.#mark();
+    }
+    notice(text) {
+        if (!this.#isActive()) {
+            this.#closeOpenThinking();
+            process.stdout.write(`${text}\n`);
+            return;
+        }
+        this.#closeOpenThinking();
+        this.#cells.push({ kind: "notice", text, done: true });
+        this.#mark();
+    }
+    /** A pre-rendered block (the banner, the session line, slash-command
+     *  outputs) — frozen immediately. */
+    raw(lines) {
+        if (!this.#isActive()) {
+            this.#closeOpenThinking();
+            for (const line of lines)
+                process.stdout.write(`${line}\n`);
+            return;
+        }
+        this.#closeOpenThinking();
+        this.#cells.push({ kind: "raw", lines, done: true });
+        this.#mark();
+    }
+    // ---- rendering ----
+    #mark() {
+        if (!this.#isActive())
+            return;
+        this.#dirty = true;
+        this.#scheduleFrame();
+    }
+    #scheduleFrame() {
+        if (this.#frameTimer !== null)
+            return;
+        this.#frameTimer = setTimeout(() => {
+            this.#frameTimer = null;
+            if (this.#dirty) {
+                this.#dirty = false;
+                this.render();
+            }
+        }, FRAME_MS);
+        this.#frameTimer.unref();
+    }
+    /** The one writer. Frozen cells print once; the tail redraws in place,
+     *  CSI 2026 wrapped; the cursor lands at the input edit column. */
+    render() {
+        if (!this.#isActive())
+            return;
+        const H = this.#opts.height();
+        const W = this.#opts.width();
+        const regionBottom = H - 3;
+        if (regionBottom < 1)
+            return;
+        const out = [];
+        out.push("\x1b[?2026h");
+        // 1. freeze completed cells — print their final form at the frozen
+        // area's next rows. The terminal scrolls the region when full.
+        while (this.#nextFrozen < this.#cells.length && this.#cells[this.#nextFrozen].done) {
+            const cell = this.#cells[this.#nextFrozen];
+            const lines = this.#cellLines(cell, W);
+            for (const line of lines) {
+                const row = Math.min(this.#frozenRows + 1, regionBottom);
+                out.push(`\x1b[${row};1H\x1b[0K${line}`);
+                if (this.#frozenRows + 1 > regionBottom) {
+                    out.push("\n"); // the region scrolls — the frozen rows shift up
+                }
+                else {
+                    this.#frozenRows += 1;
+                }
+            }
+            this.#nextFrozen += 1;
+        }
+        // 2. the active tail — clear its old area, draw the cells.
+        const tail = this.#cells.slice(this.#nextFrozen);
+        const tailHeight = tail.reduce((n, c) => n + this.#cellHeight(c, W), 0);
+        const tailTop = Math.max(1, regionBottom - tailHeight + 1);
+        const clearFrom = Math.min(this.#oldTailTop === 0 ? tailTop : this.#oldTailTop, tailTop);
+        for (let row = clearFrom; row <= regionBottom; row += 1) {
+            out.push(`\x1b[${row};1H\x1b[0K`);
+        }
+        let row = tailTop;
+        for (const cell of tail) {
+            for (const line of this.#cellLines(cell, W)) {
+                out.push(`\x1b[${row};1H${line}`);
+                row += 1;
+            }
+        }
+        this.#oldTailTop = tailTop;
+        // 3. the cursor home — the input line's edit column.
+        out.push(`\x1b[${H};${this.#opts.editCol()}H`);
+        out.push("\x1b[?2026l");
+        this.#write(out.join(""));
+    }
+    // ---- cell → lines ----
+    #cellLines(cell, W) {
+        const p = palette();
+        switch (cell.kind) {
+            case "user":
+                return [`${p.blue}you> ${escapeTerminal(cell.text)}${p.reset}`];
+            case "thinking": {
+                const block = cell.text;
+                const trimmed = escapeTerminal(block.trim());
+                if (trimmed.length <= 100)
+                    return [`${p.dim}…${trimmed}${p.reset}`];
+                return [`${p.dim}…${trimmed.slice(0, 100)} (… ${block.length} chars · /think shows full)${p.reset}`];
+            }
+            case "tool": {
+                const name = escapeTerminal(cell.name);
+                const summary = escapeTerminal(cell.input);
+                if (cell.state === "done") {
+                    const elapsed = cell.startedAt !== null && cell.doneAt !== null ? ((cell.doneAt - cell.startedAt) / 1000).toFixed(1) : "?";
+                    if (cell.isError) {
+                        const err = escapeTerminal(cell.resultText.split("\n")[0].slice(0, 60));
+                        return [`${p.red}✗ ${name} (${err}, ${elapsed}s)${p.reset}`];
+                    }
+                    return [`${p.blue}✓ ${name}${p.reset} (${summary}, ${elapsed}s)`];
+                }
+                if (cell.state === "approval")
+                    return [`→ ${name} ${summary} ${p.blue}⏸${p.reset}`];
+                if (cell.state === "running") {
+                    const elapsed = cell.startedAt !== null ? Math.max(1, Math.round((Date.now() - cell.startedAt) / 1000)) : 1;
+                    return [`→ ${name} ${summary} ${p.blue}${SPINNER[this.#spinnerI % SPINNER.length]}${p.reset} ${elapsed}s`];
+                }
+                return [`→ ${name} ${summary}`];
+            }
+            case "text": {
+                const text = escapeTerminal(cell.text);
+                const wrapped = this.#wrap(text, W);
+                return wrapped.length > 0 ? wrapped : [""];
+            }
+            case "notice":
+                return [escapeTerminal(cell.text)];
+            case "raw":
+                return cell.lines.map((l) => escapeTerminal(l));
+            case "terminal":
+                // the honest label (done / aborted / error) + the status + the
+                // rhythm gap blank
+                return [cell.label, cell.line, ""];
+        }
+    }
+    #cellHeight(cell, W) {
+        const lines = this.#cellLines(cell, W);
+        return Math.max(1, lines.length);
+    }
+    /** Wrap a body text by display width (the terminal's own wrapping,
+     *  approximated — documented; the region clamp keeps the dock safe). */
+    #wrap(text, W) {
+        if (W < 4)
+            return [text];
+        const out = [];
+        let current = "";
+        let width = 0;
+        for (const ch of text) {
+            const cw = displayWidth(ch);
+            if (ch === "\n" || width + cw > W) {
+                out.push(current);
+                current = "";
+                width = 0;
+                if (ch === "\n")
+                    continue;
+            }
+            current += ch;
+            width += cw;
+        }
+        out.push(current);
+        return out;
+    }
+    #toolCell(callId) {
+        const i = this.#toolCells.get(callId);
+        return i === undefined ? null : (this.#cells[i] ?? null);
+    }
+    /** Close an open thinking cell when a new cell starts (the block's
+     *  fold freezes at the transition). */
+    #closeOpenThinking() {
+        if (!this.#isActive() && this.#pipeBuf !== "") {
+            this.#lastThinking = this.#pipeBuf;
+            process.stdout.write(foldThinking(this.#pipeBuf));
+            this.#pipeBuf = "";
+            return;
+        }
+        const last = this.#cells[this.#cells.length - 1];
+        if (last !== undefined && last.kind === "thinking" && !last.done) {
+            last.done = true;
+            this.#lastThinking = last.text;
+        }
+    }
+}

package/dist/dock.d.ts

@@ -51,6 +51,13 @@ export declare class Dock {
      *  (probe-confirmed; the dock's redraw self-repaired ~200ms later,
      *  which read the user as cursor drift). */
     writeBody(text: string): void;
+    /** The input line's edit column — prompt width + cursor + 1. The
+     *  dock's redraw and the body's cursor return both end here, so the
+     *  ACTUAL cursor always equals what the editor tracks. The width is
+     *  DISPLAY width (the editor's cursor column is already width-based —
+     *  the CJK drift root cause, editor.ts). v2d: public — the Body's
+     *  render loop ends at this column. */
+    editCol(): number;
     /** The status bar's base text (usage, ctx, session, …). */
     setStatus(text: string): void;
     /** The live tail — the spinner glyph or "running <tool> Ns". */

package/dist/dock.js

@@ -122,7 +122,11 @@ export class Dock {
      *  dock's redraw and the body's cursor return both end here, so the
      *  ACTUAL cursor always equals what the editor tracks. The width is
      *  DISPLAY width (the editor's cursor column is already width-based —
-     *  the CJK drift root cause, editor.ts). */
+     *  the CJK drift root cause, editor.ts). v2d: public — the Body's
+     *  render loop ends at this column. */
+    editCol() {
+        return this.#inputCol();
+    }
     #inputCol() {
         const inp = this.#inputState();
         const promptWidth = displayWidth(this.#inputPrompt.replace(/\x1b\[[0-9;]*m/g, ""));

package/dist/index.js

@@ -17,6 +17,7 @@
  */
 import { existsSync, mkdtempSync, readFileSync, readdirSync, rmSync, symlinkSync, writeFileSync } from "node:fs";
 import { createInterface } from "node:readline";
+import { Body } from "./body.js";
 import { Editor, PROMPT as EDITOR_PROMPT } from "./editor.js";
 import { homedir, tmpdir } from "node:os";
 import { dirname, join } from "node:path";
@@ -209,17 +210,15 @@ function makeLineInput() {
 /** v2b: the bottom-anchored UI — docked only on a color TTY; pipes and
  *  NO_COLOR stay the v2a line mode byte-for-byte. */
 const dock = new Dock();
-/** v2b: body output routes through the dock when docked (the cursor into
- *  the scroll region, then back to the input line); otherwise a plain
- *  write — pipes are byte-identical to v2a. */
-function bodyWrite(text) {
-    if (dock.active)
-        dock.writeBody(text);
-    else
-        process.stdout.write(text);
-}
+/** v2d: the body renderer — the ONE writer of the stdout scroll region
+ *  (the frozen area + the active tail). Pipes run it in passthrough (the
+ *  v2b/v2c line-mode bytes, byte-for-byte). Created in main; closed on
+ *  every exit path. */
+let body;
+/** v2d: body output routes through the cell renderer — the single writer.
+ *  bodyLog adds the trailing newline; internal newlines are preserved. */
 function bodyLog(text) {
-    bodyWrite(`${text}\n`);
+    body.raw(text.split("\n"));
 }
 /** v2b: the spinner merged into the STATUS BAR (the v2a standalone glyph
  *  is gone) — docked only, 200ms rotation between the request and the
@@ -700,43 +699,16 @@ const DEFAULT_CONTEXT_WINDOW = 200_000;
  * line's form; `liveInput` (non-null only in interactive chat) carries the
  * last line THIS process's readline consumed — the double-echo filter.
  */
-async function consumeRun(session, run, input, turnNo, lastToolRef, faux, liveInput, lastThinking, statusCb) {
+async function consumeRun(session, run, input, turnNo, faux, liveInput, statusCb) {
     let last;
-    // B 区: tool_call_end → (name, input) for the summary; tool_result →
-    // one summary line. Usage events feed the status line.
-    const pendingCalls = new Map();
     let usage = { in: null, out: null, cache: null, known: false };
-    // v2b: thinking blocks buffer and fold to ONE dim line at the block's
-    // end (foldThinking); the FULL text goes to /think.
-    let thinkingBuf = "";
-    const flushThinking = () => {
-        if (thinkingBuf === "")
-            return;
-        lastThinking.current = thinkingBuf;
-        bodyWrite(foldThinking(thinkingBuf));
-        thinkingBuf = "";
-    };
-    let thinkingOpen = false;
-    // v2b: liveness merged into the status bar (docked); a running timer
-    // shows "running <tool> Ns" during a tool execution.
-    const stopSpinner = startStatusSpinner();
-    let stopRunning = null;
-    let firstEvent = true;
     try {
         for await (const ev of run) {
-            if (firstEvent) {
-                firstEvent = false;
-                stopSpinner();
-            }
             last = ev;
-            // v2a (双回显): the interactive readline already echoed an input THIS
-            // process consumed — rendering the event again is the double echo.
-            // Replayed history (recovery/resume — nobody typed) keeps the event
-            // render. Deterministic: exact content match with the consumed line,
-            // on a TTY (the only place an echo exists to hand over).
+            // v2a (双回显): the interactive echo was already rendered by the
+            // input source — rendering the event again is the double echo.
             // v2b: DOCKED — the echo lives in the input row (H), NOT the body;
-            // the body render is the ONLY visible copy of the sent line. The
-            // user's typed text must not vanish after Enter.
+            // the body render is the ONLY visible copy of the sent line.
             if (ev.type === "user_input" &&
                 liveInput !== null &&
                 liveInput.current === (typeof ev.content === "string" ? ev.content : "") &&
@@ -744,78 +716,87 @@ async function consumeRun(session, run, input, turnNo, lastToolRef, faux, liveIn
                 !dock.active) {
                 continue;
             }
-            const prevThinking = thinkingOpen;
-            thinkingOpen = ev.type === "thinking";
-            if (prevThinking && !thinkingOpen)
-                flushThinking();
-            if (ev.type === "thinking") {
-                thinkingBuf += ev.text;
-                continue;
-            }
-            if (ev.type === "tool_call_end") {
-                pendingCalls.set(ev.callId, { name: ev.name, input: ev.input ?? {} });
-            }
-            if (ev.type === "tool_execution_started") {
-                stopRunning = startRunningTimer(ev.name);
-            }
-            if (ev.type === "tool_result") {
-                stopRunning?.();
-                stopRunning = null;
-                const call = pendingCalls.get(ev.callId);
-                pendingCalls.delete(ev.callId);
-                if (call !== undefined) {
+            // v2d: EVERY event only mutates a cell — the Body is the single
+            // writer of the scroll region, so interleaving is impossible by
+            // construction (ADR-0040).
+            switch (ev.type) {
+                case "user_input":
+                    body.userLine(typeof ev.content === "string" ? ev.content : "");
+                    break;
+                case "thinking":
+                    body.thinkingAppend(ev.text);
+                    break;
+                case "tool_call_end":
+                    body.toolStart(ev.name, ev.callId, ev.input ?? {});
+                    break;
+                case "tool_execution_started":
+                    body.toolRunning(ev.callId);
+                    break;
+                case "tool_execution_succeeded":
+                    body.toolSucceeded(ev.callId);
+                    break;
+                case "tool_execution_failed":
+                    body.toolFailed(ev.callId, ev.error);
+                    break;
+                case "tool_result": {
                     const text = typeof ev.content === "string" ? ev.content : "";
-                    lastToolRef.current = { name: call.name, input: call.input, result: { content: text, isError: ev.isError } };
-                    bodyLog(renderToolSummary(call.name, call.input, { content: text, isError: ev.isError }));
+                    body.toolResult(ev.callId, { content: text, isError: ev.isError });
+                    break;
                 }
-            }
-            if (ev.type === "usage") {
-                usage = { in: ev.inputTokens, out: ev.outputTokens, cache: ev.cacheRead, known: ev.known };
-                statusCb?.(usage, estimateCtxRatio(session));
-            }
-            if (ev.type === "uncertain_pending") {
-                // 裁决 #12 (ADR-0038): the ⚠ line is pure INFORMATION now — the
-                // approval chain guards retries, and the human question belongs
-                // only to the crash window's recovery flow (resolveUncertains).
-                // Old logs may still carry the event; replay shows the fact.
-                bodyLog(`\n⚠ ${escapeTerminal(ev.name)} FAILED — the side effect may have applied.\n  ${escapeTerminal(ev.error)}\n`);
-                continue;
-            }
-            const rendered = renderEvent(ev, prevThinking);
-            if (rendered.prompt) {
-                // v2b (docked): the detail scrolls into the body; the question
-                // takes over the status position; the answer lands at the input
-                // line. Pipes keep the v2a inline render.
-                bodyWrite(rendered.text);
-                const decisionId = ev.decisionId;
-                const name = ev.name;
-                // 八: the tool name is model text — escaped on every output path.
-                const answer = await ask(input, `approve ${escapeTerminal(name)}? (y/n) `);
-                if (answer === CANCELLED) {
-                    // 十: a cancellation is a CONSERVATIVE denial, explicitly
-                    // distinguished from the user typing "n".
-                    bodyLog("[approval cancelled — treated as a denial]\n");
-                    await session.approve(decisionId, false);
-                    continue;
+                case "text_delta":
+                    body.textAppend(ev.text);
+                    break;
+                case "text_end":
+                    body.textEnd();
+                    break;
+                case "usage":
+                    usage = { in: ev.inputTokens, out: ev.outputTokens, cache: ev.cacheRead, known: ev.known };
+                    statusCb?.(usage, estimateCtxRatio(session));
+                    break;
+                case "uncertain_pending":
+                    // 裁决 #12 (ADR-0038): the ⚠ line is pure INFORMATION now — the
+                    // approval chain guards retries, and the human question belongs
+                    // only to the crash window's recovery flow (resolveUncertains).
+                    body.notice(`⚠ ${escapeTerminal(ev.name)} FAILED — the side effect may have applied. ${escapeTerminal(ev.error)}`);
+                    break;
+                case "permission_requested": {
+                    // v2d: the ToolCell shows the ⏸ badge; the question takes over
+                    // the dock status position; the answer lands at the input line.
+                    body.toolApproval(ev.callId);
+                    const decisionId = ev.decisionId;
+                    const name = ev.name;
+                    const answer = await ask(input, `approve ${escapeTerminal(name)}? (y/n) `);
+                    if (answer === CANCELLED) {
+                        // 十: a cancellation is a CONSERVATIVE denial, explicitly
+                        // distinguished from the user typing "n".
+                        body.notice("[approval cancelled — treated as a denial]");
+                        await session.approve(decisionId, false);
+                        continue;
+                    }
+                    await session.approve(decisionId, answer.trim().toLowerCase().startsWith("y"));
+                    break;
+                }
+                case "terminal":
+                    statusCb?.(usage, estimateCtxRatio(session));
+                    // v2a rhythm: the honest label (\ndone\n — the completed
+                    // marker), the status line hugging it, then EXACTLY one blank
+                    // line before the next prompt.
+                    body.terminal(renderEvent(ev).text, renderStatusLine(turnNo, usage, estimateCtxRatio(session), faux) ?? "");
+                    break;
+                default: {
+                    // Events without a cell (stop, …) — the generic render, byte-
+                    // preserved for the pipe path.
+                    const rendered = renderEvent(ev);
+                    if (rendered.text !== "") {
+                        body.raw(rendered.text.replace(/\n$/, "").split("\n"));
+                    }
+                    break;
                 }
-                await session.approve(decisionId, answer.trim().toLowerCase().startsWith("y"));
-            }
-            else {
-                bodyWrite(rendered.text);
-            }
-            if (ev.type === "terminal") {
-                statusCb?.(usage, estimateCtxRatio(session));
-                // v2a rhythm: the status line hugs the terminal (有什么显什么 —
-                // null = nothing to show), then EXACTLY one blank line before
-                // the next prompt.
-                bodyWrite(renderTerminalGap(renderStatusLine(turnNo, usage, estimateCtxRatio(session), faux)));
             }
         }
-        flushThinking();
+        body.thinkingEnd(); // a trailing thinking block folds at the run's end
     }
     finally {
-        stopSpinner();
-        stopRunning?.();
     }
     return last;
 }
@@ -861,7 +842,7 @@ async function chat(session, faux, input) {
         (async () => {
             let last;
             try {
-                last = await consumeRun(session, run, input, myTurn, lastToolRef, faux, liveInput, lastThinking, statusCb);
+                last = await consumeRun(session, run, input, myTurn, faux, liveInput, statusCb);
                 currentRun = null;
                 // 八: a faux script that ran out of declared turns exits
                 // loudly with a non-zero status — never a silent status 0.
@@ -935,14 +916,12 @@ async function chat(session, faux, input) {
     let chain = Promise.resolve();
     let replReady = false;
     const queuedLines = [];
-    // B 区: user-turn counter for the status line, and the /last buffer.
+    // B 区: user-turn counter for the status line. /last and /think read
+    // the body (the ToolCell / ThinkingCell final states).
     let turnNo = 0;
-    const lastToolRef = { current: null };
     // v2a: the last line THIS process's readline consumed — the double-echo
     // filter (see consumeRun). Only interactive chat sets it.
     const liveInput = { current: null };
-    // v2b: the last complete thinking block, for /think.
-    const lastThinking = { current: null };
     // v2c: turns submitted while another runs are QUEUED on the chain — the
     // live count rides the status bar (+N queued).
     let queued = 0;
@@ -976,10 +955,10 @@ async function chat(session, faux, input) {
             return;
         }
         if (trimmed === "/think") {
-            // v2b: print the last COMPLETE thinking block — straight from the
-            // event stream, nothing stored separately (the /last pattern).
+            // v2b/v2d: print the last COMPLETE thinking block — the body holds
+            // it (the ThinkingCell's fold closes at the block's end).
             chain = chain.then(async () => {
-                const t = lastThinking.current;
+                const t = body.lastThinking();
                 if (t === null) {
                     bodyLog("[no thinking yet]");
                 }
@@ -991,11 +970,11 @@ async function chat(session, faux, input) {
             return;
         }
         if (trimmed === "/last") {
-            // B 区: print the FULL input/output of the most recent tool call,
-            // straight from the event stream — nothing is stored separately.
-            // Runs on the chain: after any in-flight turn completes.
+            // B 区/v2d: print the FULL input/output of the most recent tool
+            // call — the body holds it (the ToolCell's final state). Runs on
+            // the chain: after any in-flight turn completes.
             chain = chain.then(async () => {
-                const tool = lastToolRef.current;
+                const tool = body.lastTool();
                 if (tool === null) {
                     bodyLog("[no tool call yet]");
                 }
@@ -1049,7 +1028,7 @@ async function chat(session, faux, input) {
         const recoveryRun = session.resume();
         currentRun = recoveryRun;
         turnNo += 1;
-        const last = await consumeRun(session, recoveryRun, input, turnNo, lastToolRef, faux, liveInput, lastThinking, statusCb);
+        const last = await consumeRun(session, recoveryRun, input, turnNo, faux, liveInput, statusCb);
         currentRun = null;
         failOnFauxExhaustion(last, faux, input);
     }
@@ -1084,8 +1063,6 @@ async function resume(session, prompt, faux, input) {
     let currentRun = null;
     let cancelled = false;
     let turnNo = 0;
-    const lastToolRef = { current: null };
-    const lastThinking = { current: null };
     // v2b: the live status bar (docked only).
     const statusCb = (u, ctx) => {
         if (!dock.active)
@@ -1097,7 +1074,7 @@ async function resume(session, prompt, faux, input) {
         currentRun = run;
         try {
             turnNo += 1;
-            const last = await consumeRun(session, run, input, turnNo, lastToolRef, faux, null, lastThinking, statusCb);
+            const last = await consumeRun(session, run, input, turnNo, faux, null, statusCb);
             failOnFauxExhaustion(last, faux, input);
         }
         finally {
@@ -1160,6 +1137,14 @@ async function main() {
     // readline elsewhere. The trust question, chat, and resume all read
     // through it; main's finally closes it on every exit path.
     const input = makeLineInput();
+    // v2d: the body renderer — active only where the dock is (a color
+    // TTY with a real size); pipes run it in passthrough, byte-for-byte.
+    body = new Body({
+        active: () => process.stdin.isTTY && palette().blue !== "" && (process.stdout.rows ?? 0) >= 4,
+        height: () => process.stdout.rows ?? 24,
+        width: () => process.stdout.columns ?? 80,
+        editCol: () => dock.editCol(),
+    });
     try {
         switch (command) {
             case "chat": {
@@ -1224,6 +1209,7 @@ async function main() {
         }
     }
     finally {
+        body.close(); // flush the pending frame, stop the heartbeat
         input.close();
         // E 组: every normal and abnormal exit releases the fds and writer
         // locks — no lock file is left behind.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vincemakes/kiso-code",
-  "version": "0.1.14",
+  "version": "0.1.15",
   "description": "kiso CLI — the coding-agent reference product: kiso chat / kiso resume / kiso sessions.",
   "type": "module",
   "license": "MIT",
@@ -18,12 +18,12 @@
     "test": "vitest run"
   },
   "dependencies": {
-    "@vincemakes/kiso-core": "0.1.14",
-    "@vincemakes/kiso-evals": "0.1.14",
-    "@vincemakes/kiso-provider-anthropic": "0.1.14",
-    "@vincemakes/kiso-provider-openai": "0.1.14",
-    "@vincemakes/kiso-runtime": "0.1.14",
-    "@vincemakes/kiso-tools-node": "0.1.14"
+    "@vincemakes/kiso-core": "0.1.15",
+    "@vincemakes/kiso-evals": "0.1.15",
+    "@vincemakes/kiso-provider-anthropic": "0.1.15",
+    "@vincemakes/kiso-provider-openai": "0.1.15",
+    "@vincemakes/kiso-runtime": "0.1.15",
+    "@vincemakes/kiso-tools-node": "0.1.15"
   },
   "devDependencies": {
     "@types/node": "^26.1.2",