@vincemakes/kiso-tui 0.16.8 → 0.18.0

package/dist/compositor.d.ts

@@ -184,6 +184,41 @@ export declare class Body {
             isError: boolean;
         };
     } | null;
+    /**
+     * R4 (C4d) — THE APPEND-ONLY RE-WRAP.
+     *
+     * The owner's report: resize the window and the reference
+     * implementation's text re-wraps to the new width while kiso's does
+     * not. It is true, and it is not a bug to be fixed — it is the price
+     * of ADR-0046, and the price is worth naming precisely.
+     *
+     * A terminal can only reflow a SOFT-wrapped line: one long logical
+     * line the terminal itself wrapped as the cursor flowed past the last
+     * column. Every row kiso commits is either painted by cursor
+     * addressing (#emitDiff) or scrolled out by a bare LF (#emitScroll),
+     * and frames run with autowrap OFF — so no byte kiso commits can ever
+     * carry a continuation flag, and nothing downstream can rejoin rows an
+     * application hard-split. That same LF is what makes the transcript
+     * the TERMINAL's: it survives kiso's death, a pipe, and tmux. A
+     * product whose transcript reflows is a product that repaints its
+     * transcript from its own memory, and that transcript dies with it.
+     *
+     * What kiso can do — and this is all it can do — is APPEND. The
+     * committed cells are still in memory; re-render them at the current
+     * width and put them at the BOTTOM, where writing is allowed. Nothing
+     * above is rewritten, so ADR-0046 holds exactly.
+     *
+     * Scoped to PROSE. Text is what reads badly at the wrong width — a
+     * paragraph folded for 120 columns and read at 60 is the complaint.
+     * Tool rows, folds and chips are short, already carry their own
+     * width ladders, and re-printing them would duplicate work the folds
+     * exist to state once.
+     */
+    rewrap(): {
+        lines: string[];
+        blocks: number;
+        skipped: number;
+    };
     expandNext(): {
         kind: "toggled";
     } | {

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 { ACT_SLOT_ROWS, Container, ROLLUP_NOUN, MOTION_FRAMES, MdStream, bodySpacing, boxBottom, boxTop, cellComponent, exploreCounts, foldCountsObjects, foldTerms, focusToken, exploreRows, foldLine, isExploreTool, moreRunningRow, pendingQueueRows, slotPad, slotTail, 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, foldKey: 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
@@ -296,7 +314,17 @@ export class Body {
     // rendered row carried the "ctrl+r" affordance; the expand key's
     // cycling pointer walks this list from the newest back.
     #collapsed = [];
-    #expandPtr = 0;
+    /** R4 (C1) — the ring walk is by IDENTITY, not by a modular pointer.
+     *  `#collapsed` is unshifted on every commit that carries the key, so
+     *  a numeric pointer's target silently CHANGED whenever a new fold
+     *  landed mid-cycle: the ring was not stable under itself, and the
+     *  next press opened something other than what the last press
+     *  implied. This set records what the current cycle has already
+     *  opened; the walk takes the newest entry not in it, and empties it
+     *  when every entry has been seen. */
+    #opened = new Set();
+    /** R4 (C1) — the session's fold counter. Monotonic, never reused. */
+    #foldSeq = 0;
     // W14: the turn records — one per userLine, the fold-hold's state
     // machine (ended / hasText / folded) plus the folded-turn line's
     // counts (accumulated at toolStart). The cells carry the record's
@@ -466,7 +494,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 +515,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 +572,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 +611,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;
@@ -974,6 +1034,73 @@ export class Body {
         }
         return -1;
     }
+    /**
+     * R4 (C4d) — THE APPEND-ONLY RE-WRAP.
+     *
+     * The owner's report: resize the window and the reference
+     * implementation's text re-wraps to the new width while kiso's does
+     * not. It is true, and it is not a bug to be fixed — it is the price
+     * of ADR-0046, and the price is worth naming precisely.
+     *
+     * A terminal can only reflow a SOFT-wrapped line: one long logical
+     * line the terminal itself wrapped as the cursor flowed past the last
+     * column. Every row kiso commits is either painted by cursor
+     * addressing (#emitDiff) or scrolled out by a bare LF (#emitScroll),
+     * and frames run with autowrap OFF — so no byte kiso commits can ever
+     * carry a continuation flag, and nothing downstream can rejoin rows an
+     * application hard-split. That same LF is what makes the transcript
+     * the TERMINAL's: it survives kiso's death, a pipe, and tmux. A
+     * product whose transcript reflows is a product that repaints its
+     * transcript from its own memory, and that transcript dies with it.
+     *
+     * What kiso can do — and this is all it can do — is APPEND. The
+     * committed cells are still in memory; re-render them at the current
+     * width and put them at the BOTTOM, where writing is allowed. Nothing
+     * above is rewritten, so ADR-0046 holds exactly.
+     *
+     * Scoped to PROSE. Text is what reads badly at the wrong width — a
+     * paragraph folded for 120 columns and read at 60 is the complaint.
+     * Tool rows, folds and chips are short, already carry their own
+     * width ladders, and re-printing them would duplicate work the folds
+     * exist to state once.
+     */
+    rewrap() {
+        const W = this.#opts.width();
+        const H = this.#opts.height();
+        const ctx = { spinnerI: this.#spinnerI, now: Date.now(), height: H };
+        // two screens is the bound: enough to re-read what a resize just
+        // made awkward, short enough that the append is not its own wall
+        // of text. A silent cap would read as "this is all of it".
+        const budget = Math.max(H, 2 * H);
+        const chunks = [];
+        let rows = 0;
+        let blocks = 0;
+        let skipped = 0;
+        for (let i = this.#committed - 1; i >= 0; i -= 1) {
+            const cell = this.#cells[i];
+            if (cell.kind !== "md")
+                continue;
+            blocks += 1;
+            if (rows >= budget) {
+                skipped += 1;
+                continue;
+            }
+            const lines = cellComponent(cell).render(W, ctx);
+            chunks.unshift(lines);
+            rows += lines.length;
+        }
+        return { lines: chunks.flat(), blocks: blocks - skipped, skipped };
+    }
+    /** R4 (C1) — what the NEXT press will open, by name. The walk is
+     *  deterministic (newest unopened first), so this is a promise the
+     *  key keeps rather than a guess. */
+    #nextFoldHint() {
+        const pending = this.#collapsed.filter((i) => !this.#opened.has(i));
+        const ring = pending.length > 0 ? pending : this.#collapsed;
+        const idx = ring[0];
+        const key = idx === undefined ? null : (this.#segmentOf(idx)?.foldKey ?? null);
+        return key === null ? "ctrl+r opens the next fold" : `ctrl+r opens fold ${key}`;
+    }
     expandNext() {
         for (let i = this.#cells.length - 1; i >= this.#committed; i -= 1) {
             const cell = this.#cells[i];
@@ -995,8 +1122,14 @@ export class Body {
         }
         if (this.#collapsed.length === 0)
             return { kind: "none" };
-        const idx = this.#collapsed[this.#expandPtr % this.#collapsed.length];
-        this.#expandPtr += 1;
+        // R4 (C1) — the newest entry this cycle has not opened yet. When
+        // every entry has been seen the cycle restarts, so the walk is
+        // still "newest back" — it is simply immune to the ring growing
+        // underneath it.
+        if (this.#collapsed.every((i) => this.#opened.has(i)))
+            this.#opened.clear();
+        const idx = this.#collapsed.find((i) => !this.#opened.has(i)) ?? this.#collapsed[0];
+        this.#opened.add(idx);
         const cell = this.#cells[idx];
         // R3b — a folded SEGMENT expands to the work it stands for.
         //
@@ -1075,7 +1208,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 +1244,29 @@ 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: [
+                    // R4 (C1): the expansion names the fold it opened, in the
+                    // same ordinal the fold row printed — the answer to "which
+                    // one did that open", stated rather than inferred.
+                    `${p.bold}✦${p.reset} expanded${seg.foldKey === null ? "" : ` ${seg.foldKey}`} · ${escapeTerminal(head.length === 0 ? "thinking" : head.join(" · "))} · ${back}`,
+                    ...body,
+                    `  ${p.dim}└ end of expansion · ${this.#nextFoldHint()}${p.reset}`,
+                ],
+            };
         }
         if (cell.kind !== "tool")
             return { kind: "none" };
@@ -1574,6 +1741,239 @@ 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, cap) {
+        const rows = this.#project(W, ctx, ACT_SLOT_ROWS);
+        if (cap === undefined || rows.length <= cap)
+            return rows;
+        // R4 — the slot gives way BEFORE any cell is force-committed.
+        // A standing slot that could overflow the content cap would make
+        // the force-commit loop push REAL cells into the scrollback to
+        // relieve rows that are, at the bottom of the slot, blank padding.
+        // So the slot shrinks first, in the pinned order slotPad already
+        // implements (the pad rows are last, so they go first, then the
+        // tail, then the heads beyond the first) and the floor is one row.
+        return this.#project(W, ctx, Math.max(1, ACT_SLOT_ROWS - (rows.length - cap)));
+    }
+    /** R4 — one pass of the live projection at a given slot budget. */
+    #project(W, ctx, budget) {
+        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;
+        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) {
+                // R4 — the open stretch is ONE contiguous block: its line
+                // plus the standing act slot, spaced once, at the segment's
+                // first live cell. Every other cell of the segment draws
+                // nothing; its work is counted on the line and its output,
+                // if it is the current thing, is in the slot.
+                //
+                // R3i drew the line here and then let each cell decide for
+                // itself whether it still had rows — which is why the
+                // region's height moved between every pair of calls.
+                if (stretchDrawn)
+                    continue;
+                stretchDrawn = true;
+                const rows = [
+                    ...stretchLine({ ...this.#stretchTerms(openSeg), liveNames: this.#liveNames(openSeg), phase: this.#stretchPhase(openSeg), mark: twinkleFrame(this.#spinnerI) }, W),
+                    ...this.#actSlot(openSeg, W, ctx, budget, focus),
+                ];
+                out.push(...this.#space(i, prev, rows));
+                prev = rows;
+                continue;
+            }
+            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;
+        }
+        return out;
+    }
+    /**
+     * R4 — the standing act slot's rows. EXACTLY `budget` rows in every
+     * phase, so the live region's height changes twice per stretch (once
+     * when it opens, once when it folds) instead of twice per call.
+     *
+     * The phases, in the order they are tested:
+     *  - an EXPANDED live cell outranks the slot (W15 — "the user asked
+     *    for it"): it renders in full, variable height. This is also
+     *    DC-28's cure: mid-stretch `ctrl+r` had a target it toggled and
+     *    never drew, so the press did nothing visible now and changed a
+     *    later expansion's shape;
+     *  - CALLS IN FLIGHT: one head row each within the budget, the tail
+     *    of the LAST head shown filling what is left, and the overflow
+     *    row inside the slot. The tail belongs to the last head by
+     *    construction — never call N's output under call N+1's header;
+     *  - the GAP between two calls: the call that just finished keeps its
+     *    settled head and its tail. This is the frame R3i collapsed, and
+     *    collapsing it is most of the jump;
+     *  - THINKING, before any call: the thinking's own tail (R3i ruling
+     *    5, wired at last).
+     */
+    #actSlot(seg, W, ctx, budget, focus) {
+        const tint = (i, rows) => {
+            if (i === focus && rows.length > 0)
+                rows[0] = focusToken(rows[0], W);
+            return rows;
+        };
+        const live = seg.cells.filter((i) => i >= this.#committed);
+        const tools = [];
+        for (const i of live)
+            if (this.#cells[i]?.kind === "tool")
+                tools.push(i);
+        const toolAt = (i) => this.#cells[i];
+        // An APPROVAL and an EXPANSION both outrank the slot, for the same
+        // reason: their height is the human's business, not the renderer's.
+        // W21 gives a pending approval the live region wholesale — its
+        // diff is the thing being decided about, and a diff clamped to
+        // four rows is a decision made on partial evidence. W15 gives an
+        // expanded cell its full body — "the user asked for it". The slot
+        // exists to stop the height moving ON ITS OWN; a height a human
+        // asked for is not the oscillation it was built against.
+        //
+        // (The approval half is a regression this round caused and its
+        // gate caught: the first draft treated a pending approval as a
+        // call in flight, so `⏸ edit x.ts` lost its diff tail and the
+        // `ctrl+r to expand` note with it.)
+        const owned = tools.filter((i) => toolAt(i).expanded || toolAt(i).state === "approval");
+        if (owned.length > 0) {
+            // In CELL ORDER, so the frame reads the way the work happened:
+            // an owned cell in full, every OTHER call still in flight
+            // keeping its head row. An approval pausing one call must never
+            // hide the others — the v2d parallel-frame gate caught exactly
+            // that: with the shell running and asky_read at its panel, the
+            // first draft returned the panel alone and the running shell's
+            // `● shell sleep 1; echo hi · 1s` row vanished from the screen.
+            const shown = tools.filter((i) => owned.includes(i) || !toolAt(i).done);
+            const out = [];
+            let heads = 0;
+            for (const i of shown) {
+                const rows = tint(i, cellComponent(this.#cells[i]).render(W, ctx));
+                if (owned.includes(i)) {
+                    out.push(...rows);
+                    continue;
+                }
+                if (heads >= LIVE_ACT_HEADS)
+                    continue;
+                heads += 1;
+                out.push(rows[0] ?? "");
+            }
+            const hidden = shown.length - owned.length - heads;
+            if (hidden > 0)
+                out.push(moreRunningRow(hidden, W));
+            return out;
+        }
+        const flight = tools.filter((i) => !toolAt(i).done);
+        if (flight.length > 0) {
+            // the commonest frame — exactly one call, the full budget — is
+            // the W8 block verbatim, which is what 0.17.0 already drew.
+            if (flight.length === 1 && budget >= ACT_SLOT_ROWS)
+                return slotPad(tint(flight[0], cellComponent(this.#cells[flight[0]]).render(W, ctx)), budget);
+            const heads = flight.slice(0, Math.max(1, Math.min(flight.length, budget - 1, LIVE_ACT_HEADS)));
+            const hidden = flight.length - heads.length;
+            const rows = [];
+            for (const i of heads)
+                rows.push(tint(i, cellComponent(this.#cells[i]).render(W, ctx))[0] ?? "");
+            const rest = budget - rows.length - (hidden > 0 ? 1 : 0);
+            if (rest > 0)
+                rows.push(...slotTail(toolAt(heads[heads.length - 1]).resultText, W, rest));
+            if (hidden > 0)
+                rows.push(moreRunningRow(hidden, W));
+            return slotPad(rows, budget);
+        }
+        const settled = tools.length > 0 ? tools[tools.length - 1] : null;
+        if (settled !== null) {
+            const head = tint(settled, cellComponent(this.#cells[settled]).render(W, ctx))[0] ?? "";
+            return slotPad([head, ...slotTail(toolAt(settled).resultText, W, budget - 1)], budget);
+        }
+        const think = [...live].reverse().find((i) => this.#cells[i]?.kind === "thinking");
+        return slotPad(think === undefined ? [] : slotTail(this.#cells[think].text, W, budget), budget);
+    }
+    /** R4 — the tool names with a call still IN FLIGHT in this segment.
+     *  The stretch line's tense is per term, so a finished shell reads
+     *  `ran 1 shell command` while a read is still running. */
+    #liveNames(seg) {
+        const names = new Set();
+        for (const i of seg.cells) {
+            const c = this.#cells[i];
+            if (c !== undefined && c.kind === "tool" && !c.done)
+                names.add(c.name);
+        }
+        return [...names];
+    }
+    /** 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
@@ -1603,16 +2003,25 @@ export class Body {
                 inputExtra +
                 queueRows.length);
         }
+        // DC-27 — the scalar measures the PROJECTION, not a second render
+        // of its own. This loop used to walk every live cell and render it
+        // in full: no open-segment collapse, no flight rule, no act-slot
+        // budget. After R3i that described a screen the compositor had
+        // stopped drawing — for an open stretch with five finished calls
+        // it counted five four-row blocks that were not there. Nothing
+        // broke, because the force-commit loop measures liveLines.length
+        // and the over-count is conservative; but the cap and geometry
+        // gates were asserting a property of a function nothing paints
+        // from, so a real regression in the region's height could not
+        // have moved them. The rule this file already states for the
+        // sheet ("the scalar must say so, or the cap arithmetic disagrees
+        // with the screen") is the same rule here.
         const ctx = { spinnerI: this.#spinnerI, now: Date.now(), height: this.#opts.height() };
         const W = this.#opts.width();
-        let lines = 0;
-        let prev = this.#committed > 0 ? this.#lineCache[this.#committed - 1] : null;
-        for (let i = this.#committed; i < this.#cells.length; i += 1) {
-            const rows = cellComponent(this.#cells[i]).render(W, ctx);
-            lines += this.#space(i, prev, rows).length;
-            prev = rows;
-        }
-        return lines + CHROME_ROWS + inputExtra + this.#menuRows(W).length + queueRows.length;
+        // the SAME content cap the force-commit loop applies, so the
+        // scalar sees the same slot budget the screen gets.
+        const rows = this.#liveProjection(W, ctx, this.#opts.height() - 4 - inputExtra - queueRows.length);
+        return rows.length + CHROME_ROWS + inputExtra + this.#menuRows(W).length + queueRows.length;
     }
     /** The lines committed THIS frame — the writes land in the frame's
      *  committed section (the rows just above the live region). */
@@ -1721,18 +2130,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, H - 4 - inputExtra - queueRows.length);
         }
         // 3. the FORCE commits — the live region's hard cap H−1: overflow
         //    commits the oldest live cell UNCONDITIONALLY (the one sharp
@@ -1751,21 +2149,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, H - 4 - inputExtra - queueRows.length);
         }
         // 4. the geometry — the live region's first row:
         //    liveTop = min(totalCommitted, H - liveRows) + 1 — the screen
@@ -1905,7 +2291,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 +2370,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 +2499,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 +2526,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 +2640,50 @@ 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.
+                    // R4 (C1): the ordinal is assigned HERE, before the row
+                    // is rendered, because the settled line always carries
+                    // the key — so the number is known without guessing
+                    // whether the row will earn an affordance.
+                    this.#foldSeq += 1;
+                    seg.foldKey = this.#foldSeq;
+                    // 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", foldKey: seg.foldKey }, W);
                 }
                 return [];
             }

package/dist/editor.js

@@ -61,6 +61,9 @@ export const MENU_ITEMS = [
     { name: "/resume", desc: "switch to another session; /resume <id> goes directly" },
     { name: "/think", desc: "show the last full thinking block" },
     { name: "/last", desc: "show the most recent tool call's input and output" },
+    // R4 (C4d): the committed transcript belongs to the terminal and can
+    // never be re-wrapped in place (ADR-0046); this appends it re-folded.
+    { name: "/rewrap", desc: "re-print the recent prose at the current width" },
     { name: "/status", desc: "show session id, event count, and context estimate" },
     // TUI2-R1 (E): the rent-ledger attribution — where the context went
     { name: "/context", desc: "show where the context went — the last request's rent ledger" },

package/package.json

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