@vincemakes/kiso-tui-cells 0.39.2 → 0.40.1

package/dist/approval-panel.d.ts

@@ -458,10 +458,42 @@ export declare function panelAffordance(view: PanelView, phase: PanelPhase, curs
  * 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. */
+/** The digits are the keys, so what one SCREEN offers is still bounded by
+ *  the digits there are — but the list itself is no longer bounded by it.
+ *
+ *  Finding DC-58 (the owner, 2026-09-21): this constant used to cap what the
+ *  KEYBOARD could reach (`/model` on a 60-profile config offered nine and
+ *  said `/model <name>` for the rest). The window now follows the cursor —
+ *  `pickWindow` — so PICK_MAX is only how many rows one screen shows, and
+ *  ↑↓ walks every option.
+ */
 export declare const PICK_MAX = 9;
+/** The option window the pick panel draws and the digits name: `size` rows
+ *  starting at `first`, with `first` derived from the cursor so it cannot
+ *  drift from it. Edge-following (the window starts moving only when the
+ *  cursor leaves it) and clamped at both ends, so the last page is full
+ *  rather than short.
+ *
+ *  Pure, and the ONE copy: the renderer, the digit keys and the click
+ *  hit-test all ask this function rather than each deriving an offset.
+ */
+/** The pick panel's window for THIS frame's budget — the one derivation the
+ *  renderer and the input layer share (review of this round).
+ *
+ *  The renderer draws it; `Dock.visiblePickWindow` hands the SAME value to the
+ *  digit keys, because a size derived twice is a size that can disagree — and
+ *  on a short terminal it did (two rows drawn, nine assumed, so `1` could mean
+ *  a row nobody could see). `phase` is compared as a string so this module
+ *  keeps its zero-dependency contract.
+ */
+export declare function pickWindowOf(view: PanelView, cursor: number, phase: string, maxRows: number): {
+    first: number;
+    size: number;
+};
+export declare function pickWindow(cursor: number, count: number, size: number): {
+    first: number;
+    size: number;
+};
 /** 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;

package/dist/approval-panel.js

@@ -575,20 +575,37 @@ export function pickBlockRows(view, state, W, maxRows) {
         // which it already spends on `profile: <name>`. A second axis that
         // truncates on a normal terminal is not a second axis.
         const strip = spec.options[state.cursor]?.levels !== undefined && state.phase === "options" ? 1 : 0;
-        const chrome = 5 + strip + (spec.options.length > Math.min(Math.max(1, maxRows - 5 - strip), PICK_MAX) ? 1 : 0);
-        const budget = Math.max(1, maxRows - chrome);
-        const shown = spec.options.slice(0, Math.min(budget, PICK_MAX));
+        // 2026-09-21 (finding DC-58, the owner's report): the window FOLLOWS the
+        // cursor instead of being pinned to the top. It used to be
+        // `slice(0, min(budget, PICK_MAX))`, so with a 60-profile config the
+        // keyboard reached the first nine and the rest were reachable only by
+        // typing the name.
+        //
+        // REVIEW of this round: the SIZE depends on the frame's budget, so the
+        // renderer and the digit keys used to disagree on a short terminal
+        // (drawn rows 1-2, keys computing against nine). `pickWindowOf` is the
+        // one derivation both sides use — the renderer draws it, the input layer
+        // is HANDED it (`visiblePickWindow`).
+        const win = pickWindowOf(view, state.cursor, state.phase, maxRows);
+        const shown = spec.options.slice(win.first, win.first + win.size);
         // R2: the note takes a COLUMN, not three spaces after a label of
         // whatever length this row happened to have, and the cursor row
         // wears the bar and the arrow like every other list in the
         // product. This panel was the last one still saying "selected"
         // with bold alone.
-        const lead = (o, i, cursor) => `${cursor ? "\u2192" : " "} ${i + 1} ${escapeTerminal(o.label)}`;
+        // 0.40.1 (the owner's dogfood, 2026-09-21): the row NUMBER is gone. The
+        // digits still pick by visible position (the keys sheet documents them),
+        // but a number the person reads as decoration is noise the label pays
+        // for at every width — and the owner picks with ↑↓ and the mouse.
+        const lead = (o, _i, cursor) => `${cursor ? "\u2192" : " "} ${escapeTerminal(o.label)}`;
         const widest = Math.max(...shown.map((o, i) => visibleWidth(lead(o, i, false))));
         const stop = shown.some((o) => o.note !== undefined) && widest + 2 <= Math.floor(room / 2) && room - widest - 2 >= 18 ? widest + 2 : 0;
         for (let i = 0; i < shown.length; i += 1) {
             const o = shown[i];
-            const mark = i === state.cursor && state.phase === "options";
+            // DC-58: `i` is the row's position in the WINDOW, the cursor is an
+            // option index — the mark lands on the cursor's own row after any
+            // scroll only when the window's origin is added back.
+            const mark = win.first + i === state.cursor && state.phase === "options";
             const plain = lead(o, i, mark);
             const head = `${mark ? p.bold : ""}${plain}${mark ? p.reset : ""}`;
             const note = o.note === undefined
@@ -605,9 +622,10 @@ export function pickBlockRows(view, state, W, maxRows) {
             rows.push(mark ? selectionBar(text, visibleWidth(text), W) : ` ${text}`);
         }
         if (spec.options.length > shown.length) {
-            rows.push(`  ${cutLine(`${p.dim} \u2514 +${spec.options.length - shown.length} more \u2014 /model <name> takes any of them${p.reset}`, room)}`);
+            const to = win.first + shown.length;
+            rows.push(`  ${cutLine(`${p.dim} \u2195 ${win.first + 1}-${to} / ${spec.options.length} \u2014 \u2191\u2193 scrolls${p.reset}`, room)}`);
         }
-        const axis = shown[state.cursor];
+        const axis = shown[state.cursor - win.first];
         if (strip === 1 && axis?.levels !== undefined) {
             const off = new Set(axis.disabled ?? []);
             // the RUNTIME cursor, not the option's starting index: the option
@@ -639,10 +657,48 @@ export function pickBlockRows(view, state, W, maxRows) {
     rows.push(`${p.dim}${"\u2500".repeat(Math.max(0, W))}${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. */
+/** The digits are the keys, so what one SCREEN offers is still bounded by
+ *  the digits there are — but the list itself is no longer bounded by it.
+ *
+ *  Finding DC-58 (the owner, 2026-09-21): this constant used to cap what the
+ *  KEYBOARD could reach (`/model` on a 60-profile config offered nine and
+ *  said `/model <name>` for the rest). The window now follows the cursor —
+ *  `pickWindow` — so PICK_MAX is only how many rows one screen shows, and
+ *  ↑↓ walks every option.
+ */
 export const PICK_MAX = 9;
+/** The option window the pick panel draws and the digits name: `size` rows
+ *  starting at `first`, with `first` derived from the cursor so it cannot
+ *  drift from it. Edge-following (the window starts moving only when the
+ *  cursor leaves it) and clamped at both ends, so the last page is full
+ *  rather than short.
+ *
+ *  Pure, and the ONE copy: the renderer, the digit keys and the click
+ *  hit-test all ask this function rather than each deriving an offset.
+ */
+/** The pick panel's window for THIS frame's budget — the one derivation the
+ *  renderer and the input layer share (review of this round).
+ *
+ *  The renderer draws it; `Dock.visiblePickWindow` hands the SAME value to the
+ *  digit keys, because a size derived twice is a size that can disagree — and
+ *  on a short terminal it did (two rows drawn, nine assumed, so `1` could mean
+ *  a row nobody could see). `phase` is compared as a string so this module
+ *  keeps its zero-dependency contract.
+ */
+export function pickWindowOf(view, cursor, phase, maxRows) {
+    const count = view.pick?.options.length ?? 0;
+    const strip = view.pick?.options[cursor]?.levels !== undefined && phase === "options" ? 1 : 0;
+    const chrome = 5 + strip + (count > Math.min(Math.max(1, maxRows - 5 - strip), PICK_MAX) ? 1 : 0);
+    const budget = Math.max(1, maxRows - chrome);
+    return pickWindow(cursor, count, Math.min(budget, PICK_MAX));
+}
+export function pickWindow(cursor, count, size) {
+    const win = Math.max(1, Math.min(size, count));
+    if (count <= win)
+        return { first: 0, size: win };
+    const first = Math.max(0, Math.min(cursor - win + 1, count - win));
+    return { first, size: win };
+}
 /** The input row's lead: the digit range while picking, the named
  *  prompt while typing one out. */
 export function pickLeadPlain(view, state) {

package/dist/components.d.ts

@@ -162,6 +162,19 @@ export type BodyCell = {
     kind: "notice";
     text: string;
     done: true;
+}
+/** 4c — the resumed session's earlier history, replayed into cells and
+ *  FOLDED: the row is ONE line on screen and never expands there (a
+ *  resize reprint of a six-thousand-event session redraws one row);
+ *  the children are the replayed cells, read in the ctrl+r viewer.
+ *  `summary` is a compaction checkpoint's text — what the model sees in
+ *  place of the turns it covers — null for a plain fold. */
+ | {
+    kind: "fold";
+    label: string;
+    children: BodyCell[];
+    summary: string | null;
+    done: true;
 } | {
     kind: "banner";
     version: string;
@@ -272,7 +285,9 @@ export declare function foldTerms(reads: number, edits: number, others: readonly
  * reads a payload it did not write, and a guess about what it means
  * would be a row the product cannot stand behind.
  */
-export declare function askedBlock(resultText: string, seconds: number, W: number): string[];
+/** `seconds` null: 4c's replayed card, settled from a log with no clock —
+ *  the head names the outcome and says nothing about time. */
+export declare function askedBlock(resultText: string, seconds: number | null, W: number): string[];
 /** The caps — screen rows counted AFTER the fold, at the current width
  *  (the W7 table). The renderer-cut row is inside the cap. */
 /** R13 — ONE preview cap, every tool. It was the shell's alone while

package/dist/components.js

@@ -30,7 +30,7 @@ import { displayWidth, visibleWidth, widthCut } from "./width.js";
 // KEY_BINDINGS). strings.js imports only render/width here, so this edge
 // adds no cycle.
 import { displayVerb } from "./strings.js";
-import { bannerLines, breathFrame, cutLine, escapeTerminal, foldThinking, foldThinkingRow, foldResult, renderTerminalGap, renderToolSummary, toolTarget, kUnit, palette, currentGround, } from "./render.js";
+import { bannerLines, breathFrame, cutLine, escapeTerminal, stripAnsi, foldThinking, foldThinkingRow, foldResult, renderTerminalGap, renderToolSummary, toolTarget, kUnit, palette, currentGround, } 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
@@ -179,6 +179,8 @@ export function cellComponent(cell) {
             return new MarkdownBlock(cell);
         case "notice":
             return new ErrorLine(cell);
+        case "fold":
+            return new FoldRow(cell);
         case "banner":
             return new Banner(cell);
         case "raw":
@@ -627,7 +629,7 @@ class ToolExecution {
             // that is not the ask's own JSON, so a payload this renderer
             // did not write can never be guessed at.
             if (c.name === "ask_user" && c.reason === null && !c.isError) {
-                const asked = askedBlock(c.resultText, c.startedAt !== null && c.doneAt !== null ? (c.doneAt - c.startedAt) / 1000 : 0, W);
+                const asked = askedBlock(c.resultText, c.startedAt !== null && c.doneAt !== null ? (c.doneAt - c.startedAt) / 1000 : c.startedAt === null && c.doneAt === null ? null : 0, W);
                 if (asked.length > 0)
                     return asked;
             }
@@ -644,7 +646,10 @@ class ToolExecution {
                 out.push(...toolBlockBody(c, W, ctx));
                 return out;
             }
-            const elapsed = c.startedAt !== null && c.doneAt !== null ? settledLabel((c.doneAt - c.startedAt) / 1000) : "?s";
+            // 4c: a card settled from the durable log carries no clock at all
+            // (the log's events have no timestamps) — it says nothing about
+            // time rather than `?s`, which reads as a measurement that failed.
+            const elapsed = c.startedAt !== null && c.doneAt !== null ? settledLabel((c.doneAt - c.startedAt) / 1000) : c.startedAt === null && c.doneAt === null ? "" : "?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
@@ -1099,6 +1104,8 @@ export function foldTerms(reads, edits, others) {
  * reads a payload it did not write, and a guess about what it means
  * would be a row the product cannot stand behind.
  */
+/** `seconds` null: 4c's replayed card, settled from a log with no clock —
+ *  the head names the outcome and says nothing about time. */
 export function askedBlock(resultText, seconds, W) {
     let parsed;
     try {
@@ -1111,7 +1118,7 @@ export function askedBlock(resultText, seconds, W) {
         return [];
     const asked = parsed;
     const p = palette();
-    const head = (n, outcome) => cutLine(`  ${p.bold}asked${p.reset} ${n} ${n === 1 ? "question" : "questions"} ${p.dim}(${outcome}, ${seconds.toFixed(1)}s)${p.reset}`, W);
+    const head = (n, outcome) => cutLine(`  ${p.bold}asked${p.reset} ${n} ${n === 1 ? "question" : "questions"} ${p.dim}(${seconds === null ? outcome : `${outcome}, ${seconds.toFixed(1)}s`})${p.reset}`, W);
     const row = (body) => cutLine(`  ${p.dim}│${p.reset} ${body}`, W);
     if (Array.isArray(asked.declined) && asked.declined.length > 0) {
         // the honest decline record: WHAT went unanswered, and what the
@@ -1439,7 +1446,8 @@ function blockRows(text, W, tone = "dim") {
     // rows around them take `washDim`, which was chosen for that ground.
     const open = tone === "dim" ? p.dim : "";
     const close = tone === "dim" ? p.reset : "";
-    for (const raw of escapeTerminal(text).split("\n")) {
+    // 0.40.0: the output's own styling is dropped whole before the escape
+    for (const raw of escapeTerminal(stripAnsi(text)).split("\n")) {
         for (const row of foldLine(raw, textW))
             rows.push(`${open}${bodyRow()}${row}${close}`);
     }
@@ -1643,7 +1651,12 @@ export function diffBody(diff, W, expanded = false) {
             ? `${p.red}- ${escapeTerminal(d.text)}${p.reset}`
             : d.kind === "+"
                 ? `${p.green}+ ${escapeTerminal(d.text)}${p.reset}`
-                : `${p.dim}  ${escapeTerminal(d.text)}${p.reset}`;
+                : d.kind === "note"
+                    ? // 0.40.0: a note starts in the MARKER column, where no line
+                        // of the file ever does — it reads as kiso's sentence about
+                        // the diff, not as an unchanged line inside it
+                        `${p.dim}${escapeTerminal(d.text)}${p.reset}`
+                    : `${p.dim}  ${escapeTerminal(d.text)}${p.reset}`;
         // W2: the diff body is a bounded block's body — the │ gutter
         // (dim), never the old bold ▎ rail (the table lists no ▎); the
         // +/- marks and their colors ride the content
@@ -1728,6 +1741,19 @@ class ErrorLine {
         return foldWords(escapeTerminal(this.cell.text), W);
     }
 }
+/** 4c — the folded history's ONE row. Dim, like every row that is about
+ *  the transcript rather than in it; cut, never wrapped, so it is one row
+ *  at every width. */
+class FoldRow {
+    cell;
+    constructor(cell) {
+        this.cell = cell;
+    }
+    render(W, _ctx) {
+        const p = palette();
+        return [cutLine(`  ${p.dim}${escapeTerminal(this.cell.label)}${p.reset}`, W)];
+    }
+}
 /** The CLI's pre-rendered blocks (the banner, the recap, slash-command
  *  output) — the SGR applied at composition (render.ts), folded here
  *  verbatim: the #16b contract (no re-escaping) holds, and the fold is

package/dist/diff.d.ts

@@ -10,9 +10,12 @@
  * RENDERER truncates (18 head + 18 tail + "… N lines"); the stats come
  * from the full diff.
  */
-/** The diff block's per-row kind. */
+/** The diff block's per-row kind. `note` (0.40.0) is kiso's sentence
+ *  ABOUT the diff — the renderer's cut, a search that is not there or is
+ *  there more than once — never a line of the file, so never drawn where
+ *  the file's lines are. */
 export type DiffLine = {
-    kind: "-" | "+" | " ";
+    kind: "-" | "+" | " " | "note";
     text: string;
 };
 export interface DiffResult {

package/dist/diff.js

@@ -76,7 +76,7 @@ export function truncateDiff(diff) {
     const omitted = diff.length - 2 * TRUNCATE_KEEP;
     return [
         ...diff.slice(0, TRUNCATE_KEEP),
-        { kind: " ", text: `… ${omitted} lines (/last for full)` },
+        { kind: "note", text: `… ${omitted} lines (/last for full)` },
         ...diff.slice(diff.length - TRUNCATE_KEEP),
     ];
 }
@@ -117,7 +117,7 @@ export function editFileDiff(oldContent, search, replace, path) {
     const at = oldContent.indexOf(search);
     if (at < 0) {
         return {
-            lines: [{ kind: " ", text: `pattern not found in ${path ?? "the file"}` }],
+            lines: [{ kind: "note", text: `pattern not found in ${path ?? "the file"}` }],
             added: 0,
             removed: 0,
             outcome: "not-found",
@@ -131,7 +131,7 @@ export function editFileDiff(oldContent, search, replace, path) {
     // same rule as the miss above, for the same reason.
     if (search.length > 0 && oldContent.indexOf(search, at + 1) > at) {
         return {
-            lines: [{ kind: " ", text: `pattern matches more than one place in ${path ?? "the file"}` }],
+            lines: [{ kind: "note", text: `pattern matches more than one place in ${path ?? "the file"}` }],
             added: 0,
             removed: 0,
             outcome: "ambiguous",

package/dist/index.d.ts

@@ -12,7 +12,7 @@ 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, deletionRiskHint, SAFER_BACK, SAFER_DEGRADED, type SaferOption, type SaferRuntime, panelOptions, type PanelOption, type PanelOptionKind, 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 { coldResumeLine, coldResumeView, extensionsBannerText, helpRows, unansweredAskView, type BannerExtension } from "./strings.js";
 export { displayVerb } from "./strings.js";
 export { bannerLines, COLOR_OFF, COLOR_DARK, COLOR_LIGHT, COLOR_NEUTRAL, COLOR_ON, currentGround, setGround, escapeTerminal, foldResult, foldThinking, kUnit, palette, relativeTime, renderResumeList, MOTION_FRAMES, TWINKLE, breathFrame, twinkleFrame, renderTerminalGap, renderToolSummary, TAGLINE, toolTarget, truncateRow, type Palette, type ResumeMeta, } from "./render.js";
 /** DC-3 — the ground: is the terminal light or dark. Pure; see the

package/dist/index.js

@@ -24,7 +24,7 @@ export { panelAffordance, panelBlockRows, panelLead, panelLeadPlain, panelLeadWi
 // the cli; what the human reads is presentation.
 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";
+export { coldResumeLine, coldResumeView, 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";

package/dist/render.d.ts

@@ -146,12 +146,7 @@ export declare const COLOR_OFF: Palette;
 export declare function setGround(g: Ground): void;
 export declare function currentGround(): Ground;
 export declare function palette(): Palette;
-/**
- * E group/round 8: strip terminal-injection vectors from MODEL/TOOL text before it
- * reaches the terminal — ESC, C0 (except \t \n), C1, CR, backspace, and
- * bidi overrides. The kiso colors are applied by render, not by the data.
- * EVERY externally-sourced string must pass through this before any output.
- */
+export declare function stripAnsi(text: string): string;
 export declare function escapeTerminal(text: string): string;
 /**
  * v2b — one thinking BLOCK folds to ONE dim line: the first 100 chars, a

package/dist/render.js

@@ -97,6 +97,25 @@ export function palette() {
  * bidi overrides. The kiso colors are applied by render, not by the data.
  * EVERY externally-sourced string must pass through this before any output.
  */
+/**
+ * 0.40.0 (the owner's dogfood) — a tool's OUTPUT, shown without its
+ * terminal styling. escapeTerminal drops the ESC byte and nothing else, so
+ * a coloured test run reached the card as `[31m─── [1m[41m Failed Tests`.
+ * Here the whole sequence goes: CSI (colours, cursor moves), OSC (titles,
+ * links), DCS/SOS/PM/APC strings, charset selections, the two-byte escapes,
+ * and the 8-bit CSI. Every branch is linear: a string body stops at the
+ * first ESC (only its terminator may hold one), so hostile output — an
+ * unterminated `ESC P` repeated — never scans to the end of the text once
+ * per sequence (the lead's review: that was n²/2 on the render path).
+ * Only output bodies pass through here — in a NAME the
+ * `[31m` remnant is the visible sign of an injected sequence, and stripping
+ * it would let `sh<ESC>[31mell` read as `shell`.
+ */
+// eslint-disable-next-line no-control-regex
+const ANSI_SEQUENCE = /\x1b\[[0-?]*[ -/]*[@-~]|\x1b\][^\x07\x1b]*(?:\x07|\x1b\\)|\x1b[PX^_][^\x1b]*\x1b\\|\x1b[ -/]+[0-~]|\x1b[@-Z\\-_]|\x9b[0-?]*[ -/]*[@-~]/g;
+export function stripAnsi(text) {
+    return text.replace(ANSI_SEQUENCE, "");
+}
 export function escapeTerminal(text) {
     // eslint-disable-next-line no-control-regex
     return text

package/dist/strings.d.ts

@@ -96,6 +96,16 @@ export declare function uncertainView(name: string, executionId: string): PanelV
  * back. Re-asking is safe — that is what the first option says out loud.)
  */
 export declare function unansweredAskView(executionId: string): PanelView;
+/**
+ * 0.40.0 (the owner's session) — the cold resume. A session resumed 27
+ * minutes after its last request re-sent a 727k prefix the provider had
+ * evicted. The first request after a long pause pays for the whole prefix
+ * either way; compacting first turns that one expensive request into a
+ * summary call, and every turn after it is small. The line names the size
+ * and the age, so the person can judge.
+ */
+export declare function coldResumeLine(tokens: number, minutesAgo: number): string;
+export declare function coldResumeView(tokens: number, minutesAgo: number): PanelView;
 /** An extension as the banner names it — the live `connecting` flag is
  *  the MCP bridge's in-flight state ("mcp (connecting…)"). Structural on
  *  purpose: the runtime's KisoExtension satisfies it without this
@@ -103,6 +113,9 @@ export declare function unansweredAskView(executionId: string): PanelView;
 export interface BannerExtension {
     readonly name: string;
     readonly connecting?: boolean;
+    /** A fact about the extension in this session, printed in parentheses
+     *  after its name — "ask (off in dontAsk)". `connecting` wins. */
+    readonly note?: string;
 }
 /**
  * KC3.5 slice ⓪ (the extraction) — the `[N extensions: …]` banner text:
@@ -188,7 +201,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;
-/** The slash commands `/help` lists. The keys and the `!` gestures in the
- *  table are not commands and are not here. */
+/** The slash commands `/help` lists. The keys, the `!` gestures and the
+ *  `/<name>` skill rule 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

@@ -143,6 +143,31 @@ export function unansweredAskView(executionId) {
         fallbackQuestion: `an unanswered question was interrupted (${executionId}) — ask it again? (y)es / (n)o `,
     };
 }
+/**
+ * 0.40.0 (the owner's session) — the cold resume. A session resumed 27
+ * minutes after its last request re-sent a 727k prefix the provider had
+ * evicted. The first request after a long pause pays for the whole prefix
+ * either way; compacting first turns that one expensive request into a
+ * summary call, and every turn after it is small. The line names the size
+ * and the age, so the person can judge.
+ */
+export function coldResumeLine(tokens, minutesAgo) {
+    return `this session is ${Math.round(tokens / 1000)}k tokens, last used ${minutesAgo} min ago, and its cache is cold`;
+}
+export function coldResumeView(tokens, minutesAgo) {
+    const line = coldResumeLine(tokens, minutesAgo);
+    return {
+        flavor: "simple",
+        name: "cold cache",
+        title: `compact first? (${Math.round(tokens / 1000)}k tokens, ${minutesAgo} min idle)`,
+        speaker: "kiso",
+        statusText: "❯ resumed session",
+        args: { kind: "text", lines: [line, "compacting first is one summary call, then every turn is cheap"] },
+        ruleOverride: `${line} — compact first? (one summary call, then every turn is cheap)`,
+        simpleOptions: ["compact first", "keep the full history"],
+        fallbackQuestion: `${line} — compact first? (y)es / (n)o `,
+    };
+}
 /**
  * KC3.5 slice ⓪ (the extraction) — the `[N extensions: …]` banner text:
  * the built-in column, then the user-level names, then the project-level
@@ -158,7 +183,7 @@ export function extensionsBannerText(builtIn, user, project) {
     const total = builtIn.length + user.length + project.length;
     if (total === 0)
         return "";
-    const label = (e) => (e.connecting === true ? `${e.name} (connecting…)` : e.name);
+    const label = (e) => e.connecting === true ? `${e.name} (connecting…)` : e.note !== undefined ? `${e.name} (${e.note})` : e.name;
     const parts = [];
     if (builtIn.length > 0)
         parts.push(`built-in: ${builtIn.map(label).join(", ")}`);
@@ -447,7 +472,7 @@ const HELP_TABLE = [
     // 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)"],
+    ["/mode", "show the approval tier; /mode <name> switches (default/accept-edits/plan/dontAsk/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)"],
@@ -455,6 +480,12 @@ const HELP_TABLE = [
     // §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"],
+    // 0.40.0: a skill is a user turn — its SKILL.md, then your args. The
+    // `/<name>` row says the rule a person needs before they install a
+    // skill named like a command: the command wins.
+    ["/skills", "list the installed skills, and any that cannot load"],
+    ["/skill", "run a skill as your turn: /skill <name> [args]"],
+    ["/<name>", "runs the skill <name> when no command above has that name"],
     // §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.
@@ -477,10 +508,10 @@ const HELP_TABLE = [
     // 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. */
+/** The slash commands `/help` lists. The keys, the `!` gestures and the
+ *  `/<name>` skill rule in the table are not commands and are not here. */
 export function slashCommandNames() {
-    return HELP_TABLE.map(([name]) => name).filter((n) => n.startsWith("/"));
+    return HELP_TABLE.map(([name]) => name).filter((n) => /^\/[a-z]+$/.test(n));
 }
 export function helpRows() {
     const p = palette();

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@vincemakes/kiso-tui-cells",
-	"version": "0.39.2",
+	"version": "0.40.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",