@vincemakes/kiso-tui 0.10.0 → 0.12.0

package/dist/ask-panel.d.ts

@@ -27,7 +27,7 @@
  * durability would need a new durable mechanism), no "chat about this"
  * hand-off, no timeout and no countdown.
  */
-import { type AskAnswer, type AskOption, type AskQuestion, type AskResult, type AskRuntime, type AskSpec, type PanelPhase, type PanelSel, type PanelState, type PanelView, type PickRuntime } from "./approval-panel.js";
+import { type SaferRuntime, type AskAnswer, type AskOption, type AskQuestion, type AskResult, type AskRuntime, type AskSpec, type PanelPhase, type PanelState, type PanelView, type PickRuntime } from "./approval-panel.js";
 /** The schema's own bounds — the registry refuses anything outside them
  *  (extensions/ask validates; these are the numbers it validates to). */
 export declare const ASK_MAX_QUESTIONS = 4;
@@ -77,15 +77,39 @@ export declare function askStatus(view: PanelView, state: AskRuntime): string;
 /** The input row's lead: the digit lead while picking, the typing lead
  *  in the custom phase (the rule-input phase's shape, reused). */
 export declare function askLeadPlain(state: AskRuntime): string;
-export declare function panelBlockRows(view: PanelView, phase: PanelPhase, sel: PanelSel, W: number, maxRows: number, ask?: AskRuntime, pick?: PickRuntime): string[];
-export declare function panelLead(view: PanelView, phase: PanelPhase, sel: PanelSel, ask?: AskRuntime, pick?: PickRuntime): string;
-export declare function panelLeadPlain(view: PanelView, phase: PanelPhase, sel: PanelSel, ask?: AskRuntime, pick?: PickRuntime): string;
-export declare function panelStatus(view: PanelView, phase: PanelPhase, sel: PanelSel, ask?: AskRuntime, pick?: PickRuntime): string;
-export declare function panelAffordance(view: PanelView, phase: PanelPhase, sel: PanelSel, ask?: AskRuntime, pick?: PickRuntime): string;
+export declare function panelBlockRows(view: PanelView, phase: PanelPhase, cursor: number, W: number, maxRows: number, ask?: AskRuntime, pick?: PickRuntime, note?: string, safer?: SaferRuntime): string[];
+export declare function panelLead(view: PanelView, phase: PanelPhase, cursor: number, ask?: AskRuntime, pick?: PickRuntime): string;
+export declare function panelLeadPlain(view: PanelView, phase: PanelPhase, cursor: number, ask?: AskRuntime, pick?: PickRuntime): string;
+export declare function panelStatus(view: PanelView, phase: PanelPhase, cursor: number, ask?: AskRuntime, pick?: PickRuntime): string;
+export declare function panelAffordance(view: PanelView, phase: PanelPhase, cursor: number, ask?: AskRuntime, pick?: PickRuntime, safer?: SaferRuntime): string;
 /** The whole panel state in one call — the compositor's four reads share
  *  one source, so an ask can never render half as an approval (TUI2-R2
  *  ④: nor a pick as either). */
 export declare const panelRowsOf: (s: PanelState, W: number, maxRows: number) => string[];
+/**
+ * TUI2-R3v2 ② — the rows AND where the clickable ones are, from ONE
+ * call.
+ *
+ * The compositor needs both and must not compute the second from the
+ * first: the args cap, the note row and the option window all move the
+ * list, so a hit-test that re-derived the offset would drift from the
+ * picture exactly when the block is under pressure — which is when a
+ * misrouted click is most expensive.
+ *
+ * `options` is null for the ask and pick flavors: their rows are placed
+ * by their own renderers, and this round does not claim a click on them
+ * (the enable/disable invariant covers those surfaces; the gesture does
+ * not). A null here means every click is inert, which is the safe way
+ * to not-implement something.
+ */
+export declare const panelFrameOf: (s: PanelState, W: number, maxRows: number) => {
+    rows: string[];
+    options: {
+        offset: number;
+        count: number;
+        first: number;
+    } | null;
+};
 export declare const panelLeadOf: (s: PanelState) => string;
 export declare const panelStatusOf: (s: PanelState) => string;
 export declare const panelAffordanceOf: (s: PanelState) => string;

package/dist/ask-panel.js

@@ -27,7 +27,7 @@
  * durability would need a new durable mechanism), no "chat about this"
  * hand-off, no timeout and no countdown.
  */
-import { panelAffordance as basePanelAffordance, panelBlockRows as basePanelBlockRows, panelLead as basePanelLead, panelLeadPlain as basePanelLeadPlain, panelStatus as basePanelStatus, pickAffordance, pickBlockRows, pickLead, pickLeadPlain, pickStatus, } from "./approval-panel.js";
+import { panelBlockLayout, panelAffordance as basePanelAffordance, panelBlockRows as basePanelBlockRows, panelLead as basePanelLead, panelLeadPlain as basePanelLeadPlain, panelStatus as basePanelStatus, pickAffordance, pickBlockRows, pickLead, pickLeadPlain, pickStatus, } from "./approval-panel.js";
 import { cutLine } from "@vincemakes/kiso-tui-cells/components";
 import { escapeTerminal, palette } from "./render.js";
 /** The schema's own bounds — the registry refuses anything outside them
@@ -225,49 +225,74 @@ export function askLeadPlain(state) {
     return state.phase === "custom" ? "your answer: " : "1-4> ";
 }
 // ── the dispatchers: the panel slot, with the ask branch folded in ────
-export function panelBlockRows(view, phase, sel, W, maxRows, ask, pick) {
+export function panelBlockRows(view, phase, cursor, W, maxRows, ask, pick, note, safer) {
     if (view.pick !== undefined && pick !== undefined)
         return pickBlockRows(view, pick, W, maxRows);
     if (view.ask !== undefined && ask !== undefined)
         return askBlockRows(view, ask, W, maxRows);
-    return basePanelBlockRows(view, phase, sel, W, maxRows);
+    return basePanelBlockRows(view, phase, cursor, W, maxRows, note, safer);
 }
-export function panelLead(view, phase, sel, ask, pick) {
+export function panelLead(view, phase, cursor, ask, pick) {
     const p = palette();
     if (view.pick !== undefined && pick !== undefined)
         return pickLead(view, pick);
     if (view.ask !== undefined && ask !== undefined)
         return `${p.bold}${askLeadPlain(ask)}${p.reset}`;
-    return basePanelLead(view, phase, sel);
+    return basePanelLead(view, phase, cursor);
 }
-export function panelLeadPlain(view, phase, sel, ask, pick) {
+export function panelLeadPlain(view, phase, cursor, ask, pick) {
     if (view.pick !== undefined && pick !== undefined)
         return pickLeadPlain(view, pick);
     if (view.ask !== undefined && ask !== undefined)
         return askLeadPlain(ask);
-    return basePanelLeadPlain(view, phase, sel);
+    return basePanelLeadPlain(view, phase, cursor);
 }
-export function panelStatus(view, phase, sel, ask, pick) {
+export function panelStatus(view, phase, cursor, ask, pick) {
     if (view.pick !== undefined && pick !== undefined)
         return pickStatus(view);
     if (view.ask !== undefined && ask !== undefined)
         return askStatus(view, ask);
-    return basePanelStatus(view, phase, sel);
+    return basePanelStatus(view, phase, cursor);
 }
-export function panelAffordance(view, phase, sel, ask, pick) {
+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 basePanelAffordance(view, phase, sel);
+    return basePanelAffordance(view, phase, cursor, safer);
 }
 /** The whole panel state in one call — the compositor's four reads share
  *  one source, so an ask can never render half as an approval (TUI2-R2
  *  ④: nor a pick as either). */
-export const panelRowsOf = (s, W, maxRows) => panelBlockRows(s.view, s.phase, s.sel, W, maxRows, s.ask, s.pick);
-export const panelLeadOf = (s) => panelLead(s.view, s.phase, s.sel, s.ask, s.pick);
-export const panelStatusOf = (s) => panelStatus(s.view, s.phase, s.sel, s.ask, s.pick);
-export const panelAffordanceOf = (s) => panelAffordance(s.view, s.phase, s.sel, s.ask, s.pick);
+export const panelRowsOf = (s, W, maxRows) => panelBlockRows(s.view, s.phase, s.cursor, W, maxRows, s.ask, s.pick, s.note, s.safer);
+/**
+ * TUI2-R3v2 ② — the rows AND where the clickable ones are, from ONE
+ * call.
+ *
+ * The compositor needs both and must not compute the second from the
+ * first: the args cap, the note row and the option window all move the
+ * list, so a hit-test that re-derived the offset would drift from the
+ * picture exactly when the block is under pressure — which is when a
+ * misrouted click is most expensive.
+ *
+ * `options` is null for the ask and pick flavors: their rows are placed
+ * by their own renderers, and this round does not claim a click on them
+ * (the enable/disable invariant covers those surfaces; the gesture does
+ * not). A null here means every click is inert, which is the safe way
+ * to not-implement something.
+ */
+export const panelFrameOf = (s, W, maxRows) => {
+    if (s.view.pick !== undefined || s.view.ask !== undefined)
+        return { rows: panelRowsOf(s, W, maxRows), options: null };
+    const layout = panelBlockLayout(s.view, s.phase, s.cursor, W, maxRows, s.note, s.safer);
+    return {
+        rows: layout.rows,
+        options: layout.count === 0 ? null : { offset: layout.offset, count: layout.count, first: layout.first },
+    };
+};
+export const panelLeadOf = (s) => panelLead(s.view, s.phase, s.cursor, s.ask, s.pick);
+export const panelStatusOf = (s) => panelStatus(s.view, s.phase, s.cursor, s.ask, s.pick);
+export const panelAffordanceOf = (s) => panelAffordance(s.view, s.phase, s.cursor, s.ask, s.pick, s.safer);
 // ── the view: what the human reads when the model asks ────────────────
 /** The ask's PanelView. The dock-less fallback question is HONEST: a
  *  terminal without a panel cannot walk options, so it says the ask is

package/dist/compositor.d.ts

@@ -193,6 +193,13 @@ export declare class Body {
     /** Teardown — CSI r (the "no broken terminal" contract byte), the
      *  chrome rows cleared, the cursor home at the input line. */
     exit(): void;
+    /** TUI2-R3v2 ②: the panel's option rows as this frame placed them —
+     *  absolute, 1-based. The click hit-test's single source. */
+    panelOptionRows(): {
+        top: number;
+        count: number;
+        first: number;
+    } | null;
     /** SIGWINCH: clear the OLD live area (recorded geometry, ED only —
      *  zero LF, zero \x1b[3J — the shell history untouched), then the
      *  full-redraw path at the NEW geometry (O(height), zero replay).
@@ -257,6 +264,14 @@ export declare class Dock {
     enter(): void;
     exit(): void;
     onResize(): void;
+    /** TUI2-R3v2 ②: where the last frame put the panel's clickable option
+     *  rows (absolute screen rows). The editor binds this and does no row
+     *  arithmetic of its own. */
+    panelOptionRows(): {
+        top: number;
+        count: number;
+        first: number;
+    } | null;
     setStatus(text: string, hint?: string | null): void;
     setTail(tail: string): void;
     /** W21: bind the editor's panel state — the PanelSelect slot

package/dist/compositor.js

@@ -47,11 +47,12 @@ import { 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 { panelAffordanceOf, panelLeadOf, panelRowsOf, panelStatusOf } from "./ask-panel.js";
+import { panelAffordanceOf, panelFrameOf, panelLeadOf, panelRowsOf, panelStatusOf } from "./ask-panel.js";
+import { MOUSE_OFF } from "./editor.js";
 import { atPanelRows, bandHeader } from "./at-picker.js";
 // TUI2-R2 ②: the session picker's rows — the band's third occupant.
 import { sessionPickerRows } from "./session-picker.js";
-import { Container, ROLLUP_NOUN, SPINNER, bodySpacing, boxBottom, boxTop, cellComponent, exploreCounts, focusToken, exploreRows, foldLine, isExploreTool, pendingQueueRows, statusLine, turnFold, visibleWidth, } from "./components.js";
+import { Container, ROLLUP_NOUN, SPINNER, MdStream, bodySpacing, boxBottom, boxTop, cellComponent, exploreCounts, focusToken, exploreRows, foldLine, isExploreTool, pendingQueueRows, statusLine, turnFold, visibleWidth, } from "./components.js";
 import { bannerLines, escapeTerminal, foldResult, foldThinking, palette, renderTerminalGap, renderToolSummary, toolTarget } from "./render.js";
 import { displayVerb, keysSheetRows } from "./strings.js";
 /** The cursor marker — an APC private sequence the focus component
@@ -96,6 +97,11 @@ export class Body {
     #lastTool = null;
     #pendingCalls = new Map();
     #pipeBuf = ""; // the passthrough's thinking buffer
+    /** TUI2-MD ⑤ — the markdown scanner of the message currently
+     *  streaming, and the cell index its first block landed at. Null
+     *  between messages: the scanner's life is one assistant message. */
+    #md = null;
+    #mdBase = 0;
     #toolCells = new Map(); // callId → cell index (parallel tools)
     // W15: the collapsed (cut) tool cells — committed cells whose last
     // rendered row carried the "ctrl+r" affordance; the expand key's
@@ -112,6 +118,9 @@ export class Body {
     #rolledHeads = new Set();
     #write;
     #resizeHandler = null;
+    /** TUI2-R3v2 ②: the panel option rows' absolute screen span, as of the
+     *  last frame. Null whenever no clickable list is on screen. */
+    #panelRowSpan = null;
     // the chrome state (the Dock façade)
     #status = "";
     #statusHint = null;
@@ -398,22 +407,71 @@ export class Body {
         const turn = this.#turns[this.#turns.length - 1];
         if (turn !== undefined)
             turn.hasText = true;
-        const last = this.#cells[this.#cells.length - 1];
-        if (last !== undefined && last.kind === "text" && !last.done) {
-            last.text += text;
-        }
-        else {
+        // TUI2-MD ⑤: assistant body text is MARKDOWN, scanned as it
+        // streams. The scanner yields CLOSED blocks (final source, final
+        // render) and one OPEN tail block; each becomes a cell, and the
+        // cell is the commit unit the compositor already had — so
+        // block-freeze needs no new commit machinery at all. A closed
+        // block is a DONE cell the natural loop freezes; the tail is the
+        // one cell left live, repainting in place.
+        if (this.#md === null) {
             this.#closeOpenThinking();
             this.#closeOpenText();
-            this.#cells.push({ kind: "text", text, done: false });
+            this.#md = new MdStream();
+            this.#mdBase = this.#cells.length;
         }
+        this.#md.push(text);
+        this.#syncMd();
         this.#mark();
     }
+    /** TUI2-MD ⑤ — mirror the scanner's blocks onto cells. Append-only by
+     *  construction: a block that has closed never changes, so a cell that
+     *  is done is never touched again (and a committed one could not be).
+     *  Only the trailing tail cell is rewritten per delta. */
+    #syncMd() {
+        if (this.#md === null)
+            return;
+        const blocks = this.#md.blocks();
+        const closed = this.#md.closed();
+        for (let i = 0; i < blocks.length; i += 1) {
+            const at = this.#mdBase + i;
+            const cell = this.#cells[at];
+            if (cell === undefined) {
+                this.#cells.push({ kind: "md", block: blocks[i], done: i < closed });
+                continue;
+            }
+            if (cell.kind !== "md" || cell.done)
+                continue;
+            cell.block = blocks[i];
+            cell.done = i < closed;
+        }
+        // the tail can vanish (a lone whitespace delta that turns out to be
+        // a blank line). Drop it only where dropping is safe: never below
+        // the commit frontier, where the bytes are already the terminal's.
+        const want = this.#mdBase + blocks.length;
+        while (this.#cells.length > Math.max(want, this.#committed) && this.#cells[this.#cells.length - 1].kind === "md")
+            this.#cells.pop();
+    }
+    /** TUI2-MD ⑤ — the message ends: the tail block closes and every md
+     *  cell of this message is final. */
+    #endMd() {
+        if (this.#md === null)
+            return;
+        this.#md.end();
+        this.#syncMd();
+        for (let i = this.#mdBase; i < this.#cells.length; i += 1) {
+            const cell = this.#cells[i];
+            if (cell.kind === "md")
+                cell.done = true;
+        }
+        this.#md = null;
+    }
     textEnd() {
         if (!this.#isActive()) {
             this.#write("\n");
             return;
         }
+        this.#endMd();
         const last = this.#cells[this.#cells.length - 1];
         if (last !== undefined && last.kind === "text" && !last.done)
             last.done = true;
@@ -718,6 +776,20 @@ export class Body {
     /** Teardown — CSI r (the "no broken terminal" contract byte), the
      *  chrome rows cleared, the cursor home at the input line. */
     exit() {
+        // TUI2-R3v2 ②: the mouse disable rides the SAME teardown as CSI r,
+        // and rides it BEFORE the docked guard — an un-docked compositor is
+        // exactly the state a superseded or half-torn-down one is in, and
+        // that is when a leak survives. The editor disables it too; this is
+        // the second belt on the one contract the round calls blocker-class.
+        //
+        // TTY-GATED, and the gate is not a nicety. A pipe has no mouse mode
+        // to reset, so the bytes would be pure noise there — and the pipe
+        // path is byte-identical by ruling. The unguarded version put
+        // "[?1000l[?1006l" into piped stdout and four gates caught it
+        // (compact-cli, tui-modes, tui-v7-planmode, tui2-r2-resume-picker):
+        // the invariant is about terminals, and a pipe is not one.
+        if (process.stdout.isTTY === true)
+            this.#write(MOUSE_OFF);
         if (!this.#docked) {
             // TUI2-R2pre ③: an un-docked compositor can still hold a listener
             // (it was superseded, or enter() ran and the dock was torn down by
@@ -739,6 +811,11 @@ export class Body {
         out.push(`\x1b[${Math.max(1, H - 1)};1H`);
         this.#write(out.join(""));
     }
+    /** TUI2-R3v2 ②: the panel's option rows as this frame placed them —
+     *  absolute, 1-based. The click hit-test's single source. */
+    panelOptionRows() {
+        return this.#panelRowSpan;
+    }
     /** SIGWINCH: clear the OLD live area (recorded geometry, ED only —
      *  zero LF, zero \x1b[3J — the shell history untouched), then the
      *  full-redraw path at the NEW geometry (O(height), zero replay).
@@ -923,14 +1000,13 @@ export class Body {
                 inputExtra +
                 queueRows.length);
         }
-        const live = this.#cells.slice(this.#committed);
         const ctx = { spinnerI: this.#spinnerI, now: Date.now(), height: this.#opts.height() };
         const W = this.#opts.width();
         let lines = 0;
         let prev = this.#committed > 0 ? this.#lineCache[this.#committed - 1] : null;
-        for (const cell of live) {
-            const rows = cellComponent(cell).render(W, ctx);
-            lines += bodySpacing(prev, rows).length;
+        for (let i = this.#committed; i < this.#cells.length; i += 1) {
+            const rows = cellComponent(this.#cells[i]).render(W, ctx);
+            lines += this.#space(i, prev, rows).length;
             prev = rows;
         }
         return lines + CHROME_ROWS + inputExtra + this.#menuRows(W).length + queueRows.length;
@@ -963,7 +1039,7 @@ export class Body {
                 const cell = this.#cells[i];
                 const lines = cellComponent(cell).render(W, ctx);
                 this.#lineCache[i] = lines; // the cell's OWN rows — the cache stays raw
-                this.#committedLines += bodySpacing(i > 0 ? this.#lineCache[i - 1] : null, lines).length;
+                this.#committedLines += this.#space(i, i > 0 ? this.#lineCache[i - 1] : null, lines).length;
             }
         }
         // 1. the natural commits — the leading DONE cells freeze: their
@@ -998,6 +1074,10 @@ export class Body {
         const inputExtra = editor.rows.length - 1;
         const chromeRows = CHROME_ROWS + inputExtra + menuRows.length + queueRows.length;
         let liveLines = [];
+        // TUI2-R3v2 ②: where this frame put the panel's option rows, relative
+        // to the live region's top. Resolved to ABSOLUTE screen rows once
+        // liveTop is known, below.
+        let panelSpan = null;
         const panel = this.#panelState?.() ?? null;
         // TUI2-R1.5 ⑦(a) (VD-8): the sheet is an OVERLAY, and the frame it
         // opens on — and the one it closes on — take the full-redraw path.
@@ -1024,7 +1104,12 @@ export class Body {
             // the W11 blank would separate it from the frozen content).
             // The cap is exact, so the force-commit loop never fires. W22:
             // the queue band sits below the panel — the cap shrinks by it.
-            liveLines = panelRowsOf(panel, W, Math.max(1, H - 4 - inputExtra - queueRows.length));
+            // TUI2-R3v2 ②: the rows and the CLICKABLE span come from one
+            // call, so the hit-test reads the arithmetic that placed the
+            // rows rather than a second copy of it.
+            const frame = panelFrameOf(panel, W, Math.max(1, H - 4 - inputExtra - queueRows.length));
+            liveLines = frame.rows;
+            panelSpan = frame.options;
         }
         else {
             // TUI2-R2 ⑤ (D, candidate 1): the FOCUS — the cell the next ctrl+r
@@ -1042,7 +1127,7 @@ export class Body {
                 // nowhere else, which is what makes "exactly one" structural
                 if (i === focus && rows.length > 0)
                     rows[0] = focusToken(rows[0], W);
-                liveLines.push(...bodySpacing(prev, rows));
+                liveLines.push(...this.#space(i, prev, rows));
                 prev = rows;
             }
         }
@@ -1063,7 +1148,7 @@ export class Body {
                     const rows = cellComponent(cell).render(W, ctx);
                     if (i === focus && rows.length > 0)
                         rows[0] = focusToken(rows[0], W);
-                    liveLines.push(...bodySpacing(prev, rows));
+                    liveLines.push(...this.#space(i, prev, rows));
                     prev = rows;
                 }
             }
@@ -1073,6 +1158,11 @@ export class Body {
         //    shows the bottom H rows; the live region anchors to the bottom.
         const liveRowsTotal = liveLines.length + chromeRows;
         const liveTop = Math.min(this.#committedLines, H - liveRowsTotal) + 1;
+        // TUI2-R3v2 ②: the option rows' ABSOLUTE screen rows, recorded per
+        // frame. A click is answered against the frame the human was looking
+        // at when they clicked, which is this one.
+        this.#panelRowSpan =
+            panelSpan === null ? null : { top: liveTop + panelSpan.offset, count: panelSpan.count, first: panelSpan.first };
         // 5. the frame bytes.
         const out = [];
         out.push("\x1b[?2026h"); // synchronized output ON (DEC 2026)
@@ -1106,6 +1196,23 @@ export class Body {
         // composer (N = 1 ⇒ H−2, the retired hard-coded anchor).
         this.#lastAnchorRow = H - 1 - editor.rows.length + editor.markerRow;
     }
+    /** TUI2-MD ⑤ — the join blank between cell i−1 and cell i.
+     *
+     *  W11's formula ("a blank above a row that is itself a block, or
+     *  whose previous sibling was taller than one row") reads ROW COUNTS,
+     *  and markdown's rhythm is not a row count: a heading wants a blank
+     *  above and below it even between two one-row paragraphs, and two
+     *  rows of one fence want none even when a long code line folds to
+     *  two. So between two MARKDOWN cells the formula steps aside and the
+     *  block's own `gap` decides — the renderer owns the rhythm, which is
+     *  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). */
+    #space(i, prev, rows) {
+        if (i > 0 && this.#cells[i]?.kind === "md" && this.#cells[i - 1]?.kind === "md")
+            return rows;
+        return bodySpacing(prev, rows);
+    }
     /** Commit the cell at index i: render + cache its lines (immutable —
      *  the force-committed form freezes at the current render), advance
      *  the bookkeeping — and collect the lines for this frame's writes.
@@ -1128,7 +1235,7 @@ export class Body {
         if (cell.kind === "tool" && lines.some((l) => l.includes("ctrl+r")))
             this.#collapsed.unshift(i);
         this.#lineCache[i] = lines;
-        const placed = bodySpacing(i > 0 ? this.#lineCache[i - 1] : null, lines);
+        const placed = this.#space(i, i > 0 ? this.#lineCache[i - 1] : null, lines);
         this.#committed += 1;
         this.#committedLines += placed.length;
         this.#committedLinesThisFrame.push(...placed);
@@ -1544,7 +1651,7 @@ export class Body {
         //    cell (the V6-1 frozen-loop finding — the banner vanished).
         const frozen = [];
         for (let i = 0; i < this.#committedAtFrameStart; i += 1) {
-            frozen.push(...bodySpacing(i > 0 ? this.#lineCache[i - 1] : null, this.#lineCache[i]));
+            frozen.push(...this.#space(i, i > 0 ? this.#lineCache[i - 1] : null, this.#lineCache[i]));
         }
         // A8: the march is the WINDOW — the model's last H rows. When the
         // model total (committed + live + chrome) exceeds H, the window's
@@ -1884,8 +1991,11 @@ export class Body {
         return i === undefined ? null : (this.#cells[i] ?? null);
     }
     /** Close an open TEXT cell when a new cell starts (see v2d — the
-     *  runtime emits no text_end; the next cell is the close signal). */
+     *  runtime emits no text_end; the next cell is the close signal).
+     *  TUI2-MD ⑤: that same signal ends the markdown message — the open
+     *  tail block closes and its cell becomes commit-eligible. */
     #closeOpenText() {
+        this.#endMd();
         const last = this.#cells[this.#cells.length - 1];
         if (last !== undefined && last.kind === "text" && !last.done)
             last.done = true;
@@ -1922,6 +2032,12 @@ export class Dock {
     onResize() {
         compositorRef?.onResize();
     }
+    /** TUI2-R3v2 ②: where the last frame put the panel's clickable option
+     *  rows (absolute screen rows). The editor binds this and does no row
+     *  arithmetic of its own. */
+    panelOptionRows() {
+        return compositorRef?.panelOptionRows() ?? null;
+    }
     setStatus(text, hint) {
         compositorRef?.setStatus(text, hint ?? null);
     }

package/dist/editor.d.ts

@@ -23,9 +23,20 @@
  */
 import { charWidth, displayWidth, widthOf } from "./width.js";
 export { charWidth, displayWidth, widthOf };
-import { type PanelState, type PanelVerdict, type PanelView } from "./approval-panel.js";
+import { type PanelState, type PanelVerdict, type PanelView, type SaferOption } from "./approval-panel.js";
 import { type AtItem, type AtMatch } from "./at-picker.js";
 import { type SessionCardView, type SessionPickState } from "./session-picker.js";
+/**
+ * TUI2-R3v2 ② — the mouse-mode bytes, stated once.
+ *
+ * ?1000 is the button-event report and ?1006 is the SGR encoding that
+ * makes it parseable past column 95 (the legacy X10 encoding packs the
+ * coordinate into one byte and simply breaks on a wide terminal). Both
+ * go on together and come off together; a terminal left with either one
+ * set is a terminal that prints escape bytes at the shell prompt.
+ */
+export declare const MOUSE_ON = "\u001B[?1000h\u001B[?1006h";
+export declare const MOUSE_OFF = "\u001B[?1000l\u001B[?1006l";
 export declare const PROMPT = "\u258C ";
 export declare const PROMPT_WIDTH: number;
 /** v3 §04 — the slash-command menu's command table (English one-liners). */
@@ -116,7 +127,9 @@ export declare class Editor {
     /** W21: open the approval panel. The current buffer is stashed
      *  (restored at close — commit AND cancel), the panel takes the
      *  keys and the input row's lead, the menu closes. */
-    beginPanel(view: PanelView, onCommit: (v: PanelVerdict) => void): void;
+    beginPanel(view: PanelView, onCommit: (v: PanelVerdict) => void, opts?: {
+        safer?: () => Promise<readonly SaferOption[] | null>;
+    }): void;
     /** W21: cancel the panel — the SIGINT path's pair to beginPanel. */
     cancelPanel(): void;
     /** W21: the compositor's bound view — the phase/selection while the
@@ -130,4 +143,14 @@ export declare class Editor {
     selfRender(): void;
     /** Feed raw stdin bytes — the parser. Public for unit tests. */
     feed(raw: Uint8Array): void;
+    /** TUI2-R3v2 ②: the compositor reports where it PUT the option rows.
+     *  The editor does no row arithmetic of its own — the surface that
+     *  placed them is the only thing that can say where they are, and a
+     *  second copy of that sum is how a hit-test comes to disagree with
+     *  the picture. */
+    bindPanelRows(fn: (() => {
+        top: number;
+        count: number;
+        first?: number;
+    } | null) | null): void;
 }