@vincemakes/kiso-tui 0.24.5 → 0.26.0

package/dist/compositor.js

@@ -11,14 +11,17 @@
  *    the reference implementation's model): a line COMMITS (leaves the
  *    live region) via the real-LF
  *    scroll at the last row (`\x1b[1B\n` — CUP-free) when its cell is
- *    DONE and the region needs the room. Committed bytes are never
- *    re-emitted — the native scrollback gets them, reflow-safe, and
- *    the user's shell history is never touched (zero \x1b[3J, zero
- *    replay);
+ *    DONE and the region needs the room. Within a geometry, committed
+ *    bytes are never re-emitted — the native scrollback gets them. The
+ *    one exception is a SETTLED RESIZE (ADR-0046 Amendment 1, R14):
+ *    `2J H 3J`, then the whole session reprinted from the model, so the
+ *    terminal holds exactly one rendering; the shell history the
+ *    terminal held before kiso started is the declared cost;
  *  - the live region (content + chrome + menu) is hard-capped: the
  *    content at H−4 (V6-3 — the four-row chrome); overflow FORCE-
- *    commits the oldest live line regardless of done-ness — the one
- *    sharp edge (asserted by the VT-emulator gate);
+ *    commits the oldest live cell that has a committed form — never a
+ *    tool call still running (DC-53); a running card's window shrinks
+ *    to the room instead (DC-43);
  *  - two crash invariants: ① every emitted line's visible width ≤ W
  *    (components fold; a violation THROWS with diagnostics — the
  *    no-silent-truncate ruling); ② every steady-
@@ -47,13 +50,13 @@ import { MENU_ITEMS, displayWidth } from "./editor.js";
 import { leadWidth } from "./width.js"; // W23: the ONE width authority (the editor, #inputRow, and editCol share it)
 // KC3.5: the panel-slot reads come from the DISPATCHERS — one source
 // for four reads, so an ask can never render half as an approval.
-import { panelFrameOf, panelLeadOf, panelRowsOf, panelStatusOf } from "./ask-panel.js";
+import { panelFrameOf, panelLeadOf, panelStatusOf } from "./ask-panel.js";
 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 { CAP_PREVIEW, thinkingRow, expandedCard, Container, ROLLUP_NOUN, MOTION_FRAMES, MdStream, bodySpacing, boxBottom, boxTop, cellComponent, foldCountsObjects, foldTerms, focusToken, foldLine, gutterCut, cutLine, isExploreTool, moreRunningRow, pendingQueueRows, slotPad, slotTail, statusLine, visibleWidth, breathFrame, } from "./components.js";
-import { bannerLines, escapeTerminal, foldResult, foldThinking, palette, renderTerminalGap, renderToolSummary, toolTarget } from "./render.js";
+import { CAP_PREVIEW, thinkingRow, Container, MOTION_FRAMES, MdStream, bodySpacing, boxBottom, boxTop, cellComponent, gutterCut, cutLine, pendingQueueRows, statusLine, visibleWidth, breathFrame, } from "./components.js";
+import { bannerLines, escapeTerminal, foldResult, foldThinking, palette, renderTerminalGap, renderToolSummary } from "./lines.js";
 import { displayVerb, keysSheetRows } from "./strings.js";
 // R5 — the transcript viewer's PURE projection. The compositor supplies
 // the entries (it holds the cells); the arrangement lives there.
@@ -80,50 +83,12 @@ const LIVE_ACT_HEADS = 3;
 /** R8 — the command band's window: five rows plus a counter, the same
  *  budget the composer's own ceiling can afford above it. */
 const MENU_WINDOW = 5;
-/* R13 — `rolledTitle`, `rolledDetail` and `rolledOf` retired with the
-   W13 rollup and TUI2-R1 (B)'s exploration row (see #foldOrRollup). */
-/** 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(), seen: new Map(), thinkingMs: 0, thinkingSince: null, 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)
-        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
  *  idempotent shape — an unchanged replace is a no-op, no frame). */
 function sameTask(a, b) {
     return a.length === b.length && a.every((x, i) => x.text === b[i].text && x.status === b[i].status);
 }
-/** The one compositor — implements the Body façade AND the Dock chrome
- *  API (see the class comments on each method group). */
 export class Body {
     #opts;
     #cells = [];
@@ -198,20 +163,28 @@ export class Body {
     #needsReset = false;
     #resizeTimer = null;
     #lastH = 0;
-    /** DC-34 — did THIS FRAME refold the committed cells?
+    /** R14 — the geometry the last frame PAINTED, and the snapshot of it
+     *  taken when a winch opens a settle window.
      *
-     *  It must be reset where the question is asked, not only where it
-     *  is answered. Armed once and consumed later, it latched: the
-     *  session's FIRST frame ran a vacuous refold over zero committed
-     *  cells and set it, and nothing cleared it until the first resize —
-     *  so every session's first widen still ran the adopt it was
-     *  supposed to skip, and swallowed the live band's worth of
-     *  committed rows. Three paragraphs, in the measurement that found
-     *  it. */
-    #refolded = false;
-    /** DC-34 — the previous frame's width; the reach-back guard is for a
-     *  WIDTH change, which re-indexes the model, not a height change. */
-    #lastW = 0;
+     *  Three versions of this question were wrong before this one.
+     *  Seeding in `enter()` never ran under the unit pool (it bails on a
+     *  non-TTY), so a same-size winch erased the scrollback. Comparing
+     *  against the CURRENT frame's geometry let an ordinary frame render
+     *  at the new size between the winch and the settle and eat the
+     *  change, so a real resize silently stopped reprinting. Seeding once
+     *  on the first frame had the same hole whenever the first frame had
+     *  not run yet.
+     *
+     *  The question the settle actually asks is "is the terminal holding
+     *  a rendering made at a DIFFERENT geometry than the one we have
+     *  now" — so the comparison is against what was on screen when the
+     *  winch arrived, snapshotted then, once per storm. */
+    #paintedW = 0;
+    #paintedH = 0;
+    #winchFromW = 0;
+    #winchFromH = 0;
+    /** DC-50 — the ONE expansion switch ctrl+o flips. */
+    #expandedAll = false;
     // KC1 §6: the composer's recorded extent — the row count the last
     // frame drew (exit's clear walks it) and the row its CHA parked the
     // cursor on (the steady frame's relative anchor). N = 1 reproduces
@@ -224,11 +197,6 @@ 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
@@ -237,26 +205,15 @@ export class Body {
     #mdBase = 0;
     #toolCells = new Map(); // callId → cell index (parallel tools)
     // W15: the collapsed (cut) tool cells — committed cells whose last
-    // rendered row carried the "ctrl+o" affordance; the expand key's
-    // cycling pointer walks this list from the newest back.
+    // rendered row carried the "ctrl+o" affordance.
+    //
+    // DC-50 / R14: the expand key no longer WALKS this. It is the
+    // VIEWER's index now (ctrl+r, `#viewerEntries`) — the two surfaces
+    // coexist and §9 says so. It is kept, not retired, for that reader.
     #collapsed = [];
-    /** 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();
-    // 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
+    // the turn records — one per userLine; the cells carry the record's
     // index as their turn boundary.
     #turns = [];
-    // W13: the rolled-up run heads — the commit-time scan's verdict:
-    // the head's group summary renders, the members render [].
-    #rolledHeads = new Set();
     #write;
     #resizeHandler = null;
     /** TUI2-R3v2 ②: the panel option rows' absolute screen span, as of the
@@ -396,10 +353,8 @@ export class Body {
         }
         this.#closeOpenThinking();
         this.#closeOpenText();
-        // 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, begun: false, thoughtSeconds: 0, reads: 0, edits: 0, others: new Map(), seen: new Map(), words: text, folded: false, segments: [] });
+        // the turn boundary; the cell carries the record's index.
+        this.#turns.push({ ended: false, hasText: false, begun: false, thoughtSeconds: 0 });
         this.#cells.push({ kind: "user", text, done: true, turn: this.#turns.length - 1 });
         this.#mark();
     }
@@ -414,42 +369,15 @@ export class Body {
         }
         else {
             this.#cells.push({ kind: "thinking", text, done: false, turn: this.#turns.length - 1 });
-            // DECLARED SUPERSESSION (R7, owner-ruled 2026-08-31) — THINKING
-            // IS WORDS, NOT WORK.
-            //
-            // R3b made thinking open a segment, on the reading that it is
-            // work like a tool call. Four rounds of consequences followed
-            // from that one classification: folded away with the calls, it
-            // became unreachable, and R4's printed ordinal, R5's viewer,
-            // R6's subject index and a look-back viewport were each built
-            // to hand it back. The owner's ruling is to stop hiding it —
-            // and then none of those mechanisms is answering a question
-            // anyone still asks.
-            //
-            // So thinking CLOSES the open segment, exactly as text does
-            // (see textAppend): a segment is what sits between two of
-            // these. It must close rather than merely not-open, because
-            // `#committed` is a PREFIX count — a thinking cell cannot
-            // commit past a held call, so think → call → think would
-            // otherwise flush at the segment's close with the second
-            // thought printing BELOW the fold that contains the later
-            // call.
-            //
-            // Consequence, and it is wanted: the segment's thinking clock
-            // never starts, so `thought Ns` drops off every fold line by
-            // R3h's own zero-term rule. The line stops claiming a fact the
-            // paragraph above it already states in full.
+            // R7 (owner-ruled 2026-08-31): thinking is WORDS, not work — a
+            // cell like prose.
             const t0 = this.#turns[this.#turns.length - 1];
-            closeSegment(t0, Date.now());
             if (t0 !== undefined)
-                t0.begun = true; // R6/D1: the block allocates here
-            // 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.
+                t0.begun = true;
+            // R3i: the beat starts HERE. Law 1.4 says "a running thought
+            // twinkles", and `#armSpinner`'s predicate includes an open
+            // thinking cell — but its only caller used to be `toolRunning`,
+            // so a turn that thought and did nothing else never moved.
             this.#armSpinner();
         }
         this.#mark();
@@ -457,10 +385,6 @@ 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())
@@ -485,9 +409,7 @@ export class Body {
         // `done` flag says otherwise. The commit loop takes leading DONE
         // cells, so that one stale flag parked the whole rest of the turn
         // behind it — every tool cell then reached the screen through the
-        // FORCE-commit path, which by design bypasses the fold-hold. That is
-        // why the walkthrough saw nine individual rows: not a fold that
-        // declined to form, a fold that was never consulted.
+        // FORCE-commit path.
         this.#closeOpenThinking();
         this.#closeOpenText();
         // W12: the cell carries the delegate's child roles from the FULL
@@ -502,73 +424,11 @@ export class Body {
         }
         this.#toolCells.set(callId, this.#cells.length);
         this.#cells.push({ kind: "tool", name, input: summary, inputFull: JSON.stringify(input, null, 2), childRoles, state: "pending", isError: false, resultText: "", diff: null, added: 0, removed: 0, startedAt: null, doneAt: null, done: false, expanded: false, turn: this.#turns.length - 1, reason: null, verdict: null });
-        // W14: the turn record's counts — the folded-turn line's terms
-        // (reads = read_file, edits = edit_file, the rest in first-call
-        // order). The CLI's recap counts the same way (edit_file).
+        // R3i phase 5 — an ANSWER is words (law 1.7): `ask_user` never
+        // counted as the turn's work, so it does not mark the turn begun.
         const turn = this.#turns[this.#turns.length - 1];
-        if (turn !== undefined) {
-            // R3h (fable, 2026-08-29): an OBJECT-counting tool counts the
-            // distinct thing, not the act. Reading one file twice used to
-            // fold as `read 2 files` — a sentence law 1.3 forbids, and one
-            // this product shipped. `bump` is false on the second sighting
-            // 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)
-                    return true;
-                let set = rec.seen.get(name);
-                if (set === undefined) {
-                    set = new Set();
-                    rec.seen.set(name, set);
-                }
-                if (set.has(target))
-                    return false;
-                set.add(target);
-                return true;
-            };
-            if (bump(turn)) {
-                if (name === "read_file")
-                    turn.reads += 1;
-                else if (name === "edit_file")
-                    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. Its set is its OWN — a
-            // 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;
-                else if (name === "edit_file")
-                    seg.edits += 1;
-                else
-                    seg.others.set(name, (seg.others.get(name) ?? 0) + 1);
-            }
-        }
-        this.#stampSegment();
-        const t1 = this.#turns[this.#turns.length - 1];
-        if (t1 !== undefined)
-            t1.begun = true; // R6/D1: the block allocates here
+        if (turn !== undefined && name !== "ask_user")
+            turn.begun = true;
         this.#mark();
     }
     toolApproval(callId, diff) {
@@ -684,17 +544,9 @@ export class Body {
             this.#write(escapeTerminal(text));
             return;
         }
-        // W14: the text's arrival RELEASES the fold-hold — the turn now
-        // has text, its held cells commit individually (with the W13
-        // rollups; the fold is only for the QUIET turn).
         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
@@ -762,14 +614,9 @@ export class Body {
         this.#endMd();
         this.#mark();
     }
-    /** W14 — the turn boundary's END: the CLI calls this at the run's
-     *  terminal event, once per run, BEFORE the recap (so the fold line
-     *  commits before the recap in the cell order). `thoughtSeconds` is
-     *  the CLI's wall-clocked thinking window. The QUIET turn (ended, no
-     *  text) releases its held cells as the ONE fold line; a turn with
-     *  text releases them as individual commits (the W13 rollups). The
-     *  release is LAZY — the held cells commit at the next frame, when
-     *  the fold/rollup decision runs. */
+    /** The turn boundary's END: the CLI calls this at the run's terminal
+     *  event, once per run, BEFORE the recap. `thoughtSeconds` is the
+     *  CLI's wall-clocked thinking window. */
     endTurn(thoughtSeconds) {
         if (!this.#isActive())
             return;
@@ -778,9 +625,6 @@ 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 —
@@ -803,9 +647,7 @@ export class Body {
         // 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.
+        // (law 1.3: trouble is never summarised away).
         for (const c of this.#cells) {
             if (c.kind === "tool" && !c.done) {
                 c.state = "done";
@@ -815,10 +657,8 @@ export class Body {
             }
         }
         // 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
-        // it (the commit loop only takes done cells — the fold would stall
-        // forever behind the live thinking).
+        // its natural closer is the text's arrival, which a text-less turn
+        // never has, and the commit loop only takes done cells.
         for (let i = this.#cells.length - 1; i >= 0; i -= 1) {
             const c = this.#cells[i];
             if (c.kind === "thinking" && !c.done) {
@@ -946,68 +786,24 @@ export class Body {
     lastTool() {
         return this.#lastTool;
     }
-    /** W15 — the expand key's target (ctrl+o). A cell still in the LIVE
-     *  region (the newest live tool) TOGGLES in place — the compositor
-     *  owns those rows and redraws them (the body flips to the full
-     *  form, no cap). A committed cell can never toggle — history is
-     *  never rewritten (ADR-0046) — so the key APPENDS a fresh expanded
-     *  block at the bottom instead, the /last idiom aimed at a chosen
-     *  cell: the pointer cycles the collapsed history, newest first, and
-     *  the header names the target ("N turns back" — the user cells
-     *  after it), so every press tells the user what they got. */
+    /* DECLARED REVERSAL (D-S2-1, owner-ruled 2026-09-06): `#focusIndex`
+       stood here — TUI2-R2 ⑤'s bright ctrl+o token on the newest live
+       card, "the cell the next press will act on". DC-50 made ctrl+o a
+       global switch, so there was no target left for a marker to name;
+       the status row's idle hint names the switch instead (#statusSource). */
     /**
-     * TUI2-R2 ⑤ — the cell the next ctrl+o will act on, or -1.
-     *
-     * The rule is expandNext's own first loop, extracted verbatim: the
-     * LAST live cell that can toggle. It is a separate method rather than
-     * a shared constant because the marker and the key must not merely
-     * agree today — the marker is a PROMISE about what the key will do,
-     * and the only way to keep it is to derive it from the same scan.
-     *
-     * The committed fallback (the #collapsed ring) is deliberately NOT
-     * marked: those rows are frozen history, never re-emitted, so a tint
-     * on them could not be moved when the pointer advances. A live target
-     * is the one the marker can tell the truth about.
-     */
-    #focusIndex() {
-        for (let i = this.#cells.length - 1; i >= this.#committed; i -= 1) {
-            const cell = this.#cells[i];
-            if (cell.kind === "tool" && cell.state !== "pending")
-                return i;
-            if (cell.kind === "checklist" && !cell.done)
-                return i;
-        }
-        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.
+     * R4 (C4d) — `/rewrap`: the recent PROSE, re-rendered at the current
+     * width and APPENDED at the bottom. Committed rows carry no soft-wrap
+     * flag (autowrap is OFF; every row is painted or scrolled out by a
+     * bare LF), so the terminal cannot reflow them itself. R14
+     * (ADR-0046 Amendment 1, D-B3) made a settled resize reprint the
+     * whole session from the model on its own; this stays as the
+     * user-invoked form, and it still appends rather than erasing —
+     * nothing above the append is rewritten.
      *
      * 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.
+     * Cards and chips are short and carry their own width ladders.
      */
     rewrap() {
         const W = this.#opts.width();
@@ -1134,8 +930,7 @@ export class Body {
                 continue;
             // the tool card's FULL body — the same rows its own ctrl+o
             // opens. The expanded flag is saved and restored inside this
-            // synchronous call, the pattern the rollup path has always
-            // used for head.rolled; it never outlives the render, so the
+            // synchronous call; it never outlives the render, so the
             // committed geometry #committedLines derives can never see it.
             const saved = cell.expanded;
             cell.expanded = true;
@@ -1167,112 +962,13 @@ export class Body {
             cutLine(`${p.dim} ${viewerHint(this.#viewer, entries)}${p.reset}`, W),
         ];
     }
-    /** DC-35 — the last block this key appended, and the cell count when
-     *  it did. An expansion earns its rows by showing something the
-     *  transcript does not already END with. */
-    #lastAppend = null;
-    /**
-     * DC-35 — ctrl+o does not print the same expansion twice in a row.
-     *
-     * The ring walks newest-back and restarts its cycle once every entry
-     * has been opened (R4/C1, which is what makes the walk immune to the
-     * ring growing underneath it). With a ring of ONE the restart is
-     * immediate, so holding the key appended the identical block over
-     * and over — the owner got three copies of the same four rows, each
-     * closing with `ctrl+o opens the one before it`, a footer naming
-     * something that does not exist.
-     *
-     * The bar is the BOTTOM of the transcript, not "ever shown": once
-     * other content has arrived the expansion has scrolled up and
-     * re-opening it is the point of the key, so the guard clears itself
-     * the moment a cell is added.
-     */
-    expandNext() {
-        const out = this.#expandNextRaw();
-        if (out.kind !== "appended")
-            return out;
-        const lines = out.lines.join("\n");
-        if (this.#lastAppend !== null && this.#lastAppend.lines === lines && this.#lastAppend.atCells === this.#cells.length) {
-            // NOT the same answer as "nothing is folded". The caller says
-            // which, because a reader who pressed the key deserves to know
-            // whether there is nothing to open or whether they are already
-            // looking at it.
-            return { kind: "none", why: "already-last" };
-        }
-        this.#lastAppend = { lines, atCells: this.#cells.length };
-        return out;
-    }
-    #expandNextRaw() {
-        for (let i = this.#cells.length - 1; i >= this.#committed; i -= 1) {
-            const cell = this.#cells[i];
-            if (cell.kind === "tool" && cell.state !== "pending") {
-                cell.expanded = !cell.expanded;
-                this.#mark();
-                return { kind: "toggled" };
-            }
-            // W20: the LIVE task block toggles in place too — the capped
-            // form flips to the full list (the "done-collapse expands
-            // under ctrl+o" claim). The SETTLED block is already full —
-            // no toggle, and its rows carry no affordance, so it never
-            // joins #collapsed (the committed /last append is moot).
-            if (cell.kind === "checklist" && !cell.done) {
-                cell.expanded = !cell.expanded;
-                this.#mark();
-                return { kind: "toggled" };
-            }
-        }
-        if (this.#collapsed.length === 0)
-            return { kind: "none" };
-        // 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.
-        //
-        // 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.
-        // R13 — expandNext's FOLD branch retired with the segment fold.
-        // A fold line collapsed a run of cells into one row, so the key had
-        // to be able to open the run; with every call standing as its own
-        // card there is nothing collapsed for it to open, and `#collapsed`
-        // now holds cards alone.
-        if (cell.kind !== "tool")
-            return { kind: "none" };
-        // R13 — and the ROLLUP branch retired with `rolled`.
-        let input = {};
-        try {
-            input = JSON.parse(cell.inputFull);
-        }
-        catch {
-            // the full JSON is always parseable (it was stringified at
-            // toolStart) — the empty fallback never fires
-        }
-        const turnsBack = this.#cells.slice(idx + 1).filter((c) => c.kind === "user").length;
-        const p = palette();
-        // 0.24.2 ③ — the expansion is a CARD, and `✦` is not its mark: that
-        // glyph is the turn recap's, and one symbol with two meanings is
-        // §4.1. The head row names the call, which is the tie to it that
-        // the mark's sentence used to be.
-        const verb = displayVerb(cell.name);
-        const elapsed = cell.startedAt !== null && cell.doneAt !== null ? ((cell.doneAt - cell.startedAt) / 1000).toFixed(1) : "?";
-        const n = cell.resultText === "" ? 0 : cell.resultText.split("\n").length;
-        return {
-            kind: "appended",
-            lines: expandedCard(verb, toolTarget(cell.name, input), `expanded · ${turnsBack} ${turnsBack === 1 ? "turn" : "turns"} back`, 
-            // TUI2-R2pre ④: the SECTION HEADERS say the act; the payloads
-            // below them (inputFull, resultText) are RAW and byte-identical.
-            [`--- ${verb} input ---`, cell.inputFull, `--- ${verb} output${cell.isError ? " (error)" : ""} ---`, cell.resultText], [cell.isError ? "failed" : "exit 0", `${n} line${n === 1 ? "" : "s"}`, `${elapsed}s`].filter((x) => x !== "").join(" · "), this.#opts.width()),
-        };
-    }
+    /* DECLARED REVERSAL (DC-50 / R14, 2026-09-05): the APPENDED expansion
+       stood here — `expandNext`, `#expandNextRaw`, `#lastAppend`, the
+       `#opened` set. ADR-0046 §3 forbade re-rendering a committed card,
+       so the only way to show a body was to print a copy further down.
+       Amendment 1 lets a settled reprint re-render every card where it
+       stands, and `toggleExpanded` is the whole feature. `#collapsed`
+       stays: the viewer (ctrl+r) reads it as its index of cut cells. */
     // ---- the Dock façade (the CLI's chrome API — same shape as the old dock) ----
     /** Docked = the chrome is live (a color TTY with a real size). */
     get active() {
@@ -1506,6 +1202,14 @@ export class Body {
     onResize() {
         if (!this.#isActive())
             return;
+        // R14 — the FIRST winch of a storm snapshots what the terminal is
+        // currently holding. A drag fires many winches; the settle must
+        // compare its end against the storm's beginning, not against the
+        // previous winch.
+        if (!this.#resizePending) {
+            this.#winchFromW = this.#paintedW;
+            this.#winchFromH = this.#paintedH;
+        }
         this.#resizePending = true;
         if (this.#resizeTimer !== null)
             clearTimeout(this.#resizeTimer);
@@ -1533,20 +1237,128 @@ export class Body {
         this.#screen = [];
         this.onResize();
     }
-    /** The one repaint a drag earns, once its signals have stopped. */
+    /**
+     * R14 / route B — THE ONE REPAINT A DRAG EARNS IS A REPRINT.
+     *
+     * It used to be `ESC[from;1H ESC[0J` — erase from the recorded live
+     * top down, then redraw the live area, leaving the committed rows
+     * above to whatever the terminal's own reflow had made of them. That
+     * is the shape R10 measured on the owner's real terminal, and it
+     * lost: a grow dropped 16 rows of history (DC-39), a narrow
+     * duplicated four tokens, and the scrolled-off transcript never
+     * reflowed at all. All three are one fault — kiso doing window
+     * arithmetic over rows the terminal had already reflowed underneath
+     * it, with `#scrolledOff` carried across a fold change that makes
+     * every index mean something else.
+     *
+     * So it stops arguing. `2J H 3J` — erase screen, home, erase
+     * scrollback, in THAT order because on Apple Terminal a bare `2J`
+     * scrolls the screen into history and only the following `3J` makes
+     * the state clean — and then the whole committed transcript is
+     * reprinted at the new geometry through the path a fresh terminal
+     * already uses. The terminal ends holding exactly one rendering.
+     *
+     * The declared cost (ADR-0046 Amendment 1): everything the terminal
+     * held before kiso started is erased at the first resize. Measured
+     * on the reference implementation as 0/60 in every direction — this
+     * is the behaviour being adopted, not a regression. kiso's own
+     * record is untouched: the session log holds it, `--resume` replays
+     * it, and G4' asserts the 0/60 so the cost cannot drift silently.
+     *
+     * D-B2: EVERY settled resize reprints, height-only included. A
+     * SIGWINCH at the same geometry emits nothing at all.
+     */
     #settleResize() {
         if (!this.#resizePending || !this.#isActive())
             return;
         this.#resizePending = false;
         const H = this.#opts.height();
-        const liveRows = this.#lastLiveRows > 0 ? this.#lastLiveRows : 3;
-        const from = Math.max(1, (this.#lastH > 0 ? this.#lastH : H) - liveRows + 1);
-        this.#write(`\x1b[${Math.min(from, Math.max(1, H))};1H\x1b[0J`);
+        const W = this.#opts.width();
+        // D-B2's other half: a winch that did not change the geometry is
+        // not a resize. Emitting the erase for it would throw away the
+        // terminal's scrollback for nothing (the V6-1 idempotence case).
+        if (this.#winchFromW === W && this.#winchFromH === H)
+            return;
+        // §9.2 — the viewer is closed first. Nothing commits while it is
+        // up and a reprint is a commit storm; the user reopens it. One
+        // keypress, stated rather than hidden.
+        if (this.#viewer !== null) {
+            this.#viewer = null;
+            this.#viewerWasUp = true;
+        }
+        this.#reprint();
+    }
+    /**
+     * R14 — ERASE THE TERMINAL AND PRINT THE SESSION AGAIN.
+     *
+     * Two callers: a settled resize, and DC-50's ctrl+o. They are the
+     * same act — the rendering the terminal holds is wrong (wrong
+     * geometry, or wrong expansion state) and the model is the only
+     * authority on what it should be — so they share the path rather
+     * than growing two.
+     */
+    #reprint() {
+        const H = this.#opts.height();
+        this.#write("\x1b[2J\x1b[H\x1b[3J");
+        // The terminal now holds nothing, so every record of what it held
+        // is void. `#scrolledOff` is the frontier of what reached its
+        // scrollback: after the erase, that is zero — which is also what
+        // releases the committed cells to be re-rendered at the new width
+        // without contradicting anything, the thing DC-34's frontier rule
+        // existed to prevent.
+        this.#scrolledOff = 0;
+        for (let i = 0; i < this.#committed; i += 1)
+            this.#lineCache[i] = null;
+        this.#screen = new Array(Math.max(1, H)).fill(NOT_PAINTED);
+        this.#cursorRow = 1;
         this.#fullRedraw = true;
         this.#resizeFrame = true;
         this.#dirty = true;
         this.render();
     }
+    /**
+     * DC-50 — ctrl+o flips ONE switch, and every settled card obeys it.
+     *
+     * The walk this replaces existed because ADR-0046 §3 forbade
+     * re-rendering a committed card, so the only way to show one's body
+     * was to APPEND a copy further down — with a ring to decide which
+     * card was next, `#opened` to keep the ring from repeating, and
+     * `#lastAppend` to stop a held key printing the same rows three times
+     * (DC-35). Amendment 1 removes the premise: the scrollback is ours to
+     * erase, so a card can simply be re-rendered where it stands.
+     *
+     * A RUNNING card is exempt. Its height is E2/DC-43's — it grows from
+     * its own content — and a global "show everything" has no business
+     * reaching into a card whose content is still arriving.
+     */
+    toggleExpanded() {
+        this.#expandedAll = !this.#expandedAll;
+        for (const cell of this.#cells) {
+            // SETTLED CONTENT, not "done". A card parked for approval is
+            // `state: "approval"`, `done: false` — and its content is not
+            // still arriving: the diff is complete and the card is waiting
+            // for a human to read it and decide. The mechanism this
+            // replaces toggled it (any state but "pending"), and the
+            // dispatch comment said why: "the approval pause is exactly
+            // when the user reads a cut diff, and the key must answer then,
+            // never after the run." A `done`-only switch answers with
+            // nothing at the one moment the answer matters most.
+            //
+            // The exemption is for the card still GROWING — E2 and DC-43
+            // own its height, and a global "show everything" has no
+            // business reaching into content that is still arriving. That
+            // is the ruling's reason; `done` alone was its wording.
+            if (cell.kind !== "tool")
+                continue;
+            if (cell.done || cell.state === "approval")
+                cell.expanded = this.#expandedAll;
+        }
+        this.#reprint();
+    }
+    /** DC-50 — the switch itself, for the CLI's affordance text. */
+    expandedAll() {
+        return this.#expandedAll;
+    }
     /** W18: the status row's right-aligned hint is part of the status
      *  state — the compacting row passes "esc to cancel" (the affordance
      *  must survive repaints). */
@@ -1584,13 +1396,21 @@ export class Body {
         // approval and the pick, ask-panel.ts for the ask), so nothing is
         // lost anywhere.
         if (panel !== null)
-            return { status: panelStatusOf(panel), hint: undefined };
+            return { status: panelStatusOf(panel), hint: undefined, expand: null };
         // W22: while turns wait in the queue, the right hint shows the
         // count — the chips below carry the lines themselves.
         const queued = this.#queueState?.().length ?? 0;
         if (queued > 0)
-            return { status: this.#status, hint: `+${queued} queued` };
-        return { status: this.#status, hint: this.#statusHint ?? undefined };
+            return { status: this.#status, hint: `+${queued} queued`, expand: null };
+        // D-S2-1 (owner-ruled 2026-09-06): the idle hint names the ctrl+o
+        // SWITCH — `expand all` or `collapse all` by its state — and only
+        // while a committed card has something behind the key (#collapsed
+        // is the index of exactly those). A hint for a key that would
+        // change nothing is a hint that lies. This replaced the per-card
+        // bright token (TUI2-R2 ⑤), which had no single target left to
+        // mark once DC-50 made the key global.
+        const expand = this.#collapsed.length > 0 ? (this.#expandedAll ? "collapse all" : "expand all") : null;
+        return { status: this.#status, hint: this.#statusHint ?? undefined, expand };
     }
     /** Bind the editor's panel state — the PanelSelect slot occupant
      *  (W21: the panel replaces the live region + the input lead while
@@ -1721,49 +1541,17 @@ export class Body {
     }
     // ---- 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.
+     * THE LIVE PROJECTION — the uncommitted cells as rows, one definition
+     * for the natural path and the force-commit loop alike (two copies of
+     * "what the live region looks like" would be two answers to one
+     * question). The live region is bounded by the SCREEN, and nothing
+     * else: DC-46's `#liveRoom` capped it at `H − chrome − #committedLines`
+     * to keep the window's top monotone, but `#committedLines` is
+     * cumulative, so one screenful into any session every running call
+     * was a head row with its output gone. The window's top is held by
+     * the `skip` clamp in render() instead; a live region that grows
+     * scrolls committed rows away, which is an append and not an un-scroll.
      */
-    /* DC-46 — `#liveRoom` RETIRED, and the reasoning with it.
-       It capped the live region at `H − chrome − #committedLines`, to
-       keep `skip` a function of `#committedLines` alone and therefore
-       monotone. The argument was right about `skip` and wrong about the
-       quantity: `#committedLines` is CUMULATIVE — re-derived over the
-       whole line cache every frame, counting rows that left for the
-       terminal's scrollback long ago — so one screenful into any session
-       it exceeds H, the room clamps to its floor of one row, and every
-       running call after that is a head row with its output gone.
-       Measured at 24 and 40 rows with eight blank rows still on screen.
-
-       The live region is bounded by the SCREEN (the content cap the
-       force-commit loop already uses). What holds the window's top is
-       the `skip` clamp below: rows in [0, #scrolledOff) have reached the
-       terminal's scrollback and are immutable, so the paint may not go
-       back above them. A live region that GROWS scrolls committed rows
-       away through #emitScroll, which is an append and not an un-scroll.
-       The residue is a transient hole above the composer at a settle,
-       bounded by the shrink itself and filled by the next commit. */
     #liveProjection(W, ctx, cap) {
         const rows = this.#project(W, ctx, CAP_PREVIEW);
         if (cap === undefined || rows.length <= cap)
@@ -1804,39 +1592,19 @@ export class Body {
         return [...heads.slice(0, keep), cutLine(`${p.dim}  +${hidden} more${p.reset}`, W)];
     }
     /**
-     * R13 — ONE PASS, AND EVERY CELL RENDERS ITSELF.
-     *
-     * DECLARED REVERSAL of R3i's stretch line, R4's standing activity
-     * slot and R6/D1's block-stands-for-the-turn, all owner-ruled on
-     * 2026-09-03 and all of them the same idea: the open stretch drew ONE
-     * line plus a fixed slot, and every other cell of the segment drew
-     * nothing, so the live region's height was independent of the call
-     * count. That was the answer to a 28-call turn spending 28 rows of a
-     * 30-row region.
-     *
-     * The card answers it differently, and the ruling prefers this
-     * answer: a running call is its own card at a FIXED height (E2), so
-     * the height is a function of how many calls are IN FLIGHT rather
-     * than of how many have happened — and the window shrinks to the room
-     * before anything is force-committed (above). The live form and the
-     * committed form are now the same form, which is what makes a settle
-     * a change of content and never of position.
-     *
-     * What this keeps from R4: the height never moves ON ITS OWN. What it
-     * gives up: the one-line summary of a stretch, which the owner ruled
-     * costs more than it buys.
+     * ONE PASS, AND EVERY CELL RENDERS ITSELF. The live form and the
+     * committed form are the same form, which is what makes a settle a
+     * change of content and never of position (DECLARED REVERSAL, R13:
+     * R3i's stretch line and R4's standing slot drew one line plus a
+     * fixed block for the whole stretch and had every other cell draw
+     * nothing; the owner ruled the summary costs more than it buys).
      */
     #project(W, ctx, budget) {
         const out = [];
-        const focus = this.#focusIndex();
         const live = { ...ctx, liveWindow: budget };
         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, live);
-            // 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;
         }
@@ -1883,56 +1651,17 @@ export class Body {
      *  blanks are join artifacts — the count includes them (they are real
      *  screen rows), threaded against the previous sibling's OWN rows. */
     liveCount() {
-        const panel = this.#panelState?.() ?? null;
-        const sheet = this.#sheetState?.() === true;
-        const queueRows = this.#queueRows(this.#opts.width(), this.#opts.height());
-        // KC1 §6: the composer's extra rows are chrome too — the scalar
-        // counts them exactly like the menu/queue bands (N = 1 ⇒ +0)
-        const inputExtra = this.#inputRows(this.#opts.width(), this.#opts.height(), this.#menuRows(this.#opts.width()).length, queueRows.length).rows.length - 1;
-        // TUI2-R1 (D): the sheet occupies the live region, exactly like the
-        // panel — the scalar must say so, or the cap arithmetic disagrees
-        // with the screen.
-        // R5 — the viewer occupies the live region exactly like the sheet,
-        // so the scalar must say so, or the cap arithmetic disagrees with
-        // the screen (the same rule DC-27 was about).
-        if (this.#viewer !== null) {
-            const capV = Math.max(1, this.#opts.height() - 4 - inputExtra - queueRows.length);
-            return this.#viewerBand(this.#opts.width()).slice(0, capV).length + CHROME_ROWS + inputExtra + queueRows.length;
-        }
-        if (sheet) {
-            return (keysSheetRows(this.#opts.width()).slice(0, Math.max(1, this.#opts.height() - 4 - inputExtra - queueRows.length)).length +
-                CHROME_ROWS +
-                inputExtra +
-                queueRows.length);
-        }
-        if (panel !== null) {
-            // W21: the panel's own rows (the cap is exact — the scalar
-            // reflects the screen). W22: the queue chips occupy their
-            // own band — the panel's cap shrinks by their rows.
-            return (panelRowsOf(panel, this.#opts.width(), Math.max(1, this.#opts.height() - 4 - inputExtra - queueRows.length)).length +
-                CHROME_ROWS +
-                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();
-        // 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;
+        const H = this.#opts.height();
+        const chrome = this.#chrome(W, H);
+        const ctx = { spinnerI: this.#spinnerI, now: Date.now(), height: H };
+        // DC-27 — the scalar measures what the SCREEN gets: the same
+        // selector render() paints from, under the same chrome. A scalar
+        // with rules of its own asserted a property of a function nothing
+        // painted from, so the cap and geometry gates could not move on a
+        // real regression ("the scalar must say so, or the cap arithmetic
+        // disagrees with the screen" — TUI2-R1 D, R5, DC-27, one rule).
+        return this.#liveRows(W, ctx, chrome.cap).lines.length + chrome.rows;
     }
     /** The lines committed THIS frame — the writes land in the frame's
      *  committed section (the rows just above the live region). */
@@ -1949,243 +1678,161 @@ export class Body {
         if (H < 4)
             return;
         this.#lastH = H;
+        // R14 — the geometry THIS frame painted. `onResize` snapshots it
+        // at the moment the winch arrives; see `#winchFromW`.
+        this.#paintedW = W;
+        this.#paintedH = H;
         const ctx = { spinnerI: this.#spinnerI, now: Date.now(), height: H };
-        // V6-1 (the screen-state == frame-state rule): the resize's first
-        // frame — the terminal's reflow re-wrapped the committed content at
-        // the NEW width, so the cached folds are stale. Re-fold the
-        // committed cells so the every-row draw below re-paints them at the
-        // current geometry — the frame's model and the screen agree.
-        // DC-34 — A WIDEN DOES NOT REFOLD WHAT IS ALREADY COMMITTED.
-        //
-        // Every count here is physical ROWS at the fold width in force
-        // when it was computed. Refolding the committed cells at a new W
-        // changes what every index MEANS while `#scrolledOff` is carried
-        // across untranslated — and no translation exists, because the
-        // row the scroll stopped at does not occur in the new fold. On a
-        // widen the stale count then points at text the terminal already
-        // holds, and the frame paints it a second time.
-        //
-        // A committed row is ink (ADR-0046): the rows still on screen are
-        // the same thing as the rows in the scrollback minus a scroll
-        // that has not happened, and no terminal reflows either. Leaving
-        // them folded as they were printed keeps every index valid.
-        //
-        // NARROWING still refolds — an old wide row does not FIT, and
-        // `#checked` would throw invariant ①. The comparison is against
-        // the CACHE's fold width, not the last render's: after 60 → 100
-        // (no refold, the cache is still 60) a narrowing to 80 must NOT
-        // refold, because 80 columns hold a 60-column row.
-        this.#refolded = false;
-        if (this.#fullRedraw) {
-            // DC-34 — THE REFOLD IS SCOPED BY THE FRONTIER.
-            //
-            // `#scrolledOff` is the record of what reached the terminal:
-            // rows [0, #scrolledOff) are in its scrollback, immutable, and
-            // no path of ours may contradict them. A cell with any row
-            // down there keeps the fold it was COMMITTED at, forever — in
-            // either direction. A cell entirely above the frontier has
-            // never left the screen, so re-folding it is free.
-            //
-            // Two scalar predicates were tried before this and both
-            // failed, in different ways: the last-refold width crashed on
-            // 60 → 100 → 80 (a cell committed at 100 emitted into an
-            // 80-column screen), and the cache's widest fold fires a FULL
-            // refold at the first narrowing, which re-wraps rows the
-            // scrollback already holds — the original defect, alive in
-            // the other direction. The frontier is not an approximation
-            // of them; it is the question they were both approximating.
-            // A cell is refolded when EITHER is true:
-            //   - it is entirely above the frontier (never left the
-            //     screen, so re-wrapping it contradicts nothing), or
-            //   - it does not FIT: some cached row is wider than W.
-            //
-            // The second is not a compromise of the first, it is the
-            // answer to a question the first cannot reach. A cell can
-            // STRADDLE the frontier — its head in the scrollback, its
-            // tail still on screen — and the tail must be painted at the
-            // current width. Holding its commit fold there emitted a
-            // 100-column row into an 80-column screen and invariant ①
-            // threw (60 → 100 → 80, measured). Fitting wins: a crash is
-            // worse than a seam, and the seam a narrowing leaves is
-            // rider 2's, stated rather than hidden.
-            let row = 0;
-            const refold = new Array(this.#committed).fill(false);
-            for (let i = 0; i < this.#committed; i += 1) {
-                const lines = this.#lineCache[i];
-                if (lines === null || lines === undefined) {
-                    refold[i] = true;
-                    continue;
-                }
-                const above = row >= this.#scrolledOff;
-                const fits = lines.every((l) => visibleWidth(l) <= W);
-                refold[i] = above || !fits;
-                const prev = i > 0 ? this.#lineCache[i - 1] : null;
-                row += this.#space(i, prev ?? null, lines).length;
-            }
-            for (let i = 0; i < this.#committed; i += 1) {
-                if (refold[i])
-                    this.#lineCache[i] = cellComponent(this.#cells[i]).render(W, ctx);
-            }
-            // #committedLines is re-derived over the WHOLE cache, because
-            // the frozen prefix still occupies its own rows.
-            this.#committedLines = 0;
-            for (let i = 0; i < this.#committed; i += 1) {
-                const lines = this.#lineCache[i] ?? cellComponent(this.#cells[i]).render(W, ctx);
-                this.#lineCache[i] = lines;
-                this.#committedLines += this.#space(i, i > 0 ? (this.#lineCache[i - 1] ?? []) : null, lines).length;
-            }
-            this.#refolded = refold.some(Boolean);
-        }
-        // 1. the natural commits — the leading DONE cells freeze: their
-        //    lines leave the live region, the scrolls + the committed
-        //    writes below place them (the #17 "freeze as a real line",
-        //    short sessions included — the frame coalescing keeps a
-        //    cell's first frame its freeze frame, so the frozen bytes
-        //    emit exactly once).
+        if (this.#fullRedraw)
+            this.#rederiveCommitted(W, ctx);
+        // 1. the natural commits — the leading DONE cells freeze.
+        this.#commitDone(W, ctx);
+        // 2. the live lines — the unfinished cells (the tail) + the chrome.
+        const chrome = this.#chrome(W, H);
+        this.#noteOverlay();
+        const live = this.#liveRows(W, ctx, chrome.cap);
+        // 3. the FORCE commits — the live region's hard cap.
+        const liveLines = this.#capLive(live.lines, W, ctx, chrome.cap);
+        // 4. the geometry — the live region's first row:
+        //    liveTop = min(totalCommitted, H - liveRows) + 1 — the screen
+        //    shows the bottom H rows; the live region anchors to the bottom.
+        const liveRowsTotal = liveLines.length + chrome.rows;
+        const liveTop = Math.min(this.#committedLines, H - liveRowsTotal) + 1;
+        // TUI2-R3v2 ②: the option rows' ABSOLUTE screen rows, recorded per
+        // frame. A click is answered against the frame the human was looking
+        // at when they clicked, which is this one.
+        this.#panelRowSpan =
+            live.panelSpan === null ? null : { top: liveTop + live.panelSpan.offset, count: live.panelSpan.count, first: live.panelSpan.first };
+        // 5. the frame bytes.
+        this.#paint(W, H, liveTop, liveLines, liveRowsTotal, chrome);
+    }
+    /** Phase 0 — a full redraw re-derives the committed rows from the
+     *  cache. A cell whose cache was invalidated (a settled resize, R14)
+     *  is rendered again at the current width; every other cell keeps
+     *  the rows it was committed with, because those rows are already
+     *  the terminal's (ADR-0046) and this frame paints the same bytes.
+     *
+     *  DECLARED REVERSAL (R14): DC-34's frontier-scoped REFOLD stood
+     *  here — a widen never refolded a committed cell, a narrowing
+     *  refolded the cells that no longer fit. Route B reprints the
+     *  whole session from the model on a settled resize, so no
+     *  committed row is refolded in place any more, and the width
+     *  guard that decided which ones were went with it. */
+    #rederiveCommitted(W, ctx) {
+        this.#committedLines = 0;
+        for (let i = 0; i < this.#committed; i += 1) {
+            const lines = this.#lineCache[i] ?? cellComponent(this.#cells[i]).render(W, ctx);
+            this.#lineCache[i] = lines;
+            this.#committedLines += this.#space(i, i > 0 ? (this.#lineCache[i - 1] ?? []) : null, lines).length;
+        }
+    }
+    /** Phase 1 — the natural commits: the leading DONE cells freeze —
+     *  their lines leave the live region, the scrolls + the committed
+     *  writes below place them (the #17 "freeze as a real line", short
+     *  sessions included — the frame coalescing keeps a cell's first
+     *  frame its freeze frame, so the frozen bytes emit exactly once). */
+    #commitDone(W, ctx) {
         this.#committedAtFrameStart = this.#committed;
         this.#committedLinesThisFrame = [];
-        // W14: the natural loop HONORS 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 turn's text →
-        // individual commits with the W13 rollups; the turn's end → the
-        // fold). The FORCE-commit path below bypasses the hold — the
-        // screen never sticks, the rollup degrades to individuals.
-        while (this.#committed < this.#cells.length && this.#cells[this.#committed].done && !this.#held(this.#committed)) {
+        while (this.#committed < this.#cells.length && this.#cells[this.#committed].done) {
             this.#commitCell(this.#committed, W, ctx);
         }
-        // 2. the live lines — the unfinished cells (the tail) + the chrome.
-        //    W11: the formula's blank above the first live cell hangs off
-        //    the last COMMITTED sibling (the join spans the boundary).
+    }
+    /** The chrome this frame wears: the menu band, the queue band (W22:
+     *  the menu-rows family's other occupant — the band above the box
+     *  top), the composer (KC1 §6: N rows; N = 1 ⇒ today's chrome
+     *  exactly — chromeRows = 3 + N + menu + queue, and the content cap
+     *  loses the composer's EXTRA rows the same way it loses the bands).
+     *  W11: the formula's blank above the first live cell hangs off the
+     *  last COMMITTED sibling (the join spans the boundary). */
+    #chrome(W, H) {
         const menuRows = this.#menuRows(W);
-        // W22: the queue chips are the menu-rows family's other occupant
-        // (the band above the box top) — the chrome rows and the live
-        // caps account for both.
         const queueRows = this.#queueRows(W, H);
-        // KC1 §6: the input is N rows now (N = 1 ⇒ today's chrome exactly)
-        // — chromeRows = 3 + N + menu + queue, and the content cap loses
-        // the composer's EXTRA rows the same way it loses the bands.
         const editor = this.#inputRows(W, H, menuRows.length, queueRows.length);
         const inputExtra = editor.rows.length - 1;
-        const chromeRows = CHROME_ROWS + inputExtra + menuRows.length + queueRows.length;
-        let liveLines = [];
-        // TUI2-R3v2 ②: where this frame put the panel's option rows, relative
-        // to the live region's top. Resolved to ABSOLUTE screen rows once
-        // liveTop is known, below.
-        let panelSpan = null;
-        const panel = this.#panelState?.() ?? null;
-        // TUI2-R1.5 ⑦(a) (VD-8): the sheet is an OVERLAY, and the frame it
-        // opens on — and the one it closes on — take the full-redraw path.
-        // The sheet REPLACES the live region, so on an idle composer (where
-        // the live region is empty) opening it GROWS the model by its own
-        // height; the frame's skip grows with it and the difference is paid
-        // in real LFs — rows scrolled permanently into the terminal's
-        // scrollback, which closing cannot undo, because the scrollback is
-        // not ours to rewrite. Measured: three rows per open on a full
-        // screen. The overlay below displaces content on screen instead.
+        return {
+            menuRows,
+            queueRows,
+            editor,
+            inputExtra,
+            rows: CHROME_ROWS + inputExtra + menuRows.length + queueRows.length,
+            cap: H - 4 - inputExtra - queueRows.length,
+        };
+    }
+    /** The overlay bookkeeping. TUI2-R1.5 ⑦(a) (VD-8): the sheet is an
+     *  OVERLAY, and the frame it opens on — and the one it closes on —
+     *  take the full-redraw path. The sheet REPLACES the live region, so
+     *  on an idle composer (where the live region is empty) opening it
+     *  GROWS the model by its own height; the frame's skip grows with it
+     *  and the difference is paid in real LFs — rows scrolled
+     *  permanently into the terminal's scrollback, which closing cannot
+     *  undo, because the scrollback is not ours to rewrite. Measured:
+     *  three rows per open on a full screen. The overlay displaces
+     *  content on screen instead. R5 — the viewer is an overlay of
+     *  exactly the same kind, so it joins the same flag. That one word
+     *  is what buys it the whole zero-litter discipline: the window
+     *  freezes, #emitScroll is skipped, and the close repaints from
+     *  #lastSkip. */
+    #noteOverlay() {
         const sheetUp = this.#sheetState?.() === true;
-        // R5 — the viewer is an overlay of exactly the same kind, so it
-        // joins the same flag. That one word is what buys it the whole
-        // zero-litter discipline below: the window freezes, #emitScroll
-        // is skipped, and the close repaints from #lastSkip.
         const viewerUp = this.#viewer !== null;
         this.#overlayFrame = sheetUp || this.#sheetWasUp || viewerUp || this.#viewerWasUp;
         this.#sheetWasUp = sheetUp;
         this.#viewerWasUp = viewerUp;
-        if (viewerUp) {
-            // R5: the viewer REPLACES the live region — the same slot the
-            // sheet and the panel use, for the same reason (it is what the
-            // human is reading right now). It is opened only from an idle
-            // composer, so it cannot coexist with a panel.
-            liveLines = this.#viewerBand(W).slice(0, Math.max(1, H - 4 - inputExtra - queueRows.length));
-        }
-        else if (sheetUp) {
-            // TUI2-R1 (D): the sheet REPLACES the live region — the same
-            // slot the panel uses, for the same reason (it is what the
-            // human is reading right now). It cannot coexist with a panel:
-            // the editor only opens it from an idle composer.
-            liveLines = keysSheetRows(W).slice(0, Math.max(1, H - 4 - inputExtra - queueRows.length));
-        }
-        else if (panel !== null) {
-            // W21: the panel REPLACES the running tool's live window — the
-            // bounded block, capped at H−4 (the panel IS the live region;
-            // the W11 blank would separate it from the frozen content).
-            // The cap is exact, so the force-commit loop never fires. W22:
-            // the queue band sits below the panel — the cap shrinks by it.
-            // TUI2-R3v2 ②: the rows and the CLICKABLE span come from one
-            // call, so the hit-test reads the arithmetic that placed the
-            // rows rather than a second copy of it.
-            const frame = panelFrameOf(panel, W, Math.max(1, H - 4 - inputExtra - queueRows.length));
-            liveLines = frame.rows;
-            panelSpan = frame.options;
-        }
-        else {
-            // TUI2-R2 ⑤ (D, candidate 1): the FOCUS — the cell the next ctrl+o
-            // will act on brightens its own token. The index is derived from
-            // the SAME scan expandNext performs (#focusIndex shares its rule
-            // 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.
-            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
-        //    edge — the cap scalar is asserted by the gates). W22: the
-        //    queue band shrinks the cap by its rows (empty queue → H−4).
-        // DC-53 — AND NEVER A CELL THAT IS NOT DONE.
-        //
-        // This loop committed `#committed` unconditionally. R4's standing
-        // slot held the live region at a constant height, so the
-        // projection never grew past the cap on its own and the loop never
-        // reached a running cell; R13 retired the slot (DC-46) and it
-        // promptly did. Three parallel searches, the last two settling
-        // first: their cards pushed the region over the cap, the loop
-        // committed the FIRST call — still in flight — froze its
-        // three-row running card and its breathing mark into the
-        // scrollback, and stepped `#committed` past it. When the result
-        // arrived there was no live cell left to draw it into, so the work
-        // never reached the screen at all.
-        //
-        // A cell that is not done has no committed form yet; committing
-        // one is writing history that has not happened. When the head is
-        // running, the region gives way instead — the cards behind it
-        // degrade first, then the running window shrinks (DC-43's own
-        // ladder, in #liveProjection), and the remainder is counted.
-        // The guard is on a RUNNING TOOL CALL specifically, not on any
-        // unfinished cell. A streaming text or raw cell HAS a committed
-        // form — the rows it has already written are final, append-only —
-        // and spilling those is exactly what this loop is for. A running
-        // call does not: its card changes shape at the settle, so a
-        // committed one is a row that will never be corrected.
-        while (liveLines.length > H - 4 - inputExtra - queueRows.length && // V6-3: the content cap H−4 (KC1: −N's extra rows)
+    }
+    /** Phase 2 — ONE overlay selector: what occupies the live region
+     *  this frame. The transcript viewer (R5), the keys sheet (TUI2-R1
+     *  D) and the approval panel (W21) each REPLACE the live region —
+     *  it is what the human is reading right now — capped at the
+     *  content cap; the sheet and the viewer open only from an idle
+     *  composer, so neither can coexist with a panel. The panel also
+     *  reports where its clickable rows are (TUI2-R3v2 ②: the rows and
+     *  the span come from one call, so the hit-test reads the arithmetic
+     *  that placed the rows). Otherwise the projection of the live
+     *  cells. render() paints this and
+     *  liveCount() measures it — the same rows, by construction. */
+    #liveRows(W, ctx, cap) {
+        const capped = Math.max(1, cap);
+        if (this.#viewer !== null)
+            return { lines: this.#viewerBand(W).slice(0, capped), panelSpan: null };
+        if (this.#sheetState?.() === true)
+            return { lines: keysSheetRows(W).slice(0, capped), panelSpan: null };
+        const panel = this.#panelState?.() ?? null;
+        if (panel !== null) {
+            // W21: the panel's cap is exact, so the force-commit loop never
+            // fires on it. W22: the queue band sits below the panel — the
+            // cap shrinks by it.
+            const frame = panelFrameOf(panel, W, capped);
+            return { lines: frame.rows, panelSpan: frame.options };
+        }
+        return { lines: this.#liveProjection(W, ctx, cap), panelSpan: null };
+    }
+    /** Phase 3 — the FORCE commits: overflow past the content cap
+     *  commits the oldest live cell (W22: the queue band shrinks the
+     *  cap by its rows) — but NEVER A TOOL CALL STILL RUNNING (DC-53).
+     *  A running card has no committed form yet: its shape changes at
+     *  the settle, so a committed one would be a row that is never
+     *  corrected — measured as a burst's first call frozen into the
+     *  scrollback with its breathing mark, its result never drawn. A
+     *  streaming text or raw cell DOES have a committed form (its rows
+     *  are final, append-only) and spills normally. When the head is
+     *  running the region gives way instead: the cards behind it
+     *  degrade, then the window shrinks (#liveProjection). */
+    #capLive(lines, W, ctx, cap) {
+        while (lines.length > cap && // V6-3: the content cap H−4 (KC1: −N's extra rows)
             this.#committed < this.#cells.length &&
             !(this.#cells[this.#committed].kind === "tool" && !this.#cells[this.#committed].done)) {
-            // 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);
             // 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);
+            lines = this.#liveProjection(W, ctx, cap);
         }
-        // 4. the geometry — the live region's first row:
-        //    liveTop = min(totalCommitted, H - liveRows) + 1 — the screen
-        //    shows the bottom H rows; the live region anchors to the bottom.
-        const liveRowsTotal = liveLines.length + chromeRows;
-        const liveTop = Math.min(this.#committedLines, H - liveRowsTotal) + 1;
-        // TUI2-R3v2 ②: the option rows' ABSOLUTE screen rows, recorded per
-        // frame. A click is answered against the frame the human was looking
-        // at when they clicked, which is this one.
-        this.#panelRowSpan =
-            panelSpan === null ? null : { top: liveTop + panelSpan.offset, count: panelSpan.count, first: panelSpan.first };
-        // 5. the frame bytes.
+        return lines;
+    }
+    /** Phase 5 — the frame bytes: the one-time reset, autowrap off, the
+     *  synchronised-update bracket, the ONE renderer, and the
+     *  bookkeeping the next frame's relative moves start from. */
+    #paint(W, H, liveTop, liveLines, liveRowsTotal, chrome) {
         const out = [];
         // REL-0152-D14 — AUTOWRAP OFF for the frame's duration.
         //
@@ -2266,28 +1913,12 @@ export class Body {
         // never paired with a ?25h. Sync (2026) still brackets the frame
         // where the terminal understands it.
         out.push(this.#conservative ? "\x1b[?25l" : "\x1b[?2026h\x1b[?25l");
-        // A8: the bottom-anchored window (the model's last H rows) shifts
-        // DOWN when the live region SHRINKS — the done-fold, the fold-hold
-        // release at the terminal event. The steady path's scroll syncs
-        // exactly N committed lines, but the window moves N + liveDelta:
-        // a shrink with commits (liveTop grows by LESS than N — the scroll
-        // overshoots by liveDelta) slips past the pure-shrink trigger, the
-        // stale pass erases the old live rows, and nothing re-paints the
-        // band between the committed window and the new liveTop (finding
-        // #A8 — the W11-boundary pileup). A GROWTH is safe on the steady
-        // path (the new live's bottom-anchored extent covers the old — the
-        // erased rows are all re-painted); a shrink takes the full-redraw
-        // path: the window re-paints at the model's positions, every row
-        // covered (the V6-1 every-row rule).
-        // REL-0152-R1: ONE renderer. The steady/full split existed because
-        // the steady path moved rows by scrolling and could not handle a
-        // window that moved the wrong way, so the frames it could not draw
-        // were handed to a full repaint. A diff has no such frames: it
-        // emits the rows that differ, and on a frame where everything
-        // differs that IS a full repaint. The dispatch, the two geometries
-        // and the invariant about which moves each path may use all go
-        // with it.
-        this.#drawFull(out, W, H, liveTop, liveLines, queueRows, menuRows, editor);
+        // REL-0152-R1: ONE renderer. A diff emits the rows that differ, and
+        // on a frame where everything differs that IS a full repaint — so
+        // the old steady/full split (a scrolling path that could not draw
+        // a window moving the wrong way, finding #A8) has nothing left to
+        // dispatch between.
+        this.#drawFull(out, W, H, liveTop, liveLines, chrome.queueRows, chrome.menuRows, chrome.editor);
         this.#fullRedraw = false;
         // REL-0161: the frame close no longer shows the cursor — hidden IS
         // the steady state (Terminal.app infers "a prompt line" from
@@ -2305,19 +1936,11 @@ export class Body {
         }
         this.#lastLiveTop = liveTop;
         this.#lastLiveRows = liveRowsTotal;
-        this.#lastInputRows = editor.rows.length;
+        this.#lastInputRows = chrome.editor.rows.length;
         // KC1 §6: the next steady frame's relative moves start where THIS
         // frame's CHA parked the cursor — the marker's row inside the
         // composer (N = 1 ⇒ H−2, the retired hard-coded anchor).
-        this.#lastAnchorRow = H - 1 - editor.rows.length + editor.markerRow;
-    }
-    /** R13 D1 — the same constant as everything else. This used to compute
-     *  the lead from a ONE-ROW STAND-IN so the live block would claim the
-     *  spacing its fold was going to get; with the rhythm constant there
-     *  is nothing to simulate, and R7a's device retires with the formula
-     *  that needed it. */
-    #blockSpace(i, prev, rows) {
-        return bodySpacing(this.#lastDrawn(i, prev), rows);
+        this.#lastAnchorRow = H - 1 - chrome.editor.rows.length + chrome.editor.markerRow;
     }
     #space(i, prev, rows) {
         if (i > 0 && this.#cells[i]?.kind === "md" && this.#cells[i - 1]?.kind === "md")
@@ -2326,18 +1949,9 @@ export class Body {
         // so a settle changes content and never position by construction.
         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.
-     */
+    /** The previous DRAWN sibling, not the previous cell: the spacing
+     *  formula reads what stood above, and a cell that rendered nothing
+     *  did not stand above anything (R3i). */
     #lastDrawn(i, prev) {
         if (prev !== null && prev.length > 0)
             return prev;
@@ -2356,238 +1970,36 @@ export class Body {
      *  this cell's commit — the cache stays raw, the placed rows count. */
     #commitCell(i, W, ctx) {
         const cell = this.#cells[i];
-        const lines = this.#foldOrRollup(cell, i, W, ctx);
-        // W15: a tool cell whose committed rows carried the "ctrl+o"
-        // affordance joins the expand history — the detection is the
-        // renderer's OWN output, so the read's "/last"-only cut note never
-        // lands here. TUI2-R1 (A/B): the affordance is no longer only the
-        // renderer cut's "└ … ctrl+o" — the self-naming head suffix and
-        // the exploration row carry it on the HEAD row, and a promise the
-        // key does not answer would be the one thing worse than silence.
-        // 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.
-        // 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.
-        // R4a — the ring captures by IDENTITY, not by searching our own
-        // printed bytes.
-        //
-        // This used to require the rendered rows to contain the literal
-        // "ctrl+o", which made the affordance LOAD-BEARING: retiring the
-        // printed key (the owner's ruling) would have silently emptied the
-        // ring and taken the expand key with it — not a missing hint, a
-        // missing feature. A fold head is a fold head because the segment
-        // says so; a tool cell is expandable when it is hiding rows.
-        const isFoldHead = this.#segmentOf(i)?.headCell === i;
-        const hidesRows = cell.kind === "tool" && lines.some((l) => l.includes("ctrl+o"));
-        if (isFoldHead || hidesRows) {
+        const lines = cellComponent(cell).render(W, ctx);
+        // W15: a tool cell whose committed rows hide something (its rows
+        // carry the "ctrl+o" affordance — the renderer's OWN output, so the
+        // read's "/last"-only cut note never lands here) joins the collapsed
+        // index the viewer reads (ctrl+r). unshift: cells commit
+        // oldest-first, so the newest cut is at the front.
+        if (cell.kind === "tool" && lines.some((l) => l.includes("ctrl+o")))
             this.#collapsed.unshift(i);
-            // R4a — a new fold resets the walk, so the FIRST press after any
-            // new work always opens the most recent one. That is the whole
-            // of the owner's "which one does it open": the answer is always
-            // "the last one", and repeats walk back from there.
-            this.#opened.clear();
-        }
         this.#lineCache[i] = lines;
         const placed = this.#space(i, i > 0 ? this.#lineCache[i - 1] : null, lines);
         this.#committed += 1;
         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.
-     */
-    /**
-     * 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
-        // 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;
-    }
-    /** 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
-     *  of a released turn commits normally). The force-commit path never
-     *  consults this — the screen's hard cap wins over the hold. */
-    #held(i) {
-        // R13 — NOTHING IS HELD ANY MORE. DECLARED REVERSAL of W14's
-        // quiet-turn hold, R3b/R3i's segment hold and TUI2-R1.5 ①'s
-        // explore-run hold, all three of them owner-ruled away on
-        // 2026-09-03 with the mechanism they served.
-        //
-        // Every one of them existed for the same reason: a done cell's
-        // COMMITTED FORM was undecided while its segment or its run was
-        // still open, because a fold line or a rollup row might yet stand
-        // for it — and a committed row cannot be taken back (ADR-0046).
-        // With no fold and no rollup, a call's committed form is its own
-        // card and is settled the instant the call is: there is nothing
-        // left to wait for.
-        //
-        // It is not only dead weight. Holding done cells in the live
-        // region made the region carry work that was FINISHED, so a burst
-        // of four reads and a shell in flight competed for the same rows
-        // and DC-43's shrink took the running call's output away — the
-        // one thing on the screen the human is waiting for (R7a D). Let
-        // them commit and the room is there.
-        void i;
-        return false;
-    }
-    /* R13 — `#growingRun` retired with the rollup's commit hold (#held). */
-    /** W14/W13 — the release-time decision at a commit, BEFORE the cell's
-     *  own render: the folded-turn fold first (a QUIET turn — ended, no
-     *  text — becomes the ONE fold line; the rest of its thinking/tool
-     *  cells render [] after the fold), then the W13 rollup (a text
-     *  turn's N > 2 same-tool run: the HEAD renders the group summary,
-     *  the members render [] — the scan is the work order's "group key",
-     *  derived at commit time, never pre-stored). */
-    #foldOrRollup(cell, i, W, ctx) {
-        // R13 — DECLARED REVERSAL, three at once, all of them the same
-        // idea and all of them owner-ruled on 2026-09-03:
-        //
-        //   · the SEGMENT FOLD (R3b–R3i, W14) — a closed stretch of two or
-        //     more cells collapsed into one settled line;
-        //   · the W13 ROLLUP and the `rolled` cell field — a run of three
-        //     or more same-tool calls collapsed into a group summary;
-        //   · TUI2-R1 (B)'s EXPLORATION ROW — the mixed read-only variant
-        //     of the same collapse.
-        //
-        // Every one of them answered the same pressure: ungrounded output
-        // rows owned the screen, so work was collapsed into sentences
-        // ABOUT the work. The card is what changes that arithmetic — a
-        // call's rows sit inside a surface that says where it begins and
-        // ends, so five of them read as one object rather than five loose
-        // lines — and the owner's ruling is that the collapse costs more
-        // than it buys: a page where the machine's work is sometimes a
-        // card, sometimes a summary line and sometimes nothing at all is
-        // a page a reader cannot predict. One rhythm, one surface.
-        //
-        // So every cell renders itself, and this method is the record of
-        // what used to happen here. What the folds bought is bought
-        // differently now: the preview cap (five rows a call, E1's read
-        // showing none) is what keeps a burst from owning the screen, and
-        // it is a CONSTANT per call rather than a decision about runs.
-        //
-        // What goes with them: `#growingRun`'s commit hold existed only so
-        // a run's committed FORM could be decided once the run closed —
-        // with no run-level form left to decide, a done cell commits when
-        // it is done. `#rolledHeads`, `rolledOf`, `rolledTitle`,
-        // `rolledDetail` and the `rolled` field go with the rollup.
-        return cellComponent(cell).render(W, ctx);
-    }
+    /* DECLARED REVERSAL (R13, owner-ruled 2026-09-03): the segment
+       bookkeeping stood here — `#stampSegment`, `#segmentOf`,
+       `#segmentHasTrouble`, `#segmentTroubleTerms`, `#markSpilled` — and
+       with it the three commit HOLDS (`#held`: W14's quiet turn, R3b/R3i's
+       segment, TUI2-R1.5 ①'s explore run). All of it decided whether a
+       fold or a rollup would stand for a done cell. Nothing folds, so a
+       done cell commits the instant it is done, and holding it back only
+       made finished work compete with the running call for rows (R7a D). */
+    /* DECLARED REVERSAL (R13, owner-ruled 2026-09-03): `#foldOrRollup`
+       stood here — the commit-time decision whether a cell rendered
+       itself, a segment's fold line (R3b–R3i, W14), a W13 rollup summary
+       or TUI2-R1 (B)'s exploration row. All three collapses answered one
+       pressure (ungrounded output rows owning the screen) by turning work
+       into sentences ABOUT work; the card answers it with a constant
+       preview cap per call, and a page whose work is always the same
+       shape is one a reader can predict. Every cell renders itself. */
     /** The slot occupant's extra rows — the slash-command menu (above the
      *  status, in the rhythm gap + the content's spare rows — the old
      *  menu's position, slot-shaped). */
@@ -2944,38 +2356,30 @@ export class Body {
         // sit with the live band empty and the chrome at its minimum — the
         // one-way part of a movement that otherwise goes both ways.
         if (this.#resizeFrame) {
-            // REL-0152-R1: a resize scrolls NOTHING of ours. Shrinking the
-            // window is the terminal's own scroll — it reflows the old
-            // content and pushes the overflow into its scrollback before we
-            // are called — so emitting our own LFs on top put the same rows
-            // in twice (TT-1B: twelve rows of a forty-line burst). The
-            // counter adopts the terminal's work, and the held screen is
-            // discarded because a reflow invalidates every row of it: the
-            // next diff repaints the whole screen, which is exactly what a
-            // resize needs.
-            // DC-34 — NO HIGH-WATER MARK ON A RESIZE.
+            // R14 / route B — THE RESIZE FRAME SCROLLS LIKE ANY OTHER.
             //
-            // This was `max(#scrolledOff, …)`, which held a stale count
-            // whenever a widen made the fresh one smaller; `leaving` then
-            // stayed <= 0 and the text that marched past in the meantime
-            // never entered the scrollback at all — the hole, the other
-            // half of the same off-by-a-refold.
+            // Everything this branch used to hold is retired with the
+            // window arithmetic it served. It adopted the terminal's own
+            // reflow-scroll into `#scrolledOff` (REL-0152-R1), then had to
+            // stop adopting it on a widen and keep adopting it on a narrow
+            // (DC-34), because the counter it was feeding meant a different
+            // thing at every fold width. There is no such counter to feed
+            // now: `#settleResize` erased the terminal and set
+            // `#scrolledOff` to zero, so the frontier is real and empty and
+            // the frame simply reprints from the top.
             //
-            // The other implementation in this space reached the same
-            // conclusion independently and says so in its own source: a
-            // historical high-water mark "caused self-reinforcing
-            // inflation that pushed content into scrollback on terminal
-            // widen". Dropping it alone brings the DUPLICATE back — it is
-            // the pair with the no-refold rule above, not a substitute
-            // for it.
-            // PROBE 3: a widen leaves it ALONE; a narrow keeps REL-0152-R1.
-            if (this.#refolded)
-                this.#scrolledOff = Math.max(this.#scrolledOff, Math.max(0, Math.min(skip, all.length)));
-            this.#refolded = false;
+            // Falling through to `#emitScroll` is not a convenience — it is
+            // the whole point. The transcript above the last screenful has
+            // to reach the scrollback, chunked and staged from the model,
+            // exactly as a resumed session's replay does. Without it the
+            // reprint painted the last screenful onto a terminal whose
+            // history it had just erased, and everything above was simply
+            // GONE: `dc34-widen-seam` measured 36 tokens missing from the
+            // scrollback the first time this branch was left in place.
             this.#screen = new Array(H).fill(NOT_PAINTED);
             this.#resizeFrame = false;
         }
-        else if (!overlay) {
+        if (!overlay) {
             // DC-46 — THE ROWS THAT LEAVE THE WINDOW SCROLL, and the target
             // is `skip` itself.
             //
@@ -3009,26 +2413,12 @@ export class Body {
         // OLDEST on screen — they are still in the model and come back on
         // the close.
         const contentRows = Math.max(0, H - CHROME_ROWS - inputExtra - queueRows.length - menuRows.length);
-        // DC-34 — THE MARCH NEVER REACHES BELOW THE FRONTIER.
-        //
-        // Rows [0, #scrolledOff) are in the terminal's scrollback and are
-        // immutable; painting one puts the same prose on screen twice,
-        // which is the owner's report. `skip` can drop below it whenever
-        // the model shrinks under a fixed screen — a widen refolding the
-        // cells above the frontier, or the live band collapsing — and
-        // nothing stopped it (rider 3's ungated reach-back).
-        //
-        // Clamping costs a gap under short content for one frame, which
-        // the next commit fills. Reaching back costs a duplicate that
-        // stands in the transcript forever.
-        // ...but only when the WIDTH moved. A height change re-indexes
-        // nothing — the folds are untouched, every row means what it
-        // meant — so reaching back there is the pre-existing behaviour a
-        // gate already covers (the A8 windowing case: grow the screen and
-        // the banner returns). The duplication measured in this round is
-        // width-driven, and so is the guard.
-        const march = all.slice(this.#lastW !== 0 && this.#lastW !== W ? Math.max(skip, this.#scrolledOff) : skip);
-        this.#lastW = W;
+        // The march starts at `skip`, which is already clamped to the
+        // frontier above (rows in [0, #scrolledOff) are the terminal's and
+        // are never painted again). DC-34's width-only reach-back guard
+        // stood here until R14: a resize now reprints from the model, so
+        // there is no stale fold for a width change to re-index.
+        const march = all.slice(skip);
         for (const line of march.length > contentRows ? march.slice(march.length - contentRows) : march) {
             desired[r - 1] = this.#checked(line, W);
             r += 1;
@@ -3052,7 +2442,7 @@ export class Body {
             desired[H - 2 - inputExtra + i - 1] = this.#checked(editor.rows[i], W);
         desired[H - 1 - 1] = boxBottom(W);
         const statusRow = this.#statusSource();
-        desired[H - 1] = this.#checked(statusLine(statusRow.status, this.#tail, W, statusRow.hint), W);
+        desired[H - 1] = this.#checked(statusLine(statusRow.status, this.#tail, W, statusRow.hint, statusRow.expand), W);
         this.#emitDiff(out, W, H, desired);
         // REL-0152-R1: park from where the cursor ACTUALLY is — see
         // #cursorRow. It used to be parked from H, which the bottom-up