@vincemakes/kiso-tui 0.16.8 → 0.17.0

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, foldCountsObjects, foldTerms, focusToken, exploreRows, foldLine, isExploreTool, pendingQueueRows, statusLine, turnFold, visibleWidth, } from "./components.js";
+import { Container, ROLLUP_NOUN, MOTION_FRAMES, MdStream, bodySpacing, boxBottom, boxTop, cellComponent, exploreCounts, foldCountsObjects, foldTerms, focusToken, exploreRows, foldLine, isExploreTool, pendingQueueRows, statusLine, stretchLine, turnFold, visibleWidth, twinkleFrame, } 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,11 @@ 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)
+/** R3i — how many calls in flight the act window shows at once. Beyond
+ *  it the block would grow with the model's parallelism, which is the
+ *  same unbounded height the projection exists to remove; the rest are
+ *  COUNTED, never dropped silently. */
+const LIVE_ACT_HEADS = 3;
 /** 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) {
@@ -174,7 +179,7 @@ function openSegment(turn, now) {
     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(), seen: new Map(), folded: false, spilled: false, headCell: null, cells: [] };
+    const fresh = { openedAt: now, closedAt: null, reads: 0, edits: 0, others: new Map(), seen: new Map(), thinkingMs: 0, thinkingSince: null, folded: false, spilled: false, headCell: null, cells: [] };
     turn.segments.push(fresh);
     return fresh;
 }
@@ -183,8 +188,21 @@ function openSegment(turn, now) {
  *  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;
+    if (last === undefined || last.closedAt !== null)
+        return;
+    stopThinking(last, now);
+    last.closedAt = now;
+}
+/** R3i — the segment's thinking clock stops. It runs from the first
+ *  thinking delta of a stretch and stops at the first NON-thinking
+ *  event, the same rule the CLI applies to the turn — so `thought Ns`
+ *  is thinking time at every scale and never a wall clock wearing the
+ *  word (the R3g defect, kept closed at the new scale). */
+function stopThinking(seg, now) {
+    if (seg === undefined || seg.thinkingSince === null)
+        return;
+    seg.thinkingMs += Math.max(0, now - seg.thinkingSince);
+    seg.thinkingSince = null;
 }
 /** W20 — the whole-table-replace comparison: the live task block only
  *  redraws when the items actually changed (the task extension's
@@ -466,7 +484,20 @@ export class Body {
             // 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());
+            const seg = openSegment(this.#turns[this.#turns.length - 1], Date.now());
+            // R3i: the stretch's thinking clock starts HERE — at the first
+            // delta of this stretch, the same moment the CLI starts the
+            // turn's — and stops at the next non-thinking event below.
+            if (seg !== null && seg.thinkingSince === null)
+                seg.thinkingSince = Date.now();
+            // R3i: and the beat starts HERE. Law 1.4 says "a running thought
+            // twinkles", and `#armSpinner`'s own predicate has always
+            // included an open thinking cell — but the only caller was
+            // `toolRunning`, so a stretch that thought and did nothing else
+            // never moved at all. The line's seconds are a frame-time
+            // derivation, so without the beat they also never ticked: the
+            // row read `thinking 0s` for as long as the model thought.
+            this.#armSpinner();
             this.#stampSegment();
         }
         this.#mark();
@@ -474,6 +505,10 @@ export class Body {
     thinkingEnd() {
         const last = this.#cells[this.#cells.length - 1];
         if (last !== undefined && last.kind === "thinking" && !last.done) {
+            // R3i: every closer — text, a notice, a terminal label, the next
+            // turn — routes through here, so the clock cannot keep running
+            // past the thing that ended it.
+            stopThinking(this.#turns[this.#turns.length - 1]?.segments.at(-1), Date.now());
             last.done = true;
             this.#lastThinking = last.text;
             if (!this.#isActive())
@@ -527,6 +562,18 @@ export class Body {
             // of a target the term has already counted; an ACT-counting
             // tool (a search, a shell command) always bumps, because two
             // searches for the same pattern really are two searches.
+            // R3i phase 5 — an ANSWER is words, and words do not fold (law
+            // 1.7). `ask_user` closes the open stretch exactly as prose
+            // does, and never joins one: absorbed into `1 × ask_user`,
+            // what the human said would be gone from the screen — and the
+            // one thing a summary must not do is speak for the human.
+            if (name === "ask_user") {
+                // no stamp: it belongs to NO stretch, so no fold can speak
+                // for it — the same standing a block of prose has.
+                closeSegment(turn, Date.now());
+                this.#mark();
+                return;
+            }
             const target = foldCountsObjects(name) ? toolTarget(name, input) : null;
             const bump = (rec) => {
                 if (target === null)
@@ -554,6 +601,9 @@ export class Body {
             // file read once per segment is one file in each segment's
             // terms and one file in the turn's.
             const seg = openSegment(turn, Date.now());
+            // R3i: a tool call is a NON-thinking event — the clock stops,
+            // exactly as the CLI's does at the same boundary.
+            stopThinking(seg ?? undefined, Date.now());
             if (seg !== null && bump(seg)) {
                 if (name === "read_file")
                     seg.reads += 1;
@@ -1075,7 +1125,20 @@ export class Body {
             // 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)) {
+            // DECLARED SUPERSESSION (R3i phase 3) — the expansion covers THIS
+            // STRETCH, and only this stretch.
+            //
+            // R3f widened it to the whole turn, and had to: R3d had made
+            // the fold the TURN's while the expansion still walked one
+            // segment, so a line claiming `read 3 files · edited 1 file`
+            // opened only the reads — work named and then withheld, the one
+            // thing this file's first gate forbids. R3i moves the fold back
+            // to the stretch, so the pairing is exact again: every stretch
+            // has its OWN line and its own key, and each key opens the work
+            // its line named. Keeping the turn walk would break the same
+            // rule from the other side — two lines, each opening
+            // everything, each header describing rows the other also shows.
+            for (const j of seg.cells) {
                 if (j < idx)
                     continue;
                 const c = this.#cells[j];
@@ -1098,8 +1161,26 @@ export class Body {
             // 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] };
+            const t = this.#stretchTerms(seg);
+            const head = foldTerms(t.calls.find(([n]) => n === "read_file")?.[1] ?? 0, t.calls.find(([n]) => n === "edit_file")?.[1] ?? 0, t.calls.filter(([n]) => n !== "read_file" && n !== "edit_file"));
+            // R3i phase 4 — THE FOOTER TELLS THE TRUTH ABOUT THIS PATH.
+            //
+            // The rows come from the rollup's own projection, whose last
+            // row reads `└ ctrl+r collapses` — true where it was written
+            // (the LIVE toggle, which really does close again) and false
+            // here. A committed row is ink: ADR-0046 forbids rewriting
+            // history, so nothing about this block can be taken back. The
+            // next press opens the NEXT fold, and the row now says so.
+            const closing = rows.length > 0 && /ctrl\+r collapses/.test(rows[rows.length - 1] ?? "");
+            const body = closing ? rows.slice(0, -1) : rows;
+            return {
+                kind: "appended",
+                lines: [
+                    `${p.bold}✦${p.reset} expanded · ${escapeTerminal(head.length === 0 ? "thinking" : head.join(" · "))} · ${back}`,
+                    ...body,
+                    `  ${p.dim}└ end of expansion · ctrl+r opens the next fold${p.reset}`,
+                ],
+            };
         }
         if (cell.kind !== "tool")
             return { kind: "none" };
@@ -1574,6 +1655,118 @@ export class Body {
             this.render();
     }
     // ---- the one writer ----
+    /**
+     * R3i phase 2 — THE LIVE PROJECTION.
+     *
+     * One definition, called from the natural path and from inside the
+     * force-commit loop, because two copies of "what the live region
+     * looks like" is two answers to one question.
+     *
+     * The change this phase makes, and the ONLY one: the cells of the
+     * OPEN stretch no longer each hold a row. The stretch is one line —
+     * the same line the settle will keep, in the present tense — plus
+     * the calls actually in flight. A completed call renders nothing;
+     * its count rides the line.
+     *
+     * What it fixes: a 28-call turn used to spend 28 rows of a 30-row
+     * live region, so overflow was the NORM on real turns rather than
+     * the edge — and a turn that overflows may not fold (R3f: a line
+     * cannot claim rows already in the scrollback), which is why the
+     * fold missed exactly the turns it exists for. The block's height
+     * no longer depends on the call count at all.
+     *
+     * What it does NOT change: nothing about what commits or when. The
+     * hold is untouched, the force-commit cap is untouched, and the
+     * settle still produces the same fold it did before. That is the
+     * charter's line between this phase and the next.
+     */
+    #liveProjection(W, ctx) {
+        const out = [];
+        const focus = this.#focusIndex();
+        const turn = this.#turns[this.#turns.length - 1];
+        const open = turn !== undefined && !turn.ended ? (turn.segments[turn.segments.length - 1] ?? null) : null;
+        const openSeg = open !== null && open.closedAt === null ? open : null;
+        let prev = this.#committed > 0 ? this.#lineCache[this.#committed - 1] : null;
+        let stretchDrawn = false;
+        let runningShown = 0;
+        let runningHidden = 0;
+        for (let i = this.#committed; i < this.#cells.length; i += 1) {
+            const cell = this.#cells[i];
+            const inOpen = openSeg !== null && openSeg.cells.includes(i);
+            if (inOpen) {
+                // the stretch's ONE line, drawn once, at its first cell
+                if (!stretchDrawn) {
+                    stretchDrawn = true;
+                    const rows = stretchLine({ ...this.#stretchTerms(openSeg), phase: this.#stretchPhase(openSeg), mark: twinkleFrame(this.#spinnerI) }, W);
+                    out.push(...this.#space(i, prev, rows));
+                    prev = rows;
+                }
+                // a DONE cell's row is gone; its count is on the line above.
+                // A cell still in flight keeps its row and its output —
+                // hiding the work in flight would be the opposite defect.
+                const flight = cell.kind === "tool" && !cell.done;
+                if (!flight)
+                    continue;
+                if (runningShown >= LIVE_ACT_HEADS) {
+                    runningHidden += 1;
+                    continue;
+                }
+                runningShown += 1;
+            }
+            const rows = cellComponent(cell).render(W, ctx);
+            // the head row carries the affordance; the tint lands on it and
+            // nowhere else, which is what makes "exactly one" structural
+            if (i === focus && rows.length > 0)
+                rows[0] = focusToken(rows[0], W);
+            out.push(...this.#space(i, prev, rows));
+            prev = rows;
+        }
+        if (runningHidden > 0) {
+            const p = palette();
+            out.push(`  ${p.dim}└ +${runningHidden} more running${p.reset}`);
+        }
+        return out;
+    }
+    /** R3i — the open stretch's phase. It is THINKING while a thinking
+     *  cell of it is still open and no call has started; otherwise it is
+     *  ACTING. The tense follows the phase, and the phase is what the
+     *  human is watching happen. */
+    #stretchPhase(seg) {
+        return seg.thinkingSince !== null && seg.reads === 0 && seg.edits === 0 && seg.others.size === 0 ? "thinking" : "acting";
+    }
+    /** R3i — the open stretch's terms, in the shape the line renders. */
+    #stretchTerms(seg) {
+        const ms = seg.thinkingMs + (seg.thinkingSince === null ? 0 : Math.max(0, Date.now() - seg.thinkingSince));
+        // R3i: a call in TROUBLE does not contribute to the work terms.
+        // The counts are taken at toolStart, before the outcome is known,
+        // so a denied write would otherwise fold as `wrote 1 file` beside
+        // the clause admitting it was refused — the line saying, in one
+        // breath, that the file was written and that it was not. The
+        // trouble clause is where those calls are counted.
+        const bad = new Map();
+        for (const j of seg.cells) {
+            const c = this.#cells[j];
+            if (c === undefined || c.kind !== "tool" || !this.#cellInTrouble(j))
+                continue;
+            bad.set(c.name, (bad.get(c.name) ?? 0) + 1);
+        }
+        const net = (name, n) => Math.max(0, n - (bad.get(name) ?? 0));
+        const calls = [];
+        if (net("read_file", seg.reads) > 0)
+            calls.push(["read_file", net("read_file", seg.reads)]);
+        if (net("edit_file", seg.edits) > 0)
+            calls.push(["edit_file", net("edit_file", seg.edits)]);
+        for (const [name, n] of seg.others)
+            if (net(name, n) > 0)
+                calls.push([name, net(name, n)]);
+        const targets = [];
+        for (const j of seg.cells) {
+            const c = this.#cells[j];
+            if (c !== undefined && c.kind === "tool")
+                targets.push(toolTarget(c.name, JSON.parse(c.inputFull)));
+        }
+        return { thoughtSeconds: Math.round(ms / 1000), calls, targets, trouble: this.#segmentTroubleTerms(seg) };
+    }
     /** The live region's scalar — the unit tests assert the cap directly
      *  (the e2e gate pins the screen consequence). W11: the formula's
      *  blanks are join artifacts — the count includes them (they are real
@@ -1721,18 +1914,7 @@ export class Body {
             // by construction), so the marker can never point at a cell the
             // key would not take — which is the only way a focus marker is
             // worth having.
-            const focus = this.#focusIndex();
-            let prev = this.#committed > 0 ? this.#lineCache[this.#committed - 1] : null;
-            for (let i = this.#committed; i < this.#cells.length; i += 1) {
-                const cell = this.#cells[i];
-                const rows = cellComponent(cell).render(W, ctx);
-                // the head row carries the affordance; the tint lands on it and
-                // nowhere else, which is what makes "exactly one" structural
-                if (i === focus && rows.length > 0)
-                    rows[0] = focusToken(rows[0], W);
-                liveLines.push(...this.#space(i, prev, rows));
-                prev = rows;
-            }
+            liveLines = this.#liveProjection(W, ctx);
         }
         // 3. the FORCE commits — the live region's hard cap H−1: overflow
         //    commits the oldest live cell UNCONDITIONALLY (the one sharp
@@ -1751,21 +1933,9 @@ export class Body {
             // visible above it.
             this.#markSpilled(this.#committed);
             this.#commitCell(this.#committed, W, ctx);
-            liveLines = [];
-            {
-                // TUI2-R2 ⑤: the focus re-derives after a commit — the cell it
-                // pointed at may have just left the live region
-                const focus = this.#focusIndex();
-                let prev = this.#committed > 0 ? this.#lineCache[this.#committed - 1] : null;
-                for (let i = this.#committed; i < this.#cells.length; i += 1) {
-                    const cell = this.#cells[i];
-                    const rows = cellComponent(cell).render(W, ctx);
-                    if (i === focus && rows.length > 0)
-                        rows[0] = focusToken(rows[0], W);
-                    liveLines.push(...this.#space(i, prev, rows));
-                    prev = rows;
-                }
-            }
+            // TUI2-R2 ⑤: the focus re-derives after a commit — the cell it
+            // pointed at may have just left the live region.
+            liveLines = this.#liveProjection(W, ctx);
         }
         // 4. the geometry — the live region's first row:
         //    liveTop = min(totalCommitted, H - liveRows) + 1 — the screen
@@ -1905,7 +2075,29 @@ export class Body {
     #space(i, prev, rows) {
         if (i > 0 && this.#cells[i]?.kind === "md" && this.#cells[i - 1]?.kind === "md")
             return rows;
-        return bodySpacing(prev, rows);
+        return bodySpacing(this.#lastDrawn(i, prev), rows);
+    }
+    /**
+     * R3i — the previous DRAWN sibling, not the previous cell.
+     *
+     * The spacing formula reads what stood above; a cell that rendered
+     * nothing did not stand above anything. Since R3d whole families of
+     * cells render `[]` — the members a fold speaks for — and the
+     * formula was reading that empty array as "a zero-row sibling", so a
+     * multi-row block following a fold lost the blank that belongs above
+     * it. The defect predates this round (any folded turn followed by a
+     * raw block has it); R3i's projection is what finally put a test on
+     * the path.
+     */
+    #lastDrawn(i, prev) {
+        if (prev !== null && prev.length > 0)
+            return prev;
+        for (let j = i - 1; j >= 0; j -= 1) {
+            const cached = this.#lineCache[j];
+            if (cached !== null && cached !== undefined && cached.length > 0)
+                return cached;
+        }
+        return prev;
     }
     /** Commit the cell at index i: render + cache its lines (immutable —
      *  the force-committed form freezes at the current render), advance
@@ -1962,6 +2154,67 @@ export class Body {
      * denial keeps all twenty rows. The alternative is a screen that says
      * `✦ thought 3s · 20 reads` while a write was refused inside it.
      */
+    /**
+     * R3i — the trouble the stretch met, as the line's own terms.
+     *
+     * Law 1.3: an outcome is stated in WORDS, "the only form that
+     * survives a pipe". So the kind is a different word, never a
+     * different colour — `2 failed`, `1 denied`, `1 interrupted` — and
+     * the failure's identity rides with it. In this phase the terms are
+     * only DRAWN (the live line names trouble the moment it happens);
+     * whether trouble still blocks the fold is the next phase's ruling.
+     */
+    /** R3i — is this cell one the fold must not count as work done? */
+    #cellInTrouble(i) {
+        const c = this.#cells[i];
+        if (c === undefined || c.kind !== "tool")
+            return false;
+        return c.isError || c.reason !== null || c.verdict?.decision === "denied";
+    }
+    #segmentTroubleTerms(seg) {
+        let failed = 0;
+        let denied = 0;
+        let interrupted = 0;
+        let what = "";
+        for (const j of seg.cells) {
+            const c = this.#cells[j];
+            if (c === undefined || c.kind !== "tool")
+                continue;
+            // WHICH call, and WHY. The target alone answers the first and
+            // not the second, and for a policy denial the second is the
+            // whole point: `sub/out.txt` does not tell a human that plan
+            // mode is read-only, and that sentence is the one they act
+            // on. Law 1.3's own words — an outcome is stated in words —
+            // and the ladder cuts this clause last, so it degrades to the
+            // target before it disappears.
+            const named = () => {
+                const t = toolTarget(c.name, JSON.parse(c.inputFull));
+                const why = c.verdict?.reason ?? c.reason;
+                return why === null || why === undefined || why === "" || why === "interrupted" ? t : `${t} (${why})`;
+            };
+            if (c.verdict?.decision === "denied" || (c.reason !== null && c.reason !== "interrupted" && /denied/i.test(c.reason))) {
+                denied += 1;
+                if (what === "")
+                    what = named();
+            }
+            else if (c.reason === "interrupted") {
+                interrupted += 1;
+            }
+            else if (c.isError || c.reason !== null) {
+                failed += 1;
+                if (what === "")
+                    what = named();
+            }
+        }
+        const out = [];
+        if (failed > 0)
+            out.push(["failed", failed, what]);
+        if (denied > 0)
+            out.push(["denied", denied, what]);
+        if (interrupted > 0)
+            out.push(["interrupted", interrupted, ""]);
+        return out;
+    }
     #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
@@ -2030,6 +2283,11 @@ export class Body {
         const cell = this.#cells[i];
         if (cell.kind !== "thinking" && cell.kind !== "tool")
             return false;
+        // R3i phase 5: an answered question is WORDS (law 1.7). It commits
+        // when it is done, like prose, and is never held for a fold that
+        // is not going to speak for it.
+        if (cell.kind === "tool" && cell.name === "ask_user")
+            return false;
         const turn = cell.turn >= 0 ? this.#turns[cell.turn] : undefined;
         if (turn === undefined || turn !== this.#turns[this.#turns.length - 1])
             return false;
@@ -2052,15 +2310,27 @@ export class Body {
         // 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
+        // DECLARED SUPERSESSION (R3i phase 3, owner-ruled) — THE HOLD IS
+        // THE SEGMENT'S AGAIN.
+        //
+        // R3d had made it the TURN's, so a turn's whole work waited on the
+        // settle and every one of its counts then landed on ONE line above
+        // all of its prose. The shape the owner asked for is one summary
+        // per stretch, standing with the prose that stretch led to — which
+        // requires a stretch to commit when its own text arrives.
+        //
+        // R3d's stated reason for leaving the segment was R3b's disease (a
+        // chatty model turning every call into its own `✦ thought 2s ·
+        // 1 read` row); the cures are the two rules R3b never had — a fold
+        // must absorb at least two rows, and a stretch of exactly one call
+        // names its TARGET rather than its count.
+        //
+        // The force-commit path still overrides this (a stretch 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;
+            return seg.closedAt === null;
         // 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)
@@ -2154,45 +2424,44 @@ export class Body {
             // 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) {
+            // DECLARED SUPERSESSION (R3i phase 3, owner-ruled) — THE FOLD IS
+            // THE SEGMENT'S, AND TROUBLE DOES NOT STOP IT.
+            //
+            // ① the SEGMENT. R3d folded the turn; the owner's shape is one
+            //    summary per stretch of work, standing with the prose that
+            //    stretch led to. R3b's disease is answered by the two rules
+            //    below rather than by leaving the segment: a fold must
+            //    absorb at least TWO rows, and a stretch of exactly one
+            //    call names its target (see stretchTerms).
+            //
+            // ② TROUBLE. R3b refused to fold any run holding a failure,
+            //    and R3g extended that to interrupts. Law 1.3 governs
+            //    marks versus WORDS and never granted a failure a
+            //    permanent row; law 1.7 says "Work folds, words do not".
+            //    So the work folds and the outcome words ride the line —
+            //    `1 denied: .env` — and the human sees, without pressing
+            //    anything, that trouble happened, on which call, and what
+            //    happened. The stderr is behind the key, because it is
+            //    detail, not outcome. The cost R3b priced as rare measured
+            //    at 2 failures in 28 calls in the 0.16.7 dogfood, with
+            //    zero folds as the result.
+            if (turn !== undefined && seg !== null && seg.closedAt !== null && !seg.spilled && seg.cells.length >= 2) {
+                if (!seg.folded) {
                     seg.folded = true;
                     seg.headCell = i;
                     turn.folded = true;
-                    // A9 (ruling R2, mock A): the user chip rides the fold —
-                    // 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.
+                    // DECLARED SUPERSESSION (R3i phase 3) — A9 NARROWS: the
+                    // fold carries WORK, never the human's words.
                     //
-                    // 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: quiet ? turn.words : "",
-                        thoughtSeconds: seconds,
-                        reads: turn.reads,
-                        edits: turn.edits,
-                        others: [...turn.others],
-                    }, W);
+                    // A9 put the user's words on the fold as the SGR-7 chip.
+                    // Measured under R3i, that prints them twice: the chip
+                    // BAND commits on the frame it is pushed (it always has —
+                    // `#held` exempts non-thinking/tool cells), so a quiet
+                    // turn showed ` x ` on its own row and ` x ` again inside
+                    // the fold directly beneath it. The band is the record of
+                    // what was asked; this line is the record of what was
+                    // done. One fact, one row, each.
+                    return stretchLine({ ...this.#stretchTerms(seg), phase: "settled" }, W);
                 }
                 return [];
             }

package/package.json

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