micro-models-agent 0.52.1 → 0.54.0

package/dist/cli/repl.js

@@ -0,0 +1,702 @@
+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 { homedir } from "os";
+import { Completer, SlashCommandProvider, SessionNameProvider, SubcommandProvider, SkillNameProvider, ProviderArgProvider, ModelArgProvider, } from "./completer";
+import { Renderer } from "../ui/renderer";
+import { divider } from "../ui/box";
+import { t } from "../i18n/index";
+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 { SessionLogger } from "../core/session-logger";
+import { formatPlanChecklist, stepContextForTool } from "../ui/plan-view";
+import { formatCost } from "../modules/pricing/prices";
+import { probeProviders, targetsFromProviders } from "../modules/providers/health";
+import { writeWarning } from "../ui/output";
+function formatContextBar(used, limit, compactions, quality) {
+    const pct = Math.min(100, Math.round((used / limit) * 100));
+    const barLen = 20;
+    const filled = Math.round((pct / 100) * barLen);
+    const bar = pc.green("█".repeat(filled)) + pc.dim("░".repeat(barLen - filled));
+    const pctStr = pct >= 75 ? pc.yellow(`${pct}%`) : pc.dim(`${pct}%`);
+    let line = `  ${bar}  ${pctStr}  ${pc.dim(`(${used} / ${limit} tokens)`)}`;
+    if (compactions !== undefined) {
+        line += pc.dim(`  compactions: ${compactions}`);
+    }
+    if (quality !== undefined) {
+        const qColor = quality >= 70 ? pc.green : quality >= 40 ? pc.yellow : pc.red;
+        line += `  ${qColor(`quality: ${quality}%`)}`;
+    }
+    return line;
+}
+/**
+ * Build the HostBridge exposed to plugins as `ctx.hostBridge`. Web clients
+ * (and any other plugin) submit messages through the SAME runAgent path as
+ * terminal input — rendering, session logging and single-flight guard are
+ * shared, never duplicated.
+ */
+export function createHostBridge(opts) {
+    return {
+        isBusy: opts.isBusy,
+        async submit(text, o) {
+            if (opts.isBusy())
+                throw new Error("agent is busy");
+            for (const url of o?.images ?? [])
+                opts.addPendingImage(url);
+            return opts.runAgent(text);
+        },
+        interrupt() {
+            if (opts.isBusy())
+                opts.interruptRun();
+        },
+    };
+}
+export class Repl {
+    completer = new Completer();
+    modelCache = [];
+    running = false;
+    agentRunning = false;
+    inputLocked = false;
+    historyPath;
+    history = [];
+    maxHistory = 1000;
+    lastEscTime = 0;
+    doubleEscDelay = 500;
+    configDir;
+    baseDir;
+    noAgentsMd;
+    pendingClipboardImage = null;
+    exitOnClose = false;
+    /** Owner of plan state (bootstrap). Null in tests — plan UI degrades. */
+    execModule;
+    rl;
+    agent;
+    config;
+    sessionManager;
+    skillsModule;
+    pluginManager;
+    logger;
+    slog;
+    envReport;
+    constructor(agent, config, sessionManager, skillsModule, pluginManager, configDir, baseDir, noAgentsMd, logger, exitOnClose, envReport, historyPath, execModule) {
+        this.agent = agent;
+        this.config = config;
+        this.exitOnClose = exitOnClose === true;
+        this.sessionManager = sessionManager;
+        this.skillsModule = skillsModule;
+        this.pluginManager = pluginManager;
+        this.logger = logger;
+        this.envReport = envReport;
+        this.execModule = execModule;
+        this.slog = new SessionLogger(sessionManager, logger);
+        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({
+                input: process.stdin,
+                output: process.stdout,
+                prompt: pc.cyan(t("repl.you")),
+                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({
+                input: process.stdin,
+                output: process.stdout,
+                prompt: pc.cyan(t("repl.you")),
+                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];
+                },
+            });
+        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(),
+            }));
+        }
+    }
+    loadHistory() {
+        if (existsSync(this.historyPath)) {
+            try {
+                const raw = readFileSync(this.historyPath, "utf-8");
+                this.history = raw.split("\n").filter(Boolean).slice(-this.maxHistory);
+            }
+            catch {
+                this.history = [];
+            }
+        }
+    }
+    saveHistory() {
+        const allHistory = this.history.slice(-this.maxHistory);
+        writeFileSync(this.historyPath, allHistory.join("\n"), "utf-8");
+    }
+    setupCompleter() {
+        const slashCommands = Array.from(this.commands.keys());
+        this.completer.registerProvider(new SlashCommandProvider(slashCommands));
+        if (this.sessionManager) {
+            this.completer.registerProvider(new SessionNameProvider(() => this.sessionManager.list().map((s) => s.name)));
+        }
+        if (this.skillsModule) {
+            this.completer.registerProvider(new SubcommandProvider("skill", ["list", "loaded", "load", "unload", "search"]));
+            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("model", ["list", "use"]));
+        const entryLabels = this.config.provider?.entries?.map((e) => e.label || e.type) ?? [];
+        if (entryLabels.length > 0) {
+            this.completer.registerProvider(new ProviderArgProvider(entryLabels));
+        }
+        this.completer.registerProvider(new ModelArgProvider(() => this.modelCache));
+        // Warm the model cache in the background (free listModels call).
+        this.refreshModelCache();
+    }
+    /**
+     * Background refresh of the cached model list used by `/model use <Tab>`.
+     * Best-effort: on failure the cache keeps its previous contents.
+     */
+    refreshModelCache() {
+        void (async () => {
+            try {
+                const name = this.config.provider.active ||
+                    this.config.provider.entries?.[0]?.label ||
+                    this.config.provider.type;
+                const provider = this.agent.getProviderFor(name);
+                if (!provider)
+                    return;
+                const models = await provider.listModels();
+                if (models.length > 0) {
+                    this.modelCache = models.sort();
+                }
+            }
+            catch {
+                // keep previous cache
+            }
+        })();
+    }
+    setupListeners() {
+        let multiLineBuffer = "";
+        let inMultiLine = false;
+        this.rl.on("line", async (line) => {
+            const trimmed = line.trim();
+            if (this.agentRunning || this.inputLocked) {
+                if (trimmed) {
+                    this.history.push(trimmed);
+                    if (this.history.length > this.maxHistory) {
+                        this.history = this.history.slice(-this.maxHistory);
+                    }
+                }
+                return;
+            }
+            if (trimmed) {
+                this.history.push(trimmed);
+                if (this.history.length > this.maxHistory) {
+                    this.history = this.history.slice(-this.maxHistory);
+                }
+            }
+            if (inMultiLine) {
+                multiLineBuffer += "\n" + line;
+                if (!this.isMultiLineInput(multiLineBuffer)) {
+                    inMultiLine = false;
+                    const fullInput = multiLineBuffer.trim();
+                    multiLineBuffer = "";
+                    if (fullInput) {
+                        if (fullInput.startsWith("/")) {
+                            await this.executeCommand(fullInput);
+                        }
+                        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.prompt();
+                }
+                return;
+            }
+            if (this.isMultiLineInput(trimmed)) {
+                inMultiLine = true;
+                multiLineBuffer = trimmed;
+                this.rl.setPrompt(pc.cyan(t("repl.you") + "… "));
+                this.rl.prompt();
+                return;
+            }
+            if (!trimmed) {
+                this.rl.setPrompt(pc.cyan(t("repl.you")));
+                this.rl.prompt();
+                return;
+            }
+            if (trimmed.startsWith("/")) {
+                await this.executeCommand(trimmed);
+            }
+            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;
+            this.saveHistory();
+            this.agent.shutdown();
+            // Close session log when REPL exits
+            this.logger?.closeSessionLog();
+            if (this.exitOnClose)
+                process.exit(0);
+        });
+        if (this.exitOnClose && !process.stdin.isTTY) {
+            process.stdin.on("end", () => {
+                this.running = false;
+                this.saveHistory();
+                this.agent.shutdown();
+                // Close session log when REPL exits
+                this.logger?.closeSessionLog();
+                process.exit(0);
+            });
+        }
+        if (this.rl instanceof LineEditor) {
+            this.rl.onKeyInput = (str, key) => this.handleSpecialKey(str, key);
+        }
+        let forceExitTimer = null;
+        // Idempotent registration: a second Repl in the same process must not add
+        // another global SIGINT handler. Leaked handlers from REPL instances
+        // created in tests fired process.exit(0) on ANY process.emit("SIGINT")
+        // elsewhere and silently terminated the whole bun test runner.
+        if (typeof Repl.sigintHandler === "function") {
+            process.removeListener("SIGINT", Repl.sigintHandler);
+        }
+        Repl.sigintHandler = () => {
+            if (this.agentRunning) {
+                console.log(pc.yellow(t("repl.ctrl_c_interrupt")));
+                this.agent.shutdown();
+                this.agentRunning = false;
+                if (forceExitTimer)
+                    clearTimeout(forceExitTimer);
+                forceExitTimer = setTimeout(() => process.exit(1), 2000).unref();
+            }
+            else {
+                process.exit(0);
+            }
+        };
+        process.on("SIGINT", Repl.sigintHandler);
+    }
+    handleSpecialKey(str, key) {
+        if (key.name === "escape") {
+            // Bun's keypress decoder collapses a fast double-Esc into a single
+            // keypress whose `sequence` contains two ESC bytes ("\x1b\x1b").
+            // Counting bytes (not events) catches both the collapsed case and
+            // the case where two separate escape keypresses land in the window.
+            const escBytes = key.sequence ? (key.sequence.match(/\x1b/g) || []).length : 1;
+            const now = Date.now();
+            const withinWindow = now - this.lastEscTime < this.doubleEscDelay;
+            this.lastEscTime = now;
+            if (escBytes >= 2 || withinWindow) {
+                this.lastEscTime = 0;
+                if (this.agentRunning) {
+                    process.stdout.write(pc.yellow(`\n${t("repl.interrupt")}\n`));
+                    this.agent.shutdown();
+                }
+            }
+            return true;
+        }
+        if (key.ctrl && key.name === "v" && !this.agentRunning) {
+            this.pasteClipboardImage();
+            return true;
+        }
+        return false;
+    }
+    async pasteClipboardImage() {
+        try {
+            const { readClipboardImage, bufferToDataUrl } = await import("../llm/image-utils");
+            const clipBuf = await readClipboardImage();
+            if (clipBuf) {
+                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` })}`));
+                if (this.rl instanceof LineEditor)
+                    this.rl.reset();
+                this.rl.prompt();
+            }
+            else {
+                console.log(pc.yellow(`\n${t("image.clipboard_empty")}`));
+                if (this.rl instanceof LineEditor)
+                    this.rl.reset();
+                this.rl.prompt();
+            }
+        }
+        catch {
+            // clipboard read failed — ignore, let terminal paste text normally
+        }
+    }
+    isMultiLineInput(line) {
+        if (line.endsWith("\\"))
+            return true;
+        const openBraces = (line.match(/\{/g) || []).length;
+        const closeBraces = (line.match(/\}/g) || []).length;
+        if (openBraces > closeBraces)
+            return true;
+        return false;
+    }
+    async runAgent(input) {
+        if (this.agentRunning)
+            return;
+        this.agentRunning = true;
+        try {
+            if (this.pendingClipboardImage) {
+                const contextManager = this.agent.contextManager;
+                if (contextManager) {
+                    contextManager.addPendingImage({
+                        type: "image_url",
+                        image_url: { url: this.pendingClipboardImage },
+                    });
+                }
+                this.pendingClipboardImage = null;
+            }
+            this.logger?.logREPL("user", input);
+            if (this.rl instanceof LineEditor)
+                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")));
+            const renderer = new Renderer({
+                spinner: this.config.ui?.spinner ?? true,
+                toolStyle: this.config.ui?.toolStyle ?? "inline",
+                baseDir: this.baseDir,
+            });
+            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);
+                    if (ev.tool === "plan" || ev.tool === "todo") {
+                        this.renderPlan(renderer);
+                    }
+                }
+            }, (phase) => {
+                if (phase === "thinking") {
+                    renderer.thinkingStart();
+                }
+                else {
+                    renderer.thinkingEnd();
+                }
+            });
+            renderer.flush();
+            process.stdout.write("\n");
+            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.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");
+        }
+        finally {
+            this.agentRunning = false;
+        }
+    }
+    /** Print the checklist of the plan currently tracked by ExecutionModule.
+     *  Called only on plan/todo tool events (a change event) — never polled,
+     *  so a disk-resident plan from a previous session cannot leak into chat. */
+    renderPlan(renderer) {
+        const plan = this.execModule?.getActivePlan();
+        if (!plan)
+            return;
+        renderer.planBlock(formatPlanChecklist(plan));
+    }
+    commands = new Map();
+    registerCommand(cmd) {
+        this.commands.set(cmd.name, cmd);
+        if (cmd.aliases) {
+            for (const alias of cmd.aliases) {
+                this.commands.set(alias, cmd);
+            }
+        }
+    }
+    async withExclusiveInput(fn) {
+        this.inputLocked = true;
+        try {
+            await fn();
+        }
+        finally {
+            this.inputLocked = false;
+        }
+    }
+    async executeCommand(input) {
+        const parts = input.split(/\s+/);
+        const name = parts[0].slice(1);
+        const args = parts.slice(1);
+        const cmd = this.commands.get(name);
+        if (!cmd) {
+            console.log(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),
+            })));
+        }
+    }
+    showHelp() {
+        const { COMMAND_GROUPS } = require("./repl-commands");
+        const order = ["general", "agent", "session", "skill"];
+        const seen = new Set();
+        for (const groupKey of order) {
+            const cmds = [];
+            for (const [name, cmd] of this.commands) {
+                if (cmd.aliases?.includes(name))
+                    continue;
+                if (seen.has(cmd.name))
+                    continue;
+                const group = COMMAND_GROUPS[cmd.name] ?? "general";
+                if (group !== groupKey)
+                    continue;
+                seen.add(cmd.name);
+                cmds.push(cmd);
+            }
+            if (cmds.length === 0)
+                continue;
+            console.log(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)}`);
+                if (cmd.usage) {
+                    console.log(`    ${pc.dim(cmd.usage)}`);
+                }
+            }
+            console.log();
+        }
+    }
+    lastCompactionShown = 0;
+    showContextBar(result) {
+        if (result.contextUsed === undefined ||
+            result.contextLimit === undefined ||
+            result.contextLimit <= 0) {
+            return;
+        }
+        const ui = this.config.ui;
+        if (ui?.showContextStats) {
+            console.log();
+            const ctxLine = formatContextBar(result.contextUsed, result.contextLimit, result.compactionCount, result.contextQuality);
+            console.log(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);
+            }
+            if (result.totalCost !== undefined && result.totalCost > 0) {
+                console.log(pc.yellow(`  ${t("repl.cost", { cost: formatCost(result.totalCost) })}`));
+            }
+        }
+        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})`));
+            }
+        }
+    }
+    async start() {
+        this.running = true;
+        const info = [];
+        const row = (label, value) => {
+            info.push(` ${pc.yellow(label)} ${value}`);
+        };
+        const ctx = this.config.contextWindow;
+        const sysBudget = Math.floor(ctx * this.config.contextBudget.systemPrompt);
+        const resBudget = Math.floor(ctx * this.config.contextBudget.responseReserve);
+        const histBudget = ctx - sysBudget - resBudget;
+        row(t("repl.model"), pc.white(this.config.model));
+        row(t("repl.provider"), `${this.config.provider.type}  →  ${pc.dim(this.config.provider.baseUrl)}`);
+        row(t("repl.context"), `${pc.white(String(ctx))}  ${pc.dim(`(sys:${sysBudget}  res:${resBudget}  hist:${histBudget})`)}`);
+        const si = this.agent.getSystemPromptInfo();
+        row(t("repl.sysprompt_label"), pc.dim(t("repl.sysprompt_size", { used: si.tokenCount, budget: sysBudget })));
+        if (this.skillsModule) {
+            const budget = this.skillsModule.getBudget();
+            row(t("repl.skills_label"), `${pc.white(String(this.skillsModule.getAvailable().length))} available, ${pc.dim(`budget: ${budget.total} tokens`)}`);
+        }
+        if (this.pluginManager) {
+            const infos = this.pluginManager.getPluginInfos().filter(({ plugin }) => !plugin.isBuiltin);
+            if (infos.length > 0) {
+                const pluginNames = infos
+                    .map(({ plugin, source }) => {
+                    const version = plugin.version ? `${pc.dim(plugin.version)}` : "";
+                    const origin = source ? pc.dim(` [${source}]`) : "";
+                    return `${plugin.name}${version}${origin}`;
+                })
+                    .join(", ");
+                row(t("repl.plugins_label"), `${pc.white(String(infos.length))} active  ${pc.dim(`(${pluginNames})`)}`);
+            }
+        }
+        const mcpServers = this.config.mcpServers || {};
+        const enabledServers = Object.entries(mcpServers).filter(([, s]) => s.enabled !== false);
+        if (enabledServers.length > 0) {
+            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));
+        if (this.noAgentsMd) {
+            row(t("repl.agents_label"), pc.red(t("repl.disabled")));
+        }
+        else {
+            const agentsMdCandidates = [
+                join(this.baseDir, "AGENTS.md"),
+                join(this.baseDir, ".mma", "AGENTS.md"),
+                join(this.configDir, "AGENTS.md"),
+            ];
+            const foundAgents = agentsMdCandidates.filter((p) => existsSync(p));
+            if (foundAgents.length > 0) {
+                for (const p of foundAgents) {
+                    row(t("repl.agents_label"), pc.dim(p));
+                }
+            }
+            else {
+                row(t("repl.agents_label"), pc.dim(t("repl.not_found")));
+            }
+        }
+        const meta = this.sessionManager?.getActiveMeta();
+        if (meta) {
+            const sessionPath = join(this.configDir, "sessions", meta.id);
+            row(t("repl.session_label"), `${pc.cyan(meta.name)} ${pc.dim(`(${meta.id.slice(0, 12)})`)}  —  ${meta.messageCount} msgs  ${pc.dim(sessionPath)}`);
+        }
+        // LSP status is probed in the background — it must never block the banner.
+        const isTty = process.stdout.isTTY === true;
+        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());
+        }
+        console.log();
+        // Legacy config hint
+        try {
+            const { existsSync: exists } = await import("fs");
+            const { join: pathJoin } = await import("path");
+            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();
+            }
+        }
+        catch { }
+        this.rl.prompt();
+        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();
+                }
+            })
+                .catch(() => { });
+        }
+        if ((this.config.provider.entries?.length ?? 0) > 1) {
+            // Phase 4.4: background health probe of all entries (free listModels
+            // calls). Failed providers are surfaced as warnings — failover (Phase
+            // 4.2) would silently mask a dead primary.
+            void probeProviders(targetsFromProviders((this.config.provider.entries ?? [])
+                .map((e) => ({
+                name: e.label || e.type,
+                provider: this.agent.getProviderFor(e.label || e.type),
+            }))
+                .filter((x) => Boolean(x.provider))), { timeoutMs: 5000 })
+                .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 ?? "" }));
+                    }
+                }
+            })
+                .catch(() => { });
+        }
+    }
+    /**
+     * Probe the LSP servers applicable to the current project and format a
+     * one-line banner summary, e.g. "✓ typescript (1.2s)" or "✗ css — timeout".
+     * Returns null when LSP is disabled or no server applies.
+     */
+    async probeLspBanner() {
+        const config = this.config.lsp ?? DEFAULT_LSP_CONFIG;
+        try {
+            const lspOnlyLogger = this.logger ? new FileOnlyLogger(this.logger) : undefined;
+            const summary = await probeLspServers(config, this.baseDir, { logger: lspOnlyLogger });
+            // Log LSP probe results to session for post-mortem visibility
+            this.slog.logSessionStart({
+                environment: this.envReport,
+                lspProbe: {
+                    ok: summary.ok.map((r) => ({ language: r.language, durationMs: r.durationMs })),
+                    failed: summary.failed.map((r) => ({
+                        language: r.language,
+                        error: r.error,
+                        durationMs: r.durationMs,
+                    })),
+                    noneApplicable: summary.noneApplicable,
+                },
+            });
+            if (summary.noneApplicable)
+                return null;
+            const parts = [];
+            for (const r of summary.ok) {
+                parts.push(pc.green(`✓ ${r.language}${pc.dim(` (${(r.durationMs / 1000).toFixed(1)}s)`)}`));
+            }
+            for (const r of summary.failed) {
+                const reason = r.error?.includes("timeout") ? t("repl.lsp_timeout") : t("repl.lsp_failed");
+                parts.push(pc.red(`✗ ${r.language}${pc.dim(` — ${reason}`)}`));
+            }
+            return parts.join("  ");
+        }
+        catch {
+            return pc.yellow(t("repl.lsp_unknown"));
+        }
+    }
+    stop() {
+        this.running = false;
+        this.saveHistory();
+        this.agent.shutdown();
+        // Close session log when REPL stops
+        this.logger?.closeSessionLog();
+        this.rl.close();
+    }
+}