micro-models-agent 0.63.3 → 1.1.0

package/dist/cli/repl.js

@@ -1,8 +1,8 @@
 import * as readline from "readline";
 import { pc } from "../ui/colors";
 import { LineEditor } from "../ui/line-editor";
-import { existsSync, readFileSync, writeFileSync } from "fs";
-import { join } from "path";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { dirname, join } from "path";
 import { homedir } from "os";
 import { Completer, SlashCommandProvider, SessionNameProvider, SubcommandProvider, SkillNameProvider, ProviderArgProvider, ModelArgProvider, } from "./completer";
 import { Renderer } from "../ui/renderer";
@@ -12,11 +12,15 @@ import { registerAllCommands } from "./repl-commands";
 import { probeLspServers } from "../modules/lsp/probe";
 import { FileOnlyLogger } from "../modules/lsp/client";
 import { DEFAULT_LSP_CONFIG } from "../modules/lsp/config";
+import { errMsg } from "../utils";
 import { SessionLogger } from "../core/session-logger";
 import { formatPlanChecklist, stepContextForTool } from "../ui/plan-view";
 import { formatCost } from "../modules/pricing/prices";
+import { formatCacheLine } from "./cache-line";
 import { probeProviders, targetsFromProviders } from "../modules/providers/health";
-import { writeWarning } from "../ui/output";
+import { formatWarning } from "../ui/md-formatter";
+import { defaultOutputBus, getDefaultChannel, SessionOutputSink, writeNonTtyLine, } from "../output";
+import { createPromptIO } from "../tools/prompt-io";
 function formatContextBar(used, limit, compactions, quality) {
     const pct = Math.min(100, Math.round((used / limit) * 100));
     const barLen = 20;
@@ -53,6 +57,7 @@ export function createHostBridge(opts) {
             if (opts.isBusy())
                 opts.interruptRun();
         },
+        subscribeOutput: (fn) => defaultOutputBus.subscribe(fn),
     };
 }
 export class Repl {
@@ -73,6 +78,17 @@ export class Repl {
     exitOnClose = false;
     /** Owner of plan state (bootstrap). Null in tests — plan UI degrades. */
     execModule;
+    /**
+     * True only once the input prompt frame is actually on screen. The channel's
+     * prompt sink stays inactive until then, so the startup banner prints plainly
+     * instead of erasing/redrawing a frame that was never drawn.
+     */
+    promptPresented = false;
+    /**
+     * Set by `runAgent` so the slash-command path knows the run already restored
+     * the prompt and must not present it a second time (e.g. `/run`).
+     */
+    runHandledPrompt = false;
     rl;
     agent;
     config;
@@ -81,8 +97,25 @@ export class Repl {
     pluginManager;
     logger;
     slog;
+    /**
+     * Persists `data.persist === true` output events to the active session.
+     * Inert until a SessionManager exists; re-bound by `/reload`.
+     */
+    sessionOutput;
     envReport;
-    constructor(agent, config, sessionManager, skillsModule, pluginManager, configDir, baseDir, noAgentsMd, logger, exitOnClose, envReport, historyPath, execModule) {
+    /** Background probe of the actually loaded model context (bootstrap). */
+    contextProbe;
+    /**
+     * Single terminal writer for this REPL. Public (not private) because
+     * `ReplContext` exposes it to slash commands as `ctx.output`; a private
+     * field cannot satisfy a public interface property.
+     */
+    output;
+    /** Bridge that lets the channel draw above the live input frame. */
+    promptSink;
+    /** Terminal-aware PromptIO installed on the agent's tool executor. */
+    promptIO;
+    constructor(agent, config, sessionManager, skillsModule, pluginManager, configDir, baseDir, noAgentsMd, logger, exitOnClose, envReport, historyPath, execModule, contextProbe, output) {
         this.agent = agent;
         this.config = config;
         this.exitOnClose = exitOnClose === true;
@@ -91,59 +124,137 @@ export class Repl {
         this.pluginManager = pluginManager;
         this.logger = logger;
         this.envReport = envReport;
+        this.contextProbe = contextProbe;
         this.execModule = execModule;
         this.slog = new SessionLogger(sessionManager, logger);
+        this.bindSessionOutput();
         this.configDir = configDir || join(homedir(), ".mma");
         this.baseDir = baseDir || process.cwd();
         this.noAgentsMd = noAgentsMd === true;
         this.historyPath = historyPath ?? join(homedir(), ".mma", "repl-history");
         this.loadHistory();
-        this.rl = process.stdin.isTTY
-            ? new LineEditor({
+        const editorCompleter = (line) => {
+            const [matches, partial] = this.completer.complete(line);
+            if (matches.length > 0)
+                return [matches, partial];
+            return [[], line];
+        };
+        if (process.stdin.isTTY) {
+            this.rl = new LineEditor({
                 input: process.stdin,
                 output: process.stdout,
-                prompt: pc.cyan(t("repl.you")),
+                prompt: this.inputPrompt(),
                 history: this.history,
                 historySize: this.maxHistory,
-                completer: (line) => {
-                    const [matches, partial] = this.completer.complete(line);
-                    if (matches.length > 0)
-                        return [matches, partial];
-                    return [[], line];
-                },
-            })
-            : readline.createInterface({
+                completer: editorCompleter,
+            });
+        }
+        else {
+            this.rl = readline.createInterface({
                 input: process.stdin,
                 output: process.stdout,
-                prompt: pc.cyan(t("repl.you")),
+                prompt: this.inputPrompt(),
                 history: this.history,
                 historySize: this.maxHistory,
                 tabSize: 2,
-                completer: (line) => {
-                    const [matches, partial] = this.completer.complete(line);
-                    if (matches.length > 0)
-                        return [matches, partial];
-                    return [[], line];
-                },
+                completer: editorCompleter,
             });
+        }
+        this.output = output ?? getDefaultChannel();
+        this.promptSink = {
+            isActive: () => this.rl instanceof LineEditor &&
+                this.promptPresented &&
+                !this.agentRunning &&
+                !this.inputLocked,
+            printAbove: (text) => {
+                if (this.rl instanceof LineEditor) {
+                    this.rl.printAbove(text);
+                    return;
+                }
+                // Non-TTY fallback (readline / piped stdin): no input frame to redraw
+                // above, so write directly through the sanctioned machine-output helper
+                // — there is no frame for `printAbove` here.
+                writeNonTtyLine(text);
+            },
+            clearScreen: () => {
+                if (this.rl instanceof LineEditor)
+                    this.rl.clearScreen();
+            },
+        };
+        this.output.attachPrompt(this.promptSink);
+        // Terminal-aware prompt surface for interactive tools (question/approve).
+        // The REPL owns stdin and is in `streaming` mode during a run, so tools
+        // must borrow the editor for a question instead of opening a competing
+        // readline that would fight the LineEditor's raw mode.
+        this.promptIO = createPromptIO({
+            ask: (prompt) => this.askViaEditor(prompt),
+            print: (line) => this.output.writeLine(line),
+        });
+        this.agent.setPromptIO?.(this.promptIO);
         registerAllCommands(this);
         this.setupCompleter();
         this.setupListeners();
         // Expose the agent to plugins (web UI etc.) through a narrow bridge.
         if (pluginManager) {
-            pluginManager.setHostBridge(createHostBridge({
-                isBusy: () => this.agentRunning,
-                addPendingImage: (url) => {
-                    this.agent.contextManager?.addPendingImage?.({
-                        type: "image_url",
-                        image_url: { url },
-                    });
-                },
-                runAgent: (text) => this.runAgent(text),
-                interruptRun: () => this.agent.shutdown(),
-            }));
+            this.attachHostBridge(pluginManager);
         }
     }
+    /** (Re)attach the plugin HostBridge. Called at construction and after
+     *  /reload replaces the PluginManager — without this, a reloaded web-ui
+     *  plugin silently loses the ability to submit messages. */
+    attachHostBridge(pm) {
+        const manager = pm ?? this.pluginManager;
+        if (!manager)
+            return;
+        manager.setHostBridge(createHostBridge({
+            isBusy: () => this.agentRunning,
+            addPendingImage: (url) => {
+                this.agent.contextManager?.addPendingImage?.({
+                    type: "image_url",
+                    image_url: { url },
+                });
+            },
+            runAgent: (text) => this.runAgent(text),
+            interruptRun: () => this.agent.shutdown(),
+        }));
+    }
+    /** (Re)bind the session output sink after construction or `/reload`. */
+    bindSessionOutput() {
+        this.sessionOutput?.dispose();
+        this.sessionOutput = this.sessionManager
+            ? new SessionOutputSink(defaultOutputBus, this.sessionManager)
+            : undefined;
+    }
+    /**
+     * Перезагрузка агента и модулей (команда /reload). Живёт здесь, а не в
+     * repl-commands, потому что меняет mutable-поля класса — команда через
+     * интерфейс только вызывает `ctx.reload()`, не ломая readonly-контракт.
+     */
+    async reload() {
+        const { loadConfig } = await import("../config/config");
+        const { bootstrap } = await import("../core/bootstrap");
+        this.agent.shutdown();
+        const projectConfigPath = join(this.baseDir, ".mmrc");
+        const { config: freshConfig } = loadConfig({
+            configDir: this.configDir,
+            projectConfigPath,
+        });
+        Object.assign(this.config, freshConfig);
+        const result = await bootstrap(this.configDir, this.baseDir, false, false);
+        this.agent = result.agent;
+        // Re-install the prompt surface on the freshly bootstrapped agent — the
+        // REPL's `askViaEditor` closure still belongs to this instance.
+        this.agent.setPromptIO?.(this.promptIO);
+        this.sessionManager = result.sessionManager;
+        this.skillsModule = result.skillsModule;
+        this.pluginManager = result.pluginManager;
+        this.execModule = result.execModule;
+        this.bindSessionOutput();
+        // Fresh PluginManager has no bridge — re-register it, otherwise plugins
+        // like web-ui silently lose control of the agent.
+        this.attachHostBridge(result.pluginManager);
+        this.setupCompleter();
+    }
     loadHistory() {
         if (existsSync(this.historyPath)) {
             try {
@@ -156,10 +267,21 @@ export class Repl {
         }
     }
     saveHistory() {
-        const allHistory = this.history.slice(-this.maxHistory);
-        writeFileSync(this.historyPath, allHistory.join("\n"), "utf-8");
+        try {
+            // The history dir may be gone (e.g. a temp dir removed during test or
+            // session teardown). Recreate it and never let a save throw.
+            mkdirSync(dirname(this.historyPath), { recursive: true });
+            const allHistory = this.history.slice(-this.maxHistory);
+            writeFileSync(this.historyPath, allHistory.join("\n"), "utf-8");
+        }
+        catch (e) {
+            this.logger?.debug(`Failed to save REPL history: ${e.message}`);
+        }
     }
     setupCompleter() {
+        // Rebuild from scratch: /reload calls this again after bootstrap, and
+        // re-registering without a reset would duplicate every provider.
+        this.completer.reset();
         const slashCommands = Array.from(this.commands.keys());
         this.completer.registerProvider(new SlashCommandProvider(slashCommands));
         if (this.sessionManager) {
@@ -170,7 +292,7 @@ export class Repl {
             this.completer.registerProvider(new SkillNameProvider(this.skillsModule));
         }
         // Subcommand + argument completion for provider/model management.
-        this.completer.registerProvider(new SubcommandProvider("provider", ["list", "use"]));
+        this.completer.registerProvider(new SubcommandProvider("provider", ["list", "use", "add"]));
         this.completer.registerProvider(new SubcommandProvider("model", ["list", "use"]));
         const entryLabels = this.config.provider?.entries?.map((e) => e.label || e.type) ?? [];
         if (entryLabels.length > 0) {
@@ -232,18 +354,15 @@ export class Repl {
                     if (fullInput) {
                         if (fullInput.startsWith("/")) {
                             await this.executeCommand(fullInput);
+                            this.afterCommand();
                         }
                         else {
                             await this.runAgent(fullInput);
                         }
                     }
-                    if (this.running) {
-                        this.rl.setPrompt(pc.cyan(t("repl.you")));
-                        this.rl.prompt();
-                    }
                 }
                 else {
-                    this.rl.setPrompt(pc.cyan(t("repl.you") + "… "));
+                    this.rl.setPrompt(this.inputPrompt(true));
                     this.rl.prompt();
                 }
                 return;
@@ -251,25 +370,22 @@ export class Repl {
             if (this.isMultiLineInput(trimmed)) {
                 inMultiLine = true;
                 multiLineBuffer = trimmed;
-                this.rl.setPrompt(pc.cyan(t("repl.you") + "… "));
+                this.rl.setPrompt(this.inputPrompt(true));
                 this.rl.prompt();
                 return;
             }
             if (!trimmed) {
-                this.rl.setPrompt(pc.cyan(t("repl.you")));
+                this.rl.setPrompt(this.inputPrompt());
                 this.rl.prompt();
                 return;
             }
             if (trimmed.startsWith("/")) {
                 await this.executeCommand(trimmed);
+                this.afterCommand();
             }
             else {
                 await this.runAgent(trimmed);
             }
-            if (this.running) {
-                this.rl.setPrompt(pc.cyan(t("repl.you")));
-                this.rl.prompt();
-            }
         });
         this.rl.on("close", () => {
             this.running = false;
@@ -303,7 +419,7 @@ export class Repl {
         }
         Repl.sigintHandler = () => {
             if (this.agentRunning) {
-                console.log(pc.yellow(t("repl.ctrl_c_interrupt")));
+                this.output.writeLine(pc.yellow(t("repl.ctrl_c_interrupt")));
                 this.agent.shutdown();
                 this.agentRunning = false;
                 if (forceExitTimer)
@@ -316,6 +432,56 @@ export class Repl {
         };
         process.on("SIGINT", Repl.sigintHandler);
     }
+    /**
+     * Re-present the input prompt after a slash command. Commands do not own a
+     * frame lifecycle, so they need this explicit redraw. The agent path is
+     * deliberately excluded: `runAgent`'s finally calls `LineEditor.resumeFrame()`
+     * as its single prompt presentation, so prompting here again would double-draw.
+     */
+    presentPrompt() {
+        if (!this.running)
+            return;
+        this.rl.setPrompt(this.inputPrompt());
+        this.rl.prompt();
+        this.promptPresented = true;
+    }
+    /**
+     * Reasoning label shown in the input prompt. In `auto` mode the effective
+     * level is normally decided per iteration by the policy, so we show only the
+     * fact that reasoning is automatic. If the user set an explicit override
+     * (`/reasoning <level>`, persistent) or the agent set a still-active
+     * `set_thinking` override (transient), we show `auto→<level>`. In a fixed
+     * mode we show the effective level.
+     */
+    reasoningLabel() {
+        const mode = this.config.reasoning?.mode ?? "default";
+        if (mode !== "auto")
+            return this.agent.reasoningLevel ?? mode;
+        const rs = this.agent.reasoningState;
+        const cooldown = this.config.reasoning?.overrideCooldown ?? 0;
+        const transientActive = rs.overrideIteration >= 0 && this.agent.currentIteration - rs.overrideIteration <= cooldown;
+        if (rs.manual || transientActive)
+            return `auto→${this.agent.reasoningLevel}`;
+        return "auto";
+    }
+    /** Localized input prompt embedding the active reasoning mode/level. */
+    inputPrompt(continuation = false) {
+        const key = continuation ? "repl.you_reasoning_cont" : "repl.you_reasoning";
+        return pc.cyan(t(key, { level: this.reasoningLabel() }));
+    }
+    /**
+     * Prompt bookkeeping after a slash command. A command that drove a run
+     * (e.g. `/run`) already had its prompt restored by `runAgent`; presenting
+     * again would double-render, so skip it exactly once. All other commands
+     * present the prompt here.
+     */
+    afterCommand() {
+        if (this.runHandledPrompt) {
+            this.runHandledPrompt = false;
+            return;
+        }
+        this.presentPrompt();
+    }
     handleSpecialKey(str, key) {
         if (key.name === "escape") {
             // Bun's keypress decoder collapses a fast double-Esc into a single
@@ -329,7 +495,7 @@ export class Repl {
             if (escBytes >= 2 || withinWindow) {
                 this.lastEscTime = 0;
                 if (this.agentRunning) {
-                    process.stdout.write(pc.yellow(`\n${t("repl.interrupt")}\n`));
+                    this.output.writeLine(pc.yellow(`\n${t("repl.interrupt")}`));
                     this.agent.shutdown();
                 }
             }
@@ -349,13 +515,13 @@ export class Repl {
                 const { dataUrl } = await bufferToDataUrl(clipBuf);
                 this.pendingClipboardImage = dataUrl;
                 const sizeKb = Math.round((dataUrl.length * 3) / 4 / 1024);
-                console.log(pc.green(`\n${t("image.attached", { source: "clipboard", size: `${sizeKb} KB` })}`));
+                this.output.writeLine(pc.green(`\n${t("image.attached", { source: "clipboard", size: `${sizeKb} KB` })}`));
                 if (this.rl instanceof LineEditor)
                     this.rl.reset();
                 this.rl.prompt();
             }
             else {
-                console.log(pc.yellow(`\n${t("image.clipboard_empty")}`));
+                this.output.writeLine(pc.yellow(`\n${t("image.clipboard_empty")}`));
                 if (this.rl instanceof LineEditor)
                     this.rl.reset();
                 this.rl.prompt();
@@ -390,23 +556,35 @@ export class Repl {
                 this.pendingClipboardImage = null;
             }
             this.logger?.logREPL("user", input);
-            if (this.rl instanceof LineEditor)
+            // The prompt frame is about to be taken down; deactivate the sink before
+            // any streamed output so nothing tries to draw above it.
+            this.promptPresented = false;
+            // Hand the terminal to the channel for the duration of the run: the
+            // editor stops drawing its frame and ignores typed keys, so streamed
+            // output cannot corrupt the input line. suspendFrame() runs before
+            // reset(), which would otherwise draw a frame only to erase it.
+            if (this.rl instanceof LineEditor) {
+                this.rl.suspendFrame();
+                this.rl.setInputEnabled(false);
                 this.rl.reset();
-            // Overwrite the empty prompt that reset() just drew with a divider,
-            // then label the agent's reply — separates the user's message from
-            // the agent's answer.
-            process.stdout.write("\r" + divider() + "\n" + pc.green(t("repl.agent")));
+            }
+            this.output.beginStreaming();
+            // Divider + agent label, written raw (no trailing newline): the next
+            // Renderer.text() chunk adds its own leading "\n" ("- ..."), so a
+            // writeLine here would insert a blank line ("Agent:\n\n- ...").
+            this.output.writeRaw(`\r${divider()}\n${pc.green(t("repl.agent"))}`);
             const renderer = new Renderer({
                 spinner: this.config.ui?.spinner ?? true,
-                toolStyle: this.config.ui?.toolStyle ?? "inline",
                 baseDir: this.baseDir,
+                channel: this.output,
             });
+            renderer.showLoader();
             const result = await this.agent.run(input, (c) => renderer.text(c), (m) => renderer.meta(m), (ev) => {
                 if (ev.type === "start") {
                     renderer.toolStart(ev.tool, ev.args, stepContextForTool(this.execModule?.getActivePlan() ?? null, ev.tool, ev.args), ev.icon);
                 }
                 else {
-                    renderer.toolEnd(ev.tool, ev.duration ?? 0, ev.error, ev.ctxDelta, ev.costUsd, ev.provider, ev.model);
+                    renderer.toolEnd(ev.tool, ev.duration ?? 0, ev.error, ev.ctxDelta, ev.costUsd);
                     if (ev.tool === "plan" || ev.tool === "todo") {
                         this.renderPlan(renderer);
                     }
@@ -420,18 +598,39 @@ export class Repl {
                 }
             });
             renderer.flush();
-            process.stdout.write("\n");
+            if (result.provider && result.model) {
+                renderer.footer(result.model, result.provider, result.llmDurationMs ?? result.durationMs ?? 0);
+            }
+            this.output.writeLine("");
             this.logger?.logREPL(result.success ? "assistant" : "system", result.text?.slice(0, 400) || result.error || "");
             if (!result.success) {
-                console.error(pc.red(`${t("error.prefix")}${result.error}`));
+                this.output.writeLine(pc.red(`${t("error.prefix")}${result.error}`), "stderr");
             }
             this.showContextBar(result);
             // Close the agent's turn: a divider before the next prompt keeps
             // consecutive user/agent messages visually separated.
-            process.stdout.write("\n" + divider() + "\n");
+            this.output.writeLine(`\n${divider()}`);
         }
         finally {
             this.agentRunning = false;
+            this.output.endStreaming();
+            if (this.rl instanceof LineEditor) {
+                this.rl.setInputEnabled(true);
+                // Single prompt presentation for the agent path: resumeFrame()
+                // redraws the frame, so the `line` listener must NOT prompt again
+                // after runAgent() (it still does after slash commands).
+                // Re-set the prompt first so a reasoning level changed by
+                // set_thinking during the run is reflected on the resumed frame.
+                this.rl.setPrompt(this.inputPrompt());
+                this.rl.resumeFrame();
+                this.promptPresented = true;
+            }
+            else {
+                // Piped/non-TTY fallback has no frame to resume; present the readline
+                // prompt here to preserve the old post-run behavior.
+                this.presentPrompt();
+            }
+            this.runHandledPrompt = true;
         }
     }
     /** Print the checklist of the plan currently tracked by ExecutionModule.
@@ -453,6 +652,11 @@ export class Repl {
         }
     }
     async withExclusiveInput(fn) {
+        // The wizard owns the terminal through its own `rl.question()` calls. Between
+        // questions no frame is active, so its menus/scan results must be written
+        // directly — bracketing with beginModal/endModal would QUEUE the whole
+        // transcript and the user would only see bare `: ` prompts until completion.
+        // `inputLocked` makes `promptSink.isActive()` false, routing writes direct.
         this.inputLocked = true;
         try {
             await fn();
@@ -461,22 +665,60 @@ export class Repl {
             this.inputLocked = false;
         }
     }
+    /**
+     * Borrow the terminal for one interactive-tool question and hand it back.
+     * During a run the LineEditor is suspended with input disabled; enabling
+     * input + resuming the frame lets `question()` read keys while the agent
+     * blocks, and the `finally` restores exactly the streaming state so the
+     * agent's own renderer keeps working afterwards.
+     *
+     * Order matters: `beginModal()` first flushes any output still buffered by
+     * the streaming channel so it prints plainly before the frame returns;
+     * `endModal()` runs only after the frame is suspended again, so events
+     * queued during the question flush plainly instead of corrupting the frame.
+     */
+    async askViaEditor(prompt) {
+        const editor = this.rl instanceof LineEditor ? this.rl : null;
+        const wasSuspended = editor ? editor.isFrameSuspended() : true;
+        const wasEnabled = editor ? editor.isInputEnabled() : false;
+        this.output.beginModal();
+        if (editor) {
+            editor.setInputEnabled(true);
+            editor.resumeFrame();
+        }
+        try {
+            return await new Promise((resolve) => this.rl.question(prompt, resolve));
+        }
+        finally {
+            if (editor) {
+                editor.setInputEnabled(wasEnabled);
+                if (wasSuspended)
+                    editor.suspendFrame();
+                else
+                    editor.resumeFrame();
+            }
+            this.output.endModal();
+        }
+    }
     async executeCommand(input) {
         const parts = input.split(/\s+/);
         const name = parts[0].slice(1);
         const args = parts.slice(1);
+        // Clear any stale run flag from a previous direct agent run so this
+        // command's own presentPrompt() decision is based on its own action.
+        this.runHandledPrompt = false;
         const cmd = this.commands.get(name);
         if (!cmd) {
-            console.log(pc.red(t("cli.unknown_cmd", { name })), t("cli.help_hint"));
+            this.output.writeLine(`${pc.red(t("cli.unknown_cmd", { name }))} ${t("cli.help_hint")}`);
             return;
         }
         try {
             await cmd.action(args);
         }
         catch (err) {
-            console.error(pc.red(t("error.command_error", {
-                message: err instanceof Error ? err.message : String(err),
-            })));
+            this.output.writeLine(pc.red(t("error.command_error", {
+                message: errMsg(err),
+            })), "stderr");
         }
     }
     showHelp() {
@@ -498,15 +740,15 @@ export class Repl {
             }
             if (cmds.length === 0)
                 continue;
-            console.log(pc.bold(t(`repl.group.${groupKey}`)));
+            this.output.writeLine(pc.bold(t(`repl.group.${groupKey}`)));
             for (const cmd of cmds) {
                 const aliases = cmd.aliases?.length ? ` (${pc.dim(cmd.aliases.join(", "))})` : "";
-                console.log(`  ${pc.cyan("/" + cmd.name)}${aliases}  ${pc.dim(cmd.description)}`);
+                this.output.writeLine(`  ${pc.cyan("/" + cmd.name)}${aliases}  ${pc.dim(cmd.description)}`);
                 if (cmd.usage) {
-                    console.log(`    ${pc.dim(cmd.usage)}`);
+                    this.output.writeLine(`    ${pc.dim(cmd.usage)}`);
                 }
             }
-            console.log();
+            this.output.writeLine("");
         }
     }
     lastCompactionShown = 0;
@@ -518,21 +760,25 @@ export class Repl {
         }
         const ui = this.config.ui;
         if (ui?.showContextStats) {
-            console.log();
+            this.output.writeLine("");
             const ctxLine = formatContextBar(result.contextUsed, result.contextLimit, result.compactionCount, result.contextQuality);
-            console.log(ctxLine);
+            this.output.writeLine(ctxLine);
             if (result.totalTokens !== undefined && result.totalTokens > 0) {
                 const apiLine = pc.dim(`  API: ${result.promptTokens} prompt + ${result.completionTokens} completion = ${result.totalTokens} total`);
-                console.log(apiLine);
+                this.output.writeLine(apiLine);
             }
             if (result.totalCost !== undefined && result.totalCost > 0) {
-                console.log(pc.yellow(`  ${t("repl.cost", { cost: formatCost(result.totalCost) })}`));
+                this.output.writeLine(pc.yellow(`  ${t("repl.cost", { cost: formatCost(result.totalCost) })}`));
+            }
+            const cacheLine = formatCacheLine(result.cache);
+            if (cacheLine) {
+                this.output.writeLine(pc.dim(`  ${cacheLine}`));
             }
         }
         else if (ui?.showCompaction && result.compactionCount !== undefined) {
             if (result.compactionCount > this.lastCompactionShown) {
                 this.lastCompactionShown = result.compactionCount;
-                console.log(pc.dim(`\n  ⟳ Context compacted (${result.compactionCount})`));
+                this.output.writeLine(pc.dim(`\n  ⟳ Context compacted (${result.compactionCount})`));
             }
         }
     }
@@ -574,8 +820,9 @@ export class Repl {
             const names = enabledServers.map(([name]) => name).join(", ");
             row(t("repl.mcp_label"), `${pc.white(String(enabledServers.length))}  ${pc.dim(`(${names})`)}`);
         }
-        const cwd = process.cwd();
-        row(t("repl.work_dir"), pc.dim(cwd));
+        // Show the agent's workspace (the `-d` dir), not the process cwd: `bun run`
+        // sets cwd to the package root, which is NOT where the agent operates.
+        row(t("repl.work_dir"), pc.dim(this.baseDir));
         if (this.noAgentsMd) {
             row(t("repl.agents_label"), pc.red(t("repl.disabled")));
         }
@@ -605,9 +852,9 @@ export class Repl {
         const lspEnabled = isTty && (this.config.lsp ?? DEFAULT_LSP_CONFIG).enabled !== false;
         // Plain banner without a surrounding box — line-based, wraps to width.
         for (const line of info) {
-            console.log(pc.dim(line).trimEnd());
+            this.output.writeLine(pc.dim(line).trimEnd());
         }
-        console.log();
+        this.output.writeLine("");
         // Legacy config hint
         try {
             const { existsSync: exists } = await import("fs");
@@ -615,19 +862,22 @@ export class Repl {
             const { hasDomainFiles } = await import("../config/domains");
             const legacyPath = pathJoin(this.configDir, "config.json");
             if (exists(legacyPath) && !hasDomainFiles(this.configDir)) {
-                console.log(pc.yellow(`  ${t("config.legacy_hint")}`));
-                console.log();
+                this.output.writeLine(pc.yellow(`  ${t("config.legacy_hint")}`));
+                this.output.writeLine("");
             }
         }
         catch { }
+        // Single prompt presentation for startup: the banner above was written
+        // plainly (promptPresented was false), so no frame needs erasing here.
         this.rl.prompt();
+        this.promptPresented = true;
         if (lspEnabled) {
             this.probeLspBanner()
                 .then((lspSummary) => {
                 if (lspSummary) {
                     const line = `${pc.green(t("repl.agent"))}${pc.yellow(t("repl.lsp_label"))} ${lspSummary}`;
-                    process.stdout.write(`\x1b[2K\r${divider()}\n${line}\n`);
-                    this.rl.prompt();
+                    // Channel owns the prompt row now: no manual erase + prompt() hack.
+                    this.output.writeLine(`${divider()}\n${line}`);
                 }
             })
                 .catch(() => { });
@@ -645,12 +895,37 @@ export class Repl {
                 .then((results) => {
                 for (const r of results) {
                     if (!r.ok && r.name !== this.config.provider.active) {
-                        writeWarning(t("repl.provider_down", { name: r.name, error: r.error ?? "" }));
+                        this.output.writeLine(formatWarning(t("repl.provider_down", { name: r.name, error: r.error ?? "" })));
                     }
                 }
             })
                 .catch(() => { });
         }
+        // Context probe (background): compare the context length the model is
+        // actually loaded with against the configured window. Same non-blocking
+        // banner pattern as the LSP probe above.
+        if (this.contextProbe) {
+            void this.contextProbe
+                .then((probe) => {
+                if (!probe)
+                    return;
+                this.sessionManager?.appendLog({
+                    ts: new Date().toISOString(),
+                    type: "context_probe",
+                    content: `model=${probe.model} actual=${probe.actual} configured=${this.config.contextWindow}`,
+                });
+                const line = probe.actual < this.config.contextWindow
+                    ? `${pc.yellow("⚠")} ${t("repl.context_probe_small", { model: probe.model, actual: probe.actual, configured: this.config.contextWindow })}`
+                    : probe.actual > this.config.contextWindow
+                        ? `${pc.dim(t("repl.context_probe_big", { model: probe.model, actual: probe.actual }))}`
+                        : null;
+                if (line) {
+                    // Channel owns the prompt row now: no manual erase + prompt() hack.
+                    this.output.writeLine(`${divider()}\n${line}`);
+                }
+            })
+                .catch(() => { });
+        }
     }
     /**
      * Probe the LSP servers applicable to the current project and format a
@@ -695,6 +970,8 @@ export class Repl {
         this.running = false;
         this.saveHistory();
         this.agent.shutdown();
+        this.sessionOutput?.dispose();
+        this.sessionOutput = undefined;
         // Close session log when REPL stops
         this.logger?.closeSessionLog();
         this.rl.close();