micro-models-agent 2.10.0 → 2.12.0

package/dist/cli/repl-commands.js

@@ -1,18 +1,29 @@
+// Slash-команды REPL: /config, /model, /provider, сессии, сахар над mutateConfig.
 import { pc } from "../ui/colors";
+import { resolveVerbosity } from "../ui/theme";
 import { readMmaVersion } from "../core/version";
 import { renderTable } from "../ui/table";
-import { t } from "../i18n/index";
+import { t, setLocale } from "../i18n/index";
 import { runSetup } from "./setup";
+import { applyAnswersToConfig } from "./setup-order";
 import { saveConfig } from "../config/config";
 import { HOSTED_BASE_URLS } from "../modules/providers/presets";
-import { budgetBreakdownLines, setBudgetShare } from "../config/budget";
+import { providerNameTaken } from "../modules/providers/naming";
+import { activeProviderEndpoint } from "../modules/providers/manager";
+import { budgetBreakdownLines } from "../config/budget";
+import { setConfigValue, getConfigValue, resolveConfigKey, canonicalKeys, keysForGroup, configDefs, formatConfigValue, } from "../config/registry";
+import { formatExport, redactExport, sanitizeFileName, extensionFor, } from "../modules/session/export";
 import { getMessageText } from "../llm/provider";
-import { estimateTokens } from "../llm/token-counter";
 import { join, dirname } from "path";
-import { existsSync } from "fs";
+import { existsSync, writeFileSync, mkdirSync } from "fs";
 import { runMapAction } from "../modules/indexer/map-command";
+import { registerOnboardingCommands } from "./onboarding-commands";
 import { errMsg } from "../utils";
+import { globalExportsDir } from "../config/paths";
+import { registerLspCommands } from "./repl-commands-lsp";
+import { registerSkillCommands } from "./repl-commands-skills";
 const version = readMmaVersion();
+/** Группы команд для `/help` (general/agent/session/skill). */
 export const COMMAND_GROUPS = {
     help: "general",
     exit: "general",
@@ -22,25 +33,33 @@ export const COMMAND_GROUPS = {
     config: "agent",
     status: "agent",
     reasoning: "agent",
+    verbose: "agent",
     provider: "agent",
     model: "agent",
     context: "agent",
     reload: "agent",
     wizard: "agent",
+    meet: "agent",
+    init: "agent",
+    memory: "agent",
     sysprompt: "agent",
     map: "agent",
     lsp: "agent",
+    security: "agent",
     sessions: "session",
     new: "session",
     resume: "session",
     rename: "session",
     delete: "session",
+    export: "session",
     skill: "skill",
     plugins: "agent",
 };
+/** Регистрирует все команды REPL (builtin + mma + онбординг + сессии + скиллы). */
 export function registerAllCommands(ctx) {
     registerBuiltinCommands(ctx);
     registerMmaCommands(ctx);
+    registerOnboardingCommands(ctx);
     registerSessionCommands(ctx);
     registerSkillCommands(ctx);
 }
@@ -49,7 +68,8 @@ function registerBuiltinCommands(ctx) {
         name: "help",
         description: t("repl.help"),
         usage: t("repl.help_usage"),
-        action: () => ctx.showHelp(),
+        examples: ["/help", "/help config"],
+        action: (args) => ctx.showHelp(args[0]),
     });
     ctx.registerCommand({
         name: "exit",
@@ -64,6 +84,7 @@ function registerBuiltinCommands(ctx) {
         usage: t("repl.clear_usage"),
         action: () => {
             ctx.output.clearScreen();
+            ctx.output.writeLine(pc.dim(t("repl.clear_hint")));
         },
     });
 }
@@ -142,40 +163,292 @@ function registerRunCommands(ctx) {
         },
     });
 }
+const SUGAR_HINTS = {
+    model: "/model use <name>",
+    "provider.active": "/provider use <name>",
+    contextWindow: "/context <size>",
+    "contextBudget.systemPrompt": "/context system <share>",
+    "contextBudget.responseReserve": "/context reserve <share>",
+    showReasoning: "/reasoning show | hide",
+    "reasoning.mode": "/reasoning level <level>",
+    "ui.verbosity": "/verbose <level>",
+};
+function changeHint(def) {
+    if (def.readOnly)
+        return t("config.read_only_hint");
+    return SUGAR_HINTS[def.key] ?? `/config ${def.key} <value>`;
+}
+function configValueHint(def) {
+    if (!def)
+        return "";
+    switch (def.valueType) {
+        case "enum":
+            return t("config.hint_enum", { values: (def.enumValues ?? []).join(", ") });
+        case "bool":
+            return t("config.hint_bool");
+        case "share":
+            return t("config.hint_share");
+        case "int":
+            return t("config.hint_int", { min: String(def.min ?? 1) });
+        default:
+            return t("config.hint_string");
+    }
+}
+function editDistance(a, b) {
+    const dp = Array.from({ length: b.length + 1 }, (_, i) => i);
+    for (let i = 1; i <= a.length; i++) {
+        let prev = dp[0];
+        dp[0] = i;
+        for (let j = 1; j <= b.length; j++) {
+            const tmp = dp[j];
+            dp[j] = Math.min(dp[j] + 1, dp[j - 1] + 1, prev + (a[i - 1] === b[j - 1] ? 0 : 1));
+            prev = tmp;
+        }
+    }
+    return dp[b.length];
+}
+function nearestConfigKey(input) {
+    const names = canonicalKeys();
+    let best = null;
+    for (const name of names) {
+        const d = editDistance(input.toLowerCase(), name.toLowerCase());
+        if (best === null || d < best.dist)
+            best = { name, dist: d };
+    }
+    if (!best)
+        return null;
+    const threshold = Math.max(2, Math.floor(best.name.length / 3));
+    return best.dist <= threshold ? best.name : null;
+}
+function renderConfigError(ctx, result) {
+    const key = result.key ?? result.input;
+    switch (result.reason) {
+        case "unknown-key": {
+            const suggestion = nearestConfigKey(result.input);
+            const suffix = suggestion
+                ? t("config.suggest", { name: suggestion })
+                : t("config.valid_keys", { keys: canonicalKeys().join(", ") });
+            ctx.output.writeLine(pc.yellow(t("config.unknown_key", { key: result.input, suggestion: suffix })), "stderr");
+            return;
+        }
+        case "read-only":
+            ctx.output.writeLine(pc.yellow(t("config.read_only", { key })), "stderr");
+            return;
+        case "range":
+            ctx.output.writeLine(pc.yellow(t("config.range", { key })), "stderr");
+            return;
+        case "combined":
+            ctx.output.writeLine(pc.yellow(t("config.combined")), "stderr");
+            return;
+        default:
+            ctx.output.writeLine(pc.yellow(t("config.invalid_value", { key, hint: configValueHint(result.def) })), "stderr");
+    }
+}
+function applyConfigSideEffects(ctx, result) {
+    if (result.key === "ui.verbosity") {
+        // Зеркало стартового правила (`main.ts`): структурные info-логи и диагностика
+        // петли видимы в чате только в verbose.
+        const verbose = result.value === "verbose";
+        ctx.output.setSuppressInfoLogs(!verbose);
+        ctx.output.setShowDiagnostics(verbose);
+    }
+    else if (result.key === "reasoning.mode") {
+        ctx.agent.setReasoningLevel(result.value);
+    }
+    else if (result.key === "locale") {
+        setLocale(result.value);
+    }
+}
+function persistConfig(ctx) {
+    const configPath = join(ctx.configDir, "config.json");
+    saveConfig(ctx.config, configPath, dirname(configPath));
+}
+/**
+ * Единый путь записи каждой мутации настроек. Сахарные команды тоже идут сюда,
+ * чтобы валидация, сайд-эффекты, персист и reconfigure не расходились.
+ */
+async function mutateConfig(ctx, key, raw) {
+    const result = setConfigValue(ctx.config, key, raw);
+    if (!result.ok)
+        return result;
+    applyConfigSideEffects(ctx, result);
+    persistConfig(ctx);
+    if (result.reconfigure)
+        await ctx.agent.reconfigure(ctx.config);
+    if (result.key === "locale")
+        ctx.reregisterCommands();
+    return result;
+}
+function reportSaved(ctx, result) {
+    ctx.output.writeLine(pc.green(t("config.saved", { key: result.key })));
+}
+function rawFromValue(value) {
+    if (typeof value === "boolean")
+        return value ? "on" : "off";
+    return String(value);
+}
+function printConfigTable(ctx, defs) {
+    const list = defs ?? configDefs();
+    const rows = list.map((def) => [
+        def.key,
+        formatConfigValue(def.get(ctx.config)),
+        def.domain,
+        changeHint(def),
+    ]);
+    ctx.output.writeLine(pc.bold(t("config.header")));
+    for (const line of renderTable([
+        t("config.col_setting"),
+        t("config.col_value"),
+        t("config.col_domain"),
+        t("config.col_change"),
+    ], rows)) {
+        ctx.output.writeLine(line);
+    }
+    const meta = ctx.sessionManager?.getActiveMeta();
+    if (meta) {
+        ctx.output.writeLine(pc.dim(t("config.session_line", {
+            name: meta.name,
+            id: meta.id,
+            count: String(meta.messageCount),
+        })));
+    }
+    ctx.output.writeLine(pc.dim(t("config.usage_hint")));
+}
+function confirm(ctx, prompt) {
+    return new Promise((resolve) => {
+        void ctx.withExclusiveInput(async () => {
+            await new Promise((done) => {
+                ctx.rl.question(prompt, (answer) => {
+                    resolve(/^y(es)?$/i.test(answer.trim()));
+                    done();
+                });
+            });
+        });
+    });
+}
+async function runConfigReset(ctx, rest) {
+    const snapshot = ctx.getConfigSnapshot();
+    const yes = rest.includes("--yes");
+    const all = rest.includes("--all");
+    const target = rest.find((a) => !a.startsWith("--"));
+    if (all) {
+        const changed = canonicalKeys().filter((k) => {
+            const def = resolveConfigKey(k);
+            if (!def || !snapshot.has(k))
+                return false;
+            return rawFromValue(def.get(ctx.config)) !== rawFromValue(snapshot.get(k));
+        });
+        if (changed.length === 0) {
+            ctx.output.writeLine(t("config.reset_none"));
+            return;
+        }
+        if (!yes) {
+            if (!process.stdin.isTTY) {
+                ctx.output.writeLine(pc.yellow(t("config.reset_all_needs_yes")), "stderr");
+                return;
+            }
+            const ok = await confirm(ctx, t("config.reset_all_confirm", { count: String(changed.length) }));
+            if (!ok) {
+                ctx.output.writeLine(t("config.reset_cancelled"));
+                return;
+            }
+        }
+        let anyReconfig = false;
+        let localeChanged = false;
+        for (const k of changed) {
+            const result = setConfigValue(ctx.config, k, rawFromValue(snapshot.get(k)));
+            if (result.ok) {
+                applyConfigSideEffects(ctx, result);
+                anyReconfig = anyReconfig || result.reconfigure;
+                localeChanged = localeChanged || result.key === "locale";
+            }
+        }
+        persistConfig(ctx);
+        if (anyReconfig)
+            await ctx.agent.reconfigure(ctx.config);
+        if (localeChanged)
+            ctx.reregisterCommands();
+        ctx.output.writeLine(pc.green(t("config.reset_all_done", { count: String(changed.length) })));
+        return;
+    }
+    if (!target) {
+        ctx.output.writeLine(t("config.reset_usage"));
+        return;
+    }
+    const def = resolveConfigKey(target);
+    if (!def) {
+        renderConfigError(ctx, { reason: "unknown-key", input: target });
+        return;
+    }
+    if (def.readOnly || !snapshot.has(def.key)) {
+        ctx.output.writeLine(t("config.reset_unchanged", { key: def.key }));
+        return;
+    }
+    if (rawFromValue(def.get(ctx.config)) === rawFromValue(snapshot.get(def.key))) {
+        ctx.output.writeLine(t("config.reset_unchanged", { key: def.key }));
+        return;
+    }
+    const result = await mutateConfig(ctx, def.key, rawFromValue(snapshot.get(def.key)));
+    if (!result.ok) {
+        renderConfigError(ctx, result);
+        return;
+    }
+    ctx.output.writeLine(pc.green(t("config.reset_ok", { key: result.key, value: result.display })));
+}
+function printReasoningStatus(ctx) {
+    const display = ctx.config.showReasoning ? t("reasoning.on") : t("reasoning.off");
+    const mode = ctx.config.reasoning?.mode ?? "auto";
+    const auto = mode === "auto" ? t("reasoning.auto_on") : t("reasoning.auto_off");
+    ctx.output.writeLine(t("reasoning.status", { display, level: mode, auto }));
+}
 function registerConfigCommands(ctx) {
     ctx.registerCommand({
         name: "config",
         description: t("repl.config"),
         usage: t("repl.config_usage"),
-        action: (args) => {
-            // Subcommand routing: `/config migrate`. A separate registration with
-            // a space in the name was unreachable — the dispatcher splits input on
-            // whitespace, so "/config migrate" always resolved to plain "config".
+        examples: ["/config", "/config model", "/config reasoning.mode high", "/config reset ui.verbosity"],
+        action: async (args) => {
+            // Роутинг субкоманды `/config migrate`. Отдельная регистрация с пробелом в
+            // имени недостижима: диспетчер режет ввод по пробелам, и "/config migrate"
+            // всегда резолвился в plain "config".
             if ((args[0] ?? "").trim().toLowerCase() === "migrate") {
                 return runConfigMigrate(ctx);
             }
-            const cfg = ctx.config;
-            const ctxW = cfg.contextWindow;
-            const sys = Math.floor(ctxW * cfg.contextBudget.systemPrompt);
-            const res = Math.floor(ctxW * cfg.contextBudget.responseReserve);
-            ctx.output.writeLine(`${t("repl.model")}       ${cfg.model}`);
-            const providers = ctx.agent.listProviders();
-            const active = providers.find((p) => p.active);
-            if (active) {
-                ctx.output.writeLine(`${t("repl.provider")}    ${active.label} (${pc.dim(active.type)})  →  ${pc.dim(active.baseUrl)}`);
+            if (args.length === 0) {
+                printConfigTable(ctx);
+                return;
             }
-            else {
-                ctx.output.writeLine(`${t("repl.provider")}    ${cfg.provider.type}  →  ${cfg.provider.baseUrl}`);
-            }
-            ctx.output.writeLine(`${t("repl.context")}     ${ctxW}  (sys:${sys}  res:${res}  hist:${ctxW - sys - res})`);
-            ctx.output.writeLine(`${t("repl.max_iters")}   ${cfg.maxToolIterations}`);
-            ctx.output.writeLine(`${t("repl.stuck_thresh")} ${cfg.stuckThreshold}`);
-            ctx.output.writeLine(`${t("repl.reasoning_label")}   ${cfg.showReasoning ? pc.green(t("repl.show")) : pc.dim(t("repl.hide"))}`);
-            ctx.output.writeLine(`${t("repl.log_level")}   ${cfg.logLevel}`);
-            ctx.output.writeLine(`${t("repl.locale")}      ${cfg.locale}`);
-            const meta = ctx.sessionManager?.getActiveMeta();
-            if (meta) {
-                ctx.output.writeLine(`${t("repl.session_label")}     ${meta.name} (${meta.id})  —  ${meta.messageCount} msgs`);
+            if (args[0] === "reset") {
+                await runConfigReset(ctx, args.slice(1));
+                return;
+            }
+            const name = args[0];
+            if (args.length === 1) {
+                const group = keysForGroup(name);
+                if (group.length > 0) {
+                    printConfigTable(ctx, group);
+                    return;
+                }
+                const got = getConfigValue(ctx.config, name);
+                if (!got.ok) {
+                    renderConfigError(ctx, got);
+                    return;
+                }
+                ctx.output.writeLine(`${got.key} = ${got.display}`);
+                return;
+            }
+            const raw = args.slice(1).join(" ");
+            const result = await mutateConfig(ctx, name, raw);
+            if (!result.ok) {
+                renderConfigError(ctx, result);
+                return;
+            }
+            reportSaved(ctx, result);
+            if (result.key === "model") {
+                const known = ctx.knownModels();
+                if (known.length > 0 && !known.includes(String(result.value))) {
+                    ctx.output.writeLine(pc.yellow(t("model.not_in_list", { name: String(result.value) })));
+                }
             }
         },
     });
@@ -183,23 +456,60 @@ function registerConfigCommands(ctx) {
         name: "reasoning",
         description: t("repl.reasoning"),
         usage: t("repl.reasoning_usage"),
-        action: (args) => {
+        examples: ["/reasoning", "/reasoning show", "/reasoning level high"],
+        action: async (args) => {
+            const sub = args[0]?.trim().toLowerCase();
+            if (!sub) {
+                printReasoningStatus(ctx);
+                return;
+            }
+            if (sub === "show" || sub === "on" || sub === "hide" || sub === "off") {
+                const on = sub === "show" || sub === "on";
+                const result = await mutateConfig(ctx, "showReasoning", on ? "on" : "off");
+                if (!result.ok) {
+                    renderConfigError(ctx, result);
+                    return;
+                }
+                ctx.output.writeLine(pc.green(t("reasoning.display_set", { state: on ? t("reasoning.on") : t("reasoning.off") })));
+                return;
+            }
+            if (sub === "level") {
+                const lvl = args[1]?.trim().toLowerCase();
+                if (!lvl) {
+                    ctx.output.writeLine(t("repl.reasoning_usage"));
+                    return;
+                }
+                const result = await mutateConfig(ctx, "reasoning.mode", lvl);
+                if (!result.ok) {
+                    renderConfigError(ctx, result);
+                    return;
+                }
+                ctx.output.writeLine(pc.green(t("repl.reasoning_level_set", { level: lvl })));
+                if (lvl !== "auto")
+                    ctx.output.writeLine(pc.dim(t("reasoning.auto_off_hint")));
+                return;
+            }
+            ctx.output.writeLine(pc.yellow(t("reasoning.unknown_sub", { sub })));
+            ctx.output.writeLine(t("repl.reasoning_usage"));
+        },
+    });
+    ctx.registerCommand({
+        name: "verbose",
+        description: t("repl.verbose"),
+        usage: t("repl.verbose_usage"),
+        examples: ["/verbose", "/verbose normal"],
+        action: async (args) => {
             const level = args[0]?.trim().toLowerCase();
-            const VALID_LEVELS = ["auto", "none", "low", "medium", "high", "max"];
             if (!level) {
-                // Toggle show/hide reasoning content
-                ctx.config.showReasoning = !ctx.config.showReasoning;
-                const status = ctx.config.showReasoning ? pc.green(t("repl.show")) : pc.dim(t("repl.hide"));
-                ctx.output.writeLine(t("repl.reasoning_status", { status }));
-            }
-            else if (VALID_LEVELS.includes(level)) {
-                // Set reasoning effort level
-                ctx.agent.setReasoningLevel(level);
-                ctx.output.writeLine(pc.green(t("repl.reasoning_level_set", { level })));
+                ctx.output.writeLine(t("verbose.status", { level: resolveVerbosity(ctx.config.ui) }));
+                return;
             }
-            else {
-                ctx.output.writeLine(pc.yellow(t("repl.reasoning_invalid_level", { level, valid: VALID_LEVELS.join(", ") })));
+            const result = await mutateConfig(ctx, "ui.verbosity", level);
+            if (!result.ok) {
+                renderConfigError(ctx, result);
+                return;
             }
+            ctx.output.writeLine(pc.green(t("repl.verbose_set", { level: result.display })));
         },
     });
     ctx.registerCommand({
@@ -209,17 +519,13 @@ function registerConfigCommands(ctx) {
         action: () => {
             const providers = ctx.agent.listProviders();
             const active = providers.find((p) => p.active);
-            ctx.output.writeLine(`${t("repl.model")} ${ctx.config.model}`);
-            if (active) {
-                ctx.output.writeLine(`${t("repl.provider")} ${active.label} (${pc.dim(active.type)}) @ ${pc.dim(active.baseUrl)}`);
-            }
-            else {
-                ctx.output.writeLine(`${t("repl.provider")} ${ctx.config.provider.type} @ ${ctx.config.provider.baseUrl}`);
-            }
+            const providerLabel = active ? active.label : ctx.config.provider.type;
+            const parts = [ctx.config.model, providerLabel];
             const meta = ctx.sessionManager?.getActiveMeta();
-            if (meta) {
-                ctx.output.writeLine(`${t("repl.session_label")} ${meta.name} (${meta.id}) — ${meta.messageCount} messages`);
-            }
+            if (meta)
+                parts.push(`${meta.name} (${meta.messageCount} ${t("repl.msgs")})`);
+            parts.push(`${ctx.config.contextWindow} tok`);
+            ctx.output.writeLine(parts.join(pc.dim(" · ")));
         },
     });
     ctx.registerCommand({
@@ -232,13 +538,7 @@ function registerConfigCommands(ctx) {
             await ctx.withExclusiveInput(async () => {
                 const answers = await runSetup(ctx.rl);
                 const configPath = join(ctx.configDir, "config.json");
-                ctx.config.provider.type = answers.provider;
-                ctx.config.provider.baseUrl = answers.apiBase;
-                ctx.config.provider.apiKey = answers.apiKey;
-                ctx.config.model = answers.model;
-                ctx.config.contextWindow = answers.contextWindow;
-                ctx.config.maxToolIterations = answers.maxToolIterations;
-                ctx.config.locale = answers.locale;
+                applyAnswersToConfig(ctx.config, answers);
                 saveConfig(ctx.config, configPath, dirname(configPath));
                 await ctx.agent.reconfigure(ctx.config);
                 ctx.output.writeLine(pc.green(t("cli.config_saved")));
@@ -248,21 +548,28 @@ function registerConfigCommands(ctx) {
     ctx.registerCommand({
         name: "sysprompt",
         description: t("repl.sysprompt_desc"),
-        usage: t("repl.sysprompt_desc"),
-        action: () => {
+        usage: t("repl.sysprompt_usage"),
+        examples: ["/sysprompt", "/sysprompt --full"],
+        action: (args) => {
             const info = ctx.agent.getSystemPromptInfo();
+            const full = args.includes("--full");
             ctx.output.writeLine(pc.bold(t("repl.sysprompt_tokens", { count: String(info.tokenCount) })));
-            ctx.output.writeLine(pc.dim("─".repeat(60)));
-            for (const line of info.text.split("\n")) {
-                ctx.output.writeLine(line);
-            }
-            ctx.output.writeLine(pc.dim("─".repeat(60)));
             if (info.excluded.length > 0) {
                 ctx.output.writeLine(pc.yellow(t("repl.excluded_blocks", { count: String(info.excluded.length) })));
                 for (const e of info.excluded) {
                     ctx.output.writeLine(pc.dim(`  - ${e.slice(0, 80)}${e.length > 80 ? "..." : ""}`));
                 }
             }
+            if (full) {
+                ctx.output.writeLine(pc.dim("─".repeat(60)));
+                for (const line of info.text.split("\n")) {
+                    ctx.output.writeLine(line);
+                }
+                ctx.output.writeLine(pc.dim("─".repeat(60)));
+            }
+            else {
+                ctx.output.writeLine(pc.dim(t("repl.sysprompt_full_hint")));
+            }
         },
     });
     ctx.registerCommand({
@@ -286,8 +593,9 @@ function registerProviderCommands(ctx) {
     const list = () => {
         const providers = ctx.agent.listProviders();
         if (providers.length === 0) {
-            ctx.output.writeLine(`${t("repl.provider_current")}  ${ctx.config.provider.type}`);
-            ctx.output.writeLine(`  ${ctx.config.provider.baseUrl}`);
+            const endpoint = activeProviderEndpoint(ctx.config.provider);
+            ctx.output.writeLine(`${t("repl.provider_current")}  ${endpoint.type}`);
+            ctx.output.writeLine(`  ${endpoint.baseUrl}`);
             return;
         }
         ctx.output.writeLine(t("repl.provider_current"));
@@ -302,14 +610,14 @@ function registerProviderCommands(ctx) {
             ctx.output.writeLine(t("repl.provider_usage"));
             return;
         }
-        try {
-            await ctx.agent.setProvider(name);
-            ctx.refreshModelCache();
-            ctx.output.writeLine(pc.green(t("repl.provider_set", { name })));
-        }
-        catch (e) {
-            ctx.output.writeLine(pc.red(e.message), "stderr");
+        const result = await mutateConfig(ctx, "provider.active", name);
+        if (!result.ok) {
+            renderConfigError(ctx, result);
+            return;
         }
+        ctx.refreshModelCache();
+        ctx.output.writeLine(pc.green(t("repl.provider_set", { name })));
+        reportSaved(ctx, result);
     };
     const add = async (args) => {
         const flags = {};
@@ -333,6 +641,13 @@ function registerProviderCommands(ctx) {
             ctx.output.writeLine(t("repl.provider_usage"));
             return;
         }
+        for (const flag of ["priority", "context-window", "rpm", "parallel"]) {
+            const v = flags[flag];
+            if (v !== undefined && !Number.isFinite(Number(v))) {
+                ctx.output.writeLine(pc.red(t("repl.provider_add_invalid_number", { flag: `--${flag}`, value: v })), "stderr");
+                return;
+            }
+        }
         const entries = Array.isArray(ctx.config.provider.entries) ? ctx.config.provider.entries : [];
         if (entries.length === 0) {
             entries.push({
@@ -347,6 +662,10 @@ function registerProviderCommands(ctx) {
             ctx.output.writeLine(pc.red(t("cli.provider_no_url", { name })), "stderr");
             return;
         }
+        if (providerNameTaken(entries, name)) {
+            ctx.output.writeLine(pc.red(t("cli.provider_name_conflict", { name })), "stderr");
+            return;
+        }
         entries.push({
             type: name,
             label: name,
@@ -367,8 +686,7 @@ function registerProviderCommands(ctx) {
         });
         ctx.config.provider.entries = entries;
         ctx.config.provider.active = ctx.config.provider.active || ctx.config.provider.type;
-        const configPath = join(ctx.configDir, "config.json");
-        saveConfig(ctx.config, configPath, dirname(configPath));
+        persistConfig(ctx);
         await ctx.agent.reconfigure(ctx.config);
         ctx.output.writeLine(pc.green(t("cli.provider_added", { name })));
         ctx.output.writeLine(t("repl.provider_switch_hint", { name }));
@@ -382,10 +700,12 @@ function registerProviderCommands(ctx) {
         name: "provider",
         description: t("repl.provider_list"),
         usage: t("repl.provider_usage"),
+        examples: ["/provider list", "/provider use openrouter", "/provider add openai --key sk-..."],
         action: async (args) => {
             const subcmd = args[0];
             const handler = subcmd ? handlers[subcmd] : handlers.list;
             if (!handler) {
+                ctx.output.writeLine(pc.yellow(t("repl.unknown_sub", { cmd: "provider", sub: subcmd })));
                 ctx.output.writeLine(t("repl.provider_usage"));
                 return;
             }
@@ -439,11 +759,17 @@ function registerProviderCommands(ctx) {
             ctx.output.writeLine(t("repl.model_usage"));
             return;
         }
-        ctx.config.model = name;
-        const configPath = join(ctx.configDir, "config.json");
-        saveConfig(ctx.config, configPath, dirname(configPath));
-        await ctx.agent.reconfigure(ctx.config);
+        const result = await mutateConfig(ctx, "model", name);
+        if (!result.ok) {
+            renderConfigError(ctx, result);
+            return;
+        }
         ctx.output.writeLine(pc.green(t("repl.model_set", { name })));
+        const known = ctx.knownModels();
+        if (known.length > 0 && !known.includes(name)) {
+            ctx.output.writeLine(pc.yellow(t("model.not_in_list", { name })));
+        }
+        reportSaved(ctx, result);
     };
     const modelHandlers = {
         list: listModels,
@@ -453,10 +779,12 @@ function registerProviderCommands(ctx) {
         name: "model",
         description: t("repl.model_list"),
         usage: t("repl.model_usage"),
+        examples: ["/model list", "/model use qwen/qwen3.5-9b"],
         action: async (args) => {
             const subcmd = args[0];
             const handler = subcmd ? modelHandlers[subcmd] : modelHandlers.list;
             if (!handler) {
+                ctx.output.writeLine(pc.yellow(t("repl.unknown_sub", { cmd: "model", sub: subcmd })));
                 ctx.output.writeLine(t("repl.model_usage"));
                 return;
             }
@@ -467,12 +795,8 @@ function registerProviderCommands(ctx) {
         name: "context",
         description: t("cli.manage_context"),
         usage: t("repl.context_usage"),
+        examples: ["/context", "/context 64000", "/context system 10%", "/context reserve 0.2"],
         action: async (args) => {
-            const save = async () => {
-                const configPath = join(ctx.configDir, "config.json");
-                saveConfig(ctx.config, configPath, dirname(configPath));
-                await ctx.agent.reconfigure(ctx.config);
-            };
             if (args.length === 0) {
                 for (const line of budgetBreakdownLines(ctx.config))
                     ctx.output.writeLine(line);
@@ -480,28 +804,62 @@ function registerProviderCommands(ctx) {
                 return;
             }
             if (args[0] === "system" || args[0] === "reserve") {
-                const key = args[0];
-                const value = Number(args[1]);
-                if (setBudgetShare(ctx.config, key, value) !== null) {
-                    ctx.output.writeLine(pc.yellow(t("cli.context_invalid_fraction")));
+                const raw = args[1];
+                if (!raw) {
+                    ctx.output.writeLine(t("repl.context_usage"));
                     return;
                 }
-                await save();
-                ctx.output.writeLine(pc.green(t("cli.context_fraction_set", { key, value })));
+                const key = args[0] === "system"
+                    ? "contextBudget.systemPrompt"
+                    : "contextBudget.responseReserve";
+                const result = await mutateConfig(ctx, key, raw);
+                if (!result.ok) {
+                    renderConfigError(ctx, result);
+                    return;
+                }
+                ctx.output.writeLine(pc.green(t("cli.context_fraction_set", { key: args[0], value: result.display })));
                 return;
             }
-            const size = parseInt(args[0], 10);
-            if (isNaN(size) || size < 1024) {
-                ctx.output.writeLine(t("cli.invalid_context_size"));
+            if (!/^\d+$/.test(args[0])) {
+                ctx.output.writeLine(pc.yellow(t("context.unknown_arg", { arg: args[0] })));
+                ctx.output.writeLine(t("repl.context_usage"));
                 return;
             }
-            ctx.config.contextWindow = size;
-            await save();
-            ctx.output.writeLine(pc.green(t("cli.context_set", { size })));
+            const result = await mutateConfig(ctx, "contextWindow", args[0]);
+            if (!result.ok) {
+                renderConfigError(ctx, result);
+                return;
+            }
+            ctx.output.writeLine(pc.green(t("cli.context_set", { size: String(result.value) })));
+            reportSaved(ctx, result);
         },
     });
 }
 function registerAgentCommands(ctx) {
+    const securityStatus = () => {
+        const s = ctx.config.security;
+        const flag = (v) => (v ? t("reasoning.on") : t("reasoning.off"));
+        const sep = pc.dim(" · ");
+        ctx.output.writeLine(`security${sep}${flag(s?.enabled)}`);
+        ctx.output.writeLine(`↳ bash ${flag(s?.bash.enabled)}${sep}paths ${flag(s?.paths.enabled)}${sep}network ${flag(s?.network.enabled)}`);
+        ctx.output.writeLine(`↳ contentScan ${flag(s?.contentScan.enabled)}${sep}encryption ${flag(s?.sessionEncryption.enabled)}`);
+    };
+    const securityHandlers = {
+        status: securityStatus,
+    };
+    ctx.registerCommand({
+        name: "security",
+        description: t("repl.security"),
+        action: (args) => {
+            const sub = args[0]?.trim().toLowerCase();
+            const handler = sub ? securityHandlers[sub] : securityHandlers.status;
+            if (!handler) {
+                ctx.output.writeLine(pc.yellow(t("repl.unknown_sub", { cmd: "security", sub })));
+                return;
+            }
+            handler();
+        },
+    });
     ctx.registerCommand({
         name: "reload",
         description: t("repl.reload"),
@@ -512,7 +870,8 @@ function registerAgentCommands(ctx) {
             ctx.output.writeLine(pc.green(t("repl.reloaded")));
             ctx.output.writeLine(`${t("repl.model")}       ${ctx.config.model}`);
             ctx.output.writeLine(`${t("repl.context")}     ${ctx.config.contextWindow}`);
-            ctx.output.writeLine(`${t("repl.provider")}    ${ctx.config.provider.type} @ ${ctx.config.provider.baseUrl}`);
+            const endpoint = activeProviderEndpoint(ctx.config.provider);
+            ctx.output.writeLine(`${t("repl.provider")}    ${endpoint.type} @ ${endpoint.baseUrl}`);
         },
     });
     ctx.registerCommand({
@@ -545,74 +904,7 @@ function registerAgentCommands(ctx) {
             if (!showAll) {
                 const builtinCount = infos.filter(({ plugin }) => plugin.isBuiltin).length;
                 if (builtinCount > 0) {
-                    ctx.output.writeLine(pc.dim(`  (${builtinCount} builtin hidden — /plugins --all to show)`));
-                }
-            }
-        },
-    });
-}
-function registerLspCommands(ctx) {
-    ctx.registerCommand({
-        name: "lsp",
-        description: t("repl.lsp"),
-        usage: t("repl.lsp_usage"),
-        action: async (args) => {
-            const subcommand = args[0] || "status";
-            // Access LSP module via the agent's module registry
-            const lspModule = ctx.agent.getModule("lsp");
-            if (!lspModule) {
-                ctx.output.writeLine(pc.yellow(t("repl.lsp_not_available")));
-                return;
-            }
-            switch (subcommand) {
-                case "status": {
-                    const disabled = lspModule.getDisabledServers();
-                    const failures = lspModule.getFailureCounts();
-                    const config = ctx.config.lsp;
-                    ctx.output.writeLine(pc.bold(t("repl.lsp_status_header")));
-                    ctx.output.writeLine(`${t("repl.lsp_enabled")} ${config?.enabled ? pc.green("yes") : pc.red("no")}`);
-                    if (disabled.length > 0) {
-                        ctx.output.writeLine(pc.yellow(`${t("repl.lsp_disabled_servers")} ${disabled.join(", ")}`));
-                    }
-                    if (failures.size > 0) {
-                        ctx.output.writeLine(pc.dim(t("repl.lsp_failure_counts")));
-                        for (const [server, count] of failures) {
-                            ctx.output.writeLine(pc.dim(`  ${server}: ${count}`));
-                        }
-                    }
-                    if (disabled.length === 0 && failures.size === 0) {
-                        ctx.output.writeLine(pc.green(t("repl.lsp_all_ok")));
-                    }
-                    break;
-                }
-                case "restart": {
-                    ctx.output.writeLine(pc.yellow(t("repl.lsp_restarting")));
-                    lspModule.resetDisabledServers();
-                    ctx.output.writeLine(pc.green(t("repl.lsp_restarted")));
-                    break;
-                }
-                case "check": {
-                    const path = args[1];
-                    if (!path) {
-                        ctx.output.writeLine(pc.yellow(t("repl.lsp_check_usage")));
-                        return;
-                    }
-                    ctx.output.writeLine(pc.dim(t("repl.lsp_checking", { path })));
-                    // Запуск тула lsp_check через публичный API агента (не через приватные deps)
-                    try {
-                        const result = await ctx.agent.runTool("lsp_check", { path });
-                        if (result?.output) {
-                            ctx.output.writeLine(result.output);
-                        }
-                    }
-                    catch (e) {
-                        ctx.output.writeLine(pc.red(t("repl.lsp_check_error", { error: errMsg(e) })), "stderr");
-                    }
-                    break;
-                }
-                default: {
-                    ctx.output.writeLine(pc.dim(t("repl.lsp_usage")));
-                    break;
+                    ctx.output.writeLine(pc.dim(`  ${t("repl.plugins_hidden", { count: String(builtinCount) })}`));
                 }
             }
         },
@@ -633,7 +925,23 @@ function registerSessionCommands(ctx) {
         description: t("repl.sessions"),
         aliases: ["ls"],
         usage: t("repl.sessions_usage"),
-        action: () => {
+        action: (args) => {
+            if (args[0] === "prune") {
+                const dry = args.includes("--dry-run");
+                const active = ctx.sessionManager.getActive();
+                const candidates = ctx.sessionManager.list().filter((s) => s.id !== active && ctx.sessionManager.isEmptySession(s.id));
+                if (candidates.length === 0) {
+                    ctx.output.writeLine(t("session.prune_empty"));
+                    return;
+                }
+                if (!dry)
+                    ctx.sessionManager.pruneEmpty(active ?? undefined);
+                ctx.output.writeLine(t(dry ? "session.prune_dry" : "session.pruned", { n: candidates.length }));
+                for (const s of candidates) {
+                    ctx.output.writeLine(pc.dim(`   ${s.id.slice(0, 12)}  ${s.name}`));
+                }
+                return;
+            }
             const sessions = ctx.sessionManager.list();
             const active = ctx.sessionManager.getActive();
             if (sessions.length === 0) {
@@ -668,6 +976,14 @@ function registerSessionCommands(ctx) {
             const name = args.join(" ") || undefined;
             const meta = ctx.sessionManager.create(name);
             ctx.agent.clearContext();
+            // План следует за сессией: новая — без плана, трекер сбрасывается.
+            const exec = ctx.agent.getModule("execution");
+            try {
+                exec?.switchSession(meta.id);
+            }
+            catch {
+                // fail-open: сессия создана, план остался как был
+            }
             ctx.output.clearScreen();
             ctx.output.writeLine(`${t("session.created", { name: meta.name })} (${pc.dim(meta.id.slice(0, 12))})`);
             ctx.output.writeLine(pc.dim(`  ${t("session.chat_cleared")}\n`));
@@ -676,8 +992,9 @@ function registerSessionCommands(ctx) {
     ctx.registerCommand({
         name: "resume",
         description: t("repl.resume"),
-        aliases: ["switch", "use"],
+        aliases: ["switch"],
         usage: t("repl.resume_usage"),
+        examples: ["/resume", "/resume my-session"],
         action: (args) => {
             const query = args.join(" ");
             const sessions = ctx.sessionManager.list();
@@ -701,6 +1018,17 @@ function registerSessionCommands(ctx) {
             ctx.sessionManager.setActive(match.id);
             const history = ctx.sessionManager.loadHistory();
             ctx.agent.setContext(history);
+            // План следует за сессией: трекер переключается на план этой сессии
+            // (или пустеет, если у неё плана нет).
+            const exec = ctx.agent.getModule("execution");
+            let planLine = null;
+            try {
+                exec?.switchSession(match.id);
+                planLine = exec?.getPlanSummary() ?? null;
+            }
+            catch {
+                // fail-open: история загружена, план остался как был
+            }
             ctx.output.clearScreen();
             ctx.output.writeLine(pc.bold(pc.green(t("session.resumed", { name: match.name }))) +
                 " " +
@@ -718,12 +1046,12 @@ function registerSessionCommands(ctx) {
                 ctx.output.writeLine("");
                 for (const msg of history) {
                     if (msg.role === "user") {
-                        ctx.output.writeLine(pc.cyan(t("session.user_label") + ":"));
+                        ctx.output.writeLine(pc.cyan(`${t("session.user_label")}:`));
                         ctx.output.writeLine(getMessageText(msg.content));
                         ctx.output.writeLine("");
                     }
                     else if (msg.role === "assistant") {
-                        ctx.output.writeLine(pc.green(t("session.assistant_label") + ":"));
+                        ctx.output.writeLine(pc.green(`${t("session.assistant_label")}:`));
                         ctx.output.writeLine(getMessageText(msg.content));
                         ctx.output.writeLine("");
                     }
@@ -731,6 +1059,7 @@ function registerSessionCommands(ctx) {
             }
             ctx.output.writeLine(pc.dim("─".repeat(50)));
             ctx.output.writeLine(pc.dim(`  ${t("session.chat_loaded")}`));
+            ctx.output.writeLine(pc.dim(`  ◇ ${planLine ?? t("plan.no_active")}`));
         },
     });
     ctx.registerCommand({
@@ -770,105 +1099,99 @@ function registerSessionCommands(ctx) {
                 return;
             }
             ctx.sessionManager.delete(match.id);
+            // План следует за сессией: слот удалённой сессии не оставляем мусором.
+            try {
+                ctx.agent
+                    .getModule("execution")
+                    ?.forgetSession(match.id);
+            }
+            catch {
+                /* best-effort */
+            }
             ctx.output.writeLine(`${t("session.deleted", { id: match.id })}: ${match.name}`);
         },
     });
-}
-function registerSkillCommands(ctx) {
-    if (!ctx.skillsModule)
-        return;
-    const listSkills = () => {
-        const available = ctx.skillsModule.getAvailable();
-        if (available.length === 0) {
-            ctx.output.writeLine(t("repl.no_skills"));
-            return;
-        }
-        ctx.output.writeLine(pc.bold(t("repl.available_skills")));
-        for (const skill of available) {
-            const tokens = estimateTokens(skill.content);
-            const loaded = ctx.skillsModule.getLoaded().some((s) => s.name === skill.name);
-            const marker = loaded ? pc.green(" [loaded]") : "";
-            ctx.output.writeLine(`  ${pc.cyan(skill.name)}${marker}  ${pc.dim(`(${tokens} tokens)`)}  ${skill.description.slice(0, 60)}`);
-        }
-    };
-    const listLoaded = () => {
-        const loaded = ctx.skillsModule.getLoaded();
-        const budget = ctx.skillsModule.getBudget();
-        if (loaded.length === 0) {
-            ctx.output.writeLine(t("repl.no_loaded"));
-            return;
-        }
-        ctx.output.writeLine(pc.bold(t("repl.loaded_skills")));
-        for (const skill of loaded) {
-            const tokens = estimateTokens(skill.content);
-            ctx.output.writeLine(`  ${pc.cyan(skill.name)}  ${pc.dim(`(${tokens} tokens)`)}  ${skill.description.slice(0, 60)}`);
-        }
-        ctx.output.writeLine(pc.dim(`\n  ${t("repl.budget", { used: budget.used, total: budget.total, remaining: budget.remaining })}`));
-    };
-    const loadSkill = (args) => {
-        const arg = args.join(" ");
-        if (!arg) {
-            ctx.output.writeLine(t("repl.skill_load_usage"));
-            return;
-        }
-        const result = ctx.skillsModule.loadByName(arg);
-        if (result.success) {
-            ctx.output.writeLine(pc.green(result.message));
-        }
-        else {
-            ctx.output.writeLine(pc.red(result.message), "stderr");
-        }
-    };
-    const unloadSkill = (args) => {
-        const arg = args.join(" ");
-        if (!arg) {
-            ctx.output.writeLine(t("repl.skill_unload_usage"));
-            return;
-        }
-        if (ctx.skillsModule.unload(arg)) {
-            ctx.output.writeLine(pc.green(t("repl.skill_unloaded", { name: arg })));
-        }
-        else {
-            ctx.output.writeLine(pc.red(t("repl.skill_not_loaded", { name: arg })), "stderr");
-        }
-    };
-    const searchSkills = (args) => {
-        const arg = args.join(" ");
-        if (!arg) {
-            ctx.output.writeLine(t("repl.skill_search_usage"));
-            return;
-        }
-        const results = ctx.skillsModule.search(arg);
-        if (results.length === 0) {
-            ctx.output.writeLine(t("repl.no_skill_match", { query: arg }));
-            return;
-        }
-        ctx.output.writeLine(pc.bold(t("repl.skills_matching", { query: arg })));
-        for (const skill of results) {
-            const tokens = estimateTokens(skill.content);
-            ctx.output.writeLine(`  ${pc.cyan(skill.name)}  ${pc.dim(`(${tokens} tokens)`)}  ${skill.description.slice(0, 60)}`);
-        }
-    };
-    const skillHandlers = {
-        list: listSkills,
-        loaded: listLoaded,
-        load: loadSkill,
-        unload: unloadSkill,
-        search: searchSkills,
-    };
     ctx.registerCommand({
-        name: "skill",
-        description: t("repl.skill"),
-        usage: t("repl.skill_usage"),
-        action: (args) => {
-            const subcmd = args[0];
-            const handler = subcmd ? skillHandlers[subcmd] : skillHandlers.list;
-            if (!handler) {
-                ctx.output.writeLine(pc.red(t("repl.skill_unknown_sub", { subcmd })), "stderr");
-                ctx.output.writeLine(t("repl.skill_usage"));
+        name: "export",
+        description: t("repl.export"),
+        usage: t("repl.export_usage"),
+        examples: [
+            "/export",
+            "/export my-session --format md",
+            "/export --format json --out -",
+        ],
+        action: async (args) => {
+            let format = "md";
+            let out;
+            let redact = true;
+            let compact = false;
+            const positional = [];
+            for (let i = 0; i < args.length; i++) {
+                const a = args[i];
+                if (a === "--format") {
+                    const v = args[++i];
+                    if (!v) {
+                        ctx.output.writeLine(t("export.missing_value", { flag: a }));
+                        return;
+                    }
+                    format = v;
+                }
+                else if (a === "--out") {
+                    const v = args[++i];
+                    if (v === undefined) {
+                        ctx.output.writeLine(t("export.missing_value", { flag: a }));
+                        return;
+                    }
+                    out = v;
+                }
+                else if (a === "--no-redact") {
+                    redact = false;
+                }
+                else if (a === "--compact") {
+                    compact = true;
+                }
+                else {
+                    positional.push(a);
+                }
+            }
+            if (format !== "md" && format !== "json" && format !== "jsonl") {
+                ctx.output.writeLine(pc.yellow(t("export.invalid_format", { format })), "stderr");
+                return;
+            }
+            const query = positional.join(" ");
+            const sessions = ctx.sessionManager.list();
+            const match = query
+                ? sessions.find((s) => s.id === query ||
+                    s.id.startsWith(query) ||
+                    s.name.toLowerCase().includes(query.toLowerCase()))
+                : sessions.find((s) => s.id === ctx.sessionManager.getActive());
+            if (!match) {
+                ctx.output.writeLine(query ? t("session.no_match", { query }) : t("session.no_active"));
+                return;
+            }
+            const messages = ctx.sessionManager.getHistory(match.id);
+            const log = ctx.sessionManager.loadSessionLog(match.id);
+            if (format === "jsonl" ? log.length === 0 : messages.length === 0) {
+                ctx.output.writeLine(pc.yellow(t("export.empty")));
+                return;
+            }
+            const text = redactExport(formatExport({ meta: match, messages, log }, format, { compact }), redact);
+            if (out === "-") {
+                ctx.output.writeLine(text);
+                return;
+            }
+            const baseDir = out ? dirname(out) : globalExportsDir();
+            const path = out ?? join(baseDir, `${sanitizeFileName(match.name)}-${match.id.slice(0, 8)}.${extensionFor(format)}`);
+            try {
+                mkdirSync(baseDir, { recursive: true });
+                writeFileSync(path, text, "utf-8");
+            }
+            catch (e) {
+                ctx.output.writeLine(pc.red(t("export.write_failed", { error: errMsg(e) })), "stderr");
                 return;
             }
-            handler(args.slice(1));
+            ctx.output.writeLine(pc.green(t("export.written", { path })));
+            ctx.output.writeLine(pc.dim(redact ? t("export.redacted") : t("export.raw")));
         },
     });
 }
@@ -889,7 +1212,7 @@ async function runConfigMigrate(ctx) {
     const { config } = loadCfg({ configDir, projectConfigPath: join(configDir, ".mmrc") });
     saveConfig(config, configPath, configDir);
     const { renameSync, readdirSync } = await import("fs");
-    renameSync(configPath, configPath + ".bak");
+    renameSync(configPath, `${configPath}.bak`);
     const domainFiles = readdirSync(join(configDir, "config")).filter((f) => f.endsWith(".json"));
     ctx.output.writeLine(pc.green(t("config.migrate_done", { count: String(domainFiles.length) })));
 }