@vincemakes/kiso-tui 0.31.1 → 0.32.0

package/dist/compositor.d.ts

@@ -284,8 +284,25 @@ export declare class Body {
      * reaching into a card whose content is still arriving.
      */
     toggleExpanded(): void;
+    /** §2.4 — the terminal holds someone else's drawing (an external
+     *  editor had it) and the model is the only authority on what should
+     *  be there. The same act as a resize; the same path. */
+    reprint(): void;
     /** DC-50 — the switch itself, for the CLI's affordance text. */
     expandedAll(): boolean;
+    /** §2.3 — ctrl+t: the committed thinking blocks fold, and fold back.
+     *
+     *  DC-50's mechanism exactly: one boolean, then the session is printed
+     *  again, so the blocks ALREADY on screen obey the switch rather than
+     *  only the next ones. Nothing durable moves — the events are
+     *  untouched and `/think` still reaches the last block whole.
+     *
+     *  COMMITTED blocks only. The live `thinking…` placeholder belongs to
+     *  the live region, not to a cell, and an OPEN thinking cell is text
+     *  still arriving; a global "quiet down" has no business reaching into
+     *  either, which is the same exemption `toggleExpanded` states for a
+     *  card that is still growing. */
+    toggleThinking(): void;
     /** W18: the status row's right-aligned hint is part of the status
      *  state — the compacting row passes "esc to cancel" (the affordance
      *  must survive repaints). */

package/dist/compositor.js

@@ -202,6 +202,9 @@ export class Body {
     #lastTool = null;
     #pendingCalls = new Map();
     #pipeBuf = ""; // the passthrough's thinking buffer
+    // §2.3 — the ctrl+t switch. A block that completes AFTER the press
+    // inherits it, so the session stays one way up rather than mixing.
+    #thinkingFolded = false;
     /** TUI2-MD ⑤ — the markdown scanner of the message currently
      *  streaming, and the cell index its first block landed at. Null
      *  between messages: the scanner's life is one assistant message. */
@@ -390,6 +393,9 @@ export class Body {
         const last = this.#cells[this.#cells.length - 1];
         if (last !== undefined && last.kind === "thinking" && !last.done) {
             last.done = true;
+            // §2.3: a block that SETTLES after the switch was thrown is
+            // folded like the rest — the session stays one way up.
+            last.folded = this.#thinkingFolded;
             this.#lastThinking = last.text;
             if (!this.#isActive())
                 this.#write(foldThinking(last.text));
@@ -1303,11 +1309,12 @@ export class Body {
     /**
      * R14 — ERASE THE TERMINAL AND PRINT THE SESSION AGAIN.
      *
-     * Two callers: a settled resize, and DC-50's ctrl+o. They are the
-     * same act — the rendering the terminal holds is wrong (wrong
-     * geometry, or wrong expansion state) and the model is the only
-     * authority on what it should be — so they share the path rather
-     * than growing two.
+     * Four callers now: a settled resize, DC-50's ctrl+o, §2.3's ctrl+t,
+     * and §2.4's return from an external editor. They are the same act —
+     * the rendering the terminal holds is wrong (wrong geometry, wrong
+     * expansion state, wrong fold, or another program drew over it) and
+     * the model is the only authority on what it should be — so they
+     * share the path rather than growing four.
      */
     #reprint() {
         const H = this.#opts.height();
@@ -1367,10 +1374,36 @@ export class Body {
         }
         this.#reprint();
     }
+    /** §2.4 — the terminal holds someone else's drawing (an external
+     *  editor had it) and the model is the only authority on what should
+     *  be there. The same act as a resize; the same path. */
+    reprint() {
+        this.#reprint();
+    }
     /** DC-50 — the switch itself, for the CLI's affordance text. */
     expandedAll() {
         return this.#expandedAll;
     }
+    /** §2.3 — ctrl+t: the committed thinking blocks fold, and fold back.
+     *
+     *  DC-50's mechanism exactly: one boolean, then the session is printed
+     *  again, so the blocks ALREADY on screen obey the switch rather than
+     *  only the next ones. Nothing durable moves — the events are
+     *  untouched and `/think` still reaches the last block whole.
+     *
+     *  COMMITTED blocks only. The live `thinking…` placeholder belongs to
+     *  the live region, not to a cell, and an OPEN thinking cell is text
+     *  still arriving; a global "quiet down" has no business reaching into
+     *  either, which is the same exemption `toggleExpanded` states for a
+     *  card that is still growing. */
+    toggleThinking() {
+        this.#thinkingFolded = !this.#thinkingFolded;
+        for (const cell of this.#cells) {
+            if (cell.kind === "thinking" && cell.done)
+                cell.folded = this.#thinkingFolded;
+        }
+        this.#reprint();
+    }
     /** W18: the status row's right-aligned hint is part of the status
      *  state — the compacting row passes "esc to cancel" (the affordance
      *  must survive repaints). */

package/dist/editor.d.ts

@@ -86,6 +86,26 @@ export declare class Editor {
     /** E1 §3 — the copy key (ctrl+x). */
     onCopy(cb: () => void): void;
     onExpand(cb: () => void): void;
+    /** §2.3: the thinking key (ctrl+t) — the chain-level action, wired
+     *  exactly like ctrl+o because it is the same kind of thing: a switch
+     *  the compositor throws, never an interpretation the editor makes. */
+    onThink(cb: () => void): void;
+    /** §2.4: the external-editor key (ctrl+g). */
+    onEditor(cb: () => void): void;
+    /** §2.4 — hand the terminal to an external program, and take it back.
+     *
+     *  `run` receives the composer's text and returns what should replace
+     *  it, or null to leave it alone (no editor configured, the editor
+     *  failed, nothing changed). The SPAWN is the caller's: this package is
+     *  pure terminal — input is data, output is bytes, zero runtime deps —
+     *  so what lives here is the handover and nothing else.
+     *
+     *  NOT `exit()` / `enter()`. Those are the session's boundary: exit()
+     *  also resolves the closed promise, which tells the layer above that
+     *  the session is over. Suspending is a different act with the same
+     *  terminal moves, and conflating them would end the session every time
+     *  someone opened their editor. */
+    externalEdit(run: (text: string) => string | null): void;
     /** KC2 §2: the redirect chain — the gesture hands the buffer's text
      *  over while the run is told to stop. Mirrors onEscape (a list, so
      *  listeners can coexist); the line arrives already gone from the
@@ -168,6 +188,20 @@ export declare class Editor {
     panelState(): PanelState | null;
     enter(): void;
     exit(): void;
+    /** OR-11 (a) — the lead the composer's row is DRAWN with, which is not
+     *  always the brick. The CLI binds the compositor's input lead as `""`
+     *  (a prompt character is a third thing saying "input lives here", and
+     *  it cost the row a column), while the editor measured against PROMPT
+     *  — so the editor believed the row two columns narrower than the
+     *  compositor drew it, and W23's "the two width authorities can never
+     *  disagree" was off by two.
+     *
+     *  A PROVIDER, not a string, because both renderers are live in the
+     *  same process: the dock draws the row when it is active and
+     *  `selfRender` draws it when it is not, and they lead it differently.
+     *  Whoever binds the row answers for whichever is drawing. The default
+     *  is the brick, which is what `selfRender` has always drawn. */
+    setInputLead(lead: () => string): void;
     /** The row's own render when the dock is inactive (a TTY without a
      *  real size): \r + clear + blue brick prompt + visible + cursor
      *  column. */

package/dist/editor.js

@@ -22,7 +22,7 @@
  * source funnels through the ONE normalizer in feed() (§3).
  */
 var _a;
-import { charWidth, displayWidth, leadWidth, widthOf } from "./width.js";
+import { breakable, charWidth, displayWidth, leadWidth, widthOf } from "./width.js";
 // the width primitives moved to width.ts (W1, the single width
 // authority) — re-exported so the editor's public surface is unchanged.
 export { charWidth, displayWidth, widthOf };
@@ -146,8 +146,16 @@ const N_MAX = 6;
  *  payload for someone else, and holding it is how the editor goes
  *  deaf. */
 const OSC_MAX = 1024;
-/** The dim "…" — the ONE truncation mark: the horizontal scroll's
- *  prefix (unchanged) and the viewport's hidden-rows markers. */
+/** TMUX-F1 ①: a CSI parameter string longer than this with no final byte
+ *  is not a sequence any terminal sends; it is dropped rather than held, so
+ *  a runaway can never park the editor. */
+const CSI_MAX = 64;
+/** TMUX-F1 ②: identical arrow sequences in ONE read at or past this count
+ *  are a wheel notch, not a hand — treated as one press. */
+const ARROW_BURST = 3;
+/** The dim "…" — the ONE truncation mark. OR-11 retired its other use
+ *  (the horizontal scroll's prefix) with the scroll itself; what is left
+ *  is the viewport's hidden-rows markers, above and below. */
 /** R3: built per call from the palette — `dim` is an absolute grey once
  *  the ground is known, so a frozen SGR 2 here would be the one span
  *  that ignores it. */
@@ -198,11 +206,10 @@ const shown = (chars) => {
 export class Editor {
     #chars = [];
     #cursor = 0;
-    #scroll = 0; // chars scrolled off the left of the CURSOR'S LINE (width-based reflow; KC1: line-local, so a single-line buffer is unchanged)
     // KC1 §2 — the ONE new ephemeral field: the desired column for the
     // ↑/↓ walk (a long line's column 20 → a short line clamps to 5 → the
     // next long line RETURNS to 20). Set on the first vertical move,
-    // kept across consecutive ones, reset by any horizontal move, insert
+    // kept across consecutive ones, reset by any left/right move, insert
     // or delete. Never stashed — it is a walk's state, not the buffer's.
     #verticalGoalCol = null;
     #questionCb = null;
@@ -322,6 +329,8 @@ export class Editor {
     // expanded block). Mirrors the escape list: multiple listeners can
     // coexist; the editor never interprets the key itself.
     #expandCbs = [];
+    #thinkCbs = [];
+    #editorCbs = [];
     /** E1 §3 — ctrl+x. Same shape as the expand key: the editor owns the
      *  KEY, the CLI owns what it means. */
     #copyCbs = [];
@@ -455,6 +464,57 @@ export class Editor {
     onExpand(cb) {
         this.#expandCbs.push(cb);
     }
+    /** §2.3: the thinking key (ctrl+t) — the chain-level action, wired
+     *  exactly like ctrl+o because it is the same kind of thing: a switch
+     *  the compositor throws, never an interpretation the editor makes. */
+    onThink(cb) {
+        this.#thinkCbs.push(cb);
+    }
+    /** §2.4: the external-editor key (ctrl+g). */
+    onEditor(cb) {
+        this.#editorCbs.push(cb);
+    }
+    /** §2.4 — hand the terminal to an external program, and take it back.
+     *
+     *  `run` receives the composer's text and returns what should replace
+     *  it, or null to leave it alone (no editor configured, the editor
+     *  failed, nothing changed). The SPAWN is the caller's: this package is
+     *  pure terminal — input is data, output is bytes, zero runtime deps —
+     *  so what lives here is the handover and nothing else.
+     *
+     *  NOT `exit()` / `enter()`. Those are the session's boundary: exit()
+     *  also resolves the closed promise, which tells the layer above that
+     *  the session is over. Suspending is a different act with the same
+     *  terminal moves, and conflating them would end the session every time
+     *  someone opened their editor. */
+    externalEdit(run) {
+        const before = this.line();
+        let next = null;
+        process.stdin.off("data", this.#onData);
+        process.stdout.write(MOUSE_OFF);
+        process.stdout.write("\x1b[?2004l"); // bracketed paste OFF — the child's, not ours
+        process.stdout.write("\x1b[?25h"); // and it needs a cursor to draw
+        process.stdin.setRawMode(false);
+        try {
+            next = run(before);
+        }
+        finally {
+            // the handover comes back whatever the child did, including
+            // throwing: a terminal left in the child's mode is unusable and
+            // the human has no way to ask for it back.
+            process.stdin.setRawMode(true);
+            process.stdout.write(MOUSE_OFF);
+            this.#mouseOn = false;
+            process.stdout.write("\x1b[?2004h");
+            process.stdin.on("data", this.#onData);
+        }
+        if (next !== null && next !== before) {
+            this.#chars = [...next].map((ch) => ch.codePointAt(0));
+            this.#cursor = this.#chars.length;
+            this.#reflow();
+        }
+        this.#onRender();
+    }
     /** KC2 §2: the redirect chain — the gesture hands the buffer's text
      *  over while the run is told to stop. Mirrors onEscape (a list, so
      *  listeners can coexist); the line arrives already gone from the
@@ -509,7 +569,6 @@ export class Editor {
         this.#redoStack.length = 0;
         this.#chars = [];
         this.#cursor = 0;
-        this.#scroll = 0;
         this.#verticalGoalCol = null;
         this.#onRender();
     }
@@ -539,12 +598,129 @@ export class Editor {
         }
         return bounds.length - 1;
     }
-    /** The cursor's OWN line — the unit of the horizontal scroll and of
-     *  the line-local A/E/U/K (A3). */
+    /** The cursor's OWN LOGICAL line — the unit of the line-local A/E/U/K
+     *  (A3) and of the `@` token scan. The visual rows a long line folds
+     *  into are `#visualRows`; these two answer different questions and
+     *  OR-11 kept them apart deliberately. */
     #cursorBounds() {
         const bounds = this.#lineBounds();
         return bounds[this.#cursorLine(bounds)];
     }
+    /** OR-11 — the row's width budget: the SAME number the compositor
+     *  gives the row (W23's one formula), against the lead that is
+     *  actually drawn. The fold and the cursor math both ask here. */
+    #budget() {
+        const W = (process.stdout.columns ?? 0) || 80;
+        const ps = this.#panelInput.state();
+        const lead = ps !== null ? panelLead(ps.view, ps.phase, ps.cursor, ps.ask) : this.#inputLead();
+        return Math.max(1, W - leadWidth(lead) - 1);
+    }
+    /** The `[Pasted text #N +M lines]` tokens inside [start, end).
+     *  A capsule is ONE thing on screen and one thing to the cursor, so a
+     *  fold never lands inside it: it is cut when drawn if it is wider
+     *  than the row, and it is never split into two. */
+    #capsules(start, end) {
+        const text = String.fromCodePoint(...this.#chars.slice(start, end));
+        const units = [];
+        // the regex indexes UTF-16 units; the buffer is code points
+        let cp = start;
+        for (const ch of text) {
+            units.push(cp);
+            cp += 1;
+            if (ch.length === 2)
+                units.push(cp - 1); // a surrogate pair is one code point
+        }
+        units.push(end);
+        const out = [];
+        for (const m of text.matchAll(_a.#CAPSULE)) {
+            const i = m.index ?? 0;
+            out.push({ start: units[i] ?? start, end: units[i + m[0].length] ?? end });
+        }
+        return out;
+    }
+    /** OR-11 — one logical line's VISUAL rows, as [start, end) into
+     *  #chars. The rows TILE the line exactly: no character is dropped and
+     *  none is shown twice, which is what lets the cursor map back.
+     *
+     *  The break, in order:
+     *   1. everything fits — one row;
+     *   2. the cut falls on a CJK boundary (either side breakable) — take
+     *      it, because looking further back for a space would leave the
+     *      row half empty for text that breaks anywhere;
+     *   3. otherwise the last whitespace RUN that fits: the whole run ends
+     *      the row it is on, so a continuation row never begins with a
+     *      space — unless the run itself straddles the budget, where ①
+     *      wins and the leftover spaces open the next row (OR11-F1);
+     *   4. otherwise a hard break at the last code point that fits — never
+     *      inside a wide character, because `#indexAtWidth` is that walk. */
+    #foldLine(start, end, budget) {
+        const rows = [];
+        const atoms = this.#capsules(start, end);
+        let from = start;
+        while (from < end) {
+            const fits = this.#fitsWithin(from, end, budget);
+            if (fits >= end)
+                break;
+            let cut = fits;
+            const atom = atoms.find((a) => a.start < cut && cut < a.end);
+            if (atom !== undefined) {
+                // the capsule keeps its own row: start one before it when
+                // there is text ahead of it, otherwise let it run whole.
+                cut = atom.start > from ? atom.start : atom.end;
+            }
+            else if (!breakable(this.#chars[fits] ?? 0) && !breakable(this.#chars[fits - 1] ?? 0)) {
+                let w = -1;
+                for (let i = cut - 1; i > from; i -= 1) {
+                    if (this.#chars[i] === SPACE) {
+                        w = i;
+                        break;
+                    }
+                }
+                if (w >= 0) {
+                    while (this.#chars[w + 1] === SPACE && w + 1 < end)
+                        w += 1;
+                    // OR11-F1: capped at `fits`. Ending the row with the WHOLE
+                    // run is what keeps a continuation row from opening with a
+                    // space — but that is a preference, and invariant ① is
+                    // not: every row kiso produces measures ≤ W, because
+                    // autowrap is off and the terminal will not save it. A run
+                    // STRADDLING the boundary was carrying the row past the
+                    // budget (34 letters + 12 spaces + 20 letters at width 40
+                    // measured 46 against 39). When the run itself does not
+                    // fit, the row stops at the budget and the leftover spaces
+                    // open the next row.
+                    cut = Math.min(w + 1, fits);
+                }
+            }
+            if (cut <= from || cut >= end)
+                break; // no progress, or the rest fits
+            rows.push({ start: from, end: cut });
+            from = cut;
+        }
+        rows.push({ start: from, end });
+        return rows;
+    }
+    /** OR-11 — every VISUAL row of the buffer, in order. ONE fold, built
+     *  once per read; `dockState`, the cursor mapping and the ↑/↓ walk all
+     *  READ this table rather than folding again. */
+    #visualRows() {
+        const budget = this.#budget();
+        const out = [];
+        for (const b of this.#lineBounds())
+            out.push(...this.#foldLine(b.start, b.end, budget));
+        return out;
+    }
+    /** The visual row the cursor is on: the LAST row it can belong to. At
+     *  a fold boundary that is the row the next character would go on; at
+     *  a newline it is the row the newline closes, never the next line. */
+    #cursorVisualRow(rows) {
+        let hit = 0;
+        for (let i = 0; i < rows.length; i += 1) {
+            if (rows[i].start <= this.#cursor && this.#cursor <= rows[i].end)
+                hit = i;
+        }
+        return hit;
+    }
     /** KC1 §5 — N_visible = min(lineCount, N_MAX, max(1, H − 3 − the
      *  menu/queue bands)). The height clamp guarantees legal geometry
      *  down to the compositor's enter gate; the compositor re-applies the
@@ -568,27 +744,27 @@ export class Editor {
      *  stash / restore / clear / submit path has new state to carry. A
      *  dim "…" marks whichever edge hides rows. */
     dockState() {
-        const bounds = this.#lineBounds();
-        const cursorLine = this.#cursorLine(bounds);
-        const n = this.#visibleRows(bounds.length);
-        const first = Math.max(0, Math.min(cursorLine - n + 1, bounds.length - n));
+        // OR-11: VISUAL rows. One logical line may be several of them, and
+        // the window, the markers and the cursor all count them the same
+        // way — N_MAX has always been about how tall the box may get, and
+        // a folded line is as tall as a pasted one.
+        const rows = this.#visualRows();
+        const cursorLine = this.#cursorVisualRow(rows);
+        const n = this.#visibleRows(rows.length);
+        const first = Math.max(0, Math.min(cursorLine - n + 1, rows.length - n));
         const lines = [];
         for (let i = first; i < first + n; i += 1) {
-            const b = bounds[i];
-            // the cursor's own row carries the horizontal scroll (and its
-            // "…"); the other rows render whole and cap at the frame's wall
-            const from = i === cursorLine ? b.start + this.#scroll : b.start;
-            const scrolled = i === cursorLine && this.#scroll > 0 ? ellipsis() : "";
+            const b = rows[i];
             const above = i === first && first > 0 ? ellipsis() : "";
-            const below = i === first + n - 1 && first + n < bounds.length ? ellipsis() : "";
-            lines.push(`${above}${scrolled}${shown(this.#chars.slice(from, b.end))}${below}`);
+            const below = i === first + n - 1 && first + n < rows.length ? ellipsis() : "";
+            lines.push(`${above}${shown(this.#chars.slice(b.start, b.end))}${below}`);
         }
         const cursorRow = cursorLine - first;
         // the window trails the cursor, so the hidden-above marker can only
         // share the cursor's row in the degenerate one-row window (a tiny
-        // terminal) — where it shifts the column like the scroll's does
-        const marks = (cursorRow === 0 && first > 0 ? 1 : 0) + (this.#scroll > 0 ? 1 : 0);
-        const cursorCol = marks + widthOf(this.#chars.slice(bounds[cursorLine].start + this.#scroll, this.#cursor));
+        // terminal) — where it shifts the column by its one cell
+        const marks = cursorRow === 0 && first > 0 ? 1 : 0;
+        const cursorCol = marks + widthOf(this.#chars.slice(rows[cursorLine].start, this.#cursor));
         return { line: lines[cursorRow], cursor: cursorCol, lines, cursorRow, cursorCol };
     }
     /** v3 §04: the menu's visible state for the dock — null when closed. */
@@ -852,6 +1028,24 @@ export class Editor {
     #syncMouse() {
         this.#setMouse(this.#panelInput.up() || this.#pickInput.up() || this.#atUp());
     }
+    /** OR-11 (a) — the lead the composer's row is DRAWN with, which is not
+     *  always the brick. The CLI binds the compositor's input lead as `""`
+     *  (a prompt character is a third thing saying "input lives here", and
+     *  it cost the row a column), while the editor measured against PROMPT
+     *  — so the editor believed the row two columns narrower than the
+     *  compositor drew it, and W23's "the two width authorities can never
+     *  disagree" was off by two.
+     *
+     *  A PROVIDER, not a string, because both renderers are live in the
+     *  same process: the dock draws the row when it is active and
+     *  `selfRender` draws it when it is not, and they lead it differently.
+     *  Whoever binds the row answers for whichever is drawing. The default
+     *  is the brick, which is what `selfRender` has always drawn. */
+    setInputLead(lead) {
+        this.#inputLead = lead;
+        this.#reflow();
+    }
+    #inputLead = () => PROMPT;
     /** The row's own render when the dock is inactive (a TTY without a
      *  real size): \r + clear + blue brick prompt + visible + cursor
      *  column. */
@@ -862,7 +1056,7 @@ export class Editor {
         // W21: the panel's lead owns the row while up (the brick returns
         // when the panel closes).
         const panel = this.#panelInput.state();
-        const lead = panel !== null ? panelLead(panel.view, panel.phase, panel.cursor, panel.ask) : `${p.bold}${PROMPT}${p.reset}`;
+        const lead = panel !== null ? panelLead(panel.view, panel.phase, panel.cursor, panel.ask) : `${p.bold}${this.#inputLead()}${p.reset}`;
         // W23: the ONE width authority — leadWidth(lead), the ANSI-stripped
         // visible width (the styled panel lead / the styled brick measure
         // the same as their plain text — a lead can never measure
@@ -952,13 +1146,47 @@ export class Editor {
                     // never complete. The editor went deaf. It never happened
                     // because nothing ever enabled reporting — which is exactly
                     // the kind of latent break turning a feature on discovers.
-                    const m = rest.match(/^\[([0-9;?<]*)([A-Za-z~])/);
+                    //
+                    // TMUX-F1 ①: the whole CSI grammar — parameters (the private
+                    // markers `?` `<` `>` `=` included), intermediates (0x20–0x2F),
+                    // a final (0x40–0x7E). The class above could not END a sequence
+                    // carrying an intermediate — tmux answers DECRQM with
+                    // `ESC[?69;0$y` — so it was parked as "incomplete" and every
+                    // later keystroke joined a sequence that never completed: the
+                    // editor went deaf for the session. A sequence with
+                    // intermediates is a reply kiso did not ask for; it is skipped
+                    // whole. A parameter string past CSI_MAX with no final is
+                    // dropped, not held.
+                    const m = rest.match(/^\[([0-9;?<>=]*)([ -/]*)([@-~])/);
                     if (m === null) {
+                        const junk = /^\[[0-9;?<>=]*[ -/]*/.exec(rest)[0];
+                        if (junk.length > CSI_MAX) {
+                            i += 1 + junk.length; // the introducer and its runaway parameters go; parsing continues
+                            continue;
+                        }
                         this.#pending = text.slice(i); // incomplete CSI — wait for more
                         break;
                     }
-                    this.#csi(m[1], m[2]);
-                    i += m[0].length + 1;
+                    const seqLen = m[0].length + 1;
+                    if (m[2] !== "") {
+                        i += seqLen; // intermediates: a report kiso did not ask for — skipped whole
+                        continue;
+                    }
+                    // TMUX-F1 ②: a BURST of identical arrows in ONE read is a wheel,
+                    // not a hand. Apple Terminal turns wheel and trackpad scrolling
+                    // into arrow keys for an alternate-screen app (tmux's client is
+                    // one) — three or more per notch in a single write, which a
+                    // person never produces in one read — and each one walked the
+                    // history. The burst is one press (owner ruling 2026-09-10, c);
+                    // separate reads stay separate presses.
+                    const seq = `\x1b${m[0]}`;
+                    let run = 1;
+                    if (m[1] === "" && "ABCD".includes(m[3])) {
+                        while (text.startsWith(seq, i + run * seq.length))
+                            run += 1;
+                    }
+                    this.#csi(m[1], m[3], run);
+                    i += run * seqLen;
                 }
                 else if (rest.startsWith("]")) {
                     // DC-7: an OSC is a message FROM the terminal — a background
@@ -1041,7 +1269,6 @@ export class Editor {
                         this.#checkpoint(); // UD-1
                     this.#chars = [];
                     this.#cursor = 0;
-                    this.#scroll = 0;
                     this.#verticalGoalCol = null;
                     this.#refreshMenu();
                     i += 1;
@@ -1209,6 +1436,33 @@ export class Editor {
                     cb();
                 i += 1;
             }
+            else if (c === "\x14") {
+                // §2.3 — ctrl+t folds the committed thinking blocks, and
+                // folds them back. `\x14` was unbound across the tree
+                // (checked before the round), and it is the key the
+                // reference implementation uses for this same gesture, so a
+                // reader arriving from it is not retrained.
+                //
+                // Forwarded, not interpreted: the switch is the
+                // compositor's, exactly as ctrl+o's is.
+                for (const cb of [...this.#thinkCbs])
+                    cb();
+                i += 1;
+            }
+            else if (c === "\x07") {
+                // §2.4 — ctrl+g opens $VISUAL / $EDITOR on the composer.
+                //
+                // 0x07 is BEL, which is also the terminator a terminal puts
+                // on an OSC reply (DC-7). This branch is only reached by a
+                // BARE 0x07: the OSC arm above consumes its own terminator,
+                // so the terminal's answer never arrives here. One byte, two
+                // meanings, told apart by what precedes it — and there is a
+                // gate for exactly that, because "should not reach here" is
+                // not something to take on trust.
+                for (const cb of [...this.#editorCbs])
+                    cb();
+                i += 1;
+            }
             else if (c === "\x18" && this.#composerIdle()) {
                 // E1 §3 — ctrl+x copies the last answer. `\x18` was unbound
                 // across the whole tree (checked before the round started),
@@ -1323,7 +1577,22 @@ export class Editor {
     bindPanelRows(fn) {
         this.#panelRows = fn;
     }
-    #csi(params, final) {
+    /** TMUX-F1 ②: `run` identical arrow sequences arrived in ONE read. Every
+     *  surface but one gets every press — a wheel over the transcript viewer,
+     *  a panel, a multi-row draft scrolls, as a wheel should. The HISTORY
+     *  walk is the one that replaces the draft's content, and there a burst
+     *  (ARROW_BURST or more in one read — a wheel notch, never a hand) is one
+     *  step. The first press decides which branch it was, so the gate is not
+     *  written twice. */
+    #csi(params, final, run = 1) {
+        const took = this.#csiOnce(params, final);
+        if (took === "history" && run >= ARROW_BURST)
+            return;
+        for (let k = 1; k < run; k += 1)
+            this.#csiOnce(params, final);
+    }
+    #csiOnce(params, final) {
+        let took;
         // TUI2-R3v2 ②: an SGR 1006 report — `\x1b[<b;col;rowM` (press) or
         // `...m` (release). It is routed FIRST because a `<` parameter is
         // never anything else, and because a mouse byte must never fall
@@ -1434,11 +1703,18 @@ export class Editor {
                 const view = this.#atView();
                 this.#atSel = final === "A" ? Math.max(0, view.selected - 1) : Math.min(view.matches.length - 1, view.selected + 1);
             }
-            else if (this.#chars.includes(NEWLINE)) {
-                // KC1 §4: a MULTI-LINE buffer's ↑↓ walk its lines. The
-                // history and the queue-pop below stay gated on an EMPTY
-                // buffer — a multi-line buffer is never empty, so the
-                // precedence can only ever add, never take.
+            else if (this.#visualRows().length > 1) {
+                // KC1 §4, restated by OR-11 over VISUAL rows: a buffer that
+                // occupies more than one row has its ↑↓ walk them. It used
+                // to read `#chars.includes(NEWLINE)`, which was the same
+                // question while one logical line was always one row; a
+                // folded line is several now, and the walk is about what the
+                // eye sees.
+                //
+                // The history and the queue-pop below stay gated on an EMPTY
+                // buffer, and an empty buffer is exactly one row — so the
+                // precedence can only ever add, never take, which is what
+                // T-E4 pins.
                 this.#verticalMove(final === "A" ? -1 : 1);
             }
             else if (final === "A" && this.#queuePop !== null && (this.#queuePopMode || this.line() === "") && this.#queueState().length > 0) {
@@ -1452,6 +1728,7 @@ export class Editor {
             }
             else if (this.#historyIdx !== null || this.line() === "") {
                 this.#historyMove(final === "A" ? -1 : 1);
+                took = "history"; // the repaint below is still owed — an early return here left the recall unpainted (r3a red)
             }
             this.#onRender();
         }
@@ -1468,22 +1745,31 @@ export class Editor {
                 this.#move(1);
         }
         else if (final === "H") {
+            // OR-11 (b): and REPAINT. Ctrl+A and Ctrl+E render; their arrow
+            // spellings reflowed and stopped there, so the caret stayed
+            // where it had been until some later key happened to draw. A
+            // gesture that moves the cursor is a gesture that shows it.
             this.#cursor = this.#cursorBounds().start; // A3: Home follows Ctrl+A — line-local
             this.#reflow();
+            this.#onRender();
         }
         else if (final === "F") {
             this.#cursor = this.#cursorBounds().end; // A3: End follows Ctrl+E — line-local
             this.#reflow();
+            this.#onRender();
         }
+        return took;
     }
     /** KC1 §4 — the ↑/↓ walk. The cursor keeps its DESIRED column across
      *  a short line: the goal is captured at the FIRST vertical move and
-     *  survives consecutive ones (#reflow clears it, so any horizontal
+     *  survives consecutive ones (#reflow clears it, so any left/right
      *  move / insert / delete ends the walk); a step past either end
      *  stays put. */
     #verticalMove(delta) {
-        const bounds = this.#lineBounds();
-        const cur = this.#cursorLine(bounds);
+        // OR-11: VISUAL rows — one long logical line is several of them, and
+        // ↑/↓ walk what the eye sees. The goal column is unchanged.
+        const bounds = this.#visualRows();
+        const cur = this.#cursorVisualRow(bounds);
         const next = cur + delta;
         if (next < 0 || next >= bounds.length)
             return;
@@ -1508,16 +1794,14 @@ export class Editor {
             clear: () => {
                 this.#chars = [];
                 this.#cursor = 0;
-                this.#scroll = 0;
                 this.#verticalGoalCol = null;
             },
             insert: (cp) => this.#insert(cp),
             newline: () => this.#insert(NEWLINE),
-            stash: () => ({ chars: this.#chars, cursor: this.#cursor, scroll: this.#scroll }),
+            stash: () => ({ chars: this.#chars, cursor: this.#cursor }),
             restore: (st) => {
                 this.#chars = [...st.chars];
                 this.#cursor = st.cursor;
-                this.#scroll = st.scroll;
             },
             reflow: () => this.#reflow(),
             render: () => this.#onRender(),
@@ -1615,7 +1899,6 @@ export class Editor {
     #restoreSnap(s) {
         this.#chars = [...s.chars];
         this.#cursor = s.cursor;
-        this.#scroll = 0;
         this.#verticalGoalCol = null;
         this.#reflow();
         this.#refreshMenu();
@@ -1778,8 +2061,8 @@ export class Editor {
         this.#cursor = this.#wordEdge(this.#cursor, dir);
         this.#reflow();
     }
-    /** KC1/KC2 — the buffer LEAVES: the flat chars, the cursor, the
-     *  horizontal scroll, the ↑/↓ goal, the menu and the pop-walk all
+    /** KC1/KC2 — the buffer LEAVES: the flat chars, the cursor, the ↑/↓
+     *  goal, the menu and the pop-walk all
      *  reset together (W22: a departing line ends the pop-walk, so the
      *  next esc at rest interrupts again). Shared by the submit and the
      *  redirect — the two doors a line can leave by. */
@@ -1892,7 +2175,6 @@ export class Editor {
         this.#redoStack.length = 0;
         this.#chars = [];
         this.#cursor = 0;
-        this.#scroll = 0;
         this.#verticalGoalCol = null;
         this.#menuOpen = false;
         this.#menuSel = 0;
@@ -2061,50 +2343,41 @@ export class Editor {
             this.#checkpoint(); // UD-1: a mid-walk edit is recoverable
         this.#chars = [...line].map((ch) => ch.codePointAt(0));
         this.#cursor = this.#chars.length;
-        this.#scroll = 0;
         this.#verticalGoalCol = null;
         this.#onRender();
     }
-    // ---- width-based horizontal scroll ----
+    // ---- the width walks ----
     #reflow() {
         // KC1: any key that reaches the reflow ended a ↑/↓ walk (the walk
         // itself re-arms the goal right after its own reflow call).
         this.#verticalGoalCol = null;
-        const W = (process.stdout.columns ?? 0) || 80; // degenerate 0 falls back to 80
-        // W21: the panel's phase lead owns the input row while up — the
-        // line's max width follows the lead (the rule/amend leads are
-        // wider than the brick).
-        // W23: the ONE width authority — leadWidth(lead) — the cap follows
-        // the lead the editor itself renders (the panel lead when the panel
-        // owns the keys, the brick otherwise): maxW = W − walls − lead.
-        const ps = this.#panelInput.state();
-        const lead = ps !== null ? panelLead(ps.view, ps.phase, ps.cursor, ps.ask) : PROMPT;
-        const leadW = leadWidth(lead);
-        // DC-17: ONE column, not four. W6's box took 2+2 and this kept
-        // reserving them after law 1.1 retired it — so the horizontal
-        // scroll fired three columns early, the cursor could never reach
-        // the row's last three cells, and the two width authorities the
-        // W23 contract says must never disagree disagreed by 3. The
-        // compositor's walk caps at W−1 (the drawn cursor's own cell);
-        // this is the same one column, on the same row.
-        const maxW = Math.max(1, W - leadW - 1);
-        // KC1: the scroll is the CURSOR LINE's own offset — a single-line
-        // buffer's line starts at 0, so the math is today's exactly. The
-        // clamp catches a walk onto a line SHORTER than the old offset.
-        const { start, end } = this.#cursorBounds();
-        this.#scroll = Math.min(this.#scroll, end - start);
-        const curCol = widthOf(this.#chars.slice(start, this.#cursor));
-        const scrolledW = widthOf(this.#chars.slice(start, start + this.#scroll));
-        if (curCol < scrolledW) {
-            this.#scroll = this.#indexAtWidth(start, end, curCol) - start;
-        }
-        else if (curCol >= scrolledW + maxW) {
-            this.#scroll = this.#indexAtWidth(start, end, Math.max(0, curCol - maxW + 1)) - start;
-        }
+        // OR-11 — DECLARED SUPERSESSION of ADR-0039 Amendment 2's horizontal
+        // scrolling. There is nothing to reflow horizontally any more: a
+        // long line FOLDS (see #foldLine), so every character is on screen
+        // and the row offset that used to be kept here is gone with it.
+        // What survives is the goal-column reset above, which every key
+        // that is not a ↑/↓ walk still owes.
     }
     /** The first index in [start, end] whose display width from `start`
      *  reaches `target` — the width-based column walk (a wide char never
      *  splits: the index lands BEFORE it). */
+    /** OR-11 — the end of the WIDEST PREFIX of [start, end) that fits in
+     *  `budget` columns. Distinct from `#indexAtWidth`, which answers the
+     *  scroll's question ("the first index AT or past this width") and is
+     *  one character too generous for a fold: 20 wide characters are 40
+     *  columns and do not fit in 39. The walk stops BEFORE a character
+     *  that would overflow, so a wide character is never split — the same
+     *  `w + cw > limit` the compositor's own row cut uses. */
+    #fitsWithin(start, end, budget) {
+        let w = 0;
+        for (let i = start; i < end; i += 1) {
+            const cw = charWidth(this.#chars[i]);
+            if (w + cw > budget)
+                return i;
+            w += cw;
+        }
+        return end;
+    }
     #indexAtWidth(start, end, target) {
         let w = 0;
         for (let i = start; i < end; i += 1) {

package/dist/panel-input.d.ts

@@ -17,11 +17,12 @@
  * goes through the host.
  */
 import { type PanelState, type PanelVerdict, type PanelView, type SaferAnswer } from "./approval-panel.js";
-/** The composer's buffer, as a band puts it aside and gets it back. */
+/** The composer's buffer, as a band puts it aside and gets it back.
+ *  OR-11 dropped `scroll`: a long line folds now, so there is no
+ *  horizontal offset left to put aside. */
 export interface BufferStash {
     readonly chars: number[];
     readonly cursor: number;
-    readonly scroll: number;
 }
 /** The composer, as a band controller is allowed to see it. Every
  *  entry is something a panel or the session picker does to the
@@ -31,7 +32,7 @@ export interface BandHost {
     line(): string;
     /** The buffer with its paste capsules expanded — the text that would leave the editor. */
     expandPastes(line: string): string;
-    /** Empty the buffer: chars, cursor, scroll and the ↑↓ goal column. */
+    /** Empty the buffer: chars, cursor and the ↑↓ goal column. */
     clear(): void;
     /** Type one code point at the cursor. */
     insert(cp: number): void;

package/package.json

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