@vincemakes/kiso-tui 0.19.0 → 0.20.0

package/dist/ask-panel.d.ts

@@ -73,8 +73,39 @@ export declare function askDescriptionStop(q: AskQuestion, W: number): number;
  *  type-your-own line last. R2: the shape is the RULE's — rule,
  *  title, header, body, affordance, rule. */
 export declare function askBlockRows(view: PanelView, state: AskRuntime, W: number, maxRows: number): string[];
-/** The status row's right-hand hint — the phase's keys. */
-export declare function askAffordance(state: AskRuntime): string;
+/**
+ * R6/D2 — the affordance names the FINISHER, and it names the real keys.
+ *
+ * Three defects lived in the one line this replaces:
+ *  - it never mentioned ENTER, on the one panel shape where enter is the
+ *    only way to finish. The owner could not find the finisher because
+ *    the screen did not name it;
+ *  - it said the same words in both modes, while a digit means two
+ *    different things across them (take vs mark);
+ *  - it hardcoded "1-4" whatever the option count was — the same defect
+ *    REL-0152-D3 fixed in the input LEAD one function up, and missed
+ *    here.
+ *
+ * The clauses are returned whole; `askAffordanceFit` below is what a
+ * width-bound caller uses.
+ */
+export declare function askAffordance(state: AskRuntime, q?: AskQuestion): string;
+/**
+ * The affordance at a width, by the DC-2 clause ladder.
+ *
+ * The row this serves used to be pushed UNCUT into the panel block
+ * (`askBlockRows`), unlike the approval's cutLine'd row — and panel rows
+ * go through `#checked`, which THROWS on any row wider than W
+ * (invariant ①). A multi-question ask on question 2 at W ≤ 41, or any
+ * ask at W ≤ 32, killed the renderer. So the ladder is not polish; it is
+ * the fix for a crash.
+ *
+ * The order gives way from the least load-bearing inward, and the LAST
+ * standing pair in both modes is the way through and the way out. In
+ * multi, `⏎ sends` is the fact whose absence caused this whole finding:
+ * it gives way never.
+ */
+export declare function askAffordanceFit(state: AskRuntime, q: AskQuestion | undefined, W: number): string;
 /** The status row's left text — the ask's own line, with the walk. */
 export declare function askStatus(view: PanelView, state: AskRuntime): string;
 /** The input row's lead: the digit lead while picking, the typing lead

package/dist/ask-panel.js

@@ -149,7 +149,27 @@ export function askKey(spec, state, key) {
         // row's neighbours answer with.
         if (state.cursor === customRow(q))
             return { state: { ...state, phase: "custom" } };
-        return answered(state, state.qIndex) ? advance(spec, state) : { state };
+        if (answered(state, state.qIndex))
+            return advance(spec, state);
+        // R6/D2 — ENTER TAKES THE BAR'S ROW.
+        //
+        // It used to return `{ state }` here: the cursor is not a pick, so
+        // bar-on-option-1 + enter did NOTHING, in either mode, with no
+        // message. The approval panel ruled the opposite in TUI2-R3v2 ①
+        // ("the panel used to ignore the key every human presses first"),
+        // so the product had two selection models under one identical
+        // bar — and the owner's dogfood is that trap verbatim: bar to
+        // option 1, enter (silence), "do I really have to type 1?", digit
+        // (a mark appears), enter (it commits).
+        //
+        // Single-select takes the row and advances, which is what the bar
+        // has always promised. Multi MARKS the row and stays: the press
+        // becomes visible (◯ → ◉), which teaches the mode in one frame,
+        // and the second enter sends the set. A press that "did nothing"
+        // is the defect; a press that does the smallest true thing is the
+        // fix.
+        const taken = toggle(state, state.cursor, multi);
+        return multi ? { state: taken } : advance(spec, taken);
     }
     // SPACE selects at the cursor and NEVER commits — in either mode. It
     // used to answer-and-advance a single-select question, which made a
@@ -270,7 +290,10 @@ export function askBlockRows(view, state, W, maxRows) {
     // here), but the multi-select gesture it carried is INFORMATION and
     // rides the header instead — dropping it would have been a regression
     // wearing a restyle's clothes.
-    const gesture = multi ? `${p.dim} · pick any — space toggles${p.reset}` : "";
+    // R6/D2: the header names the MODE; the keys live on the keys row,
+    // once. It used to name `space toggles` there and nowhere say what
+    // finishes the set.
+    const gesture = multi ? `${p.dim} · pick any${p.reset}` : "";
     rows.push(`  ${cutLine(`${p.dim}${header}${p.reset}${gesture}`, Math.max(1, W - 2))}`);
     rows.push("");
     const picks = state.picks[state.qIndex] ?? [];
@@ -311,7 +334,9 @@ export function askBlockRows(view, state, W, maxRows) {
     else {
         rows.push(...body);
     }
-    rows.push(`  ${p.dim}${askAffordance(state)}${p.reset}`);
+    // R6/D2: FITTED, and the two-space indent is inside the budget —
+    // the uncut push here is what made a narrow ask throw.
+    rows.push(`  ${p.dim}${askAffordanceFit(state, q, Math.max(1, W - 2))}${p.reset}`);
     // R2, shared with the approval panel: the block closes with the SAME
     // dashed rule it opened with, and the same one the composer uses.
     // TUI2-R1.5 ⑪ had already replaced a two-cell `\u2514 ` stub with a
@@ -320,11 +345,68 @@ export function askBlockRows(view, state, W, maxRows) {
     rows.push(`${p.dim}${"\u2500".repeat(Math.max(0, W))}${p.reset}`);
     return rows;
 }
-/** The status row's right-hand hint — the phase's keys. */
-export function askAffordance(state) {
+/**
+ * R6/D2 — the affordance names the FINISHER, and it names the real keys.
+ *
+ * Three defects lived in the one line this replaces:
+ *  - it never mentioned ENTER, on the one panel shape where enter is the
+ *    only way to finish. The owner could not find the finisher because
+ *    the screen did not name it;
+ *  - it said the same words in both modes, while a digit means two
+ *    different things across them (take vs mark);
+ *  - it hardcoded "1-4" whatever the option count was — the same defect
+ *    REL-0152-D3 fixed in the input LEAD one function up, and missed
+ *    here.
+ *
+ * The clauses are returned whole; `askAffordanceFit` below is what a
+ * width-bound caller uses.
+ */
+export function askAffordance(state, q) {
     if (state.phase === "custom")
         return "enter answers · esc backs out";
-    return state.qIndex > 0 ? "1-4 pick · t type · ← back · esc decline" : "1-4 pick · t type · esc decline";
+    const n = q?.options.length ?? 4;
+    const multi = q?.multiSelect === true;
+    const back = state.qIndex > 0 ? ["← back"] : [];
+    return (multi
+        ? ["↑↓ move", `space or 1-${n} marks`, "⏎ sends the set", "t types", ...back, "esc declines"]
+        : ["↑↓ move", "⏎ confirms", `1-${n} instant`, "t types", ...back, "esc declines"]).join(" · ");
+}
+/**
+ * The affordance at a width, by the DC-2 clause ladder.
+ *
+ * The row this serves used to be pushed UNCUT into the panel block
+ * (`askBlockRows`), unlike the approval's cutLine'd row — and panel rows
+ * go through `#checked`, which THROWS on any row wider than W
+ * (invariant ①). A multi-question ask on question 2 at W ≤ 41, or any
+ * ask at W ≤ 32, killed the renderer. So the ladder is not polish; it is
+ * the fix for a crash.
+ *
+ * The order gives way from the least load-bearing inward, and the LAST
+ * standing pair in both modes is the way through and the way out. In
+ * multi, `⏎ sends` is the fact whose absence caused this whole finding:
+ * it gives way never.
+ */
+export function askAffordanceFit(state, q, W) {
+    if (state.phase === "custom")
+        return cutLine("enter answers · esc backs out", W);
+    const n = q?.options.length ?? 4;
+    const multi = q?.multiSelect === true;
+    const back = state.qIndex > 0 ? ["← back"] : [];
+    const act = multi ? `space or 1-${n} marks` : `1-${n} instant`;
+    const go = multi ? "⏎ sends the set" : "⏎ confirms";
+    const tiers = [
+        ["↑↓ move", act, go, "t types", ...back, "esc declines"],
+        ["↑↓ move", act, go, ...back, "esc declines"],
+        [act, go, ...back, "esc declines"],
+        [multi ? "space marks" : `1-${n} picks`, multi ? "⏎ sends" : "⏎ confirms", "esc declines"],
+        [multi ? "⏎ sends" : "⏎ confirms", "esc declines"],
+    ];
+    for (const tier of tiers) {
+        const row = tier.join(" · ");
+        if (visibleWidth(row) <= W)
+            return row;
+    }
+    return cutLine(tiers[tiers.length - 1].join(" · "), W);
 }
 /** The status row's left text — the ask's own line, with the walk. */
 export function askStatus(view, state) {
@@ -380,7 +462,7 @@ export function panelAffordance(view, phase, cursor, ask, pick, safer) {
     if (view.pick !== undefined && pick !== undefined)
         return pickAffordance(pick);
     if (view.ask !== undefined && ask !== undefined)
-        return askAffordance(ask);
+        return askAffordance(ask, view.ask.questions[ask.qIndex]);
     return basePanelAffordance(view, phase, cursor, safer);
 }
 /** The whole panel state in one call — the compositor's four reads share

package/dist/compositor.js

@@ -52,7 +52,7 @@ import { MOUSE_OFF } from "./editor.js";
 import { atPanelRows, bandHeader } from "./at-picker.js";
 // TUI2-R2 ②: the session picker's rows — the band's third occupant.
 import { sessionPickerRows } from "./session-picker.js";
-import { ACT_SLOT_ROWS, Container, ROLLUP_NOUN, MOTION_FRAMES, MdStream, bodySpacing, boxBottom, boxTop, cellComponent, exploreCounts, foldCountsObjects, foldTerms, focusToken, exploreRows, foldLine, cutLine, isExploreTool, moreRunningRow, pendingQueueRows, slotPad, slotTail, statusLine, stretchLine, turnFold, visibleWidth, twinkleFrame, } from "./components.js";
+import { ACT_SLOT_ROWS, Container, ROLLUP_NOUN, MOTION_FRAMES, MdStream, bodySpacing, boxBottom, boxTop, cellComponent, exploreCounts, foldCountsObjects, foldTerms, focusToken, exploreRows, foldLine, cutLine, isExploreTool, moreRunningRow, pendingQueueRows, slotPad, slotTail, statusLine, stretchLine, turnFold, visibleWidth, breathFrame, } from "./components.js";
 import { bannerLines, escapeTerminal, foldResult, foldThinking, palette, renderTerminalGap, renderToolSummary, toolTarget } from "./render.js";
 import { displayVerb, keysSheetRows } from "./strings.js";
 // R5 — the transcript viewer's PURE projection. The compositor supplies
@@ -476,7 +476,7 @@ export class Body {
         // W14: the turn boundary — the record the fold-hold's release
         // state machine reads; the cell carries the record's index. A9:
         // the user's own words ride the record — the fold's leading chip.
-        this.#turns.push({ ended: false, hasText: false, thoughtSeconds: 0, reads: 0, edits: 0, others: new Map(), seen: new Map(), words: text, folded: false, segments: [] });
+        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: [] });
         this.#cells.push({ kind: "user", text, done: true, turn: this.#turns.length - 1 });
         this.#mark();
     }
@@ -491,21 +491,35 @@ export class Body {
         }
         else {
             this.#cells.push({ kind: "thinking", text, done: false, turn: this.#turns.length - 1 });
-            // R3b: thinking is WORK, so it opens a segment too — a turn that
-            // thinks, speaks, then thinks again has two segments, and the
-            // second one's clock starts here rather than at a tool call it
-            // may never make.
+            // DECLARED SUPERSESSION (R7, owner-ruled 2026-08-31) — THINKING
+            // IS WORDS, NOT WORK.
             //
-            // OPEN then STAMP, in that order: the stamp records the segment
-            // the cell belongs to, and a stamp taken first records the
-            // PREVIOUS segment (or none at all) — which left the thinking
-            // row standing outside the fold it should have led.
-            const seg = openSegment(this.#turns[this.#turns.length - 1], Date.now());
-            // R3i: the stretch's thinking clock starts HERE — at the first
-            // delta of this stretch, the same moment the CLI starts the
-            // turn's — and stops at the next non-thinking event below.
-            if (seg !== null && seg.thinkingSince === null)
-                seg.thinkingSince = Date.now();
+            // 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.
+            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
@@ -514,7 +528,6 @@ export class Body {
             // derivation, so without the beat they also never ticked: the
             // row read `thinking 0s` for as long as the model thought.
             this.#armSpinner();
-            this.#stampSegment();
         }
         this.#mark();
     }
@@ -630,6 +643,9 @@ export class Body {
             }
         }
         this.#stampSegment();
+        const t1 = this.#turns[this.#turns.length - 1];
+        if (t1 !== undefined)
+            t1.begun = true; // R6/D1: the block allocates here
         this.#mark();
     }
     toolApproval(callId, diff) {
@@ -1934,8 +1950,10 @@ export class Body {
         const openSeg = open !== null && open.closedAt === null ? open : null;
         let prev = this.#committed > 0 ? this.#lineCache[this.#committed - 1] : null;
         let stretchDrawn = false;
+        let lastIdx = this.#committed;
         for (let i = this.#committed; i < this.#cells.length; i += 1) {
             const cell = this.#cells[i];
+            lastIdx = i;
             const inOpen = openSeg !== null && openSeg.cells.includes(i);
             if (inOpen) {
                 // R4 — the open stretch is ONE contiguous block: its line
@@ -1950,11 +1968,35 @@ export class Body {
                 if (stretchDrawn)
                     continue;
                 stretchDrawn = true;
+                // R7a — a ONE-CELL stretch draws NO line.
+                //
+                // It said `running 1 shell command` directly above a row
+                // reading `● shell npm run check`: the same fact twice, and
+                // fable's R4 review had already named the duplication. R7
+                // then made it a SWALLOW as well — a one-cell segment does
+                // not fold, so that line has no committed counterpart and
+                // vanished at the settle, taking a row off the screen. The
+                // call's own head row is the line; a summary of one thing
+                // is the thing.
+                const single = openSeg.cells.filter((j) => this.#cells[j]?.kind === "tool").length <= 1;
                 const rows = [
-                    ...stretchLine({ ...this.#stretchTerms(openSeg), liveNames: this.#liveNames(openSeg), phase: this.#stretchPhase(openSeg), mark: twinkleFrame(this.#spinnerI) }, W),
+                    ...(single
+                        ? []
+                        : stretchLine({ ...this.#stretchTerms(openSeg), liveNames: this.#liveNames(openSeg), phase: this.#stretchPhase(openSeg), ...(this.#inFlight(openSeg) ? { mark: breathFrame(this.#spinnerI) } : {}) }, W)),
                     ...this.#actSlot(openSeg, W, ctx, budget, focus),
                 ];
-                out.push(...this.#space(i, prev, rows));
+                // R7a — the block TAKES the W11 blank, like everything else.
+                //
+                // CORRECTION of my own R6/D1 change, which removed it. The
+                // reasoning then was that the committed fold is a single row
+                // and single rows take no blank — but `bodySpacing` gives a
+                // blank after any MULTI-row sibling, and the thinking block
+                // above the work is exactly that. So the committed side had
+                // one and the live side did not, and a blank row APPEARED at
+                // every settle, shoving everything below it down. The owner
+                // saw it and said the blank is the correct form; it is, and
+                // the fix is to have it on both sides rather than neither.
+                out.push(...this.#blockSpace(i, prev, rows));
                 prev = rows;
                 continue;
             }
@@ -1966,8 +2008,52 @@ export class Body {
             out.push(...this.#space(i, prev, rows));
             prev = rows;
         }
+        // R6/D1 — THE BLOCK STANDS FOR THE TURN, not for the stretch.
+        //
+        // R4 made the block's height constant WITHIN a stretch. Between
+        // two stretches it was released and rebuilt, so the live region
+        // breathed by its whole height twice per stretch — and the live
+        // region is anchored to the bottom (liveTop below), so every
+        // committed row on screen moved with it. The owner's report, and
+        // their own formulation of the cure: "once something is at a line
+        // it should not jump up or down — hold the absolute position and
+        // update the content there."
+        //
+        // So when the turn has begun work and no open stretch drew the
+        // block above, it is drawn HERE, after the live cells, with its
+        // top row swapped to the slot's own pad: the closed stretch's
+        // terms are already the committed fold row further up, and
+        // printing them again one screen apart is the duplication A9's
+        // narrowing forbids.
+        //
+        // Projection-only. Commit order, commit timing and every
+        // committed byte are untouched — which is why the transcript this
+        // leaves behind cannot regress: it cannot differ.
+        if (!stretchDrawn && turn !== undefined && !turn.ended && turn.begun) {
+            // R7a: the top row is BLANK, not a `│`. It stands where the
+            // stretch line stands while a stretch is open, and between two
+            // stretches there is no line to draw — a bare gutter there is
+            // a mark on a row with nothing to mark (law 1.3), and it is
+            // the "long vertical line" the owner saw under a finished
+            // turn. The ROW is what holds the height; the glyph never was.
+            const rows = ["", ...this.#actSlot(null, W, ctx, budget, focus)];
+            out.push(...this.#blockSpace(lastIdx, prev, rows)); // R7a: the same blank
+        }
         return out;
     }
+    /** R6/D1 — the turn's most recent CLOSED segment: what the block
+     *  shows in the gap between two stretches. */
+    #lastClosedSegment() {
+        const turn = this.#turns[this.#turns.length - 1];
+        if (turn === undefined)
+            return null;
+        for (let i = turn.segments.length - 1; i >= 0; i -= 1) {
+            const seg = turn.segments[i];
+            if (seg.cells.some((j) => j >= this.#committed))
+                return seg;
+        }
+        return null;
+    }
     /**
      * R4 — the standing act slot's rows. EXACTLY `budget` rows in every
      * phase, so the live region's height changes twice per stretch (once
@@ -1995,7 +2081,16 @@ export class Body {
                 rows[0] = focusToken(rows[0], W);
             return rows;
         };
-        const live = seg.cells.filter((i) => i >= this.#committed);
+        // R6/D1: with no open stretch (the gap BETWEEN two of them) the
+        // slot looks at the turn's last closed segment instead — the call
+        // that just finished keeps its head and its tail, which is R4 B's
+        // rule extended across the boundary. Cells outlive their commit,
+        // so these are live repaints of live rows, never a rewrite of a
+        // committed one.
+        const src = seg ?? this.#lastClosedSegment();
+        if (src === null)
+            return [];
+        const live = src.cells.filter((i) => i >= this.#committed);
         const tools = [];
         for (const i of live)
             if (this.#cells[i]?.kind === "tool")
@@ -2042,31 +2137,142 @@ export class Body {
                 out.push(moreRunningRow(hidden, W));
             return out;
         }
-        const flight = tools.filter((i) => !toolAt(i).done);
-        if (flight.length > 0) {
-            // the commonest frame — exactly one call, the full budget — is
-            // the W8 block verbatim, which is what 0.17.0 already drew.
-            if (flight.length === 1 && budget >= ACT_SLOT_ROWS)
-                return slotPad(tint(flight[0], cellComponent(this.#cells[flight[0]]).render(W, ctx)), budget);
-            const heads = flight.slice(0, Math.max(1, Math.min(flight.length, budget - 1, LIVE_ACT_HEADS)));
-            const hidden = flight.length - heads.length;
+        // R7a — ONE PATH, whether or not anything is in flight.
+        //
+        // There used to be two: the in-flight composition, and a
+        // "last finished call plus its output" composition for the gap
+        // between stretches. The moment the last call of a burst
+        // returned, the block re-composed from four head rows to one
+        // head and a tail — a row shorter, so on a full screen every
+        // row above slid DOWN. The block is supposed to change its
+        // CONTENTS, not its shape; the last call returning is not a
+        // reason to redraw the stretch differently.
+        if (tools.length > 0) {
+            // the one-call special case is GONE: the path below draws a
+            // lone running call by its own component (the W8 block
+            // verbatim, which is what 0.17.0 drew) and a lone finished
+            // one as its head plus its output. The special case only
+            // differed once the call SETTLED, where it collapsed to the
+            // bare head row — a three-row shrink the moment a single
+            // call returned.
+            // R7a — EVERY call of the stretch keeps its row, not just the
+            // ones still in flight.
+            //
+            // R4 showed the in-flight calls only, so a finished one left
+            // the block and its target went with it: a four-file burst
+            // ended having shown four names and left none of them, while
+            // the rows below shuffled up one at a time. Two complaints in
+            // one — "I can't see what it read" and "the rows keep moving".
+            //
+            // A call now takes a row when it STARTS and changes in place
+            // when it finishes: `● read x · 1s` becomes the settled head.
+            // Nothing moves, every target stays, and exactly ONE row wears
+            // the breathing mark — the running one — which is the mark's
+            // whole job (§7.4: only the call still running carries one,
+            // because only it is moving).
+            //
+            // The slot's fixed height is what pays for this: the rows are
+            // already allocated, so the names fill blanks rather than
+            // pushing anything.
+            // TRUNCATION NEVER DROPS A CALL THAT IS STILL RUNNING.
+            //
+            // Taking the first N is wrong the moment a burst outlives the
+            // slot: four reads that finished held every row while the
+            // shell still running was cut, so the screen said "4 files"
+            // and showed nothing of the work actually in flight. The
+            // in-flight set is admitted first, then the most RECENT
+            // finished calls fill what is left — newest first, because
+            // the oldest is the one the eye has already read.
+            const live = tools.filter((i) => !toolAt(i).done);
+            const past = tools.filter((i) => toolAt(i).done);
+            // WHAT IS HAPPENING NOW OUTRANKS WHAT HAPPENED. In order:
+            // the in-flight rows, then that call's output when it is the
+            // only one running, then the finished NAMES, newest first.
+            //
+            // This is the line between R3i P1 and the owner's R7a ruling,
+            // which look contradictory and are not. The ruling is about a
+            // parallel burst — four reads whose names vanished one at a
+            // time, so the turn ended having shown four files and left
+            // none of them. P1 is about a burst that is OVER and a new
+            // call running: there the finished names have had their time
+            // on screen and the work in flight has not. Recency decides
+            // both, and neither gate has to give.
+            // the lone in-flight call is drawn by its OWN component, head
+            // and tail together — that is where the waiting row, VD-4's
+            // never-blank-first-row rule and the shell's live window all
+            // already live. Reaching past it to slotTail() lost every one
+            // of them: a running shell with no output yet drew three
+            // blank rows where `└ waiting for output` belongs.
+            // `grouped` says "an activity line above wears the mark for
+            // us". A stretch of ONE call draws no such line (R7a), so
+            // there is nothing above to carry it and the head keeps its
+            // own — otherwise a lone running call breathes nowhere.
+            const grouped = { ...ctx, grouped: tools.length > 1 };
+            const soloRows = live.length === 1 ? tint(live[0], cellComponent(this.#cells[live[0]]).render(W, grouped)) : [];
+            const tailWant = Math.max(0, soloRows.length - 1);
+            // the overflow row is itself a row: an in-flight set larger
+            // than the slot gives one back so `+N more running` fits.
+            const liveRows = live.slice(0, live.length > budget ? Math.max(1, budget - 1) : budget);
+            const spare = Math.max(0, budget - liveRows.length - tailWant);
+            const nameRoom = past.length > spare ? Math.max(0, spare - 1) : spare;
+            const keep = new Set([...liveRows, ...past.slice(past.length - nameRoom)]);
+            const shown = tools.filter((i) => keep.has(i));
+            // `+N more running` COUNTS ONLY CALLS THAT ARE RUNNING.
+            //
+            // Counting every dropped call said "+1 more running" over a
+            // read that had already returned — a false sentence of the
+            // R3h class, and the stretch line above had ALREADY counted
+            // that read ("read 1 file"), so the row was both wrong and
+            // redundant. A finished name giving way to live work is the
+            // recency rule doing its job, not an overflow.
+            const hidden = live.length - shown.filter((i) => !toolAt(i).done).length;
             const rows = [];
-            for (const i of heads)
-                rows.push(tint(i, cellComponent(this.#cells[i]).render(W, ctx))[0] ?? "");
-            const rest = budget - rows.length - (hidden > 0 ? 1 : 0);
-            if (rest > 0)
-                rows.push(...slotTail(toolAt(heads[heads.length - 1]).resultText, W, rest));
+            // the mark lives on the ACTIVITY line above, so the members
+            // wear a plain gutter — see FrameCtx.grouped.
+            for (const i of shown) {
+                if (i === live[0] && live.length === 1)
+                    rows.push(...soloRows.slice(0, Math.max(1, budget - rows.length)));
+                else
+                    rows.push(tint(i, cellComponent(this.#cells[i]).render(W, grouped))[0] ?? "");
+            }
             if (hidden > 0)
                 rows.push(moreRunningRow(hidden, W));
+            // R3i P3 SURVIVES: the call in flight keeps its row AND its
+            // output. R7a gave every call a row, which spent the budget
+            // the tail used to hold — but a running shell with no output
+            // on screen is the defect R3i named, and the owner's ruling
+            // was about the finished calls' NAMES, not about this. The
+            // tail takes whatever the head rows leave, so it is full
+            // height for a lone call and gives way to the names first.
+            // R4 B SURVIVES THE UNIFICATION: between two calls — nothing
+            // in flight — the slot still shows the call that just
+            // finished AND its output. It is appended UNDER the head
+            // rows now instead of replacing them, so the block's shape
+            // does not change when the last call of a burst returns.
+            const rest = budget - rows.length;
+            if (live.length === 0 && rest > 0 && tools.length > 0)
+                rows.push(...slotTail(toolAt(tools[tools.length - 1]).resultText, W, rest));
             return slotPad(rows, budget);
         }
-        const settled = tools.length > 0 ? tools[tools.length - 1] : null;
-        if (settled !== null) {
-            const head = tint(settled, cellComponent(this.#cells[settled]).render(W, ctx))[0] ?? "";
-            return slotPad([head, ...slotTail(toolAt(settled).resultText, W, budget - 1)], budget);
-        }
         const think = [...live].reverse().find((i) => this.#cells[i]?.kind === "thinking");
-        return slotPad(think === undefined ? [] : slotTail(this.#cells[think].text, W, budget), budget);
+        // R7a — A SLOT WITH NOTHING TO SHOW TAKES NO ROWS.
+        //
+        // R7 moved thinking OUT of the slot (it is words, and words do
+        // not fold), which left this branch — the pre-tool phase of a
+        // stretch — with nothing to put in the rows it was still
+        // reserving. It padded them anyway: six blank rows between the
+        // thought and the composer, on 653 of a 733-frame dogfood
+        // replay. Until today those rows were drawn as `│`, so the
+        // blank-run guard never saw them and the owner saw a gutter
+        // running down the screen marking nothing; blanking the gutter
+        // (law 1.3) revealed the hole the gutter had been covering.
+        //
+        // Reserving height buys stability only where the content
+        // CHANGES under it — a stretch whose calls come and go. Before
+        // the first call there is nothing to stabilise, so the rows are
+        // pure cost, and both complaints are the same complaint.
+        const tail = think === undefined ? [] : slotTail(this.#cells[think].text, W, budget);
+        return tail.length === 0 ? [] : slotPad(tail, budget);
     }
     /** R4 — the tool names with a call still IN FLIGHT in this segment.
      *  The stretch line's tense is per term, so a finished shell reads
@@ -2454,6 +2660,37 @@ export class Body {
      *  the only place that knows it. Every other pair is untouched,
      *  including the boundary INTO a markdown message (the blank under the
      *  user chip is still W11's). */
+    /** R7a — the live block's spacing is the spacing its COMMITTED form
+     *  will get, never its own.
+     *
+     *  W11 gives a blank when either side is multi-row. The block is
+     *  always multi-row and the fold it commits into is always ONE row,
+     *  so the two sides disagreed by construction and a blank appeared
+     *  or vanished at every settle, shoving the whole transcript by a
+     *  row. Both directions occur: after a two-row thought the settle
+     *  ADDED one (my R6/D1 note saw only this case and removed the
+     *  block's blank, which fixed that direction and broke the other);
+     *  after a one-row thought it REMOVED one.
+     *
+     *  Deciding on a one-row stand-in makes the block spaced exactly as
+     *  its fold will be, so the settle changes the row's CONTENT and
+     *  never its position — which is the whole claim of the standing
+     *  block. */
+    /** R7a — is any call of this stretch actually RUNNING?
+     *
+     *  The phase is not the same question. A stretch stays "acting" from
+     *  its first tool to its close, so between two bursts — every call
+     *  returned, the model is composing the next one — the phase still
+     *  said acting and the activity line went on breathing over four
+     *  finished reads. A mark that is lit when nothing moves is the
+     *  spinner-implies-progress error §5.3 forbids, one scale up. */
+    #inFlight(seg) {
+        return seg.cells.some((i) => { const c = this.#cells[i]; return c?.kind === "tool" && !c.done; });
+    }
+    #blockSpace(i, prev, rows) {
+        const lead = bodySpacing(this.#lastDrawn(i, prev), ["x"]).length > 1 ? [""] : [];
+        return [...lead, ...rows];
+    }
     #space(i, prev, rows) {
         if (i > 0 && this.#cells[i]?.kind === "md" && this.#cells[i - 1]?.kind === "md")
             return rows;
@@ -2687,6 +2924,12 @@ export class Body {
         // is not going to speak for it.
         if (cell.kind === "tool" && cell.name === "ask_user")
             return false;
+        // R7: and neither is THINKING. It is words now (law 1.7 — work
+        // folds, words do not), so it commits when it is done, like prose,
+        // and is never held for a fold that no longer speaks for it. The
+        // ask_user exemption one line up is the precedent this follows.
+        if (cell.kind === "thinking")
+            return false;
         const turn = cell.turn >= 0 ? this.#turns[cell.turn] : undefined;
         if (turn === undefined || turn !== this.#turns[this.#turns.length - 1])
             return false;
@@ -3225,6 +3468,21 @@ export class Body {
         // march below is clamped to the window instead, which makes the
         // sheet displace content ON SCREEN. Closing takes the full-redraw
         // path with the same #lastSkip and every displaced row comes back.
+        // R7a — a monotone skip was TRIED HERE AND REJECTED, measured.
+        //
+        // The seam it aimed at is real: the turn boundary releases the
+        // block into a one-row fold, so a full screen's computed skip
+        // drops and every row above slides down one. Holding skip at its
+        // high-water mark removes that motion exactly.
+        //
+        // It also holds the window BELOW the content, and the a7 dogfood
+        // replay prices that at 40x24: the frame from which the screen
+        // durably fills (no blank run over 2) goes 65 -> 692 of 733 —
+        // a three-row hole above the composer through most of a real
+        // session. One row of motion once per turn, at the moment the
+        // answer lands and the eye is on it, is the cheaper of the two.
+        // The A8b guard is written against a real session; this is what
+        // it exists to catch.
         const skip = overlay
             ? this.#lastSkip
             : Math.max(0, all.length + CHROME_ROWS + inputExtra + queueRows.length + menuRows.length - H);

package/package.json

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