micro-models-agent 2.10.0 → 2.12.0

package/dist/config/config.js

@@ -1,3 +1,4 @@
+// Загрузка/сохранение конфига: DEFAULTS → legacy → домены → .mmrc → env → decrypt.
 import { existsSync, readFileSync, unlinkSync, writeFileSync, mkdirSync } from "fs";
 import { join, dirname } from "path";
 import { homedir } from "os";
@@ -13,15 +14,20 @@ import { validateExpertConfig } from "./experts";
 import { ConfigEncryptor } from "../modules/security/encryption";
 import { loadDomainFiles, saveDomainFiles } from "./domains";
 import { defaultOutputBus } from "../output";
-// ── Centralized path constants ──────────────────────────────────────────
-export const CONFIG_DIR = join(homedir(), ".mma");
+import { MMA_DIR_NAME } from "./paths";
+import { MMA_ENV } from "./env";
+// ── Централизованные константы путей ──────────────────────────────────────
+/** Глобальный каталог конфига. */
+export const CONFIG_DIR = join(homedir(), MMA_DIR_NAME);
+/** Legacy-файл конфига. */
 export const CONFIG_FILE = join(CONFIG_DIR, "config.json");
+/** Каталог файлов доменов. */
 export const CONFIG_DOMAIN_DIR = join(CONFIG_DIR, "config");
-// ── Internal helpers ────────────────────────────────────────────────────
+// ── Внутренние хелперы ────────────────────────────────────────────────────
 /**
- * Restore RegExp instances in dangerousPatterns that were serialized as {}
- * (pre-0.8.0 configs) or as {__regex, source, flags} (new format).
- * Falls back to default patterns for any entry that is not a real RegExp.
+ * Восстанавливает RegExp в dangerousPatterns, сериализованных как {}
+ * (конфиги до 0.8.0) или как {__regex, source, flags} (новый формат).
+ * Для записей без настоящего RegExp — фолбэк на дефолтные паттерны.
  */
 function restoreDangerousPatterns(patterns, defaults) {
     const fallback = (Array.isArray(defaults) ? defaults : []);
@@ -45,9 +51,7 @@ function restoreDangerousPatterns(patterns, defaults) {
         return fallback[i] || fallback[0] || p;
     });
 }
-/**
- * Legacy npx `args` for LSP servers that predate the fixed invocation.
- */
+/** Legacy npx-`args` LSP-серверов, предшествующие фикс. вызову. */
 const LEGACY_LSP_SERVER_ARGS = {
     typescript: { args: ["typescript-language-server", "--stdio"], timeout: 30000 },
     javascript: { args: ["typescript-language-server", "--stdio"], timeout: 30000 },
@@ -55,9 +59,7 @@ const LEGACY_LSP_SERVER_ARGS = {
     html: { args: ["vscode-html-languageserver", "--stdio"], timeout: 60000 },
     css: { args: ["vscode-css-languageserver", "--stdio"], timeout: 60000 },
 };
-/**
- * Replace stale pre-0.41.1 LSP server invocations with current defaults.
- */
+/** Заменяет протухшие pre-0.41.1 вызовы LSP-серверов текущими дефолтами. */
 function normalizeLspServerArgs(config) {
     const servers = config.lsp?.servers;
     if (!servers)
@@ -65,7 +67,7 @@ function normalizeLspServerArgs(config) {
     for (const [lang, legacy] of Object.entries(LEGACY_LSP_SERVER_ARGS)) {
         const server = servers[lang];
         const def = DEFAULT_LSP_CONFIG.servers[lang];
-        if (!server || server.command !== "npx" || !def)
+        if (server?.command !== "npx" || !def)
             continue;
         const storedArgs = Array.isArray(server.args) ? server.args : null;
         const isLegacy = storedArgs === null || JSON.stringify(storedArgs) === JSON.stringify(legacy.args);
@@ -75,6 +77,7 @@ function normalizeLspServerArgs(config) {
         }
     }
 }
+/** Чтение JSON с восстановлением RegExp. Битый файл — warn с путём, не тишина. */
 function loadJSON(path) {
     if (!existsSync(path))
         return null;
@@ -82,14 +85,14 @@ function loadJSON(path) {
         return JSON.parse(readFileSync(path, "utf-8"), regexReviver);
     }
     catch {
-        // Never silent: a typo'd config must not quietly wipe the user's settings.
+        // Не молчим: конфиг с опечаткой не должен тихо затирать настройки юзера.
         defaultOutputBus.log("warn", "config", t("config.parse_failed", { path }));
     }
     return null;
 }
 /**
- * Apply MMA_* env overrides. Returns the overridden keys with their PRE-ENV
- * values so `saveConfig` can avoid persisting session-scoped env values (C4).
+ * Применяет MMA_*-оверрайды окружения. Возвращает тронутые ключи с ДО-env
+ * значениями, чтобы `saveConfig` не персистил сессионные env-значения (C4).
  */
 function applyEnvVars(config) {
     const env = process.env;
@@ -100,15 +103,14 @@ function applyEnvVars(config) {
         if (original !== envValue)
             overrides.push({ key, envValue, originalValue: original });
     };
-    if (env.MMA_MODEL) {
-        record("model", env.MMA_MODEL);
-        result.model = env.MMA_MODEL;
+    if (env[MMA_ENV.MODEL]) {
+        record("model", env[MMA_ENV.MODEL]);
+        result.model = env[MMA_ENV.MODEL];
     }
     const originalProvider = result.provider;
-    // normalizeEntries prefers entries[] and ignores the flat provider fields, so
-    // a flat-only env override is a silent no-op on multi-provider configs (the
-    // certification harness depends on these vars working). Resolve the active
-    // entry and patch it too.
+    // normalizeEntries предпочитает entries[] и игнорит плоские поля провайдера, так
+    // что плоский env-оверрайд на мультиконфиге — тихий no-op (а cert-харнесс зависит
+    // от работы этих vars). Резолвим активную запись и патчим её тоже.
     const activeEntryIndex = (() => {
         const entries = result.provider.entries;
         if (!entries || entries.length === 0)
@@ -127,71 +129,76 @@ function applyEnvVars(config) {
         next[activeEntryIndex] = { ...next[activeEntryIndex], ...patch };
         result.provider = { ...result.provider, entries: next };
     };
-    if (env.MMA_PROVIDER_TYPE) {
-        result.provider = { ...result.provider, type: env.MMA_PROVIDER_TYPE };
-        patchActiveEntry({ type: env.MMA_PROVIDER_TYPE });
+    if (env[MMA_ENV.PROVIDER_TYPE]) {
+        result.provider = { ...result.provider, type: env[MMA_ENV.PROVIDER_TYPE] };
+        patchActiveEntry({ type: env[MMA_ENV.PROVIDER_TYPE] });
     }
-    if (env.MMA_PROVIDER_BASEURL) {
-        result.provider = { ...result.provider, baseUrl: env.MMA_PROVIDER_BASEURL };
-        patchActiveEntry({ baseUrl: env.MMA_PROVIDER_BASEURL });
+    if (env[MMA_ENV.PROVIDER_BASEURL]) {
+        result.provider = { ...result.provider, baseUrl: env[MMA_ENV.PROVIDER_BASEURL] };
+        patchActiveEntry({ baseUrl: env[MMA_ENV.PROVIDER_BASEURL] });
     }
-    if (env.MMA_PROVIDER_APIKEY) {
-        result.provider = { ...result.provider, apiKey: env.MMA_PROVIDER_APIKEY };
-        patchActiveEntry({ apiKey: env.MMA_PROVIDER_APIKEY });
+    if (env[MMA_ENV.PROVIDER_APIKEY]) {
+        result.provider = { ...result.provider, apiKey: env[MMA_ENV.PROVIDER_APIKEY] };
+        patchActiveEntry({ apiKey: env[MMA_ENV.PROVIDER_APIKEY] });
     }
-    if (env.MMA_PROVIDER_TYPE || env.MMA_PROVIDER_BASEURL || env.MMA_PROVIDER_APIKEY) {
-        // Record once with the FINAL env-mutated provider object so the identity
-        // check in stripEnvOverrides matches what the loaded config holds.
+    if (env[MMA_ENV.PROVIDER_TYPE] || env[MMA_ENV.PROVIDER_BASEURL] || env[MMA_ENV.PROVIDER_APIKEY]) {
+        // Пишем один раз с ФИНАЛЬНЫМ env-мутированным объектом провайдера, чтобы
+        // identity-проверка в stripEnvOverrides сошлась с загруженным конфигом.
         overrides.push({ key: "provider", envValue: result.provider, originalValue: originalProvider });
     }
-    if (env.MMA_LOG_LEVEL) {
-        record("logLevel", env.MMA_LOG_LEVEL);
-        result.logLevel = env.MMA_LOG_LEVEL;
+    if (env[MMA_ENV.LOG_LEVEL]) {
+        record("logLevel", env[MMA_ENV.LOG_LEVEL]);
+        result.logLevel = env[MMA_ENV.LOG_LEVEL];
     }
-    if (env.MMA_LOCALE) {
-        record("locale", env.MMA_LOCALE);
-        result.locale = env.MMA_LOCALE;
+    if (env[MMA_ENV.LOCALE]) {
+        record("locale", env[MMA_ENV.LOCALE]);
+        result.locale = env[MMA_ENV.LOCALE];
     }
-    if (env.MMA_CONTEXT_WINDOW) {
-        const v = parseInt(env.MMA_CONTEXT_WINDOW, 10);
-        if (!isNaN(v)) {
+    if (env[MMA_ENV.CONTEXT_WINDOW]) {
+        const v = parseInt(env[MMA_ENV.CONTEXT_WINDOW], 10);
+        if (!Number.isNaN(v)) {
             record("contextWindow", v);
             result.contextWindow = v;
         }
     }
-    if (env.MMA_MAX_TOOL_ITERATIONS) {
-        const v = parseInt(env.MMA_MAX_TOOL_ITERATIONS, 10);
-        if (!isNaN(v)) {
+    if (env[MMA_ENV.MAX_TOOL_ITERATIONS]) {
+        const v = parseInt(env[MMA_ENV.MAX_TOOL_ITERATIONS], 10);
+        if (!Number.isNaN(v)) {
             record("maxToolIterations", v);
             result.maxToolIterations = v;
         }
     }
-    if (env.MMA_STUCK_THRESHOLD) {
-        const v = parseInt(env.MMA_STUCK_THRESHOLD, 10);
-        if (!isNaN(v)) {
+    if (env[MMA_ENV.STUCK_THRESHOLD]) {
+        const v = parseInt(env[MMA_ENV.STUCK_THRESHOLD], 10);
+        if (!Number.isNaN(v)) {
             record("stuckThreshold", v);
             result.stuckThreshold = v;
         }
     }
-    if (env.MMA_AUTO_PLAN) {
-        const v = env.MMA_AUTO_PLAN === "true";
+    if (env[MMA_ENV.AUTO_PLAN]) {
+        const v = env[MMA_ENV.AUTO_PLAN] === "true";
         record("autoPlan", v);
         result.autoPlan = v;
     }
-    if (env.MMA_MOE_ENABLED) {
-        const next = { ...result.moe, enabled: env.MMA_MOE_ENABLED === "true" };
+    if (env[MMA_ENV.MOE_ENABLED]) {
+        const next = { ...result.moe, enabled: env[MMA_ENV.MOE_ENABLED] === "true" };
         record("moe", next);
         result.moe = next;
     }
+    if (env[MMA_ENV.CONTEXT_LOG]) {
+        const next = { ...result.contextLog, enabled: env[MMA_ENV.CONTEXT_LOG] !== "false" };
+        record("contextLog", next);
+        result.contextLog = next;
+    }
     return { config: result, overrides };
 }
-/** Pre-env values for env-touched keys, keyed by the loaded config object. */
+/** До-env значения env-тронутых ключей, по объекту загруженного конфига. */
 const envOverrideMap = new WeakMap();
 /**
- * Restore pre-env values before persisting — session-scoped env overrides
- * (e.g. the cert harness baseUrl) must NOT leak into domain files. An explicit
- * later change (setProvider/reconfigure replacing provider, /model use) shows
- * up as a different object/value and is kept as-is.
+ * Возвращает до-env значения перед сохранением: сессионные env-оверрайды
+ * (например, baseUrl cert-харнесса) НЕ должны протекать в файлы доменов. Явное
+ * позднее изменение (setProvider/reconfigure заменил provider, /model use)
+ * видно как другой объект/значение и сохраняется как есть.
  */
 function stripEnvOverrides(config) {
     const overrides = envOverrideMap.get(config);
@@ -199,35 +206,37 @@ function stripEnvOverrides(config) {
         return config;
     const result = { ...config };
     for (const o of overrides) {
-        if (result[o.key] === o.envValue) {
-            result[o.key] = o.originalValue;
+        const rec = result;
+        if (rec[o.key] === o.envValue) {
+            rec[o.key] = o.originalValue;
         }
     }
     return result;
 }
 /**
- * Load config from domain files (preferred) or legacy config.json (fallback).
+ * Грузит конфиг из файлов доменов (предпочтительно) или legacy config.json.
  *
- * Pipeline:
+ * Конвейер:
  *   1. DEFAULTS
- *   2. deepMerge(legacy config.json)  — if exists
- *   3. deepMerge(domain files)        — if exist, override legacy
- *   4. deepMerge(project .mmrc)       — overrides everything
- *   5. Post-load fixups (RegExp, LSP args)
- *   6. Env vars
+ *   2. deepMerge(legacy config.json)  — если есть
+ *   3. deepMerge(файлы доменов)       — если есть, поверх legacy
+ *   4. deepMerge(проектный .mmrc)     — поверх всего
+ *   5. Пост-загрузочные фиксы (RegExp, LSP-args)
+ *   6. Env-переменные
  *   7. Decrypt
  *
- * On first run (no config.json, no domain files), auto-creates domain files.
+ * На первом запуске (нет ни config.json, ни доменов) результат — DEFAULTS;
+ * ничего не пишется: персист только через `saveConfig`.
  */
 export function loadConfig(options) {
     const globalPath = join(options.configDir, "config.json");
     mkdirSync(options.configDir, { recursive: true });
-    // v1 → v2 migration check (reads config.json directly, before domain logic)
+    // Проверка v1 → v2 (читает config.json напрямую, до логики доменов).
     const detector = new MigrationDetector(options.configDir);
     if (detector.needsMigration()) {
         const backup = new BackupManager(options.configDir);
-        // Full-directory backup (documented behavior) + config.json snapshot
-        // before we touch anything.
+        // Полный бэкап каталога (документированное поведение) + снапшот config.json
+        // до любых касаний.
         backup.backupAll();
         backup.backupConfig();
         const summary = backup.getBackupSummary();
@@ -236,54 +245,51 @@ export function loadConfig(options) {
             unlinkSync(globalPath);
         }
         catch (e) {
-            // Best-effort removal: loadConfig falls back to defaults either way,
-            // but a leftover v1 file would re-trigger migration on every startup.
+            // Best-effort удаление: loadConfig и так откатится на дефолты, но
+            // leftover v1-файл ретриггерил бы миграцию на каждом старте.
             defaultOutputBus.log("error", "config", `[config] failed to remove legacy config.json: ${e instanceof Error ? e.message : String(e)}`);
         }
     }
-    // Deep clone: DEFAULTS holds singleton objects (security, lsp, tools…)
-    // that must never be mutated by runtime config changes.
+    // Глубокий клон: DEFAULTS держит синглтон-объекты (security, lsp, tools…),
+    // которые рантайм-изменения конфига мутировать не должны.
     let config = structuredClone(DEFAULTS);
     let legacyDetected = false;
-    // Step 1: legacy config.json (fallback)
+    // Шаг 2: legacy config.json (фолбэк).
     const globalData = loadJSON(globalPath);
     if (globalData) {
         config = deepMerge(config, globalData);
         legacyDetected = true;
     }
-    // Step 2: domain files (override legacy)
+    // Шаг 3: файлы доменов (поверх legacy).
     const domainConfig = loadDomainFiles(options.configDir);
     if (domainConfig) {
         config = deepMerge(config, domainConfig);
         legacyDetected = false;
     }
-    // Step 3: first run — auto-create domain files instead of config.json
-    if (!globalData && !domainConfig) {
-        saveDomainFiles(config, options.configDir);
-    }
-    // Step 4: project .mmrc (overrides everything)
+    // Шаг 4: проектный .mmrc (поверх всего).
     const projectData = loadJSON(options.projectConfigPath);
     if (projectData) {
         config = deepMerge(config, projectData);
     }
-    // Step 5: post-load fixups — AFTER all merges
+    // Шаг 5: пост-загрузочные фиксы — ПОСЛЕ всех мержей.
     if (config.security?.contentScan?.dangerousPatterns) {
         config.security.contentScan.dangerousPatterns = restoreDangerousPatterns(config.security.contentScan.dangerousPatterns, DEFAULT_SECURITY_CONFIG.contentScan.dangerousPatterns);
     }
     normalizeLspServerArgs(config);
-    // Step 6: env vars
+    // Шаг 6: env-переменные.
     const { config: envConfig, overrides } = applyEnvVars(config);
     config = envConfig;
-    // Step 7: decrypt
+    // Шаг 7: decrypt.
     try {
         const encryptor = new ConfigEncryptor();
         const decrypted = encryptor.decrypt(config);
+        const configRec = config;
         for (const key of Object.keys(decrypted)) {
-            config[key] = decrypted[key];
+            configRec[key] = decrypted[key];
         }
-        // Decrypt rebuilds the object tree (new identities). Re-point the provider
-        // override at the post-decrypt provider so the save-time identity check in
-        // stripEnvOverrides still matches the loaded config.
+        // Decrypt пересобирает дерево объектов (новые identity). Переприцеливаем
+        // provider-оверрайд на пост-decrypt провайдер, чтобы save-time identity-чек
+        // в stripEnvOverrides по-прежнему сходился с загруженным конфигом.
         const providerOverride = overrides.find((o) => o.key === "provider");
         if (providerOverride)
             providerOverride.envValue = config.provider;
@@ -295,6 +301,7 @@ export function loadConfig(options) {
         envOverrideMap.set(config, overrides);
     return { config, legacyDetected };
 }
+/** Валидирует конфиг против известных тегов тулов. Ошибки — throw. */
 export function validateConfig(config, allToolTags) {
     const errors = validateExpertConfig(config, allToolTags);
     const knownTags = new Set(allToolTags);
@@ -308,20 +315,20 @@ export function validateConfig(config, allToolTags) {
     }
 }
 /**
- * Save config to domain files (preferred) or legacy single file (fallback).
+ * Пишет конфиг в файлы доменов (предпочтительно) или legacy-файл (фолбэк).
  *
- * @param config   Full AppConfig to save
- * @param configPath  Legacy path (e.g. ~/.mma/config.json) — used when configDir is absent
- * @param configDir  Optional config directory (e.g. ~/.mma). When provided, writes domain files.
+ * @param config      полный AppConfig для сохранения;
+ * @param configPath  legacy-путь (напр. ~/.mma/config.json) — когда configDir нет;
+ * @param configDir   каталог конфига (напр. ~/.mma). Если задан — пишет файлы доменов.
  */
 export function saveConfig(config, configPath, configDir) {
-    // Session-scoped MMA_* env overrides must not be persisted (C4).
+    // Сессионные MMA_*-оверрайды персистить нельзя (C4).
     const toWrite = stripEnvOverrides(config);
     if (configDir) {
         saveDomainFiles(toWrite, configDir);
         return;
     }
-    // Legacy single-file write (backward compat for tests / edge cases)
+    // Legacy-запись одним файлом (обратная совместимость для тестов/крайних случаев).
     const dir = dirname(configPath);
     mkdirSync(dir, { recursive: true });
     try {

package/dist/config/defaults.js

@@ -1,7 +1,8 @@
 import { DEFAULT_SECURITY_CONFIG } from "./security";
 import { DEFAULT_LSP_CONFIG } from "../modules/lsp/config";
-/** Single source of truth for the default model (experts inherit it, C8). */
+/** Дефолтная модель (эксперты наследуют её). */
 const DEFAULT_MODEL = "qwen/qwen3.5-9b";
+/** Дефолтный конфиг. Глубоко мержится с пользовательским при загрузке. */
 export const DEFAULTS = {
     version: "2.0.0",
     model: DEFAULT_MODEL,
@@ -18,15 +19,28 @@ export const DEFAULTS = {
         enabled: false,
         maxReplanCycles: 3,
     },
+    critic: {
+        enabled: true,
+        // Phase 2: выделенные provider/model — opt-in; пока не заданы, делит активный
+        // провайдер (поведение v1). Read-only verify-цикл включён: запускается только
+        // после вердикта concern/critical, ограничен и fail-open.
+        provider: undefined,
+        model: undefined,
+        tools: true,
+        maxCalls: 4,
+        maxRepairCycles: 1,
+        timeoutMs: 15000,
+    },
     tools: {
-        // TODO(2026-08-29): revisit tool-set visibility. enableOnDemand:false
-        // restores the full ~28-tool set (legacy behavior) — safe for small
-        // models but costs schema tokens per call. The on-demand narrowing
-        // (defaultTags + enable_tools) kept the footprint small but made the 9B
-        // model call hidden tools as shell commands / drift to MCP. Decide the
-        // right trade-off for small models and pick one mode.
+        // Автосужение P5 (2026-09-28): enableOnDemand:true показывает только
+        // defaultTags + alwaysOn структурные/интерактивные тулы; теги под тип задачи
+        // детерминированно досеиваются до первого вызова LLM (src/tools/auto-tags.ts),
+        // а модель расширяет набор через enable_tools. Дрейф 9B, вызвавший откат
+        // (скрытые тулы звались как shell-команды), гасится блоком промпта про скрытые
+        // тулы, хинтом bash про скрытые тулы + редиректом tool-call и alwaysOn
+        // question/approve.
         defaultTags: ["file", "code"],
-        enableOnDemand: false,
+        enableOnDemand: true,
     },
     experts: {
         code: {
@@ -54,11 +68,16 @@ export const DEFAULTS = {
             description: "browser + file reading for visual tasks",
         },
     },
+    // Переопределения возможностей по моделям (ключ — id модели). Пусто по
+    // умолчанию: первичны живой native-probe (LM Studio) и пресет провайдера,
+    // эта карта — ручной escape hatch, когда оба ошиблись.
+    modelCapabilities: {},
     contextWindow: 32768,
     contextBudget: {
         systemPrompt: 0.1,
         responseReserve: 0.15,
         compactionThreshold: 0.75,
+        compactionMinLoad: 0.5,
     },
     instructions: {
         summarize: true,
@@ -85,6 +104,11 @@ export const DEFAULTS = {
         autoSave: true,
         maxSessions: 50,
         isolateMemory: false,
+        autoName: true,
+    },
+    contextLog: {
+        enabled: false,
+        redact: true,
     },
     browser: {
         enabled: true,
@@ -114,9 +138,12 @@ export const DEFAULTS = {
     },
     ui: {
         spinner: true,
+        activityRail: "line",
         showContextStats: false,
         showCompaction: true,
         verbose: false,
+        verbosity: "quiet",
+        fontSize: "comfortable",
     },
     mcpServers: {
         context7: {
@@ -163,5 +190,8 @@ export const DEFAULTS = {
         min: "low",
         max: "high",
         overrideCooldown: 5,
+        // Тривиальные Q&A-ходы не должны платить за medium reasoning; политика всё
+        // равно поднимает до high на галлюцинациях/отклонениях аудита/создании плана.
+        baseline: "low",
     },
 };

package/dist/config/domains.js

@@ -1,11 +1,12 @@
+// Домены конфига: раскладка AppConfig по файлам ~/.mma/config/<домен>.json.
 import { existsSync, readFileSync, writeFileSync, mkdirSync, readdirSync } from "fs";
 import { join } from "path";
 import { t } from "../i18n/index";
 import { deepMerge, regexReplacer, regexReviver } from "./utils";
 import { defaultOutputBus } from "../output";
 /**
- * Mapping: domain name → AppConfig keys that belong to it.
- * Each domain becomes one JSON file in ~/.mma/config/<domain>.json.
+ * Маппинг: имя домена → ключи AppConfig. Каждый домен — один JSON-файл
+ * в ~/.mma/config/<domain>.json.
  */
 export const CONFIG_DOMAINS = {
     core: [
@@ -24,43 +25,39 @@ export const CONFIG_DOMAINS = {
         "reasoning",
         "hallucination",
     ],
-    provider: ["provider", "orchestrator", "retry", "pricing"],
+    provider: ["provider", "orchestrator", "retry", "pricing", "modelCapabilities"],
     moe: ["moe", "experts"],
+    critic: ["critic"],
     security: ["security"],
     browser: ["browser"],
     search: ["webSearch", "errorWebSearch"],
     tools: ["tools", "subagent"],
-    session: ["session", "sessionIsolation"],
+    session: ["session", "sessionIsolation", "contextLog"],
     ui: ["ui"],
     mcp: ["mcpServers"],
     lsp: ["lsp"],
     skills: ["skills"],
     updater: ["updater"],
 };
-/**
- * Extract a domain subset from a full AppConfig.
- */
+/** Вырезает подмножество ключей домена из полного AppConfig. */
 export function extractDomain(config, domain) {
     const keys = CONFIG_DOMAINS[domain];
     if (!keys)
         return {};
     const subset = {};
+    const source = config;
     for (const key of keys) {
-        if (config[key] !== undefined) {
-            subset[key] = config[key];
+        if (source[key] !== undefined) {
+            subset[key] = source[key];
         }
     }
     return subset;
 }
-/**
- * Get the file path for a domain config file.
- */
+/** Путь к файлу домена. */
 export function getDomainFilePath(configDir, domain) {
     return join(configDir, "config", `${domain}.json`);
 }
-/**
- * Check if domain files exist in config/ directory.
- */
+/** Проверяет, есть ли файлы доменов в каталоге config/. */
 export function hasDomainFiles(configDir) {
     const configDirPath = join(configDir, "config");
     if (!existsSync(configDirPath))
@@ -74,9 +71,9 @@ export function hasDomainFiles(configDir) {
     }
 }
 /**
- * Load all domain files from ~/.mma/config/ and merge into a partial AppConfig.
- * Each file is parsed with regexReviver to restore RegExp objects.
- * Returns null if no domain files exist.
+ * Грузит все файлы доменов из ~/.mma/config/ и мержит в частичный AppConfig.
+ * Каждый файл парсится с regexReviver (восстановление RegExp).
+ * Возвращает null, если файлов доменов нет.
  */
 export function loadDomainFiles(configDir) {
     const configDirPath = join(configDir, "config");
@@ -95,17 +92,17 @@ export function loadDomainFiles(configDir) {
             anyLoaded = true;
         }
         catch {
-            // Never silent: surface the offending path instead of silently ignoring
-            // a domain the user believes is active.
+            // Не молчим: показываем битый путь, а не тихо игнорим домен,
+            // который пользователь считает активным.
             defaultOutputBus.log("warn", "config", t("config.parse_failed", { path: filePath }));
         }
     }
     return anyLoaded ? result : null;
 }
 /**
- * Save a full AppConfig to domain files in ~/.mma/config/.
- * Each domain's keys are extracted and written to config/<domain>.json.
- * RegExp objects are serialized via regexReplacer.
+ * Пишет полный AppConfig по файлам доменов в ~/.mma/config/.
+ * Ключи каждого домена вырезаются и пишутся в config/<domain>.json.
+ * RegExp сериализуются через regexReplacer.
  */
 export function saveDomainFiles(config, configDir) {
     const configDirPath = join(configDir, "config");
@@ -113,9 +110,10 @@ export function saveDomainFiles(config, configDir) {
     for (const [domain, keys] of Object.entries(CONFIG_DOMAINS)) {
         const subset = {};
         let hasContent = false;
+        const source = config;
         for (const key of keys) {
-            if (config[key] !== undefined) {
-                subset[key] = config[key];
+            if (source[key] !== undefined) {
+                subset[key] = source[key];
                 hasContent = true;
             }
         }
@@ -126,8 +124,7 @@ export function saveDomainFiles(config, configDir) {
     }
 }
 /**
- * Determine which domain a config key belongs to.
- * Returns the domain name or null if not found.
+ * Определяет домен ключа конфига. Возвращает имя домена или null.
  */
 export function domainForKey(key) {
     for (const [domain, keys] of Object.entries(CONFIG_DOMAINS)) {