@vincemakes/kiso-tui 0.20.3 → 0.21.0

package/dist/ask-panel.js

@@ -418,7 +418,7 @@ export function askStatus(view, state) {
     // that no competitor can copy without building the log first.
     const total = view.ask.questions.length;
     const where = total > 1 ? `question ${state.qIndex + 1} of ${total}` : "a question for you";
-    return `⏸ ${where} · answers are durable facts`;
+    return `❯ ${where} · answers are durable facts`;
 }
 /** The input row's lead: the digit lead while picking, the typing lead
  *  in the custom phase (the rule-input phase's shape, reused). */
@@ -508,7 +508,7 @@ export function askView(spec) {
         name: "ask_user",
         title: first.header ?? first.question,
         speaker: "kiso",
-        statusText: "⏸ a question for you",
+        statusText: "❯ a question for you",
         args: { kind: "text", lines: askDeclineList(spec) },
         fallbackQuestion: `⚠ ${escapeTerminal(first.question)} — this terminal cannot show the option panel; the question is declined `,
         ask: spec,

package/dist/compositor.d.ts

@@ -221,21 +221,21 @@ export declare class Body {
     };
     /** Whether the viewer owns the live region right now. */
     viewerOpen(): boolean;
-    /** ctrl+o — open on the newest fold, or close. */
+    /** ctrl+r — open on the newest fold, or close. */
     viewerToggleMode(): void;
     /** The viewer's keys. Everything the surface can do, a key does —
      *  there is no pointer, so there is nothing a pointer could reach
      *  that a keyboard cannot. */
     viewerKey(cmd: "up" | "down" | "toggle" | "all" | "pageUp" | "pageDown" | "home" | "end"): void;
     /**
-     * DC-35 — ctrl+r does not print the same expansion twice in a row.
+     * DC-35 — ctrl+o does not print the same expansion twice in a row.
      *
      * The ring walks newest-back and restarts its cycle once every entry
      * has been opened (R4/C1, which is what makes the walk immune to the
      * ring growing underneath it). With a ring of ONE the restart is
      * immediate, so holding the key appended the identical block over
      * and over — the owner got three copies of the same four rows, each
-     * closing with `ctrl+r opens the one before it`, a footer naming
+     * closing with `ctrl+o opens the one before it`, a footer naming
      * something that does not exist.
      *
      * The bar is the BOTTOM of the transcript, not "ever shown": once

package/dist/compositor.js

@@ -47,7 +47,7 @@ import { MENU_ITEMS, displayWidth } from "./editor.js";
 import { leadWidth } from "./width.js"; // W23: the ONE width authority (the editor, #inputRow, and editCol share it)
 // KC3.5: the panel-slot reads come from the DISPATCHERS — one source
 // for four reads, so an ask can never render half as an approval.
-import { panelAffordanceOf, panelFrameOf, panelLeadOf, panelRowsOf, panelStatusOf } from "./ask-panel.js";
+import { panelFrameOf, panelLeadOf, panelRowsOf, panelStatusOf } from "./ask-panel.js";
 import { MOUSE_OFF } from "./editor.js";
 import { atPanelRows, bandHeader } from "./at-picker.js";
 // TUI2-R2 ②: the session picker's rows — the band's third occupant.
@@ -93,7 +93,7 @@ function rolledTitle(cell) {
  *  one.
  *
  *  Extracted at R3b so the segment fold's expansion opens a run to the
- *  SAME rows `ctrl+r` on the run itself would have opened. Two copies of
+ *  SAME rows `ctrl+o` on the run itself would have opened. Two copies of
  *  this would be two answers to "show me that run". */
 function rolledDetail(cell, W) {
     const p = palette();
@@ -331,7 +331,7 @@ export class Body {
     #mdBase = 0;
     #toolCells = new Map(); // callId → cell index (parallel tools)
     // W15: the collapsed (cut) tool cells — committed cells whose last
-    // rendered row carried the "ctrl+r" affordance; the expand key's
+    // rendered row carried the "ctrl+o" affordance; the expand key's
     // cycling pointer walks this list from the newest back.
     #collapsed = [];
     /** R4 (C1) — the ring walk is by IDENTITY, not by a modular pointer.
@@ -1040,7 +1040,7 @@ export class Body {
     lastTool() {
         return this.#lastTool;
     }
-    /** W15 — the expand key's target (ctrl+r). A cell still in the LIVE
+    /** W15 — the expand key's target (ctrl+o). A cell still in the LIVE
      *  region (the newest live tool) TOGGLES in place — the compositor
      *  owns those rows and redraws them (the body flips to the full
      *  form, no cap). A committed cell can never toggle — history is
@@ -1050,7 +1050,7 @@ export class Body {
      *  the header names the target ("N turns back" — the user cells
      *  after it), so every press tells the user what they got. */
     /**
-     * TUI2-R2 ⑤ — the cell the next ctrl+r will act on, or -1.
+     * TUI2-R2 ⑤ — the cell the next ctrl+o will act on, or -1.
      *
      * The rule is expandNext's own first loop, extracted verbatim: the
      * LAST live cell that can toggle. It is a separate method rather than
@@ -1158,7 +1158,7 @@ export class Body {
                 const saved = head.rolled;
                 head.rolled = rolledOf(run);
                 // the run OPENS. The fold's key already asked to see the
-                // work, so what lands is the same rows `ctrl+r` on the
+                // work, so what lands is the same rows `ctrl+o` on the
                 // run itself would have opened — its title, then its
                 // detail — never its collapsed row, which would make the
                 // reader press a second time for what the first press
@@ -1226,7 +1226,7 @@ export class Body {
     viewerOpen() {
         return this.#viewer !== null;
     }
-    /** ctrl+o — open on the newest fold, or close. */
+    /** ctrl+r — open on the newest fold, or close. */
     viewerToggleMode() {
         if (this.#viewer !== null) {
             this.#viewer = null;
@@ -1288,7 +1288,7 @@ export class Body {
     /**
      * The expandable things in the transcript, oldest first.
      *
-     * The set is `#collapsed` — the SAME ring `ctrl+r` walks — so the two
+     * The set is `#collapsed` — the SAME ring `ctrl+o` walks — so the two
      * mechanisms can never disagree about what is reachable. The ring is
      * newest-first (it is unshifted on commit); reading order is the
      * other way, so it is reversed here.
@@ -1315,7 +1315,7 @@ export class Body {
             }
             if (cell.kind !== "tool")
                 continue;
-            // the tool card's FULL body — the same rows its own ctrl+r
+            // the tool card's FULL body — the same rows its own ctrl+o
             // opens. The expanded flag is saved and restored inside this
             // synchronous call, the pattern the rollup path has always
             // used for head.rolled; it never outlives the render, so the
@@ -1355,14 +1355,14 @@ export class Body {
      *  transcript does not already END with. */
     #lastAppend = null;
     /**
-     * DC-35 — ctrl+r does not print the same expansion twice in a row.
+     * DC-35 — ctrl+o does not print the same expansion twice in a row.
      *
      * The ring walks newest-back and restarts its cycle once every entry
      * has been opened (R4/C1, which is what makes the walk immune to the
      * ring growing underneath it). With a ring of ONE the restart is
      * immediate, so holding the key appended the identical block over
      * and over — the owner got three copies of the same four rows, each
-     * closing with `ctrl+r opens the one before it`, a footer naming
+     * closing with `ctrl+o opens the one before it`, a footer naming
      * something that does not exist.
      *
      * The bar is the BOTTOM of the transcript, not "ever shown": once
@@ -1395,7 +1395,7 @@ export class Body {
             }
             // W20: the LIVE task block toggles in place too — the capped
             // form flips to the full list (the "done-collapse expands
-            // under ctrl+r" claim). The SETTLED block is already full —
+            // under ctrl+o" claim). The SETTLED block is already full —
             // no toggle, and its rows carry no affordance, so it never
             // joins #collapsed (the committed /last append is moot).
             if (cell.kind === "checklist" && !cell.done) {
@@ -1462,12 +1462,12 @@ export class Body {
             // R3i phase 4 — THE FOOTER TELLS THE TRUTH ABOUT THIS PATH.
             //
             // The rows come from the rollup's own projection, whose last
-            // row reads `└ ctrl+r collapses` — true where it was written
+            // row reads `└ ctrl+o collapses` — true where it was written
             // (the LIVE toggle, which really does close again) and false
             // here. A committed row is ink: ADR-0046 forbids rewriting
             // history, so nothing about this block can be taken back. The
             // next press opens the NEXT fold, and the row now says so.
-            const closing = rows.length > 0 && /ctrl\+r collapses/.test(rows[rows.length - 1] ?? "");
+            const closing = rows.length > 0 && /ctrl\+o collapses/.test(rows[rows.length - 1] ?? "");
             const body = closing ? rows.slice(0, -1) : rows;
             return {
                 kind: "appended",
@@ -1480,7 +1480,7 @@ export class Body {
                     ...body,
                     // R8a: an in-block note takes the block's indent, not a
                     // second corner — the corner opens the body above it.
-                    `${p.dim}    end of expansion · ctrl+r opens the one before it${p.reset}`,
+                    `${p.dim}    end of expansion · ctrl+o opens the one before it${p.reset}`,
                 ],
             };
         }
@@ -1820,8 +1820,25 @@ export class Body {
      *  now). */
     #statusSource() {
         const panel = this.#panelState?.() ?? null;
+        // DC-38: the panel's STATUS replaces the CLI's painting status —
+        // that half of W21 stands. The HINT does not come with it, because
+        // the panel block already ends in its own affordance row and has
+        // since TUI2-R1.5 ("the affordance — the phase's key hint, ONE
+        // row"). Both sites read `panelAffordance`, neither knew about the
+        // other, and an approval at W≥100 printed the same 48-cell sentence
+        // twice, six rows apart.
+        //
+        // The block's copy is the one to keep, on two grounds. It sits next
+        // to the options it names. And it never disappears: the status row
+        // drops its hint when the left text plus the hint will not fit, so
+        // the duplicate was width-dependent — one copy on an ask (long left
+        // text), two on an approval (`❯ run paused`, twelve cells) — which
+        // is why every fixed-width gate was blind to it. Each flavour's
+        // block carries its own row (approval-panel.ts pushes it for the
+        // approval and the pick, ask-panel.ts for the ask), so nothing is
+        // lost anywhere.
         if (panel !== null)
-            return { status: panelStatusOf(panel), hint: panelAffordanceOf(panel) };
+            return { status: panelStatusOf(panel), hint: undefined };
         // W22: while turns wait in the queue, the right hint shows the
         // count — the chips below carry the lines themselves.
         const queued = this.#queueState?.().length ?? 0;
@@ -2116,7 +2133,7 @@ export class Body {
      * The phases, in the order they are tested:
      *  - an EXPANDED live cell outranks the slot (W15 — "the user asked
      *    for it"): it renders in full, variable height. This is also
-     *    DC-28's cure: mid-stretch `ctrl+r` had a target it toggled and
+     *    DC-28's cure: mid-stretch `ctrl+o` had a target it toggled and
      *    never drew, so the press did nothing visible now and changed a
      *    later expansion's shape;
      *  - CALLS IN FLIGHT: one head row each within the budget, the tail
@@ -2161,8 +2178,8 @@ export class Body {
         //
         // (The approval half is a regression this round caused and its
         // gate caught: the first draft treated a pending approval as a
-        // call in flight, so `⏸ edit x.ts` lost its diff tail and the
-        // `ctrl+r to expand` note with it.)
+        // call in flight, so `❯ edit x.ts` lost its diff tail and the
+        // `ctrl+o to expand` note with it.)
         const owned = tools.filter((i) => toolAt(i).expanded || toolAt(i).state === "approval");
         if (owned.length > 0) {
             // In CELL ORDER, so the frame reads the way the work happened:
@@ -2621,7 +2638,7 @@ export class Body {
             panelSpan = frame.options;
         }
         else {
-            // TUI2-R2 ⑤ (D, candidate 1): the FOCUS — the cell the next ctrl+r
+            // TUI2-R2 ⑤ (D, candidate 1): the FOCUS — the cell the next ctrl+o
             // will act on brightens its own token. The index is derived from
             // the SAME scan expandNext performs (#focusIndex shares its rule
             // by construction), so the marker can never point at a cell the
@@ -2702,24 +2719,37 @@ export class Body {
             // the steady state for the session's whole life. It repairs a
             // killed predecessor straight into the same state. The visible
             // cursor comes back exactly once, in editor.exit().
-            out.push("\x1b[r\x1b[?69l\x1b[?7h\x1b[?25l");
-            // REL-0152-D20 — the mechanism is understood and the obvious fix
-            // is NOT taken here. See the finding.
+            // DC-40 — H line feeds BEFORE the reset, from wherever the shell
+            // left the cursor. The first frame is the full-redraw path and
+            // addresses rows 1..H absolutely; at launch those rows are the
+            // shell's (its prompt, the launch command, the tail of whatever
+            // ran before), and the frame painted over them — gone, not in
+            // the scrollback (REL-0152-D20 established the mechanism; 37/60
+            // shell lines survived on Apple Terminal, every line ON SCREEN
+            // lost). From cursor row r, H feeds move H−r rows and then
+            // scroll exactly r: the shell's rows 1..r enter the scrollback
+            // as CONTENT (at most one blank row — the cursor's own line),
+            // the screen is blank, and the model's assumption "row 0 is the
+            // terminal's row 1" is true by construction. The count does not
+            // depend on r, so nothing is asked of the terminal.
             //
-            // The first frame addresses rows 1..H absolutely and draws over
-            // whatever the terminal was showing. Scrolling a screenful away
-            // first would fix that, and it was built and measured: it pushes
-            // up to H BLANK rows into the scrollback, and TUI2-R2pre's
-            // blank-share gate went from 14/43 to 29/43 — past the "a
-            // healthy session's scrollback is mostly content" invariant that
-            // gate exists to hold. Trading a symptom with a five-second
-            // user-side setting for a broken invariant is a worse deal.
+            // THE ORDER IS THE FIX. `ESC[r` (DECSTBM) HOMES THE CURSOR to
+            // row 1 — VT100 semantics, honoured by Apple Terminal, xterm,
+            // xterm.js and tmux alike. Feeds emitted AFTER the reset start
+            // from row 1, move H−1 rows and scroll ONE: measured on Apple
+            // Terminal, 1/20 shell lines survived with an otherwise
+            // byte-identical frame. Feeds BEFORE the reset: 20/20. The house
+            // emulators did not model the homing and passed the wrong order;
+            // VtScrollback does now, and the DC-40 gate is red on it.
             //
-            // The correct version scrolls only as far as the terminal's
-            // content actually reaches, which needs a cursor-position query
-            // at boot — its own round, with its own risk (this file already
-            // declined a boot-time round-trip once, for racing the editor
-            // for stdin).
+            // The reset still precedes the FRAME (REL-0152-D19: a frame
+            // drawn into an inherited sub-region is the defect); only the
+            // feeds run under whatever region the shell left. A region a
+            // killed foreign program left set makes the feeds scroll that
+            // region alone and the frame paint over the rows outside it —
+            // which is what every frame did before this fix, never worse.
+            out.push("\n".repeat(H));
+            out.push("\x1b[r\x1b[?69l\x1b[?7h\x1b[?25l");
         }
         out.push("\x1b[?7l");
         // REL-0161: ?25l is the STEADY state now, not a frame bracket —
@@ -2852,11 +2882,11 @@ export class Body {
     #commitCell(i, W, ctx) {
         const cell = this.#cells[i];
         const lines = this.#foldOrRollup(cell, i, W, ctx);
-        // W15: a tool cell whose committed rows carried the "ctrl+r"
+        // W15: a tool cell whose committed rows carried the "ctrl+o"
         // affordance joins the expand history — the detection is the
         // renderer's OWN output, so the read's "/last"-only cut note never
         // lands here. TUI2-R1 (A/B): the affordance is no longer only the
-        // renderer cut's "└ … ctrl+r" — the self-naming head suffix and
+        // renderer cut's "└ … ctrl+o" — the self-naming head suffix and
         // the exploration row carry it on the HEAD row, and a promise the
         // key does not answer would be the one thing worse than silence.
         // unshift: the cells commit oldest-first, so the NEWEST cut lands
@@ -2870,13 +2900,13 @@ export class Body {
         // printed bytes.
         //
         // This used to require the rendered rows to contain the literal
-        // "ctrl+r", which made the affordance LOAD-BEARING: retiring the
+        // "ctrl+o", which made the affordance LOAD-BEARING: retiring the
         // printed key (the owner's ruling) would have silently emptied the
         // ring and taken the expand key with it — not a missing hint, a
         // missing feature. A fold head is a fold head because the segment
         // says so; a tool cell is expandable when it is hiding rows.
         const isFoldHead = this.#segmentOf(i)?.headCell === i;
-        const hidesRows = cell.kind === "tool" && lines.some((l) => l.includes("ctrl+r"));
+        const hidesRows = cell.kind === "tool" && lines.some((l) => l.includes("ctrl+o"));
         if (isFoldHead || hidesRows) {
             this.#collapsed.unshift(i);
             // R4a — a new fold resets the walk, so the FIRST press after any

package/dist/editor.js

@@ -83,7 +83,7 @@ export function viewerCommand(text) {
             return "end";
         case "\x1b":
         case "q":
-        case "\x0f": // ctrl+o — the key that opens it also puts it away
+        case "\x12": // ctrl+r — the key that opens it also puts it away
             return "close";
         default:
             return null;
@@ -275,7 +275,7 @@ export class Editor {
     // the CLI's — here it is only "these two keys, pressed together, hand
     // the line over by a different door than Enter's".
     #redirectCbs = [];
-    // W15: the expand-key list (ctrl+r) — the CLI's dispatch decides the
+    // W15: the expand-key list (ctrl+o) — the CLI's dispatch decides the
     // target (a live cell toggles in place; a committed cell appends the
     // expanded block). Mirrors the escape list: multiple listeners can
     // coexist; the editor never interprets the key itself.
@@ -929,7 +929,7 @@ export class Editor {
         // sheet (which any key dismisses) this surface is INTERACTIVE, so
         // the chunk is matched against its own bindings and anything
         // unrecognised is swallowed rather than typed into the composer
-        // behind it. esc closes; ctrl+o closes too, so the key that opens
+        // behind it. esc closes; ctrl+r closes too, so the key that opens
         // it also puts it away.
         if (this.#viewerUp?.() === true) {
             const cmd = viewerCommand(text);
@@ -1407,18 +1407,30 @@ export class Editor {
                 }
                 i += 1;
             }
-            else if (c === "\x12") {
-                // W15: the expand key (ctrl+r) — rides the chain like a
-                // command, the editor just forwards it.
+            else if (c === "\x0f") {
+                // W15: the expand key — rides the chain like a command, the
+                // editor just forwards it.
+                //
+                // DC-41 (owner ruling 2026-09-02): this is ctrl+o now. R5
+                // gave ctrl+o to the viewer because it was free and because
+                // the reference implementation uses it — betting that the
+                // finger cared about the KEY. It does not: the reference's
+                // ctrl+o expands the tool output in front of you, which is
+                // this action, and the owner reported reaching for it and
+                // getting a reader. The gesture and the job are together
+                // again; §7.1 is why kiso's form of it appends rather than
+                // toggling in place.
                 for (const cb of [...this.#expandCbs])
                     cb();
                 i += 1;
             }
-            else if (c === "\x0f" && this.#composerIdle() && this.#chars.length === 0) {
-                // R5 — ctrl+o opens the transcript viewer. Free in kiso, and
-                // the same key the reference implementation uses, so the
-                // muscle memory transfers even though what it opens is not
-                // the same surface. Idle composer only, exactly like `?`:
+            else if (c === "\x12" && this.#composerIdle() && this.#chars.length === 0) {
+                // R5 — the transcript viewer, on ctrl+r since DC-41. The
+                // reference binds ctrl+r to renaming a session, which kiso
+                // has no equivalent of, so nothing a reference user means by
+                // it is displaced; every other free control key in this
+                // dispatch collides with something that surface actually
+                // does. Idle composer only, exactly like `?`:
                 // mid-text it would be a keystroke stolen from the human.
                 this.#viewerSend("open");
                 i += 1;

package/dist/render.js

@@ -72,7 +72,7 @@ export function renderEvent(ev, prevThinking = false, resolvePath = (p) => p) {
         case "permission_requested":
             // round 8: the tool NAME is model text — escaped like everything else.
             return {
-                text: `⏸ ${escapeTerminal(ev.name)} needs approval ${p.dim}${approvalDetail(ev.name, ev.input, resolvePath)}${p.reset} `,
+                text: `❯ ${escapeTerminal(ev.name)} needs approval ${p.dim}${approvalDetail(ev.name, ev.input, resolvePath)}${p.reset} `,
                 newline: false,
                 prompt: true,
             };

package/dist/transcript.js

@@ -38,7 +38,7 @@ import { visibleWidth } from "./components.js";
 /** The gutter every viewer row carries: the cursor mark and its space. */
 export const VIEWER_GUTTER = 3;
 export function viewerInit(entries) {
-    // the cursor starts on the NEWEST fold — the one ctrl+r would have
+    // the cursor starts on the NEWEST fold — the one ctrl+o would have
     // opened, so the two mechanisms agree on their first answer.
     return { cursor: Math.max(0, entries.length - 1), top: 0, open: new Set() };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@vincemakes/kiso-tui",
-	"version": "0.20.3",
+	"version": "0.21.0",
 	"description": "kiso tui — the pure terminal layer (cell renderer, dock, raw editor, diff, palette). Zero runtime dependencies: input is data, output is bytes.",
 	"type": "module",
 	"license": "MIT",
@@ -35,6 +35,6 @@
 	},
 	"homepage": "https://github.com/vincemakes/kiso/tree/main/packages/tui#readme",
 	"dependencies": {
-		"@vincemakes/kiso-tui-cells": "0.20.3"
+		"@vincemakes/kiso-tui-cells": "0.21.0"
 	}
 }