@vincemakes/kiso-tui-cells 0.38.0 → 0.39.1

package/dist/components.d.ts

@@ -306,8 +306,30 @@ export declare function diffBody(diff: import("./diff.js").DiffLine[] | null, W:
 export declare const CAP_TASK_LIVE = 6;
 /** W20 — the settled block's duration, the `2h 14m` form (the task
  *  narrative's long-horizon idiom): minutes+seconds under an hour,
- *  hours+minutes past it. */
+ *  hours+minutes past it. Unchanged. */
 export declare function formatDuration(totalSeconds: number): string;
+/** The LIVE elapsed label — every place a duration is shown while it is
+ *  still running, and on the card that settles from it, so a card and the
+ *  status row can never disagree.
+ *
+ *  It replaced the hand-written second counts, which is how the status
+ *  row came to read "working 637s": ten minutes as a four-figure number,
+ *  with no branch anywhere that said otherwise. Past an hour it keeps
+ *  seconds, because a clock the user is watching tick should not stop
+ *  ticking. */
+export declare function elapsedLabel(totalSeconds: number): string;
+/** The SETTLED call's duration — R13's grammar (`exit 0 · 90 lines ·
+ *  0.4s`). A finished call knows its length to a tenth, which is
+ *  information a running clock cannot have and a finished one should not
+ *  throw away: under a minute the tenth stays.
+ *
+ *  Past a minute the tenth stops being the interesting digit and the
+ *  live label takes over — a twelve-minute call settled as `734.2s`, the
+ *  same unreadable four-figure count the status row had. NOTHING under a
+ *  minute moves, which is every duration the suite pinned before this.
+ *  The suffix is part of the label (the live form's already is), so no
+ *  caller appends its own `s`. */
+export declare function settledLabel(totalSeconds: number): string;
 /** The status container's row: the status text (+ the tail) with the
  *  right-aligned "/ commands · ↑ history" hint in the idle state —
  *  the hint CUT FIRST when the width is short (the #16g rule); when

package/dist/components.js

@@ -644,7 +644,7 @@ class ToolExecution {
                 out.push(...toolBlockBody(c, W, ctx));
                 return out;
             }
-            const elapsed = c.startedAt !== null && c.doneAt !== null ? ((c.doneAt - c.startedAt) / 1000).toFixed(1) : "?";
+            const elapsed = c.startedAt !== null && c.doneAt !== null ? settledLabel((c.doneAt - c.startedAt) / 1000) : "?s";
             // TUI2-R1.5 ⑤ (VD-6): the line count is stated EXACTLY ONCE. Every
             // read card carried it twice — `(2 lines, 0.0s) · 2 lines · ctrl+o
             // expands` — because the parens and the suffix were written by
@@ -726,7 +726,7 @@ class ToolExecution {
                 // which let a narrow row cut the affordance off entirely.
                 // The tier ladder is what gives way; the key never is.
                 const keySuffix = c.expanded ? ` · ${COLLAPSE_ROW}` : "";
-                const words = pickTier([join(meta, counted, `${elapsed}s`, attr), join(meta, counted, `${elapsed}s`), join(meta, `${elapsed}s`), meta], W - visibleWidth(noteIndent()) - keySuffix.length);
+                const words = pickTier([join(meta, counted, elapsed, attr), join(meta, counted, elapsed), join(meta, elapsed), meta], W - visibleWidth(noteIndent()) - keySuffix.length);
                 // DC-50 / R14 — ONE CARD, ONE SKELETON, expanded or not.
                 //
                 // The expanded card used to take a DIFFERENT shape: its head
@@ -780,7 +780,7 @@ class ToolExecution {
             // ("compil 1s"). The head is cut against the room the duration
             // leaves; the duration then rides the row, always legible.
             const elapsed = c.startedAt !== null ? Math.max(1, Math.round((ctx.now - c.startedAt) / 1000)) : 1;
-            const dur = ` · ${elapsed}s`;
+            const dur = ` · ${elapsedLabel(elapsed)}`;
             // R3 (design §5.2): a running command BREATHES — one glyph, seven
             // greys, bottoming out on the ground's dim token (§2.2 applies
             // mid-animation, not just at rest). The quadrant spinner it
@@ -823,7 +823,7 @@ class ToolExecution {
             // rewrites it in place: `3s · esc stops` → `exit 0 · 90 lines ·
             // 3.2s`.
             const gestures = c.name === "shell" ? " · esc stops · alt+⏎ redirects" : "";
-            const status = pickTier([`${elapsed}s${gestures}`, `${elapsed}s`], Math.max(1, W - visibleWidth(noteIndent())));
+            const status = pickTier([`${elapsedLabel(elapsed)}${gestures}`, elapsedLabel(elapsed)], Math.max(1, W - visibleWidth(noteIndent())));
             const live = toolBlockBody(c, W, ctx);
             if (live.length > 0)
                 return slabBlock(gutterCut(gutter, `${verbCol} ${liveTarget(c)}`, W)[0], live, status, W);
@@ -846,7 +846,7 @@ class ToolExecution {
             // way so the COMMAND keeps something to say, and the elapsed —
             // pin 4's core — never does.
             const MIN_TARGET = 10; // the gutter, the verb column, a character of command
-            const oneRow = pickTier([`${elapsed}s${gestures}`, `${elapsed}s`], Math.max(1, W - MIN_TARGET - 3));
+            const oneRow = pickTier([`${elapsedLabel(elapsed)}${gestures}`, elapsedLabel(elapsed)], Math.max(1, W - MIN_TARGET - 3));
             const room = Math.max(4, W - visibleWidth(oneRow) - 3);
             const only = gutterCut(gutter, `${verbCol} ${liveTarget(c)}`, room)[0];
             return slabBlock(`${only}${p.dim} · ${oneRow}${p.reset}`, [], null, W);
@@ -854,7 +854,10 @@ class ToolExecution {
         // W2: ◦ replaces → for QUEUED — · is the separator inside every
         // metadata group; a queued marker that is also the separator
         // glyph reads as noise
-        return gutterCut(`${p.dim}◦${p.reset} `, `${verbCol} ${liveTarget(c)}`, W);
+        // The `◦` carried "not started yet" ALONE, and a marker is not a
+        // word: on a screen where running and queued rows sit together, a
+        // reader has to already know the glyph. The suffix says it.
+        return gutterCut(`${p.dim}◦${p.reset} `, `${verbCol} ${liveTarget(c)}${p.dim} · queued${p.reset}`, W);
     }
 }
 // ---- TUI2-R1 (A): the self-naming expand affordance ----
@@ -951,18 +954,18 @@ function settledHeadText(verbCol, target, meta, attr, elapsed, room, counted = "
     // first, then the count, and the core — what happened and how long it
     // took — is never cut open; below that the target itself truncates.
     const join = (...xs) => xs.filter((x) => x !== "").join(" · ");
-    const core = join(meta, counted, `${elapsed}s`);
-    const withAttr = join(meta, counted, `${elapsed}s`, attr.replace(" · ", ""));
+    const core = join(meta, counted, elapsed);
+    const withAttr = join(meta, counted, elapsed, attr.replace(" · ", ""));
     const lead = `${verbCol} `;
     const row = (tail) => `${lead}${target}${tail === "" ? "" : ` · ${tail}`}`;
     // 1. everything; 2. the attribution gives way; 2b. the COUNT gives
     //    way next (pin 4), where the suffix is not already carrying it —
     //    the target whole through all three
-    const whole = firstFit([row(withAttr), row(core), row(join(meta, `${elapsed}s`))], room);
+    const whole = firstFit([row(withAttr), row(core), row(join(meta, elapsed))], room);
     if (whole !== null)
         return whole;
     // 3. the target truncates, the core stays whole
-    const stem = join(meta, `${elapsed}s`);
+    const stem = join(meta, elapsed);
     const budget = room - visibleWidth(lead) - visibleWidth(stem) - 4; // the ellipsis + " · "
     if (budget >= 1)
         return `${lead}${widthCut(target, budget)}… · ${stem}`;
@@ -972,7 +975,7 @@ function settledHeadText(verbCol, target, meta, attr, elapsed, room, counted = "
     //    no bracket to leave open, so the reason retired with the
     //    parentheses and pin 4's own rule applies at every width: what
     //    happened and how long it took is never cut away.
-    const floor = `${elapsed}s`;
+    const floor = elapsed;
     const left = room - visibleWidth(lead) - visibleWidth(floor) - 4; // the ellipsis + " · "
     if (left >= 1)
         return `${lead}${widthCut(target, left)}… · ${floor}`;
@@ -1780,15 +1783,57 @@ class Banner {
  *  done-collapse. Every live row CUTS at W (never folds) — the block's
  *  height is its row count. */
 export const CAP_TASK_LIVE = 6;
-/** W20 — the settled block's duration, the `2h 14m` form (the task
- *  narrative's long-horizon idiom): minutes+seconds under an hour,
- *  hours+minutes past it. */
-export function formatDuration(totalSeconds) {
+/** The two duration idioms, from ONE implementation.
+ *
+ *  They agree in every branch but the hour: W20's settled task block says
+ *  `2h 14m` (a long-horizon narrative does not care about seconds), and a
+ *  LIVE elapsed label says `1h 2m 3s` (a running clock does). A near-copy
+ *  differing in one branch is the drift that a shared helper exists to
+ *  prevent, so the branch is a parameter.
+ *
+ *  Negative is clamped: a clock skew is not a negative duration. */
+function duration(totalSeconds, hoursKeepSeconds) {
     const s = Math.max(0, Math.round(totalSeconds));
     if (s < 60)
         return `${s}s`;
     const m = Math.floor(s / 60);
-    return m < 60 ? `${m}m ${s % 60}s` : `${Math.floor(m / 60)}h ${m % 60}m`;
+    if (m < 60)
+        return `${m}m ${s % 60}s`;
+    const h = Math.floor(m / 60);
+    return hoursKeepSeconds ? `${h}h ${m % 60}m ${s % 60}s` : `${h}h ${m % 60}m`;
+}
+/** W20 — the settled block's duration, the `2h 14m` form (the task
+ *  narrative's long-horizon idiom): minutes+seconds under an hour,
+ *  hours+minutes past it. Unchanged. */
+export function formatDuration(totalSeconds) {
+    return duration(totalSeconds, false);
+}
+/** The LIVE elapsed label — every place a duration is shown while it is
+ *  still running, and on the card that settles from it, so a card and the
+ *  status row can never disagree.
+ *
+ *  It replaced the hand-written second counts, which is how the status
+ *  row came to read "working 637s": ten minutes as a four-figure number,
+ *  with no branch anywhere that said otherwise. Past an hour it keeps
+ *  seconds, because a clock the user is watching tick should not stop
+ *  ticking. */
+export function elapsedLabel(totalSeconds) {
+    return duration(totalSeconds, true);
+}
+/** The SETTLED call's duration — R13's grammar (`exit 0 · 90 lines ·
+ *  0.4s`). A finished call knows its length to a tenth, which is
+ *  information a running clock cannot have and a finished one should not
+ *  throw away: under a minute the tenth stays.
+ *
+ *  Past a minute the tenth stops being the interesting digit and the
+ *  live label takes over — a twelve-minute call settled as `734.2s`, the
+ *  same unreadable four-figure count the status row had. NOTHING under a
+ *  minute moves, which is every duration the suite pinned before this.
+ *  The suffix is part of the label (the live form's already is), so no
+ *  caller appends its own `s`. */
+export function settledLabel(totalSeconds) {
+    const tenths = Math.max(0, Math.round(totalSeconds * 10) / 10);
+    return tenths < 60 ? `${tenths.toFixed(1)}s` : elapsedLabel(tenths);
 }
 /**
  * W20 — the task checklist as STATE: ONE live block that redraws in

package/dist/index.d.ts

@@ -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, foldTerms, 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, foldTerms, CAP_TASK_LIVE, elapsedLabel, settledLabel, 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";

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, foldTerms, CAP_TASK_LIVE, formatDuration, statusLine, boxTop, boxBottom, terminalPipe, } from "./components.js";
+export { SPINNER, foldLine, foldWords, visibleWidth, bodySpacing, Container, cellComponent, foldTerms, CAP_TASK_LIVE, elapsedLabel, settledLabel, 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

package/dist/md.js

@@ -713,35 +713,36 @@ function tableRows(b, W) {
     if (cols === null)
         return recordRows(t, W);
     const p = palette();
-    // R2: no rails. The drawn width is two columns of inset plus the
-    // columns and their two-space gutters — a table is bounded by the
-    // blank lines above and below it, exactly as every other block on the
-    // screen is, and it was the last box left on a screen that has decided
-    // not to have boxes. Alignment does the work the rails were doing, and
-    // a copied table is closer to markdown without them.
+    // DECLARED REVERSAL (2026-09-17), TABLES ONLY. R2 removed the rails at
+    // the nineteen-screen review and MD-1.3 put ONE rule under the header;
+    // both are superseded here. Every other R2 hairline rule stands, and
+    // the record form keeps NO borders — it is the fallback, not a table.
+    //
+    // The rails are hairlines in the R2 hairline colour, and the styling
+    // goes on AFTER the measure, exactly as it does for a cell: a colour
+    // can never move a column.
+    const rule = (l, m, r) => `${p.dim}${l}${cols.map((w) => "\u2500".repeat(w + 2)).join(m)}${r}${p.reset}`;
+    const V = `${p.dim}\u2502${p.reset}`;
     const row = (cells, bold) => {
         const boxes = cells.map((c, i) => cellBox(c, cols[i], t.align[i], bold));
         const rows = [];
         for (let k = 0; k < Math.max(...boxes.map((x) => x.length)); k += 1) {
             // a short box pays its blanks so the columns to its right do not
             // move: a cell is a BOX, and the row is as tall as its tallest.
-            rows.push(`  ${boxes.map((x, i) => x[k] ?? " ".repeat(cols[i])).join("  ")}`.replace(/\s+$/, ""));
+            // Trailing space is NOT stripped any more — it sits inside the
+            // closing rail, and stripping it would pull the rail left.
+            rows.push(`${V}${boxes.map((x, i) => ` ${x[k] ?? " ".repeat(cols[i])} `).join(V)}${V}`);
         }
         return rows;
     };
-    // MD-1.3 / R2 AMENDMENT 1 (owner ruling, 2026-09-11) — ONE rule under
-    // the header row, at the grid's own width. R2 removed the RAILS: the
-    // four-sided box that BOUNDS a table. This bounds nothing; it SEPARATES
-    // the header from the body, which is the one job the round's governing
-    // distinction gives a rule — a rule separates, a gutter scopes, a rail
-    // bounds. Rails stay out.
-    //
-    // What it buys is not decoration: without it a six-row table's header
-    // was carried by SGR bold ALONE, so in a pipe, under NO_COLOR, or on a
-    // terminal with weak bold, seven identical rows arrived with nothing
-    // saying which one names the columns.
-    const ruleW = cols.reduce((n, w) => n + w, 0) + Math.max(0, cols.length - 1) * 2;
-    return [...row(t.header, true), `  ${p.dim}${"\u2500".repeat(ruleW)}${p.reset}`, ...t.rows.flatMap((r) => row(r, false))];
+    const body = t.rows.flatMap((r, i) => (i === 0 ? row(r, false) : [rule("\u251c", "\u253c", "\u2524"), ...row(r, false)]));
+    return [
+        rule("\u250c", "\u252c", "\u2510"),
+        ...row(t.header, true),
+        rule("\u251c", "\u253c", "\u2524"),
+        ...body,
+        rule("\u2514", "\u2534", "\u2518"),
+    ];
 }
 /** A cell's column count: what a human sees, styling removed. */
 function cellWidth(cell) {
@@ -753,13 +754,22 @@ function cellWidth(cell) {
  *  report's sample stopped reading as a table — and it is the one number
  *  that decides when the record form is still the better answer. */
 const CELL_FLOOR = 8;
-/** The drawn width of a grid with these columns, by the measure the R2
- *  table has always used: the two-column inset plus every column AND its
- *  two-space gutter. Conservative by one gutter (the last column has
- *  none), which is where the table's right margin comes from — kept as
- *  it was, because the record threshold has always been stated in it. */
+/** The drawn width of a grid with these columns.
+ *
+ *  DECLARED REVERSAL (2026-09-17, tables only): the R2 measure was the
+ *  two-column inset plus every column and its two-space gutter — the
+ *  shape of a table with NO RAILS. With rails it is `sum + 3n + 1`: one
+ *  rail between every pair of columns and one at each edge (n+1), and one
+ *  space of padding inside every rail (2n).
+ *
+ *  This function's old comment said the record threshold "has always been
+ *  stated in it", and that is exactly why changing it IS the re-cut: the
+ *  grid costs n−1 columns more than the railless form — 2 for a
+ *  three-column table, 6 for a seven-column one — and the record fallback
+ *  arrives that much earlier. Nothing else moves: the greedy shrink, the
+ *  CELL_FLOOR of 8 and the fallback criterion are untouched. */
 function gridWidth(cols) {
-    return cols.reduce((n, w) => n + w + 2, 2);
+    return cols.reduce((n, w) => n + w, 0) + 3 * cols.length + 1;
 }
 /**
  * MD-1.1 — take one column off the WIDEST column until the grid fits.

package/dist/render.js

@@ -220,8 +220,14 @@ function toolSummaryDetail(name, input, result) {
             const exit = exitCodeOf(result);
             return `${command} (exit ${exit})`;
         }
-        case "list_dir":
-            return String(input.path ?? "(root)");
+        case "list_dir": {
+            // "(root)" already answered an ABSENT path. A model that sends
+            // "." explicitly is making the same request and was getting the
+            // dot on the row. `./` likewise. Anything else — including `..`
+            // and a dotfile directory like `.github` — is a real path.
+            const dir = String(input.path ?? ".");
+            return dir === "." || dir === "./" ? "(root)" : dir;
+        }
         case "search_text":
             return searchSubject(input);
         default:
@@ -261,8 +267,14 @@ function toolTargetRaw(name, input) {
             return String(input.path ?? "?");
         case "shell":
             return String(input.command ?? "?");
-        case "list_dir":
-            return String(input.path ?? "(root)");
+        case "list_dir": {
+            // "(root)" already answered an ABSENT path. A model that sends
+            // "." explicitly is making the same request and was getting the
+            // dot on the row. `./` likewise. Anything else — including `..`
+            // and a dotfile directory like `.github` — is a real path.
+            const dir = String(input.path ?? ".");
+            return dir === "." || dir === "./" ? "(root)" : dir;
+        }
         case "search_text":
             return searchSubject(input);
         default:

package/dist/strings.d.ts

@@ -188,15 +188,7 @@ export declare function keysSheetRows(W: number): string[];
  *  sheet renders, joined — so the two can disagree only by deleting a
  *  test. The sheet is the readable form; this is the greppable one. */
 export declare function keysHelpRow(): string;
-/**
- * KC3.5 slice ⓪ (the extraction) — the /help command table.
- *
- * The rows were eight bodyLog calls in the CLI's dispatcher; they are
- * presentation, and presentation belongs here (the KC3 §1 pattern —
- * the FLOW, which is "print these on the chain, then re-prompt", stays
- * in dispatch.ts). The last row carries its own newline exactly as it
- * did inline: bodyLog splits on \n, so `exit` and `keys` land as two
- * rows from one call — the shape the KC1/KC2/KC3 gestures were added
- * to, unchanged.
- */
+/** The slash commands `/help` lists. The keys and the `!` gestures in the
+ *  table are not commands and are not here. */
+export declare function slashCommandNames(): readonly string[];
 export declare function helpRows(): string[];

package/dist/strings.js

@@ -430,51 +430,65 @@ export function keysHelpRow() {
  * rows from one call — the shape the KC1/KC2/KC3 gestures were added
  * to, unchanged.
  */
+/** The rows `/help` prints, as DATA — the one place that says which
+ *  commands exist. `helpRows` renders it; `slashCommandNames` asks it
+ *  whether a word is a command at all, so the dispatcher's error line
+ *  cannot drift from the list the same screen prints. */
+const HELP_TABLE = [
+    ["/help", "print this list of commands"],
+    ["/think", "show the last full thinking block"],
+    ["/last", "show the most recent tool call's input and output"],
+    // R4 (C4d): a committed row is the terminal's, and cannot be
+    // re-wrapped in place (ADR-0046) — this appends it re-folded.
+    ["/rewrap", "re-print the recent prose at the current width"],
+    ["/copy", "copy the last answer (raw markdown) — ctrl+x does the same"],
+    ["/status", "show session id, event count, and context estimate"],
+    // A command with no row is a command nobody can find. `/context` has
+    // been dispatchable since TUI2-R1 slice 6 and was never listed here,
+    // so the only way to learn it existed was to read the source.
+    ["/context", "show where the context went — the per-request rent ledger"],
+    ["/mode", "show the approval tier; /mode <name> switches (manual/default/accept-edits/plan/bypass)"],
+    ["/model", "list model profiles; /model <name|provider/model> switches"],
+    ["/compact", "summarize the older conversation to free context"],
+    ["/clear", "start a fresh conversation (the old session stays resumable)"],
+    ["/resume", "switch to another session; /resume <id> goes directly"],
+    // §2.5: the conversation is untouched — this rereads what kiso was
+    // built with, not what it has said.
+    ["/reload", "reread extensions, skills and config into this session"],
+    // §2.2: the two shell gestures and their one escape. They sit
+    // beside the slash commands because that is what a reader is
+    // looking for when they look here, even though `!` is not one.
+    // §2.3: the switch belongs beside ctrl+o's job, and a gesture the
+    // sheet does not name is a gesture nobody uses (DC-30, DC-36).
+    ["ctrl+t", "fold the thinking blocks, and fold them back"],
+    // §2.4: the composer, in your own editor. It names the variables
+    // because that is what a reader has to set for it to work.
+    ["ctrl+g", "edit the composer in $VISUAL or $EDITOR — the text comes back unsent"],
+    ["!<cmd>", "run a shell command and send it with its output as your turn"],
+    ["!!<cmd>", "run one and show it here only — the model never sees it"],
+    ["\\!", "send a line that really starts with ! (the only escape)"],
+    ["exit", "leave the session"],
+    // TUI2-R1 (D): the SENTENCE is deliberately unchanged. Deriving it
+    // from KEY_BINDINGS would be an improvement and it would also move
+    // an assertion outside the round's declared supersession classes,
+    // so the sheet stays the derived surface and this row keeps its
+    // words. `keysHelpRow()` exists for the round allowed to swap it;
+    // until then the drift guard is the test that every binding in the
+    // table is mentioned here. DC-1 changes the PADDING, not the words.
+    ["keys", "enter sends \u00b7 ctrl+J newline (shift+enter where encoded) \u00b7 esc stops the run \u00b7 alt+\u23ce stops it and sends this instead \u00b7 @ files \u00b7 1-4 answers an ask"],
+];
+/** The slash commands `/help` lists. The keys and the `!` gestures in the
+ *  table are not commands and are not here. */
+export function slashCommandNames() {
+    return HELP_TABLE.map(([name]) => name).filter((n) => n.startsWith("/"));
+}
 export function helpRows() {
     const p = palette();
     // DC-1: ONE description column. The gap used to be four spaces after
     // the name whatever the name's length, so `/help`'s description began
     // three columns left of `/compact`'s and the second column wandered
     // down the list. displayWidth is the authority, as everywhere else.
-    const table = [
-        ["/help", "print this list of commands"],
-        ["/think", "show the last full thinking block"],
-        ["/last", "show the most recent tool call's input and output"],
-        // R4 (C4d): a committed row is the terminal's, and cannot be
-        // re-wrapped in place (ADR-0046) — this appends it re-folded.
-        ["/rewrap", "re-print the recent prose at the current width"],
-        ["/copy", "copy the last answer (raw markdown) — ctrl+x does the same"],
-        ["/status", "show session id, event count, and context estimate"],
-        ["/mode", "show the approval tier; /mode <name> switches (manual/default/accept-edits/plan/bypass)"],
-        ["/model", "list model profiles; /model <name|provider/model> switches"],
-        ["/compact", "summarize the older conversation to free context"],
-        ["/clear", "start a fresh conversation (the old session stays resumable)"],
-        ["/resume", "switch to another session; /resume <id> goes directly"],
-        // §2.5: the conversation is untouched — this rereads what kiso was
-        // built with, not what it has said.
-        ["/reload", "reread extensions, skills and config into this session"],
-        // §2.2: the two shell gestures and their one escape. They sit
-        // beside the slash commands because that is what a reader is
-        // looking for when they look here, even though `!` is not one.
-        // §2.3: the switch belongs beside ctrl+o's job, and a gesture the
-        // sheet does not name is a gesture nobody uses (DC-30, DC-36).
-        ["ctrl+t", "fold the thinking blocks, and fold them back"],
-        // §2.4: the composer, in your own editor. It names the variables
-        // because that is what a reader has to set for it to work.
-        ["ctrl+g", "edit the composer in $VISUAL or $EDITOR — the text comes back unsent"],
-        ["!<cmd>", "run a shell command and send it with its output as your turn"],
-        ["!!<cmd>", "run one and show it here only — the model never sees it"],
-        ["\\!", "send a line that really starts with ! (the only escape)"],
-        ["exit", "leave the session"],
-        // TUI2-R1 (D): the SENTENCE is deliberately unchanged. Deriving it
-        // from KEY_BINDINGS would be an improvement and it would also move
-        // an assertion outside the round's declared supersession classes,
-        // so the sheet stays the derived surface and this row keeps its
-        // words. `keysHelpRow()` exists for the round allowed to swap it;
-        // until then the drift guard is the test that every binding in the
-        // table is mentioned here. DC-1 changes the PADDING, not the words.
-        ["keys", "enter sends \u00b7 ctrl+J newline (shift+enter where encoded) \u00b7 esc stops the run \u00b7 alt+\u23ce stops it and sends this instead \u00b7 @ files \u00b7 1-4 answers an ask"],
-    ];
+    const table = HELP_TABLE;
     const stop = Math.max(...table.map(([name]) => displayWidth(name))) + 4;
     const cmd = (name, desc) => `${p.bold}${name}${p.reset}${" ".repeat(stop - displayWidth(name))}${desc}`;
     const rows = table.slice(0, -2).map(([name, desc]) => cmd(name, desc));

package/package.json

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