@vincemakes/kiso-tui-cells 0.16.7 → 0.17.0

package/dist/components.d.ts

@@ -280,7 +280,89 @@ export declare function exploreRows(parts: readonly {
     name: string;
     subjects: readonly string[];
 }[], W: number): string[];
+/** Does this tool's fold term count distinct targets rather than calls? */
+export declare function foldCountsObjects(name: string): boolean;
 export declare function foldTerms(reads: number, edits: number, others: readonly [string, number][]): string[];
+/**
+ * R3i — THE STRETCH LINE: the turn's one working row, in three phases.
+ *
+ * A STRETCH is the run of thinking and tool calls between two blocks of
+ * the model's prose. While it runs it is this line plus a bounded act
+ * window; when it closes it commits as this same line, frozen, with its
+ * key. The contract in one sentence: **the line you watch is the line
+ * you keep** — the settle changes the mark, the tense and the key, and
+ * nothing else.
+ *
+ *   thinking   ✧ thinking 4s
+ *   acting     ✶ reading 6 files · running 4 shell commands
+ *   settled    ✦ thought 9s · read 6 files · ran 4 shell commands · ctrl+r
+ *
+ * THE GIVE-WAY LADDER, in order, because at some width everything
+ * cannot fit:
+ *
+ *   1. the human's WORDS (the A9 chip on a quiet turn) — they are on
+ *      screen above, in the chip band;
+ *   2. the NOUNS compact, cheapest word first, and stop as soon as the
+ *      row fits — buying one cell must not spend every substitution;
+ *   3. the COUNTS cut, with the honest "…";
+ *   4. the TROUBLE CLAUSE cuts. The design first said it never gives
+ *      way, and that was unimplementable: a long clause overflows after
+ *      the counts have already cut to a bare "…", and invariant ①
+ *      throws on that row;
+ *   5. the KEY gives way NEVER. A fold with no key is the turn's work
+ *      behind a line with no way back to it, which is the one thing
+ *      this row must not be.
+ *
+ * `…` in this file means CUT HERE and nothing else — which is why the
+ * live phases carry no trailing ellipsis for in-flight, though the
+ * reference implementation uses one. The moving mark and the present
+ * tense already say it twice.
+ */
+/**
+ * R3i phase 5 — THE ANSWERED QUESTION'S BLOCK.
+ *
+ * A settled `ask_user` used to render `  ask_user  (3 lines, 41.2s)` —
+ * an empty target and the answers discarded, though the tool_result
+ * already carried them. The owner asked for this block by pointing at
+ * one: after they answer, there is a display for that too.
+ *
+ *   asked 2 questions (answered, 41.2s)
+ *   │ deploy target → staging
+ *   │ retry policy → give up after 3 attempts (typed)
+ *
+ * The question is dim, the join is dim, the ANSWER is at body strength
+ * — strip every escape and every fact is still there (law 1.2: colour
+ * is emphasis, never information). A typed answer says `(typed)`,
+ * because where an answer came from is a fact about it.
+ *
+ * It is WORDS, not work (law 1.7): it never folds into a stretch line,
+ * because the one thing a summary must not do is speak for the human.
+ *
+ * A result that is not the ask's own JSON yields NOTHING. This renderer
+ * reads a payload it did not write, and a guess about what it means
+ * would be a row the product cannot stand behind.
+ */
+export declare function askedBlock(resultText: string, seconds: number, W: number): string[];
+export interface StretchTerms {
+    /** the segment's OWN measured thinking seconds; 0 drops the term */
+    readonly thoughtSeconds: number;
+    /** the segment's calls as [tool name, count], in first-call order.
+     *  Object-counting tools are deduped by target upstream (R3h). */
+    readonly calls: readonly (readonly [string, number])[];
+    /** the targets acted on — read only when the stretch made exactly
+     *  ONE call, where naming the target says everything the two rows it
+     *  replaces said (see the one-call rule below). */
+    readonly targets: readonly string[];
+    /** the trouble the stretch met: [kind, count, what it was]. */
+    readonly trouble: readonly (readonly ["failed" | "denied" | "interrupted", number, string])[];
+    /** A9 — the human's words, on a QUIET turn's fold only. */
+    readonly words?: string;
+    /** the live mark; the caller passes the spinner's current frame. */
+    readonly mark?: string;
+}
+export declare function stretchLine(t: StretchTerms & {
+    readonly phase: "thinking" | "acting" | "settled";
+}, W: number): string[];
 export declare function turnFold(t: {
     words: string;
     thoughtSeconds: number;

package/dist/components.js

@@ -593,6 +593,18 @@ class ToolExecution {
             return out;
         }
         if (c.state === "done") {
+            // R3i phase 5: an answered (or declined) ask_user renders its
+            // OWN block — the questions and what the human said. The row
+            // it replaces was `  ask_user  (3 lines, 41.2s)`: an empty
+            // target and the answers thrown away, though the result
+            // already carried them. `askedBlock` returns [] for anything
+            // that is not the ask's own JSON, so a payload this renderer
+            // did not write can never be guessed at.
+            if (c.name === "ask_user" && c.reason === null && !c.isError) {
+                const asked = askedBlock(c.resultText, c.startedAt !== null && c.doneAt !== null ? (c.doneAt - c.startedAt) / 1000 : 0, W);
+                if (asked.length > 0)
+                    return asked;
+            }
             // W19: the pinned deny — the claimed shape verbatim: the FULL
             // call name (the denial names the call), the target, the reason
             // in the W4 parentheses idiom, no timing (the call never ran).
@@ -920,7 +932,14 @@ export function exploreCounts(parts) {
     return parts
         .map((part) => {
         const [singular, plural] = EXPLORE_NOUN[part.name] ?? ["call", "calls"];
-        return `${part.subjects.length} ${part.subjects.length === 1 ? singular : plural}`;
+        // R3h (fable, 2026-08-29): DISTINCT subjects. This counted calls
+        // while exploreRows — the very next function, the expansion of
+        // THIS row — deduped them with `×N`. So the head said "6 files"
+        // over a list showing four, one of them `a.ts ×3`. The head and
+        // the body are two views of one run and must count alike; the
+        // body was right (a file read twice is one file).
+        const n = foldCountsObjects(part.name) ? new Set(part.subjects).size : part.subjects.length;
+        return `${n} ${n === 1 ? singular : plural}`;
     })
         .join(" · ");
 }
@@ -965,12 +984,20 @@ function countTerm(n, singular, plural) {
  *  as first-call-order terms (the ROLLUP_NOUN plurals when the tool opts
  *  in, the verb + "s" otherwise).
  *  A9 (ruling R2, mock A): the user chip rides the fold — the human's
- *  words LEAD the one line, `▞ <chip> · thought 19s · 5 reads · no
- *  edits` — the chip the SAME SGR-7 bracket as the live user row (#16f,
- *  side pads included). The words take the fold's width budget: the
- *  metadata terms survive (the W14 metadata rule — they give way LAST),
- *  the words width-cut at the end with the honest "…" (never a silent
- *  truncate — invariant ① holds on the ONE row by construction). */
+ *  words LEAD the one line, `✦ <chip> · thought 19s · read 5 files` —
+ *  the chip the SAME SGR-7 bracket as the live user row (#16f, side
+ *  pads included). The words take the fold's width budget and width-cut
+ *  at the end with the honest "…" (never a silent truncate — invariant
+ *  ① holds on the ONE row by construction).
+ *
+ *  DECLARED SUPERSESSION (R3g, 2026-08-28) — A9 also ruled that "the
+ *  metadata terms give way LAST". They do not any more: the KEY does.
+ *  A9 was taken when this line carried no key, and at a width where the
+ *  chip, the full metadata and " · ctrl+r" cannot coexist, a fold with
+ *  no key is the turn's work behind a line with no way back to it. So
+ *  the order is now words, then metadata, then — never — the key. The
+ *  glyph is ✦ and the zero terms are dropped (R3b), so the example above
+ *  is written as the code renders it rather than as A9 first wrote it. */
 /**
  * R3b — what a run of work DID, in words. One definition, because two
  * surfaces say it: the fold line (`turnFold`, above) and the expand
@@ -998,14 +1025,47 @@ function countTerm(n, singular, plural) {
  * commands". A tool with no entry says `3 × <verb>`, which counts calls
  * without inventing a noun for them.
  */
-const FOLD_TERM = {
-    read_file: ["read", "file", "files"],
-    edit_file: ["edited", "file", "files"],
-    write_file: ["wrote", "file", "files"],
-    list_dir: ["listed", "directory", "directories"],
-    search_text: ["ran", "search", "searches"],
-    shell: ["ran", "shell command", "shell commands"],
+/**
+ * R3i — ONE TERM TABLE, TWO TENSES: [past, progressive, singular, plural].
+ *
+ * The stretch line is the same row at every instant of a turn: while
+ * the work runs it says what it is DOING, and at the settle it says
+ * what it DID. That sentence is only true if both tenses come from one
+ * table. The v9 review found the alternative already happening on a
+ * hand-written prototype — `searching 1 pattern` live against `ran 1
+ * search` settled, the NOUN swapping at the settle, and `running 4
+ * shells`, which is verbatim the R3g defect the previous round removed.
+ *
+ * FOLD_TERM below is derived from this, so the settled vocabulary
+ * cannot drift from the live one by construction.
+ */
+const TERM = {
+    read_file: ["read", "reading", "file", "files"],
+    edit_file: ["edited", "editing", "file", "files"],
+    write_file: ["wrote", "writing", "file", "files"],
+    list_dir: ["listed", "listing", "directory", "directories"],
+    search_text: ["ran", "running", "search", "searches"],
+    shell: ["ran", "running", "shell command", "shell commands"],
 };
+const FOLD_TERM = Object.fromEntries(Object.entries(TERM).map(([name, [past, , singular, plural]]) => [name, [past, singular, plural]]));
+/**
+ * R3h (fable, 2026-08-29) — WHICH TERMS COUNT OBJECTS.
+ *
+ * The rule, one sentence: a term that counts OBJECTS counts distinct
+ * objects; a term that counts ACTS counts calls. `read 2 files` after
+ * reading ONE file twice is a false sentence, and law 1.3 does not
+ * become optional because the falsehood is small. `ran 2 searches`
+ * after searching the same pattern twice is TRUE — the acts happened.
+ *
+ * The table sits beside FOLD_TERM so the two cannot drift: a tool whose
+ * noun is a thing ("files", "directories") belongs here; a tool whose
+ * noun is an act ("searches", "shell commands") does not.
+ */
+const FOLD_COUNTS_OBJECTS = new Set(["read_file", "edit_file", "write_file", "list_dir"]);
+/** Does this tool's fold term count distinct targets rather than calls? */
+export function foldCountsObjects(name) {
+    return FOLD_COUNTS_OBJECTS.has(name);
+}
 function foldTerm(name, n) {
     const t = FOLD_TERM[name];
     if (t === undefined)
@@ -1025,6 +1085,167 @@ export function foldTerms(reads, edits, others) {
     }
     return parts;
 }
+/**
+ * R3i — THE STRETCH LINE: the turn's one working row, in three phases.
+ *
+ * A STRETCH is the run of thinking and tool calls between two blocks of
+ * the model's prose. While it runs it is this line plus a bounded act
+ * window; when it closes it commits as this same line, frozen, with its
+ * key. The contract in one sentence: **the line you watch is the line
+ * you keep** — the settle changes the mark, the tense and the key, and
+ * nothing else.
+ *
+ *   thinking   ✧ thinking 4s
+ *   acting     ✶ reading 6 files · running 4 shell commands
+ *   settled    ✦ thought 9s · read 6 files · ran 4 shell commands · ctrl+r
+ *
+ * THE GIVE-WAY LADDER, in order, because at some width everything
+ * cannot fit:
+ *
+ *   1. the human's WORDS (the A9 chip on a quiet turn) — they are on
+ *      screen above, in the chip band;
+ *   2. the NOUNS compact, cheapest word first, and stop as soon as the
+ *      row fits — buying one cell must not spend every substitution;
+ *   3. the COUNTS cut, with the honest "…";
+ *   4. the TROUBLE CLAUSE cuts. The design first said it never gives
+ *      way, and that was unimplementable: a long clause overflows after
+ *      the counts have already cut to a bare "…", and invariant ①
+ *      throws on that row;
+ *   5. the KEY gives way NEVER. A fold with no key is the turn's work
+ *      behind a line with no way back to it, which is the one thing
+ *      this row must not be.
+ *
+ * `…` in this file means CUT HERE and nothing else — which is why the
+ * live phases carry no trailing ellipsis for in-flight, though the
+ * reference implementation uses one. The moving mark and the present
+ * tense already say it twice.
+ */
+/**
+ * R3i phase 5 — THE ANSWERED QUESTION'S BLOCK.
+ *
+ * A settled `ask_user` used to render `  ask_user  (3 lines, 41.2s)` —
+ * an empty target and the answers discarded, though the tool_result
+ * already carried them. The owner asked for this block by pointing at
+ * one: after they answer, there is a display for that too.
+ *
+ *   asked 2 questions (answered, 41.2s)
+ *   │ deploy target → staging
+ *   │ retry policy → give up after 3 attempts (typed)
+ *
+ * The question is dim, the join is dim, the ANSWER is at body strength
+ * — strip every escape and every fact is still there (law 1.2: colour
+ * is emphasis, never information). A typed answer says `(typed)`,
+ * because where an answer came from is a fact about it.
+ *
+ * It is WORDS, not work (law 1.7): it never folds into a stretch line,
+ * because the one thing a summary must not do is speak for the human.
+ *
+ * A result that is not the ask's own JSON yields NOTHING. This renderer
+ * reads a payload it did not write, and a guess about what it means
+ * would be a row the product cannot stand behind.
+ */
+export function askedBlock(resultText, seconds, W) {
+    let parsed;
+    try {
+        parsed = JSON.parse(resultText);
+    }
+    catch {
+        return [];
+    }
+    if (parsed === null || typeof parsed !== "object")
+        return [];
+    const asked = parsed;
+    const p = palette();
+    const head = (n, outcome) => cutLine(`  ${p.bold}asked${p.reset} ${n} ${n === 1 ? "question" : "questions"} ${p.dim}(${outcome}, ${seconds.toFixed(1)}s)${p.reset}`, W);
+    const row = (body) => cutLine(`  ${p.dim}│${p.reset} ${body}`, W);
+    if (Array.isArray(asked.declined) && asked.declined.length > 0) {
+        // the honest decline record: WHAT went unanswered, and what the
+        // choices had been — the panel already computes both.
+        return [head(asked.declined.length, "declined"), ...asked.declined.map((q) => row(`${p.dim}${escapeTerminal(q)}${p.reset}`))];
+    }
+    if (!Array.isArray(asked.answers) || asked.answers.length === 0)
+        return [];
+    return [
+        head(asked.answers.length, "answered"),
+        ...asked.answers.map((a) => {
+            const q = escapeTerminal(String(a.q ?? ""));
+            const typed = typeof a.custom === "string" && a.custom !== "";
+            const value = typed ? a.custom : Array.isArray(a.choices) ? a.choices.join(", ") : String(a.choice ?? "");
+            return row(`${p.dim}${q} →${p.reset} ${escapeTerminal(value)}${typed ? `${p.dim} (typed)${p.reset}` : ""}`);
+        }),
+    ];
+}
+const STRETCH_COMPACT = [
+    ["directories", "dirs"],
+    ["directory", "dir"],
+    ["shell commands", "commands"],
+    ["shell command", "command"],
+];
+/** R3i — a stretch of exactly ONE call names its TARGET instead of its
+ *  count. `thought 2s · read 1 file` replaces two rows — the thinking
+ *  and the call — with a row that says less than either of them did,
+ *  and "thinking plus one call" is the commonest shape a narrating
+ *  model makes. This is the answer to the defect R3d killed R3b's
+ *  per-segment folds over; the "absorbs at least two rows" rule alone
+ *  does not answer it. */
+function stretchTerms(t, live) {
+    const total = t.calls.reduce((n, [, c]) => n + c, 0);
+    if (total === 1 && t.targets.length === 1) {
+        const [name] = t.calls[0];
+        const e = TERM[name];
+        return [`${e === undefined ? name : e[live ? 1 : 0]} ${t.targets[0]}`];
+    }
+    return t.calls
+        .filter(([, n]) => n > 0)
+        .map(([name, n]) => {
+        const e = TERM[name];
+        if (e === undefined)
+            return `${n} × ${displayVerb(name)}`;
+        return `${e[live ? 1 : 0]} ${n} ${n === 1 ? e[2] : e[3]}`;
+    });
+}
+/** R3i — the trouble clause: which call, and what happened, in WORDS.
+ *  Law 1.3 says an outcome is stated in words, "the only form that
+ *  survives a pipe"; the colour on this clause is emphasis over those
+ *  words, never the fact itself. */
+function troubleClause(t) {
+    return t.trouble
+        .filter(([, n]) => n > 0)
+        .map(([kind, n, what]) => (what === "" || kind === "interrupted" ? `${n} ${kind}` : `${n} ${kind}: ${what}`))
+        .join(" · ");
+}
+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}`;
+    const key = t.phase === "settled" ? " · ctrl+r" : "";
+    const lead = t.phase === "thinking" ? [`thinking ${t.thoughtSeconds}s`] : t.phase === "settled" && t.thoughtSeconds > 0 ? [`thought ${t.thoughtSeconds}s`] : [];
+    const clauseText = troubleClause(t);
+    let meta = [...lead, ...(t.phase === "thinking" ? [] : stretchTerms(t, live))].join(" · ");
+    let clause = clauseText === "" ? "" : ` · ${clauseText}`;
+    let words = t.words === undefined || t.words === "" ? "" : ` ${escapeTerminal(t.words).replace(/\s+/g, " ")} `;
+    const width = () => 2 + (words === "" ? 0 : visibleWidth(words) + 3) + visibleWidth(meta) + visibleWidth(clause) + visibleWidth(key);
+    const trim = (text, room, floor) => (room >= floor ? `${widthCut(text, room)}…` : "");
+    if (words !== "" && width() > W)
+        words = trim(words, W - (width() - visibleWidth(words)) - 1, 4);
+    if (width() > W) {
+        for (const [long, short] of STRETCH_COMPACT) {
+            meta = meta.replaceAll(long, short);
+            if (width() <= W)
+                break;
+        }
+    }
+    if (width() > W) {
+        const room = W - (width() - visibleWidth(meta)) - 1;
+        meta = room >= 2 ? `${widthCut(meta, room)}…` : "…";
+    }
+    if (width() > W && clause !== "")
+        clause = trim(clause, W - (width() - visibleWidth(clause)) - 1, 5);
+    // the degenerate floor: below the width where even the mark and one
+    // character fit, the row is a hard cut of what it would have said.
+    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)];
+}
 export function turnFold(t, W) {
     const p = palette();
     // R3b (owner, 2026-08-27): ZERO TERMS ARE DROPPED. W14 always wrote
@@ -1032,7 +1253,12 @@ export function turnFold(t, W) {
     // happen — on a segment fold, where a run is usually all reads or all
     // edits, half the row was the half that said nothing. A term earns its
     // place by having a count.
-    const meta = [`thought ${t.thoughtSeconds}s`, ...foldTerms(t.reads, t.edits, t.others)].join(" · ");
+    // R3h (fable, 2026-08-29): the THOUGHT term obeys the same zero-drop
+    // rule every other term got at R3b. It was exempt by accident — it
+    // was written before the rule — so a model that emits no thinking
+    // folded every turn of its life under `thought 0s`, a sentence about
+    // something that did not happen, in the lead position.
+    const meta = [...(t.thoughtSeconds > 0 ? [`thought ${t.thoughtSeconds}s`] : []), ...foldTerms(t.reads, t.edits, t.others)].join(" · ");
     // R3f: the same one-row rule. This one is worse than the thinking
     // fold's — the fold is a COMMITTED row, so a multi-line user message
     // would desync the committed-line accounting permanently rather than
@@ -1056,6 +1282,29 @@ export function turnFold(t, W) {
     // words was unreachable by the key its siblings advertise. Found by
     // an independent review (fable) and then by the paced-rollup gate,
     // which got `kind: "none"` back from expandNext.
+    // R3h: the COMPACT tier. The owner's own sentence — "thought 17s ·
+    // read 4 files · listed 1 directory · ran 4 shell commands" — is 81
+    // cells with the key at W=80: one over, so the tail was cut off the
+    // exact shape this round exists to produce. The nouns shorten before
+    // anything is lost, which is the same "degrade, never truncate"
+    // ladder every other row here walks.
+    // A LADDER, cheapest first, and it stops as soon as the row fits: the
+    // owner's canonical sentence is ONE cell over at W=80, and spending
+    // every substitution to buy one cell would shorten words that had
+    // room. "directory" is the cheapest to lose (nobody misreads "dir");
+    // "commands" is next and still says what happened.
+    const COMPACT = [
+        ["directories", "dirs"],
+        ["directory", "dir"],
+        ["shell commands", "commands"],
+        ["shell command", "command"],
+    ];
+    const compactAll = (text) => {
+        let out = text;
+        for (const [long, short] of COMPACT)
+            out = out.replaceAll(long, short);
+        return out;
+    };
     const KEY = " · ctrl+r";
     const keyW = KEY.length;
     const key = `${p.dim}${KEY}${p.reset}`;
@@ -1063,12 +1312,29 @@ export function turnFold(t, W) {
         const keyed = `${p.bold}✦${p.reset} ${meta}${key}`;
         if (visibleWidth(keyed) <= W)
             return [keyed];
-        // the meta cuts with the honest "…"; below the width where even
-        // the key fits there is nothing to preserve and the row is a cut.
+        let tightMeta = meta;
+        for (const [long, short] of COMPACT) {
+            tightMeta = tightMeta.replaceAll(long, short);
+            const tight = `${p.bold}✦${p.reset} ${tightMeta}${key}`;
+            if (visibleWidth(tight) <= W)
+                return [tight];
+        }
+        // the meta cuts with the honest "…" — the COMPACT form of it, so a
+        // cut row still carries as many whole terms as the width allows;
+        // below the width where even the key fits there is nothing to
+        // preserve and the row is a cut.
         const room = W - 2 - keyW - 1;
-        if (room < 2)
-            return [`${p.bold}✦${p.reset} ${widthCut(meta, Math.max(1, W - 3))}…`];
-        return [`${p.bold}✦${p.reset} ${widthCut(meta, room)}…${key}`];
+        if (room < 2) {
+            // R3h: and below FOUR columns even that row is 4 cells wide (the
+            // gutter, one character, the "…"), so invariant ① threw AT the
+            // widths this branch exists to serve — the same class DC-15
+            // 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)];
+        }
+        return [`${p.bold}✦${p.reset} ${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
@@ -1083,14 +1349,29 @@ export function turnFold(t, W) {
     const row = `${p.bold}✦${p.reset} ${p.rv} ${cut} ${p.rvEnd} · ${meta}${key}`;
     if (visibleWidth(row) <= W)
         return [row];
+    // R3h: the same COMPACT ladder the wordless branch walks — the nouns
+    // shorten before the words or the metadata lose anything.
+    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}`;
+        if (visibleWidth(tighter) <= W)
+            return [tighter];
+    }
     // the last resort: the METADATA gives way — the words hold their
     // budget, the key holds its nine cells, the meta cuts with the honest
     // "…"; invariant ① never trips at ANY width (a degenerate W's fold is
     // a cut, never a crash).
     const room = W - 8 - keyW - visibleWidth(cut);
-    if (room < 2)
-        return [`${p.bold}✦${p.reset} ${p.rv} ${cut} ${p.rvEnd} · ${widthCut(meta, Math.max(1, W - 8 - visibleWidth(cut)))}…`];
-    return [`${p.bold}✦${p.reset} ${p.rv} ${cut} ${p.rvEnd} · ${widthCut(meta, room)}…${key}`];
+    if (room < 2) {
+        // R3h: the chip branch's own degenerate floor. The gutter, the
+        // 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)];
+    }
+    return [`${p.bold}✦${p.reset} ${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

package/package.json

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