micro-models-agent 2.11.0 → 2.12.0

package/dist/cli/repl.js

@@ -1,19 +1,27 @@
+// Интерактивный REPL: ввод, прогоны агента, slash-команды, баннер, история.
 import * as readline from "readline";
 import { pc } from "../ui/colors";
 import { LineEditor } from "../ui/line-editor";
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
 import { dirname, join } from "path";
 import { homedir } from "os";
-import { Completer, SlashCommandProvider, SessionNameProvider, SubcommandProvider, SkillNameProvider, ProviderArgProvider, ModelArgProvider, } from "./completer";
+import { Completer, SlashCommandProvider, SessionNameProvider, SubcommandProvider, SkillNameProvider, ProviderArgProvider, ModelArgProvider, FilePathProvider, ConfigKeyProvider, ConfigValueProvider, FlagProvider, CommandArgProvider, buildSlashCompletions, } from "./completer";
 import { Renderer } from "../ui/renderer";
+import { resolveVerbosity, glyph, toolAccent } from "../ui/theme";
+import { getLastAction } from "../ui/action-log";
 import { divider } from "../ui/box";
 import { t } from "../i18n/index";
+import { createHostBridge } from "../core/host";
+import { planSnapshotFromModule, adaptActivePlan } from "../core/host-plan";
 import { registerAllCommands } from "./repl-commands";
+import { captureConfigSnapshot } from "../config/registry";
+import { activeProviderEndpoint } from "../modules/providers/manager";
 import { probeLspServers } from "../modules/lsp/probe";
 import { FileOnlyLogger } from "../modules/lsp/client";
 import { DEFAULT_LSP_CONFIG } from "../modules/lsp/config";
 import { errMsg } from "../utils";
 import { SessionLogger } from "../core/session-logger";
+import { exitMeetMode } from "../modules/onboarding/mode";
 import { formatPlanChecklist, stepContextForTool } from "../ui/plan-view";
 import { formatCost } from "../modules/pricing/prices";
 import { formatCacheLine } from "./cache-line";
@@ -21,6 +29,9 @@ import { probeProviders, targetsFromProviders } from "../modules/providers/healt
 import { formatWarning } from "../ui/md-formatter";
 import { defaultOutputBus, getDefaultChannel, SessionOutputSink, writeNonTtyLine, } from "../output";
 import { createPromptIO } from "../tools/prompt-io";
+import { MMA_DIR_NAME, projectMmaDir } from "../config/paths";
+import { MMA_ENV, readEnv } from "../config/env";
+/** Рендерит бар использования контекста с компакциями и качеством. */
 function formatContextBar(used, limit, compactions, quality) {
     const pct = Math.min(100, Math.round((used / limit) * 100));
     const barLen = 20;
@@ -37,32 +48,15 @@ function formatContextBar(used, limit, compactions, 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();
-        },
-        subscribeOutput: (fn) => defaultOutputBus.subscribe(fn),
-    };
-}
+export { createHostBridge };
+/** Интерактивный REPL терминала: владеет stdin, гоняет ходы агента, slash-команды. */
 export class Repl {
+    /** Глобальный SIGINT-хендлер, общий на все инстансы Repl (см. registerSigint). */
+    static sigintHandler;
     completer = new Completer();
     modelCache = [];
+    /** Boot-снапшот управляемых ключей: `/config reset` откатывает из него. */
+    configSnapshot = new Map();
     running = false;
     agentRunning = false;
     inputLocked = false;
@@ -76,17 +70,17 @@ export class Repl {
     noAgentsMd;
     pendingClipboardImage = null;
     exitOnClose = false;
-    /** Owner of plan state (bootstrap). Null in tests — plan UI degrades. */
+    /** Владелец состояния плана (bootstrap). В тестах null — план-UI деградирует. */
     execModule;
     /**
-     * True only once the input prompt frame is actually on screen. The channel's
-     * prompt sink stays inactive until then, so the startup banner prints plainly
-     * instead of erasing/redrawing a frame that was never drawn.
+     * True, лишь когда кадр промпта ввода реально на экране. Промпт-синк канала
+     * неактивен до тех пор, чтобы стартовый баннер печатался plain, а не стирал/
+     * перерисовывал никогда не рисованный кадр.
      */
     promptPresented = false;
     /**
-     * Set by `runAgent` so the slash-command path knows the run already restored
-     * the prompt and must not present it a second time (e.g. `/run`).
+     * Ставит `runAgent`, чтобы slash-путь знал: прогон уже вернул промпт и второй
+     * раз его показывать нельзя (напр. `/run`).
      */
     runHandledPrompt = false;
     rl;
@@ -98,23 +92,31 @@ export class Repl {
     logger;
     slog;
     /**
-     * Persists `data.persist === true` output events to the active session.
-     * Inert until a SessionManager exists; re-bound by `/reload`.
+     * Расшаренный инстанс HostBridge (для плагинов; заодно движок `Host`-поверхности).
+     * Лениво строится, если PluginManager не аттачили.
+     */
+    hostBridge;
+    /**
+     * Персистит события вывода с `data.persist === true` в активную сессию.
+     * Инертен, пока нет SessionManager; перепривязывается через `/reload`.
      */
     sessionOutput;
     envReport;
-    /** Background probe of the actually loaded model context (bootstrap). */
+    /** Фоновый пробник реально загруженного контекста модели (bootstrap). */
     contextProbe;
     /**
-     * Single terminal writer for this REPL. Public (not private) because
-     * `ReplContext` exposes it to slash commands as `ctx.output`; a private
-     * field cannot satisfy a public interface property.
+     * Единый писатель терминала этого REPL. Публичен (не private), потому что
+     * `ReplContext` отдаёт его slash-командам как `ctx.output`; private-поле не
+     * удовлетворило бы публичному свойству интерфейса.
      */
     output;
-    /** Bridge that lets the channel draw above the live input frame. */
+    /** Мост, дающий каналу рисовать поверх живого кадра ввода. */
     promptSink;
-    /** Terminal-aware PromptIO installed on the agent's tool executor. */
+    /** PromptIO с осознанием терминала, ставится на экзекутор тулов агента. */
     promptIO;
+    get toolCtx() {
+        return this.agent.toolContext;
+    }
     constructor(agent, config, sessionManager, skillsModule, pluginManager, configDir, baseDir, noAgentsMd, logger, exitOnClose, envReport, historyPath, execModule, contextProbe, output) {
         this.agent = agent;
         this.config = config;
@@ -128,7 +130,7 @@ export class Repl {
         this.execModule = execModule;
         this.slog = new SessionLogger(sessionManager, logger);
         this.bindSessionOutput();
-        this.configDir = configDir || join(homedir(), ".mma");
+        this.configDir = configDir || join(homedir(), MMA_DIR_NAME);
         this.baseDir = baseDir || process.cwd();
         this.noAgentsMd = noAgentsMd === true;
         this.historyPath = historyPath ?? join(homedir(), ".mma", "repl-history");
@@ -139,6 +141,11 @@ export class Repl {
                 return [matches, partial];
             return [[], line];
         };
+        // Комплитер node-readline понимает только plain-строковые совпадения.
+        const readlineCompleter = (line) => {
+            const [items, partial] = editorCompleter(line);
+            return [items.map((i) => i.value), partial];
+        };
         if (process.stdin.isTTY) {
             this.rl = new LineEditor({
                 input: process.stdin,
@@ -157,7 +164,7 @@ export class Repl {
                 history: this.history,
                 historySize: this.maxHistory,
                 tabSize: 2,
-                completer: editorCompleter,
+                completer: readlineCompleter,
             });
         }
         this.output = output ?? getDefaultChannel();
@@ -171,9 +178,9 @@ export class Repl {
                     this.rl.printAbove(text);
                     return;
                 }
-                // Non-TTY fallback (readline / piped stdin): no input frame to redraw
-                // above, so write directly through the sanctioned machine-output helper
-                // — there is no frame for `printAbove` here.
+                // Не-TTY фолбэк (readline / пайпнутый stdin): кадра ввода для перерисовки
+                // сверху нет — пишем напрямую через санкционированный машинный хелпер:
+                // `printAbove` здесь не про что.
                 writeNonTtyLine(text);
             },
             clearScreen: () => {
@@ -182,32 +189,42 @@ export class Repl {
             },
         };
         this.output.attachPrompt(this.promptSink);
-        // Terminal-aware prompt surface for interactive tools (question/approve).
-        // The REPL owns stdin and is in `streaming` mode during a run, so tools
-        // must borrow the editor for a question instead of opening a competing
-        // readline that would fight the LineEditor's raw mode.
+        // Промпт-поверхность с осознанием терминала для интерактивных тулов (question/approve).
+        // stdin владеет REPL и на время прогона он в `streaming`: тулы обязаны одалживать
+        // редактор под вопрос, а не открывать конкурирующий readline, который подерётся
+        // с raw-режимом LineEditor.
         this.promptIO = createPromptIO({
             ask: (prompt) => this.askViaEditor(prompt),
             print: (line) => this.output.writeLine(line),
         });
         this.agent.setPromptIO?.(this.promptIO);
         registerAllCommands(this);
+        this.configSnapshot = captureConfigSnapshot(this.config);
         this.setupCompleter();
         this.setupListeners();
-        // Expose the agent to plugins (web UI etc.) through a narrow bridge.
+        // Отдаём агента плагинам (web UI и др.) через узкий мост.
         if (pluginManager) {
             this.attachHostBridge(pluginManager);
         }
     }
-    /** (Re)attach the plugin HostBridge. Called at construction and after
-     *  /reload replaces the PluginManager — without this, a reloaded web-ui
-     *  plugin silently loses the ability to submit messages. */
+    /** (Пере)аттач плагинного HostBridge. Зовётся в конструкторе и после того, как
+     *  /reload заменил PluginManager: без этого перезагруженный web-ui плагин
+     *  молча теряет способность сабмитить сообщения. */
     attachHostBridge(pm) {
         const manager = pm ?? this.pluginManager;
         if (!manager)
             return;
-        manager.setHostBridge(createHostBridge({
-            isBusy: () => this.agentRunning,
+        this.hostBridge ??= this.buildHostBridge();
+        manager.setHostBridge(this.hostBridge);
+    }
+    /** Единый busy-предикат для `Host`-поверхности и моста. */
+    isAgentBusy() {
+        return this.agentRunning;
+    }
+    /** Строит HostBridge поверх обычного run-пути этого REPL. */
+    buildHostBridge() {
+        return createHostBridge({
+            isBusy: () => this.isAgentBusy(),
             addPendingImage: (url) => {
                 this.agent.contextManager?.addPendingImage?.({
                     type: "image_url",
@@ -216,9 +233,14 @@ export class Repl {
             },
             runAgent: (text) => this.runAgent(text),
             interruptRun: () => this.agent.shutdown(),
-        }));
+        });
+    }
+    /** Лениво резолвит общий мост, чтобы `Host`-методы работали без плагинов. */
+    getHostBridge() {
+        this.hostBridge ??= this.buildHostBridge();
+        return this.hostBridge;
     }
-    /** (Re)bind the session output sink after construction or `/reload`. */
+    /** (Пере)привязка синка вывода сессии после конструктора или `/reload`. */
     bindSessionOutput() {
         this.sessionOutput?.dispose();
         this.sessionOutput = this.sessionManager
@@ -242,19 +264,20 @@ export class Repl {
         Object.assign(this.config, freshConfig);
         const result = await bootstrap(this.configDir, this.baseDir, false, false);
         this.agent = result.agent;
-        // Re-install the prompt surface on the freshly bootstrapped agent — the
-        // REPL's `askViaEditor` closure still belongs to this instance.
+        // Переустанавливаем промпт-поверхность на свежезабутстрапленного агента: замыкание
+        // `askViaEditor` этого REPL принадлежит всё ещё этому инстансу.
         this.agent.setPromptIO?.(this.promptIO);
         this.sessionManager = result.sessionManager;
         this.skillsModule = result.skillsModule;
         this.pluginManager = result.pluginManager;
         this.execModule = result.execModule;
         this.bindSessionOutput();
-        // Fresh PluginManager has no bridge — re-register it, otherwise plugins
-        // like web-ui silently lose control of the agent.
+        // У свежего PluginManager моста нет — перерегистрируем, иначе плагины вроде
+        // web-ui молча теряют управление агентом.
         this.attachHostBridge(result.pluginManager);
         this.setupCompleter();
     }
+    /** Грузит историю ввода из файла. */
     loadHistory() {
         if (existsSync(this.historyPath)) {
             try {
@@ -266,10 +289,11 @@ export class Repl {
             }
         }
     }
+    /** Сохраняет историю ввода. Падение каталога переживает молча, не бросает. */
     saveHistory() {
         try {
-            // The history dir may be gone (e.g. a temp dir removed during test or
-            // session teardown). Recreate it and never let a save throw.
+            // Каталога истории может не быть (напр. temp снесли в тесте или при teardown
+            // сессии). Пересоздаём; сейв бросать не должен никогда.
             mkdirSync(dirname(this.historyPath), { recursive: true });
             const allHistory = this.history.slice(-this.maxHistory);
             writeFileSync(this.historyPath, allHistory.join("\n"), "utf-8");
@@ -278,33 +302,102 @@ export class Repl {
             this.logger?.debug(`Failed to save REPL history: ${e.message}`);
         }
     }
+    /** Строит комплитер с нуля. */
     setupCompleter() {
-        // Rebuild from scratch: /reload calls this again after bootstrap, and
-        // re-registering without a reset would duplicate every provider.
+        // Пересборка с нуля: /reload зовёт снова после bootstrap, и перерегистрация
+        // без reset дублировала бы каждого провайдера.
         this.completer.reset();
-        const slashCommands = Array.from(this.commands.keys());
+        // `this.commands` ключуется каноническими именами И алиасами; итерация даёт
+        // каждый дополняемый токен с описанием его команды.
+        const slashCommands = buildSlashCompletions(this.commands);
         this.completer.registerProvider(new SlashCommandProvider(slashCommands));
         if (this.sessionManager) {
-            this.completer.registerProvider(new SessionNameProvider(() => this.sessionManager.list().map((s) => s.name)));
+            this.completer.registerProvider(new SessionNameProvider(() => this.sessionManager.list().map((s) => s.name), [
+                "/resume",
+                "/delete",
+                "/export",
+            ]));
         }
         if (this.skillsModule) {
-            this.completer.registerProvider(new SubcommandProvider("skill", ["list", "loaded", "load", "unload", "search"]));
+            this.completer.registerProvider(new SubcommandProvider("skill", [
+                { name: "list", description: t("skill.sub_list") },
+                { name: "loaded", description: t("skill.sub_loaded") },
+                { name: "load", description: t("skill.sub_load") },
+                { name: "unload", description: t("skill.sub_unload") },
+                { name: "search", description: t("skill.sub_search") },
+            ]));
             this.completer.registerProvider(new SkillNameProvider(this.skillsModule));
         }
-        // Subcommand + argument completion for provider/model management.
-        this.completer.registerProvider(new SubcommandProvider("provider", ["list", "use", "add"]));
-        this.completer.registerProvider(new SubcommandProvider("model", ["list", "use"]));
+        // Комплит субкоманд + аргументов управления provider/model.
+        this.completer.registerProvider(new SubcommandProvider("provider", [
+            { name: "list", description: t("provider.sub_list") },
+            { name: "use", description: t("provider.sub_use") },
+            { name: "add", description: t("provider.sub_add") },
+        ]));
+        this.completer.registerProvider(new SubcommandProvider("model", [
+            { name: "list", description: t("model.sub_list") },
+            { name: "use", description: t("model.sub_use") },
+        ]));
+        this.completer.registerProvider(new SubcommandProvider("map", [
+            { name: "summary", description: t("map.sub_summary") },
+            { name: "refresh", description: t("map.sub_refresh") },
+            { name: "find", description: t("map.sub_find") },
+        ]));
+        this.completer.registerProvider(new SubcommandProvider("context", [
+            { name: "system", description: t("context.sub_system") },
+            { name: "reserve", description: t("context.sub_reserve") },
+        ]));
+        this.completer.registerProvider(new SubcommandProvider("lsp", [
+            { name: "status", description: t("lsp.sub_status") },
+            { name: "restart", description: t("lsp.sub_restart") },
+            { name: "check", description: t("lsp.sub_check") },
+        ]));
+        this.completer.registerProvider(new SubcommandProvider("reasoning", [
+            { name: "show", description: t("reasoning.sub_show") },
+            { name: "hide", description: t("reasoning.sub_hide") },
+            { name: "level", description: t("reasoning.sub_level") },
+        ]));
+        this.completer.registerProvider(new SubcommandProvider("verbose", [
+            { name: "quiet", description: t("verbose.sub_quiet") },
+            { name: "normal", description: t("verbose.sub_normal") },
+            { name: "verbose", description: t("verbose.sub_verbose") },
+        ]));
+        this.completer.registerProvider(new SubcommandProvider("security", [
+            { name: "status", description: t("cli.security.status") },
+        ]));
+        this.completer.registerProvider(new ConfigKeyProvider());
+        this.completer.registerProvider(new ConfigValueProvider());
+        this.completer.registerProvider(new FlagProvider());
+        this.completer.registerProvider(new CommandArgProvider(() => Array.from(this.commands.entries())
+            .filter(([key, cmd]) => key === cmd.name)
+            .map(([, cmd]) => cmd.name)));
         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).
+        // Комплит путей якорится на workspace агента, а не process.cwd().
+        this.completer.registerProvider(new FilePathProvider(this.baseDir));
+        // Греем кеш моделей фоном (бесплатный listModels-вызов).
         this.refreshModelCache();
     }
+    /** Перестройка реестра + комплитера — после смены `/config locale`. */
+    reregisterCommands() {
+        this.commands.clear();
+        registerAllCommands(this);
+        this.setupCompleter();
+    }
+    /** Boot-снапшот управляемых ключей для `/config reset`. */
+    getConfigSnapshot() {
+        return this.configSnapshot;
+    }
+    /** Кешированные id моделей активного провайдера (пусто, пока офлайн). */
+    knownModels() {
+        return this.modelCache;
+    }
     /**
-     * Background refresh of the cached model list used by `/model use <Tab>`.
-     * Best-effort: on failure the cache keeps its previous contents.
+     * Фоновое обновление кешированного списка моделей для `/model use <Tab>`.
+     * Best-effort: при провале кеш хранит прошлое содержимое.
      */
     refreshModelCache() {
         void (async () => {
@@ -346,7 +439,7 @@ export class Repl {
                 }
             }
             if (inMultiLine) {
-                multiLineBuffer += "\n" + line;
+                multiLineBuffer += `\n${line}`;
                 if (!this.isMultiLineInput(multiLineBuffer)) {
                     inMultiLine = false;
                     const fullInput = multiLineBuffer.trim();
@@ -391,7 +484,7 @@ export class Repl {
             this.running = false;
             this.saveHistory();
             this.agent.shutdown();
-            // Close session log when REPL exits
+            // Закрываем лог сессии на выходе из REPL.
             this.logger?.closeSessionLog();
             if (this.exitOnClose)
                 process.exit(0);
@@ -401,7 +494,7 @@ export class Repl {
                 this.running = false;
                 this.saveHistory();
                 this.agent.shutdown();
-                // Close session log when REPL exits
+                // Закрываем лог сессии на выходе из REPL.
                 this.logger?.closeSessionLog();
                 process.exit(0);
             });
@@ -410,10 +503,12 @@ export class Repl {
             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.
+        // Запас на очистку (сессия, MCP, дочерние процессы) после второго Ctrl+C.
+        const FORCE_EXIT_MS = 5000;
+        // Идемпотентная регистрация: второй Repl в том же процессе не добавляет
+        // ещё один глобальный SIGINT-хендлер. Протёкшие хендлеры инстансов REPL,
+        // созданные в тестах, стреляли process.exit(0) на ЛЮБОЙ process.emit("SIGINT")
+        // в другом месте и молча убивали весь bun-раннер тестов.
         if (typeof Repl.sigintHandler === "function") {
             process.removeListener("SIGINT", Repl.sigintHandler);
         }
@@ -424,7 +519,10 @@ export class Repl {
                 this.agentRunning = false;
                 if (forceExitTimer)
                     clearTimeout(forceExitTimer);
-                forceExitTimer = setTimeout(() => process.exit(1), 2000).unref();
+                forceExitTimer = setTimeout(() => {
+                    this.output.writeLine(pc.yellow(t("repl.force_exit")));
+                    process.exit(1);
+                }, FORCE_EXIT_MS).unref();
             }
             else {
                 process.exit(0);
@@ -433,10 +531,10 @@ export class Repl {
         process.on("SIGINT", Repl.sigintHandler);
     }
     /**
-     * Re-present the input prompt after a slash command. Commands do not own a
-     * frame lifecycle, so they need this explicit redraw. The agent path is
-     * deliberately excluded: `runAgent`'s finally calls `LineEditor.resumeFrame()`
-     * as its single prompt presentation, so prompting here again would double-draw.
+     * Перепоказ промпта ввода после slash-команды. У команд нет владения жизненным
+     * циклом кадра, им нужна явная перерисовка. Путь агента осознанно исключён:
+     * finally `runAgent` зовёт `LineEditor.resumeFrame()` как единственный показ —
+     * промпт здесь дал бы двойную отрисовку.
      */
     presentPrompt() {
         if (!this.running)
@@ -445,13 +543,20 @@ export class Repl {
         this.rl.prompt();
         this.promptPresented = true;
     }
+    /** Возврат обычного промпта после стартового вопроса, если активен LineEditor. */
+    restoreStartupPrompt() {
+        if (this.rl instanceof LineEditor) {
+            this.rl.setPrompt(this.inputPrompt());
+            this.rl.prompt();
+            this.promptPresented = true;
+        }
+    }
     /**
-     * Reasoning label shown in the input prompt. In `auto` mode the effective
-     * level is normally decided per iteration by the policy, so we show only the
-     * fact that reasoning is automatic. If the user set an explicit override
-     * (`/reasoning <level>`, persistent) or the agent set a still-active
-     * `set_thinking` override (transient), we show `auto→<level>`. In a fixed
-     * mode we show the effective level.
+     * Ярлык reasoning в промпте ввода. В `auto` эффективный уровень обычно решает
+     * политика поитерационно, так что показываем лишь факт автоматики. При явном
+     * оверрайде юзера (`/reasoning <level>`, персистентный) или активном
+     * `set_thinking`-оверрайде агента (транзиентный) — `auto→<level>`. В фикс.
+     * режиме — эффективный уровень.
      */
     reasoningLabel() {
         const mode = this.config.reasoning?.mode ?? "default";
@@ -464,16 +569,15 @@ export class Repl {
             return `auto→${this.agent.reasoningLevel}`;
         return "auto";
     }
-    /** Localized input prompt embedding the active reasoning mode/level. */
+    /** Локализованный промпт ввода со встроенным режимом/уровнем reasoning. */
     inputPrompt(continuation = false) {
         const key = continuation ? "repl.you_reasoning_cont" : "repl.you_reasoning";
         return pc.cyan(t(key, { level: this.reasoningLabel() }));
     }
     /**
-     * Prompt bookkeeping after a slash command. A command that drove a run
-     * (e.g. `/run`) already had its prompt restored by `runAgent`; presenting
-     * again would double-render, so skip it exactly once. All other commands
-     * present the prompt here.
+     * Учёт промпта после slash-команды. Команда, прогнавшая прогон (напр. `/run`),
+     * уже вернула себе промпт через `runAgent`: повторный показ двоил бы рендер,
+     * так что скипаем ровно раз. Все прочие команды показывают промпт здесь.
      */
     afterCommand() {
         if (this.runHandledPrompt) {
@@ -482,12 +586,12 @@ export class Repl {
         }
         this.presentPrompt();
     }
-    handleSpecialKey(str, key) {
+    /** Спецклавиши: двойной Esc — аборт прогона, Ctrl+V — вставка картинки, Ctrl+O — детали. */
+    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.
+            // Декодер keypress Bun схлопывает быстрый двойной Esc в один keypress, чей
+            // `sequence` содержит два ESC-байта ("\x1b\x1b"). Подсчёт байтов (не событий)
+            // ловит и схлопнутый случай, и два раздельных Esc в окне.
             const escBytes = key.sequence ? (key.sequence.match(/\x1b/g) || []).length : 1;
             const now = Date.now();
             const withinWindow = now - this.lastEscTime < this.doubleEscDelay;
@@ -505,8 +609,34 @@ export class Repl {
             this.pasteClipboardImage();
             return true;
         }
+        if (key.ctrl && key.name === "o" && !this.agentRunning) {
+            this.reprintLastAction();
+            return true;
+        }
         return false;
     }
+    /** Ctrl+O — допечатка полных деталей последнего действия. */
+    reprintLastAction() {
+        const last = getLastAction();
+        if (!last) {
+            this.output.writeLine(pc.dim(t("repl.last_action_none")));
+            return;
+        }
+        const mark = last.status === "error"
+            ? pc.red(glyph.failure)
+            : last.status === "warn"
+                ? pc.yellow(glyph.warning)
+                : pc.green(glyph.success);
+        const accent = toolAccent(last.tool);
+        const head = `${accent(glyph.action)} ${accent(last.label)}${last.args ? ` ${pc.dim("·")} ${pc.dim(last.args)}` : ""}  ${mark} ${pc.dim(`${last.durationMs}ms`)}`;
+        const lines = [head, ...last.body.map((l) => `  ${l}`)];
+        this.output.writeLine(`\n${lines.join("\n")}`);
+        if (this.rl instanceof LineEditor) {
+            this.rl.reset();
+            this.rl.prompt();
+        }
+    }
+    /** Вставка картинки из буфера обмена (Ctrl+V). */
     async pasteClipboardImage() {
         try {
             const { readClipboardImage, bufferToDataUrl } = await import("../llm/image-utils");
@@ -528,9 +658,10 @@ export class Repl {
             }
         }
         catch {
-            // clipboard read failed — ignore, let terminal paste text normally
+            // Чтение буфера не удалось — игнорим, пусть терминал вставит текст штатно.
         }
     }
+    /** Проверка незакрытого многострочного ввода (хвостовой `\` или `{` без `}`). */
     isMultiLineInput(line) {
         if (line.endsWith("\\"))
             return true;
@@ -540,6 +671,7 @@ export class Repl {
             return true;
         return false;
     }
+    /** Прогон хода агента: стрим в рендерер, футер, бары, возврат промпта. */
     async runAgent(input) {
         if (this.agentRunning)
             return;
@@ -556,27 +688,27 @@ export class Repl {
                 this.pendingClipboardImage = null;
             }
             this.logger?.logREPL("user", input);
-            // The prompt frame is about to be taken down; deactivate the sink before
-            // any streamed output so nothing tries to draw above it.
+            // Кадр промпта сейчас снимется; гасим синк до любого стримленного вывода,
+            // чтобы ничего не пыталось рисовать поверх него.
             this.promptPresented = false;
-            // Hand the terminal to the channel for the duration of the run: the
-            // editor stops drawing its frame and ignores typed keys, so streamed
-            // output cannot corrupt the input line. suspendFrame() runs before
-            // reset(), which would otherwise draw a frame only to erase it.
+            // Отдаём терминал каналу на время прогона: редактор перестаёт рисовать кадр
+            // и игнорит клавиши, и стрим не портит строку ввода. suspendFrame() идёт до
+            // reset(), который иначе нарисовал бы кадр лишь затем, чтобы стереть.
             if (this.rl instanceof LineEditor) {
                 this.rl.suspendFrame();
                 this.rl.setInputEnabled(false);
                 this.rl.reset();
             }
             this.output.beginStreaming();
-            // Divider + agent label, written raw (no trailing newline): the next
-            // Renderer.text() chunk adds its own leading "\n" ("- ..."), so a
-            // writeLine here would insert a blank line ("Agent:\n\n- ...").
+            // Разделитель + ярлык агента, сырьём (без trailing newline): следующий чанк
+            // Renderer.text() добавляет свой ведущий "\n", и writeLine здесь вставил бы
+            // пустую строку ("Agent:\n\n...").
             this.output.writeRaw(`\r${divider()}\n${pc.green(t("repl.agent"))}`);
             const renderer = new Renderer({
                 spinner: this.config.ui?.spinner ?? true,
                 baseDir: this.baseDir,
                 channel: this.output,
+                verbosity: resolveVerbosity(this.config.ui),
             });
             renderer.showLoader();
             const result = await this.agent.run(input, (c) => renderer.text(c), (m) => renderer.meta(m), (ev) => {
@@ -585,7 +717,7 @@ export class Repl {
                 }
                 else {
                     renderer.toolEnd(ev.tool, ev.duration ?? 0, ev.error, ev.ctxDelta, ev.costUsd);
-                    if (ev.tool === "plan" || ev.tool === "todo") {
+                    if (ev.tool === "plan" || ev.tool === "todo" || ev.tool === "plan_step") {
                         this.renderPlan(renderer);
                     }
                 }
@@ -596,7 +728,7 @@ export class Repl {
                 else {
                     renderer.thinkingEnd();
                 }
-            });
+            }, (reasoning) => renderer.reasoning(reasoning));
             renderer.flush();
             if (result.provider && result.model) {
                 renderer.footer(result.model, result.provider, result.llmDurationMs ?? result.durationMs ?? 0);
@@ -607,8 +739,8 @@ export class Repl {
                 this.output.writeLine(pc.red(`${t("error.prefix")}${result.error}`), "stderr");
             }
             this.showContextBar(result);
-            // Close the agent's turn: a divider before the next prompt keeps
-            // consecutive user/agent messages visually separated.
+            // Закрываем ход агента: разделитель перед следующим промптом визуально
+            // разводит соседние сообщения юзера/агента.
             this.output.writeLine(`\n${divider()}`);
         }
         finally {
@@ -616,26 +748,32 @@ export class Repl {
             this.output.endStreaming();
             if (this.rl instanceof LineEditor) {
                 this.rl.setInputEnabled(true);
-                // Single prompt presentation for the agent path: resumeFrame()
-                // redraws the frame, so the `line` listener must NOT prompt again
-                // after runAgent() (it still does after slash commands).
-                // Re-set the prompt first so a reasoning level changed by
-                // set_thinking during the run is reflected on the resumed frame.
+                // Единственный показ промпта на пути агента: resumeFrame() перерисовывает
+                // кадр, так что слушатель `line` после runAgent() промпт НЕ показывает
+                // (после slash-команд — показывает). Промпт переставляем первым, чтобы
+                // уровень reasoning, сменённый set_thinking в прогоне, отразился на
+                // возобновлённом кадре.
                 this.rl.setPrompt(this.inputPrompt());
                 this.rl.resumeFrame();
                 this.promptPresented = true;
             }
             else {
-                // Piped/non-TTY fallback has no frame to resume; present the readline
-                // prompt here to preserve the old post-run behavior.
+                // У пайпнутого/не-TTY фолбэка кадра для resume нет; показываем readline-
+                // промпт здесь ради старого пост-прогонного поведения.
                 this.presentPrompt();
             }
+            const onboardingCtx = this.agent.tryToolContext();
+            if (onboardingCtx?.onboarding?.done) {
+                exitMeetMode(this);
+                this.slog.logOnboarding("meet_done", { model: this.config.model });
+                this.output.writeLine(pc.dim(t("repl.meet_done")));
+            }
             this.runHandledPrompt = true;
         }
     }
-    /** 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. */
+    /** Печать чеклиста плана, трекаемого ExecutionModule.
+     *  Зовётся только на plan/todo-событиях (событие изменения), не поллится:
+     *  дисковый план прошлой сессии не протечёт в чат. */
     renderPlan(renderer) {
         const plan = this.execModule?.getActivePlan();
         if (!plan)
@@ -643,6 +781,7 @@ export class Repl {
         renderer.planBlock(formatPlanChecklist(plan));
     }
     commands = new Map();
+    /** Регистрирует slash-команду (имя + алиасы). */
     registerCommand(cmd) {
         this.commands.set(cmd.name, cmd);
         if (cmd.aliases) {
@@ -651,12 +790,12 @@ export class Repl {
             }
         }
     }
+    /** Эксклюзивный ввод: визард владеет терминалом через свои `rl.question()`. */
     async withExclusiveInput(fn) {
-        // The wizard owns the terminal through its own `rl.question()` calls. Between
-        // questions no frame is active, so its menus/scan results must be written
-        // directly — bracketing with beginModal/endModal would QUEUE the whole
-        // transcript and the user would only see bare `: ` prompts until completion.
-        // `inputLocked` makes `promptSink.isActive()` false, routing writes direct.
+        // Между вопросами активного кадра нет, так что меню/результаты скана пишутся
+        // напрямую: обёртка beginModal/endModal сложила бы ВЕСЬ транскрипт в очередь,
+        // и юзер видел бы голые `: ` промпты до конца. `inputLocked` гасит
+        // `promptSink.isActive()`, пуская записи напрямую.
         this.inputLocked = true;
         try {
             await fn();
@@ -666,16 +805,14 @@ export class Repl {
         }
     }
     /**
-     * Borrow the terminal for one interactive-tool question and hand it back.
-     * During a run the LineEditor is suspended with input disabled; enabling
-     * input + resuming the frame lets `question()` read keys while the agent
-     * blocks, and the `finally` restores exactly the streaming state so the
-     * agent's own renderer keeps working afterwards.
+     * Одалживает терминал под один вопрос интерактивного тула и возвращает обратно.
+     * На время прогона LineEditor suspended с выключенным вводом; включение ввода +
+     * resume кадра даёт `question()` читать клавиши, пока агент блокирован, а `finally`
+     * восстанавливает ровно стрим-состояние, и рендерер агента работает дальше как ни в чём.
      *
-     * Order matters: `beginModal()` first flushes any output still buffered by
-     * the streaming channel so it prints plainly before the frame returns;
-     * `endModal()` runs only after the frame is suspended again, so events
-     * queued during the question flush plainly instead of corrupting the frame.
+     * Порядок важен: `beginModal()` сначала сбрасывает вывод, ещё буферный у стрим-канала,
+     * чтобы напечатался plain до возврата кадра; `endModal()` идёт лишь после повторного
+     * suspend кадра, чтобы события, накопленные за вопрос, сбросились plain, а не побили кадр.
      */
     async askViaEditor(prompt) {
         const editor = this.rl instanceof LineEditor ? this.rl : null;
@@ -700,16 +837,60 @@ export class Repl {
             this.output.endModal();
         }
     }
-    async executeCommand(input) {
+    /** Host/HostBridge: true, пока агент крутит ход. */
+    isBusy() {
+        return this.isAgentBusy();
+    }
+    /** Host/HostBridge: сабмит через общий мост (тот же run-путь). */
+    submit(text, opts) {
+        return this.getHostBridge().submit(text, opts);
+    }
+    /** Host/HostBridge: прерывание текущего прогона (в idle — no-op). */
+    interrupt() {
+        this.getHostBridge().interrupt();
+    }
+    /** Host/HostBridge: подписка на общую шину вывода. */
+    subscribeOutput(fn) {
+        return defaultOutputBus.subscribe(fn);
+    }
+    /** Host: прогон slash-команды через ту же handler-map, что и ручной ввод. */
+    async executeCommand(line) {
+        const trimmed = line.trim();
+        if (!trimmed.startsWith("/"))
+            return;
+        await this.dispatchCommand(trimmed);
+    }
+    /** Host: снапшот план/сессия/модель для UI-поверхностей. */
+    getState() {
+        const meta = this.sessionManager?.getActiveMeta();
+        return {
+            busy: this.agentRunning,
+            sessionId: meta?.id,
+            sessionName: meta?.name,
+            model: this.config.model,
+            provider: this.config.provider?.active,
+            plan: planSnapshotFromModule(adaptActivePlan(this.execModule?.getActivePlan())),
+        };
+    }
+    async dispatchCommand(input) {
         const parts = input.split(/\s+/);
         const name = parts[0].slice(1);
         const args = parts.slice(1);
-        // Clear any stale run flag from a previous direct agent run so this
-        // command's own presentPrompt() decision is based on its own action.
+        // Сбрасываем протухший run-флаг прошлого прямого прогона, чтобы решение
+        // presentPrompt() этой команды строилось на её собственном действии.
         this.runHandledPrompt = false;
         const cmd = this.commands.get(name);
         if (!cmd) {
-            this.output.writeLine(`${pc.red(t("cli.unknown_cmd", { name }))} ${t("cli.help_hint")}`);
+            // Бывшие алиасы, уехавшие в субкоманду: указываем на новый синтаксис,
+            // а не на голое "unknown command".
+            const formerAliases = { use: "resume" };
+            const suggestion = formerAliases[name];
+            if (suggestion) {
+                this.output.writeLine(pc.red(t("cli.unknown_command", { input: `/${name}`, suggestion: `/${suggestion}` })));
+            }
+            else {
+                this.output.writeLine(`${pc.red(t("cli.unknown_cmd", { name }))} ${t("cli.help_hint")}`);
+            }
             return;
         }
         try {
@@ -721,8 +902,30 @@ export class Repl {
             })), "stderr");
         }
     }
-    showHelp() {
+    /** Показ помощи: общая или по команде (`/help <команда>`). */
+    showHelp(command) {
         const { COMMAND_GROUPS } = require("./repl-commands");
+        if (command) {
+            const name = command.replace(/^\//, "");
+            const cmd = this.commands.get(name);
+            if (!cmd) {
+                this.output.writeLine(pc.red(t("repl.help_unknown", { name })));
+                return;
+            }
+            this.output.writeLine(pc.bold(pc.cyan(`/${cmd.name}`)));
+            this.output.writeLine(`  ${cmd.description}`);
+            if (cmd.usage)
+                this.output.writeLine(`  ${pc.dim(cmd.usage)}`);
+            if (cmd.aliases?.length) {
+                this.output.writeLine(pc.dim(`  ${t("repl.help_aliases", { names: cmd.aliases.join(", ") })}`));
+            }
+            if (cmd.examples?.length) {
+                this.output.writeLine(pc.dim(`  ${t("repl.help_examples")}`));
+                for (const ex of cmd.examples)
+                    this.output.writeLine(pc.dim(`    ${ex}`));
+            }
+            return;
+        }
         const order = ["general", "agent", "session", "skill"];
         const seen = new Set();
         for (const groupKey of order) {
@@ -743,7 +946,7 @@ export class Repl {
             this.output.writeLine(pc.bold(t(`repl.group.${groupKey}`)));
             for (const cmd of cmds) {
                 const aliases = cmd.aliases?.length ? ` (${pc.dim(cmd.aliases.join(", "))})` : "";
-                this.output.writeLine(`  ${pc.cyan("/" + cmd.name)}${aliases}  ${pc.dim(cmd.description)}`);
+                this.output.writeLine(`  ${pc.cyan(`/${cmd.name}`)}${aliases}  ${pc.dim(cmd.description)}`);
                 if (cmd.usage) {
                     this.output.writeLine(`    ${pc.dim(cmd.usage)}`);
                 }
@@ -764,7 +967,11 @@ export class Repl {
             const ctxLine = formatContextBar(result.contextUsed, result.contextLimit, result.compactionCount, result.contextQuality);
             this.output.writeLine(ctxLine);
             if (result.totalTokens !== undefined && result.totalTokens > 0) {
-                const apiLine = pc.dim(`  API: ${result.promptTokens} prompt + ${result.completionTokens} completion = ${result.totalTokens} total`);
+                const apiLine = pc.dim(t("repl.api_line", {
+                    prompt: String(result.promptTokens),
+                    completion: String(result.completionTokens),
+                    total: String(result.totalTokens),
+                }));
                 this.output.writeLine(apiLine);
             }
             if (result.totalCost !== undefined && result.totalCost > 0) {
@@ -778,7 +985,7 @@ export class Repl {
         else if (ui?.showCompaction && result.compactionCount !== undefined) {
             if (result.compactionCount > this.lastCompactionShown) {
                 this.lastCompactionShown = result.compactionCount;
-                this.output.writeLine(pc.dim(`\n  ⟳ Context compacted (${result.compactionCount})`));
+                this.output.writeLine(pc.dim(`\n  ⟳ ${t("repl.compacted", { count: String(result.compactionCount) })}`));
             }
         }
     }
@@ -793,13 +1000,18 @@ export class Repl {
         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)}`);
+        // Плоские поля протухают после `/provider use` — истина в entries.
+        const endpoint = activeProviderEndpoint(this.config.provider);
+        row(t("repl.provider"), `${endpoint.type}  →  ${pc.dim(endpoint.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`)}`);
+            row(t("repl.skills_label"), t("repl.skills_available", {
+                count: String(this.skillsModule.getAvailable().length),
+                budget: String(budget.total),
+            }));
         }
         if (this.pluginManager) {
             const infos = this.pluginManager.getPluginInfos().filter(({ plugin }) => !plugin.isBuiltin);
@@ -811,7 +1023,7 @@ export class Repl {
                     return `${plugin.name}${version}${origin}`;
                 })
                     .join(", ");
-                row(t("repl.plugins_label"), `${pc.white(String(infos.length))} active  ${pc.dim(`(${pluginNames})`)}`);
+                row(t("repl.plugins_label"), t("repl.plugins_active", { count: String(infos.length), names: pluginNames }));
             }
         }
         const mcpServers = this.config.mcpServers || {};
@@ -820,8 +1032,8 @@ export class Repl {
             const names = enabledServers.map(([name]) => name).join(", ");
             row(t("repl.mcp_label"), `${pc.white(String(enabledServers.length))}  ${pc.dim(`(${names})`)}`);
         }
-        // Show the agent's workspace (the `-d` dir), not the process cwd: `bun run`
-        // sets cwd to the package root, which is NOT where the agent operates.
+        // Показываем workspace агента (каталог `-d`), а не process cwd: `bun run`
+        // ставит cwd в корень пакета, где агент НЕ работает.
         row(t("repl.work_dir"), pc.dim(this.baseDir));
         if (this.noAgentsMd) {
             row(t("repl.agents_label"), pc.red(t("repl.disabled")));
@@ -829,7 +1041,7 @@ export class Repl {
         else {
             const agentsMdCandidates = [
                 join(this.baseDir, "AGENTS.md"),
-                join(this.baseDir, ".mma", "AGENTS.md"),
+                join(projectMmaDir(this.baseDir), "AGENTS.md"),
                 join(this.configDir, "AGENTS.md"),
             ];
             const foundAgents = agentsMdCandidates.filter((p) => existsSync(p));
@@ -845,17 +1057,17 @@ export class Repl {
         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)}`);
+            row(t("repl.session_label"), `${pc.cyan(meta.name)} ${pc.dim(`(${meta.id.slice(0, 12)})`)}  —  ${meta.messageCount} ${t("repl.msgs")}  ${pc.dim(sessionPath)}`);
         }
-        // LSP status is probed in the background — it must never block the banner.
+        // Статус LSP пробнится фоном — баннер блокировать нельзя.
         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.
+        // Plain-баннер без рамки: построчно, с переносом по ширине.
         for (const line of info) {
             this.output.writeLine(pc.dim(line).trimEnd());
         }
         this.output.writeLine("");
-        // Legacy config hint
+        // Хинт про legacy-конфиг.
         try {
             const { existsSync: exists } = await import("fs");
             const { join: pathJoin } = await import("path");
@@ -866,26 +1078,76 @@ export class Repl {
                 this.output.writeLine("");
             }
         }
-        catch { }
-        // Single prompt presentation for startup: the banner above was written
-        // plainly (promptPresented was false), so no frame needs erasing here.
+        catch {
+            // Хинт best-effort: ошибка чтения его просто скипает.
+        }
+        // Единственный показ промпта на старте: баннер выше печатался plain
+        // (promptPresented был false), так что стирать кадр здесь нечего.
         this.rl.prompt();
         this.promptPresented = true;
+        try {
+            if (readEnv("START_MEET") === "1" || readEnv("START_INIT") === "1") {
+                const mode = readEnv("START_MEET") === "1" ? "meet" : "init";
+                delete process.env[MMA_ENV.START_MEET];
+                delete process.env[MMA_ENV.START_INIT];
+                this.slog.logOnboarding(`${mode}_start`, { model: this.config.model });
+                if (mode === "meet") {
+                    const { runMeet } = await import("../modules/onboarding/meet");
+                    await runMeet(this);
+                }
+                else {
+                    const { runInit } = await import("../modules/onboarding/init");
+                    await runInit(this);
+                    this.slog.logOnboarding("init_done", { model: this.config.model });
+                }
+            }
+            else if (readEnv("POST_SETUP") === "1" && process.stdout.isTTY === true) {
+                const { preflightFromConfig } = await import("../modules/providers/preflight");
+                const pre = await preflightFromConfig(this);
+                if (pre.ok) {
+                    this.output.writeLine(pc.dim(`${t("repl.meet_offer")} ${t("repl.meet_offer_hint")}`));
+                    const answer = (await new Promise((resolve) => this.rl.question("[Y/n] ", resolve)))
+                        .trim()
+                        .toLowerCase();
+                    const yes = answer === "" ||
+                        answer === "y" ||
+                        answer === "yes" ||
+                        answer === "да" ||
+                        answer === "д";
+                    if (yes) {
+                        this.slog.logOnboarding("meet_start", { model: this.config.model });
+                        const { runMeet } = await import("../modules/onboarding/meet");
+                        await runMeet(this, { preflight: async () => pre });
+                    }
+                    else {
+                        this.restoreStartupPrompt();
+                    }
+                }
+                else {
+                    this.output.writeLine(pc.yellow(t("onboarding.provider_down", { cmd: "meet" })));
+                    this.output.writeLine(t("onboarding.provider_down_hint", { cmd: "meet" }));
+                }
+            }
+        }
+        catch (err) {
+            this.logger?.debug(`Onboarding startup skipped: ${String(err)}`);
+            this.restoreStartupPrompt();
+        }
         if (lspEnabled) {
             this.probeLspBanner()
                 .then((lspSummary) => {
                 if (lspSummary) {
                     const line = `${pc.green(t("repl.agent"))}${pc.yellow(t("repl.lsp_label"))} ${lspSummary}`;
-                    // Channel owns the prompt row now: no manual erase + prompt() hack.
+                    // Строкой промпта владеет канал: ручной erase + prompt()-хак не нужен.
                     this.output.writeLine(`${divider()}\n${line}`);
                 }
             })
                 .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.
+            // Phase 4.4: фоновый health-пробник всех entries (бесплатные listModels).
+            // Упавшие провайдеры — предупреждениями: фейловер (Phase 4.2) молча
+            // замаскировал бы мёртвый primary.
             void probeProviders(targetsFromProviders((this.config.provider.entries ?? [])
                 .map((e) => ({
                 name: e.label || e.type,
@@ -901,26 +1163,22 @@ export class Repl {
             })
                 .catch(() => { });
         }
-        // Context probe (background): compare the context length the model is
-        // actually loaded with against the configured window. Same non-blocking
-        // banner pattern as the LSP probe above.
+        // Контекст-пробник (фоном): сверяем контекст, с которым модель реально
+        // загружена, против настроенного окна. Тот же неблокирующий баннер-паттерн,
+        // что у LSP-пробника выше.
         if (this.contextProbe) {
             void this.contextProbe
                 .then((probe) => {
                 if (!probe)
                     return;
-                this.sessionManager?.appendLog({
-                    ts: new Date().toISOString(),
-                    type: "context_probe",
-                    content: `model=${probe.model} actual=${probe.actual} configured=${this.config.contextWindow}`,
-                });
+                // Запись пробника персистит bootstrap (все режимы); здесь только строка баннера.
                 const line = probe.actual < this.config.contextWindow
                     ? `${pc.yellow("⚠")} ${t("repl.context_probe_small", { model: probe.model, actual: probe.actual, configured: this.config.contextWindow })}`
                     : probe.actual > this.config.contextWindow
                         ? `${pc.dim(t("repl.context_probe_big", { model: probe.model, actual: probe.actual }))}`
                         : null;
                 if (line) {
-                    // Channel owns the prompt row now: no manual erase + prompt() hack.
+                    // Строкой промпта владеет канал: ручной erase + prompt()-хак не нужен.
                     this.output.writeLine(`${divider()}\n${line}`);
                 }
             })
@@ -928,16 +1186,16 @@ export class Repl {
         }
     }
     /**
-     * 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.
+     * Пробнит LSP-серверы, применимые к текущему проекту, и форматирует однострочную
+     * сводку баннера, напр. "✓ typescript (1.2s)" или "✗ css — timeout".
+     * Null, если LSP выключен или серверов нет.
      */
     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
+            // Результаты LSP-пробника — в сессию, для пост-мортем видимости.
             this.slog.logSessionStart({
                 environment: this.envReport,
                 lspProbe: {
@@ -966,13 +1224,14 @@ export class Repl {
             return pc.yellow(t("repl.lsp_unknown"));
         }
     }
+    /** Останов REPL: сейв истории, шатдаун агента, закрытие лога сессии. */
     stop() {
         this.running = false;
         this.saveHistory();
         this.agent.shutdown();
         this.sessionOutput?.dispose();
         this.sessionOutput = undefined;
-        // Close session log when REPL stops
+        // Закрываем лог сессии на останове REPL.
         this.logger?.closeSessionLog();
         this.rl.close();
     }