@vincemakes/kiso-tui 0.1.39 → 0.1.41

package/dist/diff.d.ts

@@ -1,32 +1,4 @@
-/**
- * v2e — the diff renderer: edit/write changes as inline ± lines, zero
- * dependencies, no syntax highlighting (the spec's scope line). Shown at
- * the approval moment ONLY — the frozen summary stays one line (v2d's
- * anti-leak principle), /last has the full data.
- *
- * edit_file diffs IN PLACE (the search→replace windows are known — no
- * general engine needed); write_file does a row-level LCS over the old
- * file (small files are the target). Context: 2 rows each side. The
- * RENDERER truncates (18 head + 18 tail + "… N lines"); the stats come
- * from the full diff.
- */
-/** The diff block's per-row kind. */
-export type DiffLine = {
-    kind: "-" | "+" | " ";
-    text: string;
-};
-export interface DiffResult {
-    /** The FULL diff (with context, not truncated) — the display truncates. */
-    lines: DiffLine[];
-    added: number;
-    removed: number;
-}
-/** The RENDERER's truncation: head + "… N lines (/last for full)" + tail. */
-export declare function truncateDiff(diff: DiffLine[]): DiffLine[];
-/** edit_file: the search→replace windows replace in place — the changed
- *  region is KNOWN, so the diff is the old window vs the new window,
- *  context from the surrounding file. */
-export declare function editFileDiff(oldContent: string, search: string, replace: string): DiffResult;
-/** write_file: a new file is all +; an existing file diffs row-level
- *  against its old content. */
-export declare function writeFileDiff(oldContent: string | null, newContent: string): DiffResult;
+/** The diff renderer moved to tui-cells (ADR-0043 Amendment 4) —
+ *  this module is the re-export shim: the compositor's and index.ts's
+ *  imports (./diff.js) stay verbatim. */
+export * from "@vincemakes/kiso-tui-cells/diff";

package/dist/diff.js

@@ -1,122 +1,4 @@
-/**
- * v2e — the diff renderer: edit/write changes as inline ± lines, zero
- * dependencies, no syntax highlighting (the spec's scope line). Shown at
- * the approval moment ONLY — the frozen summary stays one line (v2d's
- * anti-leak principle), /last has the full data.
- *
- * edit_file diffs IN PLACE (the search→replace windows are known — no
- * general engine needed); write_file does a row-level LCS over the old
- * file (small files are the target). Context: 2 rows each side. The
- * RENDERER truncates (18 head + 18 tail + "… N lines"); the stats come
- * from the full diff.
- */
-/** A line-level LCS diff — the classic two-row DP, ~small inputs. */
-function lcsDiff(oldLines, newLines) {
-    const n = oldLines.length;
-    const m = newLines.length;
-    const dp = Array.from({ length: n + 1 }, () => new Array(m + 1).fill(0));
-    for (let i = n - 1; i >= 0; i -= 1) {
-        for (let j = m - 1; j >= 0; j -= 1) {
-            dp[i][j] = oldLines[i] === newLines[j] ? dp[i + 1][j + 1] + 1 : Math.max(dp[i + 1][j], dp[i][j + 1]);
-        }
-    }
-    const out = [];
-    let i = 0;
-    let j = 0;
-    while (i < n && j < m) {
-        if (oldLines[i] === newLines[j]) {
-            out.push({ kind: " ", text: oldLines[i] });
-            i += 1;
-            j += 1;
-        }
-        else if (dp[i + 1][j] >= dp[i][j + 1]) {
-            out.push({ kind: "-", text: oldLines[i] });
-            i += 1;
-        }
-        else {
-            out.push({ kind: "+", text: newLines[j] });
-            j += 1;
-        }
-    }
-    while (i < n) {
-        out.push({ kind: "-", text: oldLines[i] });
-        i += 1;
-    }
-    while (j < m) {
-        out.push({ kind: "+", text: newLines[j] });
-        j += 1;
-    }
-    return out;
-}
-/** Keep 2 context rows around each change — the unified-style window. */
-function withContext(diff) {
-    const out = [];
-    let lastAdded = -10;
-    for (let k = 0; k < diff.length; k += 1) {
-        if (diff[k].kind === " ")
-            continue;
-        const from = Math.max(0, k - 2);
-        const to = Math.min(diff.length - 1, k + 2);
-        for (let c = from; c <= to; c += 1) {
-            if (c > lastAdded) {
-                out.push(diff[c]);
-                lastAdded = c;
-            }
-        }
-        lastAdded = to;
-    }
-    return out;
-}
-const MAX_DIFF_LINES = 40; // the RENDERED cap
-const TRUNCATE_KEEP = 18;
-/** The RENDERER's truncation: head + "… N lines (/last for full)" + tail. */
-export function truncateDiff(diff) {
-    if (diff.length <= MAX_DIFF_LINES)
-        return diff;
-    const omitted = diff.length - 2 * TRUNCATE_KEEP;
-    return [
-        ...diff.slice(0, TRUNCATE_KEEP),
-        { kind: " ", text: `… ${omitted} lines (/last for full)` },
-        ...diff.slice(diff.length - TRUNCATE_KEEP),
-    ];
-}
-function stats(diff) {
-    let added = 0;
-    let removed = 0;
-    for (const d of diff) {
-        if (d.kind === "+")
-            added += 1;
-        else if (d.kind === "-")
-            removed += 1;
-    }
-    return { added, removed };
-}
-/** edit_file: the search→replace windows replace in place — the changed
- *  region is KNOWN, so the diff is the old window vs the new window,
- *  context from the surrounding file. */
-export function editFileDiff(oldContent, search, replace) {
-    const oldLines = oldContent.split("\n");
-    const searchLines = search.split("\n");
-    const replaceLines = replace.split("\n");
-    // Locate the search window (the first occurrence — the edit tool's own
-    // semantics); no occurrence → the whole file is the old side.
-    let at = -1;
-    for (let i = 0; i + searchLines.length <= oldLines.length; i += 1) {
-        if (oldLines.slice(i, i + searchLines.length).join("\n") === search) {
-            at = i;
-            break;
-        }
-    }
-    const lines = at < 0 ? withContext(lcsDiff(oldLines, replaceLines)) : withContext(lcsDiff(oldLines, [...oldLines.slice(0, at), ...replaceLines, ...oldLines.slice(at + searchLines.length)]));
-    return { lines, ...stats(lines) };
-}
-/** write_file: a new file is all +; an existing file diffs row-level
- *  against its old content. */
-export function writeFileDiff(oldContent, newContent) {
-    if (oldContent === null) {
-        const lines = newContent.split("\n").map((text) => ({ kind: "+", text }));
-        return { lines, added: lines.length, removed: 0 };
-    }
-    const lines = withContext(lcsDiff(oldContent.split("\n"), newContent.split("\n")));
-    return { lines, ...stats(lines) };
-}
+/** The diff renderer moved to tui-cells (ADR-0043 Amendment 4) —
+ *  this module is the re-export shim: the compositor's and index.ts's
+ *  imports (./diff.js) stay verbatim. */
+export * from "@vincemakes/kiso-tui-cells/diff";

package/dist/editor.d.ts

@@ -18,6 +18,7 @@
  */
 import { charWidth, displayWidth, widthOf } from "./width.js";
 export { charWidth, displayWidth, widthOf };
+import { type PanelState, type PanelVerdict, type PanelView } from "./approval-panel.js";
 export declare const PROMPT = "\u258C ";
 export declare const PROMPT_WIDTH: number;
 /** v3 §04 — the slash-command menu's command table (English one-liners). */
@@ -42,6 +43,10 @@ export declare class Editor {
     onEot(cb: () => void): void;
     onEscape(cb: () => void): void;
     onExpand(cb: () => void): void;
+    /** W22: bind the pending-turn queue — the CLI's live slots. The ↑
+     *  pop walks them (each pop leaves the queue, cancelling the turn);
+     *  esc ends the walk after one more pop. */
+    bindQueue(state: () => readonly string[], pop: () => string | null): void;
     /** The whole buffer as text (the CLI's line()/clearLine()). */
     line(): string;
     clearLine(): void;
@@ -61,6 +66,15 @@ export declare class Editor {
     /** Cancel a pending question — the buffer stays (its text becomes the
      *  next turn on Enter, the readline re-emit equivalent). */
     cancelQuestion(): void;
+    /** 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;
+    /** W21: cancel the panel — the SIGINT path's pair to beginPanel. */
+    cancelPanel(): void;
+    /** W21: the compositor's bound view — the phase/selection while the
+     *  panel is up, null otherwise. */
+    panelState(): PanelState | null;
     enter(): void;
     exit(): void;
     /** The row's own render when the dock is inactive (a TTY without a

package/dist/editor.js

@@ -16,11 +16,12 @@
  * The editor is a SINGLE line: bracketed paste (?2004h) unwraps and
  * inserts, internal newlines become spaces.
  */
-import { charWidth, displayWidth, widthOf } from "./width.js";
+import { charWidth, displayWidth, leadWidth, widthOf } from "./width.js";
 // the width primitives moved to width.ts (W1, the single width
 // authority) — re-exported so the editor's public surface is unchanged.
 export { charWidth, displayWidth, widthOf };
 import { palette } from "./render.js";
+import { panelLead } from "./approval-panel.js";
 // TUI v4 #16d: the input row is the blue brick + the edit area — the
 // "you>" text is gone (the brick IS the prompt; the pipe path's readline
 // prompt keeps its own "you> " — v2a line mode, byte-for-byte).
@@ -47,6 +48,14 @@ export class Editor {
     #cursor = 0;
     #scroll = 0; // chars scrolled off the left (width-based reflow)
     #questionCb = null;
+    // W21: the panel state machine — the approval/trust panel owns the
+    // interaction while up: the digit/y/n/esc/tab routing, the rule
+    // input, the tab-amend feedback, the phase/selection the compositor
+    // renders. The menu never opens while a panel is up; the pre-panel
+    // buffer is stashed at open and restored at close (commit AND
+    // cancel) — the panel's rule/feedback text never leaks into the
+    // user's next turn.
+    #panel = null;
     #pasting = false;
     #lineCb = null;
     #pendingLines = []; // submits before onLine is wired (startup) — never dropped
@@ -70,6 +79,16 @@ export class Editor {
     #history = [];
     #historyIdx = null;
     #preBrowse = [];
+    // W22: the pending-turn queue's bound state — the CLI's live slots
+    // (chat.ts). ↑ pops the LAST queued message into the buffer and
+    // enters the pop-mode (the walk: repeated ↑ pop older ones, each
+    // replacing the line); esc in the pop-mode pops once more and ENDS
+    // the mode — the next esc at rest rides the escapeCbs (the
+    // interrupt survives). The chips themselves are the compositor's
+    // bindQueue; this is the keys only.
+    #queueState = () => [];
+    #queuePop = null;
+    #queuePopMode = false;
     #pending = ""; // an incomplete ESC/CSI prefix across chunks
     #decoder = new TextDecoder();
     #entered = false;
@@ -103,6 +122,13 @@ export class Editor {
     onExpand(cb) {
         this.#expandCbs.push(cb);
     }
+    /** W22: bind the pending-turn queue — the CLI's live slots. The ↑
+     *  pop walks them (each pop leaves the queue, cancelling the turn);
+     *  esc ends the walk after one more pop. */
+    bindQueue(state, pop) {
+        this.#queueState = state;
+        this.#queuePop = pop;
+    }
     /** The whole buffer as text (the CLI's line()/clearLine()). */
     line() {
         return String.fromCodePoint(...this.#chars);
@@ -136,6 +162,8 @@ export class Editor {
         return MENU_ITEMS.filter((m) => m.name.startsWith(line));
     }
     #refreshMenu() {
+        if (this.#panel !== null)
+            return; // W21: the menu never opens while the panel owns the keys
         const f = this.#menuFiltered();
         this.#menuOpen = f.length > 0;
         if (this.#menuSel >= f.length)
@@ -151,6 +179,38 @@ export class Editor {
     cancelQuestion() {
         this.#questionCb = null;
     }
+    /** 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, onCommit) {
+        this.#panel = {
+            view,
+            phase: "options",
+            sel: 0,
+            amend: "yes",
+            onCommit,
+            stash: { chars: this.#chars, cursor: this.#cursor, scroll: this.#scroll },
+        };
+        this.#chars = [];
+        this.#cursor = 0;
+        this.#scroll = 0;
+        this.#menuOpen = false;
+        this.#menuSel = 0;
+        this.#queuePopMode = false; // W22: the panel owns the keys while up
+        this.#onRender();
+    }
+    /** W21: cancel the panel — the SIGINT path's pair to beginPanel. */
+    cancelPanel() {
+        this.#panelClose({ action: "cancel" });
+    }
+    /** W21: the compositor's bound view — the phase/selection while the
+     *  panel is up, null otherwise. */
+    panelState() {
+        const panel = this.#panel;
+        if (panel === null)
+            return null;
+        return { view: panel.view, phase: panel.phase, sel: panel.sel };
+    }
     enter() {
         if (this.#entered)
             return;
@@ -176,8 +236,17 @@ export class Editor {
         const p = palette();
         const st = this.dockState();
         const W = (process.stdout.columns ?? 0) || 80; // a degenerate 0 size (no TIOCSWINSZ) falls back
-        const cursorCol = Math.min(1 + PROMPT_WIDTH + st.cursor, W);
-        process.stdout.write(`\r\x1b[0K${p.bold}${PROMPT}${p.reset}${st.line}\x1b[${cursorCol}G`);
+        // W21: the panel's lead owns the row while up (the brick returns
+        // when the panel closes).
+        const panel = this.#panel;
+        const lead = panel !== null ? panelLead(panel.view, panel.phase, panel.sel) : `${p.bold}${PROMPT}${p.reset}`;
+        // W23: the ONE width authority — leadWidth(lead), the ANSI-stripped
+        // visible width (the styled panel lead / the styled brick measure
+        // the same as their plain text — a lead can never measure
+        // differently at the editor than at the compositor)
+        const leadW = leadWidth(lead);
+        const cursorCol = Math.min(1 + leadW + st.cursor, W);
+        process.stdout.write(`\r\x1b[0K${lead}${st.line}\x1b[${cursorCol}G`);
     }
     // ---- input ----
     /** Feed raw stdin bytes — the parser. Public for unit tests. */
@@ -187,6 +256,50 @@ export class Editor {
         let i = 0;
         while (i < text.length) {
             const c = text[i];
+            if (this.#panel !== null) {
+                // W21: the panel owns the keys — the digits/y/n select in
+                // the options phase (digit 2 jumps to the rule input), tab
+                // opens the amend (approval only), esc backs out (rule/
+                // amend → options, selection → rest, rest → cancel), enter
+                // commits by phase. CSI/SS3 and the editing keys still ride
+                // the normal chain below (the rule/amend lines are free
+                // text); ctrl-c still rides the SIGINT handler (which
+                // cancels the panel).
+                const panel = this.#panel;
+                if (c === "\x1b" && !text.slice(i + 1).startsWith("[") && !text.slice(i + 1).startsWith("O")) {
+                    this.#panelEsc();
+                    i += 1;
+                    continue;
+                }
+                if (c === "\t") {
+                    if (panel.phase === "options")
+                        this.#panelTab();
+                    i += 1;
+                    continue;
+                }
+                if (c === "\x0d" || c === "\x0a") {
+                    this.#panelEnter();
+                    i += 1;
+                    continue;
+                }
+                if (c === "1" || c === "y" || c === "Y") {
+                    if (panel.phase === "options")
+                        this.#panelSelect(1);
+                    i += 1;
+                    continue;
+                }
+                if (c === "2" && panel.phase === "options" && panel.view.flavor === "approval") {
+                    this.#panelRule();
+                    i += 1;
+                    continue;
+                }
+                if (c === "3" || c === "n" || c === "N") {
+                    if (panel.phase === "options")
+                        this.#panelSelect(3);
+                    i += 1;
+                    continue;
+                }
+            }
             if (c === "\x1b") {
                 const rest = text.slice(i + 1);
                 if (rest.startsWith("[")) {
@@ -203,19 +316,32 @@ export class Editor {
                 }
                 else if (this.#menuOpen) {
                     // v3 §04: Esc closes the menu and clears the buffer.
+                    // CA-4: the closing esc consumes its burst (the `i += 1`
+                    // convention) — a double-esc can never abort the turn.
                     this.#chars = [];
                     this.#cursor = 0;
                     this.#scroll = 0;
                     this.#refreshMenu();
+                    i += 1;
+                }
+                else if (this.#queuePopMode) {
+                    // W22: esc in the pop-mode — ONE more pop, then the
+                    // mode ends: the next esc at rest rides the escapeCbs
+                    // (the interrupt chain survives the walk).
+                    this.#queuePopMode = false;
+                    this.#queuePopIntoBuffer();
+                    i += 1;
                 }
                 else if (this.#historyIdx !== null) {
                     // A2: Esc exits the history browse — the pre-browse
-                    // (empty) input returns.
+                    // (empty) input returns. CA-4: the exiting esc consumes
+                    // its burst — a double-esc can never abort the turn.
                     this.#historyIdx = null;
                     this.#chars = [...this.#preBrowse];
                     this.#cursor = this.#chars.length;
                     this.#reflow();
                     this.#onRender();
+                    i += 1;
                 }
                 else {
                     for (const cb of [...this.#escapeCbs])
@@ -312,13 +438,27 @@ export class Editor {
             // v3 §04: the menu owns ↑↓ while open (the selection, never the
             // cursor). A2 (the feel): otherwise ↑↓ navigate the session history
             // — ONLY from an empty input or while already browsing; mid-edit
-            // the cursor semantics are unchanged (↑↓ do nothing).
-            if (this.#menuOpen) {
+            // the cursor semantics are unchanged (↑↓ do nothing). W21: the
+            // panel owns the keys while up (↑↓ do nothing — the panel has no
+            // ↑↓ role).
+            if (this.#panel !== null) {
+                /* the panel owns the keys */
+            }
+            else if (this.#menuOpen) {
                 if (final === "A")
                     this.#menuSel = Math.max(0, this.#menuSel - 1);
                 else
                     this.#menuSel = Math.min(this.#menuFiltered().length - 1, this.#menuSel + 1);
             }
+            else if (final === "A" && this.#queuePop !== null && (this.#queuePopMode || this.line() === "") && this.#queueState().length > 0) {
+                // W22: ↑ pops the LAST queued message into the buffer — the
+                // walk: repeated presses pop older ones (each replaces the
+                // line, the cursor at the end); esc ends the mode after one
+                // more pop. Mid-edit the pop never fires (the A2
+                // non-destructive feel, mirroring the history browse).
+                this.#queuePopMode = true;
+                this.#queuePopIntoBuffer();
+            }
             else if (this.#historyIdx !== null || this.line() === "") {
                 this.#historyMove(final === "A" ? -1 : 1);
             }
@@ -339,10 +479,104 @@ export class Editor {
             this.#reflow();
         }
     }
+    // ---- W21: the panel state machine ----
+    #panelSelect(sel) {
+        const panel = this.#panel;
+        if (panel === null)
+            return;
+        panel.sel = sel;
+        this.#onRender();
+    }
+    /** digit 2 — the rule input: the buffer prefilled with the tool name
+     *  (the option-2 prefill; enter commits the rule). */
+    #panelRule() {
+        const panel = this.#panel;
+        if (panel === null)
+            return;
+        panel.phase = "rule";
+        panel.sel = 2;
+        this.#chars = [...panel.view.name].map((ch) => ch.codePointAt(0));
+        this.#cursor = this.#chars.length;
+        this.#scroll = 0;
+        this.#onRender();
+    }
+    /** tab — the amend phase on the selected option (yes/deny); the
+     *  simple flavor never has it (options 1/3 only, no option 2). */
+    #panelTab() {
+        const panel = this.#panel;
+        if (panel === null || panel.view.flavor !== "approval")
+            return;
+        panel.amend = panel.sel === 3 ? "no" : "yes";
+        panel.phase = "amend";
+        this.#chars = [];
+        this.#cursor = 0;
+        this.#scroll = 0;
+        this.#onRender();
+    }
+    /** esc — back out of the rule/amend to the options (the buffer
+     *  clears), deselect, or cancel the panel at rest. */
+    #panelEsc() {
+        const panel = this.#panel;
+        if (panel === null)
+            return;
+        if (panel.phase !== "options") {
+            panel.phase = "options";
+            panel.sel = 0;
+            this.#chars = [];
+            this.#cursor = 0;
+            this.#scroll = 0;
+            this.#onRender();
+            return;
+        }
+        if (panel.sel !== 0) {
+            panel.sel = 0;
+            this.#onRender();
+            return;
+        }
+        this.#panelClose({ action: "cancel" });
+    }
+    /** enter — commit by phase: the rule input (the tool name when
+     *  empty), the amend feedback (the bare verdict when empty), or the
+     *  selected option (nothing at rest — an accidental enter never
+     *  approves). Enter on the selected option 2 is the digit-2 key. */
+    #panelEnter() {
+        const panel = this.#panel;
+        if (panel === null)
+            return;
+        const line = this.line();
+        if (panel.phase === "rule") {
+            this.#panelClose({ action: "allow-rule", rule: line === "" ? panel.view.name : line });
+            return;
+        }
+        if (panel.phase === "amend") {
+            this.#panelClose(panel.amend === "yes" ? { action: "allow", reason: line } : { action: "deny", reason: line });
+            return;
+        }
+        if (panel.sel === 1)
+            this.#panelClose({ action: "allow", reason: "" });
+        else if (panel.sel === 2)
+            this.#panelRule();
+        else if (panel.sel === 3)
+            this.#panelClose({ action: "deny", reason: "" });
+    }
+    #panelClose(verdict) {
+        const panel = this.#panel;
+        if (panel === null)
+            return;
+        this.#panel = null;
+        // the pre-panel buffer returns — the panel's rule/feedback text
+        // never leaks into the user's next turn (commit AND cancel).
+        this.#chars = [...panel.stash.chars];
+        this.#cursor = panel.stash.cursor;
+        this.#scroll = panel.stash.scroll;
+        this.#onRender();
+        panel.onCommit(verdict);
+    }
     // ---- editing ----
     #insert(cp) {
         if (this.#historyIdx !== null)
             this.#historyIdx = null; // editing leaves the browse
+        this.#queuePopMode = false; // W22: editing leaves the pop-walk too
         this.#chars.splice(this.#cursor, 0, cp);
         this.#cursor += 1;
         this.#reflow();
@@ -354,6 +588,7 @@ export class Editor {
             return;
         if (this.#historyIdx !== null)
             this.#historyIdx = null; // editing leaves the browse
+        this.#queuePopMode = false; // W22: editing leaves the pop-walk too
         this.#chars.splice(this.#cursor - 1, 1);
         this.#cursor -= 1;
         this.#reflow();
@@ -420,6 +655,7 @@ export class Editor {
         this.#scroll = 0;
         this.#menuOpen = false;
         this.#menuSel = 0;
+        this.#queuePopMode = false; // W22: a submit ends the pop-walk — the next esc at rest interrupts again
         const cb = this.#questionCb;
         this.#questionCb = null;
         if (cb !== null) {
@@ -467,10 +703,33 @@ export class Editor {
         this.#cursor = this.#chars.length;
         this.#reflow();
     }
+    /** W22: pop the LAST queued message into the buffer (the walk's
+     *  step — ↑ enters/stays in the pop-mode, esc's pop ends it). The
+     *  chip leaves the queue (cancelled in the CLI), the line becomes
+     *  the popped text, the cursor sits at the end. */
+    #queuePopIntoBuffer() {
+        if (this.#queuePop === null)
+            return;
+        const line = this.#queuePop();
+        if (line === null)
+            return;
+        this.#chars = [...line].map((ch) => ch.codePointAt(0));
+        this.#cursor = this.#chars.length;
+        this.#scroll = 0;
+        this.#onRender();
+    }
     // ---- width-based horizontal scroll ----
     #reflow() {
         const W = (process.stdout.columns ?? 0) || 80; // degenerate 0 falls back to 80
-        const maxW = Math.max(1, W - PROMPT_WIDTH - 4); // W6: the box's walls (2+2) — the visible line fits the box's inner width; the "…" rides inside
+        // W21: the panel's phase lead owns the input row while up — the
+        // line's max width follows the lead (the rule/amend leads are
+        // wider than the brick).
+        // W23: the ONE width authority — leadWidth(lead) — the cap follows
+        // the lead the editor itself renders (the panel lead when the panel
+        // owns the keys, the brick otherwise): maxW = W − walls − lead.
+        const lead = this.#panel !== null ? panelLead(this.#panel.view, this.#panel.phase, this.#panel.sel) : PROMPT;
+        const leadW = leadWidth(lead);
+        const maxW = Math.max(1, W - leadW - 4); // W6: the box's walls (2+2) — the visible line fits the box's inner width; the "…" rides inside
         const curCol = widthOf(this.#chars.slice(0, this.#cursor));
         const scrolledW = widthOf(this.#chars.slice(0, this.#scroll));
         if (curCol < scrolledW) {

package/dist/index.d.ts

@@ -6,7 +6,8 @@
  * editor, the diff renderer, and the palette.
  */
 export { Body, Dock, CURSOR_MARKER, type BodyOptions } from "./compositor.js";
+export { panelAffordance, panelBlockRows, panelLead, panelLeadPlain, panelLeadWidth, panelStatus, type PanelArgs, type PanelFlavor, type PanelPhase, type PanelSel, type PanelState, type PanelVerdict, type PanelView, } from "./approval-panel.js";
 export { Container, foldLine, visibleWidth, SPINNER, type Component, type FrameCtx } from "./components.js";
 export { Editor, MENU_ITEMS, PROMPT, PROMPT_WIDTH, displayWidth, charWidth, widthOf, type MenuItem, } from "./editor.js";
-export { bannerLines, COLOR_OFF, COLOR_ON, escapeTerminal, foldResult, foldThinking, kUnit, palette, renderEvent, renderRecap, renderResumeList, renderSessionLine, renderStatusLine, relativeTime, renderTerminalGap, renderToolSummary, TAGLINE, truncateRow, type Palette, type PathResolver, type RecapStats, type ResumeMeta, type RenderInput, type RenderResult, type RunUsage, } from "./render.js";
+export { bannerLines, COLOR_OFF, COLOR_ON, escapeTerminal, foldResult, foldThinking, kUnit, palette, renderEvent, renderRecap, renderResumeList, renderSessionLine, renderStatusLine, relativeTime, renderTerminalGap, renderToolSummary, TAGLINE, toolTarget, truncateRow, type Palette, type PathResolver, type RecapStats, type ResumeMeta, type RenderInput, type RenderResult, type RunUsage, } from "./render.js";
 export { editFileDiff, truncateDiff, writeFileDiff, type DiffLine, type DiffResult } from "./diff.js";

package/dist/index.js

@@ -6,7 +6,11 @@
  * editor, the diff renderer, and the palette.
  */
 export { Body, Dock, CURSOR_MARKER } from "./compositor.js";
+// W21 (the v8 approval round): the approval panel — the bounded block
+// that replaces the running tool's live window while a human-chain
+// approval is pending (the shape authority is the committed preview).
+export { panelAffordance, panelBlockRows, panelLead, panelLeadPlain, panelLeadWidth, panelStatus, } from "./approval-panel.js";
 export { Container, foldLine, visibleWidth, SPINNER } from "./components.js";
 export { Editor, MENU_ITEMS, PROMPT, PROMPT_WIDTH, displayWidth, charWidth, widthOf, } from "./editor.js";
-export { bannerLines, COLOR_OFF, COLOR_ON, escapeTerminal, foldResult, foldThinking, kUnit, palette, renderEvent, renderRecap, renderResumeList, renderSessionLine, renderStatusLine, relativeTime, renderTerminalGap, renderToolSummary, TAGLINE, truncateRow, } from "./render.js";
+export { bannerLines, COLOR_OFF, COLOR_ON, escapeTerminal, foldResult, foldThinking, kUnit, palette, renderEvent, renderRecap, renderResumeList, renderSessionLine, renderStatusLine, relativeTime, renderTerminalGap, renderToolSummary, TAGLINE, toolTarget, truncateRow, } from "./render.js";
 export { editFileDiff, truncateDiff, writeFileDiff } from "./diff.js";