@vincemakes/kiso-tui 0.1.28 → 0.1.30

package/dist/body.d.ts

@@ -62,6 +62,14 @@ export type BodyCell = {
     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
@@ -85,12 +93,17 @@ export declare class Body {
     /** Teardown — flush a pending frame, stop the timers. */
     close(): void;
     /**
-     * TUI v4 #16a: a resize reflows the terminal's scrollback — the frozen
-     * rows' positions are no longer what we tracked (and the frozen CONTENT
-     * is never re-emitted: the terminal reflowed it, we only redraw the
-     * dock + active tail). The counters reset so the next render writes new
-     * frozen lines through the REAL-LF scroll path above the tail, never at
-     * a stale CUP row (the drag-garbage the #16 user saw).
+     * #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. */
@@ -121,6 +134,14 @@ export declare class Body {
     /** 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;

package/dist/body.js

@@ -36,8 +36,9 @@ export class Body {
     #opts;
     #cells = [];
     #nextFrozen = 0; // index of the first not-yet-printed cell
-    #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
+    #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;
@@ -53,14 +54,13 @@ export class Body {
         this.#opts = opts;
         this.#write = opts.write ?? ((s) => process.stdout.write(s));
         this.#active = opts.active();
+        this.#height = opts.height();
         if (this.#isActive()) {
-            // TUI v4 #16a: the resize event — the terminal reflows its
-            // scrollback, so OUR row bookkeeping is stale. The frozen
-            // content is never re-emitted (the terminal reflowed it); the
-            // counters reset so the next render lands new frozen lines via
-            // the REAL-LF scroll path (just above the tail), never at stale
-            // CUP rows — the overwrite garbage after a drag (the #16
-            // defect). The dock redraws its own chrome on the same event.
+            // #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(() => {
@@ -104,23 +104,31 @@ export class Body {
             this.render();
     }
     /**
-     * TUI v4 #16a: a resize reflows the terminal's scrollback — the frozen
-     * rows' positions are no longer what we tracked (and the frozen CONTENT
-     * is never re-emitted: the terminal reflowed it, we only redraw the
-     * dock + active tail). The counters reset so the next render writes new
-     * frozen lines through the REAL-LF scroll path above the tail, never at
-     * a stale CUP row (the drag-garbage the #16 user saw).
+     * #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;
-        this.#frozenRows = Number.MAX_SAFE_INTEGER; // the frozen area is "full" — the next line scrolls
-        this.#oldTailTop = 0; // the reflowed tail's old rows are gone — clear only the new area
-        // NO #dirty: an immediate frame would re-render the ACTIVE TAIL —
-        // re-emitting its bytes (the terminal already reflowed the tail's
-        // content; a re-print duplicates the text in the byte stream — the
-        // #16 storm gate's "response text exactly once"). The geometry
-        // reset takes effect at the next NATURAL render (the next event).
+        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() {
@@ -301,6 +309,26 @@ export class Body {
         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) {
@@ -344,45 +372,63 @@ export class Body {
         const W = this.#opts.width();
         if (H < 4)
             return;
+        this.#height = H;
         const out = [];
-        // #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.
+        // #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);
-        const tailHeight = tail.reduce((n, c) => n + this.#cellHeight(c, W), 0);
+        // #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)) {
-                if (this.#frozenRows < writeRow) {
-                    this.#frozenRows += 1;
-                    out.push(`\x1b[${this.#frozenRows};1H\x1b[0K${line}`);
-                }
-                else {
-                    out.push(`\x1b[${H};1H\n`); // the REAL LF — the whole screen scrolls
-                    out.push(`\x1b[${writeRow};1H\x1b[0K${line}`);
-                    scrolled += 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 (shifted up by the freeze
-        // scrolls) and the current area, draw the cells at the body's bottom.
+        // 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);
-        for (let row = clearFrom; row <= H - 4; row += 1) {
+        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;
@@ -392,6 +438,8 @@ export class Body {
                 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");
@@ -409,14 +457,22 @@ export class Body {
                 // 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
-                // (多行连贯); resize-safe; NO_COLOR → the rail renders plain.
+                // (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}`];
-                return [`${p.dim}…${trimmed.slice(0, 100)} (${block.length} chars · /think)${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);
@@ -458,7 +514,7 @@ export class Body {
                 // 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_COLOR → the codes are empty →
+                // match — no cross-line matching). NO_COLOR → the codes are empty →
                 // byte-identical.
                 return wrapped.length > 0 ? wrapped.map((l) => colorInlineCode(l)) : [""];
             }
@@ -470,7 +526,7 @@ export class Body {
                 // 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 乱码,
+                // 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;
@@ -478,6 +534,17 @@ export class Body {
                 // 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) {

package/dist/dock.js

@@ -141,14 +141,20 @@ export class Dock {
         if (!this.#active)
             return;
         const p = palette();
-        const H = this.#height;
-        const W = this.#width;
+        // #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 (审查): the DEC private-mode SET/RESET needs the "?" prefix —
+        // 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)

package/dist/editor.js

@@ -102,7 +102,7 @@ export class Editor {
     #onRender;
     #menuOpen = false; // v3 §04: the slash-command menu
     #menuSel = 0;
-    // A2 (手感): the session-scoped input history — every submitted TURN
+    // A2 (the feel): the session-scoped input history — every submitted TURN
     // line (never a question answer), capped at 100, never persisted. ↑↓
     // navigate it ONLY from an empty input or while already browsing.
     #history = [];
@@ -337,7 +337,7 @@ export class Editor {
         }
         else if (final === "A" || final === "B") {
             // v3 §04: the menu owns ↑↓ while open (the selection, never the
-            // cursor). A2 (手感): otherwise ↑↓ navigate the session history
+            // cursor). A2 (the feel): otherwise ↑↓ navigate the session history
             // — ONLY from an empty input or while already browsing; mid-edit
             // the cursor semantics are unchanged (↑↓ do nothing).
             if (this.#menuOpen) {
@@ -427,7 +427,7 @@ export class Editor {
     #submit() {
         let line = String.fromCodePoint(...this.#chars);
         if (this.#menuOpen) {
-            // A1 (手感): Enter submits the EXACT selection directly; a
+            // A1 (the feel): Enter submits the EXACT selection directly; a
             // PARTIAL selection COMPLETES the buffer (the Tab semantics)
             // without submitting — the user reviews and presses Enter
             // again. The old behavior executed the completed command on

package/dist/render.d.ts

@@ -3,7 +3,7 @@
  * input, produce the lines a human sees. Colors are raw ANSI — no
  * dependencies.
  *
- * 手感批 C5: the input is the tui's OWN data shape (RenderInput), never
+ * the ergonomics batch C5: the input is the tui's OWN data shape (RenderInput), never
  * kiso-core's Event — the CLI translates Event → RenderInput. The tui
  * package has ZERO kiso-core imports: input is data, output is bytes.
  */
@@ -31,7 +31,7 @@ export declare const COLOR_ON: Palette;
 export declare const COLOR_OFF: Palette;
 export declare function palette(): Palette;
 /**
- * E 组/八: strip terminal-injection vectors from MODEL/TOOL text before it
+ * E group/round 8: strip terminal-injection vectors from MODEL/TOOL text before it
  * reaches the terminal — ESC, C0 (except \t \n), C1, CR, backspace, and
  * bidi overrides. The kiso colors are applied by render, not by the data.
  * EVERY externally-sourced string must pass through this before any output.
@@ -56,7 +56,7 @@ export interface RenderResult {
     readonly prompt: boolean;
 }
 /**
- * 手感批 C5 — the render input, the tui's OWN data shape: the subset of
+ * the ergonomics batch C5 — the render input, the tui's OWN data shape: the subset of
  * an event stream the renderer reads, keyed by type. The CLI translates
  * its Event stream into this (Event → RenderInput) before rendering —
  * the tui package never imports kiso-core. Field names mirror the
@@ -137,12 +137,19 @@ export type RenderInput = {
     readonly name: string;
     readonly executionId: string;
     readonly error: string;
+} | {
+    readonly type: "checklist";
+    readonly header: string;
+    readonly items: readonly {
+        readonly text: string;
+        readonly status: "pending" | "active" | "done";
+    }[];
 };
 /**
  * Render one event. `text` may be a continuation (text_delta appends to the
  * current line); `newline` says whether the line is complete.
  *
- * 自举 P1: `prevThinking` marks a thinking delta that continues the SAME
+ * bootstrap P1: `prevThinking` marks a thinking delta that continues the SAME
  * block — it renders appended to the segment, without the … prefix. The
  * consumer closes the segment with a newline at the next non-thinking
  * event.
@@ -159,7 +166,7 @@ export declare function foldThinking(block: string): string;
 export declare function foldResult(content: string): string;
 export declare function renderEvent(ev: RenderInput, prevThinking?: boolean, resolvePath?: PathResolver): RenderResult;
 /**
- * B 区: one-line summary of a completed tool call, e.g.
+ * B area: one-line summary of a completed tool call, e.g.
  *   ✓ edit src/foo.ts (+12 -3)    ✓ read src/bar.ts (140 lines)
  *   ✗ shell npm test (exit 1)
  * edit/write show +/- line counts, read shows lines, shell shows the exit
@@ -171,7 +178,7 @@ export declare function renderToolSummary(name: string, input: Record<string, un
 }): string;
 /** k-units for the status line: 12345 → 12.3k, 800 → 800, null → ?. */
 export declare function kUnit(value: number | null): string;
-/** B 区: usage data gathered from the run's usage events. */
+/** B area: usage data gathered from the run's usage events. */
 export interface RunUsage {
     readonly in: number | null;
     readonly out: number | null;
@@ -179,9 +186,9 @@ export interface RunUsage {
     readonly known: boolean;
 }
 /**
- * B 区/v2a: the one-line status bar after a terminal, e.g.
+ * B area/v2a: the one-line status bar after a terminal, e.g.
  *   [turn 3 · in 12.4k out 1.8k · cache 9.2k · ctx ~14%]
- * 降噪: unknown fields are OMITTED ENTIRELY (有什么显什么); a fully unknown
+ * Denoising: unknown fields are OMITTED ENTIRELY (show what there is); a fully unknown
  * usage → null (the caller prints nothing); faux mode → [turn N · faux].
  * All data comes from usage events; ctx is the approximate estimate
  * passed in (chars/4 vs the window), marked with ~.
@@ -189,7 +196,7 @@ export interface RunUsage {
 export declare function renderStatusLine(turn: number, usage: RunUsage, ctxRatio: number, faux?: boolean): string | null;
 /**
  * v2a rhythm — the exact bytes after a terminal event: the status line
- * hugs the terminal (有什么显什么 — omitted when there is nothing to show),
+ * hugs the terminal (show what there is — omitted when there is nothing to show),
  * then EXACTLY one blank line before the next prompt. The consumer prints
  * this verbatim; the render tests pin the sequence.
  */

package/dist/render.js

@@ -3,7 +3,7 @@
  * input, produce the lines a human sees. Colors are raw ANSI — no
  * dependencies.
  *
- * 手感批 C5: the input is the tui's OWN data shape (RenderInput), never
+ * the ergonomics batch C5: the input is the tui's OWN data shape (RenderInput), never
  * kiso-core's Event — the CLI translates Event → RenderInput. The tui
  * package has ZERO kiso-core imports: input is data, output is bytes.
  */
@@ -13,7 +13,7 @@ export function palette() {
     return process.env.NO_COLOR === undefined && process.stdout.isTTY ? COLOR_ON : COLOR_OFF;
 }
 /**
- * E 组/八: strip terminal-injection vectors from MODEL/TOOL text before it
+ * E group/round 8: strip terminal-injection vectors from MODEL/TOOL text before it
  * reaches the terminal — ESC, C0 (except \t \n), C1, CR, backspace, and
  * bidi overrides. The kiso colors are applied by render, not by the data.
  * EVERY externally-sourced string must pass through this before any output.
@@ -44,7 +44,7 @@ export function colorInlineCode(line) {
  * Render one event. `text` may be a continuation (text_delta appends to the
  * current line); `newline` says whether the line is complete.
  *
- * 自举 P1: `prevThinking` marks a thinking delta that continues the SAME
+ * bootstrap P1: `prevThinking` marks a thinking delta that continues the SAME
  * block — it renders appended to the segment, without the … prefix. The
  * consumer closes the segment with a newline at the next non-thinking
  * event.
@@ -80,7 +80,7 @@ export function renderEvent(ev, prevThinking = false, resolvePath = (p) => p) {
         case "text_end":
             return { text: "\n", newline: true, prompt: false };
         case "thinking":
-            // 自举 P1/v2b: the CONSUMER buffers each thinking block and folds
+            // bootstrap P1/v2b: the CONSUMER buffers each thinking block and folds
             // it to ONE dim line (foldThinking); this render is the generic
             // path for tests. The full block goes to /think.
             return {
@@ -112,7 +112,7 @@ export function renderEvent(ev, prevThinking = false, resolvePath = (p) => p) {
             };
         }
         case "permission_requested":
-            // 八: the tool NAME is model text — escaped like everything else.
+            // round 8: the tool NAME is model text — escaped like everything else.
             return {
                 text: `⏸ ${escapeTerminal(ev.name)} needs approval ${p.dim}${approvalDetail(ev.name, ev.input, resolvePath)}${p.reset} `,
                 newline: false,
@@ -146,12 +146,23 @@ export function renderEvent(ev, prevThinking = false, resolvePath = (p) => p) {
                 newline: true,
                 prompt: false,
             };
+        case "checklist": {
+            // ⑥: the durable checklist — the ▞ header accent (the recap's
+            // brick) + one brick-glyph line per item. Static line content:
+            // byte-identical in pipes and NO_COLOR.
+            const lines = [`${p.bold}▞${p.reset} ${escapeTerminal(ev.header)}`];
+            for (const item of ev.items) {
+                const glyph = item.status === "pending" ? "□" : item.status === "active" ? "▖" : "▣";
+                lines.push(`  ${glyph} ${escapeTerminal(item.text)}`);
+            }
+            return { text: `${lines.join("\n")}\n`, newline: true, prompt: false };
+        }
         default:
             return { text: "", newline: false, prompt: false };
     }
 }
 /**
- * The approval prompt detail (Area 5/八): the human must be able to see
+ * The approval prompt detail (Area 5/round 8): the human must be able to see
  * EVERYTHING they are approving. The shell command is shown in full; the
  * path is the CANONICAL one the tool will touch; write/edit show the FULL
  * content (never a truncated tail that hides a dangerous payload). The
@@ -171,7 +182,7 @@ function approvalDetail(name, input, resolvePath) {
     return `\n  ${escapeTerminal(JSON.stringify(input))}`;
 }
 /**
- * B 区: one-line summary of a completed tool call, e.g.
+ * B area: one-line summary of a completed tool call, e.g.
  *   ✓ edit src/foo.ts (+12 -3)    ✓ read src/bar.ts (140 lines)
  *   ✗ shell npm test (exit 1)
  * edit/write show +/- line counts, read shows lines, shell shows the exit
@@ -237,9 +248,9 @@ export function kUnit(value) {
     return String(value);
 }
 /**
- * B 区/v2a: the one-line status bar after a terminal, e.g.
+ * B area/v2a: the one-line status bar after a terminal, e.g.
  *   [turn 3 · in 12.4k out 1.8k · cache 9.2k · ctx ~14%]
- * 降噪: unknown fields are OMITTED ENTIRELY (有什么显什么); a fully unknown
+ * Denoising: unknown fields are OMITTED ENTIRELY (show what there is); a fully unknown
  * usage → null (the caller prints nothing); faux mode → [turn N · faux].
  * All data comes from usage events; ctx is the approximate estimate
  * passed in (chars/4 vs the window), marked with ~.
@@ -264,7 +275,7 @@ export function renderStatusLine(turn, usage, ctxRatio, faux = false) {
 }
 /**
  * v2a rhythm — the exact bytes after a terminal event: the status line
- * hugs the terminal (有什么显什么 — omitted when there is nothing to show),
+ * hugs the terminal (show what there is — omitted when there is nothing to show),
  * then EXACTLY one blank line before the next prompt. The consumer prints
  * this verbatim; the render tests pin the sequence.
  */
@@ -334,6 +345,6 @@ export function renderRecap(s) {
 /** One-line summary of a session, for `kiso sessions`. */
 export function renderSessionLine(meta) {
     const when = meta.updatedAt ? new Date(meta.updatedAt).toISOString().slice(0, 16) : "—";
-    // 八: the title is the user's first prompt — model/user text, escaped.
+    // round 8: the title is the user's first prompt — model/user text, escaped.
     return `${meta.id.padEnd(24)} ${meta.runs} runs ${String(meta.events).padStart(5)} events  ${when}  ${escapeTerminal(meta.title)}`;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vincemakes/kiso-tui",
-  "version": "0.1.28",
+  "version": "0.1.30",
   "description": "kiso tui — the pure terminal layer (cell renderer, dock, raw editor, diff, palette). Zero runtime dependencies: input is data, output is bytes.",
   "type": "module",
   "license": "MIT",