@vincemakes/kiso-tui-cells 0.9.0 → 0.10.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

@@ -215,12 +215,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

@@ -18,6 +18,10 @@
  * tint, fold wording).
  */
 import { displayWidth } 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";
 /** The spinner glyphs, cycled by the compositor's on-demand tick. */
 export const SPINNER = ["▖", "▘", "▝", "▗"];
@@ -454,7 +458,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 +715,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 +780,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 +817,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 +859,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 +1157,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

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";

package/dist/render.d.ts

@@ -34,6 +34,14 @@ export interface Palette {
     readonly dim: string;
     readonly red: string;
     readonly green: string;
+    /** TUI2-R2 ①: the third functional exception, finally spelled. The
+     *  mono-discipline ruling above names "green ✓, yellow warn and red
+     *  error" as the ONLY functional colours; warn had no entry because
+     *  nothing had needed it yet. The uncertain badge needs exactly it —
+     *  a state that is neither success nor failure but a question
+     *  addressed to the human. This is the ruling's own set gaining its
+     *  missing member, not a fourth colour. */
+    readonly warn: string;
     readonly code: string;
     readonly rv: string;
     readonly rvEnd: string;

package/dist/render.js

@@ -6,8 +6,8 @@
  * dependencies (the tui-cells package has none).
  */
 import { charWidth, displayWidth } from "./width.js";
-export const COLOR_ON = { bold: "\x1b[1m", dim: "\x1b[2m", red: "\x1b[31m", green: "\x1b[32m", code: "\x1b[38;5;252m", rv: "\x1b[7m", rvEnd: "\x1b[27m", reset: "\x1b[0m" };
-export const COLOR_OFF = { bold: "", dim: "", red: "", green: "", code: "", rv: "", rvEnd: "", reset: "" };
+export const COLOR_ON = { bold: "\x1b[1m", dim: "\x1b[2m", red: "\x1b[31m", green: "\x1b[32m", warn: "\x1b[33m", code: "\x1b[38;5;252m", rv: "\x1b[7m", rvEnd: "\x1b[27m", reset: "\x1b[0m" };
+export const COLOR_OFF = { bold: "", dim: "", red: "", green: "", warn: "", code: "", rv: "", rvEnd: "", reset: "" };
 export function palette() {
     return process.env.NO_COLOR === undefined && process.stdout.isTTY ? COLOR_ON : COLOR_OFF;
 }

package/dist/strings.d.ts

@@ -111,6 +111,10 @@ export interface KeyBinding {
  * then the completions.
  */
 export declare const KEY_BINDINGS: readonly KeyBinding[];
+/** A tool's name as the SCREEN says it. Display-only: the raw name stays
+ *  on the cell, and dispatch, the mode gate, the policy keys, the /last
+ *  RAW block and every model-facing byte keep reading that. */
+export declare function displayVerb(name: string): string;
 /** The panel keys, which belong to a panel rather than the composer —
  *  one dim line rather than four table rows, because they apply only
  *  while a panel is up. */

package/dist/strings.js

@@ -155,6 +155,40 @@ export const KEY_BINDINGS = [
     { keys: "tab", what: "complete (menu / @)" },
     { keys: "?", what: "this sheet" },
 ];
+/**
+ * TUI2-R2pre ④ — THE display-verb table (the integrator's ruling).
+ *
+ * The screen names the ACT; the tool table names the CALL. Two
+ * audiences, two vocabularies, and only the human's one lives here: the
+ * API names DO NOT change, because the model-request surface is frozen
+ * rent and every byte of it is paid for on every turn. The
+ * rename-the-tools path is REJECTED by ruling.
+ *
+ * One table, for the same reason KEY_BINDINGS above is one table. The
+ * mapping used to exist three and a half times — a `.replace("_file",
+ * "")` in components.ts, another in render.ts, two more in the
+ * compositor, and a private three-tool table for the rollup's expanded
+ * list — and the drift was visible on a single screen: a card head
+ * reading `read` directly above one reading `list_dir`.
+ *
+ * An unmapped tool (an extension's, an MCP server's) renders its own
+ * name. Inventing a verb for a tool this package has never heard of
+ * would be a worse lie than printing what the model actually calls.
+ */
+const DISPLAY_VERB = {
+    read_file: "read",
+    list_dir: "list",
+    search_text: "search",
+    write_file: "write",
+    edit_file: "edit",
+    shell: "shell",
+};
+/** A tool's name as the SCREEN says it. Display-only: the raw name stays
+ *  on the cell, and dispatch, the mode gate, the policy keys, the /last
+ *  RAW block and every model-facing byte keep reading that. */
+export function displayVerb(name) {
+    return DISPLAY_VERB[name] ?? name;
+}
 /** The panel keys, which belong to a panel rather than the composer —
  *  one dim line rather than four table rows, because they apply only
  *  while a panel is up. */

package/dist/width.d.ts

@@ -1,11 +1,21 @@
 /**
  * The display-width primitives — the SINGLE width authority (TUI v5
- * #16e: "charWidth is the width authority"). The eastAsianWidth table
- * is a ~40-line subset (CJK ideographs/kana/hangul/fullwidth/common
- * wide symbols = 2, everything else = 1 — the box-drawing/brick glyphs
- * █▀▄▞▸ are narrow). Known limitation, documented in the README: emoji
- * ZWJ clusters are not guaranteed perfect — each code point counts as
- * its width. Zero dependencies (importable from any module).
+ * #16e: "charWidth is the width authority"). The table covers the East
+ * Asian Wide/Fullwidth ranges and Emoji_Presentation=Yes; everything
+ * else is one column, the box-drawing/brick glyphs █▀▄▞▸ and the text-
+ * presentation marks ✓ ✗ ⚠ ⏸ included.
+ *
+ * This is the compositor's FLOOR, not a cosmetic detail: a glyph scored
+ * one column that a terminal draws in two makes a line whose measured
+ * width is <= W really need W+1, the terminal soft-wraps the tail onto
+ * the row below, and the live region silently eats a row it never
+ * budgeted (TUI2-R2pre ① — the composer clobber).
+ *
+ * Known limitation, documented in the README: emoji ZWJ clusters and
+ * variation-selector sequences are not guaranteed perfect — each code
+ * point counts as its own width (U+26A0 + FE0F sums to 2, which is what
+ * a terminal draws, but that is arithmetic luck, not a model).
+ * Zero dependencies (importable from any module).
  */
 /** A code point's display width: 2 for the wide ranges, 1 otherwise. */
 export declare function charWidth(cp: number): number;

package/dist/width.js

@@ -1,12 +1,63 @@
 /**
  * The display-width primitives — the SINGLE width authority (TUI v5
- * #16e: "charWidth is the width authority"). The eastAsianWidth table
- * is a ~40-line subset (CJK ideographs/kana/hangul/fullwidth/common
- * wide symbols = 2, everything else = 1 — the box-drawing/brick glyphs
- * █▀▄▞▸ are narrow). Known limitation, documented in the README: emoji
- * ZWJ clusters are not guaranteed perfect — each code point counts as
- * its width. Zero dependencies (importable from any module).
+ * #16e: "charWidth is the width authority"). The table covers the East
+ * Asian Wide/Fullwidth ranges and Emoji_Presentation=Yes; everything
+ * else is one column, the box-drawing/brick glyphs █▀▄▞▸ and the text-
+ * presentation marks ✓ ✗ ⚠ ⏸ included.
+ *
+ * This is the compositor's FLOOR, not a cosmetic detail: a glyph scored
+ * one column that a terminal draws in two makes a line whose measured
+ * width is <= W really need W+1, the terminal soft-wraps the tail onto
+ * the row below, and the live region silently eats a row it never
+ * budgeted (TUI2-R2pre ① — the composer clobber).
+ *
+ * Known limitation, documented in the README: emoji ZWJ clusters and
+ * variation-selector sequences are not guaranteed perfect — each code
+ * point counts as its own width (U+26A0 + FE0F sums to 2, which is what
+ * a terminal draws, but that is arithmetic luck, not a model).
+ * Zero dependencies (importable from any module).
  */
+/** TUI2-R2pre ① — the Emoji_Presentation=Yes code points inside
+ *  U+2000..U+2BFF. The rest of that span is TEXT presentation and stays
+ *  one column: ✓ ✗ ⚠ ⏸ ▞ ▸ and the box-drawing rails are all narrow, and
+ *  widening any of them would move every card head on the screen. Listed
+ *  as ranges because that is what the property is — the singles are
+ *  singles in Unicode too. */
+const EMOJI_PRESENTATION = [
+    [0x231a, 0x231b],
+    [0x23e9, 0x23ec],
+    [0x23f0, 0x23f0],
+    [0x23f3, 0x23f3],
+    [0x25fd, 0x25fe],
+    [0x2614, 0x2615],
+    [0x2648, 0x2653],
+    [0x267f, 0x267f],
+    [0x2693, 0x2693],
+    [0x26a1, 0x26a1],
+    [0x26aa, 0x26ab],
+    [0x26bd, 0x26be],
+    [0x26c4, 0x26c5],
+    [0x26ce, 0x26ce],
+    [0x26d4, 0x26d4],
+    [0x26ea, 0x26ea],
+    [0x26f2, 0x26f3],
+    [0x26f5, 0x26f5],
+    [0x26fa, 0x26fa],
+    [0x26fd, 0x26fd],
+    [0x2705, 0x2705],
+    [0x270a, 0x270b],
+    [0x2728, 0x2728],
+    [0x274c, 0x274c],
+    [0x274e, 0x274e],
+    [0x2753, 0x2755],
+    [0x2757, 0x2757],
+    [0x2795, 0x2797],
+    [0x27b0, 0x27b0],
+    [0x27bf, 0x27bf],
+    [0x2b1b, 0x2b1c],
+    [0x2b50, 0x2b50],
+    [0x2b55, 0x2b55],
+];
 /** A code point's display width: 2 for the wide ranges, 1 otherwise. */
 export function charWidth(cp) {
     if (cp >= 0x1100 && cp <= 0x115f)
@@ -35,12 +86,33 @@ export function charWidth(cp) {
         return 2; // fullwidth forms
     if (cp >= 0xffe0 && cp <= 0xffe6)
         return 2; // fullwidth signs
+    // TUI2-R1.5 shipped only two of the pictographic ranges; the holes
+    // (transport, mahjong/cards, enclosed, colored shapes, the extended
+    // block) were scored ONE column while every terminal draws them in
+    // two — the composer clobber of the owner's field report (①).
+    if (cp === 0x1f004 || cp === 0x1f0cf)
+        return 2; // mahjong red dragon, joker
+    if (cp >= 0x1f18e && cp <= 0x1f19a)
+        return 2; // enclosed alphanumerics
+    if (cp >= 0x1f200 && cp <= 0x1f251)
+        return 2; // enclosed ideographic
     if (cp >= 0x1f300 && cp <= 0x1f64f)
         return 2; // emoji (misc + emoticons)
+    if (cp >= 0x1f680 && cp <= 0x1f6ff)
+        return 2; // transport + map
+    if (cp >= 0x1f7e0 && cp <= 0x1f7eb)
+        return 2; // colored circles + squares
     if (cp >= 0x1f900 && cp <= 0x1f9ff)
         return 2; // supplemental emoji
+    if (cp >= 0x1fa70 && cp <= 0x1faff)
+        return 2; // symbols + pictographs ext-A
     if (cp >= 0x20000 && cp <= 0x3fffd)
         return 2; // CJK ext B..G
+    if (cp >= 0x231a && cp <= 0x2b55) {
+        for (const [lo, hi] of EMOJI_PRESENTATION)
+            if (cp >= lo && cp <= hi)
+                return 2;
+    }
     return 1;
 }
 /** Display width of a code-point array (cursor math, scrolling). */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vincemakes/kiso-tui-cells",
-  "version": "0.9.0",
+  "version": "0.10.0",
   "description": "kiso tui-cells — the components cell renderer (components, diff, width, the render slice). Zero runtime dependencies: input is data, output is bytes.",
   "type": "module",
   "license": "MIT",