@vincemakes/kiso-tui-cells 0.31.0 → 0.32.0

package/dist/approval-panel.d.ts

@@ -209,7 +209,39 @@ export interface PickOption {
     /** the dim qualifier ("profile: ds \u00b7 current") \u2014 what tells two
      *  similar rows apart */
     readonly note?: string;
+    /** OR-7 — the SECOND axis. The model's NATIVE levels in vendor order,
+     *  from the registry. Absent = this option has no second axis and the
+     *  row renders exactly as it did before. */
+    readonly levels?: readonly string[];
+    /** where the level cursor starts. UNDEFINED is a real state, not a
+     *  missing value: a row whose registry default is null (the page
+     *  states none) marks nothing, and enter applies the profile alone.
+     *  The panel never invents a default. */
+    readonly level?: number;
+    /** indexes forbidden for the current thinking mode. The cursor never
+     *  rests on one \u2014 see `enabledLevel`. */
+    readonly disabled?: readonly number[];
+    /** shown after the strip when the cursor did NOT land where the
+     *  previous selection asked ("effort xhigh \u2192 high: the nearest this
+     *  model supports"). The caller's sentence, reproduced verbatim. */
+    readonly levelNote?: string;
 }
+/** The level cursor, CORRECTED at read time: never off the end, never on
+ *  a forbidden index, and never invented where the caller supplied none.
+ *
+ *  One rule instead of two. The alternative \u2014 letting the cursor rest on
+ *  a forbidden index and refusing at enter \u2014 needs a second mechanism to
+ *  say why nothing happened, and a key that silently does nothing is the
+ *  defect this panel already fixed once (DC-36). Correcting on read is
+ *  the discipline the session picker uses for its own selection. */
+export declare function enabledLevel(o: PickOption | undefined, want: number | null): number | null;
+/** Where the cursor OPENS on an option: what the caller asked for,
+ *  corrected. The two callers (the panel opening, and the highlight
+ *  moving to another row) mean exactly this and nothing else. */
+export declare function startLevel(o: PickOption | undefined): number | null;
+/** The next enabled index in `dir`, or the current one at the end of the
+ *  ladder. Forbidden indexes are stepped OVER, never landed on. */
+export declare function stepLevel(o: PickOption, from: number | null, dir: -1 | 1): number | null;
 /** The whole pick: the header sentence, the options, the free-text
  *  escape hatch, and the honest empty state. */
 export interface PickSpec {
@@ -231,6 +263,9 @@ export interface PickSpec {
 export interface PickRuntime {
     readonly cursor: number;
     readonly phase: "options" | "custom";
+    /** OR-7: the level cursor within the highlighted option. null = the
+     *  option has no levels, or has no default to mark. */
+    readonly level: number | null;
 }
 /** 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. */
@@ -322,10 +357,12 @@ export type PanelVerdict = {
 }
 /** 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. */
+ *  switch is untouched. OR-7 adds the second axis beside it: the
+ *  level INDEX, absent when the option had no levels or marked none. */
  | {
     readonly action: "picked";
     readonly result: PickResult;
+    readonly level?: number;
 };
 /** The bound panel state the compositor reads — the editor owns the
  *  phase/selection state machine and the key routing; the compositor
@@ -432,7 +469,7 @@ 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;
+export declare function pickAffordance(state: PickRuntime, axis?: boolean): 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. */

package/dist/approval-panel.js

@@ -164,6 +164,58 @@ function segmentRisk(segment) {
     }
     return null;
 }
+/** The level cursor, CORRECTED at read time: never off the end, never on
+ *  a forbidden index, and never invented where the caller supplied none.
+ *
+ *  One rule instead of two. The alternative \u2014 letting the cursor rest on
+ *  a forbidden index and refusing at enter \u2014 needs a second mechanism to
+ *  say why nothing happened, and a key that silently does nothing is the
+ *  defect this panel already fixed once (DC-36). Correcting on read is
+ *  the discipline the session picker uses for its own selection. */
+export function enabledLevel(o, want) {
+    const levels = o?.levels;
+    if (levels === undefined || levels.length === 0 || want === null)
+        return null;
+    const off = new Set(o?.disabled ?? []);
+    if (off.size >= levels.length)
+        return null; // every level forbidden: nothing to point at
+    const clamped = Math.max(0, Math.min(levels.length - 1, want));
+    if (!off.has(clamped))
+        return clamped;
+    // walk outward from the asked-for index, nearest first
+    for (let d = 1; d < levels.length; d += 1) {
+        const hi = clamped + d;
+        if (hi < levels.length && !off.has(hi))
+            return hi;
+        const lo = clamped - d;
+        if (lo >= 0 && !off.has(lo))
+            return lo;
+    }
+    return null;
+}
+/** Where the cursor OPENS on an option: what the caller asked for,
+ *  corrected. The two callers (the panel opening, and the highlight
+ *  moving to another row) mean exactly this and nothing else. */
+export function startLevel(o) {
+    return enabledLevel(o, o?.level ?? null);
+}
+/** The next enabled index in `dir`, or the current one at the end of the
+ *  ladder. Forbidden indexes are stepped OVER, never landed on. */
+export function stepLevel(o, from, dir) {
+    const levels = o.levels;
+    if (levels === undefined || levels.length === 0)
+        return null;
+    // the first press on a row that marks nothing enters the ladder at
+    // its near end rather than guessing a middle.
+    if (from === null)
+        return enabledLevel(o, dir === 1 ? 0 : levels.length - 1);
+    const off = new Set(o.disabled ?? []);
+    for (let i = from + dir; i >= 0 && i < levels.length; i += dir) {
+        if (!off.has(i))
+            return i;
+    }
+    return from;
+}
 /** 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,
  *  code-accented). The simple flavor carries the CLI's own question
@@ -516,7 +568,14 @@ export function pickBlockRows(view, state, W, maxRows) {
         // content were scrolled irreversibly into the scrollback every time
         // `/model` opened on a tight screen. The `+N more` row is a sixth
         // when it appears, so it is paid for too.
-        const chrome = 5 + (spec.options.length > Math.min(Math.max(1, maxRows - 5), PICK_MAX) ? 1 : 0);
+        // OR-7: the level strip is a row of its own under the highlighted
+        // option, so it is chrome and it is paid for here. Inline after the
+        // note was the coordination note's shape and it does not fit: five
+        // levels need 42 columns and the note column has 48 at width 100,
+        // 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));
         // R2: the note takes a COLUMN, not three spaces after a label of
@@ -548,13 +607,35 @@ export function pickBlockRows(view, state, W, maxRows) {
         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 axis = shown[state.cursor];
+        if (strip === 1 && axis?.levels !== undefined) {
+            const off = new Set(axis.disabled ?? []);
+            // the RUNTIME cursor, not the option's starting index: the option
+            // says where the cursor opens, the state says where it is now.
+            // Reading the option here rendered a bracket that never moved
+            // while the state underneath it did — the silent movement this
+            // whole axis exists to replace.
+            const cur = enabledLevel(axis, state.level);
+            // the bracket means THE CURSOR IS HERE. It used to mean "the
+            // registry default" in the note's text form; a row whose
+            // default is null now marks nothing at all rather than
+            // promoting the first level into one.
+            const cells = axis.levels.map((l, i) => {
+                const text = escapeTerminal(l);
+                if (off.has(i))
+                    return `${p.dim}${text}${p.reset}`;
+                return i === cur ? `${p.bold}[${text}]${p.reset}` : text;
+            });
+            const note = axis.levelNote === undefined ? "" : ` ${p.dim}\u2014 ${escapeTerminal(axis.levelNote)}${p.reset}`;
+            rows.push(`  ${cutLine(`${p.dim}effort: ${p.reset}${cells.join(`${p.dim} \u00b7 ${p.reset}`)}${note}`, room)}`);
+        }
     }
     const typing = state.phase === "custom";
     if (spec.typeHint !== undefined) {
         const tText = cutLine(`${typing ? p.bold : ""}${typing ? "\u2192" : " "} t ${p.reset}${p.dim}${escapeTerminal(spec.typeHint)}${p.reset}`, room);
         rows.push(typing ? selectionBar(tText, visibleWidth(tText), W) : ` ${tText}`);
     }
-    rows.push(`  ${p.dim}${cutLine(pickAffordance(state), room)}${p.reset}`);
+    rows.push(`  ${p.dim}${cutLine(pickAffordance(state, spec.options[state.cursor]?.levels !== undefined), room)}${p.reset}`);
     rows.push(`${p.dim}${"\u2500".repeat(Math.max(0, W))}${p.reset}`);
     return rows;
 }
@@ -579,14 +660,19 @@ export function pickLead(view, state) {
 export function pickStatus(view) {
     return view.statusText;
 }
-export function pickAffordance(state) {
+export function pickAffordance(state, axis = false) {
     // DC-36 — the row NAMES the arrows. TUI2-R2 ④ bound ↑↓ to the pick's
     // cursor and the keys sheet has said `panels: ↑↓ move` ever since,
     // but this row — the one a human is actually looking at while the
     // panel is up — advertised only the digits. The owner read it as
     // "type the answer", which is the same lesson DC-30 filed: a hint
     // that omits the gesture is why the gesture goes unused.
-    return state.phase === "custom" ? "enter commits \u00b7 esc backs out" : "\u2191\u2193 move \u00b7 digits pick \u00b7 \u23ce confirms \u00b7 esc";
+    // OR-7 names \u2190\u2192 here for the same reason DC-36 named \u2191\u2193: a gesture
+    // this row omits is a gesture that goes unused. It appears only when
+    // there is a second axis to walk.
+    if (state.phase === "custom")
+        return "enter commits \u00b7 esc backs out";
+    return axis ? "\u2191\u2193 move \u00b7 \u2190\u2192 effort \u00b7 digits pick \u00b7 \u23ce confirms \u00b7 esc" : "\u2191\u2193 move \u00b7 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

package/dist/components.d.ts

@@ -99,6 +99,7 @@ export type BodyCell = {
     text: string;
     done: boolean;
     turn: number;
+    folded?: boolean;
 } | {
     kind: "tool";
     name: string;

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, foldResult, renderTerminalGap, renderToolSummary, toolTarget, kUnit, palette, currentGround, } from "./render.js";
+import { bannerLines, breathFrame, cutLine, escapeTerminal, 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
@@ -370,6 +370,17 @@ class ThinkingBlock {
         const text = escapeTerminal(this.cell.text).trim();
         if (text === "")
             return [];
+        // §2.3 — ctrl+t folded this block. The row is the pipe's own fold,
+        // fitted: `foldThinkingRow` is the single source of the shape and
+        // with unlimited room it IS `foldThinking`, so thinking has two
+        // renderings in the product and not three. It is width-aware here
+        // because a row must measure ≤ W and the pipe's line does not —
+        // cutting it from the right would take the `/think` suffix, which
+        // is the one part of a folded block that says how to read the rest.
+        // It keeps the block's own indent, so a folded block sits in the
+        // column an unfolded one does (DC-47).
+        if (this.cell.folded)
+            return [`${THINK_COL}${foldThinkingRow(this.cell.text, Math.max(1, W - THINK_COL.length))}`];
         // DC-47 — THINKING GOES ONE LEVEL DEEPER THAN PROSE, and the
         // reason is a law rather than a taste.
         //

package/dist/render.d.ts

@@ -161,6 +161,21 @@ export declare function escapeTerminal(text: string): string;
  * strategy is presentation-independent.
  */
 export declare function foldThinking(block: string): string;
+/** §2.3 — the same fold, as a ROW that fits `room` columns.
+ *
+ *  A row must measure ≤ W (invariant ①), and the pipe's line does not:
+ *  `…` + 100 characters + " (N chars · /think)" is about 122 columns, so
+ *  on an 80-column terminal the frame's cut takes the SUFFIX — which is
+ *  the affordance, the one part of a folded block that says how to read
+ *  the rest of it. Cutting from the right removes exactly the thing the
+ *  fold exists to leave behind.
+ *
+ *  So the suffix is reserved FIRST and the head takes what is left. The
+ *  vocabulary is unchanged — the leading `…`, the character count, the
+ *  `/think` route — and with unlimited room the result is byte-for-byte
+ *  the line the pipe has always written, which is what keeps the two
+ *  renderings one shape rather than two. */
+export declare function foldThinkingRow(block: string, room: number): string;
 /** v2b — the [result] echo truncates at 160 chars + a /last hint. */
 export declare function foldResult(content: string): string;
 /**

package/dist/render.js

@@ -113,10 +113,34 @@ export function escapeTerminal(text) {
  * strategy is presentation-independent.
  */
 export function foldThinking(block) {
+    // the PIPE's line: no room limit, so the row path below reproduces
+    // today's bytes exactly and this stays the one source of the shape.
+    return `${foldThinkingRow(block, Number.POSITIVE_INFINITY)}\n`;
+}
+/** §2.3 — the same fold, as a ROW that fits `room` columns.
+ *
+ *  A row must measure ≤ W (invariant ①), and the pipe's line does not:
+ *  `…` + 100 characters + " (N chars · /think)" is about 122 columns, so
+ *  on an 80-column terminal the frame's cut takes the SUFFIX — which is
+ *  the affordance, the one part of a folded block that says how to read
+ *  the rest of it. Cutting from the right removes exactly the thing the
+ *  fold exists to leave behind.
+ *
+ *  So the suffix is reserved FIRST and the head takes what is left. The
+ *  vocabulary is unchanged — the leading `…`, the character count, the
+ *  `/think` route — and with unlimited room the result is byte-for-byte
+ *  the line the pipe has always written, which is what keeps the two
+ *  renderings one shape rather than two. */
+export function foldThinkingRow(block, room) {
     const p = palette();
     const trimmed = escapeTerminal(block.trim());
     const truncated = trimmed.length > 100;
-    return `${p.dim}…${trimmed.slice(0, 100)}${truncated ? ` (${block.length} chars · /think)` : ""}${p.reset}\n`;
+    const suffix = truncated ? ` (${block.length} chars · /think)` : "";
+    const head = Number.isFinite(room)
+        ? // the leading … costs one column, the suffix costs its own width
+            widthCut(trimmed.slice(0, 100), Math.max(1, room - 1 - displayWidth(suffix)))
+        : trimmed.slice(0, 100);
+    return `${p.dim}…${head}${suffix}${p.reset}`;
 }
 /** v2b — the [result] echo truncates at 160 chars + a /last hint. */
 export function foldResult(content) {

package/dist/strings.js

@@ -440,6 +440,21 @@ export function helpRows() {
         ["/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

package/package.json

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