@vincemakes/kiso-code 0.1.13 → 0.1.14

package/dist/dock.d.ts

@@ -1,14 +1,18 @@
 /**
- * v2b — the bottom-anchored UI (TTY + color only). Borrows pi-tui's IDEA —
- * a DECSTBM scroll region with a reserved bottom — without its
+ * v2b/v2c — the bottom-anchored UI (TTY + color only). Borrows pi-tui's
+ * IDEA — a DECSTBM scroll region with a reserved bottom — without its
  * implementation: zero dependencies, line-level ANSI, no differential
  * renderer.
  *
  * Layout (H = terminal height): rows 1..H-3 = the scroll region (the body
  * streams and scrolls here, never touching the bottom), row H-2 = the dim
- * separator, row H-1 = the live status bar (or a takeover question), row
- * H = the input line (blue you> + readline). Bottom redraws are wrapped in
- * CSI 2026 (synchronized output) to avoid flicker — the pi trick.
+ * dotted separator (╌), row H-1 = the live status bar (or a takeover
+ * question), row H = the input line (the blue brick ▌you> + the v2c
+ * editor's row — readline is gone from the TTY path). Bottom redraws are
+ * wrapped in CSI 2026 (synchronized output) to avoid flicker — the pi
+ * trick. The visual identity is the kiso brick motif — ▌ half-block,
+ * dotted separator — deliberately NOT the CC rounded frame nor the pi
+ * editor (ADR-0039 Amendment 2).
  *
  * Pipes / NO_COLOR: the dock never activates; the v2a line mode stays
  * byte-for-byte (the existing e2e assertions guard it).
@@ -36,9 +40,16 @@ export declare class Dock {
     onResize(): void;
     /** Body output: position the cursor inside the scroll region at the
      *  body's tracked position, write, and hand the cursor back to the
-     *  input line. The row/col tracking is approximate for width-wrapped
-     *  and wide-char lines (documented) — the region clamp keeps the
-     *  bottom rows safe regardless. */
+     *  input line's EDIT position. The row/col tracking is approximate for
+     *  width-wrapped and wide-char lines (documented) — the region clamp
+     *  keeps the bottom rows safe regardless.
+     *
+     *  The edit-position return is a correctness requirement, not
+     *  cosmetics: readline tracks its cursor internally and NEVER
+     *  re-syncs after an external move — a body write that left the
+     *  cursor at column 1 made the next keystroke overwrite the prompt
+     *  (probe-confirmed; the dock's redraw self-repaired ~200ms later,
+     *  which read the user as cursor drift). */
     writeBody(text: string): void;
     /** The status bar's base text (usage, ctx, session, …). */
     setStatus(text: string): void;
@@ -50,6 +61,9 @@ export declare class Dock {
     clearQuestion(): void;
     /** The bottom three rows, wrapped in CSI 2026 (synchronized output —
      *  the pi trick against flicker). The cursor ends at the input line's
-     *  edit position. */
+     *  edit position. v2c: the separator is the dim dotted ╌ (a weaker
+     *  presence than the solid ─), the status line is dim (blue accents
+     *  inside come from the CLI's composition), the input row is the blue
+     *  brick ▌you> + the editor's visible slice. */
     redraw(): void;
 }

package/dist/dock.js

@@ -1,18 +1,23 @@
 /**
- * v2b — the bottom-anchored UI (TTY + color only). Borrows pi-tui's IDEA —
- * a DECSTBM scroll region with a reserved bottom — without its
+ * v2b/v2c — the bottom-anchored UI (TTY + color only). Borrows pi-tui's
+ * IDEA — a DECSTBM scroll region with a reserved bottom — without its
  * implementation: zero dependencies, line-level ANSI, no differential
  * renderer.
  *
  * Layout (H = terminal height): rows 1..H-3 = the scroll region (the body
  * streams and scrolls here, never touching the bottom), row H-2 = the dim
- * separator, row H-1 = the live status bar (or a takeover question), row
- * H = the input line (blue you> + readline). Bottom redraws are wrapped in
- * CSI 2026 (synchronized output) to avoid flicker — the pi trick.
+ * dotted separator (╌), row H-1 = the live status bar (or a takeover
+ * question), row H = the input line (the blue brick ▌you> + the v2c
+ * editor's row — readline is gone from the TTY path). Bottom redraws are
+ * wrapped in CSI 2026 (synchronized output) to avoid flicker — the pi
+ * trick. The visual identity is the kiso brick motif — ▌ half-block,
+ * dotted separator — deliberately NOT the CC rounded frame nor the pi
+ * editor (ADR-0039 Amendment 2).
  *
  * Pipes / NO_COLOR: the dock never activates; the v2a line mode stays
  * byte-for-byte (the existing e2e assertions guard it).
  */
+import { displayWidth } from "./editor.js";
 import { palette } from "./render.js";
 export class Dock {
     #active = false;
@@ -83,9 +88,16 @@ export class Dock {
     }
     /** Body output: position the cursor inside the scroll region at the
      *  body's tracked position, write, and hand the cursor back to the
-     *  input line. The row/col tracking is approximate for width-wrapped
-     *  and wide-char lines (documented) — the region clamp keeps the
-     *  bottom rows safe regardless. */
+     *  input line's EDIT position. The row/col tracking is approximate for
+     *  width-wrapped and wide-char lines (documented) — the region clamp
+     *  keeps the bottom rows safe regardless.
+     *
+     *  The edit-position return is a correctness requirement, not
+     *  cosmetics: readline tracks its cursor internally and NEVER
+     *  re-syncs after an external move — a body write that left the
+     *  cursor at column 1 made the next keystroke overwrite the prompt
+     *  (probe-confirmed; the dock's redraw self-repaired ~200ms later,
+     *  which read the user as cursor drift). */
     writeBody(text) {
         if (!this.#active) {
             process.stdout.write(text);
@@ -104,7 +116,17 @@ export class Dock {
                 this.#bodyCol += 1;
             }
         }
-        process.stdout.write(`\x1b[${this.#height};1H`); // back to the input line
+        process.stdout.write(`\x1b[${this.#height};${this.#inputCol()}H`); // back to the edit position
+    }
+    /** The input line's edit column — prompt width + cursor + 1. The
+     *  dock's redraw and the body's cursor return both end here, so the
+     *  ACTUAL cursor always equals what the editor tracks. The width is
+     *  DISPLAY width (the editor's cursor column is already width-based —
+     *  the CJK drift root cause, editor.ts). */
+    #inputCol() {
+        const inp = this.#inputState();
+        const promptWidth = displayWidth(this.#inputPrompt.replace(/\x1b\[[0-9;]*m/g, ""));
+        return promptWidth + inp.cursor + 1;
     }
     /** The status bar's base text (usage, ctx, session, …). */
     setStatus(text) {
@@ -128,25 +150,30 @@ export class Dock {
     }
     /** The bottom three rows, wrapped in CSI 2026 (synchronized output —
      *  the pi trick against flicker). The cursor ends at the input line's
-     *  edit position. */
+     *  edit position. v2c: the separator is the dim dotted ╌ (a weaker
+     *  presence than the solid ─), the status line is dim (blue accents
+     *  inside come from the CLI's composition), the input row is the blue
+     *  brick ▌you> + the editor's visible slice. */
     redraw() {
         if (!this.#active)
             return;
         const p = palette();
         const H = this.#height;
         const W = this.#width;
-        const sep = `${p.dim}${"─".repeat(W)}${p.reset}`;
+        const sep = `${p.dim}${"╌".repeat(W)}${p.reset}`;
         const status = `${this.#status}${this.#tail === "" ? "" : ` · ${this.#tail}`}`;
-        const statusLine = this.#question ?? status;
+        const statusLine = this.#question ?? `${p.dim}${status}${p.reset}`;
         const inp = this.#inputState();
-        const promptWidth = this.#inputPrompt.replace(/\x1b\[[0-9;]*m/g, "").length;
         const out = [];
-        out.push("\x1b[2026h"); // synchronized output ON
+        // P3 (审查): the DEC private-mode SET/RESET needs the "?" prefix —
+        // \x1b[?2026h/l, the pi source's exact form. Without it terminals
+        // silently ignore the mode and the anti-flicker never engages.
+        out.push("\x1b[?2026h"); // synchronized output ON (DEC 2026)
         out.push(`\x1b[${H - 2};1H\x1b[0K${sep}`);
         out.push(`\x1b[${H - 1};1H\x1b[0K${statusLine}`);
         out.push(`\x1b[${H};1H\x1b[0K${this.#inputPrompt}${inp.line}`);
-        out.push(`\x1b[${H};${promptWidth + inp.cursor + 1}H`); // back to the edit position
-        out.push("\x1b[2026l"); // synchronized output OFF
+        out.push(`\x1b[${H};${this.#inputCol()}H`); // back to the edit position
+        out.push("\x1b[?2026l"); // synchronized output OFF
         process.stdout.write(out.join(""));
     }
 }

package/dist/editor.d.ts

@@ -0,0 +1,64 @@
+/**
+ * v2c — the raw-mode single-line editor that REPLACES readline on the TTY
+ * path. Root cause of the v2b drift (plan 2026-08-05-tui-v2b §11): readline
+ * re-renders its line by CHARACTER count and assumes it owns the row
+ * exclusively — a CJK wide character (2 cells) shifts every following
+ * column, and the dock's redraws make the mismatch permanent. Patching
+ * readline is a dead end; the TTY path draws its own input row instead.
+ * Non-TTY paths keep readline untouched (pipe bytes unchanged).
+ *
+ * Zero dependencies. The eastAsianWidth table is a ~40-line subset (CJK
+ * ideographs/kana/hangul/fullwidth/common wide symbols = 2, everything
+ * else = 1). Known limitation, documented in the README: emoji ZWJ
+ * clusters (family emoji etc.) are not guaranteed perfect — each code
+ * point counts as its width.
+ *
+ * The editor is a SINGLE line: bracketed paste (?2004h) unwraps and
+ * inserts, internal newlines become spaces.
+ */
+/** A code point's display width: 2 for the wide ranges, 1 otherwise. */
+export declare function charWidth(cp: number): number;
+/** Display width of a code-point array (cursor math, scrolling). */
+export declare function widthOf(chars: readonly number[]): number;
+/** Display width of a string. */
+export declare function displayWidth(text: string): number;
+export declare const PROMPT = "\u258Cyou> ";
+export declare const PROMPT_WIDTH: number;
+/**
+ * The editor. Raw mode + bracketed paste (?2004h) on enter, restored on
+ * exit. The input row is rendered by `onRender` (the CLI wires it to the
+ * dock's redraw when docked, the editor's own self-render otherwise) —
+ * the editor itself never writes while docked. The event handlers are
+ * settable — the chat/resume contexts wire them after construction.
+ */
+export declare class Editor {
+    #private;
+    readonly closed: Promise<void>;
+    constructor(onRender: () => void);
+    onLine(cb: (line: string) => void): void;
+    onSigint(cb: () => void): void;
+    onEot(cb: () => void): void;
+    onEscape(cb: () => void): void;
+    /** The whole buffer as text (the CLI's line()/clearLine()). */
+    line(): string;
+    clearLine(): void;
+    /** The visible slice (dim "…" prefix when scrolled) + the cursor's
+     *  display column within it — the dock's input-row state. */
+    dockState(): {
+        line: string;
+        cursor: number;
+    };
+    /** One-shot question mode: the NEXT submit answers, not a turn. */
+    question(_query: string, cb: (answer: string) => void): void;
+    /** Cancel a pending question — the buffer stays (its text becomes the
+     *  next turn on Enter, the readline re-emit equivalent). */
+    cancelQuestion(): void;
+    enter(): void;
+    exit(): 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. */
+    selfRender(): void;
+    /** Feed raw stdin bytes — the parser. Public for unit tests. */
+    feed(raw: Uint8Array): void;
+}

package/dist/editor.js

@@ -0,0 +1,378 @@
+/**
+ * v2c — the raw-mode single-line editor that REPLACES readline on the TTY
+ * path. Root cause of the v2b drift (plan 2026-08-05-tui-v2b §11): readline
+ * re-renders its line by CHARACTER count and assumes it owns the row
+ * exclusively — a CJK wide character (2 cells) shifts every following
+ * column, and the dock's redraws make the mismatch permanent. Patching
+ * readline is a dead end; the TTY path draws its own input row instead.
+ * Non-TTY paths keep readline untouched (pipe bytes unchanged).
+ *
+ * Zero dependencies. The eastAsianWidth table is a ~40-line subset (CJK
+ * ideographs/kana/hangul/fullwidth/common wide symbols = 2, everything
+ * else = 1). Known limitation, documented in the README: emoji ZWJ
+ * clusters (family emoji etc.) are not guaranteed perfect — each code
+ * point counts as its width.
+ *
+ * The editor is a SINGLE line: bracketed paste (?2004h) unwraps and
+ * inserts, internal newlines become spaces.
+ */
+/** A code point's display width: 2 for the wide ranges, 1 otherwise. */
+export function charWidth(cp) {
+    if (cp >= 0x1100 && cp <= 0x115f)
+        return 2; // hangul jamo
+    if (cp >= 0x2e80 && cp <= 0x303e)
+        return 2; // radicals .. CJK punctuation
+    if (cp >= 0x3041 && cp <= 0x33ff)
+        return 2; // kana, CJK compat
+    if (cp >= 0x3400 && cp <= 0x4dbf)
+        return 2; // CJK ext A
+    if (cp >= 0x4e00 && cp <= 0x9fff)
+        return 2; // CJK unified
+    if (cp >= 0xa000 && cp <= 0xa4cf)
+        return 2; // yi
+    if (cp >= 0xa960 && cp <= 0xa97f)
+        return 2; // hangul jamo ext
+    if (cp >= 0xac00 && cp <= 0xd7a3)
+        return 2; // hangul syllables
+    if (cp >= 0xf900 && cp <= 0xfaff)
+        return 2; // CJK compat ideographs
+    if (cp >= 0xfe10 && cp <= 0xfe19)
+        return 2; // vertical forms
+    if (cp >= 0xfe30 && cp <= 0xfe6f)
+        return 2; // CJK compat forms
+    if (cp >= 0xff00 && cp <= 0xff60)
+        return 2; // fullwidth forms
+    if (cp >= 0xffe0 && cp <= 0xffe6)
+        return 2; // fullwidth signs
+    if (cp >= 0x1f300 && cp <= 0x1f64f)
+        return 2; // emoji (misc + emoticons)
+    if (cp >= 0x1f900 && cp <= 0x1f9ff)
+        return 2; // supplemental emoji
+    if (cp >= 0x20000 && cp <= 0x3fffd)
+        return 2; // CJK ext B..G
+    return 1;
+}
+/** Display width of a code-point array (cursor math, scrolling). */
+export function widthOf(chars) {
+    let w = 0;
+    for (const cp of chars)
+        w += charWidth(cp);
+    return w;
+}
+/** Display width of a string. */
+export function displayWidth(text) {
+    let w = 0;
+    for (const ch of text)
+        w += charWidth(ch.codePointAt(0));
+    return w;
+}
+import { palette } from "./render.js";
+export const PROMPT = "▌you> "; // the kiso brick motif: one blue half-block, then you>
+export const PROMPT_WIDTH = displayWidth(PROMPT);
+/**
+ * The editor. Raw mode + bracketed paste (?2004h) on enter, restored on
+ * exit. The input row is rendered by `onRender` (the CLI wires it to the
+ * dock's redraw when docked, the editor's own self-render otherwise) —
+ * the editor itself never writes while docked. The event handlers are
+ * settable — the chat/resume contexts wire them after construction.
+ */
+export class Editor {
+    #chars = [];
+    #cursor = 0;
+    #scroll = 0; // chars scrolled off the left (width-based reflow)
+    #questionCb = null;
+    #pasting = false;
+    #lineCb = null;
+    #pendingLines = []; // submits before onLine is wired (startup) — never dropped
+    #sigintCb = null;
+    #eotCb = null;
+    #escapeCb = null;
+    #onRender;
+    #pending = ""; // an incomplete ESC/CSI prefix across chunks
+    #decoder = new TextDecoder();
+    #entered = false;
+    #onData;
+    #closedResolve;
+    closed;
+    constructor(onRender) {
+        this.#onRender = onRender;
+        this.#onData = (raw) => this.feed(raw);
+        this.closed = new Promise((resolve) => {
+            this.#closedResolve = resolve;
+        });
+    }
+    onLine(cb) {
+        this.#lineCb = cb;
+        // Flush submits that arrived before the handler was wired (typed
+        // during startup) — readline buffered these; the editor must too.
+        for (const line of this.#pendingLines)
+            cb(line);
+        this.#pendingLines.length = 0;
+    }
+    onSigint(cb) {
+        this.#sigintCb = cb;
+    }
+    onEot(cb) {
+        this.#eotCb = cb;
+    }
+    onEscape(cb) {
+        this.#escapeCb = cb;
+    }
+    /** The whole buffer as text (the CLI's line()/clearLine()). */
+    line() {
+        return String.fromCodePoint(...this.#chars);
+    }
+    clearLine() {
+        this.#chars = [];
+        this.#cursor = 0;
+        this.#scroll = 0;
+        this.#onRender();
+    }
+    /** The visible slice (dim "…" prefix when scrolled) + the cursor's
+     *  display column within it — the dock's input-row state. */
+    dockState() {
+        const visible = String.fromCodePoint(...this.#chars.slice(this.#scroll));
+        const prefix = this.#scroll > 0 ? "\x1b[2m…\x1b[0m" : "";
+        const col = (this.#scroll > 0 ? 1 : 0) + widthOf(this.#chars.slice(this.#scroll, this.#cursor));
+        return { line: `${prefix}${visible}`, cursor: col };
+    }
+    /** One-shot question mode: the NEXT submit answers, not a turn. */
+    question(_query, cb) {
+        this.#questionCb = cb;
+    }
+    /** Cancel a pending question — the buffer stays (its text becomes the
+     *  next turn on Enter, the readline re-emit equivalent). */
+    cancelQuestion() {
+        this.#questionCb = null;
+    }
+    enter() {
+        if (this.#entered)
+            return;
+        this.#entered = true;
+        process.stdin.setRawMode(true);
+        process.stdout.write("\x1b[?2004h"); // bracketed paste ON
+        process.stdin.on("data", this.#onData);
+        this.#onRender();
+    }
+    exit() {
+        if (!this.#entered)
+            return;
+        this.#entered = false;
+        process.stdin.off("data", this.#onData);
+        process.stdout.write("\x1b[?2004l"); // bracketed paste OFF
+        process.stdin.setRawMode(false);
+        this.#closedResolve();
+    }
+    /** The row's own render when the dock is inactive (a TTY without a
+     *  real size): \r + clear + blue brick prompt + visible + cursor
+     *  column. */
+    selfRender() {
+        const p = palette();
+        const st = this.dockState();
+        const W = (process.stdout.columns ?? 0) || 80; // a degenerate 0 size (no TIOCSWINSZ) falls back
+        const cursorCol = Math.min(1 + PROMPT_WIDTH + st.cursor, W);
+        process.stdout.write(`\r\x1b[0K${p.blue}${PROMPT}${p.reset}${st.line}\x1b[${cursorCol}G`);
+    }
+    // ---- input ----
+    /** Feed raw stdin bytes — the parser. Public for unit tests. */
+    feed(raw) {
+        const text = this.#pending + this.#decoder.decode(raw, { stream: true });
+        this.#pending = "";
+        let i = 0;
+        while (i < text.length) {
+            const c = text[i];
+            if (c === "\x1b") {
+                const rest = text.slice(i + 1);
+                if (rest.startsWith("[")) {
+                    const m = rest.match(/^\[([0-9;?]*)([A-Za-z~])/);
+                    if (m === null) {
+                        this.#pending = text.slice(i); // incomplete CSI — wait for more
+                        break;
+                    }
+                    this.#csi(m[1], m[2]);
+                    i += m[0].length + 1;
+                }
+                else if (rest.startsWith("O")) {
+                    i += 3; // SS3 (function keys) — ignored
+                }
+                else {
+                    this.#escapeCb?.();
+                    i += 1;
+                }
+            }
+            else if (c === "\x0d" || c === "\x0a") {
+                if (this.#pasting) {
+                    this.#insert(0x20); // single-line editor: newlines become spaces
+                }
+                else {
+                    this.#submit();
+                }
+                i += 1;
+            }
+            else if (c === "\x7f" || c === "\x08") {
+                this.#backspace();
+                i += 1;
+            }
+            else if (c === "\x03") {
+                this.#sigintCb?.();
+                i += 1;
+            }
+            else if (c === "\x04") {
+                this.#eotCb?.();
+                i += 1;
+            }
+            else if (c === "\x15") {
+                this.#killToStart();
+                i += 1;
+            }
+            else if (c === "\x0b") {
+                this.#killToEnd();
+                i += 1;
+            }
+            else if (c === "\x17") {
+                this.#killWord();
+                i += 1;
+            }
+            else if (c === "\x01") {
+                this.#cursor = 0;
+                this.#reflow();
+                this.#onRender();
+                i += 1;
+            }
+            else if (c === "\x05") {
+                this.#cursor = this.#chars.length;
+                this.#reflow();
+                this.#onRender();
+                i += 1;
+            }
+            else if (c !== undefined && c < " ") {
+                i += 1; // other control — ignored
+            }
+            else {
+                this.#insert(text.codePointAt(i));
+                i += c.length;
+            }
+        }
+    }
+    #csi(params, final) {
+        if (final === "~") {
+            const n = Number(params);
+            if (n === 3)
+                this.#delete();
+            else if (n === 200)
+                this.#pasting = true;
+            else if (n === 201) {
+                this.#pasting = false;
+                this.#onRender();
+            }
+        }
+        else if (final === "D") {
+            this.#move(-1);
+        }
+        else if (final === "C") {
+            this.#move(1);
+        }
+        else if (final === "H") {
+            this.#cursor = 0;
+            this.#reflow();
+        }
+        else if (final === "F") {
+            this.#cursor = this.#chars.length;
+            this.#reflow();
+        }
+    }
+    // ---- editing ----
+    #insert(cp) {
+        this.#chars.splice(this.#cursor, 0, cp);
+        this.#cursor += 1;
+        this.#reflow();
+        if (!this.#pasting)
+            this.#onRender();
+    }
+    #backspace() {
+        if (this.#cursor === 0)
+            return;
+        this.#chars.splice(this.#cursor - 1, 1);
+        this.#cursor -= 1;
+        this.#reflow();
+        if (!this.#pasting)
+            this.#onRender();
+    }
+    #delete() {
+        if (this.#cursor >= this.#chars.length)
+            return;
+        this.#chars.splice(this.#cursor, 1);
+        this.#reflow();
+        if (!this.#pasting)
+            this.#onRender();
+    }
+    #move(delta) {
+        this.#cursor = Math.max(0, Math.min(this.#chars.length, this.#cursor + delta));
+        this.#reflow();
+        if (!this.#pasting)
+            this.#onRender();
+    }
+    #killToStart() {
+        this.#chars.splice(0, this.#cursor);
+        this.#cursor = 0;
+        this.#reflow();
+        if (!this.#pasting)
+            this.#onRender();
+    }
+    #killToEnd() {
+        this.#chars.length = this.#cursor;
+        this.#reflow();
+        if (!this.#pasting)
+            this.#onRender();
+    }
+    #killWord() {
+        let i = this.#cursor;
+        while (i > 0 && this.#chars[i - 1] === 0x20)
+            i -= 1; // trailing spaces
+        while (i > 0 && this.#chars[i - 1] !== 0x20)
+            i -= 1; // the word
+        this.#chars.splice(i, this.#cursor - i);
+        this.#cursor = i;
+        this.#reflow();
+    }
+    #submit() {
+        const line = String.fromCodePoint(...this.#chars);
+        this.#chars = [];
+        this.#cursor = 0;
+        this.#scroll = 0;
+        const cb = this.#questionCb;
+        this.#questionCb = null;
+        if (cb !== null) {
+            cb(line);
+        }
+        else if (this.#lineCb !== null) {
+            this.#lineCb(line);
+        }
+        else {
+            this.#pendingLines.push(line); // nobody wired yet — hold it
+        }
+        this.#onRender();
+    }
+    // ---- width-based horizontal scroll ----
+    #reflow() {
+        const W = (process.stdout.columns ?? 0) || 80; // degenerate 0 falls back to 80
+        const maxW = Math.max(1, W - PROMPT_WIDTH - 1); // 1 col for the "…"
+        const curCol = widthOf(this.#chars.slice(0, this.#cursor));
+        const scrolledW = widthOf(this.#chars.slice(0, this.#scroll));
+        if (curCol < scrolledW) {
+            this.#scroll = this.#indexAtWidth(curCol);
+        }
+        else if (curCol >= scrolledW + maxW) {
+            this.#scroll = this.#indexAtWidth(Math.max(0, curCol - maxW + 1));
+        }
+    }
+    #indexAtWidth(target) {
+        let w = 0;
+        for (let i = 0; i < this.#chars.length; i += 1) {
+            if (w >= target)
+                return i;
+            w += charWidth(this.#chars[i]);
+        }
+        return this.#chars.length;
+    }
+}

package/dist/index.js

@@ -17,6 +17,7 @@
  */
 import { existsSync, mkdtempSync, readFileSync, readdirSync, rmSync, symlinkSync, writeFileSync } from "node:fs";
 import { createInterface } from "node:readline";
+import { Editor, PROMPT as EDITOR_PROMPT } from "./editor.js";
 import { homedir, tmpdir } from "node:os";
 import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
@@ -87,11 +88,124 @@ function startupBanner() {
     return `${p.dim}${LOGO_TOP}${p.blue}${TAGLINE}${p.reset}${p.dim}${LOGO_BOTTOM}   v${VERSION}${names}${p.reset}\n`;
 }
 /** v2a: the interactive prompt — blue, the identity accent. readline owns
- *  the echo of what the user types; we own the prompt's color. */
+ *  the echo of what the user types; we own the prompt's color. (v2c: the
+ *  readline prompt keeps "you> " — the brick ▌ is the dock's row only;
+ *  pipe bytes must not change.) */
 function interactivePrompt() {
     const p = palette();
     return `${p.blue}you> ${p.reset}`;
 }
+/** The v2b behavior, unchanged: readline owns the line, SIGINT, and the
+ *  prompt. Only ever constructed when stdin is NOT a TTY. The rl starts
+ *  consuming stdin at construction (main), so 'line' events are buffered
+ *  until chat() wires the handler — pipe input must never be dropped. */
+function readlineInput(rl) {
+    let lineCb = null;
+    const pending = [];
+    rl.on("line", (line) => {
+        if (lineCb === null)
+            pending.push(line);
+        else
+            lineCb(line);
+    });
+    return {
+        onLine(cb) {
+            lineCb = cb;
+            for (const line of pending)
+                cb(line);
+            pending.length = 0;
+        },
+        onSigint(cb) {
+            rl.on("SIGINT", cb);
+        },
+        onEot() {
+            /* readline's Ctrl+D on an empty line is EOF → 'close' — the
+             * exit path is the close, nothing to wire here. */
+        },
+        onEscape() {
+            /* readline has no bare-Esc semantics — ignored. */
+        },
+        question(query, cb) {
+            rl.question(query, cb);
+        },
+        cancelQuestion() {
+            /* the rl.question stays pending; the settled branch re-emits
+             * the answer as a new line. */
+        },
+        emitLine(line) {
+            rl.emit("line", line);
+        },
+        line() {
+            return rl.line;
+        },
+        clearLine() {
+            /* readline: Ctrl+C is exit/abort only — nothing to clear. */
+        },
+        prompt() {
+            rl.setPrompt(interactivePrompt());
+            rl.prompt();
+        },
+        close() {
+            rl.close();
+        },
+        closed: new Promise((resolve) => rl.on("close", () => resolve())),
+    };
+}
+/** The v2c TTY path: the editor's events map 1:1 onto the interface; the
+ *  input row renders on every state change (the CLI's onRender wiring). */
+function editorInput(editor) {
+    return {
+        onLine(cb) {
+            editor.onLine(cb);
+        },
+        onSigint(cb) {
+            editor.onSigint(cb);
+        },
+        onEot(cb) {
+            editor.onEot(cb);
+        },
+        onEscape(cb) {
+            editor.onEscape(cb);
+        },
+        question(query, cb) {
+            editor.question(query, cb);
+        },
+        cancelQuestion() {
+            editor.cancelQuestion();
+        },
+        emitLine() {
+            /* the editor's buffer survives a cancelled question — its text
+             * becomes the next turn on Enter (the readline re-emit
+             * equivalent). */
+        },
+        line() {
+            return editor.line();
+        },
+        clearLine() {
+            editor.clearLine();
+        },
+        prompt() {
+            /* the editor renders on every state change — nothing to arm. */
+        },
+        close() {
+            editor.exit();
+        },
+        closed: editor.closed,
+    };
+}
+/** One input source per process: the raw-mode Editor on a TTY (entered
+ *  here, bound to the dock once — the trust question, chat, and resume
+ *  all read through it), readline elsewhere. */
+function makeLineInput() {
+    if (process.stdin.isTTY) {
+        const editor = new Editor(() => (dock.active ? dock.redraw() : editor.selfRender()));
+        editor.enter();
+        const p = palette();
+        dock.bindInput(() => editor.dockState(), `${p.blue}${EDITOR_PROMPT}${p.reset}`);
+        return editorInput(editor);
+    }
+    return readlineInput(createInterface({ input: process.stdin, output: process.stdout }));
+}
 /** v2b: the bottom-anchored UI — docked only on a color TTY; pipes and
  *  NO_COLOR stay the v2a line mode byte-for-byte. */
 const dock = new Dock();
@@ -171,7 +285,7 @@ function extensionsBanner() {
  * record → only a HUMAN may decide, TTY only — non-TTY refuses with one
  * stderr line. Returns the artifacts on grant, null on anything else.
  */
-async function resolveProjectTrust() {
+async function resolveProjectTrust(input) {
     const artifacts = await projectArtifacts(process.cwd());
     if (artifacts === null)
         return null; // no .kiso artifacts — nothing to gate
@@ -188,25 +302,19 @@ async function resolveProjectTrust() {
         console.error(`[project .kiso] found ${artifacts.files.length} artifact(s) in ${artifacts.root} — not trusted, not loaded (run kiso interactively once to decide)`);
         return null;
     }
-    const rl = createInterface({ input: process.stdin, output: process.stdout });
-    // v2b: docked — the trust question takes over the status position.
-    dock.bindInput(() => ({ line: rl.line, cursor: rl.cursor }), interactivePrompt());
-    try {
-        bodyLog(`[project .kiso] ${artifacts.root}`);
-        for (const f of artifacts.files) {
-            bodyLog(`  ${f.path}  (${f.digest.slice(0, 6)})`);
-        }
-        const answer = await ask(rl, `trust this project's .kiso? (y/n) `);
-        const granted = answer !== CANCELLED && answer.trim().toLowerCase().startsWith("y");
-        recordTrust({ root: artifacts.root, digest: artifacts.digest, decision: granted ? "granted" : "refused" });
-        if (!granted)
-            return null;
-        applyProjectMerges(artifacts);
-        return artifacts;
-    }
-    finally {
-        rl.close();
+    // v2c: the shared input (the editor on a TTY) reads the answer; the
+    // dock shows the question at the status position.
+    bodyLog(`[project .kiso] ${artifacts.root}`);
+    for (const f of artifacts.files) {
+        bodyLog(`  ${f.path}  (${f.digest.slice(0, 6)})`);
     }
+    const answer = await ask(input, `trust this project's .kiso? (y/n) `);
+    const granted = answer !== CANCELLED && answer.trim().toLowerCase().startsWith("y");
+    recordTrust({ root: artifacts.root, digest: artifacts.digest, decision: granted ? "granted" : "refused" });
+    if (!granted)
+        return null;
+    applyProjectMerges(artifacts);
+    return artifacts;
 }
 /**
  * E3 — merge the project's mcp.json and skills into the env BEFORE the
@@ -368,12 +476,12 @@ function fauxSkip(id) {
         events.filter((e) => e.type === "stop" && e.reason === "end_turn").length +
         events.filter((e) => e.type === "tool_call_end" && !results.has(e.callId)).length);
 }
-async function makeAgent(fauxSkipTurns = 0) {
+async function makeAgent(fauxSkipTurns = 0, input) {
     const store = new SessionStore(sessionsDir());
     // E3: the project-level trust gate runs BEFORE any extension load (the
     // mcp/skills merges must be in the env when the user-level extensions
     // load). Untrusted project capability is never loaded — never silently.
-    const project = await resolveProjectTrust();
+    const project = input !== undefined ? await resolveProjectTrust(input) : await resolveProjectTrust(undefined);
     // E1: the startup extension scan — a broken extension fails the process
     // LOUDLY here (loadExtensions throws), never silently.
     userExtensions = await loadExtensions(extensionsDir());
@@ -508,15 +616,20 @@ const CANCELLED = Symbol("kiso-question-cancelled");
  * question.
  */
 let pendingAsk = null;
-function ask(rl, question) {
+function ask(input, question) {
     if (!process.stdin.isTTY) {
         console.log(`[non-interactive — no human to ask: ${question}]`);
         return Promise.resolve("");
     }
     // v2b: docked — the question takes over the status position, the
-    // answer lands at the input line.
-    if (dock.active)
+    // answer lands at the input line. v2c: a TTY without a dock (rows < 4)
+    // prints the question into the body — the editor cannot show it.
+    if (dock.active) {
         dock.showQuestion(question);
+    }
+    else {
+        bodyLog(question);
+    }
     return new Promise((resolve) => {
         let settled = false;
         pendingAsk = () => {
@@ -524,12 +637,18 @@ function ask(rl, question) {
                 return;
             settled = true;
             pendingAsk = null;
+            input.cancelQuestion();
             resolve(CANCELLED); // the run is aborting — the question is dead
         };
-        rl.question(dock.active ? "" : question, (answer) => {
+        // v2b: docked — the question reads at the input line, whose prompt
+        // is the same blue you> (the editor's brick row; the readline path
+        // passes the plain question). An empty prompt would start readline
+        // at column 1 while the dock renders "you> " — the typed answer
+        // would land on the prompt and drift (probe-confirmed).
+        input.question(dock.active ? interactivePrompt() : question, (answer) => {
             if (settled) {
                 // The question was cancelled; this line is a NEW user turn.
-                rl.emit("line", answer);
+                input.emitLine(answer);
                 return;
             }
             settled = true;
@@ -560,9 +679,9 @@ function estimateCtxRatio(session) {
     return chars / 4 / contextWindowTokens();
 }
 /** Decide every uncertain execution with the human (r)erun/(a)bandon. */
-async function resolveUncertains(session, rl, isCancelled) {
+async function resolveUncertains(session, input, isCancelled) {
     for (const uncertain of session.uncertainExecutions()) {
-        const answer = await ask(rl, `⚠ interrupted execution: ${escapeTerminal(uncertain.name)} (${uncertain.executionId}) — did it apply? (r)erun / (a)bandon: `);
+        const answer = await ask(input, `⚠ interrupted execution: ${escapeTerminal(uncertain.name)} (${uncertain.executionId}) — did it apply? (r)erun / (a)bandon: `);
         if (isCancelled() || answer === CANCELLED) {
             // 十: a cancellation NEVER records a verdict — the execution
             // stays uncertain and durable; no rerun/abandoned is fabricated.
@@ -581,7 +700,7 @@ const DEFAULT_CONTEXT_WINDOW = 200_000;
  * line's form; `liveInput` (non-null only in interactive chat) carries the
  * last line THIS process's readline consumed — the double-echo filter.
  */
-async function consumeRun(session, run, rl, turnNo, lastToolRef, faux, liveInput, lastThinking, statusCb) {
+async function consumeRun(session, run, input, turnNo, lastToolRef, faux, liveInput, lastThinking, statusCb) {
     let last;
     // B 区: tool_call_end → (name, input) for the summary; tool_result →
     // one summary line. Usage events feed the status line.
@@ -615,7 +734,14 @@ async function consumeRun(session, run, rl, turnNo, lastToolRef, faux, liveInput
             // Replayed history (recovery/resume — nobody typed) keeps the event
             // render. Deterministic: exact content match with the consumed line,
             // on a TTY (the only place an echo exists to hand over).
-            if (ev.type === "user_input" && liveInput !== null && liveInput.current === (typeof ev.content === "string" ? ev.content : "") && process.stdin.isTTY) {
+            // v2b: DOCKED — the echo lives in the input row (H), NOT the body;
+            // the body render is the ONLY visible copy of the sent line. The
+            // user's typed text must not vanish after Enter.
+            if (ev.type === "user_input" &&
+                liveInput !== null &&
+                liveInput.current === (typeof ev.content === "string" ? ev.content : "") &&
+                process.stdin.isTTY &&
+                !dock.active) {
                 continue;
             }
             const prevThinking = thinkingOpen;
@@ -664,7 +790,7 @@ async function consumeRun(session, run, rl, turnNo, lastToolRef, faux, liveInput
                 const decisionId = ev.decisionId;
                 const name = ev.name;
                 // 八: the tool name is model text — escaped on every output path.
-                const answer = await ask(rl, `approve ${escapeTerminal(name)}? (y/n) `);
+                const answer = await ask(input, `approve ${escapeTerminal(name)}? (y/n) `);
                 if (answer === CANCELLED) {
                     // 十: a cancellation is a CONSERVATIVE denial, explicitly
                     // distinguished from the user typing "n".
@@ -707,35 +833,35 @@ class FauxExhaustionError extends Error {
         this.name = "FauxExhaustionError";
     }
 }
-function failOnFauxExhaustion(last, faux, rl) {
+function failOnFauxExhaustion(last, faux, input) {
     if (!faux)
         return;
     if (last?.type !== "terminal" || last.outcome.kind !== "error")
         return;
     const message = last.outcome.error.message;
-    rl?.close(); // the REPL must not stay open waiting for a line
+    input?.close(); // the REPL must not stay open waiting for a line
     throw new FauxExhaustionError(message.startsWith("provider stream ended without a stop event")
         ? "[faux mode] the scripted demo turns are exhausted — set ANTHROPIC_API_KEY or OPENAI_API_KEY for a real model"
         : `[faux mode] the scripted model failed: ${escapeTerminal(message.slice(0, 200))}`);
 }
 /** Interactive REPL: stream events, pause for approvals, Ctrl+C aborts. */
-async function chat(session, faux) {
-    const rl = createInterface({ input: process.stdin, output: process.stdout });
+async function chat(session, faux, input) {
     let currentRun = null;
     let cancelled = false;
-    const turn = (input) => new Promise((resolve, reject) => {
+    const turn = (text) => new Promise((resolve, reject) => {
+        queued = Math.max(0, queued - 1); // a queued turn starts
         // v2a: the echo filter compares the user_input event against THIS
         // turn's own input — lines that arrive ahead of their turn (piped
         // bursts, queued replays) must not overwrite the reference.
-        liveInput.current = input;
-        const run = session.run(input);
+        liveInput.current = text;
+        const run = session.run(text);
         currentRun = run;
         turnNo += 1;
         const myTurn = turnNo;
         (async () => {
             let last;
             try {
-                last = await consumeRun(session, run, rl, myTurn, lastToolRef, faux, liveInput, lastThinking, statusCb);
+                last = await consumeRun(session, run, input, myTurn, lastToolRef, faux, liveInput, lastThinking, statusCb);
                 currentRun = null;
                 // 八: a faux script that ran out of declared turns exits
                 // loudly with a non-zero status — never a silent status 0.
@@ -743,11 +869,10 @@ async function chat(session, faux) {
                 // this turn's promise — it propagates through the chain to
                 // chat to main's finally/catch, never an orphaned
                 // unhandled rejection from the IIFE.
-                failOnFauxExhaustion(last, faux, rl);
+                failOnFauxExhaustion(last, faux, input);
                 // 八: after EVERY turn the prompt is re-armed — the human
                 // never types blind after the first turn.
-                rl.setPrompt(interactivePrompt());
-                rl.prompt();
+                input.prompt();
                 resolve();
             }
             catch (err) {
@@ -760,13 +885,12 @@ async function chat(session, faux) {
                 }
                 console.error(`\n[run failed] ${err instanceof Error ? err.message : String(err)}\n`);
                 currentRun = null;
-                rl.setPrompt(interactivePrompt());
-                rl.prompt();
+                input.prompt();
                 resolve();
             }
         })();
     });
-    rl.on("SIGINT", () => {
+    input.onSigint(() => {
         if (currentRun) {
             // 八: Ctrl+C cancels BOTH the pending question (if one is
             // awaiting a line) and the run — the run then writes its unique
@@ -775,11 +899,30 @@ async function chat(session, faux) {
             pendingAsk?.();
             currentRun.abort();
         }
-        else if (!cancelled) {
+        else if (pendingAsk !== null) {
+            pendingAsk?.(); // a startup/trust question — cancel it
+        }
+        else if (input.line() === "") {
             cancelled = true;
             console.log("\n[exit requested]");
-            pendingAsk?.(); // unblock a startup question
-            rl.close();
+            input.close();
+        }
+        else {
+            input.clearLine(); // v2c: Ctrl+C on a non-empty line clears it
+        }
+    });
+    input.onEot(() => {
+        if (!currentRun && pendingAsk === null && input.line() === "") {
+            cancelled = true;
+            console.log("\n[exit requested]");
+            input.close();
+        }
+    });
+    input.onEscape(() => {
+        if (currentRun) {
+            console.log("\n[aborting run]");
+            pendingAsk?.();
+            currentRun.abort();
         }
     });
     // 第五轮(P1-11): the PERSISTENT line listener is installed BEFORE the
@@ -800,15 +943,22 @@ async function chat(session, faux) {
     const liveInput = { current: null };
     // v2b: the last complete thinking block, for /think.
     const lastThinking = { current: null };
+    // v2c: turns submitted while another runs are QUEUED on the chain — the
+    // live count rides the status bar (+N queued).
+    let queued = 0;
     // v2b: the live status bar (docked only).
     const statusCb = (u, ctx) => {
         if (!dock.active)
             return;
         const st = renderStatusLine(turnNo, u, ctx, faux);
-        dock.setStatus(st === null ? `${session.id} · ${agentModel}` : `${session.id} · ${agentModel} · ${st}`);
+        const base = st === null ? `${session.id} · ${agentModel}` : `${session.id} · ${agentModel} · ${st}`;
+        dock.setStatus(queued > 0 ? `${base} · +${queued} queued` : base);
     };
-    dock.bindInput(() => ({ line: rl.line, cursor: rl.cursor }), interactivePrompt());
-    rl.on("line", (line) => {
+    // The ONE dispatcher: slash commands, exit, and turns. The recovery
+    // replay routes through it too — a queued "/last" must never become a
+    // user turn (v2c: the rl lives in main, so lines arrive earlier and
+    // the queue is the common path).
+    const dispatch = (line) => {
         const trimmed = line.trim();
         if (trimmed === "/help") {
             // Prints the available commands with one-line descriptions.
@@ -821,8 +971,7 @@ async function chat(session, faux) {
                 bodyLog(cmd("/last", "show the most recent tool call's input and output"));
                 bodyLog(cmd("/status", "show session id, event count, and context estimate"));
                 bodyLog(cmd("exit", "leave the session"));
-                rl.setPrompt(interactivePrompt());
-                rl.prompt();
+                input.prompt();
             });
             return;
         }
@@ -837,8 +986,7 @@ async function chat(session, faux) {
                 else {
                     bodyLog(escapeTerminal(t));
                 }
-                rl.setPrompt(interactivePrompt());
-                rl.prompt();
+                input.prompt();
             });
             return;
         }
@@ -857,8 +1005,7 @@ async function chat(session, faux) {
                     bodyLog(`--- ${tool.name} output${tool.result.isError ? " (error)" : ""} ---`);
                     bodyLog(escapeTerminal(tool.result.content));
                 }
-                rl.setPrompt(interactivePrompt());
-                rl.prompt();
+                input.prompt();
             });
             return;
         }
@@ -872,49 +1019,58 @@ async function chat(session, faux) {
                 bodyLog(`session ${session.id}`);
                 bodyLog(`${session.log.all.length} events`);
                 bodyLog(`ctx ${ctx}`);
-                rl.setPrompt(interactivePrompt());
-                rl.prompt();
+                input.prompt();
             });
             return;
         }
         if (trimmed === "exit" || trimmed === "") {
-            rl.close();
+            input.close();
             return;
         }
+        // v2c: a turn submitted while another runs waits on the chain — the
+        // live count rides the status bar (+N queued).
+        queued += 1;
+        chain = chain.then(() => turn(line));
+    };
+    input.onLine((line) => {
         if (!replReady) {
             queuedLines.push(line);
             return;
         }
-        chain = chain.then(() => turn(line));
+        dispatch(line);
     });
     // Recovery first: a session with a dangling pause or uncertain
     // executions must resolve them BEFORE the REPL accepts new turns —
     // otherwise the interrupted run dangles while a new one starts.
     // 八: the startup resume is bound to currentRun — Ctrl+C during it
     // aborts the recovery, exactly like the interactive turns.
-    await resolveUncertains(session, rl, () => cancelled);
+    await resolveUncertains(session, input, () => cancelled);
     if (!cancelled) {
         const recoveryRun = session.resume();
         currentRun = recoveryRun;
         turnNo += 1;
-        const last = await consumeRun(session, recoveryRun, rl, turnNo, lastToolRef, faux, liveInput, lastThinking, statusCb);
+        const last = await consumeRun(session, recoveryRun, input, turnNo, lastToolRef, faux, liveInput, lastThinking, statusCb);
         currentRun = null;
-        failOnFauxExhaustion(last, faux, rl);
+        failOnFauxExhaustion(last, faux, input);
     }
     if (cancelled) {
-        rl.close();
-        await new Promise((resolve) => rl.on("close", () => resolve()));
+        input.close();
+        await input.closed;
         return;
     }
     // The REPL is ready: replay anything that arrived during recovery.
     replReady = true;
+    // v2c: dispatch SYNCHRONOUSLY — each call appends its segment to the
+    // chain variable; the final `await chain` then covers every replayed
+    // turn. A chain.then(() => dispatch()) indirection would capture the
+    // chain BEFORE the appends and the replayed turns would never be
+    // awaited (the F-group regression).
     for (const line of queuedLines) {
-        chain = chain.then(() => turn(line));
+        dispatch(line);
     }
     queuedLines.length = 0;
-    rl.setPrompt(interactivePrompt());
-    rl.prompt();
-    await new Promise((resolve) => rl.on("close", () => resolve()));
+    input.prompt();
+    await input.closed;
     await chain; // never exit while a turn is in flight
 }
 /**
@@ -924,8 +1080,7 @@ async function chat(session, faux) {
  * E 组: SIGINT aborts the run being resumed; every exit path closes the
  * session store so no lock is left behind.
  */
-async function resume(session, prompt, faux) {
-    const rl = createInterface({ input: process.stdin, output: process.stdout });
+async function resume(session, prompt, faux, input) {
     let currentRun = null;
     let cancelled = false;
     let turnNo = 0;
@@ -938,19 +1093,18 @@ async function resume(session, prompt, faux) {
         const st = renderStatusLine(turnNo, u, ctx, faux);
         dock.setStatus(st === null ? `${session.id} · ${agentModel}` : `${session.id} · ${agentModel} · ${st}`);
     };
-    dock.bindInput(() => ({ line: rl.line, cursor: rl.cursor }), interactivePrompt());
     const withRun = async (run) => {
         currentRun = run;
         try {
             turnNo += 1;
-            const last = await consumeRun(session, run, rl, turnNo, lastToolRef, faux, null, lastThinking, statusCb);
-            failOnFauxExhaustion(last, faux, rl);
+            const last = await consumeRun(session, run, input, turnNo, lastToolRef, faux, null, lastThinking, statusCb);
+            failOnFauxExhaustion(last, faux, input);
         }
         finally {
             currentRun = null;
         }
     };
-    rl.on("SIGINT", () => {
+    input.onSigint(() => {
         if (currentRun) {
             // 八: Ctrl+C cancels the pending question AND the run.
             console.log("\n[aborting run]");
@@ -965,11 +1119,25 @@ async function resume(session, prompt, faux) {
             cancelled = true;
             console.log("\n[exit requested]");
             pendingAsk?.();
-            rl.close();
+            input.close();
+        }
+    });
+    input.onEot(() => {
+        if (!currentRun && !cancelled && input.line() === "") {
+            cancelled = true;
+            console.log("\n[exit requested]");
+            input.close();
+        }
+    });
+    input.onEscape(() => {
+        if (currentRun) {
+            console.log("\n[aborting run]");
+            pendingAsk?.();
+            currentRun.abort();
         }
     });
     try {
-        await resolveUncertains(session, rl, () => cancelled);
+        await resolveUncertains(session, input, () => cancelled);
         if (!cancelled) {
             await withRun(session.resume());
             if (prompt !== undefined && prompt !== "") {
@@ -978,7 +1146,7 @@ async function resume(session, prompt, faux) {
         }
     }
     finally {
-        rl.close();
+        input.close();
     }
 }
 async function main() {
@@ -987,6 +1155,11 @@ async function main() {
     // exit non-zero, never masquerade as a successful provider run.
     const faux = process.env.ANTHROPIC_API_KEY === undefined && process.env.OPENAI_API_KEY === undefined;
     let agent;
+    // v2c: ONE input source per process — the raw-mode editor on a TTY
+    // (entered here, dock-bound, trusted before any extension loads),
+    // readline elsewhere. The trust question, chat, and resume all read
+    // through it; main's finally closes it on every exit path.
+    const input = makeLineInput();
     try {
         switch (command) {
             case "chat": {
@@ -996,11 +1169,11 @@ async function main() {
                 dock.enter();
                 // E 区: a resumed session continues the script at its durable
                 // position — never restarts it (fauxSkip).
-                const agent = await makeAgent(fauxSkip(id));
+                const agent = await makeAgent(fauxSkip(id), input);
                 const session = await agent.session({ id });
                 bodyLog(`session ${id}\n`);
                 extensionsBanner();
-                await chat(session, faux);
+                await chat(session, faux, input);
                 break;
             }
             case "resume": {
@@ -1012,9 +1185,9 @@ async function main() {
                 // (argv = [node, script, resume, id, prompt?]).
                 const prompt = process.argv[4];
                 dock.enter();
-                const agent = await makeAgent(fauxSkip(arg));
+                const agent = await makeAgent(fauxSkip(arg), input);
                 const session = await agent.session({ id: arg });
-                await resume(session, prompt, faux);
+                await resume(session, prompt, faux, input);
                 break;
             }
             case "sessions": {
@@ -1045,12 +1218,13 @@ async function main() {
                 const session = await agent.session({ id });
                 bodyLog(`session ${id}\n`);
                 extensionsBanner();
-                await chat(session, faux);
+                await chat(session, faux, input);
                 break;
             }
         }
     }
     finally {
+        input.close();
         // E 组: every normal and abnormal exit releases the fds and writer
         // locks — no lock file is left behind.
         agent?.close();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vincemakes/kiso-code",
-  "version": "0.1.13",
+  "version": "0.1.14",
   "description": "kiso CLI — the coding-agent reference product: kiso chat / kiso resume / kiso sessions.",
   "type": "module",
   "license": "MIT",
@@ -18,12 +18,12 @@
     "test": "vitest run"
   },
   "dependencies": {
-    "@vincemakes/kiso-core": "0.1.13",
-    "@vincemakes/kiso-evals": "0.1.13",
-    "@vincemakes/kiso-provider-anthropic": "0.1.13",
-    "@vincemakes/kiso-provider-openai": "0.1.13",
-    "@vincemakes/kiso-runtime": "0.1.13",
-    "@vincemakes/kiso-tools-node": "0.1.13"
+    "@vincemakes/kiso-core": "0.1.14",
+    "@vincemakes/kiso-evals": "0.1.14",
+    "@vincemakes/kiso-provider-anthropic": "0.1.14",
+    "@vincemakes/kiso-provider-openai": "0.1.14",
+    "@vincemakes/kiso-runtime": "0.1.14",
+    "@vincemakes/kiso-tools-node": "0.1.14"
   },
   "devDependencies": {
     "@types/node": "^26.1.2",