@vincemakes/kiso-tui-cells 0.16.2 → 0.16.4

package/dist/md.js

@@ -41,6 +41,10 @@ import { breakable, charWidth, displayWidth } from "./width.js";
 import { escapeTerminal } from "./render.js";
 import { visibleWidth } from "./components.js";
 // ---- line classification -------------------------------------------
+/** E2 — the rail a fenced block is drawn with. Three backticks: what
+ *  the model wrote, and what a human gets back when they copy the block
+ *  out of the terminal. */
+const RAIL = "\u0060\u0060\u0060";
 const FENCE = /^ {0,3}(`{3,}|~{3,})(.*)$/;
 /** ATX only, and the space is REQUIRED: `#hashtag` is prose. */
 const HEADING = /^ {0,3}(#{1,6}) +(\S.*)$/;
@@ -164,11 +168,16 @@ export class MdStream {
     }
     #line(line) {
         if (this.#fence !== null) {
-            // the closer emits no block: a bottom border is drawn only by an
-            // actual close, and under committed lines a phantom one would be
-            // a lie the force-commit path could freeze.
+            // E2: the closer emits its OWN block now. The rule it used to
+            // obey — "a bottom border is drawn only by an actual close, and
+            // under committed lines a phantom one would be a lie the
+            // force-commit path could freeze" — is UNCHANGED and is why this
+            // is safe: the rail appears here, on an actual close, and never
+            // before. An unterminated fence still draws no bottom, which is
+            // the truth about an unterminated fence.
             if (closesFence(line, this.#fence)) {
                 this.#fence = null;
+                this.#push({ kind: "fence-close", lines: [line], gap: false, lang: "" });
                 return;
             }
             this.#push({ kind: "fence-line", lines: [line], gap: false, lang: "" });
@@ -230,22 +239,38 @@ function blockBody(b, W) {
     const p = palette();
     switch (b.kind) {
         case "heading": {
-            // the marker is stripped, the numbering kept, and the levels are
-            // NOT differentiated by colour — attributes only. A `**bold**`
-            // inside a heading is therefore a no-op, which is the mono
-            // discipline paying for itself: the nested-style restore machinery
-            // both reference implementations need for this exact input has
-            // nothing to restore here.
+            // DC-4: the LEVEL is information and it used to be discarded —
+            // `#`, `##` and `###` all rendered as the same bold line, so a
+            // structured answer arrived flat. Levels are NOT differentiated
+            // by colour: 1 adds an underline, 2 is bold alone, and 3 and
+            // below print their own `###`, because attributes have run out
+            // and a marker is the only carrier that survives a pipe. A
+            // `**bold**` inside a heading is still a no-op, which is the mono
+            // discipline paying for itself.
             const m = HEADING.exec(b.lines[0] ?? "");
-            return wrap(`${p.bold}${inlineSpans(m?.[2] ?? b.lines[0] ?? "", p.bold)}${p.reset}`, W, "", "");
+            const level = (m?.[1] ?? "#").length;
+            const text = m?.[2] ?? b.lines[0] ?? "";
+            const style = level === 1 ? `${p.bold}${p.underline}` : p.bold;
+            const marker = level >= 3 ? `${"#".repeat(level)} ` : "";
+            return wrap(`${style}${marker}${inlineSpans(text, style)}${p.reset}`, W, "", "");
         }
         case "rule":
-            return [`${p.dim}${"─".repeat(Math.min(W, 28))}${p.reset}`];
+            // R2: the dashed rule, at the block's own width. The 28 was a
+            // guess that read as a short line rather than a divider, and ─
+            // belonged to the box vocabulary this round is collapsing.
+            return [`${p.dim}${"\u254c".repeat(Math.max(1, W))}${p.reset}`];
         case "fence-open":
-            // the dim gutter names the block; the language tag rides the
-            // opening row. Zero highlighting — which is exactly what makes a
-            // fence body line committable on its own.
-            return [`${p.dim}│${b.lang === "" ? "" : ` ${b.lang}`}${p.reset}`];
+            // E2: the RAIL, not a gutter. A block drawn with ``` is still a
+            // fenced block when a human selects it and pastes it somewhere
+            // else; a block drawn with a gutter is not. Zero highlighting —
+            // which is exactly what makes a fence body line committable on
+            // its own.
+            return [`${p.dim}${RAIL}${b.lang}${p.reset}`];
+        case "fence-close":
+            // only ever reached by an ACTUAL close (see MdStream#line): an
+            // unterminated fence draws no bottom, which is the truth about
+            // an unterminated fence.
+            return [`${p.dim}${RAIL}${p.reset}`];
         case "fence-line": {
             // a fence body's INDENTATION is its content. The wrapper drops
             // leading spaces \u2014 right for prose, a lie for code \u2014 so the indent
@@ -253,12 +278,23 @@ function blockBody(b, W) {
             // under it rather than returning to the gutter.
             const src = (b.lines[0] ?? "").replace(/\t/g, "    ");
             const indent = /^ */.exec(src)[0];
-            const gutter = `${p.dim}\u2502${p.reset} `;
-            return foldLineWidth(`${p.code}${src.slice(indent.length)}${p.reset}`, W - visibleWidth(gutter), indent).map((r) => `${gutter}${r}`);
+            const gutter = "  "; // E2: the rails bound the block; the body just insets
+            // DC-3: a fenced BODY carries no colour token. It used to take
+            // `code` — 1.54:1 on a white terminal, applied to whole blocks,
+            // which made the code the model just wrote the least readable
+            // thing on screen. The block's own ``` RAILS already say "this
+            // is verbatim" (E2 replaced the `│` gutter this comment used to
+            // name with them); saying it twice cost legibility and bought
+            // nothing.
+            return foldLineWidth(src.slice(indent.length), W - visibleWidth(gutter), indent).map((r) => `${gutter}${r}`);
         }
         case "quote": {
             const text = b.lines.map((l) => QUOTE.exec(l)?.[1] ?? l).join(" ");
-            const gutter = `${p.dim}\u258f${p.reset} `;
+            // R2: one gutter glyph. A quote and a fenced block both say "this
+            // text is not mine", and the screen was saying it two ways — ▏
+            // here and │ for code. The fences took their own ``` rails, so │
+            // is free and the quote takes it.
+            const gutter = `${p.dim}\u2502${p.reset} `;
             return wrap(`${p.dim}${inlineSpans(text, p.dim)}${p.reset}`, W - visibleWidth(gutter), "", "").map((r) => `${gutter}${r}`);
         }
         case "list":
@@ -310,7 +346,10 @@ export function inlineSpans(text, base) {
             if (end > i) {
                 // a code span's content is LITERAL — no markers inside it mean
                 // anything, which is what makes `x | y` survive a table split
-                out += `${p.code}${text.slice(i + 1, end)}${p.reset}${base}`;
+                // DC-3: inline code is a SURFACE (`wash`), closed with washEnd
+                // rather than a reset so the span composes inside a heading's
+                // or a quote's own style.
+                out += `${p.wash}${text.slice(i + 1, end)}${p.washEnd}${base}`;
                 i = end + 1;
                 continue;
             }
@@ -456,9 +495,12 @@ function listRows(b, W) {
         }
         flush();
         const depth = Math.min(5, Math.floor(m[1].length / 2));
-        // `•` normalization for bullets; a numbered list KEEPS its numbers
-        // (they are the author's meaning, not decoration).
-        const marker = /^\d/.test(m[2]) ? `${m[2]} ` : "• ";
+        // E1: normalization stays — `-`, `*` and `+` all render as ONE
+        // marker, so the model's arbitrary choice never leaks onto the
+        // screen — but the marker is `- ` rather than `•`, so a copied list
+        // is still a list. A numbered list KEEPS its numbers (they are the
+        // author's meaning, not decoration).
+        const marker = /^\d/.test(m[2]) ? `${m[2]} ` : "- ";
         lead = `${"  ".repeat(depth + 1)}${marker}`;
         text = m[3];
     }
@@ -484,17 +526,17 @@ function tableRows(b, W) {
     if (t === null)
         return b.lines.flatMap((l) => wrap(l, W, "", ""));
     const cols = t.header.map((h, i) => Math.max(cellWidth(h), ...t.rows.map((r) => cellWidth(r[i] ?? ""))));
-    // the drawn width: one rail, then each column as "│ cell " + its pad
-    const total = cols.reduce((n, w) => n + w + 3, 1);
+    // R2: no rails. The drawn width is two columns of inset plus the
+    // columns and their two-space gutters — a table is bounded by the
+    // blank lines above and below it, exactly as every other block on the
+    // screen is, and it was the last box left on a screen that has decided
+    // not to have boxes. Alignment does the work the rails were doing, and
+    // a copied table is closer to markdown without them.
+    const total = cols.reduce((n, w) => n + w + 2, 2);
     if (total > W)
         return recordRows(t, W);
-    const rail = `${p.dim}│${p.reset}`;
-    const row = (cells, bold) => `${rail}${cells.map((c, i) => ` ${pad(c, cols[i], t.align[i], bold)} `).join(rail)}${rail}`;
-    return [
-        row(t.header, true),
-        `${p.dim}├${cols.map((w) => "─".repeat(w + 2)).join("┼")}┤${p.reset}`,
-        ...t.rows.map((r) => row(r, false)),
-    ];
+    const row = (cells, bold) => `  ${cells.map((c, i) => pad(c, cols[i], t.align[i], bold)).join("  ")}`.replace(/\s+$/, "");
+    return [row(t.header, true), ...t.rows.map((r) => row(r, false))];
 }
 /** A cell's column count: what a human sees, styling removed. */
 function cellWidth(cell) {

package/dist/render.d.ts

@@ -5,6 +5,7 @@
  * produce the bytes a human sees. Colors are raw ANSI — zero
  * dependencies (the tui-cells package has none).
  */
+import type { Ground } from "./ground.js";
 /**
  * v2a — the palette, centralized (no hard-coded codes elsewhere); v5
  * (TUI v5 #16e, the v4.1 design): the decorative blue (38;5;75) is
@@ -42,6 +43,12 @@ export interface Palette {
      *  addressed to the human. This is the ruling's own set gaining its
      *  missing member, not a fourth colour. */
     readonly warn: string;
+    /** DC-3 — RETIRED as a tint; kept as an alias of `wash` so nothing
+     *  reading it gets the old absolute grey. It was 256-colour index 252
+     *  (#d0d0d0): 1.54:1 on a white terminal, against a 4.5:1 floor, and
+     *  five call sites shared it. Inline code is a SURFACE now — never a
+     *  foreground tint, and never applied to a whole fenced block, whose
+     *  `│` gutter already says the same thing more cheaply. */
     readonly code: string;
     /** TUI2-MD (MD-1, the owner's circle) — the markdown round's ONE new
      *  member. `*italic*` needs a rendering, and under the mono discipline
@@ -53,12 +60,44 @@ export interface Palette {
      *  SGR-0 that would strand the heading's own style. */
     readonly italic: string;
     readonly italicEnd: string;
+    /** DC-4 — the heading round's ONE new member, on the italic precedent:
+     *  SGR 4 is an ATTRIBUTE, so it costs the alphabet nothing chromatic
+     *  and a terminal without underlines simply draws the text. It carries
+     *  the level-1 heading; levels 3 and below carry their own `###`,
+     *  because attributes run out and a marker survives a pipe. */
+    readonly underline: string;
+    readonly underlineEnd: string;
     readonly rv: string;
     readonly rvEnd: string;
+    /** DC-3 — the VERBATIM surface: the human's own words, and inline
+     *  code. A background, so it needs the ground; with no ground it is
+     *  reverse video, which is correct on any ground and is rung 4 of the
+     *  ladder in `ground.ts`. Closed with 49 rather than SGR 0, for the
+     *  reason `rv` is closed with 27: a washed span sits inside other
+     *  spans and must end without stranding them. */
+    readonly wash: string;
+    readonly washEnd: string;
     readonly reset: string;
 }
+/**
+ * DC-3 — one table per ground.
+ *
+ * `dim` is the same in all three ON tables and that is the point: SGR 2
+ * is an ATTRIBUTE, it dims whatever the terminal's own foreground is, so
+ * it adapts to the ground instead of asserting one. Only the background
+ * genuinely needs to know, which is why `wash` is the only member that
+ * varies.
+ */
+export declare const COLOR_NEUTRAL: Palette;
+export declare const COLOR_LIGHT: Palette;
+export declare const COLOR_DARK: Palette;
+/** The historical name — the palette for a colour TTY whose ground has
+ *  not been established. Unchanged in every byte except `code`, which
+ *  was the defect. */
 export declare const COLOR_ON: Palette;
 export declare const COLOR_OFF: Palette;
+export declare function setGround(g: Ground): void;
+export declare function currentGround(): Ground;
 export declare function palette(): Palette;
 /**
  * E group/round 8: strip terminal-injection vectors from MODEL/TOOL text before it
@@ -102,17 +141,14 @@ export declare function kUnit(value: number | null): string;
  * 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";
+/** R2 — what the opening knows about the session. Optional because the
+ *  off-TTY caller prints a banner before a model is bound. */
+export interface BannerMeta {
+    readonly model: string;
+    readonly mode: string;
+    readonly cwd: string;
+}
 /** 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
@@ -129,7 +165,7 @@ export declare function truncateRow(row: string, width: number): string;
  *  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[];
+export declare function bannerLines(W: number, H: number, version: string, extensionsText: string, resume?: readonly ResumeMeta[], now?: number, meta?: BannerMeta | undefined): 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

package/dist/render.js

@@ -6,8 +6,56 @@
  * 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", warn: "\x1b[33m", code: "\x1b[38;5;252m", italic: "\x1b[3m", italicEnd: "\x1b[23m", rv: "\x1b[7m", rvEnd: "\x1b[27m", reset: "\x1b[0m" };
-export const COLOR_OFF = { bold: "", dim: "", red: "", green: "", warn: "", code: "", italic: "", italicEnd: "", rv: "", rvEnd: "", reset: "" };
+const BASE = { bold: "\x1b[1m", dim: "\x1b[2m", red: "\x1b[31m", green: "\x1b[32m", warn: "\x1b[33m", italic: "\x1b[3m", italicEnd: "\x1b[23m", underline: "\x1b[4m", underlineEnd: "\x1b[24m", rv: "\x1b[7m", rvEnd: "\x1b[27m", reset: "\x1b[0m" };
+/**
+ * DC-9 (design §2.3) — the failure colour is theme-resolved.
+ *
+ * ANSI 31 is 5.89:1 on a white ground and 2.83:1 on a dark one: the one
+ * token in the alphabet whose whole job is "this went wrong" was the
+ * least readable thing on the screen exactly where a dark-terminal user
+ * reads it. A failure is CONTENT (law 1.2 admits colour there), so it
+ * cannot degrade to an attribute the way `dim` does — it needs a value
+ * per ground, and the ground is what §3's ladder is for.
+ *
+ * 256-cube indices, never truecolor (§2). Measured against the grounds
+ * §2 measures against — white, and #1E1E1E:
+ *
+ *   light  124 `#af0000`  7.44:1
+ *   dark   173 `#d7875f`  5.97:1
+ *
+ * With NO ground established the token stays ANSI 31 — the TERMINAL's
+ * own red, which its theme picked for its own background. That is rung
+ * 4's principle exactly: when the ground is unknown, use the thing that
+ * is correct on any ground rather than guessing one.
+ */
+const withWash = (wash, washEnd, red = BASE.red) => ({ ...BASE, red, wash, washEnd, code: wash });
+/**
+ * DC-3 — one table per ground.
+ *
+ * `dim` is the same in all three ON tables and that is the point: SGR 2
+ * is an ATTRIBUTE, it dims whatever the terminal's own foreground is, so
+ * it adapts to the ground instead of asserting one. Only the background
+ * genuinely needs to know, which is why `wash` is the only member that
+ * varies.
+ */
+export const COLOR_NEUTRAL = withWash("\x1b[7m", "\x1b[27m");
+export const COLOR_LIGHT = withWash("\x1b[48;5;255m", "\x1b[49m", "\x1b[38;5;124m");
+export const COLOR_DARK = withWash("\x1b[48;5;236m", "\x1b[49m", "\x1b[38;5;173m");
+/** The historical name — the palette for a colour TTY whose ground has
+ *  not been established. Unchanged in every byte except `code`, which
+ *  was the defect. */
+export const COLOR_ON = COLOR_NEUTRAL;
+export const COLOR_OFF = { bold: "", dim: "", red: "", green: "", warn: "", code: "", italic: "", italicEnd: "", underline: "", underlineEnd: "", rv: "", rvEnd: "", wash: "", washEnd: "", reset: "" };
+/** DC-3 — the resolved ground, set once at startup when the terminal
+ *  answers (see `ground.ts`). It starts UNKNOWN and may stay that way
+ *  forever; that is a supported state, not a failure. */
+let ground = "unknown";
+export function setGround(g) {
+    ground = g;
+}
+export function currentGround() {
+    return ground;
+}
 export function palette() {
     // PH-1a (finding PH-F5): the no-color.org contract is "present AND
     // non-empty" — the old `=== undefined` check let an EMPTY `NO_COLOR=`
@@ -16,7 +64,9 @@ export function palette() {
     // UI with them. The v4-round plan recorded this as debugging pitfall ①;
     // it was a bug.
     const noColor = process.env.NO_COLOR;
-    return (noColor === undefined || noColor === "") && process.stdout.isTTY ? COLOR_ON : COLOR_OFF;
+    if (!((noColor === undefined || noColor === "") && process.stdout.isTTY))
+        return COLOR_OFF;
+    return ground === "light" ? COLOR_LIGHT : ground === "dark" ? COLOR_DARK : COLOR_NEUTRAL;
 }
 /**
  * E group/round 8: strip terminal-injection vectors from MODEL/TOOL text before it
@@ -161,14 +211,49 @@ export function renderTerminalGap(statusLine) {
  * 40 columns skips the logo + the blank entirely — only the info rows.
  * Pure.
  */
+/** DC-18: the display-width prefix of PLAIN text. `widthCut` lives in
+ *  components.ts, which imports this module — the dependency runs one
+ *  way, so the four lines live here rather than inverting it. */
+function plainCut(text, max) {
+    let w = 0;
+    let i = 0;
+    for (; i < text.length; i += 1) {
+        const cw = charWidth(text.codePointAt(i));
+        if (w + cw > max)
+            break;
+        w += cw;
+    }
+    return text.slice(0, i);
+}
 export const TAGLINE = "the coding agent that survives kill -9";
-/** TT-1B (VD-14) — the ONE wordmark, 2 rows. The 36x6 pixel art and the
- *  3-row compact logo both retire: a tall pixel banner's mid-scroll cut
- *  state renders as glyph garbage (VD-14 — frames 03/04/s2-05 of the
- *  2026-08-17 walkthrough), inherent to the height. This is the compact
- *  font with its base row folded into lower half-blocks — same alphabet,
- *  15 columns, and the cut window shrinks to nothing a reader catches. */
-const WORDMARK_ROWS = ["█ █ ▀█▀ █▀▀ █▀█", "█▀▄ ▄█▄ ▄▄█ █▄█"];
+/**
+ * R2 — the wordmark is retired (2026-08-27, the nineteen-screen review).
+ *
+ * TT-1B had already cut the 36x6 pixel art down to two rows because a
+ * tall banner's mid-scroll cut state renders as glyph garbage. The
+ * remaining two rows go now for a different reason: they say the word
+ * `kiso` in fifteen columns of block glyphs, and the word `kiso` says it
+ * in four. A rendered clover mark was tried first, at 4x2, 10x5, 14x7
+ * and 16x8, and rejected on measurement — below fourteen columns the
+ * centre star closes and the mark reads as a domino, and at fourteen it
+ * costs seven rows.
+ *
+ * What takes the room is not decoration. A first screen is asked three
+ * questions — what model, where am I, what is loaded — and it now
+ * answers them in one aligned column.
+ */
+/** R2 — the keys a first screen teaches. One dim row, and deliberately
+ *  NOT derived from KEY_BINDINGS: the sheet is the complete list and
+ *  this is the opening's five, chosen rather than generated. */
+// R2: the keys row names bindings the product ACTUALLY has. The first
+// draft advertised `! bash` — there is no bang passthrough in kiso and
+// KEY_BINDINGS never had one, so the opening screen was teaching a key
+// that does nothing. A first screen that lies is worse than a short one.
+const BANNER_KEYS = "esc interrupt · ctrl+c exit · / commands · @ files · ? keys";
+/** R2 — the labels. Uppercase mono, dim, letter-spaced by the column
+ *  rather than by SGR: they mark sections and are never content. */
+const BANNER_LABELS = ["MODEL", "WORKSPACE", "EXTENSIONS"];
+const LABEL_STOP = Math.max(...BANNER_LABELS.map((l) => l.length)) + 2;
 /** 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
@@ -179,6 +264,13 @@ export function truncateRow(row, width) {
     const total = displayWidth(row);
     if (total <= width)
         return row;
+    // DC-18: a width too narrow to HOLD the marker gets a hard cut. The
+    // fixpoint below floors `cut` at 0 and then appends a 6-cell marker
+    // regardless, so every width ≤ 6 returned a row WIDER than the
+    // terminal — and invariant ① throws rather than truncating. A marker
+    // wider than the row it marks is not a marker.
+    if (width < 7)
+        return plainCut(row, Math.max(0, width));
     // 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)";
@@ -209,17 +301,80 @@ export function truncateRow(row, width) {
  *  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 && H >= 14) {
-        for (const r of WORDMARK_ROWS)
-            rows.push(truncateRow(`  ${r}`, W));
+export function bannerLines(W, H, version, extensionsText, resume = [], now = Date.now(), meta) {
+    const p = palette();
+    // R2: the banner styles itself per span. It used to be wrapped in one
+    // blanket dim by its component, which made the answers as faint as the
+    // labels asking the questions — the labels are the quiet half, the
+    // values are what a human came to read.
+    //
+    // Every width decision below is taken on PLAIN text and the styling is
+    // applied after, because truncateRow measures with displayWidth, which
+    // counts SGR bytes as columns. Style then measure is a bug waiting.
+    // DC-18: the name row is CUT like every other row here. It was the one
+    // row in this function pushed unguarded, so at W ≤ 10 `kiso 0.16.4`
+    // measured 11 cells and invariant ① threw AT STARTUP — the function
+    // whose own comment preaches "invariant ① holds at every width".
+    // The cut is taken on the plain text, per the note above.
+    const namePlain = plainCut(`kiso ${version}`, Math.max(1, W));
+    const nameCut = namePlain.slice(0, 4); // "kiso", or its surviving prefix
+    const verCut = namePlain.slice(5); // the version, if the width left room for it
+    const rows = [`${p.bold}${nameCut}${p.reset}${verCut === "" ? "" : `${p.dim} ${verCut}${p.reset}`}`];
+    const facts = [];
+    if (meta !== undefined) {
+        facts.push([BANNER_LABELS[0], `${meta.model}${meta.mode === "" ? "" : ` · ${meta.mode}`}`], [BANNER_LABELS[1], meta.cwd]);
     }
-    if (rows.length > 0)
-        rows.push("");
-    rows.push(truncateRow(`v${version} — ${TAGLINE}`, W));
     if (extensionsText !== "")
-        rows.push(truncateRow(extensionsText, W));
+        facts.push([BANNER_LABELS[2], extensionsText]);
+    if (facts.length > 0) {
+        rows.push("");
+        // The value column HANGS rather than truncating. The label costs
+        // columns the value used to have, and an extension list cut at the
+        // width would hide which extensions loaded — on the one screen whose
+        // job is to say what is loaded.
+        const indent = 2 + LABEL_STOP;
+        // a terminal too narrow to hold the label column at all: the room is
+        // what is left, floored at one column, and the assembled row is
+        // truncated as a unit so invariant ① holds at every width.
+        const room = Math.max(1, W - indent);
+        for (const [label, value] of facts) {
+            const lead = `  ${p.dim}${label}${p.reset}${" ".repeat(LABEL_STOP - label.length)}`;
+            const hang = " ".repeat(indent);
+            const lines = [];
+            let line = "";
+            for (const word of value.split(" ")) {
+                if (line === "")
+                    line = word;
+                else if (displayWidth(`${line} ${word}`) <= room)
+                    line += ` ${word}`;
+                else {
+                    lines.push(line);
+                    line = word;
+                }
+            }
+            if (line !== "")
+                lines.push(line);
+            for (const [i, l] of lines.entries()) {
+                const styled = `${i === 0 ? lead : hang}${truncateRow(l, room)}`;
+                rows.push(displayWidth(styled) - (i === 0 ? p.dim.length + p.reset.length : 0) <= W ? styled : truncateRow(`${hang}${l}`, W));
+            }
+        }
+    }
+    if (meta !== undefined && W >= 40) {
+        // R2/DC-2's device: the keys row is a list of independent clauses,
+        // so a narrow terminal drops whole clauses from the end rather than
+        // cutting one in half. `ctrl+r ex (+8)` teaches nothing.
+        const clauses = BANNER_KEYS.split(" \u00b7 ");
+        let keys = clauses[0];
+        for (let n = clauses.length; n > 1; n -= 1) {
+            const row = clauses.slice(0, n).join(" \u00b7 ");
+            if (displayWidth(row) <= W - 2) {
+                keys = row;
+                break;
+            }
+        }
+        rows.push("", `  ${p.dim}${truncateRow(keys, W - 2)}${p.reset}`);
+    }
     if (W >= 40 && H >= 20 && resume.length > 0) {
         rows.push("", ...renderResumeList(resume, W, now));
     }
@@ -259,7 +414,7 @@ function titleCut(text, max) {
 export function renderResumeList(metas, W, now) {
     if (metas.length === 0)
         return [];
-    const rows = ["  ▞ resume"];
+    const rows = ["  ✦ resume"]; // R2: the ONE fold/segment mark (§4.2)
     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));