micro-models-agent 0.41.0 → 0.41.2

package/dist/cli/repl.js

@@ -1,20 +1,22 @@
 import * as readline from "readline";
 import { pc } from "../ui/colors";
+import { LineEditor } from "../ui/line-editor";
 import { existsSync, readFileSync, writeFileSync } from "fs";
 import { join, dirname } from "path";
 import { homedir } from "os";
 import { fileURLToPath } from "url";
 import { Completer, SlashCommandProvider, SessionNameProvider, SubcommandProvider, SkillNameProvider, } from "./completer";
 import { Renderer } from "../ui/renderer";
-import { box } from "../ui/box";
+import { box, divider } from "../ui/box";
+import stringWidth from "string-width";
 import { t } from "../i18n/index";
 import { registerAllCommands } from "./repl-commands";
+import { probeLspServers } from "../modules/lsp/probe";
+import { DEFAULT_LSP_CONFIG } from "../modules/lsp/config";
+import { readActivePlan, formatPlanChecklist, stepContextForTool } from "../ui/plan-view";
 function readVersion() {
     const here = dirname(fileURLToPath(import.meta.url));
-    const candidates = [
-        join(here, "..", "..", "package.json"),
-        join(here, "..", "package.json"),
-    ];
+    const candidates = [join(here, "..", "..", "package.json"), join(here, "..", "package.json")];
     for (const p of candidates) {
         if (existsSync(p)) {
             try {
@@ -60,6 +62,9 @@ export class Repl {
     baseDir;
     noAgentsMd;
     pendingClipboardImage = null;
+    exitOnClose = false;
+    activePlan = null;
+    lastPlanSig = "";
     rl;
     agent;
     config;
@@ -67,9 +72,10 @@ export class Repl {
     skillsModule;
     pluginManager;
     logger;
-    constructor(agent, config, sessionManager, skillsModule, pluginManager, configDir, baseDir, noAgentsMd, logger) {
+    constructor(agent, config, sessionManager, skillsModule, pluginManager, configDir, baseDir, noAgentsMd, logger, exitOnClose) {
         this.agent = agent;
         this.config = config;
+        this.exitOnClose = exitOnClose === true;
         this.sessionManager = sessionManager;
         this.skillsModule = skillsModule;
         this.pluginManager = pluginManager;
@@ -79,20 +85,34 @@ export class Repl {
         this.noAgentsMd = noAgentsMd === true;
         this.historyPath = join(homedir(), ".mma", "repl-history");
         this.loadHistory();
-        this.rl = readline.createInterface({
-            input: process.stdin,
-            output: process.stdout,
-            prompt: pc.cyan("> "),
-            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];
-            },
-        });
+        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();
@@ -119,13 +139,7 @@ export class Repl {
             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 SubcommandProvider("skill", ["list", "loaded", "load", "unload", "search"]));
             this.completer.registerProvider(new SkillNameProvider(this.skillsModule));
         }
     }
@@ -164,12 +178,12 @@ export class Repl {
                         }
                     }
                     if (this.running) {
-                        this.rl.setPrompt(pc.cyan("> "));
+                        this.rl.setPrompt(pc.cyan(t("repl.you")));
                         this.rl.prompt();
                     }
                 }
                 else {
-                    this.rl.setPrompt(pc.cyan("... "));
+                    this.rl.setPrompt(pc.cyan(t("repl.you") + "… "));
                     this.rl.prompt();
                 }
                 return;
@@ -177,7 +191,7 @@ export class Repl {
             if (this.isMultiLineInput(trimmed)) {
                 inMultiLine = true;
                 multiLineBuffer = trimmed;
-                this.rl.setPrompt(pc.cyan("... "));
+                this.rl.setPrompt(pc.cyan(t("repl.you") + "… "));
                 this.rl.prompt();
                 return;
             }
@@ -197,52 +211,22 @@ export class Repl {
         });
         this.rl.on("close", () => {
             this.running = false;
+            this.saveHistory();
+            this.agent.shutdown();
+            if (this.exitOnClose)
+                process.exit(0);
         });
-        if (process.stdin.isTTY) {
-            readline.emitKeypressEvents(process.stdin);
-            process.stdin.on("keypress", async (str, key) => {
-                if (key.name === "escape") {
-                    // Bun/Node's readline 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;
-                }
-                if (key.ctrl && key.name === "v" && !this.agentRunning) {
-                    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` })}`));
-                            this.rl.prompt();
-                        }
-                        else {
-                            console.log(pc.yellow(`\n${t("image.clipboard_empty")}`));
-                            this.rl.prompt();
-                        }
-                    }
-                    catch {
-                        // clipboard read failed — ignore, let terminal paste text normally
-                    }
-                }
+        if (this.exitOnClose && !process.stdin.isTTY) {
+            process.stdin.on("end", () => {
+                this.running = false;
+                this.saveHistory();
+                this.agent.shutdown();
+                process.exit(0);
             });
         }
+        if (this.rl instanceof LineEditor) {
+            this.rl.onKeyInput = (str, key) => this.handleSpecialKey(str, key);
+        }
         let forceExitTimer = null;
         process.on("SIGINT", () => {
             if (this.agentRunning) {
@@ -258,6 +242,55 @@ export class Repl {
             }
         });
     }
+    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;
@@ -283,17 +316,26 @@ export class Repl {
                 this.pendingClipboardImage = null;
             }
             this.logger?.logREPL("user", input);
-            process.stdout.write("\n" + pc.green(t("repl.agent")));
+            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",
             });
+            this.refreshActivePlan(renderer);
             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);
+                    renderer.toolStart(ev.tool, ev.args, stepContextForTool(this.activePlan, ev.tool, ev.args));
                 }
                 else {
                     renderer.toolEnd(ev.tool, ev.duration ?? 0, ev.error, ev.ctxDelta);
+                    if (ev.tool === "plan" || ev.tool === "todo") {
+                        this.refreshActivePlan(renderer);
+                    }
                 }
             }, (phase) => {
                 if (phase === "thinking") {
@@ -310,11 +352,29 @@ export class Repl {
                 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;
         }
     }
+    /** Re-read the active plan from disk; print a live checklist when it changed. */
+    refreshActivePlan(renderer) {
+        const plan = readActivePlan(this.baseDir);
+        const sig = plan ? JSON.stringify(plan.steps.map((s) => `${s.id}:${s.status}`)) : "";
+        if (!plan) {
+            this.activePlan = null;
+            this.lastPlanSig = "";
+            return;
+        }
+        this.activePlan = plan;
+        if (sig !== this.lastPlanSig) {
+            this.lastPlanSig = sig;
+            renderer.planBlock(formatPlanChecklist(plan));
+        }
+    }
     commands = new Map();
     registerCommand(cmd) {
         this.commands.set(cmd.name, cmd);
@@ -372,9 +432,7 @@ export class Repl {
                 continue;
             console.log(pc.bold(t(`repl.group.${groupKey}`)));
             for (const cmd of cmds) {
-                const aliases = cmd.aliases?.length
-                    ? ` (${pc.dim(cmd.aliases.join(", "))})`
-                    : "";
+                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)}`);
@@ -407,7 +465,7 @@ export class Repl {
             }
         }
     }
-    start() {
+    async start() {
         this.running = true;
         const info = [];
         const row = (label, value) => {
@@ -427,12 +485,16 @@ export class Repl {
             row(t("repl.skills_label"), `${pc.white(String(this.skillsModule.getAvailable().length))} available, ${pc.dim(`budget: ${budget.total} tokens`)}`);
         }
         if (this.pluginManager) {
-            const plugins = this.pluginManager
-                .getAllPlugins()
-                .filter((p) => !p.isBuiltin);
-            if (plugins.length > 0) {
-                const pluginNames = plugins.map((p) => p.name).join(", ");
-                row(t("repl.plugins_label"), `${pc.white(String(plugins.length))} active  ${pc.dim(`(${pluginNames})`)}`);
+            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 || {};
@@ -468,14 +530,82 @@ export class Repl {
             row(t("repl.session_label"), `${pc.cyan(meta.name)} ${pc.dim(`(${meta.id.slice(0, 12)})`)}  —  ${meta.messageCount} msgs  ${pc.dim(sessionPath)}`);
         }
         const headerWidth = Math.max(50, Math.min(96, process.stdout.columns || 96));
-        for (const line of box(info, {
+        // 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;
+        if (lspEnabled) {
+            row(t("repl.lsp_label"), pc.dim("…"));
+        }
+        const boxLines = box(info, {
             title: t("repl.title", { version }),
             width: headerWidth,
-        })) {
+        });
+        for (const line of boxLines) {
             console.log(line);
         }
         console.log();
         this.rl.prompt();
+        if (lspEnabled) {
+            this.probeLspBanner()
+                .then((lspSummary) => {
+                if (lspSummary)
+                    this.updateLspRow(boxLines.length, headerWidth, lspSummary);
+            })
+                .catch(() => { });
+        }
+    }
+    /**
+     * Replace the LSP banner row (rendered as "…") in place once the probe
+     * finishes. The LSP row is the last data row of the box, so it sits exactly
+     * two terminal rows above the prompt line — that offset is stable no matter
+     * how earlier rows wrap. Skipped (placeholder stays) when a rewrite would
+     * corrupt the screen: the agent is already running, the terminal is not a
+     * TTY, a box line wrapped, or the summary is too wide for a single row.
+     */
+    updateLspRow(boxLineCount, headerWidth, summary) {
+        if (this.agentRunning || !process.stdout.isTTY)
+            return;
+        if ((process.stdout.columns ?? 96) < headerWidth)
+            return;
+        const inner = headerWidth - 4;
+        // Match box()'s wrapText normalization (leading space stripped, runs of
+        // whitespace collapsed) so the rewritten row is byte-identical to what
+        // box() would render for the same text.
+        const rowText = `${pc.yellow(t("repl.lsp_label"))} ${summary.replace(/\s+/g, " ").trim()}`;
+        if (stringWidth(rowText) > inner)
+            return;
+        const padded = rowText + " ".repeat(Math.max(0, inner - stringWidth(rowText)));
+        const line = pc.dim("│") + " " + padded + " " + pc.dim("│");
+        // From the prompt row (boxLineCount) up 2 to the LSP row (last data row,
+        // directly above the bottom border), clear it, write the new row, and
+        // return the cursor to the prompt row. The editor re-positions itself on
+        // the next keystroke, so any typed input is preserved.
+        process.stdout.write(`\x1b[2A\r\x1b[2K${line}\x1b[2B\r`);
+    }
+    /**
+     * 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 summary = await probeLspServers(config, this.baseDir);
+            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;

package/dist/cli/run-result.js

@@ -0,0 +1,22 @@
+import { t } from "../i18n/index";
+import { pc } from "../ui/colors";
+/**
+ * Render a single-run AgentResult to the terminal (non-JSON mode) and return
+ * the process exit code.
+ *
+ * On failure only the error is printed. The model's `text` (which is the last
+ * *accepted* message, i.e. possibly stale after an audit/hallucination error)
+ * was already streamed live during the run — re-printing it here misleadingly
+ * suggests the task succeeded.
+ */
+export function printRunResult(result, flush) {
+    flush();
+    if (result.success) {
+        if (!result.text) {
+            console.log(pc.yellow(t("cli.no_output")));
+        }
+        return 0;
+    }
+    console.error(`${t("error.prefix")}${result.error}`);
+    return 1;
+}

package/dist/cli/security-commands.js

@@ -9,9 +9,7 @@ import { t } from "../i18n/index";
  * Create security subcommand
  */
 export function createSecurityCommand(program) {
-    const securityCmd = program
-        .command("security")
-        .description(t("cli.security.description"));
+    const securityCmd = program.command("security").description(t("cli.security.description"));
     // security status - show current security configuration
     securityCmd
         .command("status")
@@ -45,7 +43,7 @@ export function createSecurityCommand(program) {
         console.log(t("cli.security.available_policies"));
         console.log("");
         for (const [preset, policy] of Object.entries(SECURITY_POLICIES)) {
-            if (preset === 'custom')
+            if (preset === "custom")
                 continue;
             const marker = " ";
             console.log(` ${marker}${preset.padEnd(12)}  ${policy.name}`);
@@ -62,7 +60,7 @@ export function createSecurityCommand(program) {
         .action(async (preset) => {
         const configPath = join(homedir(), ".mma", "config.json");
         const { config: appConfig } = await bootstrap();
-        const validPresets = ['strict', 'balanced', 'permissive'];
+        const validPresets = ["strict", "balanced", "permissive"];
         if (!validPresets.includes(preset)) {
             console.log(t("cli.security.invalid_preset", { presets: validPresets.join(", ") }));
             return;
@@ -117,8 +115,8 @@ export function createSecurityCommand(program) {
         appConfig.security = appConfig.security || {};
         appConfig.security.auditNotifier = {
             enabled: true,
-            minSeverity: 'medium',
-            eventTypes: ['security_block', 'bash_command', 'file_operation', 'network_request'],
+            minSeverity: "medium",
+            eventTypes: ["security_block", "bash_command", "file_operation", "network_request"],
             maxRetries: 3,
             webhookTimeout: 5000,
         };

package/dist/cli/setup.js

@@ -22,9 +22,7 @@ function menuList(items) {
 }
 function ask(rl, question, defaultValue) {
     return new Promise((resolve) => {
-        const prompt = defaultValue
-            ? `${question} [${defaultValue}]: `
-            : `${question}: `;
+        const prompt = defaultValue ? `${question} [${defaultValue}]: ` : `${question}: `;
         rl.question(prompt, (answer) => {
             resolve(answer.trim() || defaultValue || "");
         });
@@ -176,7 +174,7 @@ export async function runSetup(externalRl) {
         model = models[idx];
     }
     else {
-        model = await ask(rl, t("setup.model_name"), "qwen3.5-9b");
+        model = await ask(rl, t("setup.model_name"), "qwen/qwen3.5-9b");
     }
     const connected = await withSpinner(t("setup.testing_spinner", { model }), () => testChat(apiBase, apiKey, model));
     if (connected) {
@@ -195,17 +193,11 @@ export async function runSetup(externalRl) {
     let securityBashBlock = false;
     let securityFlagsBlock = false;
     let securityPathsDeny = true;
-    if (configureSecurity.toLowerCase() === "y" ||
-        configureSecurity.toLowerCase() === "yes") {
-        securityBashBlock =
-            (await ask(rl, t("setup.security_bash_block"), "n")).toLowerCase() ===
-                "y";
+    if (configureSecurity.toLowerCase() === "y" || configureSecurity.toLowerCase() === "yes") {
+        securityBashBlock = (await ask(rl, t("setup.security_bash_block"), "n")).toLowerCase() === "y";
         securityFlagsBlock =
-            (await ask(rl, t("setup.security_flags_block"), "n")).toLowerCase() ===
-                "y";
-        securityPathsDeny =
-            (await ask(rl, t("setup.security_paths_deny"), "Y")).toLowerCase() !==
-                "n";
+            (await ask(rl, t("setup.security_flags_block"), "n")).toLowerCase() === "y";
+        securityPathsDeny = (await ask(rl, t("setup.security_paths_deny"), "Y")).toLowerCase() !== "n";
     }
     if (ownRl)
         rl.close();
@@ -229,18 +221,8 @@ export async function runSetup(externalRl) {
         t("setup.summary_value"),
     ], [
         [t("setup.provider_type"), provider, t("setup.model_name"), model],
-        [
-            "API Base URL",
-            apiBase,
-            t("setup.context_window"),
-            String(contextWindow),
-        ],
-        [
-            t("setup.api_key"),
-            apiKey || "not-needed",
-            t("setup.max_iters"),
-            String(maxIterations),
-        ],
+        ["API Base URL", apiBase, t("setup.context_window"), String(contextWindow)],
+        [t("setup.api_key"), apiKey || "not-needed", t("setup.max_iters"), String(maxIterations)],
         [t("setup.ui_lang"), locale, "", ""],
     ], { maxColumns: 4 });
     for (const l of summary)

package/dist/config/config.js

@@ -1,12 +1,13 @@
-import { existsSync, readFileSync, unlinkSync, writeFileSync, mkdirSync, } from "fs";
+import { existsSync, readFileSync, unlinkSync, writeFileSync, mkdirSync } from "fs";
 import { join, dirname } from "path";
 import { DEFAULTS } from "./defaults";
 import { DEFAULT_SECURITY_CONFIG } from "./security";
+import { DEFAULT_LSP_CONFIG } from "../modules/lsp/config";
 import { t } from "../i18n/index";
 import { MigrationDetector } from "../migration/detect";
 import { BackupManager } from "../migration/backup";
 import { validateExpertConfig } from "./experts";
-import { ConfigEncryptor, } from "../modules/security/encryption";
+import { ConfigEncryptor } from "../modules/security/encryption";
 /**
  * Restore RegExp instances in dangerousPatterns that were serialized as {}
  * (pre-0.8.0 configs) or as {__regex, source, flags} (new format).
@@ -69,9 +70,7 @@ function regexReplacer(_key, value) {
  * JSON reviver that restores RegExp objects serialized by regexReplacer.
  */
 function regexReviver(_key, value) {
-    if (value &&
-        typeof value === "object" &&
-        value.__regex === true) {
+    if (value && typeof value === "object" && value.__regex === true) {
         const { source, flags } = value;
         try {
             return new RegExp(source, flags);
@@ -82,6 +81,46 @@ function regexReviver(_key, value) {
     }
     return value;
 }
+/**
+ * Legacy npx `args` for LSP servers that predate the fixed invocation
+ * (`--yes --package <server> --package typescript@5 …`). These exact arrays
+ * are unsafe: without `--yes`/`--package` the servers fail to bootstrap
+ * (`Could not find a valid TypeScript installation`) or the package name is
+ * wrong, so the server hangs until the initialize timeout. When a stored
+ * server's `args` matches one of these (or is missing) it is replaced with the
+ * current default args — user-customized arrays that differ are left alone.
+ */
+const LEGACY_LSP_SERVER_ARGS = {
+    typescript: { args: ["typescript-language-server", "--stdio"], timeout: 30000 },
+    javascript: { args: ["typescript-language-server", "--stdio"], timeout: 30000 },
+    json: { args: ["vscode-json-languageserver", "--stdio"], timeout: 30000 },
+    html: { args: ["vscode-html-languageserver", "--stdio"], timeout: 60000 },
+    css: { args: ["vscode-css-languageserver", "--stdio"], timeout: 60000 },
+};
+/**
+ * Replace stale pre-0.41.1 LSP server invocations (npx bootstrap args) with
+ * the current defaults, so an old `~/.mma/config.json` that overrides the
+ * fixed server args can't silently re-break every LSP server. In-memory only —
+ * mirrors the `restoreDangerousPatterns` precedent; the file keeps the old
+ * args and is normalized again on every load.
+ */
+function normalizeLspServerArgs(config) {
+    const servers = config.lsp?.servers;
+    if (!servers)
+        return;
+    for (const [lang, legacy] of Object.entries(LEGACY_LSP_SERVER_ARGS)) {
+        const server = servers[lang];
+        const def = DEFAULT_LSP_CONFIG.servers[lang];
+        if (!server || server.command !== "npx" || !def)
+            continue;
+        const storedArgs = Array.isArray(server.args) ? server.args : null;
+        const isLegacy = storedArgs === null || JSON.stringify(storedArgs) === JSON.stringify(legacy.args);
+        if (isLegacy) {
+            server.args = def.args;
+            server.timeout = def.timeout;
+        }
+    }
+}
 function loadJSON(path) {
     try {
         if (existsSync(path)) {
@@ -160,6 +199,8 @@ export function loadConfig(options) {
     if (config.security?.contentScan?.dangerousPatterns) {
         config.security.contentScan.dangerousPatterns = restoreDangerousPatterns(config.security.contentScan.dangerousPatterns, DEFAULT_SECURITY_CONFIG.contentScan.dangerousPatterns);
     }
+    // Replace stale pre-0.41.1 LSP server args with the current defaults.
+    normalizeLspServerArgs(config);
     config = applyEnvVars(config);
     // Decrypt sensitive fields in the loaded config
     try {
@@ -179,6 +220,12 @@ export function loadConfig(options) {
 }
 export function validateConfig(config, allToolTags) {
     const errors = validateExpertConfig(config, allToolTags);
+    const knownTags = new Set(allToolTags);
+    for (const tag of config.tools?.defaultTags ?? []) {
+        if (!knownTags.has(tag)) {
+            errors.push(`tools.defaultTags references unknown tag "${tag}". Known tags: ${Array.from(knownTags).join(", ")}`);
+        }
+    }
     if (errors.length > 0) {
         throw new Error(`Config validation failed:\n${errors.join("\n")}`);
     }