@vincemakes/kiso-tui-cells 0.1.41

package/dist/diff.d.ts

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

package/dist/diff.js

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

package/dist/index.d.ts

@@ -0,0 +1,14 @@
+/**
+ * kiso-tui-cells — the components cell renderer, extracted from the
+ * tui (ADR-0043 Amendment 4): components.ts, diff.ts, width.ts, and
+ * the render slice. ZERO runtime dependencies: input is data, output
+ * is bytes. The tui is the stable consumer (its shims re-export this
+ * package); the cli never imports it directly. Experimental — no
+ * API-stability promise yet.
+ */
+export { SPINNER, foldLine, visibleWidth, bodySpacing, Container, cellComponent, ROLLUP_NOUN, turnFold, CAP_TASK_LIVE, formatDuration, statusLine, boxTop, boxBottom, terminalPipe, type FrameCtx, type RenderLine, type Component, type BodyCell, } from "./components.js";
+export { editFileDiff, truncateDiff, writeFileDiff, type DiffLine, type DiffResult } from "./diff.js";
+export { pendingQueueRows } from "./components.js";
+export { charWidth, displayWidth, leadWidth, widthOf } from "./width.js";
+export { panelAffordance, panelBlockRows, panelLead, panelLeadPlain, panelLeadWidth, panelStatus, type PanelArgs, type PanelFlavor, type PanelPhase, type PanelSel, type PanelState, type PanelVerdict, type PanelView, } from "./approval-panel.js";
+export { bannerLines, COLOR_OFF, COLOR_ON, colorInlineCode, escapeTerminal, foldResult, foldThinking, kUnit, palette, relativeTime, renderResumeList, renderTerminalGap, renderToolSummary, TAGLINE, toolTarget, truncateRow, type Palette, type ResumeMeta, } from "./render.js";

package/dist/index.js

@@ -0,0 +1,21 @@
+/**
+ * kiso-tui-cells — the components cell renderer, extracted from the
+ * tui (ADR-0043 Amendment 4): components.ts, diff.ts, width.ts, and
+ * the render slice. ZERO runtime dependencies: input is data, output
+ * is bytes. The tui is the stable consumer (its shims re-export this
+ * package); the cli never imports it directly. Experimental — no
+ * API-stability promise yet.
+ */
+export { SPINNER, foldLine, visibleWidth, bodySpacing, Container, cellComponent, ROLLUP_NOUN, turnFold, CAP_TASK_LIVE, formatDuration, statusLine, boxTop, boxBottom, terminalPipe, } from "./components.js";
+export { editFileDiff, truncateDiff, writeFileDiff } from "./diff.js";
+// W22 (the v8 input round): the pending-queue chips — the SAME
+// UserMessage chip with the □ gutter, pre-rendered above the input
+// row while turns wait in the queue.
+export { pendingQueueRows } from "./components.js";
+export { charWidth, displayWidth, leadWidth, widthOf } from "./width.js";
+// W21 (the v8 approval round): the approval panel — the bounded block
+// that replaces the running tool's live window while a human-chain
+// approval is pending. Types + the row/lead/status renderers; the
+// verdict mapping lives in the cli, never here.
+export { panelAffordance, panelBlockRows, panelLead, panelLeadPlain, panelLeadWidth, panelStatus, } from "./approval-panel.js";
+export { bannerLines, COLOR_OFF, COLOR_ON, colorInlineCode, escapeTerminal, foldResult, foldThinking, kUnit, palette, relativeTime, renderResumeList, renderTerminalGap, renderToolSummary, TAGLINE, toolTarget, truncateRow, } from "./render.js";

package/dist/render.d.ts

@@ -0,0 +1,129 @@
+/**
+ * tui-cells — the render slice (ADR-0043 Amendment 4): the
+ * cell-rendering helpers components.ts imports — moved verbatim from
+ * the tui's render.ts, never duplicated. Pure (testable): given text,
+ * produce the bytes a human sees. Colors are raw ANSI — zero
+ * dependencies (the tui-cells package has none).
+ */
+/**
+ * v2a — the palette, centralized (no hard-coded codes elsewhere); v5
+ * (TUI v5 #16e, the v4.1 design): the decorative blue (38;5;75) is
+ * RETIRED — the identity accents (the you> prompt, the banner tagline,
+ * ✓ marks, slash-command names, the input brick) are bright-white BOLD
+ * (SGR 1); the user message is the SGR-7 chip (the 2026-08-09 ruling
+ * retired the ▍ rail); `code` is the content semantic tint for
+ * inline code spans in assistant text (256-color 110 — the cube color
+ * nearest the design's #8fb4d8); red for errors, dim for metadata,
+ * green for the diff additions. NO_COLOR set, or a non-TTY output →
+ * every code is empty, so pipes and CI carry ZERO ANSI (the existing
+ * byte-level e2e assertions guard it). Everything not listed is plain.
+ */
+export interface Palette {
+    readonly bold: string;
+    readonly dim: string;
+    readonly red: string;
+    readonly green: string;
+    readonly code: string;
+    readonly rv: string;
+    readonly rvEnd: string;
+    readonly reset: string;
+}
+export declare const COLOR_ON: Palette;
+export declare const COLOR_OFF: Palette;
+export declare function palette(): Palette;
+/**
+ * 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.
+ */
+export declare function escapeTerminal(text: string): string;
+/**
+ * TUI v5 #16e: the inline-code tint — backtick spans in ONE line of
+ * assistant body text get the `code` color. Deliberately NOT a markdown
+ * engine: single level only (`[^`]*` cannot nest), a span never matches
+ * across lines (the caller passes one line; an opener without a closer
+ * on the same line stays plain). NO_COLOR / pipes → the codes are empty
+ * strings → the line passes through byte-identical.
+ */
+export declare function colorInlineCode(line: string): string;
+/**
+ * v2b — one thinking BLOCK folds to ONE dim line: the first 100 chars, a
+ * " (… /think shows full)" marker when the block is longer. The consumer
+ * buffers the block's deltas, renders this at the block's end, and keeps
+ * the full text for /think. Pipes get the same fold — the content
+ * strategy is presentation-independent.
+ */
+export declare function foldThinking(block: string): string;
+/** v2b — the [result] echo truncates at 160 chars + a /last hint. */
+export declare function foldResult(content: string): string;
+/**
+ * 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
+ * code; failures (isError) are ✗. Pure and deterministic.
+ */
+export declare function renderToolSummary(name: string, input: Record<string, unknown>, result: {
+    content: string;
+    isError: boolean;
+}, reason?: string | null): string;
+/** W15 — the expand header's target: the tool call's subject (the path
+ *  for the *_file tools, the command for shell) — the same extraction
+ *  the summary detail uses, WITHOUT the counts (the header names what
+ *  was expanded, not its size). */
+export declare function toolTarget(name: string, input: Record<string, unknown>): string;
+/** k-units for the status line: 12345 → 12.3k, 800 → 800, null → ?. */
+export declare function kUnit(value: number | null): string;
+/**
+ * v2a rhythm — the exact bytes after a terminal event: the status line
+ * 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.
+ */
+export declare function renderTerminalGap(statusLine: string | null): string;
+/**
+ * v3 §01 (V6-2) — the banner, block-split. The logo is THREE BRICK rows
+ * (the logo.svg pixel form — K I S O), then a BLANK, then the info rows:
+ * "kiso vX — tagline" + extensions. The tagline rides the version line
+ * (the old logo MIDDLE row was the tagline — a text row masquerading as
+ * the logo's centre). Every row truncates at the terminal width with a
+ * " (+N)" marker (N = the hidden display width); a window narrower than
+ * 40 columns skips the logo + the blank entirely — only the info rows.
+ * Pure.
+ */
+export declare const TAGLINE = "the coding agent that survives kill -9";
+/** 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) + 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[];
+/** 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

@@ -0,0 +1,295 @@
+/**
+ * tui-cells — the render slice (ADR-0043 Amendment 4): the
+ * cell-rendering helpers components.ts imports — moved verbatim from
+ * the tui's render.ts, never duplicated. Pure (testable): given text,
+ * produce the bytes a human sees. Colors are raw ANSI — zero
+ * dependencies (the tui-cells package has none).
+ */
+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;
+}
+/**
+ * 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.
+ */
+export function escapeTerminal(text) {
+    // eslint-disable-next-line no-control-regex
+    return text
+        .replace(/[\u0000-\u0008\u000d\u000e-\u001f\u007f]/g, "") // C0 (keeps only \t and \n)
+        .replace(/\u001b/g, "") // ESC
+        .replace(/[\u0080-\u009f]/g, "") // C1
+        .replace(/[\u202a-\u202e\u2066-\u2069]/g, ""); // bidi
+}
+/**
+ * TUI v5 #16e: the inline-code tint — backtick spans in ONE line of
+ * assistant body text get the `code` color. Deliberately NOT a markdown
+ * engine: single level only (`[^`]*` cannot nest), a span never matches
+ * across lines (the caller passes one line; an opener without a closer
+ * on the same line stays plain). NO_COLOR / pipes → the codes are empty
+ * strings → the line passes through byte-identical.
+ */
+export function colorInlineCode(line) {
+    const p = palette();
+    if (p.code === "" || p.reset === "")
+        return line;
+    return line.replace(/`([^`]*)`/g, `${p.code}\`$1\`${p.reset}`);
+}
+/**
+ * v2b — one thinking BLOCK folds to ONE dim line: the first 100 chars, a
+ * " (… /think shows full)" marker when the block is longer. The consumer
+ * buffers the block's deltas, renders this at the block's end, and keeps
+ * the full text for /think. Pipes get the same fold — the content
+ * strategy is presentation-independent.
+ */
+export function foldThinking(block) {
+    const p = palette();
+    const trimmed = escapeTerminal(block.trim());
+    const truncated = trimmed.length > 100;
+    return `${p.dim}…${trimmed.slice(0, 100)}${truncated ? ` (${block.length} chars · /think)` : ""}${p.reset}\n`;
+}
+/** v2b — the [result] echo truncates at 160 chars + a /last hint. */
+export function foldResult(content) {
+    const flat = content.replaceAll("\n", " ");
+    const truncated = flat.length > 160;
+    return `${escapeTerminal(flat.slice(0, 160))}${truncated ? " (/last for full)" : ""}`;
+}
+/**
+ * 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
+ * code; failures (isError) are ✗. Pure and deterministic.
+ */
+export function renderToolSummary(name, input, result, reason = null) {
+    // v2a/v5: ✓ is a bold identity accent; ✗ stays red.
+    const p = palette();
+    // W19: a DENIED call (the "denied" tag) renders the pinned row — the
+    // FULL call name, the target, the reason in the W4 parentheses idiom,
+    // and NO timing metadata (the call never ran — (0.0s) would be noise).
+    // The same row in the interactive and pipe paths, byte-clean on a pipe.
+    if (reason !== null) {
+        return `${p.red}✗${p.reset} ${escapeTerminal(`${name} ${toolTarget(name, input)} (${reason})`)}`;
+    }
+    const mark = result.isError ? `${p.red}✗${p.reset}` : `${p.bold}✓${p.reset}`;
+    const shortName = name.replace("_file", "");
+    const detail = toolSummaryDetail(name, input, result);
+    return `${mark} ${escapeTerminal(`${shortName} ${detail}`)}`;
+}
+function toolSummaryDetail(name, input, result) {
+    // Line count without the phantom empty line after a trailing newline.
+    const lines = (text) => {
+        if (text === "")
+            return 0;
+        const parts = text.split("\n");
+        return parts[parts.length - 1] === "" ? parts.length - 1 : parts.length;
+    };
+    switch (name) {
+        case "read_file": {
+            const path = String(input.path ?? "?");
+            const count = lines(String(result.content));
+            return `${path} (${count} line${count === 1 ? "" : "s"})`;
+        }
+        case "write_file": {
+            const path = String(input.path ?? "?");
+            const count = lines(String(input.content ?? ""));
+            return `${path} (+${count})`;
+        }
+        case "edit_file": {
+            const path = String(input.path ?? "?");
+            const removed = lines(String(input.search ?? ""));
+            const added = lines(String(input.replace ?? ""));
+            return `${path} (+${added} -${removed})`;
+        }
+        case "shell": {
+            const command = String(input.command ?? "?");
+            const exit = exitCodeOf(result);
+            return `${command} (exit ${exit})`;
+        }
+        case "list_dir":
+            return String(input.path ?? "(root)");
+        default:
+            return String(input.path ?? input.command ?? "");
+    }
+}
+/** W15 — the expand header's target: the tool call's subject (the path
+ *  for the *_file tools, the command for shell) — the same extraction
+ *  the summary detail uses, WITHOUT the counts (the header names what
+ *  was expanded, not its size). */
+export function toolTarget(name, input) {
+    switch (name) {
+        case "read_file":
+        case "write_file":
+        case "edit_file":
+            return String(input.path ?? "?");
+        case "shell":
+            return String(input.command ?? "?");
+        case "list_dir":
+            return String(input.path ?? "(root)");
+        default:
+            return String(input.path ?? input.command ?? "");
+    }
+}
+/** The exit code of a shell result: parsed from the failure text, 0 on success. */
+function exitCodeOf(result) {
+    if (!result.isError)
+        return 0;
+    const m = /exit (\d+)/.exec(result.content);
+    return m !== null ? Number(m[1]) : 1;
+}
+/** k-units for the status line: 12345 → 12.3k, 800 → 800, null → ?. */
+export function kUnit(value) {
+    if (value === null)
+        return "?";
+    if (value >= 1000)
+        return `${(value / 1000).toFixed(1).replace(/\.0$/, "")}k`;
+    return String(value);
+}
+/**
+ * v2a rhythm — the exact bytes after a terminal event: the status line
+ * 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.
+ */
+export function renderTerminalGap(statusLine) {
+    return `${statusLine === null ? "" : `${statusLine}\n`}\n`;
+}
+/**
+ * v3 §01 (V6-2) — the banner, block-split. The logo is THREE BRICK rows
+ * (the logo.svg pixel form — K I S O), then a BLANK, then the info rows:
+ * "kiso vX — tagline" + extensions. The tagline rides the version line
+ * (the old logo MIDDLE row was the tagline — a text row masquerading as
+ * the logo's centre). Every row truncates at the terminal width with a
+ * " (+N)" marker (N = the hidden display width); a window narrower than
+ * 40 columns skips the logo + the blank entirely — only the info rows.
+ * 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 = ["█ █ ▀█▀ █▀▀ █▀█", "█▀▄  █  ▀▀█ █ █", "▀ ▀ ▀▀▀ ▀▀▀ ▀▀▀"];
+/** 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) {
+    const total = displayWidth(row);
+    if (total <= width)
+        return row;
+    // 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;
+    }
+}
+/** 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) {
+        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));
+        }
+    }
+    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 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,21 @@
+/**
+ * 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;
+/** A LEAD's display width — the prompt / the panel's phase lead,
+ *  ANSI-stripped. W23: the ONE width authority shared by the editor
+ *  (selfRender, #reflow), the compositor's #inputRow, and editCol — a
+ *  lead can never measure differently at two call sites (the frame-
+ *  derived column contract: wallL + leadWidth(lead) + cells + 1). */
+export declare function leadWidth(lead: string): number;