@vincemakes/kiso-code 0.1.20 → 0.1.21

package/dist/index.js

@@ -14,54 +14,31 @@
  * Sessions live under $KISO_HOME/sessions (default ~/.kiso/sessions) as
  * append-only JSONL. Write/edit/shell tools sit behind the approval policy:
  * the run pauses, asks, and resumes — durably (ADR-0024).
+ *
+ * 手感批 B4 (pure move): the interactive pieces live beside this file —
+ * chat.ts (the REPL + consumeRun), dispatch.ts (the slash dispatcher),
+ * resume.ts, trust-ui.ts (the question surface + E3 merges), faux-glue.ts
+ * (the scripted-model plumbing), state.ts (the shared process state).
+ * index.ts keeps the entry: banner, input sources, the A 区 prompt,
+ * makeAgent, and main.
  */
-import { existsSync, mkdtempSync, readFileSync, readdirSync, rmSync, symlinkSync, writeFileSync } from "node:fs";
+import { readFileSync, rmSync } from "node:fs";
 import { createInterface } from "node:readline";
-import { Body } from "@vincemakes/kiso-tui";
-import { editFileDiff, writeFileDiff } from "@vincemakes/kiso-tui";
-import { MODES, getMode, modeExtensions, modeFromEnv, modeSystemPrompt, setMode } from "./mode.js";
-import { Editor, PROMPT as EDITOR_PROMPT } from "@vincemakes/kiso-tui";
-import { homedir, tmpdir } from "node:os";
-import { dirname, join } from "node:path";
-import { fileURLToPath } from "node:url";
-import { createAgent, disposeExtensions, loadExtensions, loadProjectExtensions, projectArtifacts, recordTrust, SessionStore, trustFor, } from "@vincemakes/kiso-runtime";
+import { join } from "node:path";
+import { Body, Editor, PROMPT as EDITOR_PROMPT, bannerLines, palette, renderSessionLine } from "@vincemakes/kiso-tui";
+import { escapeTerminal } from "@vincemakes/kiso-tui";
+import { createAgent, disposeExtensions, loadExtensions, loadProjectExtensions, SessionStore, } from "@vincemakes/kiso-runtime";
 import { createFauxProvider } from "@vincemakes/kiso-evals";
-import { canonicalTargetPath, createCodingTools } from "@vincemakes/kiso-tools-node";
-import { escapeTerminal, foldResult, foldThinking, palette, renderEvent, renderSessionLine, renderStatusLine, renderTerminalGap, renderToolSummary, bannerLines, kUnit, renderRecap, truncateRow, } from "@vincemakes/kiso-tui";
-import { Dock } from "@vincemakes/kiso-tui";
-/** 发现#11: KISO_HOME is the ONE root — every default path derives from
- *  it (sessions, trust, extensions, mcp config, skills). The dedicated
- *  env vars (KISO_EXTENSIONS_DIR / KISO_MCP_CONFIG / KISO_SKILLS_DIR)
- *  still override their own path; nothing hard-codes ~/.kiso anymore. */
-function kisoHome() {
-    return process.env.KISO_HOME ?? join(homedir(), ".kiso");
-}
-function sessionsDir() {
-    return join(kisoHome(), "sessions");
-}
-/** E1: the extension scan directory — KISO_EXTENSIONS_DIR overrides. */
-function extensionsDir() {
-    return process.env.KISO_EXTENSIONS_DIR ?? join(kisoHome(), "extensions");
-}
-/** E1: the extensions loaded by makeAgent — their names feed the banner. */
-let loadedExtensions = [];
-/** E1: the USER-level extensions alone — the banner's unmarked part (E3:
- *  loadedExtensions later includes the project-level ones too). */
-let userExtensions = [];
-/** E3: the PROJECT-level extensions (loaded after the trust gate) — the
- *  banner distinguishes them from the user-level ones. */
-let projectExtensions = [];
-/** E3: temp artifacts of the mcp/skills merge — removed on exit. */
-const mergedTempPaths = [];
-/** The CLI's own version — read from the package.json next to the build. */
-let VERSION = "?";
-try {
-    const pkg = JSON.parse(readFileSync(join(dirname(fileURLToPath(import.meta.url)), "..", "package.json"), "utf8"));
-    VERSION = pkg.version ?? "?";
-}
-catch {
-    // a packed CLI without a readable package.json still works
-}
+import { createCodingTools } from "@vincemakes/kiso-tools-node";
+import { MODES, modeExtensions, modeFromEnv, modeSystemPrompt, setMode } from "./mode.js";
+import { body, bodyLog, dock, extensionsDir, loadedExtensions, mergedTempPaths, projectExtensions, sessionsDir, setAgentModel, setBody, setExtensionLists, userExtensions, VERSION } from "./state.js";
+import { interactivePrompt, resolveProjectTrust } from "./trust-ui.js";
+import { fauxSkip, readFauxScript } from "./faux-glue.js";
+import { autoCompactFromEnv, chat, contextWindowTokens } from "./chat.js";
+import { resume } from "./resume.js";
+// The moved exports stay reachable from this entry — the test imports
+// (project-trust, coding-agent) never change (B4: 断言零改动).
+export { applyProjectMerges } from "./trust-ui.js";
 /** 横幅: the block-letter logo (design fixed). TTY only — pipes, e2e
  *  drivers, and CI see byte-for-byte the old output; the extensions line
  *  merges into the third row on TTY and stays a standalone line off-TTY.
@@ -80,14 +57,6 @@ function startupBanner() {
     const rows = bannerLines(W > 0 ? W : 80, VERSION, bannerExtensionText().replace(/^ · /, ""));
     return `${rows.map((r) => `${p.dim}${r}${p.reset}`).join("\n")}\n`;
 }
-/** v2a: the interactive prompt — blue, the identity accent. readline owns
- *  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
@@ -200,37 +169,6 @@ function makeLineInput() {
     }
     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();
-/** 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) {
-    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
- *  first event. */
-function startStatusSpinner(onTick) {
-    if (!dock.active)
-        return () => { };
-    // v3 §03/§05: the working glyph family ▖▘▝▗, 200ms rotation — the
-    // callback repaints the running status line with the new glyph.
-    const GLYPHS = ["▖", "▘", "▝", "▗"];
-    let i = 0;
-    const timer = setInterval(() => onTick(GLYPHS[i++ % GLYPHS.length]), 200);
-    timer.unref();
-    return () => clearInterval(timer);
-}
-/** v3 §03: "running <tool> Ns" is gone — the running status line owns
- *  the wall clock; the per-tool timer was the old tail mechanism. */
-/** The model name for the status bar — set by makeAgent. */
-let agentModel = "faux";
 /** E3: the `[N extensions: ...]` text — user-level names, then project-level
  *  ones marked with `project:`. Byte-identical to the historical text when
  *  no project extensions are loaded. */
@@ -257,134 +195,6 @@ function extensionsBanner() {
         return;
     bodyLog(`${text}\n`);
 }
-/**
- * E3 — the project-level trust gate (ADR-0037): capability is trusted by
- * content digest, not by directory. Runs BEFORE any extension loads — the
- * mcp/skills merges must be in the env before the user-level extensions are
- * loaded (the mcp factory reads KISO_MCP_CONFIG at load time, the skills
- * extension scans KISO_SKILLS_DIR at load time).
- *
- * Verdicts: granted → load; refused → never load, never re-ask (refused is
- * sticky — re-evaluate by deleting the trust line or changing a file); no
- * 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(input) {
-    const artifacts = await projectArtifacts(process.cwd());
-    if (artifacts === null)
-        return null; // no .kiso artifacts — nothing to gate
-    const record = trustFor(artifacts.root, artifacts.digest);
-    if (record?.decision === "granted") {
-        applyProjectMerges(artifacts);
-        return artifacts;
-    }
-    if (record?.decision === "refused")
-        return null; // refused is sticky — no re-ask
-    // First discovery — list every artifact (file name + digest short
-    // prefix) and ask the human ONCE.
-    if (!process.stdin.isTTY) {
-        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;
-    }
-    // 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
- * extension load. A server name in BOTH configs is a LOUD error (a silent
- * override would be a supply-chain surprise); a skill name in both merges
- * with project-wins and a stderr note. Exported for tests.
- */
-export function applyProjectMerges(artifacts) {
-    if (artifacts.files.some((f) => f.kind === "mcp"))
-        applyMcpMerge(artifacts.root);
-    if (artifacts.files.some((f) => f.kind === "skill"))
-        applySkillsMerge(artifacts.root);
-}
-/** Read an mcp.json with the mcp extension's tolerance: absent/unreadable →
- *  {}, present-but-broken → throw (the loader convention). */
-function readMcpConfig(path) {
-    let text;
-    try {
-        text = readFileSync(path, "utf8");
-    }
-    catch {
-        return {};
-    }
-    let parsed;
-    try {
-        parsed = JSON.parse(text);
-    }
-    catch (err) {
-        throw new Error(`[project .kiso] cannot parse ${path}: ${err.message}`);
-    }
-    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
-        throw new Error(`[project .kiso] ${path} must be an object with an mcpServers map`);
-    }
-    return parsed;
-}
-/** Merge user-level + project-level mcp.json into one temp file and point
- *  KISO_MCP_CONFIG at it — the mcp extension reads it at load time. */
-function applyMcpMerge(root) {
-    const userPath = process.env.KISO_MCP_CONFIG ?? join(kisoHome(), "mcp.json");
-    const user = readMcpConfig(userPath);
-    const project = readMcpConfig(join(root, "mcp.json"));
-    const userServers = user.mcpServers ?? {};
-    const projectServers = project.mcpServers ?? {};
-    if (Object.keys(projectServers).length === 0)
-        return; // nothing to merge
-    for (const name of Object.keys(projectServers)) {
-        if (name in userServers) {
-            throw new Error(`[project .kiso] mcp server "${name}" exists in both the user-level and the project-level mcp.json`);
-        }
-    }
-    const merged = { mcpServers: { ...userServers, ...projectServers } };
-    const temp = join(tmpdir(), `kiso-mcp-merged-${process.pid}.json`);
-    writeFileSync(temp, `${JSON.stringify(merged, null, 2)}\n`, "utf8");
-    process.env.KISO_MCP_CONFIG = temp;
-    mergedTempPaths.push(temp);
-}
-/** Merge user-level + project-level skills into one temp scan dir (project
- *  skill dirs symlinked first; a name in both → project wins + a stderr
- *  note) and point KISO_SKILLS_DIR at it — the skills extension's existing
- *  scan reads it at load time and per read_skill call. */
-function applySkillsMerge(root) {
-    const userDir = process.env.KISO_SKILLS_DIR ?? join(kisoHome(), "skills");
-    const projectDir = join(root, "skills");
-    const merged = mkdtempSync(join(tmpdir(), "kiso-skills-"));
-    mergedTempPaths.push(merged);
-    for (const dir of readdirSyncSafe(projectDir)) {
-        symlinkSync(join(projectDir, dir), join(merged, dir)); // project wins on collision
-    }
-    for (const dir of readdirSyncSafe(userDir)) {
-        const target = join(merged, dir);
-        if (existsSync(target)) {
-            console.error(`[project .kiso] skill "${dir}" exists in both user and project skills — project wins`);
-            continue;
-        }
-        symlinkSync(join(userDir, dir), target);
-    }
-    process.env.KISO_SKILLS_DIR = merged;
-}
-function readdirSyncSafe(dir) {
-    try {
-        return readdirSync(dir);
-    }
-    catch {
-        return []; // no skills dir on either level = nothing to merge
-    }
-}
 /**
  * A 区: the coding-agent system prompt — ONE constant, byte-stable for the
  * session's lifetime (D 区). Kept under ~80 lines; no template engine.
@@ -440,26 +250,6 @@ export function composeSystemPrompt(cwd) {
     const injected = readProjectInstructions(cwd);
     return injected === "" ? SYSTEM_PROMPT : `${SYSTEM_PROMPT}\n${injected}`;
 }
-/**
- * E 区: how many faux-script turns a session has already consumed. The faux
- * provider's script counter is per-process, so a FRESH process that resumes
- * a session would restart the script at turn 0 — re-issuing the first
- * scripted call instead of continuing the trajectory. The session log is
- * the durable position: a turn is consumed when it produced a tool_result
- * or an end_turn stop — AND when its tool call is unfinished (started but
- * no result): the recovery completes those turns WITHOUT a provider call
- * (executes the approved call, or fills the human verdict), so the model's
- * next response is the turn AFTER them.
- */
-function fauxSkip(id) {
-    const events = new SessionStore(sessionsDir())
-        .load(id)
-        .map((r) => r.event);
-    const results = new Set(events.filter((e) => e.type === "tool_result").map((e) => e.callId));
-    return (events.filter((e) => e.type === "tool_result").length +
-        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, input) {
     const store = new SessionStore(sessionsDir());
     // E3: the project-level trust gate runs BEFORE any extension load (the
@@ -468,14 +258,13 @@ async function makeAgent(fauxSkipTurns = 0, input) {
     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());
+    const user = await loadExtensions(extensionsDir());
     if (project !== null) {
-        projectExtensions = await loadProjectExtensions(process.cwd(), userExtensions);
-        loadedExtensions = [...userExtensions, ...projectExtensions];
+        const proj = await loadProjectExtensions(process.cwd(), user);
+        setExtensionLists(user, proj, [...user, ...proj]);
     }
     else {
-        projectExtensions = [];
-        loadedExtensions = userExtensions;
+        setExtensionLists(user, [], user);
     }
     // Provider wiring (F 组): the CLI never imports provider SDKs directly —
     // the runtime's lazy provider resolution owns them. Real key → real
@@ -496,7 +285,7 @@ async function makeAgent(fauxSkipTurns = 0, input) {
         console.log("[faux mode — set ANTHROPIC_API_KEY or OPENAI_API_KEY for a real model]\n");
         model = "faux";
     }
-    agentModel = model; // v2b: the status bar shows it
+    setAgentModel(model); // v2b: the status bar shows it
     const definition = {
         model,
         store,
@@ -533,749 +322,6 @@ async function makeAgent(fauxSkipTurns = 0, input) {
     };
     return createAgent(definition);
 }
-/**
- * E 区: KISO_FAUX_SCRIPT=<path> overrides the demo script with a JSON
- * FauxScript file — the kill -9 e2e drives the CLI through an exact
- * multi-tool trajectory. Absent → the built-in demo script.
- */
-function readFauxScript() {
-    const path = process.env.KISO_FAUX_SCRIPT;
-    if (path === undefined)
-        return fauxScript();
-    try {
-        const parsed = JSON.parse(readFileSync(path, "utf8"));
-        if (!Array.isArray(parsed))
-            throw new Error("not an array");
-        return parsed;
-    }
-    catch (err) {
-        console.error(`[KISO_FAUX_SCRIPT] cannot load ${path}: ${err.message}`);
-        process.exit(1);
-    }
-}
-/**
- * The keyless demo script: tours the tools so `kiso chat` exercises them.
- * FOUR turns: each user turn consumes two model rounds (call → result →
- * summary), so at least two consecutive user turns work in one process
- * (F 组).
- */
-function fauxScript() {
-    return [
-        {
-            events: [
-                // 自举 P1: a multi-delta thinking block — renders as ONE
-                // streaming segment, not one line per token.
-                { type: "thinking", text: "Let me think about" },
-                { type: "thinking", text: " the workspace" },
-                { type: "thinking", text: " before acting." },
-                { type: "text_start" },
-                { type: "text_delta", text: "I'm the faux model. Let me look at the working directory." },
-                { type: "tool_call_end", callId: "c1", name: "list_dir", input: {} },
-                { type: "stop", reason: "tool_use" },
-            ],
-        },
-        {
-            events: [
-                { type: "text_delta", text: "I see the workspace. What would you like me to inspect or change?" },
-                { type: "stop", reason: "end_turn" },
-            ],
-        },
-        {
-            events: [
-                { type: "text_delta", text: "The faux model is still here, with full context." },
-                { type: "stop", reason: "end_turn" },
-            ],
-        },
-        {
-            events: [
-                { type: "text_delta", text: "And this is the end of the scripted tour." },
-                { type: "stop", reason: "end_turn" },
-            ],
-        },
-    ];
-}
-/** 十: a question cancelled by Ctrl+C — NEVER the empty string, which is a
- *  real user answer (the empty line). The empty answer and the cancellation
- *  are distinct facts. */
-const CANCELLED = Symbol("kiso-question-cancelled");
-/**
- * Ask the human a question. Non-interactive stdin (piped, CI) cannot wait
- * forever: approvals auto-deny and uncertain executions auto-abandon, both
- * printed loudly — never silently ignored, never hung (Area 7).
- *
- * 八/十: the question is ABORTABLE — a pending rl.question is registered in
- * `pendingAsk` and the SIGINT handler resolves it with the CANCELLED
- * sentinel. The rl.question callback is NOT left dangling: an input that
- * arrives after the cancellation is re-emitted as a fresh "line" — it
- * becomes the next user turn instead of being swallowed by the dead
- * question.
- */
-let pendingAsk = null;
-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. 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 = () => {
-            if (settled)
-                return;
-            settled = true;
-            pendingAsk = null;
-            input.cancelQuestion();
-            resolve(CANCELLED); // the run is aborting — the question is dead
-        };
-        // 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.
-                input.emitLine(answer);
-                return;
-            }
-            settled = true;
-            pendingAsk = null;
-            if (dock.active)
-                dock.clearQuestion();
-            resolve(answer);
-        });
-    });
-}
-/**
- * C 区: the model window in tokens — KISO_CONTEXT_WINDOW overrides the
- * 200k default. The microcompact threshold is derived from it (50%), and
- * the status line's ~ctx estimate is measured against it — one source of
- * truth for the window.
- */
-function contextWindowTokens() {
-    const window = Number.parseInt(process.env.KISO_CONTEXT_WINDOW ?? "", 10);
-    return Number.isFinite(window) && window > 0 ? window : DEFAULT_CONTEXT_WINDOW;
-}
-/**
- * B 区: approximate context ratio — chars/4 of the projected messages vs
- * the model window. Marked ~ everywhere it is shown; no counting API.
- */
-function estimateCtxRatio(session) {
-    const projected = session.projected();
-    const chars = JSON.stringify(projected).length;
-    return chars / 4 / contextWindowTokens();
-}
-/** Decide every uncertain execution with the human (r)erun/(a)bandon. */
-async function resolveUncertains(session, input, isCancelled) {
-    for (const uncertain of session.uncertainExecutions()) {
-        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.
-            return;
-        }
-        const resolution = answer.trim().toLowerCase().startsWith("r") ? "rerun" : "abandoned";
-        await session.resolveUncertain(uncertain.executionId, resolution);
-        console.log(`  ${resolution}\n`);
-    }
-}
-/** B 区: default context window for the ~ctx estimate (config overridable). */
-const DEFAULT_CONTEXT_WINDOW = 200_000;
-/**
- * Consume a run, answering approval pauses as they arrive. `resumeMode`
- * marks a session.resume() continuation. v2a: `faux` picks the status
- * line's form; `liveInput` (non-null only in interactive chat) carries the
- * last line THIS process's readline consumed — the double-echo filter.
- */
-/** v2e: the approval-moment mini-diff — edit_file/write_file changes as
- *  ± lines; other tools get null (no diff, no cost). The file read is
- *  best-effort: an unreadable file yields NO diff, never a failure —
- *  the diff must never break the approval. */
-function approvalDiff(name, input) {
-    if (name !== "edit_file" && name !== "write_file")
-        return null;
-    const path = typeof input.path === "string" ? input.path : "";
-    if (path === "")
-        return null;
-    let oldContent = null;
-    try {
-        oldContent = readFileSync(path, "utf8");
-    }
-    catch {
-        // a new write_file target (or an unreadable one) — all + degrades
-    }
-    try {
-        if (name === "edit_file") {
-            const search = typeof input.search === "string" ? input.search : "";
-            const replace = typeof input.replace === "string" ? input.replace : "";
-            if (search === "")
-                return null;
-            return editFileDiff(oldContent ?? "", search, replace);
-        }
-        const content = typeof input.content === "string" ? input.content : "";
-        return writeFileDiff(oldContent, content);
-    }
-    catch {
-        return null; // never let the diff break the approval
-    }
-}
-async function consumeRun(session, run, input, turnNo, faux, liveInput, statusCb) {
-    let last;
-    let usage = { in: null, out: null, cache: null, known: false };
-    // v3 §02: the recap line derives ENTIRELY from the local event stream
-    // (zero tokens) — wall seconds, tool/edit counts, usage, ctx left.
-    const turnStart = Date.now();
-    let toolCount = 0;
-    let editCount = 0;
-    try {
-        for await (const ev of run) {
-            last = ev;
-            // 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;
-            }
-            // 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":
-                    toolCount += 1;
-                    if (ev.name === "edit_file")
-                        editCount += 1;
-                    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 : "";
-                    body.toolResult(ev.callId, { content: text, isError: ev.isError });
-                    break;
-                }
-                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.
-                    // v2e: the mini-diff for edit/write at the approval moment —
-                    // the human sees the change BEFORE deciding (auto-allowed tools
-                    // skip the diff: nobody is looking).
-                    const name = ev.name;
-                    body.toolApproval(ev.callId, approvalDiff(name, ev.input ?? {}));
-                    const decisionId = ev.decisionId;
-                    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": {
-                    // v3 §02: the run's recap line REPLACES the old "done" label
-                    // + status line — one local line, derived from this run's
-                    // events (zero tokens). The dock's status bar still paints.
-                    statusCb?.(usage, estimateCtxRatio(session));
-                    const ratio = estimateCtxRatio(session);
-                    bodyLog(renderRecap({
-                        seconds: Math.round((Date.now() - turnStart) / 1000),
-                        tools: toolCount,
-                        edits: editCount,
-                        usage,
-                        ctxLeftPct: Number.isFinite(ratio) ? (1 - ratio) * 100 : null,
-                    }));
-                    break;
-                }
-                default: {
-                    // Events without a cell (stop, …) — the generic render, byte-
-                    // preserved for the pipe path.
-                    const rendered = renderEvent(ev, false, canonicalTargetPath);
-                    if (rendered.text !== "") {
-                        body.raw(rendered.text.replace(/\n$/, "").split("\n"));
-                    }
-                    break;
-                }
-            }
-        }
-        body.thinkingEnd(); // a trailing thinking block folds at the run's end
-    }
-    finally {
-    }
-    return last;
-}
-/** 十: a faux-mode run whose scripted turns are exhausted must NOT print a
- * provider error and exit 0 — the honest outcome is a loud message and a
- * non-zero exit. Thrown as a CONTROLLED exception (never process.exit):
- * the REPL closes, the error propagates through main's finally (so
- * agent.close() runs and no lock is left behind), and main's catch sets
- * the exit code. Only the exhaustion signature (the empty stream after
- * the declared turns) triggers the script-specific message; any other
- * error terminal still exits non-zero. */
-class FauxExhaustionError extends Error {
-    constructor(message) {
-        super(message);
-        this.name = "FauxExhaustionError";
-    }
-}
-function failOnFauxExhaustion(last, faux, input) {
-    if (!faux)
-        return;
-    if (last?.type !== "terminal" || last.outcome.kind !== "error")
-        return;
-    const message = last.outcome.error.message;
-    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, input) {
-    let currentRun = null;
-    let cancelled = false;
-    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 = text;
-        const run = session.run(text);
-        currentRun = run;
-        turnNo += 1;
-        const myTurn = turnNo;
-        // v3 §03: the running state owns the status bar — the glyph
-        // rotates every 200ms; the idle state returns after the run.
-        runStart = Date.now();
-        runUsage = { in: null, out: null, cache: null, known: false };
-        const stopSpinner = startStatusSpinner((g) => {
-            runGlyph = g;
-            paintRunning();
-        });
-        (async () => {
-            let last;
-            try {
-                last = await consumeRun(session, run, input, myTurn, faux, liveInput, statusCb);
-                stopSpinner();
-                paintIdle();
-                currentRun = null;
-                // 八: a faux script that ran out of declared turns exits
-                // loudly with a non-zero status — never a silent status 0.
-                // 第四轮(对抗): the exhaustion is a CONTROLLED rejection of
-                // 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, input);
-                // 八: after EVERY turn the prompt is re-armed — the human
-                // never types blind after the first turn.
-                input.prompt();
-                resolve();
-            }
-            catch (err) {
-                // A run failure must not freeze the REPL (review finding
-                // 11): surface it and re-arm the prompt.
-                if (err instanceof FauxExhaustionError) {
-                    currentRun = null;
-                    reject(err);
-                    return;
-                }
-                console.error(`\n[run failed] ${err instanceof Error ? err.message : String(err)}\n`);
-                currentRun = null;
-                input.prompt();
-                resolve();
-            }
-        })();
-    });
-    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
-            // aborted terminal, which the consumer keeps consuming.
-            console.log("\n[aborting run]");
-            pendingAsk?.();
-            currentRun.abort();
-        }
-        else if (pendingAsk !== null) {
-            pendingAsk?.(); // a startup/trust question — cancel it
-        }
-        else if (input.line() === "") {
-            cancelled = true;
-            console.log("\n[exit requested]");
-            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
-    // startup recovery — a cancelled question's re-emitted "line" needs a
-    // listener from the very first instant, or the input is silently lost.
-    // Turns are SERIALIZED on a chain — piped lines arrive faster than
-    // turns complete, and concurrent runs are forbidden. Lines that arrive
-    // while the recovery is still running are QUEUED and replayed once the
-    // REPL is ready (they are never dropped).
-    let chain = Promise.resolve();
-    let replReady = false;
-    const queuedLines = [];
-    // B 区: user-turn counter for the status line. /last and /think read
-    // the body (the ToolCell / ThinkingCell final states).
-    let turnNo = 0;
-    // v2a: the last line THIS process's readline consumed — the double-echo
-    // filter (see consumeRun). Only interactive chat sets it.
-    const liveInput = { 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). Modes: /mode switches repaint
-    // it immediately through paintStatus (the last turn stats are kept).
-    // v3 §03: the status bar has TWO states. Idle: the mode is ALWAYS
-    // shown (default included) with the /mode hint. Running: the working
-    // glyph (▖▘▝▗ — the spinner drives it) + wall seconds + ↓ out tokens
-    // + the interrupt hint. ctx left is the live estimate everywhere.
-    let runUsage = { in: null, out: null, cache: null, known: false };
-    let runGlyph = "▖";
-    let runStart = Date.now();
-    const paintRunning = () => {
-        if (!dock.active)
-            return;
-        const ratio = estimateCtxRatio(session);
-        const pct = Number.isFinite(ratio) ? Math.round((1 - ratio) * 100) : null;
-        const out = runUsage.out !== null ? ` ↓ ${kUnit(runUsage.out)} tokens` : "";
-        dock.setStatus(`${runGlyph} working ${Math.max(1, Math.round((Date.now() - runStart) / 1000))}s${out} · esc to interrupt · ctx left ~${pct}%`);
-    };
-    const paintIdle = () => {
-        if (!dock.active)
-            return;
-        const ratio = estimateCtxRatio(session);
-        const pct = Number.isFinite(ratio) ? Math.round((1 - ratio) * 100) : null;
-        dock.setStatus(`▸ ${getMode()} · /mode to switch · ${agentModel} · ctx left ~${pct}%`);
-    };
-    const statusCb = (u, ctx) => {
-        runUsage = u;
-        paintRunning();
-    };
-    // 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.
-            // v2a: the command names are the blue identity accent.
-            const p = palette();
-            const cmd = (name, desc) => `${p.blue}${name}${p.reset}    ${desc}`;
-            chain = chain.then(async () => {
-                bodyLog(cmd("/help", "print this list of commands"));
-                bodyLog(cmd("/think", "show the last full thinking block"));
-                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("/mode", "show the approval tier; /mode <name> switches (manual/default/accept-edits/plan/bypass)"));
-                bodyLog(cmd("/compact", "summarize the older conversation to free context"));
-                bodyLog(cmd("exit", "leave the session"));
-                input.prompt();
-            });
-            return;
-        }
-        if (trimmed === "/think") {
-            // 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 = body.lastThinking();
-                if (t === null) {
-                    bodyLog("[no thinking yet]");
-                }
-                else {
-                    bodyLog(escapeTerminal(t));
-                }
-                input.prompt();
-            });
-            return;
-        }
-        if (trimmed === "/last") {
-            // 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 = body.lastTool();
-                if (tool === null) {
-                    bodyLog("[no tool call yet]");
-                }
-                else {
-                    bodyLog(`--- ${tool.name} input ---`);
-                    bodyLog(escapeTerminal(JSON.stringify(tool.input, null, 2)));
-                    bodyLog(`--- ${tool.name} output${tool.result.isError ? " (error)" : ""} ---`);
-                    bodyLog(escapeTerminal(tool.result.content));
-                }
-                input.prompt();
-            });
-            return;
-        }
-        if (trimmed === "/status") {
-            // B 区: session id, durable event count, and the ~ context
-            // estimate — all read straight from the live session, nothing
-            // stored separately. Runs on the chain after any in-flight turn.
-            chain = chain.then(async () => {
-                const ctxRatio = estimateCtxRatio(session);
-                const ctx = Number.isFinite(ctxRatio) ? `~${Math.round(ctxRatio * 100)}%` : "~?";
-                bodyLog(`session ${session.id}`);
-                bodyLog(`${session.log.all.length} events`);
-                bodyLog(`ctx ${ctx}`);
-                input.prompt();
-            });
-            return;
-        }
-        if (trimmed === "/mode" || trimmed.startsWith("/mode ")) {
-            // Modes: /mode alone prints the current tier + the list;
-            // /mode <name> switches — the notice cell leaves the audit
-            // line in the body, the status bar repaints at once.
-            chain = chain.then(async () => {
-                const m = MODES.find((x) => x === trimmed.slice(5).trim());
-                if (trimmed.slice(5).trim() === "") {
-                    bodyLog(`mode ${getMode()}`);
-                    bodyLog(`tiers: ${MODES.join(" ")}`);
-                }
-                else if (m === undefined) {
-                    bodyLog(`no such mode: ${trimmed.slice(5).trim()}`);
-                    bodyLog(`tiers: ${MODES.join(" ")}`);
-                }
-                else {
-                    setMode(m);
-                    body.notice(`mode → ${m}`);
-                    paintIdle();
-                }
-                input.prompt();
-            });
-            return;
-        }
-        if (trimmed === "/compact") {
-            // /compact (ADR-0044): the older conversation becomes one
-            // model summary — an OFF-LOOP call through the session's own
-            // adapter, so it must never race a running turn: refused
-            // mid-run, with a hint to wait for the turn to end.
-            if (currentRun !== null) {
-                body.notice("[/compact] a turn is running — wait for it to finish");
-                return;
-            }
-            chain = chain.then(async () => {
-                try {
-                    const result = await session.summarize();
-                    if (result === null) {
-                        body.notice("[/compact] nothing to compact — fewer than 5 rounds yet");
-                    }
-                    else {
-                        body.notice(`[/compact] saved ~${result.savedTokens.toLocaleString("en-US")} tokens`);
-                    }
-                }
-                catch (err) {
-                    // Honest failure: nothing was persisted, the session
-                    // is unchanged (ADR-0044 crash semantics).
-                    body.notice(`[/compact] failed: ${err instanceof Error ? err.message : String(err)}`);
-                }
-                input.prompt();
-            });
-            return;
-        }
-        if (trimmed === "exit" || trimmed === "") {
-            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;
-        }
-        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, input, () => cancelled);
-    if (!cancelled) {
-        const recoveryRun = session.resume();
-        currentRun = recoveryRun;
-        turnNo += 1;
-        const last = await consumeRun(session, recoveryRun, input, turnNo, faux, liveInput, statusCb);
-        currentRun = null;
-        failOnFauxExhaustion(last, faux, input);
-    }
-    if (cancelled) {
-        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) {
-        dispatch(line);
-    }
-    queuedLines.length = 0;
-    input.prompt();
-    await input.closed;
-    await chain; // never exit while a turn is in flight
-}
-/**
- * Resume = the RECOVERY flow (Area 2/7): uncertain executions are decided,
- * the interrupted run is continued via session.resume() — never faked with
- * a new prompt. An optional prompt afterwards starts a genuinely new turn.
- * 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, input) {
-    let currentRun = null;
-    let cancelled = false;
-    let turnNo = 0;
-    // v3 §03: the two-state status bar (see chat — same shapes).
-    let runUsage = { in: null, out: null, cache: null, known: false };
-    let runGlyph = "▖";
-    let runStart = Date.now();
-    const statusCb = (u, ctx) => {
-        runUsage = u;
-        if (!dock.active)
-            return;
-        const pct = Number.isFinite(ctx) ? Math.round((1 - ctx) * 100) : null;
-        const out = runUsage.out !== null ? ` ↓ ${kUnit(runUsage.out)} tokens` : "";
-        dock.setStatus(`${runGlyph} working ${Math.max(1, Math.round((Date.now() - runStart) / 1000))}s${out} · esc to interrupt · ctx left ~${pct}%`);
-    };
-    const paintIdle = () => {
-        if (!dock.active)
-            return;
-        const ratio = estimateCtxRatio(session);
-        const pct = Number.isFinite(ratio) ? Math.round((1 - ratio) * 100) : null;
-        dock.setStatus(`▸ ${getMode()} · /mode to switch · ${agentModel} · ctx left ~${pct}%`);
-    };
-    const withRun = async (run) => {
-        currentRun = run;
-        runStart = Date.now();
-        runUsage = { in: null, out: null, cache: null, known: false };
-        const stopSpinner = startStatusSpinner((g) => {
-            runGlyph = g;
-            statusCb(runUsage, estimateCtxRatio(session));
-        });
-        try {
-            turnNo += 1;
-            const last = await consumeRun(session, run, input, turnNo, faux, null, statusCb);
-            failOnFauxExhaustion(last, faux, input);
-        }
-        finally {
-            stopSpinner();
-            paintIdle();
-            currentRun = null;
-        }
-    };
-    input.onSigint(() => {
-        if (currentRun) {
-            // 八: Ctrl+C cancels the pending question AND the run.
-            console.log("\n[aborting run]");
-            pendingAsk?.();
-            currentRun.abort();
-        }
-        else if (!cancelled) {
-            // 第四轮(对抗): also unblock a pending startup question — the
-            // readline close alone would leave ask() hanging forever.
-            // 第五轮(P2-2): the cancellation is recorded so the recovery is
-            // NOT started afterwards — Ctrl+C exits cleanly.
-            cancelled = true;
-            console.log("\n[exit requested]");
-            pendingAsk?.();
-            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, input, () => cancelled);
-        if (!cancelled) {
-            await withRun(session.resume());
-            if (prompt !== undefined && prompt !== "") {
-                await withRun(session.run(prompt));
-            }
-        }
-    }
-    finally {
-        input.close();
-    }
-}
 async function main() {
     // Modes: --mode <name> wins over KISO_MODE — both applied before the
     // first makeAgent (the tier extensions read `current` live). The flag
@@ -1306,13 +352,13 @@ async function main() {
     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({
+    setBody(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(),
         onDock: () => dock.redraw(), // v2d-B: the freeze scrolls the dock up — re-pin it
-    });
+    }));
     try {
         switch (command) {
             case "chat": {
@@ -1326,7 +372,7 @@ async function main() {
                 const session = await agent.session({ id });
                 bodyLog(`session ${id}\n`);
                 extensionsBanner();
-                await chat(session, faux, input);
+                await chat(session, faux, input, autoCompactFromEnv());
                 break;
             }
             case "resume": {
@@ -1371,7 +417,7 @@ async function main() {
                 const session = await agent.session({ id });
                 bodyLog(`session ${id}\n`);
                 extensionsBanner();
-                await chat(session, faux, input);
+                await chat(session, faux, input, autoCompactFromEnv());
                 break;
             }
         }