@vincemakes/kiso-tui 0.1.36 → 0.1.37

package/dist/compositor.js

@@ -42,8 +42,8 @@
  */
 import { truncateDiff } from "./diff.js";
 import { displayWidth } from "./editor.js";
-import { Container, SPINNER, cellComponent, foldLine, footerLine, statusLine, visibleWidth, } from "./components.js";
-import { escapeTerminal, foldResult, foldThinking, palette, renderTerminalGap, renderToolSummary } from "./render.js";
+import { Container, SPINNER, bodySpacing, cellComponent, foldLine, footerLine, statusLine, visibleWidth, } from "./components.js";
+import { bannerLines, escapeTerminal, foldResult, foldThinking, palette, renderTerminalGap, renderToolSummary } from "./render.js";
 /** The cursor marker — an APC private sequence the focus component
  *  embeds at the edit position; the compositor strips it and moves
  *  relatively (it never reaches the terminal). */
@@ -78,6 +78,7 @@ export class Body {
     #resizeHandler = null;
     // the chrome state (the Dock façade)
     #status = "";
+    #statusHint = null;
     #tail = "";
     #question = null;
     #inputState = () => ({ line: "", cursor: 0 });
@@ -154,8 +155,18 @@ export class Body {
             this.#write(`→ ${escapeTerminal(name)}(${escapeTerminal(JSON.stringify(input).slice(0, 200))})\n`);
             return;
         }
+        // W12: the cell carries the delegate's child roles from the FULL
+        // input — the display summary is sliced at 60 chars (unparseable);
+        // the roles are the only running-state data the parent holds (there
+        // is no live channel to a running child session).
+        const childRoles = [];
+        for (const t of Array.isArray(input.tasks) ? input.tasks : []) {
+            if (typeof t === "object" && t !== null && typeof t.role === "string") {
+                childRoles.push(t.role);
+            }
+        }
         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.#cells.push({ kind: "tool", name, input: summary, childRoles, state: "pending", isError: false, resultText: "", diff: null, added: 0, removed: 0, startedAt: null, doneAt: null, done: false });
         this.#mark();
     }
     toolApproval(callId, diff) {
@@ -286,6 +297,30 @@ export class Body {
         this.#cells.push({ kind: "checklist", header, items, done: true });
         this.#mark();
     }
+    /** The startup banner (W1): a LIVE cell — the tier re-derives per
+     *  frame (bannerLines with the CURRENT W and H), so a resize re-tiers
+     *  the art instead of re-folding frozen rows (a window below 40 cols
+     *  never paints the logo). W5: the resume metas ride the cell — the
+     *  list re-gates with the tier (BIG only) and re-times with the
+     *  frame. The inactive path keeps the historical bytes (no resume —
+     *  the pipe contract). */
+    banner(version, extensionsText, resume = []) {
+        if (!this.#isActive()) {
+            this.#closeOpenThinking();
+            this.#closeOpenText();
+            const W = this.#opts.width() || 80; // a 0-size pty falls back
+            const H = this.#opts.height();
+            const p = palette();
+            for (const r of bannerLines(W, H, version, extensionsText))
+                this.#write(`${p.dim}${r}${p.reset}\n`);
+            this.#write("\n");
+            return;
+        }
+        this.#closeOpenThinking();
+        this.#closeOpenText();
+        this.#cells.push({ kind: "banner", version, extensionsText, resume, done: true });
+        this.#mark();
+    }
     raw(lines) {
         if (!this.#isActive()) {
             this.#closeOpenThinking();
@@ -360,8 +395,12 @@ export class Body {
         this.#dirty = true;
         this.render(); // the immediate redraw at the NEW geometry
     }
-    setStatus(text) {
+    /** W18: the status row's right-aligned hint is part of the status
+     *  state — the compacting row passes "esc to cancel" (the affordance
+     *  must survive repaints). */
+    setStatus(text, hint = null) {
         this.#status = text;
+        this.#statusHint = hint;
         this.redraw();
     }
     setTail(tail) {
@@ -452,19 +491,29 @@ export class Body {
     }
     // ---- the one writer ----
     /** The live region's scalar — the unit tests assert the cap directly
-     *  (the e2e gate pins the screen consequence). */
+     *  (the e2e gate pins the screen consequence). W11: the formula's
+     *  blanks are join artifacts — the count includes them (they are real
+     *  screen rows), threaded against the previous sibling's OWN rows. */
     liveCount() {
         const live = this.#cells.slice(this.#committed);
-        const ctx = { spinnerI: this.#spinnerI, now: Date.now() };
+        const ctx = { spinnerI: this.#spinnerI, now: Date.now(), height: this.#opts.height() };
         const W = this.#opts.width();
         let lines = 0;
-        for (const cell of live)
-            lines += cellComponent(cell).render(W, ctx).length;
+        let prev = this.#committed > 0 ? this.#lineCache[this.#committed - 1] : null;
+        for (const cell of live) {
+            const rows = cellComponent(cell).render(W, ctx);
+            lines += bodySpacing(prev, rows).length;
+            prev = rows;
+        }
         return lines + CHROME_ROWS + this.#menuRows(W).length;
     }
     /** The lines committed THIS frame — the writes land in the frame's
      *  committed section (the rows just above the live region). */
     #committedLinesThisFrame = [];
+    // the CELL count when the frame began — the drawFull frozen bound's
+    // unit (the cells committed BEFORE this frame; a force-commit frame's
+    // placed LINES outnumber its cells)
+    #committedAtFrameStart = 0;
     render() {
         if (!this.#isActive())
             return;
@@ -473,7 +522,7 @@ export class Body {
         if (H < 4)
             return;
         this.#lastH = H;
-        const ctx = { spinnerI: this.#spinnerI, now: Date.now() };
+        const ctx = { spinnerI: this.#spinnerI, now: Date.now(), height: H };
         // V6-1 (the screen-state == frame-state rule): the resize's first
         // frame — the terminal's reflow re-wrapped the committed content at
         // the NEW width, so the cached folds are stale. Re-fold the
@@ -485,8 +534,8 @@ export class Body {
             for (let i = 0; i < this.#committed; i += 1) {
                 const cell = this.#cells[i];
                 const lines = cellComponent(cell).render(W, ctx);
-                this.#lineCache[i] = lines;
-                this.#committedLines += lines.length;
+                this.#lineCache[i] = lines; // the cell's OWN rows — the cache stays raw
+                this.#committedLines += bodySpacing(i > 0 ? this.#lineCache[i - 1] : null, lines).length;
             }
         }
         // 1. the natural commits — the leading DONE cells freeze: their
@@ -495,16 +544,24 @@ export class Body {
         //    short sessions included — the frame coalescing keeps a
         //    cell's first frame its freeze frame, so the frozen bytes
         //    emit exactly once).
+        this.#committedAtFrameStart = this.#committed;
         this.#committedLinesThisFrame = [];
         while (this.#committed < this.#cells.length && this.#cells[this.#committed].done) {
             this.#commitCell(this.#committed, W, ctx);
         }
         // 2. the live lines — the unfinished cells (the tail) + the chrome.
+        //    W11: the formula's blank above the first live cell hangs off
+        //    the last COMMITTED sibling (the join spans the boundary).
         const menuRows = this.#menuRows(W);
         const chromeRows = CHROME_ROWS + menuRows.length;
         let liveLines = [];
-        for (const cell of this.#cells.slice(this.#committed)) {
-            liveLines.push(...cellComponent(cell).render(W, ctx));
+        {
+            let prev = this.#committed > 0 ? this.#lineCache[this.#committed - 1] : null;
+            for (const cell of this.#cells.slice(this.#committed)) {
+                const rows = cellComponent(cell).render(W, ctx);
+                liveLines.push(...bodySpacing(prev, rows));
+                prev = rows;
+            }
         }
         // 3. the FORCE commits — the live region's hard cap H−1: overflow
         //    commits the oldest live cell UNCONDITIONALLY (the one sharp
@@ -512,8 +569,13 @@ export class Body {
         while (liveLines.length > H - 4 && this.#committed < this.#cells.length) { // V6-3: the content cap H−4
             this.#commitCell(this.#committed, W, ctx);
             liveLines = [];
-            for (const cell of this.#cells.slice(this.#committed)) {
-                liveLines.push(...cellComponent(cell).render(W, ctx));
+            {
+                let prev = this.#committed > 0 ? this.#lineCache[this.#committed - 1] : null;
+                for (const cell of this.#cells.slice(this.#committed)) {
+                    const rows = cellComponent(cell).render(W, ctx);
+                    liveLines.push(...bodySpacing(prev, rows));
+                    prev = rows;
+                }
             }
         }
         // 4. the geometry — the live region's first row:
@@ -539,14 +601,17 @@ export class Body {
     /** Commit the cell at index i: render + cache its lines (immutable —
      *  the force-committed form freezes at the current render), advance
      *  the bookkeeping — and collect the lines for this frame's writes.
-     *  Pure accounting + the write list; the BYTES emit in the frame. */
+     *  Pure accounting + the write list; the BYTES emit in the frame.
+     *  W11: the formula's blank above the cell (when one belongs) rides
+     *  this cell's commit — the cache stays raw, the placed rows count. */
     #commitCell(i, W, ctx) {
         const cell = this.#cells[i];
         const lines = cellComponent(cell).render(W, ctx);
         this.#lineCache[i] = lines;
+        const placed = bodySpacing(i > 0 ? this.#lineCache[i - 1] : null, lines);
         this.#committed += 1;
-        this.#committedLines += lines.length;
-        this.#committedLinesThisFrame.push(...lines);
+        this.#committedLines += placed.length;
+        this.#committedLinesThisFrame.push(...placed);
     }
     /** The slot occupant's extra rows — the slash-command menu (above the
      *  status, in the rhythm gap + the content's spare rows — the old
@@ -633,20 +698,24 @@ export class Body {
         const committed = this.#committedLinesThisFrame;
         // 0. the FROZEN rows — the re-folded committed content (re-flowed
         //    at the new width by the terminal): re-painted at [1..frozen],
-        //    so the reflow's shifted copies can never ghost.
-        const frozen = this.#lineCache.slice(0, this.#committed - committed.length).flat().filter((l) => l !== null);
-        let r = 1;
-        for (const line of frozen) {
-            out.push(`\x1b[${r};1H\x1b[0K${this.#checked(line, W)}`);
-            r += 1;
-        }
-        // 1. the committed lines (this frame's).
-        for (const line of committed) {
-            out.push(`\x1b[${r};1H\x1b[0K${this.#checked(line, W)}`);
-            r += 1;
+        //    so the reflow's shifted copies can never ghost. W11: the
+        //    formula's blanks between the cells are re-inserted here — the
+        //    cache holds each cell's OWN rows; a missing blank would paint
+        //    every row below it one row too high (the V6-1 idempotence
+        //    rule: this draw must reproduce the screen, row by row).
+        //    The bound is the CELL count at the frame's start — the force
+        //    commit's placed LINES can exceed the cell count, and the old
+        //    lines-bound went negative, skipping every previously-committed
+        //    cell (the V6-1 frozen-loop finding — the banner vanished).
+        const frozen = [];
+        for (let i = 0; i < this.#committedAtFrameStart; i += 1) {
+            frozen.push(...bodySpacing(i > 0 ? this.#lineCache[i - 1] : null, this.#lineCache[i]));
         }
-        // 2. the live lines.
-        for (const line of liveLines) {
+        let r = 1;
+        // one march — the frozen, the committed (this frame's), the live —
+        // in write order, r monotone (three byte-identical loops merged for
+        // the gate; the exact write sequence preserved)
+        for (const line of [...frozen, ...committed, ...liveLines]) {
             out.push(`\x1b[${r};1H\x1b[0K${this.#checked(line, W)}`);
             r += 1;
         }
@@ -664,7 +733,7 @@ export class Body {
         const editor = this.#inputRow(W, ctx);
         out.push(`\x1b[${H - 2};1H\x1b[0K${this.#checked(editor.stripped, W)}`);
         out.push(`\x1b[${H - 1};1H\x1b[0K${footerLine(W)}`);
-        out.push(`\x1b[${H};1H\x1b[0K${this.#checked(statusLine(this.#status, this.#tail, this.#question !== null, W), W)}`);
+        out.push(`\x1b[${H};1H\x1b[0K${this.#checked(statusLine(this.#status, this.#tail, this.#question !== null, W, this.#statusHint ?? undefined), W)}`);
         // the cursor: up two (the input row at H−2) + left to the marker
         out.push("\x1b[2A");
         if (editor.afterW > 0)
@@ -689,7 +758,7 @@ export class Body {
             out.push("\n");
         // the bottom-up repaint, from the last row up — V6-3: the design
         // §03 chrome: status (H), lower ╌ (H−1), input (H−2), upper ╌ (H−3)
-        out.push(`\x1b[1G\x1b[0K${this.#checked(statusLine(this.#status, this.#tail, this.#question !== null, W), W)}`); // H — the status
+        out.push(`\x1b[1G\x1b[0K${this.#checked(statusLine(this.#status, this.#tail, this.#question !== null, W, this.#statusHint ?? undefined), W)}`); // H — the status
         out.push(`\x1b[1A\x1b[1G\x1b[0K${footerLine(W)}`); // H−1 — the lower ╌
         out.push(`\x1b[1A\x1b[1G\x1b[0K${this.#checked(editor.stripped, W)}`); // H−2 — the input
         out.push(`\x1b[1A\x1b[1G\x1b[0K${footerLine(W)}`); // H−3 — the upper ╌
@@ -806,8 +875,8 @@ export class Dock {
     onResize() {
         compositorRef?.onResize();
     }
-    setStatus(text) {
-        compositorRef?.setStatus(text);
+    setStatus(text, hint) {
+        compositorRef?.setStatus(text, hint ?? null);
     }
     setTail(tail) {
         compositorRef?.setTail(tail);

package/dist/editor.d.ts

@@ -16,12 +16,8 @@
  * The editor is a SINGLE line: bracketed paste (?2004h) unwraps and
  * inserts, internal newlines become spaces.
  */
-/** A code point's display width: 2 for the wide ranges, 1 otherwise. */
-export declare function charWidth(cp: number): number;
-/** Display width of a code-point array (cursor math, scrolling). */
-export declare function widthOf(chars: readonly number[]): number;
-/** Display width of a string. */
-export declare function displayWidth(text: string): number;
+import { charWidth, displayWidth, widthOf } from "./width.js";
+export { charWidth, displayWidth, widthOf };
 export declare const PROMPT = "\u258C ";
 export declare const PROMPT_WIDTH: number;
 /** v3 §04 — the slash-command menu's command table (English one-liners). */

package/dist/editor.js

@@ -16,56 +16,10 @@
  * The editor is a SINGLE line: bracketed paste (?2004h) unwraps and
  * inserts, internal newlines become spaces.
  */
-/** A code point's display width: 2 for the wide ranges, 1 otherwise. */
-export function charWidth(cp) {
-    if (cp >= 0x1100 && cp <= 0x115f)
-        return 2; // hangul jamo
-    if (cp >= 0x2e80 && cp <= 0x303e)
-        return 2; // radicals .. CJK punctuation
-    if (cp >= 0x3041 && cp <= 0x33ff)
-        return 2; // kana, CJK compat
-    if (cp >= 0x3400 && cp <= 0x4dbf)
-        return 2; // CJK ext A
-    if (cp >= 0x4e00 && cp <= 0x9fff)
-        return 2; // CJK unified
-    if (cp >= 0xa000 && cp <= 0xa4cf)
-        return 2; // yi
-    if (cp >= 0xa960 && cp <= 0xa97f)
-        return 2; // hangul jamo ext
-    if (cp >= 0xac00 && cp <= 0xd7a3)
-        return 2; // hangul syllables
-    if (cp >= 0xf900 && cp <= 0xfaff)
-        return 2; // CJK compat ideographs
-    if (cp >= 0xfe10 && cp <= 0xfe19)
-        return 2; // vertical forms
-    if (cp >= 0xfe30 && cp <= 0xfe6f)
-        return 2; // CJK compat forms
-    if (cp >= 0xff00 && cp <= 0xff60)
-        return 2; // fullwidth forms
-    if (cp >= 0xffe0 && cp <= 0xffe6)
-        return 2; // fullwidth signs
-    if (cp >= 0x1f300 && cp <= 0x1f64f)
-        return 2; // emoji (misc + emoticons)
-    if (cp >= 0x1f900 && cp <= 0x1f9ff)
-        return 2; // supplemental emoji
-    if (cp >= 0x20000 && cp <= 0x3fffd)
-        return 2; // CJK ext B..G
-    return 1;
-}
-/** Display width of a code-point array (cursor math, scrolling). */
-export function widthOf(chars) {
-    let w = 0;
-    for (const cp of chars)
-        w += charWidth(cp);
-    return w;
-}
-/** Display width of a string. */
-export function displayWidth(text) {
-    let w = 0;
-    for (const ch of text)
-        w += charWidth(ch.codePointAt(0));
-    return w;
-}
+import { charWidth, displayWidth, widthOf } from "./width.js";
+// the width primitives moved to width.ts (W1, the single width
+// authority) — re-exported so the editor's public surface is unchanged.
+export { charWidth, displayWidth, widthOf };
 import { palette } from "./render.js";
 // TUI v4 #16d: the input row is the blue brick + the edit area — the
 // "you>" text is gone (the brick IS the prompt; the pipe path's readline
@@ -98,7 +52,10 @@ export class Editor {
     #pendingLines = []; // submits before onLine is wired (startup) — never dropped
     #sigintCb = null;
     #eotCb = null;
-    #escapeCb = null;
+    // W18: the escape LIST — the run-abort (chat) and the /compact cancel
+    // (dispatch) coexist; a listener removes itself via an unarmed guard
+    // (the compact's handler no-ops after its abort has fired).
+    #escapeCbs = [];
     #onRender;
     #menuOpen = false; // v3 §04: the slash-command menu
     #menuSel = 0;
@@ -136,7 +93,7 @@ export class Editor {
         this.#eotCb = cb;
     }
     onEscape(cb) {
-        this.#escapeCb = cb;
+        this.#escapeCbs.push(cb);
     }
     /** The whole buffer as text (the CLI's line()/clearLine()). */
     line() {
@@ -253,7 +210,8 @@ export class Editor {
                     this.#onRender();
                 }
                 else {
-                    this.#escapeCb?.();
+                    for (const cb of [...this.#escapeCbs])
+                        cb();
                     i += 1;
                 }
             }

package/dist/index.d.ts

@@ -8,5 +8,5 @@
 export { Body, Dock, CURSOR_MARKER, type BodyOptions } from "./compositor.js";
 export { Container, foldLine, visibleWidth, SPINNER, type Component, type FrameCtx } from "./components.js";
 export { Editor, MENU_ITEMS, PROMPT, PROMPT_WIDTH, displayWidth, charWidth, widthOf, type MenuItem, } from "./editor.js";
-export { bannerLines, COLOR_OFF, COLOR_ON, escapeTerminal, foldResult, foldThinking, kUnit, palette, renderEvent, renderRecap, renderSessionLine, renderStatusLine, renderTerminalGap, renderToolSummary, TAGLINE, truncateRow, type Palette, type PathResolver, type RecapStats, type RenderInput, type RenderResult, type RunUsage, } from "./render.js";
+export { bannerLines, COLOR_OFF, COLOR_ON, escapeTerminal, foldResult, foldThinking, kUnit, palette, renderEvent, renderRecap, renderResumeList, renderSessionLine, renderStatusLine, relativeTime, renderTerminalGap, renderToolSummary, TAGLINE, truncateRow, type Palette, type PathResolver, type RecapStats, type ResumeMeta, type RenderInput, type RenderResult, type RunUsage, } from "./render.js";
 export { editFileDiff, truncateDiff, writeFileDiff, type DiffLine, type DiffResult } from "./diff.js";

package/dist/index.js

@@ -8,5 +8,5 @@
 export { Body, Dock, CURSOR_MARKER } from "./compositor.js";
 export { Container, foldLine, visibleWidth, SPINNER } from "./components.js";
 export { Editor, MENU_ITEMS, PROMPT, PROMPT_WIDTH, displayWidth, charWidth, widthOf, } from "./editor.js";
-export { bannerLines, COLOR_OFF, COLOR_ON, escapeTerminal, foldResult, foldThinking, kUnit, palette, renderEvent, renderRecap, renderSessionLine, renderStatusLine, renderTerminalGap, renderToolSummary, TAGLINE, truncateRow, } from "./render.js";
+export { bannerLines, COLOR_OFF, COLOR_ON, escapeTerminal, foldResult, foldThinking, kUnit, palette, renderEvent, renderRecap, renderResumeList, renderSessionLine, renderStatusLine, relativeTime, renderTerminalGap, renderToolSummary, TAGLINE, truncateRow, } from "./render.js";
 export { editFileDiff, truncateDiff, writeFileDiff } from "./diff.js";

package/dist/render.d.ts

@@ -25,6 +25,8 @@ export interface Palette {
     readonly red: string;
     readonly green: string;
     readonly code: string;
+    readonly rv: string;
+    readonly rvEnd: string;
     readonly reset: string;
 }
 export declare const COLOR_ON: Palette;
@@ -212,11 +214,24 @@ export declare function renderTerminalGap(statusLine: string | null): string;
  * Pure.
  */
 export declare const TAGLINE = "the coding agent that survives kill -9";
-/** v3 §01: truncate a row at `width`, marking the hidden span " (+N)". */
+/** v3 §01 (W1): truncate a row at `width`, marking the hidden span
+ *  " (+N)". W1: the width math is the charWidth authority (the banner's
+ *  brick glyphs are 1 cell — the art's 38 columns clear 40), and the
+ *  marker's own cells are part of the row — the visible cut leaves room
+ *  for it, so a truncated row never exceeds W (a cut row carries the
+ *  marker INSIDE the width; a row that fits is returned untouched). */
 export declare function truncateRow(row: string, width: number): string;
-/** v3 §01 (V6-2): the banner lines for a width W — logo (skipped under
- *  40 columns) + blank + "kiso vX — tagline" + extensions. */
-export declare function bannerLines(W: number, version: string, extensionsText: string): string[];
+/** v3 §01 (V6-2) + W1: the banner lines for a width W and height H —
+ *  the tier table (extends the existing "under 40 columns, skip the
+ *  logo" rule with a HEIGHT input):
+ *    W ≥ 40 and H ≥ 20 → BIG (the 36x6 wordmark, 2-column indent)
+ *    W ≥ 40 and 14–19 rows → COMPACT (v6's LOGO_ROWS, byte-identical)
+ *    anything smaller → text rows only
+ *  then the blank, then "vX — tagline" — the art IS the wordmark, so the
+ *  text row does not repeat the name — then extensions — then the W5
+ *  resume list (BIG only, W5). Every row truncates at the terminal width
+ *  with a " (+N)" marker. Pure. */
+export declare function bannerLines(W: number, H: number, version: string, extensionsText: string, resume?: readonly ResumeMeta[], now?: number): string[];
 /** v3 §02 — the recap line that ends a run, replacing the "done" label +
  *  the old status line. All fields derive LOCALLY from the event stream
  *  (zero tokens): wall seconds, tool counts, usage, cache hit %, ctx left.
@@ -237,3 +252,19 @@ export declare function renderSessionLine(meta: {
     runs: number;
     updatedAt: number;
 }): string;
+/** W5 — the opening-screen resume list. Every field already exists
+ *  behind renderSessionLine / `kiso sessions`: the relative time, the
+ *  title, then the right-aligned "N events · M runs". The columns are
+ *  fixed per W: 4 indent + 7 when + 1 + the title (the ONLY flexible
+ *  field — cut with the ellipsis marker INSIDE the width) + 1 + the meta
+ *  (padStart to metaW). The done-when: the meta's right edge lands at
+ *  exactly W on every row. Returns PLAIN rows — the banner's uniform dim
+ *  wrap styles them (no dim+bold SGR composition). */
+export interface ResumeMeta {
+    readonly title: string;
+    readonly events: number;
+    readonly runs: number;
+    readonly updatedAt: number;
+}
+export declare function relativeTime(updatedAt: number, now: number): string;
+export declare function renderResumeList(metas: readonly ResumeMeta[], W: number, now: number): string[];

package/dist/render.js

@@ -7,8 +7,9 @@
  * kiso-core's Event — the CLI translates Event → RenderInput. The tui
  * package has ZERO kiso-core imports: input is data, output is bytes.
  */
-export const COLOR_ON = { bold: "\x1b[1m", dim: "\x1b[2m", red: "\x1b[31m", green: "\x1b[32m", code: "\x1b[38;5;110m", reset: "\x1b[0m" };
-export const COLOR_OFF = { bold: "", dim: "", red: "", green: "", code: "", reset: "" };
+import { charWidth, displayWidth } from "./width.js";
+export const COLOR_ON = { bold: "\x1b[1m", dim: "\x1b[2m", red: "\x1b[31m", green: "\x1b[32m", code: "\x1b[38;5;110m", rv: "\x1b[7m", rvEnd: "\x1b[27m", reset: "\x1b[0m" };
+export const COLOR_OFF = { bold: "", dim: "", red: "", green: "", code: "", rv: "", rvEnd: "", reset: "" };
 export function palette() {
     return process.env.NO_COLOR === undefined && process.stdout.isTTY ? COLOR_ON : COLOR_OFF;
 }
@@ -293,43 +294,81 @@ export function renderTerminalGap(statusLine) {
  * Pure.
  */
 export const TAGLINE = "the coding agent that survives kill -9";
+/** v6's existing logo — W1's COMPACT tier, byte-identical, no redraw. */
 const LOGO_ROWS = ["█ █ ▀█▀ █▀▀ █▀█", "█▀▄  █  ▀▀█ █ █", "▀ ▀ ▀▀▀ ▀▀▀ ▀▀▀"];
-/** Display width of a row (1-cell ASCII; 2-cell CJK/wide). */
-function displayW(row) {
-    let w = 0;
-    for (let i = 0; i < row.length; i += 1) {
-        const cp = row.codePointAt(i);
-        w += cp > 0xff ? 2 : 1;
-    }
-    return w;
-}
-/** v3 §01: truncate a row at `width`, marking the hidden span " (+N)". */
+/** W1's BIG tier (36x6, `█` and space only — no half-blocks, so there is
+ *  no tile seam to lose in a font that renders ▀ ▄ at the wrong height).
+ *  Each pixel is two cells wide on purpose (a terminal cell is ~1:2);
+ *  the render indents two — 38 columns total, clears 40. */
+const BIG_LOGO_ROWS = [
+    "██    ██  ██████  ████████  ████████",
+    "██  ██      ██    ██        ██    ██",
+    "████        ██    ████████  ██    ██",
+    "████        ██          ██  ██    ██",
+    "██  ██      ██          ██  ██    ██",
+    "██    ██  ██████  ████████  ████████",
+];
+/** v3 §01 (W1): truncate a row at `width`, marking the hidden span
+ *  " (+N)". W1: the width math is the charWidth authority (the banner's
+ *  brick glyphs are 1 cell — the art's 38 columns clear 40), and the
+ *  marker's own cells are part of the row — the visible cut leaves room
+ *  for it, so a truncated row never exceeds W (a cut row carries the
+ *  marker INSIDE the width; a row that fits is returned untouched). */
 export function truncateRow(row, width) {
-    if (displayW(row) <= width)
+    const total = displayWidth(row);
+    if (total <= width)
         return row;
-    const cut = Math.max(0, width - 4);
-    let w = 0;
-    let i = 0;
-    for (; i < row.length; i += 1) {
-        const cw = row.codePointAt(i) > 0xff ? 2 : 1;
-        if (w + cw > cut)
-            break;
-        w += cw;
+    // iterate the marker to a fixpoint: the marker's width changes the
+    // cut, the cut changes the hidden count the marker reports
+    let marker = " (+0)";
+    for (;;) {
+        const cut = Math.max(0, width - displayWidth(marker));
+        let w = 0;
+        let i = 0;
+        while (i < row.length) {
+            const cp = row.codePointAt(i);
+            const cw = charWidth(cp);
+            if (w + cw > cut)
+                break;
+            w += cw;
+            i += cp > 0xffff ? 2 : 1; // code-point stepping — never split a pair
+        }
+        const next = ` (+${total - w})`;
+        if (next === marker)
+            return `${row.slice(0, i)}${next}`;
+        marker = next;
     }
-    return `${row.slice(0, i)} (+${displayW(row) - w})`;
 }
-/** v3 §01 (V6-2): the banner lines for a width W — logo (skipped under
- *  40 columns) + blank + "kiso vX — tagline" + extensions. */
-export function bannerLines(W, version, extensionsText) {
+/** v3 §01 (V6-2) + W1: the banner lines for a width W and height H —
+ *  the tier table (extends the existing "under 40 columns, skip the
+ *  logo" rule with a HEIGHT input):
+ *    W ≥ 40 and H ≥ 20 → BIG (the 36x6 wordmark, 2-column indent)
+ *    W ≥ 40 and 14–19 rows → COMPACT (v6's LOGO_ROWS, byte-identical)
+ *    anything smaller → text rows only
+ *  then the blank, then "vX — tagline" — the art IS the wordmark, so the
+ *  text row does not repeat the name — then extensions — then the W5
+ *  resume list (BIG only, W5). Every row truncates at the terminal width
+ *  with a " (+N)" marker. Pure. */
+export function bannerLines(W, H, version, extensionsText, resume = [], now = Date.now()) {
     const rows = [];
     if (W >= 40) {
-        for (const r of LOGO_ROWS)
-            rows.push(truncateRow(r, W));
-        rows.push("");
+        if (H >= 20) {
+            for (const r of BIG_LOGO_ROWS)
+                rows.push(truncateRow(`  ${r}`, W));
+        }
+        else if (H >= 14) {
+            for (const r of LOGO_ROWS)
+                rows.push(truncateRow(r, W));
+        }
     }
-    rows.push(truncateRow(`kiso v${version} — ${TAGLINE}`, W));
+    if (rows.length > 0)
+        rows.push("");
+    rows.push(truncateRow(`v${version} — ${TAGLINE}`, W));
     if (extensionsText !== "")
         rows.push(truncateRow(extensionsText, W));
+    if (W >= 40 && H >= 20 && resume.length > 0) {
+        rows.push("", ...renderResumeList(resume, W, now));
+    }
     return rows;
 }
 export function renderRecap(s) {
@@ -353,3 +392,50 @@ export function renderSessionLine(meta) {
     // 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)}`;
 }
+export function relativeTime(updatedAt, now) {
+    const s = Math.max(0, now - updatedAt) / 1000;
+    if (s < 60)
+        return "now";
+    const m = Math.floor(s / 60);
+    if (m < 60)
+        return `${m}m ago`;
+    const h = Math.floor(m / 60);
+    if (h < 24)
+        return `${h}h ago`;
+    const d = Math.floor(h / 24);
+    if (d < 7)
+        return `${d}d ago`;
+    return `${Math.floor(d / 7)}w ago`;
+}
+function titleCut(text, max) {
+    if (displayWidth(text) <= max)
+        return text;
+    const room = max - displayWidth("…");
+    let w = 0;
+    let i = 0;
+    while (i < text.length) {
+        const cp = text.codePointAt(i);
+        const cw = charWidth(cp);
+        if (w + cw > room)
+            break;
+        w += cw;
+        i += cp > 0xffff ? 2 : 1;
+    }
+    return text.slice(0, i) + "…";
+}
+export function renderResumeList(metas, W, now) {
+    if (metas.length === 0)
+        return [];
+    const rows = ["  ▞ resume"];
+    const whens = metas.map((m) => relativeTime(m.updatedAt, now));
+    const metaTexts = metas.map((m) => `${m.events} events · ${m.runs} runs`);
+    const metaW = Math.max(...metaTexts.map((t) => t.length));
+    const titleW = Math.max(1, W - 13 - metaW);
+    for (let i = 0; i < metas.length; i += 1) {
+        const title = escapeTerminal(metas[i].title);
+        const shown = titleCut(title, titleW);
+        const pad = titleW - displayWidth(shown);
+        rows.push(`    ${whens[i].padEnd(7)} ${shown}${" ".repeat(pad)} ${metaTexts[i].padStart(metaW)}`);
+    }
+    return rows;
+}

package/dist/width.d.ts

@@ -0,0 +1,15 @@
+/**
+ * The display-width primitives — the SINGLE width authority (TUI v5
+ * #16e: "charWidth is the width authority"). The eastAsianWidth table
+ * is a ~40-line subset (CJK ideographs/kana/hangul/fullwidth/common
+ * wide symbols = 2, everything else = 1 — the box-drawing/brick glyphs
+ * █▀▄▞▸ are narrow). Known limitation, documented in the README: emoji
+ * ZWJ clusters are not guaranteed perfect — each code point counts as
+ * its width. Zero dependencies (importable from any module).
+ */
+/** A code point's display width: 2 for the wide ranges, 1 otherwise. */
+export declare function charWidth(cp: number): number;
+/** Display width of a code-point array (cursor math, scrolling). */
+export declare function widthOf(chars: readonly number[]): number;
+/** Display width of a string. */
+export declare function displayWidth(text: string): number;