@vincemakes/kiso-tui-cells 0.9.0 → 0.11.0

package/dist/approval-panel.d.ts

@@ -75,6 +75,38 @@ export interface AskRuntime {
     readonly custom: readonly (string | null)[];
     readonly phase: "options" | "custom";
 }
+/** One thing that can be picked: what it is, and what qualifies it. */
+export interface PickOption {
+    readonly label: string;
+    /** the dim qualifier ("profile: ds \u00b7 current") \u2014 what tells two
+     *  similar rows apart */
+    readonly note?: string;
+}
+/** The whole pick: the header sentence, the options, the free-text
+ *  escape hatch, and the honest empty state. */
+export interface PickSpec {
+    readonly header: string;
+    readonly options: readonly PickOption[];
+    /** the `t` row \u2014 typing it directly is always available, because a
+     *  list of profiles is never the list of models that exist */
+    readonly typeHint: string;
+    /** shown INSTEAD of the options when there are none. The copy is the
+     *  caller's and is reproduced verbatim. */
+    readonly emptyNote?: string;
+}
+/** The pick panel's runtime state \u2014 the editor owns it, the compositor
+ *  reads it (the AskRuntime precedent, two fields instead of five). */
+export interface PickRuntime {
+    readonly cursor: number;
+    readonly phase: "options" | "custom";
+}
+/** What was picked: a listed option by INDEX (never a label the caller
+ *  would have to re-match against its own list), or typed text. */
+export type PickResult = {
+    readonly index: number;
+} | {
+    readonly custom: string;
+};
 /** The ALWAYS-verbose args (the panel's body): the untruncated diff
  *  (edit/write), or the full text (shell = the command line, other =
  *  the pretty-printed JSON). The CLI composes them UNTRUNCATED — the
@@ -116,6 +148,9 @@ export interface PanelView {
      *  panel renders the ask block and the editor routes the ask keys;
      *  absent = the approval/simple panel, unchanged. */
     readonly ask?: AskSpec;
+    /** TUI2-R2 \u2463: the options, when this view is a PICK. Same contract
+     *  as `ask`, one payload over. */
+    readonly pick?: PickSpec;
 }
 export type PanelVerdict = {
     readonly action: "allow";
@@ -135,6 +170,13 @@ export type PanelVerdict = {
  | {
     readonly action: "answers";
     readonly result: AskResult;
+}
+/** TUI2-R2 \u2463: the pick's verdict \u2014 the chosen index or the typed
+ *  text. Only pick views ever produce it, so the approval path's
+ *  switch is untouched. */
+ | {
+    readonly action: "picked";
+    readonly result: PickResult;
 };
 /** The bound panel state the compositor reads — the editor owns the
  *  phase/selection state machine and the key routing; the compositor
@@ -145,6 +187,8 @@ export interface PanelState {
     readonly sel: PanelSel;
     /** KC3.5: the ask's walk — present exactly when `view.ask` is. */
     readonly ask?: AskRuntime;
+    /** TUI2-R2 \u2463: the pick's walk — present exactly when `view.pick` is. */
+    readonly pick?: PickRuntime;
 }
 /** The block's rows — EXACTLY the preview's frame shape, the gutter at
  *  the left edge (the preview's two-space mock indent is its own
@@ -168,3 +212,34 @@ export declare function panelStatus(view: PanelView, phase: PanelPhase, sel: Pan
  *  phase's keys. The approval flavor gains the tab-amend path; the
  *  simple flavor (the trust/uncertain gates) never does. */
 export declare function panelAffordance(view: PanelView, phase: PanelPhase, sel: PanelSel): string;
+/**
+ * The pick block's rows — the prototype's C frame.
+ *
+ * The header says what is in effect right now, because the first
+ * question anyone opening this panel has is "what am I on?". The
+ * options are numbered from 1 and the number IS the key. The `t` row is
+ * last and always present: a profile list is a convenience, never the
+ * set of models that exist, and a picker that can only offer what
+ * someone remembered to configure is a smaller product than the one it
+ * replaced.
+ *
+ * Single-row discipline: every row CUTS, never folds — the block's
+ * height is its row count (the W20 rule the #checked throw demands).
+ */
+export declare function pickBlockRows(view: PanelView, state: PickRuntime, W: number, maxRows: number): string[];
+/** The digits are the keys, so the list the panel offers is bounded by
+ *  the digits there are. Beyond it, `/model <name>` still takes any
+ *  profile — the panel says so rather than paginating. */
+export declare const PICK_MAX = 9;
+/** The input row's lead: the digit range while picking, the named
+ *  prompt while typing one out. */
+export declare function pickLeadPlain(view: PanelView, state: PickRuntime): string;
+export declare function pickLead(view: PanelView, state: PickRuntime): string;
+/** The status row's left text \u2014 the CALLER's, because only the caller
+ *  knows whether a run is paused behind this panel. */
+export declare function pickStatus(view: PanelView): string;
+export declare function pickAffordance(state: PickRuntime): string;
+/** Compose a pick view. The flavor/name/title/args fields exist for the
+ *  approval path and are given inert values here \u2014 the pick block
+ *  reads none of them. */
+export declare function modelPickView(spec: PickSpec, statusText: string): PanelView;

package/dist/approval-panel.js

@@ -26,6 +26,9 @@
  */
 import { displayWidth } from "./width.js";
 import { cutLine, diffBody, gutterFold, visibleWidth, widthCut } from "./components.js";
+// TUI2-R2pre ④: strings.js takes only a TYPE from this module, so the
+// import is erased at compile time and no runtime cycle exists.
+import { displayVerb } from "./strings.js";
 import { escapeTerminal, palette } from "./render.js";
 /** The rule line's text — the why-asked line (the R3 chain): the tool
  *  name, the first non-abstain speaker, the fix hint (the §3.5 table,
@@ -37,7 +40,11 @@ function panelRuleText(view) {
     if (view.ruleOverride !== undefined)
         return escapeTerminal(view.ruleOverride);
     const hint = view.hint;
-    const base = `${p.bold}${escapeTerminal(view.name)}${p.reset} ${p.dim}needs approval — asked by${p.reset} ${p.bold}${escapeTerminal(view.speaker)}${p.reset}`;
+    // TUI2-R2pre ④: the rule line is the panel's header — it says the ACT
+    // ("edit needs approval"). view.name keeps the RAW tool name, which is
+    // what the option-2 rule prefill and the fallbackQuestion (the
+    // dock-less/pipe path — byte-identical by ruling) still read.
+    const base = `${p.bold}${escapeTerminal(displayVerb(view.name))}${p.reset} ${p.dim}needs approval — asked by${p.reset} ${p.bold}${escapeTerminal(view.speaker)}${p.reset}`;
     return hint ? `${base}${p.dim} ·${p.reset} ${p.code}${escapeTerminal(hint)}${p.reset}` : base;
 }
 /** The numbered options row — "1 Yes  2 Yes, don't ask again for
@@ -170,3 +177,88 @@ export function panelAffordance(view, phase, sel) {
         return sel === 0 ? "tab amend · esc cancel" : "enter sends · esc backs out";
     return sel === 0 ? "esc cancel" : "enter sends";
 }
+// ── TUI2-R2 ④: the pick block, its lead, its status, its affordance ──
+/**
+ * The pick block's rows — the prototype's C frame.
+ *
+ * The header says what is in effect right now, because the first
+ * question anyone opening this panel has is "what am I on?". The
+ * options are numbered from 1 and the number IS the key. The `t` row is
+ * last and always present: a profile list is a convenience, never the
+ * set of models that exist, and a picker that can only offer what
+ * someone remembered to configure is a smaller product than the one it
+ * replaced.
+ *
+ * Single-row discipline: every row CUTS, never folds — the block's
+ * height is its row count (the W20 rule the #checked throw demands).
+ */
+export function pickBlockRows(view, state, W, maxRows) {
+    const p = palette();
+    const spec = view.pick;
+    const gutter = `${p.dim}\u2502${p.reset} `;
+    const rows = [];
+    const room = Math.max(1, W - 2);
+    rows.push(`${gutter}${cutLine(`${p.bold}${escapeTerminal(spec.header.split(" \u2014 ")[0] ?? spec.header)}${p.reset}${p.dim}${escapeTerminal(spec.header.slice((spec.header.split(" \u2014 ")[0] ?? "").length))}${p.reset}`, room)}`);
+    if (spec.options.length === 0) {
+        // the honest empty state \u2014 the caller's own copy, verbatim
+        rows.push(`${gutter}${cutLine(`${p.dim} ${escapeTerminal(spec.emptyNote ?? "no options")}${p.reset}`, room)}`);
+    }
+    else {
+        // the budget: the header, the t row, the affordance and the rule
+        const budget = Math.max(1, maxRows - 4);
+        const shown = spec.options.slice(0, Math.min(budget, PICK_MAX));
+        for (let i = 0; i < shown.length; i += 1) {
+            const o = shown[i];
+            const mark = i === state.cursor && state.phase === "options";
+            const head = `${mark ? p.bold : ""} ${i + 1} ${escapeTerminal(o.label)}${mark ? p.reset : ""}`;
+            const note = o.note === undefined ? "" : `${p.dim}   ${escapeTerminal(o.note)}${p.reset}`;
+            rows.push(`${gutter}${cutLine(`${head}${note}`, room)}`);
+        }
+        if (spec.options.length > shown.length) {
+            rows.push(`${gutter}${cutLine(`${p.dim} \u2514 +${spec.options.length - shown.length} more \u2014 /model <name> takes any of them${p.reset}`, room)}`);
+        }
+    }
+    rows.push(`${gutter}${cutLine(`${state.phase === "custom" ? p.bold : ""} t ${p.reset}${p.dim}${escapeTerminal(spec.typeHint)}${p.reset}`, room)}`);
+    rows.push(`${gutter}${p.dim}${cutLine(pickAffordance(state), room)}${p.reset}`);
+    rows.push(`${p.dim}\u2514${"\u2500".repeat(Math.max(0, W - 1))}${p.reset}`);
+    return rows;
+}
+/** The digits are the keys, so the list the panel offers is bounded by
+ *  the digits there are. Beyond it, `/model <name>` still takes any
+ *  profile — the panel says so rather than paginating. */
+export const PICK_MAX = 9;
+/** The input row's lead: the digit range while picking, the named
+ *  prompt while typing one out. */
+export function pickLeadPlain(view, state) {
+    if (state.phase === "custom")
+        return "provider/model: ";
+    const n = Math.min(view.pick.options.length, PICK_MAX);
+    return n === 0 ? "t> " : `1-${n}> `;
+}
+export function pickLead(view, state) {
+    const p = palette();
+    return `${p.bold}${pickLeadPlain(view, state)}${p.reset}`;
+}
+/** The status row's left text \u2014 the CALLER's, because only the caller
+ *  knows whether a run is paused behind this panel. */
+export function pickStatus(view) {
+    return view.statusText;
+}
+export function pickAffordance(state) {
+    return state.phase === "custom" ? "enter commits \u00b7 esc backs out" : "digits pick \u00b7 \u23ce confirms \u00b7 esc";
+}
+/** Compose a pick view. The flavor/name/title/args fields exist for the
+ *  approval path and are given inert values here \u2014 the pick block
+ *  reads none of them. */
+export function modelPickView(spec, statusText) {
+    return {
+        flavor: "simple",
+        name: "model",
+        title: "model",
+        speaker: "you",
+        statusText,
+        args: { kind: "text", lines: [] },
+        fallbackQuestion: "switch model? (name) ",
+        pick: spec,
+    };
+}

package/dist/components.d.ts

@@ -18,6 +18,8 @@
  * tint, fold wording).
  */
 import { foldThinking, foldResult, renderToolSummary, type ResumeMeta } from "./render.js";
+import { type MdBlock } from "./md.js";
+export { MdStream, renderBlock, renderMarkdown, type MdBlock, type MdKind } from "./md.js";
 /** The spinner glyphs, cycled by the compositor's on-demand tick. */
 export declare const SPINNER: string[];
 /** The frame context the compositor passes down — the pieces of time
@@ -43,8 +45,12 @@ export type RenderLine = string;
  */
 export declare function foldLine(line: string, W: number): string[];
 /** The visible width of a rendered line (SGR stripped — the invariant
- *  the compositor enforces on every emitted line). */
-export declare function visibleWidth(line: string): number;
+ *  the compositor enforces on every emitted line). TUI2-MD ⑤: the body
+ *  moved to width.ts (the width authority's own home) so the markdown
+ *  renderer can measure without importing this module back — the
+ *  re-export is verbatim, so every existing importer and the barrel see
+ *  exactly what they saw. */
+export { visibleWidth } from "./width.js";
 /** A component: render the display lines for one piece of state. */
 export interface Component {
     render(width: number, ctx: FrameCtx): string[];
@@ -145,6 +151,18 @@ export type BodyCell = {
     kind: "text";
     text: string;
     done: boolean;
+}
+/** TUI2-MD ⑤ — ONE markdown block of assistant body text. The cell is
+ *  the commit unit the compositor already had, so block-freeze needs
+ *  no new commit machinery: a CLOSED block is a DONE cell and the
+ *  natural loop freezes it; the OPEN tail block is the one cell left
+ *  live. `block` carries the block's SOURCE (never rendered rows), so
+ *  a resize re-renders it at the new width exactly as every other
+ *  cell does. */
+ | {
+    kind: "md";
+    block: MdBlock;
+    done: boolean;
 } | {
     kind: "notice";
     text: string;
@@ -215,12 +233,37 @@ export declare function gutterFold(gutter: string, line: string, W: number): str
  *  ellipsis ride the row (the invariant ① cap holds). */
 export declare function gutterCut(gutter: string, line: string, W: number): string[];
 export declare function expandSuffix(lines: number | null, room: number): string;
+/**
+ * TUI2-R2 ⑤ (D, candidate 1) — the FOCUS tint.
+ *
+ * The cell the next ctrl+r will act on brightens its own `ctrl+r` token
+ * to the code tint; the rest of the suffix — the separator, the count —
+ * stays dim, because what is being marked is the KEY's target, not the
+ * row. Zero new rows, zero new columns: the affordance the cell already
+ * prints is the marker.
+ *
+ * Applied to a row rather than composed into it on purpose. The token is
+ * emitted from several places (the settled suffix, the renderer's own
+ * `└ +N … · ctrl+r` cut rows) and threading a flag through all of them
+ * would put the invariant "exactly one bright token" in as many hands as
+ * there are emitters. Here it has exactly one.
+ *
+ * NO_COLOR: p.code is empty, so the row's bytes are untouched.
+ */
+export declare function focusToken(row: string, W: number): string;
 /** W13 — the rollup opt-in table: which tools collapse, and the count
  *  NOUN (read_file calls → "5 files", list_dir → "5 dirs", search_text
  *  → "5 matches"). Only these tools opt in — a shell burst is never
  *  rolled up (its rows carry meaning). The folded-turn line (W14) reuses
  *  the plurals for its other-tool terms ("2 dirs", "1 match"). */
 export declare const ROLLUP_NOUN: Readonly<Record<string, string>>;
+/** TUI2-R1 (B) — the verb column of the expanded list names the ACT.
+ *  TUI2-R2pre ④: this used to be a private three-tool table saying the
+ *  same thing as the card head's `_file` strip, in a different way and
+ *  for a different set of tools. Both are `displayVerb` now — the whole
+ *  point of the ruling is that there is ONE answer to "what does the
+ *  screen call this". The cut note, which used to be the deliberate
+ *  exception here, moved with it (see toolCutNote). */
 /** Whether a tool joins an exploration run. Exactly the read-only set —
  *  writes, edits, shells and extension tools never group (a burst of
  *  side effects is a list of things that HAPPENED, and every row of it

package/dist/components.js

@@ -17,8 +17,18 @@
  * (untouched); render.ts supplies the original text (palette, escape,
  * tint, fold wording).
  */
-import { displayWidth } from "./width.js";
+import { displayWidth, visibleWidth } from "./width.js";
+// TUI2-R2pre ④: the ONE display-verb table (strings.ts, beside
+// KEY_BINDINGS). strings.js imports only render/width here, so this edge
+// adds no cycle.
+import { displayVerb } from "./strings.js";
 import { bannerLines, escapeTerminal, foldThinking, foldResult, colorInlineCode, renderTerminalGap, renderToolSummary, toolTarget, kUnit, palette, } from "./render.js";
+// TUI2-MD: the markdown renderer's surface reaches the tui through this
+// module (the tui's components shim re-exports it) — one import edge,
+// and it points one way: md.ts measures with the width authority, never
+// back through here.
+import { renderBlock } from "./md.js";
+export { MdStream, renderBlock, renderMarkdown } from "./md.js";
 /** The spinner glyphs, cycled by the compositor's on-demand tick. */
 export const SPINNER = ["▖", "▘", "▝", "▗"];
 /**
@@ -90,24 +100,12 @@ export function foldLine(line, W) {
     return out;
 }
 /** The visible width of a rendered line (SGR stripped — the invariant
- *  the compositor enforces on every emitted line). */
-export function visibleWidth(line) {
-    let w = 0;
-    for (let i = 0; i < line.length;) {
-        if (line[i] === "\x1b") {
-            const m = /^\x1b\[[0-9;?]*[A-Za-z]/.exec(line.slice(i));
-            if (m !== null) {
-                i += m[0].length;
-                continue;
-            }
-            i += 1;
-            continue;
-        }
-        w += displayWidth(line[i]);
-        i += 1;
-    }
-    return w;
-}
+ *  the compositor enforces on every emitted line). TUI2-MD ⑤: the body
+ *  moved to width.ts (the width authority's own home) so the markdown
+ *  renderer can measure without importing this module back — the
+ *  re-export is verbatim, so every existing importer and the barrel see
+ *  exactly what they saw. */
+export { visibleWidth } from "./width.js";
 /** The W11 spacing formula — "a row gets one blank line above it when
  *  the row is itself a block, or when the previous sibling was taller
  *  than one row". One-row siblings pack tight; anything multi-row
@@ -156,6 +154,8 @@ export function cellComponent(cell) {
             return new ToolExecution(cell);
         case "text":
             return new AssistantMessage(cell);
+        case "md":
+            return new MarkdownBlock(cell);
         case "notice":
             return new ErrorLine(cell);
         case "banner":
@@ -454,7 +454,7 @@ class ToolExecution {
     render(W, ctx) {
         const p = palette();
         const c = this.cell;
-        const verb = escapeTerminal(c.name.replace("_file", ""));
+        const verb = escapeTerminal(displayVerb(c.name));
         const verbCol = verb.length < 5 ? `${verb}${" ".repeat(5 - verb.length)}` : verb;
         const parts = c.rolled?.parts;
         if (c.rolled !== null && parts !== undefined) {
@@ -711,6 +711,46 @@ function appendSuffix(row, suffix) {
     const p = palette();
     return `${row}${p.dim}${suffix}${p.reset}`;
 }
+/**
+ * TUI2-R2 ⑤ (D, candidate 1) — the FOCUS tint.
+ *
+ * The cell the next ctrl+r will act on brightens its own `ctrl+r` token
+ * to the code tint; the rest of the suffix — the separator, the count —
+ * stays dim, because what is being marked is the KEY's target, not the
+ * row. Zero new rows, zero new columns: the affordance the cell already
+ * prints is the marker.
+ *
+ * Applied to a row rather than composed into it on purpose. The token is
+ * emitted from several places (the settled suffix, the renderer's own
+ * `└ +N … · ctrl+r` cut rows) and threading a flag through all of them
+ * would put the invariant "exactly one bright token" in as many hands as
+ * there are emitters. Here it has exactly one.
+ *
+ * NO_COLOR: p.code is empty, so the row's bytes are untouched.
+ */
+export function focusToken(row, W) {
+    const p = palette();
+    const at = row.lastIndexOf(CTRL_R);
+    if (at !== -1) {
+        // the row already names the key — brighten the token in place, and
+        // leave every other span exactly as it was
+        if (p.code === "")
+            return row;
+        return `${row.slice(0, at)}${p.code}${CTRL_R}${p.reset}${p.dim}${row.slice(at + CTRL_R.length)}`;
+    }
+    // A LIVE row does not carry the affordance today, and the live cell is
+    // the one ctrl+r takes FIRST (expandNext scans the live tail before
+    // the committed ring) — so the row the key is aimed at was the one row
+    // that never said the key existed. The affordance IS the marker here:
+    // it appears on the focused row and nowhere else, which is why no
+    // unfocused row's bytes move (every existing live-row assertion
+    // renders a cell with no focus and is untouched).
+    const room = W - visibleWidth(row);
+    if (room < SUFFIX_MIN)
+        return row; // never at the cost of invariant ①
+    return `${row}${p.dim} · ${p.reset}${p.code}${CTRL_R}${p.reset}`;
+}
+const CTRL_R = "ctrl+r";
 /** TUI2-R1 (A) — the expanded block's last row: the way back. The
  *  rollup's expanded list carries a second clause (its members' full
  *  outputs live in /last, which the group row cannot show). */
@@ -736,10 +776,13 @@ const EXPLORE_NOUN = {
     list_dir: ["dir", "dirs"],
     search_text: ["search", "searches"],
 };
-/** TUI2-R1 (B) — the verb column of the expanded list. `search_text`
- *  reads as "search" there: the column names the ACT, and the raw tool
- *  name is what the cut notes carry (they name what the model calls). */
-const EXPLORE_VERB = { read_file: "read", list_dir: "list", search_text: "search" };
+/** TUI2-R1 (B) — the verb column of the expanded list names the ACT.
+ *  TUI2-R2pre ④: this used to be a private three-tool table saying the
+ *  same thing as the card head's `_file` strip, in a different way and
+ *  for a different set of tools. Both are `displayVerb` now — the whole
+ *  point of the ruling is that there is ONE answer to "what does the
+ *  screen call this". The cut note, which used to be the deliberate
+ *  exception here, moved with it (see toolCutNote). */
 /** Whether a tool joins an exploration run. Exactly the read-only set —
  *  writes, edits, shells and extension tools never group (a burst of
  *  side effects is a list of things that HAPPENED, and every row of it
@@ -770,7 +813,7 @@ export function exploreRows(parts, W) {
             counts.set(s, (counts.get(s) ?? 0) + 1);
         const shown = [...counts.entries()].slice(0, 3).map(([s, n]) => (n > 1 ? `${s} ×${n}` : s));
         const more = counts.size > 3 ? ` (+${counts.size - 3})` : "";
-        const verb = EXPLORE_VERB[part.name] ?? part.name;
+        const verb = displayVerb(part.name);
         rows.push(cutLine(`${p.dim}${BODY_ROW}${escapeTerminal(`${verb.padEnd(6)} ${shown.join(" · ")}${more}`)}${p.reset}`, W));
     }
     // TUI2-R1.5 ① (VD-15): the footer used to promise "/last shows the full
@@ -812,7 +855,7 @@ export function turnFold(t, W) {
             parts.push(countTerm(n, noun.endsWith("es") ? noun.slice(0, -2) : noun.slice(0, -1), noun));
         }
         else {
-            const verb = name.replace("_file", "");
+            const verb = displayVerb(name);
             parts.push(countTerm(n, verb, `${verb}s`));
         }
     }
@@ -1110,14 +1153,22 @@ export function diffBody(diff, W, expanded = false) {
  *  offset=N", the output cap, list_dir's entry cap). The note reaches
  *  the MODEL and never the human — this row surfaces it. Detected in
  *  the result's TAIL (the note is appended at the end); returns null
- *  when the tool did not truncate. */
+ *  when the tool did not truncate.
+ *
+ *  TUI2-R2pre ④: the verb here is the DISPLAY one now. This row used to
+ *  be the sanctioned raw-name exception, on the reasoning that it names
+ *  the tool the model should call again — but the row is addressed to
+ *  the HUMAN (the model already has the note in its own transcript, which
+ *  is where it read it), and the ruling names this advisory family
+ *  explicitly. The `offset=N` it carries is the actionable half and is
+ *  untouched. */
 function toolCutNote(name, resultText) {
     const tail = resultText.slice(-300);
     const m = /offset=(\d+)/.exec(tail);
     if (m !== null)
-        return `capped by ${escapeTerminal(name)} · offset=${m[1]} for the rest`;
+        return `capped by ${escapeTerminal(displayVerb(name))} · offset=${m[1]} for the rest`;
     if (/…\[truncated\]/.test(tail) || /… \+?\d+ more (?:lines|entries)/.test(tail))
-        return `capped by ${escapeTerminal(name)} · /last for the rest`;
+        return `capped by ${escapeTerminal(displayVerb(name))} · /last for the rest`;
     return null;
 }
 /** The assistant body text — wrapped at W, the inline-code tint per
@@ -1135,6 +1186,20 @@ class AssistantMessage {
         return wrapped.length > 0 ? wrapped.map((l) => colorInlineCode(l)) : [""];
     }
 }
+/** TUI2-MD ⑤ — one markdown block. Pure in (block, W): the same source
+ *  and the same width give the same bytes, which is the freeze property
+ *  the commit path relies on. The block carries its own leading blank
+ *  (the style table's rhythm), so the compositor's W11 join formula
+ *  steps aside between two of these. */
+class MarkdownBlock {
+    cell;
+    constructor(cell) {
+        this.cell = cell;
+    }
+    render(W, _ctx) {
+        return renderBlock(this.cell.block, W);
+    }
+}
 /** The ⚠ / notice lines — the error surface. */
 class ErrorLine {
     cell;

package/dist/index.d.ts

@@ -6,11 +6,12 @@
  * package); the cli never imports it directly. Experimental — no
  * API-stability promise yet.
  */
-export { SPINNER, foldLine, foldWords, visibleWidth, bodySpacing, Container, cellComponent, ROLLUP_NOUN, turnFold, CAP_TASK_LIVE, formatDuration, statusLine, boxTop, boxBottom, terminalPipe, type FrameCtx, type RenderLine, type Component, type BodyCell, } from "./components.js";
+export { SPINNER, foldLine, foldWords, visibleWidth, bodySpacing, Container, cellComponent, focusToken, ROLLUP_NOUN, turnFold, CAP_TASK_LIVE, formatDuration, statusLine, boxTop, boxBottom, terminalPipe, type FrameCtx, type RenderLine, type Component, type BodyCell, } from "./components.js";
 export { editFileDiff, truncateDiff, writeFileDiff, type DiffLine, type DiffResult } from "./diff.js";
 export { pendingQueueRows } from "./components.js";
 export { charWidth, displayWidth, leadWidth, widthOf } from "./width.js";
 export { panelAffordance, panelBlockRows, panelLead, panelLeadPlain, panelLeadWidth, panelStatus, type PanelArgs, type PanelFlavor, type PanelPhase, type PanelSel, type PanelState, type PanelVerdict, type PanelView, type AskAnswer, type AskOption, type AskQuestion, type AskResult, type AskRuntime, type AskSpec, } from "./approval-panel.js";
 export { interactivePrompt, projectTrustRows, projectTrustView, projectUntrustedNote, uncertainView, type TrustArtifact, } from "./strings.js";
 export { extensionsBannerText, helpRows, unansweredAskView, type BannerExtension } from "./strings.js";
+export { displayVerb } from "./strings.js";
 export { bannerLines, COLOR_OFF, COLOR_ON, colorInlineCode, escapeTerminal, foldResult, foldThinking, kUnit, palette, relativeTime, renderResumeList, renderTerminalGap, renderToolSummary, TAGLINE, toolTarget, truncateRow, type Palette, type ResumeMeta, } from "./render.js";

package/dist/index.js

@@ -6,7 +6,7 @@
  * package); the cli never imports it directly. Experimental — no
  * API-stability promise yet.
  */
-export { SPINNER, foldLine, foldWords, visibleWidth, bodySpacing, Container, cellComponent, ROLLUP_NOUN, turnFold, CAP_TASK_LIVE, formatDuration, statusLine, boxTop, boxBottom, terminalPipe, } from "./components.js";
+export { SPINNER, foldLine, foldWords, visibleWidth, bodySpacing, Container, cellComponent, focusToken, ROLLUP_NOUN, turnFold, CAP_TASK_LIVE, formatDuration, statusLine, boxTop, boxBottom, terminalPipe, } from "./components.js";
 export { editFileDiff, truncateDiff, writeFileDiff } from "./diff.js";
 // W22 (the v8 input round): the pending-queue chips — the SAME
 // UserMessage chip with the □ gutter, pre-rendered above the input
@@ -25,4 +25,7 @@ export { panelAffordance, panelBlockRows, panelLead, panelLeadPlain, panelLeadWi
 export { interactivePrompt, projectTrustRows, projectTrustView, projectUntrustedNote, uncertainView, } from "./strings.js";
 // KC3.5: the interrupted-ask copy and the extracted /help table.
 export { extensionsBannerText, helpRows, unansweredAskView } from "./strings.js";
+// TUI2-R2pre ④: the ONE display-verb table — the screen names the act,
+// the tool table names the call.
+export { displayVerb } from "./strings.js";
 export { bannerLines, COLOR_OFF, COLOR_ON, colorInlineCode, escapeTerminal, foldResult, foldThinking, kUnit, palette, relativeTime, renderResumeList, renderTerminalGap, renderToolSummary, TAGLINE, toolTarget, truncateRow, } from "./render.js";