@vincemakes/kiso-tui 0.19.1 → 0.20.1

package/dist/at-picker.d.ts

@@ -12,6 +12,7 @@
  * lexical order of the path (never localeCompare, whose result depends
  * on the machine's locale).
  */
+import { bandHeader } from "@vincemakes/kiso-tui-cells/strings";
 /** The bound source's item — a repo-relative path and nothing else.
  *  Structural: the CLI passes whatever it likes as long as it has a
  *  path (slice 5 passes exactly this). */
@@ -168,4 +169,4 @@ export declare function atPanelRows(state: {
  * composer and every panel now share, so a band opens the way everything
  * else does and the label tells you WHICH band in the same row.
  */
-export declare function bandHeader(label: string, W: number): string;
+export { bandHeader };

package/dist/at-picker.js

@@ -14,6 +14,7 @@
  */
 import { escapeTerminal, palette } from "./render.js";
 import { selectionBar, visibleWidth, widthCut } from "./components.js";
+import { bandHeader } from "@vincemakes/kiso-tui-cells/strings";
 /**
  * KC3 §5 — the ONE cap. The file list is computed per open with no
  * index and no watcher, so its cost is bounded here rather than
@@ -263,8 +264,8 @@ export function atPanelRows(state, W) {
  * composer and every panel now share, so a band opens the way everything
  * else does and the label tells you WHICH band in the same row.
  */
-export function bandHeader(label, W) {
-    const p = palette();
-    const head = `\u2500\u2500\u2500 ${label} `;
-    return `${p.dim}${widthCut(`${head}${"\u2500".repeat(Math.max(1, W - head.length))}`, Math.max(1, W))}${p.reset}`;
-}
+// R8b: bandHeader MOVED to tui-cells/strings.ts — the keys sheet needs
+// it and lives there, and `components.ts` already imports that module,
+// so the dependency only runs one way. Re-exported here so every
+// existing import site is untouched.
+export { bandHeader };

package/dist/compositor.js

@@ -43,7 +43,7 @@
  * line-mode bytes byte-for-byte (the e2e guards them).
  */
 import { truncateDiff } from "./diff.js";
-import { displayWidth } from "./editor.js";
+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.
@@ -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, gutterCut, 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
@@ -77,6 +77,9 @@ const CHROME_ROWS = 4; // box top + input + box bottom + status — the design
  *  same unbounded height the projection exists to remove; the rest are
  *  COUNTED, never dropped silently. */
 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;
 /** W13 / TUI2-R1 (B) — a rolled run's TITLE: the exploration sentence on
  *  a mixed run, W13's verb+count on a single-name one. */
 function rolledTitle(cell) {
@@ -476,7 +479,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 +494,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 +531,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 +646,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) {
@@ -1410,7 +1429,9 @@ export class Body {
                     // always the part a reader could use.
                     `${p.bold}✦${p.reset} expanded · ${escapeTerminal(head.length === 0 ? "thinking" : head.join(" · "))} · ${back}`,
                     ...body,
-                    `  ${p.dim}└ end of expansion · ctrl+r opens the one before it${p.reset}`,
+                    // R8a: an in-block note takes the block's indent, not a
+                    // second corner — the corner opens the body above it.
+                    `${p.dim}    end of expansion · ctrl+r opens the one before it${p.reset}`,
                 ],
             };
         }
@@ -1934,8 +1955,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 +1973,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 +2013,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 +2086,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 +2142,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 +2665,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 +2929,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;
@@ -3018,14 +3266,40 @@ export class Body {
         // picker's does. Both render frameless directly above the composer,
         // so with scrollback behind them there was nothing to say where the
         // surface began — the rows read as more history.
+        // R8 — THE BAND IS A WINDOW, and the rows are a table.
+        //
+        // It used to draw every match and fold each long description over
+        // as many rows as it took, which is why a bare `/` could not open
+        // it: eleven commands plus wraps is most of a short terminal. A
+        // fixed window is what lets the trigger be the `/` the banner
+        // advertises (see the editor's #menuFiltered).
+        //
+        // Three shape rules, all of them §1.3 or §1.2:
+        //  - the leading `/` comes off the rows. It is already on the
+        //    input line directly below, so printing it eleven more times
+        //    is a mark carrying no fact the screen does not have.
+        //  - the name column is padded to the longest command in the
+        //    WHOLE list, not the visible slice, so the descriptions do
+        //    not shift sideways as the window scrolls.
+        //  - a description is CUT, never folded — a folded row would
+        //    break the window's height, which is the thing being bought.
+        const items = menu.items;
+        const col = MENU_ITEMS.reduce((n, m) => Math.max(n, m.name.length - 1), 0);
+        const windowed = items.length > MENU_WINDOW;
+        // the window's top is derived from the selection alone (this
+        // method is re-entered per frame and keeps no state): centre it,
+        // clamped to the ends.
+        const top = windowed ? Math.max(0, Math.min(menu.selected - ((MENU_WINDOW - 1) >> 1), items.length - MENU_WINDOW)) : 0;
         const rows = [bandHeader("commands", W)];
-        for (let i = 0; i < menu.items.length; i += 1) {
-            const item = menu.items[i];
-            const text = i === menu.selected
-                ? `${p.bold}▸ ${item.name}${p.reset} ${item.desc}`
-                : `${p.dim}  ${item.name} ${item.desc}${p.reset}`;
-            rows.push(...foldLine(text, W));
-        }
+        for (let i = top; i < Math.min(items.length, top + MENU_WINDOW); i += 1) {
+            const item = items[i];
+            const label = `${item.name.slice(1).padEnd(col)} ${item.desc}`;
+            rows.push(...(i === menu.selected ? gutterCut(`${p.bold}▸${p.reset} `, `${p.bold}${label}${p.reset}`, W) : gutterCut("  ", `${p.dim}${label}${p.reset}`, W)));
+        }
+        // the counter earns its row only when the list is CUT — over a
+        // list you can see all of, it says nothing the rows do not.
+        if (windowed)
+            rows.push(`  ${p.dim}(${menu.selected + 1}/${items.length})${p.reset}`);
         return rows;
     }
     /** ONE input row's bytes — the marker embedded at `embedAt` (the
@@ -3225,6 +3499,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/dist/editor.js

@@ -542,11 +542,20 @@ export class Editor {
             return null;
         return { items: this.#menuFiltered(), selected: this.#menuSel };
     }
-    /** v3 §04: the filtered command list for the current buffer — open
-     *  only while the line is "/" + something (a bare "/" waits). */
+    /** v3 §04: the filtered command list for the current buffer.
+     *
+     *  A BARE `/` OPENS IT (owner-ruled 2026-09-01). It used to wait for
+     *  a second character, which made the key the banner advertises —
+     *  `/ commands` — a thing you had to already know the answer to: the
+     *  list that tells you the commands appeared only once you had typed
+     *  one. The reason for the wait was real and is fixed on the other
+     *  side: the band drew EVERY match with no window, so a bare `/`
+     *  would have piled eleven rows plus wraps above the composer. The
+     *  band windows now (see the compositor's #menuRows), so the trigger
+     *  no longer has to do the rationing. */
     #menuFiltered() {
         const line = this.line();
-        if (!line.startsWith("/") || line === "/")
+        if (!line.startsWith("/"))
             return [];
         return MENU_ITEMS.filter((m) => m.name.startsWith(line));
     }

package/package.json

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