@vincemakes/kiso-tui 0.46.1 → 0.47.0

package/dist/compositor.js

@@ -50,20 +50,32 @@ 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, panelStatusOf } from "./ask-panel.js";
+import { panelFrameOf, panelHintOf, panelStatusOf } from "./ask-panel.js";
 import { MOUSE_OFF } from "./editor.js";
 import { pickWindowOf } from "./approval-panel.js";
-import { atPanelRows, bandHeader } from "./at-picker.js";
+import { atPanelRows, bandHeader, bandKeyRow, bandVisible, bandWindow, moreMark } 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, Container, MOTION_FRAMES, MdStream, bodySpacing, boxBottom, boxTop, cellComponent, gutterCut, cutLine, pendingQueueRows, statusLine, visibleWidth, breathFrame, } from "./components.js";
+import { RESUME_FILTER_HINT, sessionPickerRows } from "./session-picker.js";
+import { CAP_PREVIEW, thinkingRow, Container, MOTION_FRAMES, MdStream, bodySpacing, boxBottom, boxTop, cellComponent, cutLine, pendingQueueRows, selectionBar, statusLine, visibleWidth, breathFrame, widthCut, } from "./components.js";
 import { bannerLines, escapeTerminal, foldResult, foldThinking, palette, renderTerminalGap, renderToolSummary } from "./lines.js";
 import { oneRow } from "@vincemakes/kiso-tui-cells/render";
 import { displayVerb, keysSheetRows } from "./strings.js";
+import { noticeMeta } from "./notice-meta.js";
+import { statusBar } from "./status.js";
+/** Graphite §7.8 — the drawn caret: a block in the terminal's own ink,
+ *  reverse video on every ground (owner, 2026-09-29 — the 0.44 caret; R1c
+ *  had painted it gold). */
+const caretOn = () => "\x1b[7m";
+const caretOff = () => "\x1b[27m";
 /** DC-56: does a rendered row carry any visible text once its SGR is
  *  stripped? A washed pad row is spaces under a background colour — width
  *  without words. */
-const saysSomething = (row) => row.replace(/\x1b\[[0-9;?]*[A-Za-z]/g, "").trim() !== "";
+/** A row that says something: not blank, and not a card's half-row pad
+ *  (Graphite §7.4 — a `▄`/`▀` row is the card's edge, not its head). */
+const saysSomething = (row) => {
+    const t = row.replace(/\x1b\[[0-9;?]*[A-Za-z]/g, "").trim();
+    return t !== "" && !/^[\u2584\u2580]+$/.test(t);
+};
 // R5 — the transcript viewer's PURE projection. The compositor supplies
 // the entries (it holds the cells); the arrangement lives there.
 import { VIEWER_GUTTER, viewerFlat, viewerHint, viewerInit, viewerMove, viewerRows, viewerScroll, viewerTitle, viewerToggle, viewerToggleAll, } from "./transcript.js";
@@ -86,9 +98,6 @@ 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;
 export class Body {
     #opts;
     #cells = [];
@@ -230,6 +239,17 @@ export class Body {
     // the chrome state (the Dock façade)
     #status = "";
     #statusHint = null;
+    /** Graphite §8.9 — the status bar's facts, handed over by the CLI and
+     *  composed at paint time (the drop order spans both sides of the row,
+     *  and only the paint knows the width and the `ctrl+o` state). Null:
+     *  the CLI's own status text is the row (setStatus). */
+    #bar = null;
+    /** Graphite §8.7 — the live row above the composer while a turn runs
+     *  (working, retrying, compacting), or null. */
+    #live = null;
+    /** A short confirmation (the clipboard's) on the live row while nothing
+     *  is live; the next keypress clears it. */
+    #flash = null;
     #tail = "";
     // W21: the panel's bound state — the PanelSelect slot occupant (the
     // old ApprovalPrompt's question slot retires with it): while a
@@ -716,7 +736,103 @@ export class Body {
         }
         this.#closeOpenThinking();
         this.#closeOpenText();
-        this.#cells.push({ kind: "notice", text, done: true });
+        // Graphite §7.12: a meta row on the terminal; the pipe above keeps
+        // the text as written.
+        this.#cells.push({ kind: "notice", text, done: true, ...noticeMeta(text) });
+        this.#mark();
+    }
+    /** The tasks round (owner, 2026-10-06) — a notice whose terminal form
+     *  is one meta row per thing it names (a task's end, a project's trust):
+     *  each row a label (`TASK` once, `""` under it), the sentence cut to one
+     *  row, its outcome word marked. A pipe keeps `text`, byte for byte. */
+    metaNotice(text, rows) {
+        if (!this.#isActive()) {
+            this.#closeOpenThinking();
+            this.#closeOpenText();
+            this.#write(`${text}\n`);
+            return;
+        }
+        this.#closeOpenThinking();
+        this.#closeOpenText();
+        const [first, ...also] = rows;
+        if (first === undefined)
+            return;
+        // ONE cell for the notice, so its rows stay together (D1 puts a blank
+        // between two cells)
+        this.#cells.push({ kind: "notice", text, done: true, label: first.label, sentence: first.sentence, ...(first.mark !== undefined ? { mark: first.mark } : {}), oneRow: true, ...(also.length > 0 ? { also } : {}) });
+        this.#mark();
+    }
+    /** The last sweep (owner, 2026-10-06) — what `/think` or `/last` brings
+     *  back: on the terminal ONE cell, a meta row (`label`, `sentence`) and
+     *  the sections under it; a pipe keeps `text`, byte for byte. */
+    recall(text, label, sentence, sections) {
+        if (!this.#isActive()) {
+            this.#closeOpenThinking();
+            this.#closeOpenText();
+            this.#write(`${text}\n`);
+            return;
+        }
+        this.#closeOpenThinking();
+        this.#closeOpenText();
+        this.#cells.push({ kind: "recall", text, label, sentence, sections, done: true });
+        this.#mark();
+    }
+    /** Graphite R3e (owner, 2026-09-29) — a mode switch: on the terminal
+     *  `MODE` on a row of its own and `from → to` under it, the new tier
+     *  bold (full access — the old bypass — in the failure colour, plan in
+     *  blue) — no explanation:
+     *  the picker that switched it says what each tier does. A pipe keeps
+     *  the confirmation it always printed, byte for byte (`text`). */
+    modeNotice(text, from, to) {
+        if (!this.#isActive()) {
+            this.#closeOpenThinking();
+            this.#closeOpenText();
+            this.#write(`${text}\n`);
+            return;
+        }
+        this.#closeOpenThinking();
+        this.#closeOpenText();
+        // the main-sync round: `full access` (the old bypass) keeps the failure colour
+        const tone = to === "full access" || to === "bypass" ? "fail" : to === "plan" ? "blue" : "ink";
+        this.#cells.push({ kind: "notice", text, done: true, label: "MODE", sentence: `${from} \u2192 ${to}`, mark: { text: to, tone }, stacked: true });
+        this.#mark();
+    }
+    /** The main-sync round (owner, 2026-09-30) — the don't-ask switch, the
+     *  MODE row's sibling: `DON'T ASK` gold (the person's choice) and
+     *  `off → on` with the new state bold. It is a switch on top of the tier,
+     *  not a tier, so it has a row of its own. A pipe keeps #203's words
+     *  (`don't ask → on`), byte for byte. */
+    dontAskNotice(text, on) {
+        if (!this.#isActive()) {
+            this.#closeOpenThinking();
+            this.#closeOpenText();
+            this.#write(`${text}\n`);
+            return;
+        }
+        this.#closeOpenThinking();
+        this.#closeOpenText();
+        const to = on ? "on" : "off";
+        this.#cells.push({ kind: "notice", text, done: true, label: "DON'T ASK", sentence: `${on ? "off" : "on"} \u2192 ${to}`, mark: { text: to, tone: "ink" }, stacked: true });
+        this.#mark();
+    }
+    /**
+     * Graphite §7.11 — the turn's SEAL. On the terminal a cell of its own,
+     * drawn at the current width (widest tier that fits); a pipe gets
+     * `pipe` — today's recap line — byte for byte.
+     */
+    seal(tiers, pipe) {
+        if (!this.#isActive()) {
+            this.#closeOpenThinking();
+            this.#closeOpenText();
+            // byte for byte what `raw(pipe.split("\n"))` wrote before the
+            // seal had a cell of its own — the trailing newline included
+            for (const line of pipe.split("\n"))
+                this.#write(`${line}\n`);
+            return;
+        }
+        this.#closeOpenThinking();
+        this.#closeOpenText();
+        this.#cells.push({ kind: "seal", tiers, done: true });
         this.#mark();
     }
     /** The startup banner (W1): a LIVE cell — the tier re-derives per
@@ -756,6 +872,33 @@ export class Body {
         this.#cells.push({ kind: "raw", lines, done: true, ...(wrap === undefined ? {} : { wrap }) });
         this.#mark();
     }
+    /** G3 (R2d) — the person's `!!cmd`: run, shown here, never sent. Off a
+     *  dock the command and its output are written as they always were. */
+    bang(command, output, isError) {
+        if (!this.#isActive()) {
+            this.#closeOpenThinking();
+            this.#closeOpenText();
+            this.#write(`$ ${escapeTerminal(command)}\n${escapeTerminal(output)}\n`);
+            return;
+        }
+        this.#closeOpenThinking();
+        this.#closeOpenText();
+        this.#cells.push({ kind: "bang", command, output, isError, done: true });
+        this.#mark();
+    }
+    /** G3 (R2d) — the input's lead: a gold `$ ` while the line starts with
+     *  `!` (the person's shell, run by `!` / `!!`); the bound prompt
+     *  otherwise. One line only — a pasted block that begins with `!` is
+     *  prose (dispatch's rule). */
+    #composerLead() {
+        const st = this.#inputState();
+        const lines = st.lines !== undefined && st.lines.length > 0 ? st.lines : [st.line];
+        if (lines.length === 1 && lines[0].startsWith("!")) {
+            const p = palette();
+            return `${p.gold}$${p.gold === "" ? "" : p.fgEnd} ${this.#inputPrompt}`;
+        }
+        return this.#inputPrompt;
+    }
     /** The last COMPLETE thinking block, for /think. */
     lastThinking() {
         return this.#lastThinking;
@@ -929,7 +1072,7 @@ export class Body {
             // a light terminal showed "5 folds" over five empty grey rows.
             const first = rows.findIndex((r) => saysSomething(r));
             const headAt = first < 0 ? 0 : first;
-            out.push({ head: rows[headAt] ?? "", body: rows.slice(headAt + 1) });
+            out.push({ head: rows[headAt] ?? "", body: rows.slice(headAt + 1).filter((r) => saysSomething(r) || r.replace(/\x1b\[[0-9;?]*[A-Za-z]/g, "").trim() === "") });
         }
         return out;
     }
@@ -1246,14 +1389,28 @@ export class Body {
      * which time the first frame is already painted with the no-ground
      * palette. Rather than delay the opening to wait for an answer that
      * may never come, the frame is painted at once and repainted when the
-     * answer lands. Invalidating the held screen is exactly what a resize
-     * does, for exactly the same reason — every row's bytes are wrong —
-     * so it rides the settle the resize already owns and costs one
-     * repaint, once per session.
+     * answer lands.
+     *
+     * It is NOT a resize, and must not ride one: the settle returns early
+     * when the geometry did not change — which it never does here — so the
+     * old path cleared the held screen and painted nothing, leaving the
+     * no-ground palette up until the first keystroke. Nor is it a reprint:
+     * `3J` would erase the shell's scrollback at every launch, since the
+     * answer arrives at every launch. So: the committed cells' cached rows
+     * are dropped (their bytes carry the old palette; their geometry does
+     * not change, the palette sets no width), the held screen is voided,
+     * and one frame repaints what is on screen. Rows already in the
+     * terminal's scrollback keep the palette they were written in.
      */
     onGroundChange() {
-        this.#screen = [];
-        this.onResize();
+        if (!this.#isActive())
+            return;
+        for (let i = 0; i < this.#committed; i += 1)
+            this.#lineCache[i] = null;
+        this.#screen = new Array(Math.max(1, this.#opts.height())).fill(NOT_PAINTED);
+        this.#fullRedraw = true;
+        this.#dirty = true;
+        this.render();
     }
     /**
      * R14 / route B — THE ONE REPAINT A DRAG EARNS IS A REPRINT.
@@ -1432,6 +1589,26 @@ export class Body {
     setStatus(text, hint = null) {
         this.#status = text;
         this.#statusHint = hint;
+        // a caller that paints its own text takes the row
+        this.#bar = null;
+        this.redraw();
+    }
+    /** Graphite §8.9 — hand the status bar its facts. */
+    setBar(bar) {
+        this.#bar = bar;
+        this.redraw();
+    }
+    /** Graphite §8.7 — the live row (already composed for the width the
+     *  caller measured; cut here if the terminal narrowed since), or null
+     *  when nothing is live. */
+    setLive(row) {
+        this.#live = row;
+        this.redraw();
+    }
+    /** A confirmation that is true for a moment — `copied 212 chars` — on the
+     *  live row, until the next keypress. It never displaces a live row. */
+    flash(text) {
+        this.#flash = text;
         this.redraw();
     }
     setTail(tail) {
@@ -1462,12 +1639,26 @@ export class Body {
         // block carries its own row (approval-panel.ts pushes it for the
         // approval and the pick, ask-panel.ts for the ask), so nothing is
         // lost anywhere.
-        if (panel !== null)
-            return { status: panelStatusOf(panel), hint: undefined, expand: null };
-        // ADR-0057: while steers wait for the run's next quiescent boundary,
-        // the right hint counts them — the chips carry the lines. Short on
-        // purpose: the running status shares the row, and a hint that does
-        // not fit is dropped whole.
+        // Graphite P3/P4 (owner, 2026-10-04): a panel leaves the bar where it
+        // is — the session's facts do not stop being true while a panel is up,
+        // and what the panel is doing is said in its band. The panel's own
+        // status line is the form before a bar is bound (the trust question
+        // comes before the session exists): its words, and not the key ladder
+        // §7.8 retired — an empty hint, so the row offers none.
+        if (panel !== null && this.#bar === null)
+            return { status: panelStatusOf(panel), hint: "", expand: null };
+        // Graphite §8.9: the bar, when the CLI handed one over — the steers
+        // are on screen in the band above the input (§8.7), so the bar does
+        // not count them (the main-sync round, owner 2026-09-30: no `+N
+        // steer` on a Graphite bar).
+        if (this.#bar !== null) {
+            const expand = this.#collapsed.length > 0 ? (this.#expandedAll ? "collapse all" : "expand all") : null;
+            return { status: "", hint: undefined, expand, bar: this.#bar };
+        }
+        // ADR-0057: without a bar, while steers wait for the run's next
+        // quiescent boundary, the right hint counts them — the rows carry the
+        // lines. Short on purpose: the running status shares the row, and a
+        // hint that does not fit is dropped whole.
         const queued = this.#queueState?.().length ?? 0;
         if (queued > 0)
             return { status: this.#status, hint: `+${queued} steer`, expand: null };
@@ -1514,8 +1705,9 @@ export class Body {
         this.#pickState = state;
     }
     /** Bind the pending-turn queue — the CLI's live slots (chat.ts):
-     *  the chips render in the menu-rows family, the live caps shrink
-     *  by their rows, and the +N queued hint rides the status row. */
+     *  the queued rows render in the menu-rows family and the live caps
+     *  shrink by their rows (Graphite §8.7). The status bar does not
+     *  count them; without a bar the status row's hint still does. */
     bindQueue(state) {
         this.#queueState = state;
     }
@@ -1532,7 +1724,8 @@ export class Body {
         // panel rows' edit column; leadWidth is the ONE authority).
         // R2: wallL is 0 — the box is retired, so the row starts at column
         // one and the frame's marker and this formula share the constant.
-        const lead = panel !== null ? panelLeadOf(panel) : this.#inputPrompt;
+        // Graphite P3/P4: a panel leaves the input row to the composer
+        const lead = this.#composerLead();
         return 1 + leadWidth(lead) + st.cursor;
     }
     /** The old dock's redraw — the editor's onRender target: mark + the
@@ -1553,6 +1746,7 @@ export class Body {
             return;
         this.#dirty = true;
         if (fromKey) {
+            this.#flash = null;
             this.#scheduleInputFrame();
             return;
         }
@@ -1892,7 +2086,7 @@ export class Body {
      *  freezes, #emitScroll is skipped, and the close repaints from
      *  #lastSkip. */
     #noteOverlay() {
-        const sheetUp = this.#sheetState?.() === true;
+        const sheetUp = (this.#sheetState?.() ?? false) !== false;
         const viewerUp = this.#viewer !== null;
         this.#overlayFrame = sheetUp || this.#sheetWasUp || viewerUp || this.#viewerWasUp;
         this.#sheetWasUp = sheetUp;
@@ -1913,19 +2107,21 @@ export class Body {
         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 };
+        // Graphite R3e: the keys sheet, or a sheet of the caller's rows (`/status`)
+        const sheet = this.#sheetState?.() ?? false;
+        if (sheet !== false)
+            return { lines: (sheet === true ? keysSheetRows(W) : sheet(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);
+            const frame = panelFrameOf(panel, W, capped, this.#opts.height());
             // B (review of this round): the pick window THIS frame draws. The size
             // depends on the budget, so the renderer is the only producer — the
             // digit keys are handed this value instead of deriving a second one.
             const pick = panel.pick ?? null;
-            return { lines: frame.rows, panelSpan: frame.options, pickWin: pick === null ? null : pickWindowOf(panel.view, pick.cursor, pick.phase, capped) };
+            return { lines: frame.rows, panelSpan: frame.options, pickWin: pick === null ? null : pickWindowOf(panel.view, pick, capped, this.#opts.height()) };
         }
         return { lines: this.#liveProjection(W, ctx, cap), panelSpan: null };
     }
@@ -2132,6 +2328,18 @@ export class Body {
      *  occupant (the queue is dense, like the menu; each line is its
      *  own chip with the □ gutter). */
     #queueRows(W, H) {
+        // Graphite §8.7: the live row opens the band above the composer; the
+        // queued messages sit under it, next to the input they wait on.
+        const panelUp = (this.#panelState?.() ?? null) !== null;
+        const p = palette();
+        // a blank row above the live row keeps it off the streaming content
+        // (owner, 2026-09-29: the words ran right up to `working`)
+        const live = panelUp ? [] : this.#live !== null ? ["", cutLine(this.#live, W)] : this.#flash !== null ? ["", cutLine(`  ${p.dim}${this.#flash}${p.reset}`, W)] : [];
+        return [...live, ...this.#queuedRows(W, H - live.length)];
+    }
+    /** The queued messages' rows; `H` is the height they may share with
+     *  the content, the live row's already taken out. */
+    #queuedRows(W, H) {
         const queued = this.#queueState?.() ?? [];
         if (queued.length === 0)
             return [];
@@ -2153,14 +2361,17 @@ export class Body {
         // scroll — the scrollback lost the turns entirely (finding #A8b —
         // the queued-flood content loss). The band keeps the first H−9
         // chips + one "…N more" row (≤ H−8 rows — the content keeps ≥ 4);
-        // the status hint's "+N queued" already carries the count, so the
-        // cap hides nothing the status doesn't show.
+        // that row carries the count, so the cap hides nothing without
+        // saying so.
+        // the main-sync round (owner, 2026-09-30): a steer waits for an open
+        // approval — it never answers one — and its row says so
+        const waiting = this.#panelState?.()?.view.flavor === "approval" ? "approval" : "step";
         const keep = Math.max(1, H - 9);
         if (lines.length <= keep)
-            return pendingQueueRows(lines, W);
+            return pendingQueueRows(lines, W, waiting);
         const p = palette();
         const hidden = lines.length - keep;
-        return [...pendingQueueRows(lines.slice(0, keep), W), `${p.dim}□ …${hidden} more${p.reset}`];
+        return [...pendingQueueRows(lines.slice(0, keep), W, waiting), `  ${p.dim}\u2026${hidden} more${p.reset}`];
     }
     /**
      * The band ABOVE the box top. Two occupants share it — the slash
@@ -2185,10 +2396,10 @@ export class Body {
         // composer, redrawn with the frame.
         const pick = this.#pickState?.() ?? null;
         if (pick !== null)
-            return sessionPickerRows(pick, W, Date.now());
+            return sessionPickerRows(pick, W, Date.now(), this.#opts.height());
         const at = this.#atState?.() ?? null;
         if (at !== null)
-            return atPanelRows(at, W);
+            return atPanelRows(at, W, this.#opts.height());
         const menu = this.#menuState?.();
         if (menu === null || menu === undefined || menu.items.length === 0)
             return [];
@@ -2215,22 +2426,46 @@ export class Body {
         //  - 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 = top; i < Math.min(items.length, top + MENU_WINDOW); i += 1) {
+        // Graphite P2 (owner, 2026-10-03): the list takes /resume's shape —
+        // the count in the band, the window (eight rows from a 30-row
+        // terminal, five below) with its more-marks, the typed prefix gold,
+        // and one key row with the counter. The selected row keeps R3a's gold
+        // `›` in column 1 (owner: kept).
+        const total = menu.total ?? items.length;
+        const query = menu.query ?? "";
+        const col = Math.max(menu.nameCol ?? 0, ...items.map((m) => m.name.length - 1));
+        const rows = [bandHeader(`commands \u00b7 ${query === "" ? `${total}` : `${items.length} of ${total} match`}`, W)];
+        const { first, count } = bandWindow(items.length, menu.selected, bandVisible(this.#opts.height()));
+        for (let i = first; i < first + count; 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)));
+            const name = item.name.slice(1);
+            const selected = i === menu.selected;
+            // the prefix the person typed, gold — the filter is a prefix match
+            // (off a known ground the warn tint stands in, as in the @ band)
+            const typed = Math.min(query.length, name.length);
+            const gold = p.gold !== "" ? p.gold : p.warn;
+            const shownName = `${typed > 0 ? `${p.reset}${p.bold}${gold}${name.slice(0, typed)}${p.reset}${selected ? p.bold : ""}` : ""}${name.slice(typed)}`;
+            // THE FIX (found capturing the real terminal, 2026-10-03): the
+            // description is cut as TEXT, by cells, before it is styled. It was
+            // cut after — by a cutter that counts escape bytes as cells — so
+            // Graphite's 19-byte dim took 19 cells off every row, and a cut that
+            // landed inside the reset left a bare ESC in the output.
+            const room = Math.max(0, W - 2 - col - 2 - 1);
+            const desc = visibleWidth(item.desc) <= room ? item.desc : room <= 1 ? "" : `${widthCut(item.desc, room - 1)}\u2026`;
+            const label = `${shownName}${" ".repeat(Math.max(0, col - name.length))}  ${p.reset}${p.dim}${desc}${p.reset}`;
+            const width = col + 2 + visibleWidth(desc);
+            if (selected) {
+                // Graphite §8.2 (R3a): the selected command wears the one selected
+                // row every list has — its `→` is the gold `›` in column 1, the
+                // name from the content edge
+                rows.push(selectionBar(`${p.bold}\u2192${label}`, width + 1, W));
+            }
+            else {
+                const mark = moreMark(i, first, count, items.length);
+                rows.push(`${mark === null ? " " : `${p.dim}${mark}${p.reset}`} ${label}`);
+            }
         }
-        // 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}`);
+        rows.push(bandKeyRow(["\u2191\u2193 move", "\u23ce completes", "esc"], menu.selected, items.length, W));
         return rows;
     }
     /** ONE input row's bytes — the marker embedded at `embedAt` (the
@@ -2316,7 +2551,7 @@ export class Body {
                 // the cursor rests past the content — an inverse space,
                 // taken OUT of the pad (the walk capped content at W, so
                 // the pad absorbs it and the row still totals W)
-                stripped0 = `${before}\x1b[7m \x1b[27m`;
+                stripped0 = `${before}${caretOn()} ${caretOff()}`;
                 cursorPad = 1;
             }
             else if (after[0] === "\x1b" || (after.codePointAt(0) >= 0xd800 && after.codePointAt(0) <= 0xdfff)) {
@@ -2327,7 +2562,7 @@ export class Body {
             }
             else {
                 const glyph = String.fromCodePoint(after.codePointAt(0));
-                stripped0 = `${before}\x1b[7m${glyph}\x1b[27m${after.slice(glyph.length)}`;
+                stripped0 = `${before}${caretOn()}${glyph}${caretOff()}${after.slice(glyph.length)}`;
             }
         }
         // R2 — the box is retired (see boxTop): the composer is two dashed
@@ -2354,11 +2589,22 @@ export class Body {
         // the lead — the panel's phase lead when the panel owns the row
         // (1-3> / the rule input's "2 Yes, don't ask again for " / the
         // amend "feedback (deny): "), the bound prompt otherwise
-        const lead = panel !== null ? panelLeadOf(panel) : this.#inputPrompt;
+        const p = palette();
+        // Graphite §7.8: the prompt `›` is gold (the edge of a turn); the
+        // bound lead is plain text and the colour is the paint's, so a ground
+        // resolved after the first frame reaches it.
+        // Graphite P3/P4: a panel leaves the input row its own lead — a filter,
+        // a note or an answer is typed there, and a list says its keys on its
+        // key row (DECLARED REVERSAL of `1-4>`, `pick>`, `amend›`)
+        const lead = this.#composerLead().replace("\u203a", `${p.gold}\u203a${p.gold === "" ? "" : p.fgEnd}`);
         const leadW = leadWidth(lead);
         // a LEGACY one-row provider (the old {line, cursor} shape) keeps
         // working: its single line is the composer's single row
         let rows = st.lines !== undefined && st.lines.length > 0 ? [...st.lines] : [st.line];
+        // Graphite §7.8 — DECLARED REMOVAL (owner, 2026-09-29): the empty
+        // input carries no placeholder. R1c put the key ladder there; the
+        // row is kept empty — `?` lists the keys, and the empty input is
+        // where later work (follow-up suggestions) will speak.
         let cursorRow = Math.min(st.cursorRow ?? 0, rows.length - 1);
         const cursorCol = st.cursorCol ?? st.cursor;
         // KC1 §5's N_visible, re-applied against the frame's REAL bands:
@@ -2382,6 +2628,21 @@ export class Body {
             if (r === cursorRow)
                 markerCol = 1 + bytes.markerCell;
         }
+        // Graphite P1 (owner, 2026-09-30) — DECLARED EXCEPTION to §7.8's empty
+        // input: while the /resume picker is up and nothing is typed, the
+        // input says what typing there does. The input IS the picker's filter,
+        // so the hint names a key the person is about to press; everywhere
+        // else the empty input stays empty. It sits after the drawn cursor,
+        // in the row's pad, so the cursor and the columns do not move.
+        // Graphite P3: the same exception for a pick that filters (/model) —
+        // its input is the filter too, and its hint is the caller's words.
+        const hint = panel === null ? (this.#pickState?.() != null ? RESUME_FILTER_HINT : null) : panelHintOf(panel);
+        if (hint !== null && rows.length === 1 && rows[0] === "") {
+            const pad = / +$/.exec(out[0]);
+            const hintW = visibleWidth(hint);
+            if (pad !== null && pad[0].length > hintW)
+                out[0] = `${out[0].slice(0, pad.index)}${p.dim}${hint}${p.reset}${" ".repeat(pad[0].length - hintW)}`;
+        }
         return { rows: out, markerRow: cursorRow, markerCol };
     }
     /** The full-redraw path (the first frame, the resize repaint) — CUP
@@ -2544,7 +2805,16 @@ export class Body {
         // 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) {
+        // The sheets round (owner, 2026-10-06): a sheet sits ON the
+        // composer. When the window's top cannot come back down (R13 — a
+        // taller band, the `/` list, pushed rows into the scrollback) the
+        // rows a shorter sheet leaves free go ABOVE it, between the
+        // conversation and the sheet — not between the sheet and the
+        // composer's rail, where they read as the sheet stopping short.
+        const sheetUp = (this.#sheetState?.() ?? false) !== false;
+        const short = contentRows - march.length;
+        const placed = sheetUp && short > 0 && liveLines.length > 0 && liveLines.length <= march.length ? [...march.slice(0, march.length - liveLines.length), ...new Array(short).fill(""), ...march.slice(march.length - liveLines.length)] : march;
+        for (const line of placed.length > contentRows ? placed.slice(placed.length - contentRows) : placed) {
             desired[r - 1] = this.#checked(line, W);
             r += 1;
         }
@@ -2567,7 +2837,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, statusRow.expand), W);
+        desired[H - 1] = this.#checked(statusRow.bar !== undefined ? statusBar(statusRow.bar, W, statusRow.expand) : 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
@@ -2849,6 +3119,18 @@ export class Dock {
     setStatus(text, hint) {
         compositorRef?.setStatus(text, hint ?? null);
     }
+    /** Graphite §8.9 — the status bar's facts. */
+    setBar(bar) {
+        compositorRef?.setBar(bar);
+    }
+    /** Graphite §8.7 — the live row, or null. */
+    setLive(row) {
+        compositorRef?.setLive(row);
+    }
+    /** A short confirmation on the live row, gone at the next keypress. */
+    flash(text) {
+        compositorRef?.flash(text);
+    }
     setTail(tail) {
         compositorRef?.setTail(tail);
     }
@@ -2919,8 +3201,8 @@ export class Dock {
         }
         compositorRef.bindPick(state);
     }
-    /** W22: bind the pending-turn queue — the chips + the +N queued
-     *  hint (the CLI binds it from chat(); the editor's pop keys ride
+    /** W22: bind the pending-turn queue — the queued rows (the CLI
+     *  binds it from chat(); the editor's pop keys ride
      *  the LineInput's own bindQueue). */
     bindQueue(state) {
         if (compositorRef === null) {

package/dist/context-ledger.d.ts

@@ -69,3 +69,31 @@ export declare function contextRows(ledger: ContextLedger): string[];
  *  right thing to show is that fact and the one step that produces one.
  *  Never an empty bar — an empty bar reads as "measured zero". */
 export declare function contextUnavailableRows(reason: string): string[];
+/** §8.9 — the meter's cells, ONE rule for the status bar's ctx meter and
+ *  the `/context` sheet (the sheets round, owner 2026-10-06: the two
+ *  meters cannot disagree). Ten `▆` cells filled to the percentage SHOWN
+ *  (`0%` is empty; from 1% at least one cell), `ink2` below the soft
+ *  compaction tier, gold to the hard one, the failure colour past it; the
+ *  empty cells `track`. "" off a known ground: the colours carry nothing
+ *  there, and the percentage says it alone. `used`, `soft` and `hard`
+ *  are shares of the window. */
+export declare const METER_CELLS = 10;
+export declare function meterCells(used: number, soft: number, hard: number): string;
+/**
+ * The sheets round (owner, 2026-10-06) — `/context` on a dock is a sheet
+ * over the input, the shape `/status` has (§8.16): the band names the
+ * total (`context · 2.7k of 200k · 1%`), the bar's meter with when
+ * compaction happens beside it, the surfaces as a table — the label, the
+ * count right-aligned, the detail dim — the free remainder dim, and the
+ * closing row. No blank rows: the printed form spent a cell per row and
+ * came out double-spaced. On a pipe `/context` prints `contextRows`,
+ * unchanged. `tiers` are the compaction thresholds as shares of the
+ * window, or null when the window is not known.
+ */
+export declare function contextSheetRows(ledger: ContextLedger, tiers: {
+    readonly soft: number;
+    readonly hard: number;
+} | null, W: number): string[];
+/** The sheets round — `/context` before any request, as a sheet: the band
+ *  says there is no ledger yet, the row says what produces one. */
+export declare function contextUnavailableSheetRows(reason: string, W: number): string[];