@vincemakes/kiso-tui-cells 0.19.0 → 0.20.0

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;

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
@@ -1248,7 +1302,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 +1377,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 +1443,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 +1465,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 +1488,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 +1502,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
@@ -1542,12 +1632,20 @@ 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}${CUT_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);
@@ -1593,7 +1691,7 @@ 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}`);
+        kept.push(""); // R7a: blank, not a bar
     return [...kept, cutLine(`${p.dim}${CUT_ROW}live tail · esc stop · alt+⏎ redirect${p.reset}`, W)];
 }
 /**
@@ -1642,10 +1740,10 @@ 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.
+    return 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 +1752,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

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

@@ -155,7 +155,19 @@ export declare function displayVerb(name: string): string;
  * The two ask-only gestures keep their clauses because the ask is the
  * only flavor with a set to build and an answer to write.
  */
-export declare const PANEL_KEYS_ROW = "panels: \u2191\u2193 move \u00B7 \u23CE or click confirms \u00B7 1-4 instant \u00B7 space toggles \u00B7 t types";
+/**
+ * R6/D2 — the row claims only what is TRUE OF EVERY panel.
+ *
+ * Its old sentence ("⏎ or click confirms · 1-4 instant · space toggles")
+ * was documented as true of every flavor, and had silently stopped
+ * being: `1-4 instant` is false on the ask's multi-select and on the
+ * pick panel (where a digit only moves the cursor and never commits),
+ * `or click` is false on both (their frames deliberately report no
+ * clickable span), and "1-4" is wrong whenever a panel has a different
+ * option count. Layered honesty: this row states the invariant, and each
+ * panel's own affordance row states that panel's whole truth.
+ */
+export declare const PANEL_KEYS_ROW = "panels: \u2191\u2193 move \u00B7 \u23CE confirms \u00B7 digits act on their row \u00B7 t types";
 /**
  * TUI2-R1 (D) — the sheet, one screen, static.
  *

package/dist/strings.js

@@ -249,7 +249,19 @@ export function displayVerb(name) {
  * The two ask-only gestures keep their clauses because the ask is the
  * only flavor with a set to build and an answer to write.
  */
-export const PANEL_KEYS_ROW = "panels: ↑↓ move · ⏎ or click confirms · 1-4 instant · space toggles · t types";
+/**
+ * R6/D2 — the row claims only what is TRUE OF EVERY panel.
+ *
+ * Its old sentence ("⏎ or click confirms · 1-4 instant · space toggles")
+ * was documented as true of every flavor, and had silently stopped
+ * being: `1-4 instant` is false on the ask's multi-select and on the
+ * pick panel (where a digit only moves the cursor and never commits),
+ * `or click` is false on both (their frames deliberately report no
+ * clickable span), and "1-4" is wrong whenever a panel has a different
+ * option count. Layered honesty: this row states the invariant, and each
+ * panel's own affordance row states that panel's whole truth.
+ */
+export const PANEL_KEYS_ROW = "panels: ↑↓ move \u00b7 ⏎ confirms \u00b7 digits act on their row \u00b7 t types";
 /** The sheet's grid: the first six bindings in two 3-column rows, the
  *  last four in two 2-column rows (the wide entries get the room). The
  *  COLUMN STOPS are the prototype's absolute positions, floored by the

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@vincemakes/kiso-tui-cells",
-	"version": "0.19.0",
+	"version": "0.20.0",
 	"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",