@vincemakes/kiso-tui-cells 0.19.1 → 0.20.1

package/dist/components.d.ts

@@ -32,6 +32,18 @@ export interface FrameCtx {
      *  the tier table reads H, so a resize RE-TIERS instead of
      *  re-folding frozen rows). */
     readonly height: number;
+    /** R7a — this cell is drawn UNDER an activity header that carries the
+     *  breathing mark, so its own head row wears a plain gutter.
+     *
+     *  The mark belongs to the ACTIVITY, not to each call in it. A
+     *  four-file burst drew four breathing marks, which is four marks
+     *  distinguishing nothing (law 1.3, the same ground R2 retired the
+     *  tick and cross on) — and worse, on a read that finishes in
+     *  200ms the mark is gone before the eye lands, so per-row it is
+     *  motion that never resolves into meaning. On the header it is lit
+     *  for the whole stretch, which is the fact it is there to carry:
+     *  work is in flight. Owner-ruled 2026-08-31. */
+    readonly grouped?: boolean;
 }
 /** ONE screen line a component emits (raw, SGR included). */
 export type RenderLine = string;
@@ -392,7 +404,11 @@ export interface StretchTerms {
  */
 export declare function stretchLine(t: StretchTerms & {
     readonly phase: "thinking" | "acting" | "settled";
+    readonly mark?: string;
 }, W: number): string[];
+/** R6/D3: the quiet turn's fold wears no mark either — the SECOND
+ *  emission site, and the one the D3 brief did not name. Same ruling,
+ *  same two-space indent; see stretchLine above for the argument. */
 export declare function turnFold(t: {
     words: string;
     thoughtSeconds: number;
@@ -492,6 +508,21 @@ export declare function formatDuration(totalSeconds: number): string;
  *  W21: the question param is gone — the old question slot retires; a
  *  pending approval's status IS the panel's (the compositor derives
  *  it from the bound panel state). */
+/** R8b — THE IDLE HINT GIVES WAY IN ORDER, and `ctrl+o` is on it.
+ *
+ *  The transcript viewer shipped in 0.19.0 and was reachable only from
+ *  the `?` sheet: not on the banner's key line, not here. A feature
+ *  whose only advertisement is a screen you have to already know to
+ *  open is DC-30's lesson pointing the other way.
+ *
+ *  It cannot simply be appended, because this hint is dropped WHOLE
+ *  when it does not fit — a longer string would take `/ commands` down
+ *  with it on a narrow terminal. So the forms are a ladder, and the
+ *  order says which affordance is least replaceable: `/ commands`
+ *  survives longest because it is the door to everything; `ctrl+o`
+ *  outranks `↑ history` because pressing up is how a person finds the
+ *  history by accident, and nothing finds ctrl+o by accident. */
+export declare function idleHint(room: number): string;
 export declare function statusLine(status: string, tail: string, W: number, hint?: string): string;
 /** The display-width prefix of a plain (SGR-free) text. W21: exported
  *  for the approval panel's option-2 rule-name cut. */

package/dist/components.js

@@ -149,7 +149,10 @@ export function cellComponent(cell) {
         case "user":
             return new UserMessage(cell);
         case "thinking":
-            return new ThinkingFold(cell);
+            // R7: the committed/live surface is the BLOCK. ThinkingFold
+            // survives for the pipe path (render.ts's foldThinking), whose
+            // bytes are asserted by the --plain identity gate.
+            return new ThinkingBlock(cell);
         case "tool":
             return new ToolExecution(cell);
         case "md":
@@ -281,6 +284,57 @@ export function pendingQueueRows(lines, W) {
  *  CJK — 2 cells per char — and tripped invariant ① on a real
  *  Chinese session). W2: the leading ⋯ is the thinking gutter — the
  *  midline mark (the state), never the text ellipsis (the truncation). */
+/**
+ * R7 — THINKING IS A BLOCK OF WORDS.
+ *
+ * The owner's ruling, arrived at from a side-by-side with pi's screen:
+ * the model's reasoning reads as its own paragraphs — italic, dim,
+ * indented two — and is never folded away. `ThinkingFold` (below, kept
+ * for the pipe path) summarised it to one row with a key; four rounds
+ * of machinery were then built to hand the rest back, and the owner's
+ * complaint through all of them was the same sentence: I cannot see
+ * what it was thinking.
+ *
+ * THE INDENT IS NOT DECORATION. Law 1.2 is SETTLED — "strip every
+ * escape sequence and no fact is lost" — and italic is SGR 3, which a
+ * pipe strips and `COLOR_OFF` empties outright. Stripped, an italic
+ * paragraph and the model's ANSWER are the same bytes, and the reader
+ * cannot tell the reasoning from the reply. The two-space indent is the
+ * byte that survives: reasoning sits in, the answer stands at the
+ * margin. The owner chose this over the un-indented form for exactly
+ * that reason, with the cost stated.
+ *
+ * Paragraphs are preserved (a blank line between them); the newlines
+ * INSIDE a paragraph collapse, because a hard-wrapped source line is
+ * the model's line width, not the reader's.
+ */
+class ThinkingBlock {
+    cell;
+    constructor(cell) {
+        this.cell = cell;
+    }
+    render(W, _ctx) {
+        const p = palette();
+        const text = escapeTerminal(this.cell.text).trim();
+        if (text === "")
+            return [];
+        const room = Math.max(1, W - 2);
+        const rows = [];
+        for (const para of text.split(/\n\s*\n/)) {
+            const flat = para.replace(/\s+/g, " ").trim();
+            if (flat === "")
+                continue;
+            if (rows.length > 0)
+                rows.push("");
+            // foldLine is the ONE width authority and returns real rows —
+            // invariant ①b (a row is one physical row) holds by
+            // construction rather than by remembering to split.
+            for (const line of foldLine(flat, room))
+                rows.push(`  ${p.dim}${p.italic}${line}${p.italicEnd}${p.reset}`);
+        }
+        return rows;
+    }
+}
 class ThinkingFold {
     cell;
     constructor(cell) {
@@ -687,7 +741,7 @@ class ToolExecution {
             // cannot be predicted: a turning mark implies progress the
             // product does not have. With no ground the breath freezes to a
             // static `●` and says the same thing more quietly.
-            const out = gutterCut(`${breathFrame(ctx.spinnerI)} `, `${verbCol} ${liveTarget(c)}`, Math.max(4, W - dur.length));
+            const out = gutterCut(ctx.grouped === true ? "  " : `${breathFrame(ctx.spinnerI)} `, `${verbCol} ${liveTarget(c)}`, Math.max(4, W - dur.length));
             out[0] = `${out[0]}${p.dim}${dur}${p.reset}`;
             out.push(...toolBlockBody(c, W));
             return out;
@@ -873,7 +927,7 @@ export function focusToken(row, W) {
         // attribute like bold is spent everywhere. It closes with washEnd
         // rather than a reset, so the surrounding dim survives instead of
         // having to be re-applied.
-        return `${row.slice(0, at)}${p.wash}${CTRL_R}${p.washEnd}${row.slice(at + CTRL_R.length)}`;
+        return `${row.slice(0, at)}${p.lift}${CTRL_R}${p.dim}${row.slice(at + CTRL_R.length)}`;
     }
     // A LIVE row does not carry the affordance today, and the live cell is
     // the one ctrl+r takes FIRST (expandNext scans the live tail before
@@ -885,7 +939,7 @@ export function focusToken(row, W) {
     const room = W - visibleWidth(row);
     if (room < SUFFIX_MIN)
         return row; // never at the cost of invariant ①
-    return `${row}${p.dim} · ${p.reset}${p.wash}${CTRL_R}${p.washEnd}`;
+    return `${row}${p.dim} · ${p.lift}${CTRL_R}${p.reset}`;
 }
 const CTRL_R = "ctrl+r";
 /** TUI2-R1 (A) — the expanded block's last row: the way back. The
@@ -964,8 +1018,10 @@ export function exploreRows(parts, W) {
     // outputs". /last shows the LAST call only — for a nine-call burst that
     // is one output out of nine, and a footer that sends the human to a
     // place the content is not is worse than a footer that says nothing.
-    rows.push(cutLine(`${p.dim}${CUT_ROW}${COLLAPSE_ROW}${p.reset}`, W));
-    return rows;
+    // R8a: the footer is an in-block note — the same indent, no glyph —
+    // and the corner opens the block's first row, like every other one.
+    rows.push(cutLine(`${p.dim}${NOTE_ROW}${COLLAPSE_ROW}${p.reset}`, W));
+    return openBlock(rows);
 }
 /** The count term with the singular/plural forms — "no reads", "1 read",
  *  "5 reads". The noun's singular drops the plural suffix ("dirs" → "dir",
@@ -1248,7 +1304,40 @@ function troubleClause(t) {
 export function stretchLine(t, W) {
     const p = palette();
     const live = t.phase !== "settled";
-    const mark = t.phase === "settled" ? `${p.bold}✦${p.reset}` : `${p.dim}${t.mark ?? "✧"}${p.reset}`;
+    // DECLARED SUPERSESSION (R6/D3, owner-ruled) — THE STRETCH LINE WEARS
+    // NO MARK, in any phase.
+    //
+    // Law 1.3: a symbol earns its cell by carrying a fact the words do
+    // not. When every settled fold, the live line AND the status row all
+    // wear a star, none of them distinguishes anything — it is the tick
+    // and the cross again (R2 retired those on exactly this ground), at
+    // the stretch scale. design.md §7.4 had already ruled the principle
+    // one scale down: "only the call still running carries a mark,
+    // because only it is moving", with a settled call's mark "(none) —
+    // the outcome is in the words. SETTLED." A settled STRETCH wearing
+    // one contradicted a precedent the file had already ratified.
+    //
+    // Nothing settled is being reversed: §4 lists this mark PROPOSED and
+    // §8 lists it OPEN. This is that proposal's ruling arriving, as a
+    // decline, on the owner's own dogfood.
+    //
+    // The replacement is a two-space INDENT, not a column shift: the row
+    // joins the settled-call family's geometry, the indent survives a
+    // pipe as bytes (prose never starts at column 3), and both forms are
+    // 2 cells so the width ladder below does not reflow. The status row's
+    // twinkle survives as the ONE moving mark; `✦ took` survives as the
+    // turn's seal.
+    //
+    // R7a AMENDS this by ONE case: the live ACTING line takes the
+    // breathing mark, passed in. D3 declined a mark on the SETTLED fold,
+    // where the words already carry the outcome; a line that means "work
+    // is in flight RIGHT NOW" carries a fact its words do not, which is
+    // exactly the test law 1.3 sets. It is also where the mark was
+    // migrating TO: §7.4's "only the call still running carries one" now
+    // applies at the stretch scale, one mark for the activity instead of
+    // one per call. Owner-ruled 2026-08-31, on the ground that a fast
+    // call's per-row mark is gone before the eye lands.
+    const mark = t.mark ?? " ";
     // R4a (owner ruling, 2026-08-30) — the fold row prints NO key.
     //
     // R4 printed `· ctrl+r 3` so the row could name its own target. The
@@ -1290,6 +1379,9 @@ export function stretchLine(t, W) {
     const row = `${mark}${words === "" ? "" : ` ${p.rv}${words}${p.rvEnd}${p.dim} ·${p.reset}`} ${meta}${clause === "" ? "" : `${p.red}${clause}${p.reset}`}${key === "" ? "" : `${p.dim}${key}${p.reset}`}`;
     return [visibleWidth(row) <= W ? row : cutLine(row, W)];
 }
+/** R6/D3: the quiet turn's fold wears no mark either — the SECOND
+ *  emission site, and the one the D3 brief did not name. Same ruling,
+ *  same two-space indent; see stretchLine above for the argument. */
 export function turnFold(t, W) {
     const p = palette();
     // R3b (owner, 2026-08-27): ZERO TERMS ARE DROPPED. W14 always wrote
@@ -1353,13 +1445,13 @@ export function turnFold(t, W) {
     const keyW = KEY.length;
     const key = `${p.dim}${KEY}${p.reset}`;
     if (words === "") {
-        const keyed = `${p.bold}✦${p.reset} ${meta}${key}`;
+        const keyed = `  ${meta}${key}`;
         if (visibleWidth(keyed) <= W)
             return [keyed];
         let tightMeta = meta;
         for (const [long, short] of COMPACT) {
             tightMeta = tightMeta.replaceAll(long, short);
-            const tight = `${p.bold}✦${p.reset} ${tightMeta}${key}`;
+            const tight = `  ${tightMeta}${key}`;
             if (visibleWidth(tight) <= W)
                 return [tight];
         }
@@ -1375,22 +1467,22 @@ export function turnFold(t, W) {
             // closed in the thinking fold, still open here. A width with no
             // room for the mark is a width with nothing to say: the row is
             // a hard cut of what it would have said.
-            const cut = `${p.bold}✦${p.reset} ${widthCut(tightMeta, Math.max(1, W - 3))}…`;
-            return [visibleWidth(cut) <= W ? cut : cutLine(`${p.bold}✦${p.reset} ${tightMeta}`, W)];
+            const cut = `  ${widthCut(tightMeta, Math.max(1, W - 3))}…`;
+            return [visibleWidth(cut) <= W ? cut : cutLine(`  ${tightMeta}`, W)];
         }
-        return [`${p.bold}✦${p.reset} ${widthCut(tightMeta, room)}…${key}`];
+        return [`  ${widthCut(tightMeta, room)}…${key}`];
     }
     // A9 (ruling R2, mock A): the user chip rides the fold — the human's
     // words LEAD the one line, the same SGR-7 bracket as the live user
     // row (#16f, side pads included). The words take the fold's width
-    // budget: W − the gutter ("✦ " = 2) − the join (" · " = 3) − the
+    // budget: W − the gutter (two spaces = 2, R6/D3) − the join (3) − the
     // chip's side pads (2) − the cut-tail reserve (1, the "…") − the
     // metadata's own width — the metadata survives, the words width-cut
     // at the end with the honest "…" (the "…" alone is the honest floor:
     // the words were there, cut).
-    const budget = Math.max(0, W - visibleWidth(`✦ ${meta}`) - 6 - keyW);
+    const budget = Math.max(0, W - visibleWidth(`  ${meta}`) - 6 - keyW);
     const cut = visibleWidth(words) > budget ? `${widthCut(words, budget)}…` : words;
-    const row = `${p.bold}✦${p.reset} ${p.rv} ${cut} ${p.rvEnd} · ${meta}${key}`;
+    const row = `  ${p.rv} ${cut} ${p.rvEnd} · ${meta}${key}`;
     if (visibleWidth(row) <= W)
         return [row];
     // R3h: the same COMPACT ladder the wordless branch walks — the nouns
@@ -1398,7 +1490,7 @@ export function turnFold(t, W) {
     let chipMeta = meta;
     for (const [long, short] of COMPACT) {
         chipMeta = chipMeta.replaceAll(long, short);
-        const tighter = `${p.bold}✦${p.reset} ${p.rv} ${cut} ${p.rvEnd} · ${chipMeta}${key}`;
+        const tighter = `  ${p.rv} ${cut} ${p.rvEnd} · ${chipMeta}${key}`;
         if (visibleWidth(tighter) <= W)
             return [tighter];
     }
@@ -1412,10 +1504,10 @@ export function turnFold(t, W) {
         // bracket's pads, the join and the "…" are ten cells before a
         // single character of content, so every width below ten threw
         // invariant ① — see the wordless branch above for the same class.
-        const tail = `${p.bold}✦${p.reset} ${p.rv} ${cut} ${p.rvEnd} · ${widthCut(compactAll(meta), Math.max(1, W - 8 - visibleWidth(cut)))}…`;
-        return [visibleWidth(tail) <= W ? tail : cutLine(`${p.bold}✦${p.reset} ${p.rv} ${cut} ${p.rvEnd}`, W)];
+        const tail = `  ${p.rv} ${cut} ${p.rvEnd} · ${widthCut(compactAll(meta), Math.max(1, W - 8 - visibleWidth(cut)))}…`;
+        return [visibleWidth(tail) <= W ? tail : cutLine(`  ${p.rv} ${cut} ${p.rvEnd}`, W)];
     }
-    return [`${p.bold}✦${p.reset} ${p.rv} ${cut} ${p.rvEnd} · ${widthCut(compactAll(meta), room)}…${key}`];
+    return [`  ${p.rv} ${cut} ${p.rvEnd} · ${widthCut(compactAll(meta), room)}…${key}`];
 }
 // ---- the bounded-block flow contract (W7, W8, W10) ----
 /** The caps — screen rows counted AFTER the fold, at the current width
@@ -1428,8 +1520,43 @@ const CAP_ERROR = 3; // the error text head
  *  block's body, └ the block's last row — what was cut, where the rest
  *  is — at the LEFT EDGE (the gutter column: the left edge alone
  *  distinguishes the states at --plain). Structural (constraint 1). */
-const BODY_ROW = "│ ";
+/** R8a — A TOOL BLOCK'S ROWS ARE INDENTED, NOT GUTTERED.
+ *
+ *  `│ ` on every row drew a bar down the left of every multi-row
+ *  output, which is what the owner kept pointing at. The fact the bar
+ *  carried — "these rows are the call's output, not prose" — is real
+ *  and law 1.2 requires it survive a pipe, so it moves into the
+ *  INDENT: four columns, one level deeper than the header (2) and than
+ *  prose (2). Bytes still tell them apart; no column of glyphs.
+ *
+ *  `└` survives as the mark that OPENS the block, once, on its first
+ *  row (see openBlock). In-block notes take NOTE_ROW — the same indent,
+ *  no glyph — because a second `└` inside one block would be the same
+ *  mark meaning two things (§4.1). CUT_ROW is unchanged for the
+ *  surfaces that are not a tool block: the fold row's target list, the
+ *  slot's overflow count. */
+const BODY_ROW = "    ";
+const NOTE_ROW = "    ";
 const CUT_ROW = "└ ";
+/** R8a — stamp `└` on a block's FIRST row, after every slice and note
+ *  has been assembled, so the mark is always on the first row actually
+ *  emitted rather than on one a cap may have dropped. */
+function openBlock(rows) {
+    // the corner goes on the first row that HAS something on it. A cap
+    // or a blank leading output line can put an empty row first, and a
+    // corner there would be a mark on a row with nothing to mark — law
+    // 1.3, which is the rule this whole change is serving.
+    const i = rows.findIndex((r) => visibleWidth(r) > visibleWidth(BODY_ROW));
+    if (i < 0)
+        return rows;
+    const first = rows[i];
+    const at = first.indexOf(BODY_ROW);
+    if (at < 0)
+        return rows;
+    // the corner REPLACES two of the four indent columns, so the text
+    // stays in the same column as every other row of the block.
+    return [...rows.slice(0, i), `${first.slice(0, at)}  \u2514 ${first.slice(at + BODY_ROW.length)}`, ...rows.slice(i + 1)];
+}
 const blockMemo = new WeakMap();
 /** The block's body rows below the header (memoized, W9). */
 function toolBlockBody(c, W) {
@@ -1476,15 +1603,16 @@ function toolBlockBody(c, W) {
                     : [];
     const note = c.expanded ? null : toolCutNote(c.name, c.resultText);
     if (note !== null)
-        rows.push(...foldLine(`${p.dim}${CUT_ROW}${note}${p.reset}`, W));
+        rows.push(...foldLine(`${p.dim}${NOTE_ROW}${note}${p.reset}`, W));
     // TUI2-R1 (A): an EXPANDED block says how to put it back. The footer
     // rides a block that HAS rows — an expanded delegate whose summary
     // marker is missing renders nothing, and a lone footer under a head
     // row would be an affordance for an empty block.
     if (c.expanded && rows.length > 0)
-        rows.push(...foldLine(`${p.dim}${CUT_ROW}${COLLAPSE_ROW}${p.reset}`, W));
-    blockMemo.set(c, { width: W, state, content, rows });
-    return rows;
+        rows.push(...foldLine(`${p.dim}${NOTE_ROW}${COLLAPSE_ROW}${p.reset}`, W));
+    const opened = openBlock(rows);
+    blockMemo.set(c, { width: W, state, content, rows: opened });
+    return opened;
 }
 /** Fold result text into dim body rows (the BODY_ROW prefix): escape,
  *  split, fold each line at W−prefix; trailing empty rows (the result's
@@ -1511,7 +1639,7 @@ function shellTail(text, W) {
     if (rows.length <= CAP_SHELL_SETTLED)
         return rows;
     const kept = CAP_SHELL_SETTLED - 1;
-    const cut = foldLine(`${p.dim}${CUT_ROW}+${rows.length - kept} earlier rows · ctrl+r${p.reset}`, W);
+    const cut = foldLine(`${p.dim}${NOTE_ROW}+${rows.length - kept} earlier rows · ctrl+r${p.reset}`, W);
     return [...rows.slice(rows.length - kept), ...cut];
 }
 /** The error text head: the FIRST rows, capped at 3 — the answer is at
@@ -1531,7 +1659,7 @@ function errorBody(c, W) {
     const rows = blockRows(c.resultText.split("\n").slice(skipFirst).join("\n"), W);
     if (rows.length <= CAP_ERROR)
         return rows;
-    const cut = foldLine(`${p.dim}${CUT_ROW}+${rows.length - (CAP_ERROR - 1)} more · ctrl+r${p.reset}`, W);
+    const cut = foldLine(`${p.dim}${NOTE_ROW}+${rows.length - (CAP_ERROR - 1)} more · ctrl+r${p.reset}`, W);
     return [...rows.slice(0, CAP_ERROR - 1), ...cut];
 }
 /** The running tool's FIXED-height window (W8): exactly 3 rows from
@@ -1542,15 +1670,23 @@ function errorBody(c, W) {
 function liveWindow(text, W) {
     const p = palette();
     if (text === "") {
-        return [`${p.dim}${BODY_ROW}${p.reset}`, `${p.dim}${BODY_ROW}${p.reset}`, `${p.dim}${CUT_ROW}waiting for output${p.reset}`];
+        // R7a: blank, not two bare gutters. A `│` marks a row that HAS
+        // content; two of them above "waiting for output" drew a tall
+        // empty bar under every command that had not printed yet — which
+        // is most of them, for their first second.
+        // ...and the waiting row sits DIRECTLY under its header, with the
+        // blanks below it — VD-4's own rule ("the output starts under its
+        // own header and grows downward"), which the gutter rows used to
+        // satisfy by accident and blanks made visible as a two-row gap.
+        return [`${p.dim}${NOTE_ROW}waiting for output${p.reset}`, "", ""];
     }
     const rows = blockRows(text, W);
     if (rows.length <= CAP_LIVE_WINDOW) {
         while (rows.length < CAP_LIVE_WINDOW)
-            rows.push(`${p.dim}${BODY_ROW}${p.reset}`);
+            rows.push(""); // R7a: blank, not a bar
         return rows;
     }
-    const cut = foldLine(`${p.dim}${CUT_ROW}+${rows.length - (CAP_LIVE_WINDOW - 1)} earlier rows · ctrl+r${p.reset}`, W);
+    const cut = foldLine(`${p.dim}${NOTE_ROW}+${rows.length - (CAP_LIVE_WINDOW - 1)} earlier rows · ctrl+r${p.reset}`, W);
     return [...rows.slice(rows.length - (CAP_LIVE_WINDOW - 1)), ...cut];
 }
 /**
@@ -1593,8 +1729,8 @@ function shellLiveTail(text, W) {
         return liveWindow("", W);
     const kept = rows.slice(Math.max(0, rows.length - (CAP_LIVE_WINDOW - 1)));
     while (kept.length < CAP_LIVE_WINDOW - 1)
-        kept.push(`${p.dim}${BODY_ROW}${p.reset}`);
-    return [...kept, cutLine(`${p.dim}${CUT_ROW}live tail · esc stop · alt+⏎ redirect${p.reset}`, W)];
+        kept.push(""); // R7a: blank, not a bar
+    return [...kept, cutLine(`${p.dim}${NOTE_ROW}live tail · esc stop · alt+⏎ redirect${p.reset}`, W)];
 }
 /**
  * R4 — the standing act slot.
@@ -1642,10 +1778,11 @@ export function slotTail(text, W, rows) {
     const all = blockRows(text, W);
     const from = all.findIndex((r) => visibleWidth(r) > visibleWidth(BODY_ROW));
     const body = from < 0 ? [] : all.slice(from);
-    const kept = body.slice(Math.max(0, body.length - rows));
-    while (kept.length < rows)
-        kept.push(`${p.dim}${BODY_ROW}${p.reset}`);
-    return kept;
+    // R7a: no pad. The slot stopped padding (see slotPad) and this was
+    // the same pad by another route — three blank rows under a call with
+    // nothing to say yet, which is the hole a7's blank-run guard prices.
+    // R8a: the corner opens whatever slice survives the cap.
+    return openBlock(body.slice(Math.max(0, body.length - rows)));
 }
 /** R4 — clamp or pad assembled slot rows to EXACTLY `rows`. The padding
  *  is what makes the slot stand; the clamp is what keeps the slot from
@@ -1654,11 +1791,24 @@ export function slotTail(text, W, rows) {
 export function slotPad(content, rows) {
     if (rows <= 0)
         return [];
-    const p = palette();
-    const out = content.slice(0, rows);
-    while (out.length < rows)
-        out.push(`${p.dim}${BODY_ROW}${p.reset}`);
-    return out;
+    // R7a — THE SLOT NO LONGER PADS. It caps, and that is all.
+    //
+    // R4 padded to a fixed height because the slot's content came and
+    // went: a finished call left the block, the block shrank, and every
+    // row above it moved. The pad bought stability with rows drawn as
+    // `│`, which is why a tall empty gutter ran down the screen under
+    // every short block — the owner's own screenshot, and law 1.3's
+    // case: a mark on a row with nothing to mark.
+    //
+    // Blanking the gutter revealed the hole it had been covering, and
+    // the a7 replay priced the hole: blank runs over 2 in 653 of 733
+    // frames, the screen never durably filling. So the pad had to go —
+    // and the height it was buying is now bought by the CONTENT, since
+    // R7a keeps every call's row for the life of the stretch. A block
+    // whose rows only accumulate cannot shrink, so there is nothing
+    // left for a pad to hold up. Measured: 65 of 733 at 40x24, the
+    // pre-R7a number exactly, with the motion gates still green.
+    return content.slice(0, rows);
 }
 /** R4 — the slot's overflow row: the calls in flight beyond the head
  *  budget. It lives INSIDE the slot (it is one of the four rows), which
@@ -1889,7 +2039,11 @@ export function cutLine(line, W) {
         width += cw;
         i += 1;
     }
-    return `${out}\x1b[0m…`;
+    // R8a: the reset comes from the PALETTE, not hardcoded. `\x1b[0m`
+    // here put an escape into every cut row under NO_COLOR and behind a
+    // pipe — the one context COLOR_OFF exists to keep clean (§1.2). A
+    // coloured palette is byte-identical, because its reset IS `\x1b[0m`.
+    return `${out}${palette().reset}…`;
 }
 /** W20 — the settled block's duration, the `2h 14m` form (the task
  *  narrative's long-horizon idiom): minutes+seconds under an hour,
@@ -1974,6 +2128,33 @@ class Checklist {
  *  W21: the question param is gone — the old question slot retires; a
  *  pending approval's status IS the panel's (the compositor derives
  *  it from the bound panel state). */
+/** R8b — THE IDLE HINT GIVES WAY IN ORDER, and `ctrl+o` is on it.
+ *
+ *  The transcript viewer shipped in 0.19.0 and was reachable only from
+ *  the `?` sheet: not on the banner's key line, not here. A feature
+ *  whose only advertisement is a screen you have to already know to
+ *  open is DC-30's lesson pointing the other way.
+ *
+ *  It cannot simply be appended, because this hint is dropped WHOLE
+ *  when it does not fit — a longer string would take `/ commands` down
+ *  with it on a narrow terminal. So the forms are a ladder, and the
+ *  order says which affordance is least replaceable: `/ commands`
+ *  survives longest because it is the door to everything; `ctrl+o`
+ *  outranks `↑ history` because pressing up is how a person finds the
+ *  history by accident, and nothing finds ctrl+o by accident. */
+export function idleHint(room) {
+    // The third rung is today's hint, kept so that NO width loses
+    // something that used to fit: without it, a room of 24-30 columns
+    // fell all the way to `/ commands` even though the old form fitted.
+    // So the ladder is not a strict ranking of the three affordances —
+    // it is the widest honest form at each room, and ctrl+o is on the
+    // first two rungs rather than on all of them.
+    for (const form of [" / commands · ↑ history · ctrl+o transcript", " / commands · ctrl+o transcript", " / commands · ↑ history", " / commands"]) {
+        if (visibleWidth(form) <= room)
+            return form;
+    }
+    return "";
+}
 export function statusLine(status, tail, W, hint) {
     const p = palette();
     const text = `${status}${tail === "" ? "" : ` · ${tail}`}`;
@@ -1981,13 +2162,13 @@ export function statusLine(status, tail, W, hint) {
     // "esc to cancel" (the same one-line-bounded shape as W12's delegate
     // row; the #16g rule still cuts the HINT first, then the status with
     // a "…" — never a fold).
-    const hintText = hint ?? " / commands · ↑ history";
     const statusW = visibleWidth(text);
     if (statusW > W) {
         return `${p.dim}${widthCut(text, W - 1)}…${p.reset}`;
     }
+    const hintText = hint ?? idleHint(Math.max(0, W - statusW));
     const hintW = visibleWidth(hintText);
-    if (statusW + hintW > W)
+    if (hintW === 0 || statusW + hintW > W)
         return `${p.dim}${text}${p.reset}`;
     return `${p.dim}${text}${" ".repeat(Math.max(0, W - statusW - hintW))}${hintText}${p.reset}`;
 }

package/dist/render.d.ts

@@ -77,6 +77,23 @@ export interface Palette {
      *  spans and must end without stranding them. */
     readonly wash: string;
     readonly washEnd: string;
+    /** R7a — THE FOCUS MARKER'S EMPHASIS, and it is not a background.
+     *
+     *  DC-3 gave the `ctrl+r` token the wash, which is a BACKGROUND once
+     *  a ground is resolved: `48;5;236` on dark reads as a black block
+     *  behind the key, on a row that is otherwise plain text. The owner
+     *  asked for it gone. The invariant DC-3 was serving — exactly one
+     *  bright token per frame, because the key has exactly one target —
+     *  never required a background; it required CONTRAST against the dim
+     *  siblings, and full-strength bold foreground is more of it than a
+     *  wash was.
+     *
+     *  Three escapes because "dim" has two forms here: SGR 2 in the
+     *  neutral palette, a 256-colour foreground in the resolved ones.
+     *  22 cancels the attribute, 39 restores the default foreground, 1
+     *  is the emphasis. It closes by re-opening the palette's own dim,
+     *  like `washEnd`, so the surrounding span survives. */
+    readonly lift: string;
     readonly reset: string;
 }
 /**

package/dist/render.js

@@ -28,7 +28,7 @@ const BASE = { bold: "\x1b[1m", dim: "\x1b[2m", red: "\x1b[31m", green: "\x1b[32
  * 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, dim = BASE.dim) => ({ ...BASE, red, dim, wash, washEnd, code: wash });
+const withWash = (wash, washEnd, red = BASE.red, dim = BASE.dim) => ({ ...BASE, red, dim, wash, washEnd, code: wash, lift: "\x1b[22m\x1b[39m\x1b[1m" });
 /**
  * DC-3 — one table per ground.
  *
@@ -56,7 +56,7 @@ export const COLOR_DARK = withWash("\x1b[48;5;236m", "\x1b[49m", "\x1b[38;5;173m
  *  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: "" };
+export const COLOR_OFF = { bold: "", dim: "", red: "", green: "", warn: "", code: "", italic: "", italicEnd: "", underline: "", underlineEnd: "", rv: "", rvEnd: "", wash: "", washEnd: "", lift: "", 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. */

package/dist/strings.d.ts

@@ -176,6 +176,13 @@ export declare const PANEL_KEYS_ROW = "panels: \u2191\u2193 move \u00B7 \u23CE c
  * screens pretending to be one. A narrow terminal shows fewer columns
  * of the same truth, which is the honest degradation.
  */
+/** R8b — the band's own opening row: a labelled rule at full width.
+ *
+ *  Moved here from the @ picker, unchanged in every byte, because the
+ *  keys sheet needs it too and `components.ts` already imports this
+ *  module — the dependency only runs one way. `at-picker.ts` re-exports
+ *  it, so every existing import site is untouched. */
+export declare function bandHeader(label: string, W: number): string;
 export declare function keysSheetRows(W: number): string[];
 /** TUI2-R1 (D) — the keys as ONE line, for /help. The same table the
  *  sheet renders, joined — so the two can disagree only by deleting a

package/dist/strings.js

@@ -18,7 +18,7 @@
  * looked up here.
  */
 import { escapeTerminal, palette } from "./render.js";
-import { displayWidth } from "./width.js";
+import { displayWidth, visibleWidth } from "./width.js";
 /** v2a: the interactive prompt — the identity accent. readline owns the
  *  echo of what the user types; we own the prompt's color. (v2c: the
  *  readline prompt keeps "you> " — the brick ▌ is the dock's row only;
@@ -296,6 +296,27 @@ const SHEET_STOPS = [
  * screens pretending to be one. A narrow terminal shows fewer columns
  * of the same truth, which is the honest degradation.
  */
+/** R8b — the band's own opening row: a labelled rule at full width.
+ *
+ *  Moved here from the @ picker, unchanged in every byte, because the
+ *  keys sheet needs it too and `components.ts` already imports this
+ *  module — the dependency only runs one way. `at-picker.ts` re-exports
+ *  it, so every existing import site is untouched. */
+export function bandHeader(label, W) {
+    const p = palette();
+    const head = `\u2500\u2500\u2500 ${label} `;
+    const line = `${head}${"\u2500".repeat(Math.max(1, W - head.length))}`;
+    let out = "";
+    let w = 0;
+    for (const ch of line) {
+        const cw = displayWidth(ch);
+        if (w + cw > Math.max(1, W))
+            break;
+        out += ch;
+        w += cw;
+    }
+    return `${p.dim}${out}${p.reset}`;
+}
 export function keysSheetRows(W) {
     const p = palette();
     const cell = (i) => {
@@ -309,7 +330,14 @@ export function keysSheetRows(W) {
         const b = KEY_BINDINGS[i];
         return b === undefined ? "" : `${b.keys} ${b.what}`;
     };
-    const rows = [`${p.bold}keys${p.reset}`];
+    // R8b — THE SHEET NAMES ITSELF, in the band vocabulary.
+    //
+    // Every other overlay does: `─── commands ───`, `─── files ───`,
+    // `─── sessions ───`, `── transcript · N folds ──`. This one opened
+    // with a bare bold word at column 0, which is the exact condition
+    // TUI2-R1.5 ⑦(b) named when it made the rule — with scrollback
+    // behind an overlay, nothing said where the surface began.
+    const rows = [bandHeader("keys", W)];
     for (let r = 0; r < SHEET_GRID.length; r += 1) {
         const indexes = SHEET_GRID[r];
         let row = "";

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@vincemakes/kiso-tui-cells",
-	"version": "0.19.1",
+	"version": "0.20.1",
 	"description": "kiso tui-cells — the components cell renderer (components, diff, width, the render slice). Zero runtime dependencies: input is data, output is bytes.",
 	"type": "module",
 	"license": "MIT",