@vincemakes/kiso-tui 0.15.2 → 0.15.3

package/dist/ask-panel.d.ts

@@ -53,13 +53,6 @@ export interface AskStep {
     readonly state: AskRuntime;
     readonly result?: AskResult;
 }
-/**
- * The pure key reducer. `key` is a single logical key: a digit "1".."4",
- * "space", "up"/"down", "left" (walk back), "enter", "t" (type your own),
- * or "esc". The custom phase's TEXT is not routed here — the editor owns
- * the buffer exactly as it does for the rule-input phase, and hands the
- * committed line to `askCommitCustom`.
- */
 export declare function askKey(spec: AskSpec, state: AskRuntime, key: string): AskStep;
 /** The typed answer commits: it becomes THE answer for this question
  *  (clearing its picks) and the walk advances. An empty line is a

package/dist/ask-panel.js

@@ -103,6 +103,10 @@ function toggle(state, option, multi) {
  * the buffer exactly as it does for the rule-input phase, and hands the
  * committed line to `askCommitCustom`.
  */
+/** REL-0152-D3 — the index of the type-your-own row: one past the last
+ *  option, which is where `askBlockRows` draws it. Options and this row
+ *  are one list to the eye, so they are one list to the cursor. */
+const customRow = (q) => q.options.length;
 export function askKey(spec, state, key) {
     const q = spec.questions[state.qIndex];
     const multi = q.multiSelect === true;
@@ -121,17 +125,29 @@ export function askKey(spec, state, key) {
         return { state: state.qIndex === 0 ? state : { ...state, qIndex: state.qIndex - 1, cursor: 0 } };
     if (key === "up")
         return { state: { ...state, cursor: Math.max(0, state.cursor - 1) } };
+    // REL-0152-D3: the cursor range includes the type-your-own row, which
+    // askBlockRows renders as the list's last item. It used to stop one
+    // short, so a row the eye counts as fourth could not be reached by
+    // the key that walks the list — the affordance promised a list and
+    // delivered four of its five rows.
     if (key === "down")
-        return { state: { ...state, cursor: Math.min(q.options.length - 1, state.cursor + 1) } };
-    if (key === "enter")
+        return { state: { ...state, cursor: Math.min(customRow(q), state.cursor + 1) } };
+    if (key === "enter") {
+        // on the custom row, enter is the way in — the same gesture the
+        // row's neighbours answer with.
+        if (state.cursor === customRow(q))
+            return { state: { ...state, phase: "custom" } };
         return answered(state, state.qIndex) ? advance(spec, state) : { state };
+    }
     // SPACE selects at the cursor and NEVER commits — in either mode. It
     // used to answer-and-advance a single-select question, which made a
     // stray space (the most pressable key there is) an instant answer of
     // whatever the cursor happened to be on. Enter and the digits are the
     // only gestures that commit; space is how you point at something.
+    // space points at an option; on the custom row it opens the typing
+    // phase rather than toggling an option that is not there.
     if (key === "space")
-        return { state: toggle(state, state.cursor, multi) };
+        return state.cursor === customRow(q) ? { state: { ...state, phase: "custom" } } : { state: toggle(state, state.cursor, multi) };
     const digit = Number.parseInt(key, 10);
     if (Number.isInteger(digit) && digit >= 1 && digit <= q.options.length) {
         const next = toggle(state, digit - 1, multi);
@@ -181,10 +197,14 @@ export function askBlockRows(view, state, W, maxRows) {
     rows.push(cutLine(`${p.dim}─ ${multi ? "pick any — space toggles" : "pick one"} ─${p.reset}`, Math.max(1, W - 2)));
     const picks = state.picks[state.qIndex] ?? [];
     const body = q.options.map((o, i) => `${gutter}${optionRow(o, i + 1, picks.includes(i), state.cursor === i, multi, W)}`);
+    // REL-0152-D3: the row is part of the list, so it carries the same
+    // cursor affordance the options do. Dim-always made a reachable row
+    // look like a footnote.
     const typed = state.custom[state.qIndex];
+    const onCustom = state.cursor === customRow(q);
     body.push(`${gutter}${cutLine(typed === null || typed === undefined
-        ? `${p.dim} t   type your own answer${p.reset}`
-        : ` t ◉ ${escapeTerminal(typed)}`, Math.max(1, W - 2))}`);
+        ? `${onCustom ? p.bold : p.dim} t   type your own answer${p.reset}`
+        : `${onCustom ? p.bold : ""} t ◉ ${escapeTerminal(typed)}${p.reset}`, Math.max(1, W - 2))}`);
     // the bounded block: the options fold nothing and cut individually,
     // so the cap drops whole rows with the W21 notice row.
     const budget = Math.max(1, maxRows - 5);
@@ -222,7 +242,10 @@ export function askStatus(view, state) {
 /** The input row's lead: the digit lead while picking, the typing lead
  *  in the custom phase (the rule-input phase's shape, reused). */
 export function askLeadPlain(state) {
-    return state.phase === "custom" ? "your answer: " : "1-4> ";
+    // REL-0152-D3: "1-4> " was hard-coded and wrong twice over — it named
+    // a range even when there were two options, and it excluded the
+    // type-your-own row the list shows.
+    return state.phase === "custom" ? "your answer: " : "pick> ";
 }
 // ── the dispatchers: the panel slot, with the ask branch folded in ────
 export function panelBlockRows(view, phase, cursor, W, maxRows, ask, pick, note, safer) {

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@vincemakes/kiso-tui",
-	"version": "0.15.2",
+	"version": "0.15.3",
 	"description": "kiso tui \u2014 the pure terminal layer (cell renderer, dock, raw editor, diff, palette). Zero runtime dependencies: input is data, output is bytes.",
 	"type": "module",
 	"license": "MIT",
@@ -35,6 +35,6 @@
 	},
 	"homepage": "https://github.com/vincemakes/kiso/tree/main/packages/tui#readme",
 	"dependencies": {
-		"@vincemakes/kiso-tui-cells": "0.15.2"
+		"@vincemakes/kiso-tui-cells": "0.15.3"
 	}
 }

package/dist/body.d.ts

@@ -1,151 +0,0 @@
-/**
- * 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;
-    diff: import("./diff.js").DiffLine[] | null;
-    added: number;
-    removed: number;
-    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;
-} | {
-    kind: "checklist";
-    header: string;
-    items: {
-        text: string;
-        status: "pending" | "active" | "done";
-    }[];
-    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;
-    /**
-     * #17 (P1): a resize reflows the terminal's buffer — the old chrome
-     * rows SURVIVE the reflow at their shifted positions (the recorded
-     * separator wall + the tail ghost — the #16a assumption that the
-     * reflow erases them was wrong). The handler: (1) clear the old tail +
-     * dock area with the OLD geometry (one ED from the last-drawn tail
-     * top; EL/ED only, zero LF — the #16 storm gate's invariants hold);
-     * (2) redraw immediately at the NEW geometry (the tail, the cursor
-     * home, the dock — via the normal render). The frozen content is
-     * strictly ABOVE the old tail top — the clear never touches it (the
-     * frozen bytes stay emitted exactly once). Consecutive resizes are
-     * idempotent: the clear covers an already-clear area.
-     */
-    onResize(): 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, diff: import("./diff.js").DiffResult | null): 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;
-    /** ⑥ todo round: the durable checklist — header + one brick-glyph line
-     *  per item, frozen immediately (it is static content). The CLI
-     *  translates a tagged tool result into the structured items; the
-     *  passthrough writes the same lines (byte-identical in pipes). */
-    checklist(header: string, items: {
-        text: string;
-        status: "pending" | "active" | "done";
-    }[]): 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

@@ -1,606 +0,0 @@
-/**
- * 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 { truncateDiff } from "./diff.js";
-import { displayWidth } from "./editor.js";
-import { colorInlineCode, escapeTerminal, foldResult, foldThinking, palette, renderTerminalGap, renderToolSummary, } from "./render.js";
-/** 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
-export class Body {
-    #active;
-    #opts;
-    #cells = [];
-    #nextFrozen = 0; // index of the first not-yet-printed cell
-    #height = 0; // the last DRAWN height — the resize handler clears with the OLD geometry
-    #oldTailTop = 0; // the last-drawn tail top — the clear pass + the resize handler's clear
-    #oldTailHeight = 0; // the last-drawn tail's height — the clear covers EXACTLY it (never the frozen area)
-    #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;
-    #resizeHandler = null;
-    constructor(opts) {
-        this.#opts = opts;
-        this.#write = opts.write ?? ((s) => process.stdout.write(s));
-        this.#active = opts.active();
-        this.#height = opts.height();
-        if (this.#isActive()) {
-            // #17 (P1): the resize handler — clear the OLD tail + dock area
-            // (old geometry, EL/ED only — no LF), then redraw at the new
-            // geometry. The #16a assumption is retired: the terminal's
-            // reflow does NOT erase the old chrome rows (the recorded
-            // separator wall + the tail ghost prove it) — the clear does.
-            this.#resizeHandler = () => this.onResize();
-            process.stdout.on("resize", this.#resizeHandler);
-            this.#heartbeat = setInterval(() => {
-                // #14/#15: the idle heartbeat PAINTS NOTHING unless an
-                // ANIMATION advances — only a RUNNING tool's glyph/elapsed
-                // changes between beats. The #14 fix skipped an all-frozen
-                // body; #15 widened the skip to ANY no-change body: a cell
-                // that stays unfinished without animating (an unclosed text
-                // or thinking block) would otherwise re-paint the tail AND
-                // the dock every 200ms with zero change — the short-session
-                // leak (measured: 51KB / 46 beats after the recap, LF=0).
-                if (!this.#cells.some((c) => c.kind === "tool" && c.state === "running"))
-                    return;
-                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.#resizeHandler !== null) {
-            process.stdout.off("resize", this.#resizeHandler);
-            this.#resizeHandler = null;
-        }
-        if (this.#dirty)
-            this.render();
-    }
-    /**
-     * #17 (P1): a resize reflows the terminal's buffer — the old chrome
-     * rows SURVIVE the reflow at their shifted positions (the recorded
-     * separator wall + the tail ghost — the #16a assumption that the
-     * reflow erases them was wrong). The handler: (1) clear the old tail +
-     * dock area with the OLD geometry (one ED from the last-drawn tail
-     * top; EL/ED only, zero LF — the #16 storm gate's invariants hold);
-     * (2) redraw immediately at the NEW geometry (the tail, the cursor
-     * home, the dock — via the normal render). The frozen content is
-     * strictly ABOVE the old tail top — the clear never touches it (the
-     * frozen bytes stay emitted exactly once). Consecutive resizes are
-     * idempotent: the clear covers an already-clear area.
-     */
-    onResize() {
-        if (!this.#isActive())
-            return;
-        const from = this.#oldTailTop > 0 ? this.#oldTailTop : Math.max(1, this.#height - 3);
-        const H = this.#opts.height(); // the NEW height — the clamp for a shrunk screen
-        const out = [];
-        // The cursor home + the ED land with the NEW geometry — rows beyond
-        // the old screen are already gone; rows below the old tail top are
-        // exactly the tail + the dock areas (the old tail, the old chrome).
-        out.push(`\x1b[${Math.min(from, Math.max(1, H))};1H\x1b[0J`);
-        this.#write(out.join(""));
-        this.#dirty = true; // the immediate redraw at the NEW geometry
-        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();
-            this.#closeOpenText();
-            const p = palette();
-            this.#write(`${p.bold}you> ${escapeTerminal(text)}${p.reset}\n`);
-            return;
-        }
-        this.#closeOpenThinking();
-        this.#closeOpenText();
-        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();
-            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: "", diff: null, added: 0, removed: 0, startedAt: null, doneAt: null, done: false });
-        this.#mark();
-    }
-    toolApproval(callId, diff) {
-        if (!this.#isActive())
-            return;
-        const cell = this.#toolCell(callId);
-        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) {
-        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();
-            this.#closeOpenText();
-            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.#closeOpenText();
-            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();
-            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();
-    }
-    /** ⑥ todo round: the durable checklist — header + one brick-glyph line
-     *  per item, frozen immediately (it is static content). The CLI
-     *  translates a tagged tool result into the structured items; the
-     *  passthrough writes the same lines (byte-identical in pipes). */
-    checklist(header, items) {
-        const glyphOf = (status) => (status === "pending" ? "□" : status === "active" ? "▖" : "▣");
-        if (!this.#isActive()) {
-            this.#closeOpenThinking();
-            this.#closeOpenText();
-            const p = palette();
-            process.stdout.write(`${p.bold}▞${p.reset} ${escapeTerminal(header)}\n`);
-            for (const item of items)
-                process.stdout.write(`  ${glyphOf(item.status)} ${escapeTerminal(item.text)}\n`);
-            return;
-        }
-        this.#closeOpenThinking();
-        this.#closeOpenText();
-        this.#cells.push({ kind: "checklist", header, items, 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();
-            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();
-    }
-    // ---- 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();
-        if (H < 4)
-            return;
-        this.#height = H;
-        const out = [];
-        // #13 (P1), v2d-B: NO DECSTBM — a frozen line scrolls with a REAL
-        // LF at the screen's last row (\x1b[H;1H\n — the top line leaves
-        // into the NATIVE scrollback) and lands at the body's bottom row,
-        // just above the active tail. The dock is redrawn after.
-        // #17 (P1): the pre-fill phase is GONE — EVERY frozen line takes
-        // this REAL-LF path, short sessions included. The old pre-fill drew
-        // at absolute CUP rows with NO real LF: the terminal's resize
-        // reflow treated those rows as soft lines — the recorded fold/body
-        // MERGE (the /think suffix lost), the tail ghost, the separator
-        // wall. A real-LF line reflows as ONE logical line, never merged
-        // with a neighbor; the only soft lines left are the active tail +
-        // the dock (small, redrawn every frame / cleared by onResize).
-        // 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;
-        // #17: the tail holds ONLY the unfinished cells — slice(nextFrozen)
-        // also captures the DONE cells that follow (an approval verdict
-        // freezing behind a live text+tool), inflating tailHeight so the
-        // tail's top rises INTO the frozen area and its clear pass wipes
-        // the freshly-frozen lines (the fold's /think suffix — recorded).
-        const tail = this.#cells.slice(nextFrozen);
-        // #17: the tail HEIGHT counts only the unfinished cells — slice()
-        // also captures the DONE cells that follow (an approval verdict
-        // freezing behind a live text+tool); counting them inflates the
-        // height so the tail's top rises INTO the frozen area and its
-        // clear pass wipes the freshly-frozen lines (the fold's /think
-        // suffix — recorded). The tail array itself keeps the old shape.
-        const tailHeight = tail.reduce((n, c) => n + (c.done ? 0 : 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)) {
-                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 EXACTLY its old area (shifted up by the
-        // freeze scrolls) and the current area, draw the cells at the body's
-        // bottom. #17: the old code cleared clearFrom..H-4 unconditionally —
-        // harmless when the frozen lines sat at the TOP (pre-fill), but with
-        // the real-LF commits the frozen lines land just ABOVE the tail, so
-        // an over-wide clear wipes the freshly-frozen cells (the recorded
-        // fold/response vanishing).
-        out.push("\x1b[?2026h");
-        const oldBottom = this.#oldTailHeight > 0 ? this.#oldTailTop + this.#oldTailHeight - 1 - scrolled : -1;
-        const newBottom = tailHeight > 0 ? tailTop + tailHeight - 1 : -1;
-        const clearFrom = Math.min(this.#oldTailTop === 0 ? tailTop : this.#oldTailTop - scrolled, tailTop);
-        const clearTo = Math.max(oldBottom, newBottom);
-        for (let row = clearFrom; row <= Math.min(clearTo, H - 4); 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; // the last-drawn tail top — the resize clear starts here
-        this.#oldTailHeight = tailHeight;
-        // 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":
-                // v3 §02, TUI v5 #16f (v4.1 design): the user message is a left
-                // rail — a bright-white BOLD ▍ per line, then the text (the
-                // reverse-video block is RETIRED: it washed out on light
-                // themes). Multi-line whole: every line carries the rail
-                // (coherent across lines); resize-safe; NO_COLOR → the rail renders plain.
-                return cell.text.split("\n").map((l) => `${p.bold}▍${p.reset} ${escapeTerminal(l)}`);
-            case "thinking": {
-                const block = cell.text;
-                const trimmed = escapeTerminal(block.trim());
-                if (trimmed.length <= 100)
-                    return [`${p.dim}…${trimmed}${p.reset}`];
-                const suffix = ` (${block.length} chars · /think)`;
-                // #17: the fold must FIT its row — every frozen line commits
-                // via the REAL-LF scroll path at the SAME write row; a
-                // soft-wrapped fold's continuation row would be clobbered by
-                // the next line's commit write (the /think suffix lost — the
-                // recorded symptom). The slice shrinks with the width; the
-                // suffix always rides the fold's own row.
-                const slice = Math.max(1, W - 1 - suffix.length);
-                return [`${p.dim}…${trimmed.slice(0, slice)}${suffix}${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}`];
-                    }
-                    const delta = cell.added + cell.removed > 0 ? `, +${cell.added} -${cell.removed}` : "";
-                    return [`${p.bold}✓ ${name}${p.reset} (${summary}${delta}, ${elapsed}s)`];
-                }
-                if (cell.state === "approval") {
-                    const lines = [`→ ${name} ${summary} ${p.bold}⏸${p.reset}`];
-                    // v2e: the mini-diff — ▎ bold 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.bold}▎${p.reset}${body}`);
-                        }
-                    }
-                    return lines;
-                }
-                if (cell.state === "running") {
-                    const elapsed = cell.startedAt !== null ? Math.max(1, Math.round((Date.now() - cell.startedAt) / 1000)) : 1;
-                    return [`→ ${name} ${summary} ${p.bold}${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);
-                // TUI v5 #16e: the inline-code tint — backtick spans in
-                // assistant body text, matched PER LINE after the wrap (a
-                // span opened on one line and closed on another does NOT
-                // match — no cross-line matching). NO_COLOR → the codes are empty →
-                // byte-identical.
-                return wrapped.length > 0 ? wrapped.map((l) => colorInlineCode(l)) : [""];
-            }
-            case "notice":
-                return [escapeTerminal(cell.text)];
-            case "raw":
-                // TUI v4 #16b: the raw cell carries the CLI's OWN pre-rendered
-                // lines (the banner, the recap, slash-command output) — the
-                // SGR is applied at COMPOSITION time (renderRecap/startupBanner),
-                // and model/tool content was already escapeTerminal'd there.
-                // Re-escaping at render STRIPPED the ESC from the SGR — the
-                // literal "[38;5;75m▞[0m" garbage the user saw (the #16 mojibake,
-                // also the banner's dim). Verbatim: the injection guard lives
-                // at composition, not here.
-                return cell.lines;
-            case "terminal":
-                // the honest label (done / aborted / error) + the status + the
-                // rhythm gap blank
-                return [cell.label, cell.line, ""];
-            case "checklist": {
-                // ⑥: the durable checklist — the ▞ header accent + one brick
-                // glyph per item (□ pending / ▖ active / ▣ done). Text is
-                // escaped at composition; the glyphs are renderer-owned.
-                const lines = [`${p.bold}▞${p.reset} ${escapeTerminal(cell.header)}`];
-                for (const item of cell.items) {
-                    const glyph = item.status === "pending" ? "□" : item.status === "active" ? "▖" : "▣";
-                    lines.push(`  ${glyph} ${escapeTerminal(item.text)}`);
-                }
-                return lines;
-            }
-        }
-    }
-    #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 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() {
-        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

@@ -1,76 +0,0 @@
-/**
- * v2b/v2c — the bottom-anchored UI (TTY + color only). Borrows pi-tui's
- * IDEA — a DECSTBM scroll region with a reserved bottom — without its
- * implementation: zero dependencies, line-level ANSI, no differential
- * renderer.
- *
- * 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
- * byte-for-byte (the existing e2e assertions guard it).
- */
-export declare class Dock {
-    #private;
-    /** v2b: docked only on a color TTY — pipes and NO_COLOR stay v2a. */
-    get active(): boolean;
-    /** Bind the CURRENT input line's state — called when a readline takes
-     *  over (the chat REPL, the trust question's short-lived rl, resume). */
-    bindInput(state: () => {
-        line: string;
-        cursor: number;
-    }, prompt: string): void;
-    /** 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;
-    /** Teardown — CSI r resets the scroll region, the cursor lands at the
-     *  input line, the bottom rows are cleared: no broken terminal. Called
-     *  from main's finally on EVERY exit path (kill -9 excepted — README:
-     *  `reset` saves it). */
-    exit(): void;
-    /** SIGWINCH: recompute the size, redraw the chrome. */
-    onResize(): 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
-     *  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". */
-    setTail(tail: string): void;
-    /** Show a takeover question at the status position (answered at the
-     *  input line by the caller's readline); clearQuestion() restores. */
-    showQuestion(question: string): void;
-    clearQuestion(): void;
-    /** 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. v3 §03: the upper ╌ row, the input row, the lower
-     *  ╌ row, the status row — the status is dim (bold accents inside
-     *  come from the CLI's composition). TUI v5 #16g: the idle status
-     *  row carries the right-aligned "/ commands · ↑ history" hint. */
-    redraw(): void;
-}

package/dist/dock.js

@@ -1,199 +0,0 @@
-/**
- * v2b/v2c — the bottom-anchored UI (TTY + color only). Borrows pi-tui's
- * IDEA — a DECSTBM scroll region with a reserved bottom — without its
- * implementation: zero dependencies, line-level ANSI, no differential
- * renderer.
- *
- * 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
- * byte-for-byte (the existing e2e assertions guard it).
- */
-import { displayWidth } from "./editor.js";
-import { palette } from "./render.js";
-export class Dock {
-    #active = false;
-    #height = 0;
-    #width = 0;
-    #status = "";
-    #tail = ""; // the live tail: the spinner glyph or "running <tool> Ns"
-    #question = null; // a takeover question shown at H-1
-    #inputState = () => ({ line: "", cursor: 0 });
-    #inputPrompt = "";
-    #bodyRow = 1; // the body's logical row inside the scroll region
-    #bodyCol = 1; // …and column (mid-line continuations survive cursor jumps)
-    #resizeHandler = null;
-    /** v2b: docked only on a color TTY — pipes and NO_COLOR stay v2a. */
-    get active() {
-        return this.#active;
-    }
-    /** Bind the CURRENT input line's state — called when a readline takes
-     *  over (the chat REPL, the trust question's short-lived rl, resume). */
-    bindInput(state, prompt) {
-        this.#inputState = state;
-        this.#inputPrompt = prompt;
-    }
-    /** 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() {
-        const rows = process.stdout.rows ?? 0;
-        if (process.stdout.isTTY !== true || palette().bold === "" || rows < 4)
-            return;
-        this.#active = true;
-        this.#height = rows;
-        this.#width = process.stdout.columns ?? 80;
-        this.#bodyRow = 1;
-        this.#bodyCol = 1;
-        this.redraw();
-        this.#resizeHandler = () => this.onResize();
-        process.stdout.on("resize", this.#resizeHandler);
-    }
-    /** Teardown — CSI r resets the scroll region, the cursor lands at the
-     *  input line, the bottom rows are cleared: no broken terminal. Called
-     *  from main's finally on EVERY exit path (kill -9 excepted — README:
-     *  `reset` saves it). */
-    exit() {
-        if (!this.#active)
-            return;
-        this.#active = false;
-        if (this.#resizeHandler !== null) {
-            process.stdout.off("resize", this.#resizeHandler);
-            this.#resizeHandler = null;
-        }
-        const H = this.#height;
-        process.stdout.write("\x1b[r"); // reset the scroll region
-        for (let row = H - 3; row <= H; row += 1) {
-            process.stdout.write(`\x1b[${row};1H\x1b[0K`); // clear the four rows
-        }
-        process.stdout.write(`\x1b[${H};1H`);
-    }
-    /** SIGWINCH: recompute the size, redraw the chrome. */
-    onResize() {
-        if (!this.#active)
-            return;
-        this.#height = process.stdout.rows ?? this.#height;
-        this.#width = process.stdout.columns ?? this.#width;
-        this.redraw();
-    }
-    #menuState = null;
-    /** 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) {
-        this.#menuState = state;
-    }
-    /** 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() {
-        return this.#inputCol();
-    }
-    #inputCol() {
-        const inp = this.#inputState();
-        const promptWidth = displayWidth(this.#inputPrompt.replace(/\x1b\[[0-9;]*m/g, ""));
-        return promptWidth + inp.cursor + 1;
-    }
-    /** The status bar's base text (usage, ctx, session, …). */
-    setStatus(text) {
-        this.#status = text;
-        this.redraw();
-    }
-    /** The live tail — the spinner glyph or "running <tool> Ns". */
-    setTail(tail) {
-        this.#tail = tail;
-        this.redraw();
-    }
-    /** Show a takeover question at the status position (answered at the
-     *  input line by the caller's readline); clearQuestion() restores. */
-    showQuestion(question) {
-        this.#question = question;
-        this.redraw();
-    }
-    clearQuestion() {
-        this.#question = null;
-        this.redraw();
-    }
-    /** 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. v3 §03: the upper ╌ row, the input row, the lower
-     *  ╌ row, the status row — the status is dim (bold accents inside
-     *  come from the CLI's composition). TUI v5 #16g: the idle status
-     *  row carries the right-aligned "/ commands · ↑ history" hint. */
-    redraw() {
-        if (!this.#active)
-            return;
-        const p = palette();
-        // #17 (P1): read the LIVE size, not the cache — the body's resize
-        // render calls onDock (this redraw) BEFORE this dock's own resize
-        // handler runs, so the cached geometry would draw the chrome at
-        // stale rows (clamped into the body — the separator residue wall).
-        // The live read makes the handler order irrelevant; the cache keeps
-        // serving exit().
-        const H = process.stdout.rows ?? this.#height;
-        const W = process.stdout.columns ?? this.#width;
-        const sep = `${p.dim}${"╌".repeat(W)}${p.reset}`;
-        const status = `${this.#status}${this.#tail === "" ? "" : ` · ${this.#tail}`}`;
-        const statusLine = this.#question ?? this.#statusRow(status, p, W);
-        const inp = this.#inputState();
-        const out = [];
-        // P3 (review): the DEC private-mode SET/RESET needs the "?" prefix —
-        // \x1b[?2026h/l, the pi source's exact form. Without it terminals
-        // silently ignore the mode and the anti-flicker never engages.
-        out.push("\x1b[?2026h"); // synchronized output ON (DEC 2026)
-        // v3 §04: the slash-command menu — above the chrome, one row per
-        // filtered command, the selection highlighted. Drawn first so the
-        // chrome rows repaint on top of any overlap.
-        const menu = this.#menuState?.();
-        if (menu !== null && menu !== undefined) {
-            for (let i = 0; i < menu.items.length; i += 1) {
-                const item = menu.items[i];
-                const row = H - 4 - (menu.items.length - 1 - i);
-                const text = i === menu.selected
-                    ? `${p.bold}▸ ${item.name}${p.reset} ${item.desc}`
-                    : `${p.dim}  ${item.name} ${item.desc}${p.reset}`;
-                out.push(`\x1b[${row};1H\x1b[0K${text}`);
-            }
-        }
-        out.push(`\x1b[${H - 3};1H\x1b[0K${sep}`);
-        out.push(`\x1b[${H - 2};1H\x1b[0K${this.#inputPrompt}${inp.line}`);
-        out.push(`\x1b[${H - 1};1H\x1b[0K${sep}`);
-        out.push(`\x1b[${H};1H\x1b[0K${statusLine}`);
-        out.push(`\x1b[${H - 2};${this.#inputCol()}H`); // back to the edit position
-        out.push("\x1b[?2026l"); // synchronized output OFF
-        process.stdout.write(out.join(""));
-    }
-    /** TUI v5 #16g: the status row — the base status left-aligned, the
-     *  "/ commands · ↑ history" hint right-aligned in the idle state
-     *  (tail empty, no takeover question). The hint is CUT FIRST when
-     *  the width is short — the status itself is never truncated for it;
-     *  the running state carries its own esc hint in the status text, so
-     *  the non-empty tail suppresses this one. */
-    #statusRow(status, p, W) {
-        const hint = this.#tail === "" && this.#question === null ? " / commands · ↑ history" : "";
-        if (hint === "")
-            return `${p.dim}${status}${p.reset}`;
-        const statusW = displayWidth(status.replace(/\x1b\[[0-9;]*m/g, ""));
-        const hintW = displayWidth(hint);
-        if (statusW + hintW > W)
-            return `${p.dim}${status}${p.reset}`;
-        return `${p.dim}${status}${" ".repeat(W - statusW - hintW)}${hint}${p.reset}`;
-    }
-}