@vincemakes/kiso-tui-cells 0.16.6 → 0.16.8

package/dist/components.d.ts

@@ -280,30 +280,8 @@ export declare function exploreRows(parts: readonly {
     name: string;
     subjects: readonly string[];
 }[], W: number): string[];
-/** W14 — the folded-turn line: a whole QUIET turn (no text), once it is
- *  scrollback, becomes ONE line — the work order's claimed shape
- *  (`▞ thought 19s · 5 reads · no edits`), the counts accumulated at
- *  toolStart: read_file → "reads", edit_file → "edits", the other tools
- *  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). */
-/**
- * R3b — what a run of work DID, in words. One definition, because two
- * surfaces say it: the fold line (`turnFold`, above) and the expand
- * header the compositor writes when that fold is opened. A second copy
- * would be a second answer to the same question, and the first thing to
- * drift would be the plurals — `search_text` is "matches", not
- * "searchs", and only the ROLLUP_NOUN table knows that.
- *
- * Zero terms are dropped (owner ruling, R3b): a term earns its place by
- * having a count.
- */
+/** 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[];
 export declare function turnFold(t: {
     words: string;

package/dist/components.js

@@ -289,7 +289,18 @@ class ThinkingFold {
     render(W, _ctx) {
         const p = palette();
         const block = this.cell.text;
-        const trimmed = escapeTerminal(block.trim());
+        // R3f — the fold is ONE ROW, so its text is one line.
+        //
+        // `escapeTerminal` strips C0 but KEEPS \n and \t, and
+        // `charWidth(0x0A)` is 1 — so a multi-line thinking block sailed
+        // through every width check as a legal single row, and the
+        // terminal then wrapped it across the chrome. That shipped in
+        // 0.16.6 and is what smashed the composer: a model whose thinking
+        // opens with a numbered plan ("1. …\n2. …") produces exactly it.
+        // Invariant ①b now catches the class at the emit; this stops
+        // producing it. Whitespace collapses because the row is a
+        // SUMMARY — the full text is one ctrl+r away, unchanged.
+        const trimmed = escapeTerminal(block.trim()).replace(/\s+/g, " ");
         // R2 (owner, 2026-08-27) — three changes, each independent.
         //
         // ITALIC marks the row as not-the-answer without spending a colour,
@@ -909,7 +920,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(" · ");
 }
@@ -954,12 +972,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
@@ -971,22 +997,64 @@ function countTerm(n, singular, plural) {
  * Zero terms are dropped (owner ruling, R3b): a term earns its place by
  * having a count.
  */
+/**
+ * R3g (2026-08-28) — the fold's own terms, VERB + COUNT + NOUN.
+ *
+ * DECLARED SUPERSESSION. R3b built these terms out of ROLLUP_NOUN,
+ * whose own comment says not to: that table names what a single-tool
+ * rollup COUNTS ("5 matches" — five matched lines), and this line
+ * counts CALLS. So one search_text call rendered `1 match`, a sentence
+ * that is false whenever the search matched any other number — which is
+ * almost always. `shell` fell through to the verb branch and read
+ * `4 shells`.
+ *
+ * The phrasing is the owner's, from the shape they asked for:
+ * "thought 17s · read 4 files · listed 1 directory · ran 4 shell
+ * 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"],
+};
+/**
+ * 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)
+        return `${n} × ${displayVerb(name)}`;
+    return `${t[0]} ${n} ${n === 1 ? t[1] : t[2]}`;
+}
 export function foldTerms(reads, edits, others) {
     const parts = [];
     if (reads > 0)
-        parts.push(countTerm(reads, "read", "reads"));
+        parts.push(foldTerm("read_file", reads));
     if (edits > 0)
-        parts.push(countTerm(edits, "edit", "edits"));
+        parts.push(foldTerm("edit_file", edits));
     for (const [name, n] of others) {
         if (n === 0)
             continue;
-        const noun = ROLLUP_NOUN[name];
-        if (noun !== undefined)
-            parts.push(countTerm(n, noun.endsWith("es") ? noun.slice(0, -2) : noun.slice(0, -1), noun));
-        else {
-            const verb = displayVerb(name);
-            parts.push(countTerm(n, verb, `${verb}s`));
-        }
+        parts.push(foldTerm(name, n));
     }
     return parts;
 }
@@ -997,20 +1065,88 @@ 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(" · ");
-    const words = escapeTerminal(t.words);
+    // 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
+    // for one frame. (The live UserMessage chip keeps its multi-row form:
+    // it folds per paragraph and each row is already one row.)
+    const words = escapeTerminal(t.words).replace(/\s+/g, " ");
+    // R3g (2026-08-28) — THE KEY IS LOAD-BEARING, SO IT GIVES WAY LAST.
+    //
+    // R3b wrote "the suffix gives way first at a narrow width", by
+    // analogy with the settled card's affordance. The analogy does not
+    // hold: the card's rows are still on the screen when its hint is
+    // dropped, and a fold's are not. A fold with no key is the turn's
+    // work behind a line with no way back — the one thing the fold's own
+    // header says it must never be. So the META gives way first (a cut
+    // count is still a true count), and the key survives.
+    //
+    // Two live cases, both reachable at W=80: the wordless fold went
+    // keyless as soon as the terms grew (R3g's verb+noun phrasing pushed
+    // it over), and the CHIP fold never had a key at all — it was
+    // written without one, so every folded turn that carried the user's
+    // 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}`;
     if (words === "") {
-        const row = `${p.bold}✦${p.reset} ${meta}`;
-        // R3b: the fold NAMES ITS OWN KEY. Without it the segment's work is
-        // unreachable — no rollup row, no expand, nothing — and hiding a
-        // tool call behind a line with no way back is the one thing this
-        // product must not do. The suffix gives way first at a narrow
-        // width, on the same principle the settled card's does: an
-        // affordance that does not fit is dropped, never half-drawn.
-        const keyed = `${row}${p.dim} · ctrl+r${p.reset}`;
+        const keyed = `${p.bold}✦${p.reset} ${meta}${key}`;
         if (visibleWidth(keyed) <= W)
             return [keyed];
-        return visibleWidth(row) <= W ? [row] : [`${p.bold}✦${p.reset} ${widthCut(meta, Math.max(1, W - 3))}…`]; // a wordless turn folds to the W14 shape
+        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) {
+            // 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
@@ -1020,15 +1156,34 @@ export function turnFold(t, W) {
     // 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);
+    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}`;
+    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 meta cuts with the honest "…"; invariant ① never trips
-    // at ANY width (a degenerate W's fold is a cut, never a crash).
-    return [`${p.bold}✦${p.reset} ${p.rv} ${cut} ${p.rvEnd} · ${widthCut(meta, Math.max(1, W - 8 - visibleWidth(cut)))}…`];
+    // 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) {
+        // 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.6",
+	"version": "0.16.8",
 	"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",