@vincemakes/kiso-code 0.1.13 → 0.1.15

package/dist/index.js

@@ -17,6 +17,8 @@
  */
 import { existsSync, mkdtempSync, readFileSync, readdirSync, rmSync, symlinkSync, writeFileSync } from "node:fs";
 import { createInterface } from "node:readline";
+import { Body } from "./body.js";
+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,25 +89,136 @@ 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();
-/** v2b: body output routes through the dock when docked (the cursor into
- *  the scroll region, then back to the input line); otherwise a plain
- *  write — pipes are byte-identical to v2a. */
-function bodyWrite(text) {
-    if (dock.active)
-        dock.writeBody(text);
-    else
-        process.stdout.write(text);
-}
+/** v2d: the body renderer — the ONE writer of the stdout scroll region
+ *  (the frozen area + the active tail). Pipes run it in passthrough (the
+ *  v2b/v2c line-mode bytes, byte-for-byte). Created in main; closed on
+ *  every exit path. */
+let body;
+/** v2d: body output routes through the cell renderer — the single writer.
+ *  bodyLog adds the trailing newline; internal newlines are preserved. */
 function bodyLog(text) {
-    bodyWrite(`${text}\n`);
+    body.raw(text.split("\n"));
 }
 /** v2b: the spinner merged into the STATUS BAR (the v2a standalone glyph
  *  is gone) — docked only, 200ms rotation between the request and the
@@ -171,7 +284,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 +301,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 +475,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 +615,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 +636,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 +678,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,115 +699,104 @@ 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, faux, liveInput, statusCb) {
     let last;
-    // B 区: tool_call_end → (name, input) for the summary; tool_result →
-    // one summary line. Usage events feed the status line.
-    const pendingCalls = new Map();
     let usage = { in: null, out: null, cache: null, known: false };
-    // v2b: thinking blocks buffer and fold to ONE dim line at the block's
-    // end (foldThinking); the FULL text goes to /think.
-    let thinkingBuf = "";
-    const flushThinking = () => {
-        if (thinkingBuf === "")
-            return;
-        lastThinking.current = thinkingBuf;
-        bodyWrite(foldThinking(thinkingBuf));
-        thinkingBuf = "";
-    };
-    let thinkingOpen = false;
-    // v2b: liveness merged into the status bar (docked); a running timer
-    // shows "running <tool> Ns" during a tool execution.
-    const stopSpinner = startStatusSpinner();
-    let stopRunning = null;
-    let firstEvent = true;
     try {
         for await (const ev of run) {
-            if (firstEvent) {
-                firstEvent = false;
-                stopSpinner();
-            }
             last = ev;
-            // v2a (双回显): the interactive readline already echoed an input THIS
-            // process consumed — rendering the event again is the double echo.
-            // 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) {
+            // v2a (双回显): the interactive echo was already rendered by the
+            // input source — rendering the event again is the double echo.
+            // 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.
+            if (ev.type === "user_input" &&
+                liveInput !== null &&
+                liveInput.current === (typeof ev.content === "string" ? ev.content : "") &&
+                process.stdin.isTTY &&
+                !dock.active) {
                 continue;
             }
-            const prevThinking = thinkingOpen;
-            thinkingOpen = ev.type === "thinking";
-            if (prevThinking && !thinkingOpen)
-                flushThinking();
-            if (ev.type === "thinking") {
-                thinkingBuf += ev.text;
-                continue;
-            }
-            if (ev.type === "tool_call_end") {
-                pendingCalls.set(ev.callId, { name: ev.name, input: ev.input ?? {} });
-            }
-            if (ev.type === "tool_execution_started") {
-                stopRunning = startRunningTimer(ev.name);
-            }
-            if (ev.type === "tool_result") {
-                stopRunning?.();
-                stopRunning = null;
-                const call = pendingCalls.get(ev.callId);
-                pendingCalls.delete(ev.callId);
-                if (call !== undefined) {
+            // v2d: EVERY event only mutates a cell — the Body is the single
+            // writer of the scroll region, so interleaving is impossible by
+            // construction (ADR-0040).
+            switch (ev.type) {
+                case "user_input":
+                    body.userLine(typeof ev.content === "string" ? ev.content : "");
+                    break;
+                case "thinking":
+                    body.thinkingAppend(ev.text);
+                    break;
+                case "tool_call_end":
+                    body.toolStart(ev.name, ev.callId, ev.input ?? {});
+                    break;
+                case "tool_execution_started":
+                    body.toolRunning(ev.callId);
+                    break;
+                case "tool_execution_succeeded":
+                    body.toolSucceeded(ev.callId);
+                    break;
+                case "tool_execution_failed":
+                    body.toolFailed(ev.callId, ev.error);
+                    break;
+                case "tool_result": {
                     const text = typeof ev.content === "string" ? ev.content : "";
-                    lastToolRef.current = { name: call.name, input: call.input, result: { content: text, isError: ev.isError } };
-                    bodyLog(renderToolSummary(call.name, call.input, { content: text, isError: ev.isError }));
+                    body.toolResult(ev.callId, { content: text, isError: ev.isError });
+                    break;
                 }
-            }
-            if (ev.type === "usage") {
-                usage = { in: ev.inputTokens, out: ev.outputTokens, cache: ev.cacheRead, known: ev.known };
-                statusCb?.(usage, estimateCtxRatio(session));
-            }
-            if (ev.type === "uncertain_pending") {
-                // 裁决 #12 (ADR-0038): the ⚠ line is pure INFORMATION now — the
-                // approval chain guards retries, and the human question belongs
-                // only to the crash window's recovery flow (resolveUncertains).
-                // Old logs may still carry the event; replay shows the fact.
-                bodyLog(`\n⚠ ${escapeTerminal(ev.name)} FAILED — the side effect may have applied.\n  ${escapeTerminal(ev.error)}\n`);
-                continue;
-            }
-            const rendered = renderEvent(ev, prevThinking);
-            if (rendered.prompt) {
-                // v2b (docked): the detail scrolls into the body; the question
-                // takes over the status position; the answer lands at the input
-                // line. Pipes keep the v2a inline render.
-                bodyWrite(rendered.text);
-                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) `);
-                if (answer === CANCELLED) {
-                    // 十: a cancellation is a CONSERVATIVE denial, explicitly
-                    // distinguished from the user typing "n".
-                    bodyLog("[approval cancelled — treated as a denial]\n");
-                    await session.approve(decisionId, false);
-                    continue;
+                case "text_delta":
+                    body.textAppend(ev.text);
+                    break;
+                case "text_end":
+                    body.textEnd();
+                    break;
+                case "usage":
+                    usage = { in: ev.inputTokens, out: ev.outputTokens, cache: ev.cacheRead, known: ev.known };
+                    statusCb?.(usage, estimateCtxRatio(session));
+                    break;
+                case "uncertain_pending":
+                    // 裁决 #12 (ADR-0038): the ⚠ line is pure INFORMATION now — the
+                    // approval chain guards retries, and the human question belongs
+                    // only to the crash window's recovery flow (resolveUncertains).
+                    body.notice(`⚠ ${escapeTerminal(ev.name)} FAILED — the side effect may have applied. ${escapeTerminal(ev.error)}`);
+                    break;
+                case "permission_requested": {
+                    // v2d: the ToolCell shows the ⏸ badge; the question takes over
+                    // the dock status position; the answer lands at the input line.
+                    body.toolApproval(ev.callId);
+                    const decisionId = ev.decisionId;
+                    const name = ev.name;
+                    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".
+                        body.notice("[approval cancelled — treated as a denial]");
+                        await session.approve(decisionId, false);
+                        continue;
+                    }
+                    await session.approve(decisionId, answer.trim().toLowerCase().startsWith("y"));
+                    break;
+                }
+                case "terminal":
+                    statusCb?.(usage, estimateCtxRatio(session));
+                    // v2a rhythm: the honest label (\ndone\n — the completed
+                    // marker), the status line hugging it, then EXACTLY one blank
+                    // line before the next prompt.
+                    body.terminal(renderEvent(ev).text, renderStatusLine(turnNo, usage, estimateCtxRatio(session), faux) ?? "");
+                    break;
+                default: {
+                    // Events without a cell (stop, …) — the generic render, byte-
+                    // preserved for the pipe path.
+                    const rendered = renderEvent(ev);
+                    if (rendered.text !== "") {
+                        body.raw(rendered.text.replace(/\n$/, "").split("\n"));
+                    }
+                    break;
                 }
-                await session.approve(decisionId, answer.trim().toLowerCase().startsWith("y"));
-            }
-            else {
-                bodyWrite(rendered.text);
-            }
-            if (ev.type === "terminal") {
-                statusCb?.(usage, estimateCtxRatio(session));
-                // v2a rhythm: the status line hugs the terminal (有什么显什么 —
-                // null = nothing to show), then EXACTLY one blank line before
-                // the next prompt.
-                bodyWrite(renderTerminalGap(renderStatusLine(turnNo, usage, estimateCtxRatio(session), faux)));
             }
         }
-        flushThinking();
+        body.thinkingEnd(); // a trailing thinking block folds at the run's end
     }
     finally {
-        stopSpinner();
-        stopRunning?.();
     }
     return last;
 }
@@ -707,35 +814,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, faux, liveInput, 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 +850,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 +866,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 +880,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
@@ -792,23 +916,28 @@ async function chat(session, faux) {
     let chain = Promise.resolve();
     let replReady = false;
     const queuedLines = [];
-    // B 区: user-turn counter for the status line, and the /last buffer.
+    // B 区: user-turn counter for the status line. /last and /think read
+    // the body (the ToolCell / ThinkingCell final states).
     let turnNo = 0;
-    const lastToolRef = { current: null };
     // v2a: the last line THIS process's readline consumed — the double-echo
     // filter (see consumeRun). Only interactive chat sets it.
     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,33 +950,31 @@ 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;
         }
         if (trimmed === "/think") {
-            // v2b: print the last COMPLETE thinking block — straight from the
-            // event stream, nothing stored separately (the /last pattern).
+            // v2b/v2d: print the last COMPLETE thinking block — the body holds
+            // it (the ThinkingCell's fold closes at the block's end).
             chain = chain.then(async () => {
-                const t = lastThinking.current;
+                const t = body.lastThinking();
                 if (t === null) {
                     bodyLog("[no thinking yet]");
                 }
                 else {
                     bodyLog(escapeTerminal(t));
                 }
-                rl.setPrompt(interactivePrompt());
-                rl.prompt();
+                input.prompt();
             });
             return;
         }
         if (trimmed === "/last") {
-            // B 区: print the FULL input/output of the most recent tool call,
-            // straight from the event stream — nothing is stored separately.
-            // Runs on the chain: after any in-flight turn completes.
+            // B 区/v2d: print the FULL input/output of the most recent tool
+            // call — the body holds it (the ToolCell's final state). Runs on
+            // the chain: after any in-flight turn completes.
             chain = chain.then(async () => {
-                const tool = lastToolRef.current;
+                const tool = body.lastTool();
                 if (tool === null) {
                     bodyLog("[no tool call yet]");
                 }
@@ -857,8 +984,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 +998,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, faux, liveInput, 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,13 +1059,10 @@ 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;
-    const lastToolRef = { current: null };
-    const lastThinking = { current: null };
     // v2b: the live status bar (docked only).
     const statusCb = (u, ctx) => {
         if (!dock.active)
@@ -938,19 +1070,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, faux, null, 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 +1096,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 +1123,7 @@ async function resume(session, prompt, faux) {
         }
     }
     finally {
-        rl.close();
+        input.close();
     }
 }
 async function main() {
@@ -987,6 +1132,19 @@ 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();
+    // v2d: the body renderer — active only where the dock is (a color
+    // TTY with a real size); pipes run it in passthrough, byte-for-byte.
+    body = new Body({
+        active: () => process.stdin.isTTY && palette().blue !== "" && (process.stdout.rows ?? 0) >= 4,
+        height: () => process.stdout.rows ?? 24,
+        width: () => process.stdout.columns ?? 80,
+        editCol: () => dock.editCol(),
+    });
     try {
         switch (command) {
             case "chat": {
@@ -996,11 +1154,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 +1170,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 +1203,14 @@ 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 {
+        body.close(); // flush the pending frame, stop the heartbeat
+        input.close();
         // E 组: every normal and abnormal exit releases the fds and writer
         // locks — no lock file is left behind.
         agent?.close();