@vincemakes/kiso-tui 0.20.4 → 0.21.1

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,9 +508,9 @@ 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 `,
+        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

@@ -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}`,
                 ],
             };
         }
@@ -1832,7 +1832,7 @@ export class Body {
         // 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
+        // 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
@@ -2133,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
@@ -2178,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:
@@ -2638,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
@@ -2882,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
@@ -2900,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
@@ -3161,7 +3161,7 @@ export class Body {
         if (cell.kind !== "tool" || !isExploreTool(cell.name))
             return false;
         // the run is still growing while NOTHING but explore cells follow —
-        // the turn-less noise cells (permission raws, ⚠ notices) are
+        // the turn-less noise cells (permission raws, notices) are
         // transparent here for the same reason the run scan sees through
         // them: the streaming execution interleaves them between the calls.
         for (let j = i + 1; j < this.#cells.length; j += 1) {
@@ -3270,7 +3270,7 @@ export class Body {
         // split every real burst into fragments. Writes, edits, shells and
         // extension tools still break the run at the first one.
         // the maximal read-only run around i — forward/backward scans over
-        // the cells. The turn-less noise cells (the permission raws, the ⚠
+        // the cells. The turn-less noise cells (the permission raws, the
         // notices) are TRANSPARENT: the streaming execution (loop.ts launch)
         // interleaves them BETWEEN the calls of one burst, so the run must
         // see through them. It never crosses a user/text/thinking cell —

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,
             };
@@ -100,7 +100,7 @@ export function renderEvent(ev, prevThinking = false, resolvePath = (p) => p) {
             return { text: `${p.dim}  [summarized up to seq ${ev.coversToSeq}]${p.reset}\n`, newline: true, prompt: false };
         case "uncertain_pending":
             return {
-                text: `${p.red}⚠ ${escapeTerminal(ev.name)} failed (${ev.executionId}): ${escapeTerminal(ev.error.slice(0, 160))}${p.reset}\n`,
+                text: `${p.red}${escapeTerminal(ev.name)} failed (${ev.executionId}): ${escapeTerminal(ev.error.slice(0, 160))}${p.reset}\n`,
                 newline: true,
                 prompt: false,
             };

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.4",
+	"version": "0.21.1",
 	"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.4"
+		"@vincemakes/kiso-tui-cells": "0.21.1"
 	}
 }