@vincemakes/kiso-tui 0.16.5 → 0.16.7

package/dist/components.d.ts

@@ -2,4 +2,5 @@
  *  Amendment 4) — this module is the re-export shim: the compositor's
  *  and index.ts's imports (./components.js) stay verbatim. */
 export * from "@vincemakes/kiso-tui-cells/components";
+export { foldTerms } from "@vincemakes/kiso-tui-cells/components";
 export { MOTION_FRAMES, TWINKLE, breathFrame, twinkleFrame } from "@vincemakes/kiso-tui-cells/render";

package/dist/components.js

@@ -4,4 +4,5 @@
 export * from "@vincemakes/kiso-tui-cells/components";
 // R3 (design §5.2): the two motion cycles reach the compositor through
 // the same shim every other cell primitive does.
+export { foldTerms } from "@vincemakes/kiso-tui-cells/components";
 export { MOTION_FRAMES, TWINKLE, breathFrame, twinkleFrame } from "@vincemakes/kiso-tui-cells/render";

package/dist/compositor.js

@@ -52,7 +52,7 @@ import { MOUSE_OFF } from "./editor.js";
 import { atPanelRows, bandHeader } from "./at-picker.js";
 // TUI2-R2 ②: the session picker's rows — the band's third occupant.
 import { sessionPickerRows } from "./session-picker.js";
-import { Container, ROLLUP_NOUN, MOTION_FRAMES, MdStream, bodySpacing, boxBottom, boxTop, cellComponent, exploreCounts, focusToken, exploreRows, foldLine, isExploreTool, pendingQueueRows, statusLine, turnFold, visibleWidth, } from "./components.js";
+import { Container, ROLLUP_NOUN, MOTION_FRAMES, MdStream, bodySpacing, boxBottom, boxTop, cellComponent, exploreCounts, foldTerms, focusToken, exploreRows, foldLine, isExploreTool, pendingQueueRows, statusLine, turnFold, visibleWidth, } from "./components.js";
 import { bannerLines, escapeTerminal, foldResult, foldThinking, palette, renderTerminalGap, renderToolSummary, toolTarget } from "./render.js";
 import { displayVerb, keysSheetRows } from "./strings.js";
 /** The cursor marker — an APC private sequence the focus component
@@ -69,6 +69,123 @@ const NOT_PAINTED = "\u0000never";
  *  that a single resize still feels immediate. */
 const RESIZE_SETTLE_MS = 80;
 const CHROME_ROWS = 4; // box top + input + box bottom + status — the design §03 chrome (V6-3; the box is W6)
+/** W13 / TUI2-R1 (B) — a rolled run's TITLE: the exploration sentence on
+ *  a mixed run, W13's verb+count on a single-name one. */
+function rolledTitle(cell) {
+    const r = cell.rolled;
+    if (r.parts !== undefined)
+        return `explored ${exploreCounts(r.parts)}`;
+    return `${displayVerb(cell.name)} ${r.count} ${ROLLUP_NOUN[cell.name] ?? "calls"}`;
+}
+/** W13 / TUI2-R1 (B) — a rolled run's DETAIL rows: one row per tool with
+ *  its subjects on a mixed run, one `└ target` per call on a single-name
+ *  one.
+ *
+ *  Extracted at R3b so the segment fold's expansion opens a run to the
+ *  SAME rows `ctrl+r` on the run itself would have opened. Two copies of
+ *  this would be two answers to "show me that run". */
+function rolledDetail(cell, W) {
+    const p = palette();
+    const r = cell.rolled;
+    if (r.parts !== undefined)
+        return exploreRows(r.parts, W);
+    return r.targets.map((t) => `  ${p.dim}└ ${escapeTerminal(t)}${p.reset}`);
+}
+/**
+ * W13 / TUI2-R1 (B) — the rollup's own projection of a run: the count,
+ * the lines, the elapsed, the targets, and — on a MIXED run only — the
+ * per-tool parts. A single-name run keeps W13's row byte for byte,
+ * which is the "the generalization adds, it never rewrites" rule.
+ *
+ * Extracted at R3b because the segment fold's EXPANSION renders the run
+ * through this same projection rather than reimplementing it — so the
+ * expanded rows cannot drift from the ones the commit path would have
+ * drawn.
+ */
+function rolledOf(members) {
+    let total = 0;
+    const targets = [];
+    for (const m of members) {
+        // the lines count, excluding the tool's OWN truncation note
+        // (read_file's "… N more lines") — the per-cell meta's rule
+        const noteAt = m.resultText.lastIndexOf("\n… ");
+        const shown = noteAt >= 0 ? m.resultText.slice(0, noteAt) : m.resultText;
+        const rows = shown.split("\n");
+        total += rows[rows.length - 1] === "" ? rows.length - 1 : rows.length;
+        let input = {};
+        try {
+            input = JSON.parse(m.inputFull);
+        }
+        catch {
+            // the full JSON is always parseable (stringified at toolStart)
+        }
+        const target = toolTarget(m.name, input);
+        targets.push(target.split("/").pop() ?? target);
+    }
+    const parts = exploreParts(members);
+    const first = members[0];
+    const last = members[members.length - 1];
+    const elapsed = first.startedAt !== null && last.doneAt !== null ? ((last.doneAt - first.startedAt) / 1000).toFixed(1) : "?";
+    return { count: members.length, lines: total, elapsed, targets, ...(parts.length > 1 ? { parts } : {}) };
+}
+/**
+ * TUI2-R1 (B) / R3b — the per-tool parts of an explore run, in
+ * first-call order. A search's subject is the PATTERN it looked for
+ * (quoted); a read's or a list's is the path it named.
+ *
+ * Extracted at R3b because TWO paths need it now: the commit-time
+ * rollup, which has always built it, and the segment fold's EXPANSION,
+ * which shows the rollup's rows rather than one row per call. Two
+ * copies of this would be two answers to "what did that run do".
+ */
+function exploreParts(members) {
+    const parts = [];
+    for (const m of members) {
+        let input = {};
+        try {
+            input = JSON.parse(m.inputFull);
+        }
+        catch {
+            // the full JSON is always parseable (stringified at toolStart)
+        }
+        const target = toolTarget(m.name, input);
+        const subject = m.name === "search_text" ? `"${String(input.pattern ?? "")}"` : target;
+        const part = parts.find((x) => x.name === m.name);
+        if (part === undefined)
+            parts.push({ name: m.name, subjects: [subject] });
+        else
+            part.subjects.push(subject);
+    }
+    return parts;
+}
+/** R3b — a segment's terms, for the expand header. The fold line's own
+ *  wording comes from `turnFold`; this is the same facts in the header
+ *  idiom the other expands use. */
+function foldMeta(seg) {
+    const parts = foldTerms(seg.reads, seg.edits, [...seg.others]);
+    return parts.length === 0 ? "thinking" : parts.join(" · ");
+}
+/** R3b — the turn's open segment, opened on demand at the first cell of
+ *  work that follows a text block (or the turn's start). Returns null
+ *  only when there is no turn at all, which is the pipe path's shape. */
+function openSegment(turn, now) {
+    if (turn === undefined)
+        return null;
+    const last = turn.segments[turn.segments.length - 1];
+    if (last !== undefined && last.closedAt === null)
+        return last;
+    const fresh = { openedAt: now, closedAt: null, reads: 0, edits: 0, others: new Map(), folded: false, spilled: false, headCell: null, cells: [] };
+    turn.segments.push(fresh);
+    return fresh;
+}
+/** R3b — close the turn's open segment, if it has one. Idempotent: text
+ *  arriving twice in a row closes nothing the second time, which is what
+ *  keeps a zero-cell segment from ever existing. */
+function closeSegment(turn, now) {
+    const last = turn?.segments[turn.segments.length - 1];
+    if (last !== undefined && last.closedAt === null)
+        last.closedAt = now;
+}
 /** W20 — the whole-table-replace comparison: the live task block only
  *  redraws when the items actually changed (the task extension's
  *  idempotent shape — an unchanged replace is a no-op, no frame). */
@@ -163,6 +280,11 @@ export class Body {
     #lastThinking = null;
     #lastTool = null;
     #pendingCalls = new Map();
+    /** R3b — cell index → the index of the segment it belongs to, for
+     *  thinking/tool cells; -1 for every other kind. Parallel to #cells,
+     *  because a segment is the COMPOSITOR's bookkeeping and does not
+     *  belong on the cell type the renderer sees. */
+    #cellSegment = [];
     #pipeBuf = ""; // the passthrough's thinking buffer
     /** TUI2-MD ⑤ — the markdown scanner of the message currently
      *  streaming, and the cell index its first block landed at. Null
@@ -320,7 +442,7 @@ export class Body {
         // W14: the turn boundary — the record the fold-hold's release
         // state machine reads; the cell carries the record's index. A9:
         // the user's own words ride the record — the fold's leading chip.
-        this.#turns.push({ ended: false, hasText: false, thoughtSeconds: 0, reads: 0, edits: 0, others: new Map(), words: text, folded: false });
+        this.#turns.push({ ended: false, hasText: false, thoughtSeconds: 0, reads: 0, edits: 0, others: new Map(), words: text, folded: false, segments: [] });
         this.#cells.push({ kind: "user", text, done: true, turn: this.#turns.length - 1 });
         this.#mark();
     }
@@ -335,6 +457,17 @@ export class Body {
         }
         else {
             this.#cells.push({ kind: "thinking", text, done: false, turn: this.#turns.length - 1 });
+            // R3b: thinking is WORK, so it opens a segment too — a turn that
+            // thinks, speaks, then thinks again has two segments, and the
+            // second one's clock starts here rather than at a tool call it
+            // may never make.
+            //
+            // OPEN then STAMP, in that order: the stamp records the segment
+            // the cell belongs to, and a stamp taken first records the
+            // PREVIOUS segment (or none at all) — which left the thinking
+            // row standing outside the fold it should have led.
+            openSegment(this.#turns[this.#turns.length - 1], Date.now());
+            this.#stampSegment();
         }
         this.#mark();
     }
@@ -393,7 +526,19 @@ export class Body {
                 turn.edits += 1;
             else
                 turn.others.set(name, (turn.others.get(name) ?? 0) + 1);
+            // R3b: and into the SEGMENT, which opens here when this is the
+            // first work since the last text block.
+            const seg = openSegment(turn, Date.now());
+            if (seg !== null) {
+                if (name === "read_file")
+                    seg.reads += 1;
+                else if (name === "edit_file")
+                    seg.edits += 1;
+                else
+                    seg.others.set(name, (seg.others.get(name) ?? 0) + 1);
+            }
         }
+        this.#stampSegment();
         this.#mark();
     }
     toolApproval(callId, diff) {
@@ -515,6 +660,11 @@ export class Body {
         const turn = this.#turns[this.#turns.length - 1];
         if (turn !== undefined)
             turn.hasText = true;
+        // R3b: text CLOSES the open segment. This is the boundary design.md
+        // §8 names — "folding at every text boundary changes what commits
+        // and when" — and it is the whole mechanism: a segment is what sits
+        // between two of these.
+        closeSegment(turn, Date.now());
         // TUI2-MD ⑤: assistant body text is MARKDOWN, scanned as it
         // streams. The scanner yields CLOSED blocks (final source, final
         // render) and one OPEN tail block; each becomes a cell, and the
@@ -598,6 +748,9 @@ export class Body {
             return;
         turn.ended = true;
         turn.thoughtSeconds = thoughtSeconds;
+        // R3b: the settle closes the last open segment — the turn's end is
+        // a boundary exactly as a text block is.
+        closeSegment(turn, Date.now());
         // W20: the turn's live task block settles HERE — the ONE recap
         // block for the turn ("`task done · N items · <duration>", the
         // duration clocked compositor-side from the block's first call —
@@ -612,6 +765,25 @@ export class Body {
                 break;
             }
         }
+        // R3g (fable D3, 2026-08-28): an INTERRUPTED tool never receives a
+        // result, so its cell stays `done: false` — and the commit loop
+        // stops at the first cell that is not done. One esc mid-tool
+        // therefore parked the commit pointer for the REST of the
+        // session: every later turn's rows piled up in the live region
+        // and only ever left it through the force-commit cap. The turn's
+        // end is the boundary that closes them, exactly as it closes an
+        // open thinking cell. `reason` is set so the row keeps its words
+        // AND so #segmentHasTrouble holds the turn unfolded — an
+        // interruption is trouble, and law 1.3 says trouble is never
+        // summarised away.
+        for (const c of this.#cells) {
+            if (c.kind === "tool" && !c.done) {
+                c.state = "done";
+                c.reason = "interrupted";
+                c.doneAt = Date.now();
+                c.done = true;
+            }
+        }
         // the QUIET turn: an open thinking cell closes at the boundary —
         // its natural closer is the text's arrival (never comes here — the
         // text-less turn), so without this the fold could never commit AT
@@ -801,6 +973,109 @@ export class Body {
         const idx = this.#collapsed[this.#expandPtr % this.#collapsed.length];
         this.#expandPtr += 1;
         const cell = this.#cells[idx];
+        // R3b — a folded SEGMENT expands to the work it stands for.
+        //
+        // The fold line collapses a run of thinking and tool cells into
+        // one row; without this the run would be unreachable, which is
+        // hiding a durable record behind a summary. The rows are APPENDED
+        // (ADR-0046 — history is never rewritten), exactly as every other
+        // expand in this method does, and they are the cells' OWN renders,
+        // so the expansion cannot drift from what was folded.
+        const seg = this.#segmentOf(idx);
+        const foldTurn = (cell.kind === "thinking" || cell.kind === "tool") && cell.turn >= 0 ? this.#turns[cell.turn] : undefined;
+        if (seg !== null && foldTurn !== undefined && seg.headCell === idx) {
+            const p = palette();
+            const turnsBack = this.#cells.slice(idx + 1).filter((c) => c.kind === "user").length;
+            const back = `${turnsBack} ${turnsBack === 1 ? "turn" : "turns"} back`;
+            const W = this.#opts.width();
+            const ctx = { spinnerI: this.#spinnerI, now: Date.now(), height: this.#opts.height() };
+            // R3b (owner ruling): the ROLLUP is the expansion. TUI2-R1 built
+            // a richer projection of an explore run than a fold line can
+            // carry — the per-tool counts, and one row per tool with its
+            // subjects — and the segment fold would have retired it by
+            // simply arriving first. So the run's own rows are what the key
+            // opens: explore tools group the way the rollup groups them,
+            // everything else renders as itself.
+            // The segment's cells IN ORDER, with consecutive explore tools
+            // grouped exactly as the rollup groups them — a write, a shell
+            // or anything else BREAKS the run, which is TUI2-R1's own rule
+            // and the reason two explore runs on either side of a write
+            // stay two runs. Merging every explore tool of the segment
+            // would have been simpler and would have quietly deleted that
+            // rule.
+            const rows = [];
+            let run = [];
+            const flush = () => {
+                if (run.length === 0)
+                    return;
+                // the same threshold the commit-time rollup uses: below it a
+                // "run" is just some rows
+                if (run.length > 2) {
+                    // the run renders through the ROLLUP's own projection —
+                    // literally the same function the commit path uses — so
+                    // a single-name run keeps W13's row and a mixed one gets
+                    // the exploration line, exactly as they would have if the
+                    // segment had never folded.
+                    const head = run[0];
+                    const saved = head.rolled;
+                    head.rolled = rolledOf(run);
+                    // the run OPENS. The fold's key already asked to see the
+                    // work, so what lands is the same rows `ctrl+r` on the
+                    // run itself would have opened — its title, then its
+                    // detail — never its collapsed row, which would make the
+                    // reader press a second time for what the first press
+                    // was for.
+                    rows.push(`  ${p.dim}${escapeTerminal(rolledTitle(head))}${p.reset}`);
+                    rows.push(...rolledDetail(head, W));
+                    head.rolled = saved;
+                }
+                else {
+                    for (const c of run)
+                        rows.push(...cellComponent(c).render(W, ctx));
+                }
+                run = [];
+            };
+            // R3f — the expansion covers the WHOLE TURN, every segment.
+            //
+            // R3d moved the fold to the turn while the expansion kept
+            // walking one segment, so a turn that spoke between calls
+            // folded to a line claiming `3 reads · 1 edit · 1 shell` whose
+            // key opened only the reads: the edit and the shell were on no
+            // surface and reachable by no key. That is the one thing this
+            // round's own first gate forbids — the work is never
+            // unreachable — and it is worse than never folding, because the
+            // line names work it then withholds.
+            //
+            // A run still BREAKS at a non-explore cell, so the segment
+            // boundaries survive where they carry meaning (the write that
+            // splits two explore runs); they simply no longer bound what
+            // the key can reach.
+            for (const j of foldTurn.segments.flatMap((sg) => sg.cells).sort((a, b) => a - b)) {
+                if (j < idx)
+                    continue;
+                const c = this.#cells[j];
+                if (c.kind === "tool" && isExploreTool(c.name)) {
+                    run.push(c);
+                    continue;
+                }
+                flush();
+                rows.push(...cellComponent(c).render(W, ctx));
+            }
+            flush();
+            // the header NAMES the segment. When the segment is exactly one
+            // explore run, "explored 8 files · 14 searches" is what that run
+            // is called everywhere else in the product, and the header says
+            // the same thing rather than a second wording of it.
+            // the header states what the SEGMENT did, in the fold line's own
+            // terms; each run below states what IT did, in the rollup's. Two
+            // scales, one wording each — the header used to borrow the run's
+            // sentence, which read as the same run twice.
+            // the header names what the FOLD said — the turn's terms — so the
+            // line you pressed and the block it opens agree. It used to name
+            // segment 1's, which contradicted the fold above it.
+            const head = foldTerms(foldTurn.reads, foldTurn.edits, [...foldTurn.others]);
+            return { kind: "appended", lines: [`${p.bold}✦${p.reset} expanded · ${escapeTerminal(head.length === 0 ? "thinking" : head.join(" · "))} · ${back}`, ...rows] };
+        }
         if (cell.kind !== "tool")
             return { kind: "none" };
         if (cell.rolled !== null) {
@@ -814,15 +1089,10 @@ export class Body {
             // TUI2-R1 (B): an EXPLORATION head lists per TOOL — the counts
             // the row showed, then one row per tool with its subjects. The
             // header keeps W15's shape; only the subject changes.
-            if (cell.rolled.parts !== undefined) {
-                const header = `${p.bold}✦${p.reset} expanded · ${escapeTerminal(`explored ${exploreCounts(cell.rolled.parts)}`)} · ${back}`;
-                return { kind: "appended", lines: [header, ...exploreRows(cell.rolled.parts, this.#opts.width())] };
-            }
-            const noun = ROLLUP_NOUN[cell.name] ?? "calls";
-            const header = `${p.bold}✦${p.reset} expanded · ${escapeTerminal(`${displayVerb(cell.name)} ${cell.rolled.count} ${noun}`)} · ${back}`;
+            const rolledHead = rolledTitle(cell);
             return {
                 kind: "appended",
-                lines: [header, ...cell.rolled.targets.map((t) => `  ${p.dim}└ ${escapeTerminal(t)}${p.reset}`)],
+                lines: [`${p.bold}✦${p.reset} expanded · ${escapeTerminal(rolledHead)} · ${back}`, ...rolledDetail(cell, this.#opts.width())],
             };
         }
         let input = {};
@@ -1444,6 +1714,17 @@ export class Body {
         //    edge — the cap scalar is asserted by the gates). W22: the
         //    queue band shrinks the cap by its rows (empty queue → H−4).
         while (liveLines.length > H - 4 - inputExtra - queueRows.length && this.#committed < this.#cells.length) { // V6-3: the content cap H−4 (KC1: −N's extra rows)
+            // R3f: the cell about to be force-committed marks its segment
+            // SPILLED. The rule was written at R3b — "a segment too big for
+            // the screen already has rows in the scrollback that cannot be
+            // taken back, so it renders normally and does not collapse" —
+            // and then never wired: `spilled` had a declaration, an
+            // initializer and a read, and nothing ever set it. The read was
+            // therefore vacuously true, so a 43-call turn force-committed
+            // thirty expanded rows and STILL printed `✦ thought 103s · 43
+            // reads` underneath them, claiming as folded the work standing
+            // visible above it.
+            this.#markSpilled(this.#committed);
             this.#commitCell(this.#committed, W, ctx);
             liveLines = [];
             {
@@ -1620,7 +1901,11 @@ export class Body {
         // unshift: the cells commit oldest-first, so the NEWEST cut lands
         // at the front — the expand pointer's "newest back" walk starts
         // where the user's last key press would aim.
-        if (cell.kind === "tool" && lines.some((l) => l.includes("ctrl+r")))
+        // R3b: a fold HEAD joins the ring too. The test used to demand a
+        // tool cell, and a segment's fold can be emitted at a thinking
+        // cell — which would have left the whole segment unreachable by
+        // the very key its own row advertises.
+        if ((cell.kind === "tool" || this.#segmentOf(i)?.headCell === i) && lines.some((l) => l.includes("ctrl+r")))
             this.#collapsed.unshift(i);
         this.#lineCache[i] = lines;
         const placed = this.#space(i, i > 0 ? this.#lineCache[i - 1] : null, lines);
@@ -1628,6 +1913,89 @@ export class Body {
         this.#committedLines += placed.length;
         this.#committedLinesThisFrame.push(...placed);
     }
+    /** R3b — record which segment the cell just pushed belongs to. Called
+     *  right after the push, so #cells.length-1 is that cell. */
+    #stampSegment() {
+        const turn = this.#turns[this.#turns.length - 1];
+        const idx = turn === undefined ? -1 : turn.segments.length - 1;
+        const at = this.#cells.length - 1;
+        this.#cellSegment[at] = idx;
+        if (turn !== undefined && idx >= 0)
+            turn.segments[idx].cells.push(at);
+    }
+    /**
+     * R3b — does the segment hold a call that FAILED or was DENIED?
+     *
+     * Such a segment does not fold. Routine work is what the fold is for;
+     * a refusal and an error are the opposite of routine, and putting
+     * either behind a key hides the one thing on the screen that most
+     * needs a human's eye. Law 1.3 makes the same call about marks — a
+     * failure keeps its colour AND its words — and this is that rule at
+     * the scale of a run.
+     *
+     * The cost, accepted: a turn that reads twenty files and hits one
+     * denial keeps all twenty rows. The alternative is a screen that says
+     * `✦ thought 3s · 20 reads` while a write was refused inside it.
+     */
+    #segmentHasTrouble(seg) {
+        // R3g (fable, 2026-08-28): a DENIED call is the case this rule
+        // exists for, and it was the one case the predicate could not
+        // see — a denial carrying no `reason` string leaves isError
+        // false and reason null, so `✦ thought 3s · 20 reads` could
+        // stand over a refused write. The verdict is the record of it.
+        return this.#segmentTools(seg).some((c) => c.isError || c.reason !== null || c.verdict?.decision === "denied");
+    }
+    /** R3b — the segment's TOOL cells, in order. */
+    #segmentTools(seg) {
+        const out = [];
+        for (const j of seg.cells) {
+            const c = this.#cells[j];
+            if (c.kind === "tool")
+                out.push(c);
+        }
+        return out;
+    }
+    /** R3f — the cell is leaving the live region under the screen's hard
+     *  cap, so its segment can no longer be represented by a fold. */
+    #markSpilled(i) {
+        const seg = this.#segmentOf(i);
+        if (seg !== null)
+            seg.spilled = true;
+    }
+    /** R3f — did ANY of the turn's segments spill? The fold is the
+     *  TURN's, so one spilled segment makes the whole turn unfoldable:
+     *  a line claiming the turn's counts cannot stand under rows that
+     *  already show part of that same work. */
+    #turnSpilled(turn) {
+        return turn.segments.some((seg) => seg.spilled);
+    }
+    /** R3d — the turn's cells and its trouble, across every segment. */
+    #turnCells(turn) {
+        let n = 0;
+        for (const seg of turn.segments)
+            n += seg.cells.length;
+        return n;
+    }
+    #turnHasTrouble(turn) {
+        return turn.segments.some((seg) => this.#segmentHasTrouble(seg));
+    }
+    /** R3b — how many cells the segment holds. The fold's threshold reads
+     *  it; nothing else needs it, so it is counted rather than tracked. */
+    #segmentCells(seg) {
+        return seg.cells.length;
+    }
+    /** R3b — the segment a committed cell belongs to, or null when it has
+     *  none (a cell of the pipe path, or a kind that is not work). */
+    #segmentOf(i) {
+        const cell = this.#cells[i];
+        if (cell.kind !== "thinking" && cell.kind !== "tool")
+            return null;
+        const turn = cell.turn >= 0 ? this.#turns[cell.turn] : undefined;
+        const si = this.#cellSegment[i];
+        if (turn === undefined || si === undefined || si < 0)
+            return null;
+        return turn.segments[si] ?? null;
+    }
     /** W14 — the fold-hold: a thinking/tool cell of the OPEN quiet turn
      *  (no text yet) does not commit — its committed form is decided at
      *  the release. The cell's OWN turn must be the CURRENT one (a cell
@@ -1640,10 +2008,38 @@ export class Body {
         const turn = cell.turn >= 0 ? this.#turns[cell.turn] : undefined;
         if (turn === undefined || turn !== this.#turns[this.#turns.length - 1])
             return false;
+        // R3b (owner, 2026-08-27) — the hold is the SEGMENT's, not the
+        // quiet turn's.
+        //
+        // W14 held a turn's work only while the turn had produced no text
+        // at all, because the fold existed only for a turn that never
+        // spoke. The owner ruled that a segment folds the moment text
+        // arrives, so the unit whose committed form is undecided is the
+        // SEGMENT: while it is open, its cells must not reach the
+        // scrollback, because a committed row cannot be replaced by the
+        // fold line that is going to stand for it.
+        //
+        // This is exactly the change design.md §8 warned about — "folding
+        // at every text boundary changes what commits and when" — and the
+        // warning is why the hold is stated here, once, rather than
+        // spread across the callers.
+        //
+        // The quiet turn is the same rule seen from one side: its single
+        // segment never closes until the settle, so it holds exactly as
+        // it always did.
+        // R3d: the hold is the TURN's. A turn's work has no committed form
+        // until the turn ends, because one line stands for all of it — and
+        // a row already in the scrollback cannot be replaced by that line.
+        // The force-commit path still overrides this (a turn too big for
+        // the screen spills and renders normally); that is the honest
+        // degradation, marked `spilled`.
+        const seg = this.#segmentOf(i);
+        if (seg !== null)
+            return !turn.ended;
+        // no segment (the pipe path's shape) — W14's original test, kept
+        // so a cell that never got a segment behaves as it used to.
         if (!turn.ended && !turn.hasText)
             return true;
-        // the turn's END releases every hold — the settle is where the run
-        // is decided, and a held cell at settle would never commit at all.
         if (turn.ended)
             return false;
         return this.#growingRun(i);
@@ -1696,15 +2092,78 @@ export class Body {
     #foldOrRollup(cell, i, W, ctx) {
         if (cell.kind === "thinking" || cell.kind === "tool") {
             const turn = cell.turn >= 0 ? this.#turns[cell.turn] : undefined;
-            if (turn !== undefined && turn.ended && !turn.hasText) {
+            const seg = this.#segmentOf(i);
+            // R3b — the SEGMENT folds, and it folds once.
+            //
+            // A cell only reaches here once its segment is closed (the hold
+            // above keeps an open segment out of the commit loop entirely),
+            // so the first cell of a closed segment emits the fold and every
+            // cell after it renders nothing. `folded` is the latch: without
+            // it the second cell would emit a second fold line for the same
+            // work.
+            //
+            // A SPILLED segment is the honest degradation. The force-commit
+            // path does not consult the hold — the screen's hard cap wins —
+            // so a segment too big for the screen already has rows in the
+            // scrollback that cannot be taken back. It renders normally and
+            // says nothing false; it simply does not collapse.
+            // R3b — a ONE-CELL segment does not fold. Collapsing one row into
+            // one row gains no space and costs the row's subject: `✦ thought
+            // 0s · 1 shell` says strictly less than `shell make build ·
+            // exit 0`. The fold exists to stop a screen filling with work
+            // rows, and one row is not that.
+            // R3d (owner, 2026-08-28) — a segment folds only on a QUIET turn.
+            //
+            // R3b folded every closed segment, and in use that was wrong for
+            // a reason the design questions never surfaced: a model narrates
+            // between calls, so a turn is not two or three segments, it is
+            // one per tool. Every call became its own `✦ thought 2s · 1 read`
+            // row — the same row count the fold exists to remove, now saying
+            // less. The screen is not improved by summarising one thing.
+            //
+            // The turn's ONE line (renderRecap, R3d) carries the work now,
+            // which is where it always belonged: it is already emitted once
+            // per turn, in the right place, and it only needed to say what
+            // the turn DID rather than "43 tools".
+            //
+            // The quiet turn keeps its fold because there IS no recap line
+            // to carry it: a turn with no text is the fold, and W14's gates
+            // pin that shape.
+            if (turn !== undefined && seg !== null && seg.closedAt !== null && !this.#turnSpilled(turn) && turn.ended && this.#turnCells(turn) >= 2 && !this.#turnHasTrouble(turn)) {
                 if (!turn.folded) {
+                    seg.folded = true;
+                    seg.headCell = i;
                     turn.folded = true;
                     // A9 (ruling R2, mock A): the user chip rides the fold —
-                    // the words take the fold's width budget (turnFold is
-                    // W-aware — the ONE row never trips invariant ①).
+                    // but ONLY on a quiet turn, where the fold stands for the
+                    // whole turn and the chip has nowhere else to be. In a
+                    // turn WITH text the chip cell commits on its own, so a
+                    // fold that repeated the words would put the user's line
+                    // on screen twice. The words take the fold's width budget
+                    // (turnFold is W-aware — the ONE row never trips
+                    // invariant ①).
+                    const quiet = turn.ended && !turn.hasText;
+                    // R3g (fable, 2026-08-28) — DECLARED SUPERSESSION: both
+                    // branches read the SAME number now, `thoughtSeconds`,
+                    // the measure the kernel took and handed to endTurn.
+                    // The non-quiet branch used to re-derive a wall clock
+                    // from the segment's opening and print it under the word
+                    // "thought" — a different quantity wearing the same
+                    // label: a turn that thought 1s and then ran a 40s shell
+                    // said "thought 41s". The fold only ever renders after
+                    // endTurn (the gate below requires `turn.ended`), so the
+                    // honest number is always available by the time it runs.
+                    //
+                    // The terms are the TURN's, not the segment's: R3d folds
+                    // a turn's work into ONE line wherever the first work
+                    // lands. A per-segment line put a row on screen for every
+                    // break in the model's narration, which on a chatty model
+                    // is one row per tool — the row count the fold exists to
+                    // remove.
+                    const seconds = turn.thoughtSeconds;
                     return turnFold({
-                        words: turn.words,
-                        thoughtSeconds: turn.thoughtSeconds,
+                        words: quiet ? turn.words : "",
+                        thoughtSeconds: seconds,
                         reads: turn.reads,
                         edits: turn.edits,
                         others: [...turn.others],
@@ -1766,7 +2225,14 @@ export class Body {
             // text's release they are — the natural loop commits the run in
             // one frame; the force-commit's early commits degrade to the
             // individual rows, the members render normally after).
-            if (!members.every((c) => c.done))
+            // R3g (2026-08-28): ...and no member is in TROUBLE. A rollup
+            // says "explored 3 paths" — a sentence a failed or interrupted
+            // call makes false, and the row it replaces was the only place
+            // that failure had words. Law 1.3 at the scale of a run: the
+            // same rule #segmentHasTrouble applies to the fold. Found when
+            // R3g's interrupt-closing made an aborted call `done`, which
+            // let a run it never finished roll up as if it had.
+            if (!members.every((c) => c.done && !c.isError && c.reason === null))
                 return cellComponent(cell).render(W, ctx);
             this.#rolledHeads.add(head);
             let total = 0;
@@ -1775,37 +2241,7 @@ export class Body {
             // exploration row's counts and its expanded list both read them.
             // A search's subject is the PATTERN it looked for (quoted); a
             // read's or a list's is the path it named.
-            const parts = [];
-            for (const m of members) {
-                // the lines count, excluding the tool's OWN truncation note
-                // (read_file's "… N more lines") — the per-cell meta's rule
-                const noteAt = m.resultText.lastIndexOf("\n… ");
-                const shown = noteAt >= 0 ? m.resultText.slice(0, noteAt) : m.resultText;
-                const rows = shown.split("\n");
-                total += rows[rows.length - 1] === "" ? rows.length - 1 : rows.length;
-                let input = {};
-                try {
-                    input = JSON.parse(m.inputFull);
-                }
-                catch {
-                    // the full JSON is always parseable (stringified at
-                    // toolStart) — the empty fallback never fires
-                }
-                const target = toolTarget(m.name, input);
-                targets.push(target.split("/").pop() ?? target);
-                const subject = m.name === "search_text" ? `"${String(input.pattern ?? "")}"` : target;
-                const part = parts.find((x) => x.name === m.name);
-                if (part === undefined)
-                    parts.push({ name: m.name, subjects: [subject] });
-                else
-                    part.subjects.push(subject);
-            }
-            const first = members[0];
-            const last = members[members.length - 1];
-            const elapsed = first.startedAt !== null && last.doneAt !== null ? ((last.doneAt - first.startedAt) / 1000).toFixed(1) : "?";
-            // TUI2-R1 (B): `parts` rides ONLY a mixed run — a single-name
-            // run keeps W13's row, byte for byte (the generalization adds).
-            cell.rolled = { count: members.length, lines: total, elapsed, targets, ...(parts.length > 1 ? { parts } : {}) };
+            cell.rolled = rolledOf(members);
             return cellComponent(cell).render(W, ctx);
         }
         // a MEMBER of an already-rolled run → [] (its rows live in the
@@ -2318,6 +2754,32 @@ export class Body {
     /** Invariant ①: every emitted line fits the width — a violation is a
      *  CRASH with the diagnostic, never a silent truncate. */
     #checked(line, W) {
+        // Invariant ①b (R3f): a ROW IS ONE PHYSICAL ROW.
+        //
+        // The defect this catches shipped in 0.16.6 and smashed the
+        // composer. `escapeTerminal` keeps `\n` (it strips C0 except tab
+        // and newline), and `charWidth(0x0A)` is 1 — so a newline counts as
+        // ONE CELL in `visibleWidth`, and every width check in the product,
+        // invariant ① included, waves a multi-line string through as a
+        // single row of legal width. `#emitDiff` then paints it as
+        // `CUP(row,1) + EL + content`, the terminal's ONLCR moves the
+        // cursor down at the newline, and the tail lands on whatever
+        // physical row is there — the box rail, the input row. The diff
+        // then adopts `desired` as the screen's truth, so the corruption
+        // SURVIVES: the self-healing property this renderer is built on
+        // ("a wrong row is repaired by the next frame, because the
+        // difference includes it") is exactly what a lying `#screen`
+        // breaks.
+        //
+        // Width was never the whole invariant — it was the half we
+        // noticed. A row that occupies two physical rows violates the
+        // geometry as surely as one that overruns the width, and it does
+        // so INVISIBLY to a width check. `\r` is here for the same reason
+        // (it moves the cursor to column 1).
+        const bad = /[\n\r]/.exec(line);
+        if (bad !== null) {
+            throw new Error(`kiso-tui invariant ①b violated: a row containing ${JSON.stringify(bad[0])} was about to be emitted — a row must be ONE physical row, and the width check cannot see this (charWidth counts a newline as one cell) — ${JSON.stringify(line.slice(0, 80))}`);
+        }
         const w = visibleWidth(line);
         if (w > W) {
             throw new Error(`kiso-tui invariant ① violated: a line of visible width ${w} > ${W} was about to be emitted — ${JSON.stringify(line.slice(0, 80))}`);

package/dist/render.d.ts

@@ -144,15 +144,45 @@ export declare function renderStatusLine(turn: number, usage: RunUsage, ctxRatio
  *  (zero tokens): wall seconds, tool counts, usage, cache hit %, ctx left.
  */
 export interface RecapStats {
+    /** The TURN's wall seconds — what it took, start to settle. Named
+     *  `took` on the row since R3g: it was labelled "thought" while the
+     *  fold line one row above printed the kernel's MEASURED thinking
+     *  seconds under that same word, so a turn that thought for 1s and
+     *  then ran a 40s shell had two different numbers both called
+     *  "thought". */
     readonly seconds: number;
-    readonly tools: number;
-    readonly edits: number;
+    /**
+     * R3g — THE WORK TERMS ARE OPTIONAL, AND kiso NO LONGER PASSES THEM.
+     *
+     * The turn's work is said ONCE, by the compositor's fold line, in
+     * the place the work happened and with the key that reopens it. This
+     * row used to repeat it a few rows below — the same terms, a
+     * different clock — which is the doubling the owner called out.
+     *
+     * The fields stay, and still render when a caller supplies them, so
+     * an embedder of this package sees the byte-for-byte historical row.
+     * A turn whose work did NOT fold (it spilled past the live region,
+     * or it hit trouble) keeps every one of its rows on screen, so the
+     * work is not lost by their absence — it is standing right there.
+     */
+    readonly tools?: number;
+    readonly edits?: number;
+    /** The turn's work BY TOOL, in first-call order (R3d). */
+    readonly byTool?: readonly [string, number][];
     readonly usage: RunUsage;
     /** R-C item 4: the per-turn cache miss (min(prevIn, in) − cacheRead),
      *  passed only when above the noise floor — the re-sent-uncached
      *  prefix. Absent → the recap bytes stay the historical form. */
     readonly missed?: number;
     readonly ctxLeftPct: number | null;
+    /** R3g — the terminal's width. The recap is the ONE row on the screen
+     *  that was never measured: it is written raw, so a line longer than
+     *  the terminal wrapped, and the second physical row is a fragment
+     *  matching no cell format (the v2v lint reads it as interleaving).
+     *  R3g's verb+noun terms made an 80-column wrap ordinary rather than
+     *  rare, which is how it surfaced. Absent → uncut, the historical
+     *  bytes, for the callers that render into no terminal. */
+    readonly width?: number;
     /** W19 — the mode the turn ran under. Under "plan" the recap becomes
      *  the way-forward row (the claimed shape): a plan turn's currency is
      *  the plan, not the tool count — the timing and tool-count parts

package/dist/render.js

@@ -14,6 +14,8 @@
  * session line).
  */
 import { escapeTerminal, foldResult, foldThinking, kUnit, palette } from "@vincemakes/kiso-tui-cells/render";
+import { foldTerms, widthCut } from "@vincemakes/kiso-tui-cells/components";
+import { visibleWidth } from "@vincemakes/kiso-tui-cells/width";
 export * from "@vincemakes/kiso-tui-cells/render";
 /**
  * Render one event. `text` may be a continuation (text_delta appends to the
@@ -163,6 +165,23 @@ export function renderStatusLine(turn, usage, ctxRatio, faux = false) {
         return null;
     return `[turn ${turn} · ${parts.join(" · ")}]`;
 }
+/** R3d — the per-tool terms of a settled turn, in the fold line's own
+ *  vocabulary (ROLLUP_NOUN plurals, zero terms dropped). One wording for
+ *  "what a run did", wherever it is said. */
+function recapWork(byTool) {
+    let reads = 0;
+    let edits = 0;
+    const others = [];
+    for (const [name, n] of byTool) {
+        if (name === "read_file")
+            reads += n;
+        else if (name === "edit_file")
+            edits += n;
+        else
+            others.push([name, n]);
+    }
+    return foldTerms(reads, edits, others);
+}
 export function renderRecap(s) {
     const p = palette();
     // W19: under plan the recap is the way out of the mode — the header
@@ -176,7 +195,21 @@ export function renderRecap(s) {
         const parts = ["plan ready", "/mode default executes", "/mode accept-edits auto-approves edits"];
         return `${p.bold}✦${p.reset} ${parts.join(" · ")}\n`;
     }
-    const parts = [`${s.seconds}s`, `${s.tools} tool${s.tools === 1 ? "" : "s"}${s.edits > 0 ? ` (${s.edits} edit${s.edits === 1 ? "" : "s"})` : ""}`];
+    // R3d (owner, 2026-08-28): the turn's ONE line says what the turn DID.
+    //
+    // The per-segment folds this replaces put a row on screen for every
+    // break in the model's narration — and a model that narrates between
+    // every call turned that into one row per tool, which is the row
+    // count the fold was built to remove, wearing a summary's clothes.
+    // The turn already had exactly one line in exactly the right place;
+    // it was just too coarse to be worth reading.
+    const edits = s.edits ?? 0;
+    const work = s.byTool !== undefined && s.byTool.length > 0
+        ? recapWork(s.byTool)
+        : s.tools !== undefined && s.tools > 0
+            ? [`${s.tools} tool${s.tools === 1 ? "" : "s"}${edits > 0 ? ` (${edits} edit${edits === 1 ? "" : "s"})` : ""}`]
+            : [];
+    const parts = [`took ${s.seconds}s`, ...work];
     if (s.usage.known) {
         const seg = `${s.usage.in !== null ? `in ${kUnit(s.usage.in)}` : ""}${s.usage.in !== null && s.usage.out !== null ? " " : ""}${s.usage.out !== null ? `out ${kUnit(s.usage.out)}` : ""}`;
         if (seg !== "")
@@ -193,7 +226,17 @@ export function renderRecap(s) {
     }
     if (s.ctxLeftPct !== null)
         parts.push(`ctx left ~${Math.round(s.ctxLeftPct)}%`);
-    return `${p.bold}✦${p.reset} ${parts.join(" · ")}\n`;
+    // R3g: ONE physical row, at any width — the same rule every other row
+    // in the product obeys. The cut is the honest "…": the recap said
+    // more than fits, and says so.
+    const line = parts.join(" · ");
+    // R3g: the floor is the renderer's own guard against a caller that
+    // hands it a degenerate width (a PTY with no winsize reports 0). A
+    // recap cut to one character is worse than one that wraps.
+    if (s.width !== undefined && s.width >= 20 && visibleWidth(`✦ ${line}`) > s.width) {
+        return `${p.bold}✦${p.reset} ${widthCut(line, Math.max(1, s.width - 3))}…\n`;
+    }
+    return `${p.bold}✦${p.reset} ${line}\n`;
 }
 /** One-line summary of a session, for `kiso sessions`. */
 export function renderSessionLine(meta) {

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@vincemakes/kiso-tui",
-	"version": "0.16.5",
+	"version": "0.16.7",
 	"description": "kiso tui — the pure terminal layer (cell renderer, dock, raw editor, diff, palette). Zero runtime dependencies: input is data, output is bytes.",
 	"type": "module",
 	"license": "MIT",
@@ -35,6 +35,6 @@
 	},
 	"homepage": "https://github.com/vincemakes/kiso/tree/main/packages/tui#readme",
 	"dependencies": {
-		"@vincemakes/kiso-tui-cells": "0.16.5"
+		"@vincemakes/kiso-tui-cells": "0.16.7"
 	}
 }