@vincemakes/kiso-code 0.1.15 → 0.1.17

package/dist/body.d.ts

@@ -39,6 +39,9 @@ export type BodyCell = {
     state: "pending" | "approval" | "running" | "done";
     isError: boolean;
     resultText: string;
+    diff: import("./diff.js").DiffLine[] | null;
+    added: number;
+    removed: number;
     startedAt: number | null;
     doneAt: number | null;
     done: boolean;
@@ -96,7 +99,7 @@ export declare class Body {
     thinkingAppend(text: string): void;
     thinkingEnd(): void;
     toolStart(name: string, callId: string, input: Record<string, unknown>): void;
-    toolApproval(callId: string): void;
+    toolApproval(callId: string, diff: import("./diff.js").DiffResult | null): void;
     toolRunning(callId: string): void;
     toolSucceeded(callId: string): void;
     toolFailed(callId: string, error: string): void;

package/dist/body.js

@@ -23,10 +23,11 @@
  * NoticeCell / raw block) — deliberately NOT pi's Component interface
  * shape (ADR-0040).
  */
+import { truncateDiff } from "./diff.js";
 import { displayWidth } from "./editor.js";
 import { escapeTerminal, foldResult, foldThinking, palette, renderTerminalGap, renderToolSummary, } from "./render.js";
-/** The spinner glyphs, cycled by the heartbeat. */
-const SPINNER = ["◐", "◓", "◑", "◒"];
+/** The spinner glyphs, cycled by the heartbeat (v3 §05 — the working family). */
+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
@@ -35,7 +36,7 @@ export class Body {
     #opts;
     #cells = [];
     #nextFrozen = 0; // index of the first not-yet-printed cell
-    #frozenRows = 0; // rows of the region occupied by printed cells
+    #frozenRows = 0; // the frozen area's rows filled WITHOUT scrolling (then the real LFs take over)
     #oldTailTop = 0; // the tail's previous first row — for the clear pass
     #frameTimer = null;
     #heartbeat = null;
@@ -53,6 +54,14 @@ export class Body {
         this.#active = opts.active();
         if (this.#isActive()) {
             this.#heartbeat = setInterval(() => {
+                // #14 (P1): the idle heartbeat PAINTS NOTHING. An idle body
+                // (every cell frozen) has no glyph/elapsed to advance — a
+                // beat that renders anyway re-paints the tail + the dock
+                // every 200ms with ZERO change (12s idle = 61 copies /
+                // ~47KB — the measured defect). Only an ACTIVE tail makes
+                // the beat matter: paint, then.
+                if (!this.#cells.some((c) => !c.done))
+                    return;
                 this.#spinnerI = (this.#spinnerI + 1) % SPINNER.length;
                 this.#dirty = true; // the running cells' glyph/elapsed advance
                 this.#scheduleFrame();
@@ -90,11 +99,13 @@ export class Body {
     userLine(text) {
         if (!this.#isActive()) {
             this.#closeOpenThinking();
+            this.#closeOpenText();
             const p = palette();
             this.#write(`${p.blue}you> ${escapeTerminal(text)}${p.reset}\n`);
             return;
         }
         this.#closeOpenThinking();
+        this.#closeOpenText();
         this.#cells.push({ kind: "user", text, done: true });
         this.#mark();
     }
@@ -129,19 +140,27 @@ export class Body {
         this.#pendingCalls.set(callId, { name, input, result: { content: "", isError: false } });
         if (!this.#isActive()) {
             this.#closeOpenThinking();
+            this.#closeOpenText();
             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.#cells.push({ kind: "tool", name, input: summary, state: "pending", isError: false, resultText: "", diff: null, added: 0, removed: 0, startedAt: null, doneAt: null, done: false });
         this.#mark();
     }
-    toolApproval(callId) {
+    toolApproval(callId, diff) {
         if (!this.#isActive())
             return;
         const cell = this.#toolCell(callId);
-        if (cell !== null && cell.kind === "tool" && !cell.done)
+        if (cell !== null && cell.kind === "tool" && !cell.done) {
             cell.state = "approval";
+            // v2e: the mini-diff renders BELOW the tool line at the approval
+            // moment — the human sees the change before deciding. Auto-allowed
+            // tools pass null (nobody is looking — no diff, no cost).
+            cell.diff = diff === null ? null : truncateDiff(diff.lines);
+            cell.added = diff?.added ?? 0;
+            cell.removed = diff?.removed ?? 0;
+        }
         this.#mark();
     }
     toolRunning(callId) {
@@ -196,6 +215,7 @@ export class Body {
     textAppend(text) {
         if (!this.#isActive()) {
             this.#closeOpenThinking();
+            this.#closeOpenText();
             process.stdout.write(escapeTerminal(text));
             return;
         }
@@ -205,6 +225,7 @@ export class Body {
         }
         else {
             this.#closeOpenThinking();
+            this.#closeOpenText();
             this.#cells.push({ kind: "text", text, done: false });
         }
         this.#mark();
@@ -223,21 +244,25 @@ export class Body {
     terminal(label, statusLine) {
         if (!this.#isActive()) {
             this.#closeOpenThinking();
+            this.#closeOpenText();
             // the v2c bytes: the terminal label (\ndone\n) + the status gap.
             process.stdout.write(label + renderTerminalGap(statusLine));
             return;
         }
         this.#closeOpenThinking();
+        this.#closeOpenText();
         this.#cells.push({ kind: "terminal", label: label.trim(), line: statusLine, done: true });
         this.#mark();
     }
     notice(text) {
         if (!this.#isActive()) {
             this.#closeOpenThinking();
+            this.#closeOpenText();
             process.stdout.write(`${text}\n`);
             return;
         }
         this.#closeOpenThinking();
+        this.#closeOpenText();
         this.#cells.push({ kind: "notice", text, done: true });
         this.#mark();
     }
@@ -246,11 +271,13 @@ export class Body {
     raw(lines) {
         if (!this.#isActive()) {
             this.#closeOpenThinking();
+            this.#closeOpenText();
             for (const line of lines)
                 process.stdout.write(`${line}\n`);
             return;
         }
         this.#closeOpenThinking();
+        this.#closeOpenText();
         this.#cells.push({ kind: "raw", lines, done: true });
         this.#mark();
     }
@@ -280,34 +307,47 @@ export class Body {
             return;
         const H = this.#opts.height();
         const W = this.#opts.width();
-        const regionBottom = H - 3;
-        if (regionBottom < 1)
+        if (H < 4)
             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
+        // #13 (P1), v2d-B: NO DECSTBM — overflow scrolls with a REAL LF at
+        // the screen's last row, so the frozen lines enter the terminal's
+        // NATIVE scrollback deterministically (region-scrolled lines are
+        // terminal-dependent; some terminals drop them — the measured v2d-A
+        // defect). The body fills from the top without scrolling; once full,
+        // every new frozen line scrolls the whole screen (\x1b[H;1H\n — the
+        // top line leaves into the scrollback) and lands at the body's
+        // bottom row, just above the active tail. The dock is redrawn after.
+        // The tail (the remaining ACTIVE cells) and its geometry — computed
+        // FIRST from the final nextFrozen, so the frozen cells are NOT in it
+        // (a stale tail would re-draw them — the double-render).
+        let nextFrozen = this.#nextFrozen;
+        while (nextFrozen < this.#cells.length && this.#cells[nextFrozen].done)
+            nextFrozen += 1;
+        const tail = this.#cells.slice(nextFrozen);
+        const tailHeight = tail.reduce((n, c) => n + this.#cellHeight(c, W), 0);
+        const tailTop = Math.max(1, H - 3 - tailHeight); // v3 §03: 4 dock rows below
+        const writeRow = Math.max(1, tailTop - 1); // the frozen area's bottom row
+        let scrolled = 0;
+        for (let i = this.#nextFrozen; i < nextFrozen; i += 1) {
+            for (const line of this.#cellLines(this.#cells[i], W)) {
+                if (this.#frozenRows < writeRow) {
+                    this.#frozenRows += 1;
+                    out.push(`\x1b[${this.#frozenRows};1H\x1b[0K${line}`);
                 }
                 else {
-                    this.#frozenRows += 1;
+                    out.push(`\x1b[${H};1H\n`); // the REAL LF — the whole screen scrolls
+                    out.push(`\x1b[${writeRow};1H\x1b[0K${line}`);
+                    scrolled += 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) {
+        // 2. the active tail — clear its old area (shifted up by the freeze
+        // scrolls) and the current area, draw the cells at the body's bottom.
+        out.push("\x1b[?2026h");
+        const clearFrom = Math.min(this.#oldTailTop === 0 ? tailTop : this.#oldTailTop - scrolled, tailTop);
+        for (let row = clearFrom; row <= H - 4; row += 1) {
             out.push(`\x1b[${row};1H\x1b[0K`);
         }
         let row = tailTop;
@@ -317,24 +357,29 @@ export class Body {
                 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(""));
+        // 4. the dock rows — the freeze scrolls shifted them; redraw (the
+        // dock's own redraw re-pins the cursor at the edit position).
+        this.#opts.onDock?.();
     }
     // ---- cell → lines ----
     #cellLines(cell, W) {
         const p = palette();
         switch (cell.kind) {
             case "user":
-                return [`${p.blue}you> ${escapeTerminal(cell.text)}${p.reset}`];
+                // v3 §02: the user message is a SGR BACKGROUND block, no
+                // prefix — every line carries the block's background
+                // (multi-line whole; resize-safe). Pipes stay plain.
+                return cell.text.split("\n").map((l) => `${p.bg}${escapeTerminal(l)}${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}`];
+                return [`${p.dim}…${trimmed.slice(0, 100)} (${block.length} chars · /think)${p.reset}`];
             }
             case "tool": {
                 const name = escapeTerminal(cell.name);
@@ -345,10 +390,25 @@ export class Body {
                         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)`];
+                    const delta = cell.added + cell.removed > 0 ? `, +${cell.added} -${cell.removed}` : "";
+                    return [`${p.blue}✓ ${name}${p.reset} (${summary}${delta}, ${elapsed}s)`];
+                }
+                if (cell.state === "approval") {
+                    const lines = [`→ ${name} ${summary} ${p.blue}⏸${p.reset}`];
+                    // v2e: the mini-diff — ▎ blue edge (the brick motif), - red /
+                    // + green / context dim; NO_COLOR keeps the ± prefixes plain.
+                    if (cell.diff !== null) {
+                        for (const d of cell.diff) {
+                            const body = d.kind === "-"
+                                ? `${p.red}- ${escapeTerminal(d.text)}${p.reset}`
+                                : d.kind === "+"
+                                    ? `${p.green}+ ${escapeTerminal(d.text)}${p.reset}`
+                                    : `${p.dim}  ${escapeTerminal(d.text)}${p.reset}`;
+                            lines.push(`${p.blue}▎${p.reset}${body}`);
+                        }
+                    }
+                    return lines;
                 }
-                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`];
@@ -401,6 +461,16 @@ export class Body {
         const i = this.#toolCells.get(callId);
         return i === undefined ? null : (this.#cells[i] ?? null);
     }
+    /** Close an open TEXT cell when a new cell starts — the runtime emits
+     *  no text_end (it is an adapter-level event), so the stream's next
+     *  cell is the close signal; without it the freeze blocks behind the
+     *  open text and everything after it re-renders in the tail forever
+     *  (the #13 flood reproduced the overwrite). */
+    #closeOpenText() {
+        const last = this.#cells[this.#cells.length - 1];
+        if (last !== undefined && last.kind === "text" && !last.done)
+            last.done = true;
+    }
     /** Close an open thinking cell when a new cell starts (the block's
      *  fold freezes at the transition). */
     #closeOpenThinking() {

package/dist/diff.d.ts

@@ -0,0 +1,32 @@
+/**
+ * v2e — the diff renderer: edit/write changes as inline ± lines, zero
+ * dependencies, no syntax highlighting (the spec's scope line). Shown at
+ * the approval moment ONLY — the frozen summary stays one line (v2d's
+ * anti-leak principle), /last has the full data.
+ *
+ * edit_file diffs IN PLACE (the search→replace windows are known — no
+ * general engine needed); write_file does a row-level LCS over the old
+ * file (small files are the target). Context: 2 rows each side. The
+ * RENDERER truncates (18 head + 18 tail + "… N lines"); the stats come
+ * from the full diff.
+ */
+/** The diff block's per-row kind. */
+export type DiffLine = {
+    kind: "-" | "+" | " ";
+    text: string;
+};
+export interface DiffResult {
+    /** The FULL diff (with context, not truncated) — the display truncates. */
+    lines: DiffLine[];
+    added: number;
+    removed: number;
+}
+/** The RENDERER's truncation: head + "… N lines (/last for full)" + tail. */
+export declare function truncateDiff(diff: DiffLine[]): DiffLine[];
+/** edit_file: the search→replace windows replace in place — the changed
+ *  region is KNOWN, so the diff is the old window vs the new window,
+ *  context from the surrounding file. */
+export declare function editFileDiff(oldContent: string, search: string, replace: string): DiffResult;
+/** write_file: a new file is all +; an existing file diffs row-level
+ *  against its old content. */
+export declare function writeFileDiff(oldContent: string | null, newContent: string): DiffResult;

package/dist/diff.js

@@ -0,0 +1,122 @@
+/**
+ * v2e — the diff renderer: edit/write changes as inline ± lines, zero
+ * dependencies, no syntax highlighting (the spec's scope line). Shown at
+ * the approval moment ONLY — the frozen summary stays one line (v2d's
+ * anti-leak principle), /last has the full data.
+ *
+ * edit_file diffs IN PLACE (the search→replace windows are known — no
+ * general engine needed); write_file does a row-level LCS over the old
+ * file (small files are the target). Context: 2 rows each side. The
+ * RENDERER truncates (18 head + 18 tail + "… N lines"); the stats come
+ * from the full diff.
+ */
+/** A line-level LCS diff — the classic two-row DP, ~small inputs. */
+function lcsDiff(oldLines, newLines) {
+    const n = oldLines.length;
+    const m = newLines.length;
+    const dp = Array.from({ length: n + 1 }, () => new Array(m + 1).fill(0));
+    for (let i = n - 1; i >= 0; i -= 1) {
+        for (let j = m - 1; j >= 0; j -= 1) {
+            dp[i][j] = oldLines[i] === newLines[j] ? dp[i + 1][j + 1] + 1 : Math.max(dp[i + 1][j], dp[i][j + 1]);
+        }
+    }
+    const out = [];
+    let i = 0;
+    let j = 0;
+    while (i < n && j < m) {
+        if (oldLines[i] === newLines[j]) {
+            out.push({ kind: " ", text: oldLines[i] });
+            i += 1;
+            j += 1;
+        }
+        else if (dp[i + 1][j] >= dp[i][j + 1]) {
+            out.push({ kind: "-", text: oldLines[i] });
+            i += 1;
+        }
+        else {
+            out.push({ kind: "+", text: newLines[j] });
+            j += 1;
+        }
+    }
+    while (i < n) {
+        out.push({ kind: "-", text: oldLines[i] });
+        i += 1;
+    }
+    while (j < m) {
+        out.push({ kind: "+", text: newLines[j] });
+        j += 1;
+    }
+    return out;
+}
+/** Keep 2 context rows around each change — the unified-style window. */
+function withContext(diff) {
+    const out = [];
+    let lastAdded = -10;
+    for (let k = 0; k < diff.length; k += 1) {
+        if (diff[k].kind === " ")
+            continue;
+        const from = Math.max(0, k - 2);
+        const to = Math.min(diff.length - 1, k + 2);
+        for (let c = from; c <= to; c += 1) {
+            if (c > lastAdded) {
+                out.push(diff[c]);
+                lastAdded = c;
+            }
+        }
+        lastAdded = to;
+    }
+    return out;
+}
+const MAX_DIFF_LINES = 40; // the RENDERED cap
+const TRUNCATE_KEEP = 18;
+/** The RENDERER's truncation: head + "… N lines (/last for full)" + tail. */
+export function truncateDiff(diff) {
+    if (diff.length <= MAX_DIFF_LINES)
+        return diff;
+    const omitted = diff.length - 2 * TRUNCATE_KEEP;
+    return [
+        ...diff.slice(0, TRUNCATE_KEEP),
+        { kind: " ", text: `… ${omitted} lines (/last for full)` },
+        ...diff.slice(diff.length - TRUNCATE_KEEP),
+    ];
+}
+function stats(diff) {
+    let added = 0;
+    let removed = 0;
+    for (const d of diff) {
+        if (d.kind === "+")
+            added += 1;
+        else if (d.kind === "-")
+            removed += 1;
+    }
+    return { added, removed };
+}
+/** edit_file: the search→replace windows replace in place — the changed
+ *  region is KNOWN, so the diff is the old window vs the new window,
+ *  context from the surrounding file. */
+export function editFileDiff(oldContent, search, replace) {
+    const oldLines = oldContent.split("\n");
+    const searchLines = search.split("\n");
+    const replaceLines = replace.split("\n");
+    // Locate the search window (the first occurrence — the edit tool's own
+    // semantics); no occurrence → the whole file is the old side.
+    let at = -1;
+    for (let i = 0; i + searchLines.length <= oldLines.length; i += 1) {
+        if (oldLines.slice(i, i + searchLines.length).join("\n") === search) {
+            at = i;
+            break;
+        }
+    }
+    const lines = at < 0 ? withContext(lcsDiff(oldLines, replaceLines)) : withContext(lcsDiff(oldLines, [...oldLines.slice(0, at), ...replaceLines, ...oldLines.slice(at + searchLines.length)]));
+    return { lines, ...stats(lines) };
+}
+/** write_file: a new file is all +; an existing file diffs row-level
+ *  against its old content. */
+export function writeFileDiff(oldContent, newContent) {
+    if (oldContent === null) {
+        const lines = newContent.split("\n").map((text) => ({ kind: "+", text }));
+        return { lines, added: lines.length, removed: 0 };
+    }
+    const lines = withContext(lcsDiff(oldContent.split("\n"), newContent.split("\n")));
+    return { lines, ...stats(lines) };
+}

package/dist/dock.d.ts

@@ -4,14 +4,16 @@
  * implementation: zero dependencies, line-level ANSI, no differential
  * renderer.
  *
- * Layout (H = terminal height): rows 1..H-3 = the scroll region (the body
- * streams and scrolls here, never touching the bottom), row H-2 = the dim
- * dotted separator (╌), row H-1 = the live status bar (or a takeover
- * question), row H = the input line (the blue brick ▌you> + the v2c
- * editor's row — readline is gone from the TTY path). Bottom redraws are
- * wrapped in CSI 2026 (synchronized output) to avoid flicker — the pi
- * trick. The visual identity is the kiso brick motif — ▌ half-block,
- * dotted separator — deliberately NOT the CC rounded frame nor the pi
+ * Layout (H = terminal height): rows 1..H-4 = the scroll region (the body
+ * streams and scrolls here, never touching the bottom), row H-3 = the
+ * upper dim dotted separator (╌), row H-2 = the input line (the blue
+ * brick ▌you> + the v2c editor's row — readline is gone from the TTY
+ * path), row H-1 = the lower dotted separator, row H = the live status
+ * bar (v3 §03: idle "▸ <mode> · /mode to switch · …", running
+ * "▖ working Ns · …"; a takeover question replaces it). Bottom redraws
+ * are wrapped in CSI 2026 (synchronized output) to avoid flicker — the
+ * pi trick. The visual identity is the kiso brick motif — ▌ half-block,
+ * dotted separators — deliberately NOT the CC rounded frame nor the pi
  * editor (ADR-0039 Amendment 2).
  *
  * Pipes / NO_COLOR: the dock never activates; the v2a line mode stays
@@ -27,7 +29,11 @@ export declare class Dock {
         line: string;
         cursor: number;
     }, prompt: string): void;
-    /** Enter docked mode: DECSTBM the scroll region, draw the chrome. A
+    /** Enter docked mode: draw the chrome. #13 (P1): the DECSTBM scroll
+     *  region is GONE — v2d-B (ADR-0040): the body uses plain LF scrolling
+     *  so frozen lines enter the native scrollback deterministically
+     *  (region-scrolled lines are terminal-dependent — some terminals drop
+     *  them). The dock rows are redrawn by the body after every scroll. A
      *  TTY without a real window size (rows < 4) stays in the v2a line
      *  mode — the bottom three rows need room to exist. */
     enter(): void;
@@ -36,21 +42,15 @@ export declare class Dock {
      *  from main's finally on EVERY exit path (kill -9 excepted — README:
      *  `reset` saves it). */
     exit(): void;
-    /** SIGWINCH: recompute the region, redraw the chrome. */
+    /** SIGWINCH: recompute the size, redraw the chrome. */
     onResize(): void;
-    /** Body output: position the cursor inside the scroll region at the
-     *  body's tracked position, write, and hand the cursor back to the
-     *  input line's EDIT position. The row/col tracking is approximate for
-     *  width-wrapped and wide-char lines (documented) — the region clamp
-     *  keeps the bottom rows safe regardless.
-     *
-     *  The edit-position return is a correctness requirement, not
-     *  cosmetics: readline tracks its cursor internally and NEVER
-     *  re-syncs after an external move — a body write that left the
-     *  cursor at column 1 made the next keystroke overwrite the prompt
-     *  (probe-confirmed; the dock's redraw self-repaired ~200ms later,
-     *  which read the user as cursor drift). */
-    writeBody(text: string): void;
+    /** v3 §04: bind the editor's slash-command menu state — the menu rows
+     *  render ABOVE the chrome (over the body's bottom rows; the menu
+     *  opens while the buffer is a "/" prefix, when no tail is live). */
+    bindMenu(state: () => {
+        items: readonly import("./editor.js").MenuItem[];
+        selected: number;
+    } | null): 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
@@ -66,11 +66,10 @@ export declare class Dock {
      *  input line by the caller's readline); clearQuestion() restores. */
     showQuestion(question: string): void;
     clearQuestion(): void;
-    /** The bottom three rows, wrapped in CSI 2026 (synchronized output —
+    /** The bottom four rows, wrapped in CSI 2026 (synchronized output —
      *  the pi trick against flicker). The cursor ends at the input line's
-     *  edit position. v2c: the separator is the dim dotted ╌ (a weaker
-     *  presence than the solid ─), the status line is dim (blue accents
-     *  inside come from the CLI's composition), the input row is the blue
-     *  brick ▌you> + the editor's visible slice. */
+     *  edit position. v3 §03: the upper ╌ row, the input row, the lower
+     *  ╌ row, the status row — the status is dim (blue accents inside
+     *  come from the CLI's composition). */
     redraw(): void;
 }