micro-models-agent 0.50.4 → 0.51.2

package/dist/main.js

@@ -2634,6 +2634,7 @@ Fix the error and re-edit the file (a clean write clears the failure), or mark t
     "cli.set_value": "Set a config value",
     "cli.set_done": "Set {key}={value}",
     "cli.show_config": "Show current config",
+    "cli.migrate_config": "Migrate legacy config.json to domain format",
     "cli.manage_models": "Manage models",
     "cli.list_models": "List available models",
     "cli.current_model": "Current model:",
@@ -3020,6 +3021,11 @@ Apply a matching solution from these results. If none is relevant — do NOT rep
     "tool.friendly.project_map": "Project map",
     "config.decryption_warning": "Warning: Failed to decrypt config: {error}",
     "config.encryption_warning": "Warning: Failed to encrypt config: {error}",
+    "config.migrate_start": "Migrating config to domain format...",
+    "config.migrate_done": "Migration complete. Created {count} domain files. Legacy saved as config.json.bak.",
+    "config.migrate_no_legacy": "No legacy config.json found. Already using domain format.",
+    "config.migrate_error": "Migration failed: {error}",
+    "config.legacy_hint": 'Config: using legacy config.json. Run "mma config migrate" to switch to domain format.',
     "image.source_required": 'Image source is required. Provide a file path, URL, or "clipboard".',
     "image.clipboard_empty": "Clipboard does not contain an image. Copy an image first (e.g. screenshot with Win+Shift+S).",
     "image.not_found": "Image file not found: {path}",
@@ -3353,6 +3359,7 @@ var init_ru = __esm(() => {
     "cli.set_value": "Установить значение",
     "cli.set_done": "Установлено {key}={value}",
     "cli.show_config": "Показать текущий конфиг",
+    "cli.migrate_config": "Мигрировать legacy config.json в domain-формат",
     "cli.manage_models": "Управление моделями",
     "cli.list_models": "Список доступных моделей",
     "cli.current_model": "Текущая модель:",
@@ -3739,6 +3746,11 @@ var init_ru = __esm(() => {
     "tool.friendly.project_map": "Карта проекта",
     "config.decryption_warning": "Предупреждение: не удалось расшифровать конфигурацию: {error}",
     "config.encryption_warning": "Предупреждение: не удалось зашифровать конфигурацию: {error}",
+    "config.migrate_start": "Миграция конфига в domain-формат...",
+    "config.migrate_done": "Миграция завершена. Создано {count} domain файлов. Legacy сохранён как config.json.bak.",
+    "config.migrate_no_legacy": "Legacy config.json не найден. Уже используется domain-формат.",
+    "config.migrate_error": "Ошибка миграции: {error}",
+    "config.legacy_hint": 'Config: используется legacy config.json. Запустите "mma config migrate" для перехода к domain-формату.',
     "image.source_required": 'Укажите источник изображения: путь к файлу, URL или "clipboard".',
     "image.clipboard_empty": "Буфер обмена не содержит изображение. Скопируйте изображение (например, скриншот через Win+Shift+S).",
     "image.not_found": "Файл изображения не найден: {path}",
@@ -4142,15 +4154,163 @@ var init_encryption = __esm(() => {
   ];
 });
 
+// src/config/domains.ts
+var exports_domains = {};
+__export(exports_domains, {
+  saveDomainFiles: () => saveDomainFiles,
+  loadDomainFiles: () => loadDomainFiles,
+  hasDomainFiles: () => hasDomainFiles,
+  getDomainFilePath: () => getDomainFilePath,
+  extractDomain: () => extractDomain,
+  domainForKey: () => domainForKey,
+  CONFIG_DOMAINS: () => CONFIG_DOMAINS
+});
+import { existsSync as existsSync4, readFileSync as readFileSync3, writeFileSync as writeFileSync3, mkdirSync as mkdirSync2, readdirSync as readdirSync3 } from "fs";
+import { join as join4 } from "path";
+function regexReplacer(_key, value) {
+  if (value instanceof RegExp) {
+    return { __regex: true, source: value.source, flags: value.flags };
+  }
+  return value;
+}
+function regexReviver(_key, value) {
+  if (value && typeof value === "object" && value.__regex === true) {
+    const { source, flags } = value;
+    try {
+      return new RegExp(source, flags);
+    } catch {
+      return value;
+    }
+  }
+  return value;
+}
+function deepMerge(target, source) {
+  const result = { ...target };
+  for (const key of Object.keys(source)) {
+    const srcVal = source[key];
+    const tgtVal = target[key];
+    if (srcVal !== null && srcVal !== undefined && typeof srcVal === "object" && !Array.isArray(srcVal) && typeof tgtVal === "object" && !Array.isArray(tgtVal)) {
+      result[key] = deepMerge(tgtVal, srcVal);
+    } else if (srcVal !== undefined) {
+      result[key] = srcVal;
+    }
+  }
+  return result;
+}
+function extractDomain(config, domain) {
+  const keys = CONFIG_DOMAINS[domain];
+  if (!keys)
+    return {};
+  const subset = {};
+  for (const key of keys) {
+    if (config[key] !== undefined) {
+      subset[key] = config[key];
+    }
+  }
+  return subset;
+}
+function getDomainFilePath(configDir, domain) {
+  return join4(configDir, "config", `${domain}.json`);
+}
+function hasDomainFiles(configDir) {
+  const configDirPath = join4(configDir, "config");
+  if (!existsSync4(configDirPath))
+    return false;
+  try {
+    const files = readdirSync3(configDirPath);
+    return files.some((f) => f.endsWith(".json"));
+  } catch {
+    return false;
+  }
+}
+function loadDomainFiles(configDir) {
+  const configDirPath = join4(configDir, "config");
+  if (!existsSync4(configDirPath))
+    return null;
+  let result = {};
+  let anyLoaded = false;
+  for (const domain of Object.keys(CONFIG_DOMAINS)) {
+    const filePath = getDomainFilePath(configDir, domain);
+    if (!existsSync4(filePath))
+      continue;
+    try {
+      const raw = readFileSync3(filePath, "utf-8");
+      const data = JSON.parse(raw, regexReviver);
+      result = deepMerge(result, data);
+      anyLoaded = true;
+    } catch {}
+  }
+  return anyLoaded ? result : null;
+}
+function saveDomainFiles(config, configDir) {
+  const configDirPath = join4(configDir, "config");
+  mkdirSync2(configDirPath, { recursive: true });
+  for (const [domain, keys] of Object.entries(CONFIG_DOMAINS)) {
+    const subset = {};
+    let hasContent = false;
+    for (const key of keys) {
+      if (config[key] !== undefined) {
+        subset[key] = config[key];
+        hasContent = true;
+      }
+    }
+    if (!hasContent)
+      continue;
+    const filePath = getDomainFilePath(configDir, domain);
+    writeFileSync3(filePath, JSON.stringify(subset, regexReplacer, 2), "utf-8");
+  }
+}
+function domainForKey(key) {
+  for (const [domain, keys] of Object.entries(CONFIG_DOMAINS)) {
+    if (keys.includes(key))
+      return domain;
+  }
+  return null;
+}
+var CONFIG_DOMAINS;
+var init_domains = __esm(() => {
+  CONFIG_DOMAINS = {
+    core: [
+      "version",
+      "model",
+      "contextWindow",
+      "contextBudget",
+      "modelLoad",
+      "maxToolIterations",
+      "stuckThreshold",
+      "autoPlan",
+      "showReasoning",
+      "logLevel",
+      "locale"
+    ],
+    provider: ["provider", "orchestrator", "retry", "pricing"],
+    moe: ["moe", "experts"],
+    security: ["security"],
+    browser: ["browser"],
+    search: ["webSearch", "errorWebSearch"],
+    tools: ["tools", "subagent"],
+    session: ["session", "sessionIsolation"],
+    ui: ["ui"],
+    mcp: ["mcpServers"],
+    lsp: ["lsp"],
+    skills: ["skills"],
+    updater: ["updater"]
+  };
+});
+
 // src/config/config.ts
 var exports_config = {};
 __export(exports_config, {
   validateConfig: () => validateConfig,
   saveConfig: () => saveConfig,
-  loadConfig: () => loadConfig
+  loadConfig: () => loadConfig,
+  CONFIG_FILE: () => CONFIG_FILE,
+  CONFIG_DOMAIN_DIR: () => CONFIG_DOMAIN_DIR,
+  CONFIG_DIR: () => CONFIG_DIR
 });
-import { existsSync as existsSync4, readFileSync as readFileSync3, unlinkSync, writeFileSync as writeFileSync3, mkdirSync as mkdirSync2 } from "fs";
-import { join as join4, dirname } from "path";
+import { existsSync as existsSync5, readFileSync as readFileSync4, unlinkSync, writeFileSync as writeFileSync4, mkdirSync as mkdirSync3 } from "fs";
+import { join as join5, dirname } from "path";
+import { homedir as homedir2 } from "os";
 function restoreDangerousPatterns(patterns, defaults) {
   const fallback = Array.isArray(defaults) ? defaults : [];
   if (!Array.isArray(patterns) || patterns.length === 0) {
@@ -4170,26 +4330,26 @@ function restoreDangerousPatterns(patterns, defaults) {
     return fallback[i] || fallback[0] || p;
   });
 }
-function deepMerge(target, source) {
+function deepMerge2(target, source) {
   const result = { ...target };
   for (const key of Object.keys(source)) {
     const srcVal = source[key];
     const tgtVal = target[key];
     if (srcVal !== null && srcVal !== undefined && typeof srcVal === "object" && !Array.isArray(srcVal) && typeof tgtVal === "object" && !Array.isArray(tgtVal)) {
-      result[key] = deepMerge(tgtVal, srcVal);
+      result[key] = deepMerge2(tgtVal, srcVal);
     } else if (srcVal !== undefined) {
       result[key] = srcVal;
     }
   }
   return result;
 }
-function regexReplacer(_key, value) {
+function regexReplacer2(_key, value) {
   if (value instanceof RegExp) {
     return { __regex: true, source: value.source, flags: value.flags };
   }
   return value;
 }
-function regexReviver(_key, value) {
+function regexReviver2(_key, value) {
   if (value && typeof value === "object" && value.__regex === true) {
     const { source, flags } = value;
     try {
@@ -4219,8 +4379,8 @@ function normalizeLspServerArgs(config) {
 }
 function loadJSON(path) {
   try {
-    if (existsSync4(path)) {
-      return JSON.parse(readFileSync3(path, "utf-8"), regexReviver);
+    if (existsSync5(path)) {
+      return JSON.parse(readFileSync4(path, "utf-8"), regexReviver2);
     }
   } catch {}
   return null;
@@ -4262,8 +4422,8 @@ function applyEnvVars(config) {
   return result;
 }
 function loadConfig(options) {
-  const globalPath = join4(options.configDir, "config.json");
-  mkdirSync2(options.configDir, { recursive: true });
+  const globalPath = join5(options.configDir, "config.json");
+  mkdirSync3(options.configDir, { recursive: true });
   const detector = new MigrationDetector(options.configDir);
   if (detector.needsMigration()) {
     const backup = new BackupManager(options.configDir);
@@ -4275,16 +4435,23 @@ function loadConfig(options) {
     } catch {}
   }
   let config = { ...DEFAULTS };
+  let legacyDetected = false;
   const globalData = loadJSON(globalPath);
   if (globalData) {
-    config = deepMerge(config, globalData);
+    config = deepMerge2(config, globalData);
+    legacyDetected = true;
   }
-  if (!existsSync4(globalPath)) {
-    saveConfig(config, globalPath);
+  const domainConfig = loadDomainFiles(options.configDir);
+  if (domainConfig) {
+    config = deepMerge2(config, domainConfig);
+    legacyDetected = false;
+  }
+  if (!globalData && !domainConfig) {
+    saveDomainFiles(config, options.configDir);
   }
   const projectData = loadJSON(options.projectConfigPath);
   if (projectData) {
-    config = deepMerge(config, projectData);
+    config = deepMerge2(config, projectData);
   }
   if (config.security?.contentScan?.dangerousPatterns) {
     config.security.contentScan.dangerousPatterns = restoreDangerousPatterns(config.security.contentScan.dangerousPatterns, DEFAULT_SECURITY_CONFIG.contentScan.dangerousPatterns);
@@ -4300,7 +4467,7 @@ function loadConfig(options) {
   } catch (e) {
     console.warn(t("config.decryption_warning", { error: e.message }));
   }
-  return config;
+  return { config, legacyDetected };
 }
 function validateConfig(config, allToolTags) {
   const errors = validateExpertConfig(config, allToolTags);
@@ -4316,21 +4483,25 @@ ${errors.join(`
 `)}`);
   }
 }
-function saveConfig(config, configPath) {
+function saveConfig(config, configPath, configDir) {
+  if (configDir) {
+    saveDomainFiles(config, configDir);
+    return;
+  }
   const dir = dirname(configPath);
-  mkdirSync2(dir, { recursive: true });
+  mkdirSync3(dir, { recursive: true });
   try {
     const encryptor = new ConfigEncryptor;
     const encryptedConfig = encryptor.encrypt({
       ...config
     });
-    writeFileSync3(configPath, JSON.stringify(encryptedConfig, regexReplacer, 2), "utf-8");
+    writeFileSync4(configPath, JSON.stringify(encryptedConfig, regexReplacer2, 2), "utf-8");
   } catch (e) {
     console.warn(t("config.encryption_warning", { error: e.message }));
-    writeFileSync3(configPath, JSON.stringify(config, regexReplacer, 2), "utf-8");
+    writeFileSync4(configPath, JSON.stringify(config, regexReplacer2, 2), "utf-8");
   }
 }
-var LEGACY_LSP_SERVER_ARGS;
+var CONFIG_DIR, CONFIG_FILE, CONFIG_DOMAIN_DIR, LEGACY_LSP_SERVER_ARGS;
 var init_config2 = __esm(() => {
   init_defaults();
   init_security();
@@ -4339,6 +4510,10 @@ var init_config2 = __esm(() => {
   init_detect();
   init_backup();
   init_encryption();
+  init_domains();
+  CONFIG_DIR = join5(homedir2(), ".mma");
+  CONFIG_FILE = join5(CONFIG_DIR, "config.json");
+  CONFIG_DOMAIN_DIR = join5(CONFIG_DIR, "config");
   LEGACY_LSP_SERVER_ARGS = {
     typescript: { args: ["typescript-language-server", "--stdio"], timeout: 30000 },
     javascript: { args: ["typescript-language-server", "--stdio"], timeout: 30000 },
@@ -4409,31 +4584,31 @@ var init_data_sanitizer = __esm(() => {
 // src/logger/file-log.ts
 import {
   appendFileSync,
-  mkdirSync as mkdirSync3,
-  existsSync as existsSync5,
-  readdirSync as readdirSync3,
+  mkdirSync as mkdirSync4,
+  existsSync as existsSync6,
+  readdirSync as readdirSync4,
   renameSync,
   statSync,
   unlinkSync as unlinkSync2
 } from "node:fs";
-import { join as join5 } from "node:path";
+import { join as join6 } from "node:path";
 
 class FileLogWriter {
   logDir = null;
   sessionLogPath = null;
   setLogDir(dir) {
     this.logDir = dir;
-    if (!existsSync5(dir)) {
-      mkdirSync3(dir, { recursive: true });
+    if (!existsSync6(dir)) {
+      mkdirSync4(dir, { recursive: true });
     }
   }
   initSessionLog(sessionId) {
     if (!this.logDir)
       return;
-    if (!existsSync5(this.logDir)) {
-      mkdirSync3(this.logDir, { recursive: true });
+    if (!existsSync6(this.logDir)) {
+      mkdirSync4(this.logDir, { recursive: true });
     }
-    this.sessionLogPath = join5(this.logDir, `${sessionId}.log`);
+    this.sessionLogPath = join6(this.logDir, `${sessionId}.log`);
     this.cleanupOldLogs();
   }
   closeSessionLog() {
@@ -4445,16 +4620,16 @@ class FileLogWriter {
     if (!this.logDir)
       return "";
     const date = new Date().toISOString().slice(0, 10);
-    return join5(this.logDir, `${date}.log`);
+    return join6(this.logDir, `${date}.log`);
   }
   rotateIfNeeded(filePath) {
-    if (!existsSync5(filePath))
+    if (!existsSync6(filePath))
       return;
     const size = statSync(filePath).size;
     if (size < MAX_LOG_SIZE)
       return;
     let idx = 1;
-    while (existsSync5(`${filePath}.${idx}`))
+    while (existsSync6(`${filePath}.${idx}`))
       idx++;
     renameSync(filePath, `${filePath}.${idx}`);
   }
@@ -4462,8 +4637,8 @@ class FileLogWriter {
     const fp = this.getLogPath();
     if (!fp)
       return;
-    if (this.logDir && !existsSync5(this.logDir)) {
-      mkdirSync3(this.logDir, { recursive: true });
+    if (this.logDir && !existsSync6(this.logDir)) {
+      mkdirSync4(this.logDir, { recursive: true });
     }
     this.rotateIfNeeded(fp);
     const line = `[${new Date().toISOString()}] [${level}] [${tag}] ${message}
@@ -4504,13 +4679,13 @@ ${trimmed}`);
     this.log("INFO", `REPL/${tag}`, trimmed);
   }
   cleanupOldLogs(maxDays = DEFAULT_MAX_DAYS, maxFiles = MAX_LOG_FILES) {
-    if (!this.logDir || !existsSync5(this.logDir))
+    if (!this.logDir || !existsSync6(this.logDir))
       return;
     const now = Date.now();
-    const list = () => readdirSync3(this.logDir).filter((f) => f.endsWith(".log") || /\.log\.\d+$/.test(f)).map((f) => ({
+    const list = () => readdirSync4(this.logDir).filter((f) => f.endsWith(".log") || /\.log\.\d+$/.test(f)).map((f) => ({
       name: f,
-      path: join5(this.logDir, f),
-      mtime: statSync(join5(this.logDir, f)).mtimeMs
+      path: join6(this.logDir, f),
+      mtime: statSync(join6(this.logDir, f)).mtimeMs
     })).sort((a, b) => b.mtime - a.mtime);
     for (const f of list()) {
       if (now - f.mtime > maxDays * 24 * 60 * 60 * 1000) {
@@ -4603,8 +4778,8 @@ var require_picocolors = __commonJS((exports, module) => {
 });
 
 // src/logger/app-logger.ts
-import { appendFileSync as appendFileSync2, mkdirSync as mkdirSync4, existsSync as existsSync6 } from "fs";
-import { join as join6 } from "path";
+import { appendFileSync as appendFileSync2, mkdirSync as mkdirSync5, existsSync as existsSync7 } from "fs";
+import { join as join7 } from "path";
 function isColorEnabled() {
   return !process.env.NO_COLOR && !process.env.CI && process.stdout.isTTY === true;
 }
@@ -4625,15 +4800,15 @@ class Logger {
   }
   setLogDir(dir) {
     this.logDir = dir;
-    if (!existsSync6(dir)) {
-      mkdirSync4(dir, { recursive: true });
+    if (!existsSync7(dir)) {
+      mkdirSync5(dir, { recursive: true });
     }
     this.fileLog.setLogDir(dir);
   }
   setSessionDir(dir) {
     this.sessionDir = dir;
-    if (!existsSync6(dir)) {
-      mkdirSync4(dir, { recursive: true });
+    if (!existsSync7(dir)) {
+      mkdirSync5(dir, { recursive: true });
     }
   }
   clearSessionDir() {
@@ -4700,7 +4875,7 @@ class Logger {
     const logTarget = this.sessionDir ?? this.logDir;
     if (logTarget) {
       try {
-        appendFileSync2(join6(logTarget, "app.jsonl"), JSON.stringify({
+        appendFileSync2(join7(logTarget, "app.jsonl"), JSON.stringify({
           level,
           ts,
           prefix: this.prefix,
@@ -4729,7 +4904,7 @@ class Logger {
     if (!logTarget)
       return;
     try {
-      appendFileSync2(join6(logTarget, "app.jsonl"), JSON.stringify({
+      appendFileSync2(join7(logTarget, "app.jsonl"), JSON.stringify({
         level: "info",
         ts: new Date().toISOString(),
         type,
@@ -4746,7 +4921,7 @@ class Logger {
     const sanitizedMsg = sanitizeLogMessage(msg);
     const sanitizedMeta = meta ? this.sanitizeMeta(meta) : undefined;
     try {
-      appendFileSync2(join6(logTarget, "app.jsonl"), JSON.stringify({
+      appendFileSync2(join7(logTarget, "app.jsonl"), JSON.stringify({
         level,
         ts,
         prefix: this.prefix,
@@ -6446,7 +6621,7 @@ var init_executor = __esm(() => {
 
 // src/tools/path-utils.ts
 import { resolve, normalize, dirname as dirname2, basename, sep, relative, isAbsolute } from "path";
-import { existsSync as existsSync7 } from "fs";
+import { existsSync as existsSync8 } from "fs";
 function isInsideDir(targetPath, dirPath) {
   const norm = (p) => process.platform === "win32" ? p.toLowerCase() : p;
   const t2 = norm(resolve(targetPath));
@@ -6464,23 +6639,23 @@ function matchesScopeEntry(targetResolved, entryResolved) {
 function safeResolvePath(baseDir, userPath) {
   const asIs = resolve(normalize(userPath));
   if (userPath.startsWith("/") || userPath.startsWith("\\")) {
-    if (existsSync7(asIs) || existsSync7(dirname2(asIs)))
+    if (existsSync8(asIs) || existsSync8(dirname2(asIs)))
       return asIs;
   }
   const norm = normalize(userPath);
   if (isAbsolute(norm)) {
-    if (existsSync7(norm) || existsSync7(dirname2(norm)))
+    if (existsSync8(norm) || existsSync8(dirname2(norm)))
       return norm;
     const stripped2 = norm.replace(/^[/\\]/, "");
     const relativeCandidate = resolve(baseDir, stripped2);
-    if (existsSync7(relativeCandidate) || existsSync7(dirname2(relativeCandidate))) {
+    if (existsSync8(relativeCandidate) || existsSync8(dirname2(relativeCandidate))) {
       return relativeCandidate;
     }
     return norm;
   }
   const stripped = norm.replace(/^[/\\]/, "");
   const resolved = resolve(baseDir, stripped);
-  if (existsSync7(resolved) || existsSync7(dirname2(resolved)))
+  if (existsSync8(resolved) || existsSync8(dirname2(resolved)))
     return resolved;
   const baseNorm = normalize(baseDir);
   let cur = baseNorm;
@@ -6497,11 +6672,11 @@ function safeResolvePath(baseDir, userPath) {
       if (afterChar && afterChar !== "\\" && afterChar !== "/") {
         const fixed = stripped.slice(0, afterIdx) + sep + stripped.slice(afterIdx);
         const fixedResolved = resolve(baseDir, normalize(fixed));
-        if (existsSync7(fixedResolved) || existsSync7(dirname2(fixedResolved))) {
+        if (existsSync8(fixedResolved) || existsSync8(dirname2(fixedResolved))) {
           return fixedResolved;
         }
         const fromParent = resolve(dirname2(cur), normalize(fixed));
-        if (existsSync7(fromParent) || existsSync7(dirname2(fromParent))) {
+        if (existsSync8(fromParent) || existsSync8(dirname2(fromParent))) {
           return fromParent;
         }
       }
@@ -6699,10 +6874,10 @@ __export(exports_audit_notifier, {
   DEFAULT_AUDIT_NOTIFIER_CONFIG: () => DEFAULT_AUDIT_NOTIFIER_CONFIG,
   AuditNotifier: () => AuditNotifier
 });
-import { writeFileSync as writeFileSync4, appendFileSync as appendFileSync3, existsSync as existsSync8, mkdirSync as mkdirSync5 } from "fs";
-import { join as join7, dirname as dirname3 } from "path";
-import { homedir as homedir2 } from "os";
-import { readFileSync as readFileSync4 } from "fs";
+import { writeFileSync as writeFileSync5, appendFileSync as appendFileSync3, existsSync as existsSync9, mkdirSync as mkdirSync6 } from "fs";
+import { join as join8, dirname as dirname3 } from "path";
+import { homedir as homedir3 } from "os";
+import { readFileSync as readFileSync5 } from "fs";
 
 class AuditNotifier {
   config;
@@ -6728,7 +6903,7 @@ class AuditNotifier {
   ensureLogDirectory() {
     if (this.config.filePath) {
       const dir = dirname3(this.config.filePath);
-      mkdirSync5(dir, { recursive: true });
+      mkdirSync6(dir, { recursive: true });
     }
   }
   shouldNotify(eventType) {
@@ -6850,11 +7025,11 @@ class AuditNotifier {
     this.isProcessing = false;
   }
   readNotifications(limit = 100) {
-    if (!this.config.filePath || !existsSync8(this.config.filePath)) {
+    if (!this.config.filePath || !existsSync9(this.config.filePath)) {
       return [];
     }
     try {
-      const content = readFileSync4(this.config.filePath, "utf8");
+      const content = readFileSync5(this.config.filePath, "utf8");
       const lines = content.split(`
 `).filter(Boolean);
       return lines.slice(-limit).map((line) => JSON.parse(line));
@@ -6864,7 +7039,7 @@ class AuditNotifier {
   }
   clearNotifications() {
     if (this.config.filePath) {
-      writeFileSync4(this.config.filePath, "", "utf8");
+      writeFileSync5(this.config.filePath, "", "utf8");
     }
     this.retryQueue = [];
   }
@@ -6907,7 +7082,7 @@ var init_audit_notifier = __esm(() => {
   };
   DEFAULT_AUDIT_NOTIFIER_CONFIG = {
     enabled: false,
-    filePath: join7(homedir2(), ".mma", "logs", "audit-notifications.jsonl"),
+    filePath: join8(homedir3(), ".mma", "logs", "audit-notifications.jsonl"),
     webhookTimeout: 5000,
     minSeverity: "medium",
     eventTypes: [
@@ -6924,26 +7099,26 @@ var init_audit_notifier = __esm(() => {
 });
 
 // src/modules/security/audit-log.ts
-import { existsSync as existsSync9, mkdirSync as mkdirSync6, appendFileSync as appendFileSync4 } from "fs";
-import { resolve as resolve3, join as join8 } from "path";
-import { homedir as homedir3 } from "os";
+import { existsSync as existsSync10, mkdirSync as mkdirSync7, appendFileSync as appendFileSync4 } from "fs";
+import { resolve as resolve3, join as join9 } from "path";
+import { homedir as homedir4 } from "os";
 function getAuditDir() {
   return _sessionAuditDir ?? _globalAuditDir;
 }
 function setAuditSessionDir(dir) {
   _sessionAuditDir = dir;
-  if (!existsSync9(dir)) {
-    mkdirSync6(dir, { recursive: true, mode: 448 });
+  if (!existsSync10(dir)) {
+    mkdirSync7(dir, { recursive: true, mode: 448 });
   }
 }
 function logAudit(entry) {
   const dir = getAuditDir();
-  if (!existsSync9(dir)) {
-    mkdirSync6(dir, { recursive: true, mode: 448 });
+  if (!existsSync10(dir)) {
+    mkdirSync7(dir, { recursive: true, mode: 448 });
   }
   try {
     const logEntry = JSON.stringify(entry);
-    appendFileSync4(join8(dir, "audit.jsonl"), logEntry + `
+    appendFileSync4(join9(dir, "audit.jsonl"), logEntry + `
 `, "utf8");
   } catch {}
   try {
@@ -7003,11 +7178,11 @@ function logSecurityBlock(sessionId, action, reason, details) {
 var _globalAuditDir, _sessionAuditDir = null;
 var init_audit_log = __esm(() => {
   init_audit_notifier();
-  _globalAuditDir = resolve3(homedir3(), ".mma", "logs");
+  _globalAuditDir = resolve3(homedir4(), ".mma", "logs");
 });
 
 // src/tools/read-file.ts
-import { readFileSync as readFileSync5, existsSync as existsSync10, statSync as statSync2, openSync, readSync, closeSync } from "fs";
+import { readFileSync as readFileSync6, existsSync as existsSync11, statSync as statSync2, openSync, readSync, closeSync } from "fs";
 import { extname } from "path";
 function readLineSlice(path, offset, limit) {
   const fd = openSync(path, "r");
@@ -7108,7 +7283,7 @@ var init_read_file = __esm(() => {
           })
         };
       }
-      if (!existsSync10(resolved)) {
+      if (!existsSync11(resolved)) {
         const output = resolved !== path ? t("file.notfound_resolved", {
           path,
           resolved
@@ -7125,7 +7300,7 @@ var init_read_file = __esm(() => {
         total = slice.total;
         selected = slice.selected;
       } else {
-        const content = readFileSync5(resolved, "utf-8");
+        const content = readFileSync6(resolved, "utf-8");
         lines = content.split(`
 `);
         total = lines.length;
@@ -7217,16 +7392,16 @@ __export(exports_session_isolation, {
   cleanupSessionTempDir: () => cleanupSessionTempDir,
   DEFAULT_SESSION_ISOLATION: () => DEFAULT_SESSION_ISOLATION
 });
-import { join as join9, resolve as resolve5 } from "path";
-import { homedir as homedir4 } from "os";
-import { mkdirSync as mkdirSync7, existsSync as existsSync11 } from "fs";
+import { join as join10, resolve as resolve5 } from "path";
+import { homedir as homedir5 } from "os";
+import { mkdirSync as mkdirSync8, existsSync as existsSync12 } from "fs";
 function createSessionContext(sessionId, projectDir, isolationConfig, securityOverrides) {
   const config = { ...DEFAULT_SESSION_ISOLATION, ...isolationConfig };
-  const baseDir = config.baseDir || join9(homedir4(), ".mma", "sessions", sessionId);
-  const tempDir = join9(baseDir, "temp");
-  if (config.isolateTempFiles && !existsSync11(tempDir)) {
+  const baseDir = config.baseDir || join10(homedir5(), ".mma", "sessions", sessionId);
+  const tempDir = join10(baseDir, "temp");
+  if (config.isolateTempFiles && !existsSync12(tempDir)) {
     try {
-      mkdirSync7(tempDir, { recursive: true, mode: 448 });
+      mkdirSync8(tempDir, { recursive: true, mode: 448 });
     } catch {}
   }
   return {
@@ -7476,7 +7651,7 @@ var init_diff = __esm(() => {
 });
 
 // src/tools/write-file.ts
-import { writeFileSync as writeFileSync5, mkdirSync as mkdirSync8, existsSync as existsSync12, readFileSync as readFileSync6 } from "fs";
+import { writeFileSync as writeFileSync6, mkdirSync as mkdirSync9, existsSync as existsSync13, readFileSync as readFileSync7 } from "fs";
 import { dirname as dirname4 } from "path";
 var writeFileTool;
 var init_write_file = __esm(() => {
@@ -7535,15 +7710,15 @@ var init_write_file = __esm(() => {
         }
       }
       const dir = dirname4(resolved);
-      if (!existsSync12(dir)) {
-        mkdirSync8(dir, { recursive: true });
+      if (!existsSync13(dir)) {
+        mkdirSync9(dir, { recursive: true });
       }
-      const fileExists = existsSync12(resolved);
+      const fileExists = existsSync13(resolved);
       let oldContent = "";
       if (fileExists) {
-        oldContent = readFileSync6(resolved, "utf-8");
+        oldContent = readFileSync7(resolved, "utf-8");
       }
-      writeFileSync5(resolved, content, "utf-8");
+      writeFileSync6(resolved, content, "utf-8");
       const diff = fileExists ? generateDiff(oldContent, content) : generateNewFileDiff(content);
       ctx.fileOperationsCount = currentCount + 1;
       logFileWrite(ctx.sessionId, path, true, `File ${fileExists ? "updated" : "created"}`);
@@ -7553,7 +7728,7 @@ var init_write_file = __esm(() => {
 });
 
 // src/tools/edit-file.ts
-import { readFileSync as readFileSync7, writeFileSync as writeFileSync6 } from "fs";
+import { readFileSync as readFileSync8, writeFileSync as writeFileSync7 } from "fs";
 var editFileTool;
 var init_edit_file = __esm(() => {
   init_i18n();
@@ -7600,7 +7775,7 @@ var init_edit_file = __esm(() => {
           })
         };
       }
-      const content = readFileSync7(resolved, "utf-8");
+      const content = readFileSync8(resolved, "utf-8");
       const oldStr = String(args.old);
       const newStr = String(args.new);
       if (!content.includes(oldStr)) {
@@ -7620,7 +7795,7 @@ var init_edit_file = __esm(() => {
           };
         }
       }
-      writeFileSync6(resolved, updated, "utf-8");
+      writeFileSync7(resolved, updated, "utf-8");
       const diff = generateDiff(content, updated);
       ctx.fileOperationsCount = currentCount + 1;
       logFileWrite(ctx.sessionId, path, true, "File edited");
@@ -7777,7 +7952,7 @@ var init_grep_tool = __esm(() => {
 });
 
 // src/tools/list-dir.ts
-import { readdirSync as readdirSync4, statSync as statSync3, existsSync as existsSync13 } from "fs";
+import { readdirSync as readdirSync5, statSync as statSync3, existsSync as existsSync14 } from "fs";
 import { resolve as resolve8 } from "path";
 var listDirTool;
 var init_list_dir = __esm(() => {
@@ -7809,10 +7984,10 @@ var init_list_dir = __esm(() => {
           })
         };
       }
-      if (!existsSync13(resolved)) {
+      if (!existsSync14(resolved)) {
         return { success: false, output: t("file.dir_notfound", { path }) };
       }
-      const entries = readdirSync4(resolved);
+      const entries = readdirSync5(resolved);
       const lines = entries.map((e) => {
         const full = resolve8(resolved, e);
         return statSync3(full).isDirectory() ? `${e}/` : e;
@@ -7829,7 +8004,7 @@ var init_list_dir = __esm(() => {
 });
 
 // src/tools/create-dir.ts
-import { mkdirSync as mkdirSync9, existsSync as existsSync14 } from "fs";
+import { mkdirSync as mkdirSync10, existsSync as existsSync15 } from "fs";
 var createDirTool;
 var init_create_dir = __esm(() => {
   init_i18n();
@@ -7872,8 +8047,8 @@ var init_create_dir = __esm(() => {
           })
         };
       }
-      if (!existsSync14(resolved)) {
-        mkdirSync9(resolved, { recursive: true });
+      if (!existsSync15(resolved)) {
+        mkdirSync10(resolved, { recursive: true });
       }
       ctx.fileOperationsCount = currentCount + 1;
       logFileWrite(ctx.sessionId, path, true, "Directory created");
@@ -7883,7 +8058,7 @@ var init_create_dir = __esm(() => {
 });
 
 // src/tools/delete-file.ts
-import { unlinkSync as unlinkSync3, existsSync as existsSync15, statSync as statSync4, readFileSync as readFileSync8 } from "fs";
+import { unlinkSync as unlinkSync3, existsSync as existsSync16, statSync as statSync4, readFileSync as readFileSync9 } from "fs";
 var deleteFileTool;
 var init_delete_file = __esm(() => {
   init_i18n();
@@ -7927,13 +8102,13 @@ var init_delete_file = __esm(() => {
           })
         };
       }
-      if (!existsSync15(resolved)) {
+      if (!existsSync16(resolved)) {
         return { success: false, output: t("file.notfound", { path }) };
       }
       if (statSync4(resolved).isDirectory()) {
         return { success: false, output: t("file.is_directory", { path }) };
       }
-      const content = readFileSync8(resolved, "utf-8");
+      const content = readFileSync9(resolved, "utf-8");
       unlinkSync3(resolved);
       const diff = generateDeleteDiff(content);
       ctx.fileOperationsCount = currentCount + 1;
@@ -7944,7 +8119,7 @@ var init_delete_file = __esm(() => {
 });
 
 // src/tools/move-file.ts
-import { renameSync as renameSync2, existsSync as existsSync16, mkdirSync as mkdirSync10 } from "fs";
+import { renameSync as renameSync2, existsSync as existsSync17, mkdirSync as mkdirSync11 } from "fs";
 import { resolve as resolve9, normalize as normalize3, dirname as dirname5 } from "path";
 var moveFileTool;
 var init_move_file = __esm(() => {
@@ -8003,15 +8178,15 @@ var init_move_file = __esm(() => {
           })
         };
       }
-      if (!existsSync16(fromResolved)) {
+      if (!existsSync17(fromResolved)) {
         return {
           success: false,
           output: t("file.not_found_short", { path: fromPath })
         };
       }
       const toDir = dirname5(toResolved);
-      if (!existsSync16(toDir)) {
-        mkdirSync10(toDir, { recursive: true });
+      if (!existsSync17(toDir)) {
+        mkdirSync11(toDir, { recursive: true });
       }
       renameSync2(fromResolved, toResolved);
       const diff = generateMoveDiff(fromPath, toPath);
@@ -8027,7 +8202,7 @@ var init_move_file = __esm(() => {
 });
 
 // src/tools/file-info.ts
-import { statSync as statSync5, existsSync as existsSync17 } from "fs";
+import { statSync as statSync5, existsSync as existsSync18 } from "fs";
 var fileInfoTool;
 var init_file_info = __esm(() => {
   init_i18n();
@@ -8058,7 +8233,7 @@ var init_file_info = __esm(() => {
           })
         };
       }
-      if (!existsSync17(resolved)) {
+      if (!existsSync18(resolved)) {
         return { success: false, output: t("file.not_found_short", { path }) };
       }
       const stat = statSync5(resolved);
@@ -9120,8 +9295,8 @@ var init_prompt_builder = __esm(() => {
 });
 
 // src/core/session-logger.ts
-import { join as join10 } from "path";
-import { readFileSync as readFileSync9, existsSync as existsSync18 } from "fs";
+import { join as join11 } from "path";
+import { readFileSync as readFileSync10, existsSync as existsSync19 } from "fs";
 
 class SessionLogger {
   session;
@@ -9329,10 +9504,10 @@ class SessionLogger {
   logSessionStart(data) {
     const meta = this.session?.getActiveMeta();
     if (meta) {
-      const logPath = join10(this.session.getSessionDirectory(meta.id), "session.jsonl");
+      const logPath = join11(this.session.getSessionDirectory(meta.id), "session.jsonl");
       try {
-        if (existsSync18(logPath)) {
-          const content = readFileSync9(logPath, "utf-8");
+        if (existsSync19(logPath)) {
+          const content = readFileSync10(logPath, "utf-8");
           if (content.includes('"type":"session_start"'))
             return;
         }
@@ -11056,7 +11231,7 @@ var init_stuck_detector = __esm(() => {
 });
 
 // src/modules/artifacts/store.ts
-import { existsSync as existsSync19, mkdirSync as mkdirSync11, readFileSync as readFileSync10, writeFileSync as writeFileSync7 } from "node:fs";
+import { existsSync as existsSync20, mkdirSync as mkdirSync12, readFileSync as readFileSync11, writeFileSync as writeFileSync8 } from "node:fs";
 import { resolve as resolve10, relative as relative2, isAbsolute as isAbsolute2 } from "node:path";
 
 class ArtifactStore {
@@ -11082,21 +11257,21 @@ class ArtifactStore {
   save(name, content, ext = "md") {
     const safe = ArtifactStore.sanitizeName(name);
     const dir = resolve10(this.root);
-    mkdirSync11(dir, { recursive: true });
+    mkdirSync12(dir, { recursive: true });
     const abs = resolve10(dir, `${safe}.${ext}`);
     if (!ArtifactStore.isInside(dir, abs)) {
       throw new Error(`Artifact path escapes root: ${abs}`);
     }
-    writeFileSync7(abs, content, "utf8");
+    writeFileSync8(abs, content, "utf8");
     return abs;
   }
   read(path) {
     const abs = resolve10(this.root, path);
     if (!ArtifactStore.isInside(this.root, abs))
       return null;
-    if (!existsSync19(abs))
+    if (!existsSync20(abs))
       return null;
-    return readFileSync10(abs, "utf8");
+    return readFileSync11(abs, "utf8");
   }
   summary(content, maxChars) {
     if (content.length <= maxChars)
@@ -11420,15 +11595,15 @@ var init_moe_executor = __esm(() => {
 });
 
 // src/modules/lsp/project-root.ts
-import { existsSync as existsSync20 } from "fs";
-import { dirname as dirname6, join as join11 } from "path";
+import { existsSync as existsSync21 } from "fs";
+import { dirname as dirname6, join as join12 } from "path";
 function findProjectRoot(filePath, baseDir, markers) {
   if (!markers || markers.length === 0)
     return baseDir;
   let dir = dirname6(filePath);
   const root = baseDir.replace(/[\\/]+$/, "");
   while (true) {
-    if (markers.some((m) => existsSync20(join11(dir, m)))) {
+    if (markers.some((m) => existsSync21(join12(dir, m)))) {
       return dir;
     }
     if (dir === root)
@@ -11651,13 +11826,13 @@ var init_js_identifiers = __esm(() => {
 });
 
 // src/modules/execution/audit-runners.ts
-import { existsSync as existsSync21, readdirSync as readdirSync5, readFileSync as readFileSync11 } from "fs";
-import { dirname as dirname7, join as join12, resolve as resolve11 } from "path";
+import { existsSync as existsSync22, readdirSync as readdirSync6, readFileSync as readFileSync12 } from "fs";
+import { dirname as dirname7, join as join13, resolve as resolve11 } from "path";
 function resolveTestCommand(dir) {
-  const pkgPath = join12(dir, "package.json");
-  if (existsSync21(pkgPath)) {
+  const pkgPath = join13(dir, "package.json");
+  if (existsSync22(pkgPath)) {
     try {
-      const pkg = JSON.parse(readFileSync11(pkgPath, "utf-8"));
+      const pkg = JSON.parse(readFileSync12(pkgPath, "utf-8"));
       const script = pkg?.scripts?.test;
       if (typeof script === "string" && script.trim())
         return script.trim();
@@ -11673,7 +11848,7 @@ function resolveTestCommand(dir) {
     "jest.config.cjs",
     "bunfig.toml"
   ]) {
-    if (existsSync21(join12(dir, f))) {
+    if (existsSync22(join13(dir, f))) {
       if (f.startsWith("vitest"))
         return "bunx vitest run";
       if (f.startsWith("jest"))
@@ -11682,12 +11857,12 @@ function resolveTestCommand(dir) {
         return "bun test";
     }
   }
-  if (existsSync21(join12(dir, "pyproject.toml")) || existsSync21(join12(dir, "pytest.ini")) || existsSync21(join12(dir, "conftest.py"))) {
+  if (existsSync22(join13(dir, "pyproject.toml")) || existsSync22(join13(dir, "pytest.ini")) || existsSync22(join13(dir, "conftest.py"))) {
     return "python -m pytest -q";
   }
-  if (existsSync21(join12(dir, "go.mod")))
+  if (existsSync22(join13(dir, "go.mod")))
     return "go test ./...";
-  if (existsSync21(join12(dir, "Cargo.toml")))
+  if (existsSync22(join13(dir, "Cargo.toml")))
     return "cargo test";
   return "bun test";
 }
@@ -11696,12 +11871,12 @@ function findTestFile(dir, depth = 0) {
     return null;
   let entries;
   try {
-    entries = readdirSync5(dir, { withFileTypes: true });
+    entries = readdirSync6(dir, { withFileTypes: true });
   } catch {
     return null;
   }
   for (const e of entries) {
-    const full = join12(dir, e.name);
+    const full = join13(dir, e.name);
     if (e.isDirectory()) {
       if (SKIP_DIRS.has(e.name))
         continue;
@@ -11777,7 +11952,7 @@ function findTypecheckRoot(baseDir, existingFiles = []) {
   for (const start of candidates) {
     let dir = resolve11(start);
     for (let depth = 0;depth <= 10; depth++) {
-      if (existsSync21(join12(dir, "tsconfig.json"))) {
+      if (existsSync22(join13(dir, "tsconfig.json"))) {
         if (!best || depth < best.depth)
           best = { depth, root: dir };
         break;
@@ -11821,11 +11996,11 @@ var init_audit_runners = __esm(() => {
 });
 
 // src/modules/execution/auditor.ts
-import { existsSync as existsSync22, readdirSync as readdirSync6 } from "fs";
-import { resolve as resolve12, join as join13, basename as basename2 } from "path";
+import { existsSync as existsSync23, readdirSync as readdirSync7 } from "fs";
+import { resolve as resolve12, join as join14, basename as basename2 } from "path";
 function findExistingFile(baseDir, filePath) {
   const direct = resolve12(baseDir, filePath);
-  if (existsSync22(direct))
+  if (existsSync23(direct))
     return direct;
   const name = basename2(filePath).toLowerCase();
   const suffix = filePath.replace(/\\/g, "/").toLowerCase();
@@ -11835,14 +12010,14 @@ function findExistingFile(baseDir, filePath) {
       return;
     let entries;
     try {
-      entries = readdirSync6(dir, { withFileTypes: true });
+      entries = readdirSync7(dir, { withFileTypes: true });
     } catch {
       return;
     }
     for (const e of entries) {
       if (found)
         return;
-      const full = join13(dir, e.name);
+      const full = join14(dir, e.name);
       if (e.isDirectory()) {
         if (SKIP_DIRS.has(e.name))
           continue;
@@ -11980,8 +12155,8 @@ var init_auditor = __esm(() => {
 });
 
 // src/modules/execution/verifier.ts
-import { existsSync as existsSync23 } from "fs";
-import { resolve as resolve13, extname as extname2, join as join14 } from "path";
+import { existsSync as existsSync24 } from "fs";
+import { resolve as resolve13, extname as extname2, join as join15 } from "path";
 import { spawn as spawn3 } from "child_process";
 
 class StepVerifier {
@@ -11991,7 +12166,7 @@ class StepVerifier {
   }
   async checkFileExists(path) {
     const resolved = resolve13(this.baseDir, path);
-    const exists = existsSync23(resolved);
+    const exists = existsSync24(resolved);
     return {
       passed: exists,
       message: exists ? t("verify.file_exists", { path }) : t("verify.file_not_found", { path })
@@ -12010,7 +12185,7 @@ class StepVerifier {
   }
   async runTypeCheck() {
     const tsconfigPath = resolve13(this.baseDir, "tsconfig.json");
-    if (!existsSync23(tsconfigPath)) {
+    if (!existsSync24(tsconfigPath)) {
       return { passed: true, message: "No tsconfig.json found — skipping type check" };
     }
     try {
@@ -12023,8 +12198,8 @@ class StepVerifier {
   }
   async runTypeCheckForFile(filePath) {
     const projectRoot = findProjectRoot(filePath, this.baseDir, ["tsconfig.json", "package.json"]);
-    const tsconfigPath = join14(projectRoot, "tsconfig.json");
-    if (!existsSync23(tsconfigPath)) {
+    const tsconfigPath = join15(projectRoot, "tsconfig.json");
+    if (!existsSync24(tsconfigPath)) {
       return { passed: true, message: "No tsconfig.json found — skipping type check" };
     }
     try {
@@ -12037,7 +12212,7 @@ class StepVerifier {
   }
   async runTests() {
     const pkgPath = resolve13(this.baseDir, "package.json");
-    if (!existsSync23(pkgPath)) {
+    if (!existsSync24(pkgPath)) {
       return { passed: true, message: "No package.json found — skipping tests" };
     }
     try {
@@ -12639,16 +12814,41 @@ ${t("tool.truncated", { tokens: Math.ceil(removedChars / 2) })}`;
     }
     contextManager.addMessage({ role: "user", content: input });
     slog.logUser(input);
-    if (config.moe?.enabled) {
-      return runWithMoE({
+    const startedAt = Date.now();
+    let toolCalls = 0;
+    const countTool = (ev) => {
+      if (ev.type === "end")
+        toolCalls++;
+      onTool?.(ev);
+    };
+    const emitTurnEnd = (result, err) => {
+      const interrupted = err instanceof Error && err.name === "AbortError" || this.shutdownRequested;
+      pluginManager.runOnTurnEnd?.({
+        logger,
+        sessionManager: sessionManager?.getActiveMeta(),
+        contextManager
+      }, {
+        success: !!result && result.success !== false && !err,
+        durationMs: Date.now() - startedAt,
+        textLength: (result?.text || "").length,
+        toolCalls,
+        interrupted: interrupted || undefined
+      });
+    };
+    try {
+      const result = config.moe?.enabled === true ? await runWithMoE({
         config,
         llmProvider,
         toolExecutor,
         logger,
         baseDir: this.deps.baseDir
-      }, input, () => this.executeSingleAgentLoop(input, onChunk, onMeta, onTool, onPhase), { onMeta, onTool, onPhase });
+      }, input, () => this.executeSingleAgentLoop(input, onChunk, onMeta, countTool, onPhase), { onMeta, onTool: countTool, onPhase }) : await this.executeSingleAgentLoop(input, onChunk, onMeta, countTool, onPhase);
+      emitTurnEnd(result);
+      return result;
+    } catch (err) {
+      emitTurnEnd(null, err);
+      throw err;
     }
-    return this.executeSingleAgentLoop(input, onChunk, onMeta, onTool, onPhase);
   }
   async executeSingleAgentLoop(input, onChunk, onMeta, onTool, onPhase) {
     const {
@@ -12936,10 +13136,12 @@ ${t("tool.truncated", { tokens: Math.ceil(removedChars / 2) })}`;
             }
           }
           pluginManager.runOnToolEnd({ iteration, logger, contextManager }, { id: call.id, name: call.name, arguments: call.arguments }, result, duration);
-          if (result.display) {
-            onMeta?.(`
+          if (result.display !== undefined) {
+            if (result.display.length > 0) {
+              onMeta?.(`
 ` + result.display + `
 `);
+            }
           } else {
             const metaOut = pluginManager.runOnMeta({ iteration, logger, contextManager }, result.output);
             onMeta?.(`
@@ -13894,8 +14096,8 @@ var init_confidence = __esm(() => {
 });
 
 // src/modules/hallucination/factual.ts
-import { existsSync as existsSync24, readdirSync as readdirSync7 } from "fs";
-import { resolve as resolve14, isAbsolute as isAbsolute3, join as join15 } from "path";
+import { existsSync as existsSync25, readdirSync as readdirSync8 } from "fs";
+import { resolve as resolve14, isAbsolute as isAbsolute3, join as join16 } from "path";
 
 class FactualCheck {
   baseDir;
@@ -13935,13 +14137,13 @@ class FactualCheck {
   }
   pathExists(fp) {
     if (isAbsolute3(fp))
-      return existsSync24(fp);
+      return existsSync25(fp);
     if (this.knownFiles.has(fp))
       return true;
     for (const cand of this.dotfileVariants(fp)) {
       if (this.knownFiles.has(cand))
         return true;
-      if (existsSync24(resolve14(this.baseDir, cand)))
+      if (existsSync25(resolve14(this.baseDir, cand)))
         return true;
     }
     if (!fp.includes("/") && !fp.includes("\\")) {
@@ -13958,7 +14160,7 @@ class FactualCheck {
   }
   bareNameExists(name) {
     for (const cand of this.dotfileVariants(name)) {
-      if (existsSync24(resolve14(this.baseDir, cand)))
+      if (existsSync25(resolve14(this.baseDir, cand)))
         return true;
       if (this.indexHas(cand))
         return true;
@@ -13997,14 +14199,14 @@ class FactualCheck {
       return count;
     let entries;
     try {
-      entries = readdirSync7(dir, { withFileTypes: true });
+      entries = readdirSync8(dir, { withFileTypes: true });
     } catch {
       return count;
     }
     for (const entry of entries) {
       if (count >= FactualCheck.MAX_INDEXED_FILES)
         break;
-      const full = join15(dir, entry.name);
+      const full = join16(dir, entry.name);
       if (entry.isDirectory()) {
         if (!IGNORED_DIRS.has(entry.name)) {
           count = this.scanDir(full, index, count);
@@ -14178,8 +14380,8 @@ var init_detector = __esm(() => {
 });
 
 // src/modules/lsp/command.ts
-import { delimiter, join as join16 } from "path";
-import { existsSync as existsSync25 } from "fs";
+import { delimiter, join as join17 } from "path";
+import { existsSync as existsSync26 } from "fs";
 import { platform as platform3 } from "os";
 function resolveSpawnCommand(command, platformName = platform3(), pathEnv = process.env.PATH ?? "") {
   if (platformName !== "win32")
@@ -14190,8 +14392,8 @@ function resolveSpawnCommand(command, platformName = platform3(), pathEnv = proc
   const dirs = pathEnv.split(delimiter).filter(Boolean);
   for (const dir of dirs) {
     for (const ext of WIN_EXTS) {
-      const candidate = join16(dir, `${command}${ext}`);
-      if (existsSync25(candidate))
+      const candidate = join17(dir, `${command}${ext}`);
+      if (existsSync26(candidate))
         return `${command}${ext}`;
     }
   }
@@ -14303,6 +14505,18 @@ var init_checker = __esm(() => {
 // src/modules/plugins/manager.ts
 class PluginManager {
   plugins = [];
+  hostBridge = null;
+  setHostBridge(bridge) {
+    this.hostBridge = bridge;
+  }
+  withHost(ctx) {
+    if (!ctx || typeof ctx !== "object")
+      return ctx;
+    if (!this.hostBridge || ctx.hostBridge !== undefined) {
+      return ctx;
+    }
+    return { ...ctx, hostBridge: this.hostBridge };
+  }
   register(plugin, source) {
     if (source)
       plugin.source = source;
@@ -14341,7 +14555,8 @@ class PluginManager {
       }
     });
   }
-  async runOnBeforeTool(ctx, call) {
+  async runOnBeforeTool(rawCtx, call) {
+    const ctx = this.withHost(rawCtx);
     for (const plugin of this.plugins) {
       if (plugin.onBeforeTool) {
         try {
@@ -14353,7 +14568,8 @@ class PluginManager {
     }
     return true;
   }
-  async runOnAfterTool(ctx, call, result) {
+  async runOnAfterTool(rawCtx, call, result) {
+    const ctx = this.withHost(rawCtx);
     for (const plugin of this.plugins) {
       if (plugin.onAfterTool) {
         try {
@@ -14362,7 +14578,8 @@ class PluginManager {
       }
     }
   }
-  async runOnError(ctx, error) {
+  async runOnError(rawCtx, error) {
+    const ctx = this.withHost(rawCtx);
     for (const plugin of this.plugins) {
       if (plugin.onError) {
         try {
@@ -14371,7 +14588,8 @@ class PluginManager {
       }
     }
   }
-  runOnSessionStart(ctx) {
+  runOnSessionStart(rawCtx) {
+    const ctx = this.withHost(rawCtx);
     for (const plugin of this.plugins) {
       if (plugin.onSessionStart) {
         try {
@@ -14380,7 +14598,8 @@ class PluginManager {
       }
     }
   }
-  runOnBeforeThink(ctx) {
+  runOnBeforeThink(rawCtx) {
+    const ctx = this.withHost(rawCtx);
     for (const plugin of this.plugins) {
       if (plugin.onBeforeThink) {
         try {
@@ -14389,7 +14608,8 @@ class PluginManager {
       }
     }
   }
-  runOnAfterThink(ctx, response) {
+  runOnAfterThink(rawCtx, response) {
+    const ctx = this.withHost(rawCtx);
     for (const plugin of this.plugins) {
       if (plugin.onAfterThink) {
         try {
@@ -14398,7 +14618,8 @@ class PluginManager {
       }
     }
   }
-  runOnSessionEnd(ctx) {
+  runOnSessionEnd(rawCtx) {
+    const ctx = this.withHost(rawCtx);
     for (const plugin of this.plugins) {
       if (plugin.onSessionEnd) {
         try {
@@ -14407,7 +14628,8 @@ class PluginManager {
       }
     }
   }
-  runOnToolCall(ctx) {
+  runOnToolCall(rawCtx) {
+    const ctx = this.withHost(rawCtx);
     for (const plugin of this.plugins) {
       if (plugin.onToolCall) {
         try {
@@ -14416,7 +14638,8 @@ class PluginManager {
       }
     }
   }
-  runOnPhase(ctx, phase) {
+  runOnPhase(rawCtx, phase) {
+    const ctx = this.withHost(rawCtx);
     for (const plugin of this.plugins) {
       if (plugin.onPhase) {
         try {
@@ -14425,7 +14648,8 @@ class PluginManager {
       }
     }
   }
-  runOnToolStart(ctx, call) {
+  runOnToolStart(rawCtx, call) {
+    const ctx = this.withHost(rawCtx);
     for (const plugin of this.plugins) {
       if (plugin.onToolStart) {
         try {
@@ -14434,7 +14658,8 @@ class PluginManager {
       }
     }
   }
-  runOnToolEnd(ctx, call, result, durationMs) {
+  runOnToolEnd(rawCtx, call, result, durationMs) {
+    const ctx = this.withHost(rawCtx);
     for (const plugin of this.plugins) {
       if (plugin.onToolEnd) {
         try {
@@ -14443,7 +14668,8 @@ class PluginManager {
       }
     }
   }
-  runOnText(ctx, chunk) {
+  runOnText(rawCtx, chunk) {
+    const ctx = this.withHost(rawCtx);
     for (const plugin of this.plugins) {
       if (plugin.onText) {
         try {
@@ -14455,7 +14681,8 @@ class PluginManager {
     }
     return chunk;
   }
-  runOnMeta(ctx, chunk) {
+  runOnMeta(rawCtx, chunk) {
+    const ctx = this.withHost(rawCtx);
     for (const plugin of this.plugins) {
       if (plugin.onMeta) {
         try {
@@ -14467,6 +14694,16 @@ class PluginManager {
     }
     return chunk;
   }
+  runOnTurnEnd(rawCtx, summary) {
+    const ctx = this.withHost(rawCtx);
+    for (const plugin of this.plugins) {
+      if (plugin.onTurnEnd) {
+        try {
+          plugin.onTurnEnd(ctx, summary);
+        } catch {}
+      }
+    }
+  }
 }
 var init_manager3 = __esm(() => {
   init_checker();
@@ -14786,7 +15023,7 @@ ${joined}` }
 var DEFAULT_CHUNK_SYSTEM_PROMPT = 'Answer the query using ONLY the provided text. Be concise. If the text does not contain the answer, say "NO_EVIDENCE".', DEFAULT_SYNTHESIS_SYSTEM_PROMPT = "You are given a query and per-chunk answers over a large text. Produce the final answer to the query, combining evidence from the chunks. If no chunk had evidence, say so.";
 
 // src/tools/chunk-query.ts
-import { readFileSync as readFileSync12 } from "node:fs";
+import { readFileSync as readFileSync13 } from "node:fs";
 import { resolve as resolve16 } from "node:path";
 var chunkQueryTool;
 var init_chunk_query = __esm(() => {
@@ -14856,7 +15093,7 @@ var init_chunk_query = __esm(() => {
           return { success: false, output: `[SCOPE] ${check.reason || "Path not allowed"}` };
         }
         try {
-          content = readFileSync12(resolve16(ctx.baseDir, inputPath), "utf8");
+          content = readFileSync13(resolve16(ctx.baseDir, inputPath), "utf8");
         } catch (e) {
           return { success: false, output: `Cannot read ${inputPath}: ${e.message}` };
         }
@@ -15256,7 +15493,7 @@ var init_web_browse = __esm(() => {
 });
 
 // src/tools/download-file.ts
-import { writeFileSync as writeFileSync8, mkdirSync as mkdirSync12 } from "fs";
+import { writeFileSync as writeFileSync9, mkdirSync as mkdirSync13 } from "fs";
 import { dirname as dirname9 } from "path";
 var MAX_DOWNLOAD_BYTES, downloadFileTool;
 var init_download_file = __esm(() => {
@@ -15345,8 +15582,8 @@ var init_download_file = __esm(() => {
             output: t("tool.download_too_large", { max: String(maxBytes) })
           };
         }
-        mkdirSync12(dirname9(resolved), { recursive: true });
-        writeFileSync8(resolved, buffer);
+        mkdirSync13(dirname9(resolved), { recursive: true });
+        writeFileSync9(resolved, buffer);
         const contentType = response.headers.get("content-type")?.split(";")[0]?.trim() || "unknown";
         logNetworkRequest(ctx.sessionId, sanitizeUrl(url), true, `Status: ${response.status}`);
         logFileWrite(ctx.sessionId, resolved, true, `Downloaded ${buffer.byteLength} bytes`);
@@ -16185,8 +16422,8 @@ ${JSON.stringify(result, null, 2)}`
 
 // src/tools/search-history.ts
 import * as fs from "fs";
-import { join as join17 } from "path";
-import { homedir as homedir5 } from "os";
+import { join as join18 } from "path";
+import { homedir as homedir6 } from "os";
 function searchFile(filePath, query, maxResults, results) {
   if (!fs.existsSync(filePath))
     return;
@@ -16230,7 +16467,7 @@ var init_search_history = __esm(() => {
       const query = String(args.query || "").toLowerCase();
       const maxResults = Number(args.maxResults) || 5;
       const sessionId = args.sessionId ? String(args.sessionId) : null;
-      const sessionDir = join17(homedir5(), ".mma", "sessions");
+      const sessionDir = join18(homedir6(), ".mma", "sessions");
       const results = [];
       try {
         if (!fs.existsSync(sessionDir)) {
@@ -16245,7 +16482,7 @@ var init_search_history = __esm(() => {
             continue;
           if (sessionId && entry.name !== sessionId)
             continue;
-          const historyFile = join17(sessionDir, entry.name, "history.jsonl");
+          const historyFile = join18(sessionDir, entry.name, "history.jsonl");
           searchFile(historyFile, query, maxResults, results);
           if (results.length >= maxResults)
             break;
@@ -16272,8 +16509,8 @@ var init_search_history = __esm(() => {
 });
 
 // src/modules/memory/search.ts
-import { readFileSync as readFileSync14, existsSync as existsSync27 } from "fs";
-import { join as join18 } from "path";
+import { readFileSync as readFileSync15, existsSync as existsSync28 } from "fs";
+import { join as join19 } from "path";
 
 class MemorySearch {
   memoryDir;
@@ -16284,10 +16521,10 @@ class MemorySearch {
     const results = [];
     const lowerQuery = query.toLowerCase();
     for (const name of MEMORY_FILES) {
-      const path = join18(this.memoryDir, `${name}.md`);
-      if (!existsSync27(path))
+      const path = join19(this.memoryDir, `${name}.md`);
+      if (!existsSync28(path))
         continue;
-      const content = readFileSync14(path, "utf-8");
+      const content = readFileSync15(path, "utf-8");
       const lines = content.split(`
 `);
       for (const line of lines) {
@@ -16296,10 +16533,10 @@ class MemorySearch {
         }
       }
     }
-    const prefsPath = join18(this.memoryDir, "preferences.json");
-    if (existsSync27(prefsPath)) {
+    const prefsPath = join19(this.memoryDir, "preferences.json");
+    if (existsSync28(prefsPath)) {
       try {
-        const prefs = JSON.parse(readFileSync14(prefsPath, "utf-8"));
+        const prefs = JSON.parse(readFileSync15(prefsPath, "utf-8"));
         for (const [key, value] of Object.entries(prefs)) {
           const searchStr = `${key}=${value}`;
           if (searchStr.toLowerCase().includes(lowerQuery)) {
@@ -16317,8 +16554,8 @@ var init_search = __esm(() => {
 });
 
 // src/modules/memory/store.ts
-import { readFileSync as readFileSync15, writeFileSync as writeFileSync9, appendFileSync as appendFileSync5, existsSync as existsSync28, mkdirSync as mkdirSync13 } from "fs";
-import { join as join19 } from "path";
+import { readFileSync as readFileSync16, writeFileSync as writeFileSync10, appendFileSync as appendFileSync5, existsSync as existsSync29, mkdirSync as mkdirSync14 } from "fs";
+import { join as join20 } from "path";
 
 class MemoryStore {
   memoryDir;
@@ -16326,27 +16563,27 @@ class MemoryStore {
     this.memoryDir = memoryDir;
     this.ensureDir();
     for (const name of MEMORY_FILES2) {
-      const path = join19(this.memoryDir, `${name}.md`);
-      if (!existsSync28(path)) {
-        writeFileSync9(path, `# ${name.charAt(0).toUpperCase() + name.slice(1)}
+      const path = join20(this.memoryDir, `${name}.md`);
+      if (!existsSync29(path)) {
+        writeFileSync10(path, `# ${name.charAt(0).toUpperCase() + name.slice(1)}
 
 `, "utf-8");
       }
     }
   }
   ensureDir() {
-    if (!existsSync28(this.memoryDir)) {
-      mkdirSync13(this.memoryDir, { recursive: true });
+    if (!existsSync29(this.memoryDir)) {
+      mkdirSync14(this.memoryDir, { recursive: true });
     }
   }
   read(name) {
-    const path = join19(this.memoryDir, `${name}.md`);
-    if (!existsSync28(path))
+    const path = join20(this.memoryDir, `${name}.md`);
+    if (!existsSync29(path))
       return "";
-    return readFileSync15(path, "utf-8");
+    return readFileSync16(path, "utf-8");
   }
   append(name, entry) {
-    const path = join19(this.memoryDir, `${name}.md`);
+    const path = join20(this.memoryDir, `${name}.md`);
     const timestamp = new Date().toISOString().replace("T", " ").slice(0, 19);
     const formatted = `- **${timestamp}** — ${entry}
 `;
@@ -16357,14 +16594,14 @@ class MemoryStore {
     return searchModule.query(query);
   }
   prefsPath() {
-    return join19(this.memoryDir, "preferences.json");
+    return join20(this.memoryDir, "preferences.json");
   }
   getPreferences() {
     const path = this.prefsPath();
-    if (!existsSync28(path))
+    if (!existsSync29(path))
       return {};
     try {
-      return JSON.parse(readFileSync15(path, "utf-8"));
+      return JSON.parse(readFileSync16(path, "utf-8"));
     } catch {
       return {};
     }
@@ -16372,14 +16609,14 @@ class MemoryStore {
   setPreference(key, value) {
     const prefs = this.getPreferences();
     prefs[key] = value;
-    writeFileSync9(this.prefsPath(), JSON.stringify(prefs, null, 2), "utf-8");
+    writeFileSync10(this.prefsPath(), JSON.stringify(prefs, null, 2), "utf-8");
   }
   deletePreference(key) {
     const prefs = this.getPreferences();
     if (!(key in prefs))
       return false;
     delete prefs[key];
-    writeFileSync9(this.prefsPath(), JSON.stringify(prefs, null, 2), "utf-8");
+    writeFileSync10(this.prefsPath(), JSON.stringify(prefs, null, 2), "utf-8");
     return true;
   }
   appendRule(category, pattern, cause, solution) {
@@ -16396,8 +16633,8 @@ var init_store2 = __esm(() => {
 });
 
 // src/tools/remember.ts
-import { homedir as homedir6 } from "os";
-import { join as join20 } from "path";
+import { homedir as homedir7 } from "os";
+import { join as join21 } from "path";
 var CATEGORIES, rememberTool;
 var init_remember = __esm(() => {
   init_i18n();
@@ -16436,7 +16673,7 @@ var init_remember = __esm(() => {
       if (!CATEGORIES.includes(category)) {
         return { success: false, output: t("tool.invalid_params") };
       }
-      const memoryDir = join20(homedir6(), ".mma", "memory");
+      const memoryDir = join21(homedir7(), ".mma", "memory");
       const store = new MemoryStore(memoryDir);
       try {
         if (category === "preferences") {
@@ -16468,8 +16705,8 @@ var init_remember = __esm(() => {
 });
 
 // src/tools/recall.ts
-import { homedir as homedir7 } from "os";
-import { join as join21 } from "path";
+import { homedir as homedir8 } from "os";
+import { join as join22 } from "path";
 function formatAll(store) {
   const parts = [];
   const prefs = store.getPreferences();
@@ -16553,7 +16790,7 @@ var init_recall = __esm(() => {
     handler: async (_ctx, args) => {
       const query = args.query ? String(args.query) : "";
       const category = args.category ? String(args.category) : "";
-      const memoryDir = join21(homedir7(), ".mma", "memory");
+      const memoryDir = join22(homedir8(), ".mma", "memory");
       const store = new MemoryStore(memoryDir);
       try {
         if (!query && !category) {
@@ -16591,9 +16828,9 @@ var init_recall = __esm(() => {
 });
 
 // src/modules/browser/bridge-path.ts
-import { existsSync as existsSync29 } from "fs";
+import { existsSync as existsSync30 } from "fs";
 function pickExistingPath(candidates, fallback = candidates[0]) {
-  return candidates.find((p) => existsSync29(p)) ?? fallback;
+  return candidates.find((p) => existsSync30(p)) ?? fallback;
 }
 var init_bridge_path = () => {};
 
@@ -16604,13 +16841,13 @@ __export(exports_bridge_client, {
 });
 import { spawn as spawn5 } from "child_process";
 import { createInterface } from "readline";
-import { dirname as dirname10, join as join22 } from "path";
+import { dirname as dirname10, join as join23 } from "path";
 import { fileURLToPath } from "url";
 function bridgeScriptPath() {
   const dir = dirname10(fileURLToPath(import.meta.url));
   const candidates = [
-    join22(dir, "bridge-server.mjs"),
-    join22(dir, "modules", "browser", "bridge-server.mjs")
+    join23(dir, "bridge-server.mjs"),
+    join23(dir, "modules", "browser", "bridge-server.mjs")
   ];
   return pickExistingPath(candidates);
 }
@@ -17164,15 +17401,15 @@ function buildTextExtractionScript() {
 
 // src/modules/browser/cookie-store.ts
 import { readFile, writeFile, mkdir } from "fs/promises";
-import { join as join23 } from "path";
+import { join as join24 } from "path";
 
 class CookieStore {
   filePath;
   constructor(cookieDir) {
-    this.filePath = join23(cookieDir, "cookies.json");
+    this.filePath = join24(cookieDir, "cookies.json");
   }
   async save(cookies) {
-    await mkdir(join23(this.filePath, ".."), { recursive: true });
+    await mkdir(join24(this.filePath, ".."), { recursive: true });
     await writeFile(this.filePath, JSON.stringify(cookies, null, 2), "utf-8");
   }
   async load() {
@@ -17530,10 +17767,10 @@ var init_session = __esm(() => {
 });
 
 // src/tools/browser.ts
-import { join as join24 } from "path";
+import { join as join25 } from "path";
 function getSession(ctx) {
   if (!session) {
-    const cookieDir = join24(ctx.baseDir, ".mma", "browser");
+    const cookieDir = join25(ctx.baseDir, ".mma", "browser");
     session = new BrowserSession({
       ...DEFAULT_BROWSER_CONFIG,
       headless: ctx.config.browser?.headless ?? true,
@@ -17659,7 +17896,7 @@ __export(exports_image_utils, {
   detectMime: () => detectMime,
   bufferToDataUrl: () => bufferToDataUrl
 });
-import { readFileSync as readFileSync16 } from "fs";
+import { readFileSync as readFileSync17 } from "fs";
 import { extname as extname3 } from "path";
 function detectMime(filePath) {
   const ext = extname3(filePath).toLowerCase();
@@ -17680,9 +17917,9 @@ async function readClipboardImage() {
 async function readClipboardFallback() {
   const { platform: platform5 } = await import("os");
   const { execSync } = await import("child_process");
-  const { readFileSync: readFileSync17, unlinkSync: unlinkSync4 } = await import("fs");
-  const { join: join25 } = await import("path");
-  const tmpPath = join25(process.env.TEMP || process.env.TMP || "/tmp", `mma-clip-${Date.now()}.png`);
+  const { readFileSync: readFileSync18, unlinkSync: unlinkSync4 } = await import("fs");
+  const { join: join26 } = await import("path");
+  const tmpPath = join26(process.env.TEMP || process.env.TMP || "/tmp", `mma-clip-${Date.now()}.png`);
   try {
     if (platform5() === "linux") {
       execSync(`xclip -selection clipboard -t image/png -o > "${tmpPath}" 2>/dev/null`, {
@@ -17691,7 +17928,7 @@ async function readClipboardFallback() {
     } else {
       return null;
     }
-    const buf = readFileSync17(tmpPath);
+    const buf = readFileSync18(tmpPath);
     unlinkSync4(tmpPath);
     return buf.length > 0 ? buf : null;
   } catch {
@@ -17702,7 +17939,7 @@ async function readClipboardFallback() {
   }
 }
 async function loadFileAsDataUrl(filePath) {
-  const buf = readFileSync16(filePath);
+  const buf = readFileSync17(filePath);
   if (typeof Bun !== "undefined" && typeof Bun.Image !== "undefined") {
     try {
       const img = new Bun.Image(buf);
@@ -17762,7 +17999,7 @@ var init_image_utils = __esm(() => {
 });
 
 // src/tools/attach-image.ts
-import { existsSync as existsSync30 } from "fs";
+import { existsSync as existsSync31 } from "fs";
 import { resolve as resolve17 } from "path";
 var attachImageTool;
 var init_attach_image = __esm(() => {
@@ -17814,7 +18051,7 @@ var init_attach_image = __esm(() => {
           dataUrl = result.dataUrl;
         } else {
           const absPath = resolve17(ctx.baseDir, source);
-          if (!existsSync30(absPath)) {
+          if (!existsSync31(absPath)) {
             return {
               success: false,
               output: t("image.not_found", { path: source })
@@ -18072,16 +18309,16 @@ class ModuleRegistry {
 }
 
 // src/modules/plugins/loader.ts
-import { readdirSync as readdirSync9, existsSync as existsSync31, statSync as statSync6 } from "fs";
-import { join as join25, basename as basename3 } from "path";
+import { readdirSync as readdirSync10, existsSync as existsSync32, statSync as statSync6 } from "fs";
+import { join as join26, basename as basename3 } from "path";
 
 class PluginLoader {
   loadFromDir(dirPath, pluginManager, logger, options) {
-    if (!existsSync31(dirPath))
+    if (!existsSync32(dirPath))
       return;
-    const entries = readdirSync9(dirPath).sort();
+    const entries = readdirSync10(dirPath).sort();
     for (const entry of entries) {
-      const fullPath = join25(dirPath, entry);
+      const fullPath = join26(dirPath, entry);
       const stat = statSync6(fullPath);
       if (stat.isFile()) {
         if (!entry.endsWith(".ts") && !entry.endsWith(".js"))
@@ -18097,8 +18334,8 @@ class PluginLoader {
   }
   findEntryFile(dir) {
     for (const name of FOLDER_ENTRY_NAMES) {
-      const candidate = join25(dir, name);
-      if (existsSync31(candidate))
+      const candidate = join26(dir, name);
+      if (existsSync32(candidate))
         return candidate;
     }
     return null;
@@ -18140,8 +18377,8 @@ var init_loader = __esm(() => {
 
 // src/modules/plugins/builtin/lint-on-write.ts
 import { spawn as spawn6, execSync } from "child_process";
-import { existsSync as existsSync32, readFileSync as readFileSync17 } from "fs";
-import { resolve as resolve18, extname as extname4, join as join26 } from "path";
+import { existsSync as existsSync33, readFileSync as readFileSync18 } from "fs";
+import { resolve as resolve18, extname as extname4, join as join27 } from "path";
 import { platform as platform5 } from "os";
 function lintCacheKey(baseDir, lintScript) {
   return `${baseDir}::${lintScript}`;
@@ -18217,7 +18454,7 @@ class LintOnWritePlugin {
     if (!path)
       return;
     const fullPath = resolve18(ctx.baseDir, path);
-    if (!existsSync32(fullPath))
+    if (!existsSync33(fullPath))
       return;
     const signal = ctx.signal;
     if (signal?.aborted)
@@ -18241,7 +18478,7 @@ class LintOnWritePlugin {
     if (ext === ".ts" || ext === ".tsx" || ext === ".cts" || ext === ".mts") {
       let content = "";
       try {
-        content = readFileSync17(filePath, "utf-8");
+        content = readFileSync18(filePath, "utf-8");
       } catch {
         return null;
       }
@@ -18283,11 +18520,11 @@ class LintOnWritePlugin {
   async runProjectLint(ctx, result, signal) {
     let lintScript;
     try {
-      const packageJsonPath = join26(ctx.baseDir, "package.json");
-      if (!existsSync32(packageJsonPath)) {
+      const packageJsonPath = join27(ctx.baseDir, "package.json");
+      if (!existsSync33(packageJsonPath)) {
         return;
       }
-      const packageJson = JSON.parse(readFileSync17(packageJsonPath, "utf-8"));
+      const packageJson = JSON.parse(readFileSync18(packageJsonPath, "utf-8"));
       lintScript = packageJson.scripts?.lint;
       if (!lintScript) {
         return;
@@ -18320,8 +18557,8 @@ ${stdout}`;
   }
   async runProjectTypeCheck(filePath, baseDir, result, signal) {
     const projectRoot = findProjectRoot(filePath, baseDir, ["tsconfig.json", "package.json"]);
-    const tsconfigPath = join26(projectRoot, "tsconfig.json");
-    if (!existsSync32(tsconfigPath)) {
+    const tsconfigPath = join27(projectRoot, "tsconfig.json");
+    if (!existsSync33(tsconfigPath)) {
       return;
     }
     const now = Date.now();
@@ -18577,11 +18814,11 @@ class PlanTracker {
 var init_tracker = () => {};
 
 // src/modules/execution/plan-store.ts
-import { readFileSync as readFileSync18, writeFileSync as writeFileSync10, mkdirSync as mkdirSync14, existsSync as existsSync33, readdirSync as readdirSync10, rmSync } from "fs";
-import { join as join27 } from "path";
+import { readFileSync as readFileSync19, writeFileSync as writeFileSync11, mkdirSync as mkdirSync15, existsSync as existsSync34, readdirSync as readdirSync11, rmSync } from "fs";
+import { join as join28 } from "path";
 function readPlanFile(path, fallbackBaseDir) {
   try {
-    const raw = readFileSync18(path, "utf-8");
+    const raw = readFileSync19(path, "utf-8");
     if (!raw.trim())
       return null;
     const parsed = JSON.parse(raw);
@@ -18600,13 +18837,13 @@ function readPlanFile(path, fallbackBaseDir) {
   }
 }
 function writePlanFile(path, plan) {
-  writeFileSync10(path, JSON.stringify(plan, null, 2), "utf-8");
+  writeFileSync11(path, JSON.stringify(plan, null, 2), "utf-8");
 }
 function listDir(dir, baseDir) {
-  if (!existsSync33(dir))
+  if (!existsSync34(dir))
     return [];
-  const files = readdirSync10(dir).filter((f) => f.endsWith(".json"));
-  return files.map((f) => readPlanFile(join27(dir, f), baseDir)).filter((p) => p !== null);
+  const files = readdirSync11(dir).filter((f) => f.endsWith(".json"));
+  return files.map((f) => readPlanFile(join28(dir, f), baseDir)).filter((p) => p !== null);
 }
 function toMeta(plan, status) {
   return {
@@ -18627,33 +18864,33 @@ class PlanStore {
   archiveDir;
   legacyPath;
   constructor(baseDir) {
-    const mmaDir = join27(baseDir, ".mma");
-    if (!existsSync33(mmaDir))
-      mkdirSync14(mmaDir, { recursive: true });
+    const mmaDir = join28(baseDir, ".mma");
+    if (!existsSync34(mmaDir))
+      mkdirSync15(mmaDir, { recursive: true });
     this.baseDir = baseDir;
-    this.plansDir = join27(mmaDir, "plans");
-    this.draftsDir = join27(this.plansDir, "drafts");
-    this.archiveDir = join27(this.plansDir, "archive");
-    this.legacyPath = join27(mmaDir, LEGACY_FILE);
+    this.plansDir = join28(mmaDir, "plans");
+    this.draftsDir = join28(this.plansDir, "drafts");
+    this.archiveDir = join28(this.plansDir, "archive");
+    this.legacyPath = join28(mmaDir, LEGACY_FILE);
     for (const dir of [this.plansDir, this.draftsDir, this.archiveDir]) {
-      if (!existsSync33(dir))
-        mkdirSync14(dir, { recursive: true });
+      if (!existsSync34(dir))
+        mkdirSync15(dir, { recursive: true });
     }
   }
   activePath() {
-    return join27(this.plansDir, "active.json");
+    return join28(this.plansDir, "active.json");
   }
   saveActive(plan) {
     writePlanFile(this.activePath(), plan);
   }
   loadActive() {
     const activePath = this.activePath();
-    if (existsSync33(activePath)) {
+    if (existsSync34(activePath)) {
       const plan = readPlanFile(activePath, this.baseDir);
       if (plan)
         return plan;
     }
-    if (existsSync33(this.legacyPath)) {
+    if (existsSync34(this.legacyPath)) {
       const legacy = readPlanFile(this.legacyPath, this.baseDir);
       if (legacy) {
         this.saveActive(legacy);
@@ -18667,26 +18904,26 @@ class PlanStore {
   }
   clearActive() {
     const p = this.activePath();
-    if (existsSync33(p))
+    if (existsSync34(p))
       rmSync(p, { force: true });
   }
   saveDraft(plan) {
-    writePlanFile(join27(this.draftsDir, `${plan.id}.json`), plan);
+    writePlanFile(join28(this.draftsDir, `${plan.id}.json`), plan);
   }
   loadDraft(id) {
-    const p = join27(this.draftsDir, `${id}.json`);
-    return existsSync33(p) ? readPlanFile(p, this.baseDir) : null;
+    const p = join28(this.draftsDir, `${id}.json`);
+    return existsSync34(p) ? readPlanFile(p, this.baseDir) : null;
   }
   removeDraft(id) {
-    const p = join27(this.draftsDir, `${id}.json`);
-    if (existsSync33(p))
+    const p = join28(this.draftsDir, `${id}.json`);
+    if (existsSync34(p))
       rmSync(p, { force: true });
   }
   listDrafts() {
     return listDir(this.draftsDir, this.baseDir);
   }
   archivePlan(plan) {
-    writePlanFile(join27(this.archiveDir, `${plan.id}.json`), plan);
+    writePlanFile(join28(this.archiveDir, `${plan.id}.json`), plan);
     this.removeDraft(plan.id);
     const active = this.loadActive();
     if (active && active.id === plan.id) {
@@ -18697,8 +18934,8 @@ class PlanStore {
     return listDir(this.archiveDir, this.baseDir);
   }
   removeArchived(id) {
-    const p = join27(this.archiveDir, `${id}.json`);
-    if (existsSync33(p))
+    const p = join28(this.archiveDir, `${id}.json`);
+    if (existsSync34(p))
       rmSync(p, { force: true });
   }
   listAll() {
@@ -18730,13 +18967,13 @@ class PlanStore {
       this.clearActive();
       return "active";
     }
-    const draftPath = join27(this.draftsDir, `${id}.json`);
-    if (existsSync33(draftPath)) {
+    const draftPath = join28(this.draftsDir, `${id}.json`);
+    if (existsSync34(draftPath)) {
       rmSync(draftPath, { force: true });
       return "draft";
     }
-    const archivedPath = join27(this.archiveDir, `${id}.json`);
-    if (existsSync33(archivedPath)) {
+    const archivedPath = join28(this.archiveDir, `${id}.json`);
+    if (existsSync34(archivedPath)) {
       rmSync(archivedPath, { force: true });
       return "archived";
     }
@@ -19772,7 +20009,7 @@ var init_plan_tool = __esm(() => {
 });
 
 // src/modules/execution/module.ts
-import { existsSync as existsSync34, readFileSync as readFileSync19 } from "fs";
+import { existsSync as existsSync35, readFileSync as readFileSync20 } from "fs";
 import { resolve as resolve19 } from "path";
 
 class ExecutionModule {
@@ -20106,7 +20343,7 @@ class ExecutionModule {
         "poetry.lock",
         "requirements.txt"
       ];
-      const hasLockFile = lockFiles.some((f) => existsSync34(resolve19(this.baseDir, f)));
+      const hasLockFile = lockFiles.some((f) => existsSync35(resolve19(this.baseDir, f)));
       if (!hasLockFile) {
         if (contextManager) {
           const hints = this.state.depsGateHints.get(step.id) || 0;
@@ -20138,7 +20375,7 @@ class ExecutionModule {
         if (!r)
           continue;
         try {
-          const content = readFileSync19(r, "utf-8");
+          const content = readFileSync20(r, "utf-8");
           if (content.trim().length < 10) {
             emptyFiles.push(r);
           }
@@ -20246,9 +20483,9 @@ var init_module = __esm(() => {
 });
 
 // src/modules/security/session-encryption.ts
-import { readFileSync as readFileSync20, writeFileSync as writeFileSync11, existsSync as existsSync35, readdirSync as readdirSync11, unlinkSync as unlinkSync4 } from "fs";
-import { join as join28 } from "path";
-import { homedir as homedir8 } from "os";
+import { readFileSync as readFileSync21, writeFileSync as writeFileSync12, existsSync as existsSync36, readdirSync as readdirSync12, unlinkSync as unlinkSync4 } from "fs";
+import { join as join29 } from "path";
+import { homedir as homedir9 } from "os";
 
 class SessionFileEncryptor {
   config;
@@ -20256,7 +20493,7 @@ class SessionFileEncryptor {
   constructor(config) {
     this.config = { ...DEFAULT_SESSION_ENCRYPTION, ...config };
     this.encryptor = new ConfigEncryptor({
-      keyPath: config?.keyPath || join28(homedir8(), ".mma", ".session-encryption-key")
+      keyPath: config?.keyPath || join29(homedir9(), ".mma", ".session-encryption-key")
     });
   }
   isEnabled() {
@@ -20301,23 +20538,23 @@ class SessionFileEncryptor {
     return lines.map((line) => this.decryptFileContent(line));
   }
   readSessionFile(filePath) {
-    const content = readFileSync20(filePath, "utf8");
+    const content = readFileSync21(filePath, "utf8");
     return this.decryptFileContent(content);
   }
   writeSessionFile(filePath, content) {
     const encrypted = this.encryptFileContent(content);
-    writeFileSync11(filePath, encrypted, "utf8");
+    writeFileSync12(filePath, encrypted, "utf8");
   }
   readSessionJSON(filePath) {
-    const content = readFileSync20(filePath, "utf8");
+    const content = readFileSync21(filePath, "utf8");
     return this.decryptJSON(content);
   }
   writeSessionJSON(filePath, obj) {
     const content = this.encryptJSON(obj);
-    writeFileSync11(filePath, content, "utf8");
+    writeFileSync12(filePath, content, "utf8");
   }
   readSessionJSONL(filePath) {
-    const content = readFileSync20(filePath, "utf8");
+    const content = readFileSync21(filePath, "utf8");
     const lines = content.split(`
 `).filter((line) => line.trim());
     const decryptedLines = this.decryptJSONL(lines);
@@ -20331,7 +20568,7 @@ class SessionFileEncryptor {
   }
   appendToSessionJSONL(filePath, obj) {
     const encryptedLine = this.encryptFileContent(JSON.stringify(obj));
-    writeFileSync11(filePath, encryptedLine + `
+    writeFileSync12(filePath, encryptedLine + `
 `, {
       flag: "a",
       encoding: "utf8"
@@ -20340,14 +20577,14 @@ class SessionFileEncryptor {
   encryptSessionDirectory(sessionDir) {
     if (!this.config.enabled)
       return;
-    const files = readdirSync11(sessionDir);
+    const files = readdirSync12(sessionDir);
     for (const file of files) {
-      const filePath = join28(sessionDir, file);
-      if (existsSync35(filePath) && !file.endsWith(".enc")) {
+      const filePath = join29(sessionDir, file);
+      if (existsSync36(filePath) && !file.endsWith(".enc")) {
         try {
-          const content = readFileSync20(filePath, "utf8");
+          const content = readFileSync21(filePath, "utf8");
           const encrypted = this.encryptFileContent(content);
-          writeFileSync11(filePath + ".enc", encrypted, "utf8");
+          writeFileSync12(filePath + ".enc", encrypted, "utf8");
           unlinkSync4(filePath);
         } catch {}
       }
@@ -20356,15 +20593,15 @@ class SessionFileEncryptor {
   decryptSessionDirectory(sessionDir) {
     if (!this.config.enabled)
       return;
-    const files = readdirSync11(sessionDir);
+    const files = readdirSync12(sessionDir);
     for (const file of files) {
       if (file.endsWith(".enc")) {
-        const encFilePath = join28(sessionDir, file);
+        const encFilePath = join29(sessionDir, file);
         const decFilePath = encFilePath.slice(0, -4);
         try {
-          const content = readFileSync20(encFilePath, "utf8");
+          const content = readFileSync21(encFilePath, "utf8");
           const decrypted = this.decryptFileContent(content);
-          writeFileSync11(decFilePath, decrypted, "utf8");
+          writeFileSync12(decFilePath, decrypted, "utf8");
           unlinkSync4(encFilePath);
         } catch {}
       }
@@ -20384,15 +20621,15 @@ var init_session_encryption = __esm(() => {
 
 // src/modules/session/store.ts
 import {
-  existsSync as existsSync36,
-  mkdirSync as mkdirSync15,
-  readdirSync as readdirSync12,
-  readFileSync as readFileSync21,
+  existsSync as existsSync37,
+  mkdirSync as mkdirSync16,
+  readdirSync as readdirSync13,
+  readFileSync as readFileSync22,
   rmSync as rmSync2,
-  writeFileSync as writeFileSync12,
+  writeFileSync as writeFileSync13,
   appendFileSync as appendFileSync6
 } from "fs";
-import { join as join29 } from "path";
+import { join as join30 } from "path";
 import { gzipSync } from "zlib";
 
 class SessionStore {
@@ -20406,7 +20643,7 @@ class SessionStore {
     }
   }
   getSessionDir(id) {
-    return join29(this.baseDir, id);
+    return join30(this.baseDir, id);
   }
   updateEncryption(config) {
     if (config?.enabled) {
@@ -20419,32 +20656,32 @@ class SessionStore {
     return this.encryptor?.isEnabled() ?? false;
   }
   init() {
-    mkdirSync15(this.baseDir, { recursive: true, mode: 448 });
+    mkdirSync16(this.baseDir, { recursive: true, mode: 448 });
   }
   sessionDir(id) {
-    return join29(this.baseDir, id);
+    return join30(this.baseDir, id);
   }
   metaPath(id) {
-    return join29(this.sessionDir(id), "meta.json");
+    return join30(this.sessionDir(id), "meta.json");
   }
   historyPath(id) {
-    return join29(this.sessionDir(id), "history.jsonl");
+    return join30(this.sessionDir(id), "history.jsonl");
   }
   sessionLogPath(id) {
-    return join29(this.sessionDir(id), "session.jsonl");
+    return join30(this.sessionDir(id), "session.jsonl");
   }
   sessionExists(id) {
-    return existsSync36(this.metaPath(id));
+    return existsSync37(this.metaPath(id));
   }
   saveMeta(id, meta) {
     this._metaCache.set(id, meta);
     const dir = this.sessionDir(id);
-    mkdirSync15(dir, { recursive: true, mode: 448 });
+    mkdirSync16(dir, { recursive: true, mode: 448 });
     const content = JSON.stringify(meta, null, 2);
     if (this.encryptor) {
-      writeFileSync12(this.metaPath(id), this.encryptor.encryptFileContent(content), { encoding: "utf-8", mode: 384 });
+      writeFileSync13(this.metaPath(id), this.encryptor.encryptFileContent(content), { encoding: "utf-8", mode: 384 });
     } else {
-      writeFileSync12(this.metaPath(id), content, { encoding: "utf-8", mode: 384 });
+      writeFileSync13(this.metaPath(id), content, { encoding: "utf-8", mode: 384 });
     }
   }
   loadMeta(id) {
@@ -20452,10 +20689,10 @@ class SessionStore {
     if (cached)
       return cached;
     const path = this.metaPath(id);
-    if (!existsSync36(path))
+    if (!existsSync37(path))
       return null;
     try {
-      const raw = readFileSync21(path, "utf-8");
+      const raw = readFileSync22(path, "utf-8");
       const content = this.encryptor ? this.encryptor.decryptFileContent(raw) : raw;
       const meta = JSON.parse(content);
       this._metaCache.set(id, meta);
@@ -20466,7 +20703,7 @@ class SessionStore {
   }
   appendMessage(id, msg) {
     const dir = this.sessionDir(id);
-    mkdirSync15(dir, { recursive: true, mode: 448 });
+    mkdirSync16(dir, { recursive: true, mode: 448 });
     const line = JSON.stringify(msg);
     if (this.encryptor?.isEnabled()) {
       appendFileSync6(this.historyPath(id), this.encryptor.encryptFileContent(line) + `
@@ -20484,10 +20721,10 @@ class SessionStore {
   }
   loadHistory(id) {
     const path = this.historyPath(id);
-    if (!existsSync36(path))
+    if (!existsSync37(path))
       return [];
     try {
-      const raw = readFileSync21(path, "utf-8");
+      const raw = readFileSync22(path, "utf-8");
       const lines = raw.split(`
 `).filter(Boolean);
       const parseLine = (line) => {
@@ -20513,7 +20750,7 @@ class SessionStore {
   }
   appendSessionLog(id, entry) {
     const dir = this.sessionDir(id);
-    mkdirSync15(dir, { recursive: true, mode: 448 });
+    mkdirSync16(dir, { recursive: true, mode: 448 });
     const line = JSON.stringify(entry);
     if (this.encryptor?.isEnabled()) {
       appendFileSync6(this.sessionLogPath(id), this.encryptor.encryptFileContent(line) + `
@@ -20525,10 +20762,10 @@ class SessionStore {
   }
   loadSessionLog(id) {
     const path = this.sessionLogPath(id);
-    if (!existsSync36(path))
+    if (!existsSync37(path))
       return [];
     try {
-      const raw = readFileSync21(path, "utf-8");
+      const raw = readFileSync22(path, "utf-8");
       const lines = raw.split(`
 `).filter(Boolean);
       const parseLine = (line) => {
@@ -20553,9 +20790,9 @@ class SessionStore {
     }
   }
   listSessions() {
-    if (!existsSync36(this.baseDir))
+    if (!existsSync37(this.baseDir))
       return [];
-    const entries = readdirSync12(this.baseDir, { withFileTypes: true });
+    const entries = readdirSync13(this.baseDir, { withFileTypes: true });
     const sessions = [];
     for (const entry of entries) {
       if (entry.isDirectory()) {
@@ -20570,7 +20807,7 @@ class SessionStore {
   deleteSession(id) {
     this._metaCache.delete(id);
     const dir = this.sessionDir(id);
-    if (existsSync36(dir)) {
+    if (existsSync37(dir)) {
       rmSync2(dir, { recursive: true, force: true });
     }
   }
@@ -20582,11 +20819,11 @@ class SessionStore {
       const updatedAt = new Date(session2.updatedAt);
       if (updatedAt < thirtyDaysAgo) {
         const historyPath = this.historyPath(session2.id);
-        if (existsSync36(historyPath)) {
-          const content = readFileSync21(historyPath, "utf-8");
+        if (existsSync37(historyPath)) {
+          const content = readFileSync22(historyPath, "utf-8");
           const compressed = gzipSync(content);
-          const gzPath = join29(this.baseDir, `${session2.id}.jsonl.gz`);
-          writeFileSync12(gzPath, compressed);
+          const gzPath = join30(this.baseDir, `${session2.id}.jsonl.gz`);
+          writeFileSync13(gzPath, compressed);
           rmSync2(historyPath);
         }
       }
@@ -20795,9 +21032,9 @@ class ProfileCompressor {
 }
 
 // src/modules/user-profile/profile.ts
-import { readFileSync as readFileSync22, writeFileSync as writeFileSync13, existsSync as existsSync37, mkdirSync as mkdirSync16 } from "fs";
-import { join as join30 } from "path";
-import { homedir as homedir9, hostname, platform as platform7, type } from "os";
+import { readFileSync as readFileSync23, writeFileSync as writeFileSync14, existsSync as existsSync38, mkdirSync as mkdirSync17 } from "fs";
+import { join as join31 } from "path";
+import { homedir as homedir10, hostname, platform as platform7, type } from "os";
 import { env } from "process";
 
 class UserProfile {
@@ -20813,24 +21050,24 @@ class UserProfile {
       os: `${type()} ${hostname()}`,
       hostname: hostname(),
       shell: env.SHELL || env.ComSpec || "unknown",
-      home: homedir9(),
+      home: homedir10(),
       nodeVersion: process.version,
       preferences: { ...this.preferences }
     };
     return this.info;
   }
   save() {
-    if (!existsSync37(this.profileDir)) {
-      mkdirSync16(this.profileDir, { recursive: true });
+    if (!existsSync38(this.profileDir)) {
+      mkdirSync17(this.profileDir, { recursive: true });
     }
-    writeFileSync13(join30(this.profileDir, "profile.json"), JSON.stringify({ ...this.info, preferences: this.preferences }, null, 2), "utf-8");
+    writeFileSync14(join31(this.profileDir, "profile.json"), JSON.stringify({ ...this.info, preferences: this.preferences }, null, 2), "utf-8");
   }
   load() {
-    const path = join30(this.profileDir, "profile.json");
-    if (!existsSync37(path))
+    const path = join31(this.profileDir, "profile.json");
+    if (!existsSync38(path))
       return null;
     try {
-      const data = JSON.parse(readFileSync22(path, "utf-8"));
+      const data = JSON.parse(readFileSync23(path, "utf-8"));
       this.info = {
         platform: data.platform,
         os: data.os,
@@ -20865,21 +21102,21 @@ class UserProfile {
 var init_profile = () => {};
 
 // src/modules/skills/loader.ts
-import { readdirSync as readdirSync13, readFileSync as readFileSync23, existsSync as existsSync38, statSync as statSync7 } from "fs";
-import { join as join31 } from "path";
+import { readdirSync as readdirSync14, readFileSync as readFileSync24, existsSync as existsSync39, statSync as statSync7 } from "fs";
+import { join as join32 } from "path";
 
 class SkillsLoader {
   loadFromDir(dirPath) {
-    if (!existsSync38(dirPath))
+    if (!existsSync39(dirPath))
       return [];
     const skills = [];
     this.scanDir(dirPath, skills);
     return skills;
   }
   scanDir(dirPath, skills) {
-    const entries = readdirSync13(dirPath);
+    const entries = readdirSync14(dirPath);
     for (const entry of entries) {
-      const fullPath = join31(dirPath, entry);
+      const fullPath = join32(dirPath, entry);
       const stat = statSync7(fullPath);
       if (stat.isDirectory()) {
         this.scanDir(fullPath, skills);
@@ -20887,7 +21124,7 @@ class SkillsLoader {
       }
       if (!entry.endsWith(".md") && !entry.endsWith(".skill.md"))
         continue;
-      const content = readFileSync23(fullPath, "utf-8");
+      const content = readFileSync24(fullPath, "utf-8");
       const parsed = this.parseSkillFile(content, fullPath);
       if (parsed)
         skills.push(parsed);
@@ -21524,7 +21761,7 @@ var init_check_tool = __esm(() => {
 });
 
 // src/modules/lsp/module.ts
-import { existsSync as existsSync39 } from "fs";
+import { existsSync as existsSync40 } from "fs";
 import { relative as relative4, resolve as resolve22 } from "path";
 
 class LspModule {
@@ -21579,7 +21816,7 @@ class LspModule {
         if (!filePath)
           return;
         const fullPath = resolve22(_ctx.baseDir, filePath);
-        if (!existsSync39(fullPath))
+        if (!existsSync40(fullPath))
           return;
         const serverConfig = getServerForFile(fullPath, self.config);
         if (!serverConfig)
@@ -21671,7 +21908,7 @@ ${items}`;
         })
       };
     }
-    if (!existsSync39(resolved)) {
+    if (!existsSync40(resolved)) {
       return { success: false, output: t("lsp.check_notfound", { path }) };
     }
     const files = await collectCheckFiles(resolved, this.config);
@@ -21771,8 +22008,8 @@ var init_lsp = __esm(() => {
 });
 
 // src/modules/lsp/startup-check.ts
-import { existsSync as existsSync40 } from "fs";
-import { join as join32 } from "path";
+import { existsSync as existsSync41 } from "fs";
+import { join as join33 } from "path";
 import { spawn as spawn8 } from "child_process";
 async function runStartupHealthCheck(config, baseDir, deps = {}) {
   if (!config.enabled)
@@ -21799,7 +22036,7 @@ ${result.lines.join(`
 }
 async function runCheck(config, baseDir, deps) {
   const projectRoot = findProjectRoot(baseDir, baseDir, ["tsconfig.json", "package.json"]);
-  if (existsSync40(join32(projectRoot, "tsconfig.json"))) {
+  if (existsSync41(join33(projectRoot, "tsconfig.json"))) {
     const runTsc = deps.runTsc ?? runTscDefault;
     const errors = await runTsc(projectRoot, STARTUP_CHECK_TIMEOUT_MS);
     if (errors.length === 0)
@@ -21899,8 +22136,8 @@ var init_startup_check = __esm(() => {
 });
 
 // src/modules/indexer/walker.ts
-import { readdirSync as readdirSync14, readFileSync as readFileSync24, statSync as statSync8, existsSync as existsSync41, watch } from "fs";
-import { join as join33, relative as relative5, extname as extname5 } from "path";
+import { readdirSync as readdirSync15, readFileSync as readFileSync25, statSync as statSync8, existsSync as existsSync42, watch } from "fs";
+import { join as join34, relative as relative5, extname as extname5 } from "path";
 
 class Indexer {
   baseDir;
@@ -21927,18 +22164,18 @@ class Indexer {
     let totalSize = 0;
     let count = 0;
     const walkDir2 = (dir) => {
-      if (!existsSync41(dir))
+      if (!existsSync42(dir))
         return;
       let entries;
       try {
-        entries = readdirSync14(dir);
+        entries = readdirSync15(dir);
       } catch {
         return;
       }
       for (const entry of entries) {
         if (count >= this.MAX_FILES)
           return;
-        const fullPath = join33(dir, entry);
+        const fullPath = join34(dir, entry);
         const relPath = relative5(this.baseDir, fullPath);
         const stat2 = statSync8(fullPath);
         if (stat2.isDirectory()) {
@@ -21949,7 +22186,7 @@ class Indexer {
           const ext = extname5(entry).toLowerCase();
           const language = LANGUAGES[ext];
           if (language) {
-            const content = readFileSync24(fullPath, "utf-8");
+            const content = readFileSync25(fullPath, "utf-8");
             const exports = this.extractExports(content, language);
             files.push({ path: relPath, language, exports, size: stat2.size });
             totalSize += stat2.size;
@@ -22001,22 +22238,22 @@ var init_walker = __esm(() => {
 });
 
 // src/modules/indexer/cache.ts
-import { readFileSync as readFileSync25, writeFileSync as writeFileSync14, existsSync as existsSync42, mkdirSync as mkdirSync17, rmSync as rmSync3 } from "fs";
-import { join as join34 } from "path";
+import { readFileSync as readFileSync26, writeFileSync as writeFileSync15, existsSync as existsSync43, mkdirSync as mkdirSync18, rmSync as rmSync3 } from "fs";
+import { join as join35 } from "path";
 
 class IndexCache {
   cachePath;
   cache = null;
   constructor(cacheDir) {
-    this.cachePath = join34(cacheDir, "index-cache.json");
+    this.cachePath = join35(cacheDir, "index-cache.json");
   }
   load() {
     if (this.cache)
       return this.cache;
-    if (!existsSync42(this.cachePath))
+    if (!existsSync43(this.cachePath))
       return null;
     try {
-      this.cache = JSON.parse(readFileSync25(this.cachePath, "utf-8"));
+      this.cache = JSON.parse(readFileSync26(this.cachePath, "utf-8"));
       return this.cache;
     } catch {
       return null;
@@ -22024,14 +22261,14 @@ class IndexCache {
   }
   save(result) {
     this.cache = result;
-    const dir = join34(this.cachePath, "..");
-    if (!existsSync42(dir))
-      mkdirSync17(dir, { recursive: true });
-    writeFileSync14(this.cachePath, JSON.stringify(result), "utf-8");
+    const dir = join35(this.cachePath, "..");
+    if (!existsSync43(dir))
+      mkdirSync18(dir, { recursive: true });
+    writeFileSync15(this.cachePath, JSON.stringify(result), "utf-8");
   }
   invalidate() {
     this.cache = null;
-    if (existsSync42(this.cachePath)) {
+    if (existsSync43(this.cachePath)) {
       try {
         rmSync3(this.cachePath);
       } catch {}
@@ -22041,11 +22278,11 @@ class IndexCache {
 var init_cache = () => {};
 
 // src/modules/indexer/project-profile.ts
-import { readFileSync as readFileSync26, existsSync as existsSync43 } from "fs";
-import { join as join35 } from "path";
+import { readFileSync as readFileSync27, existsSync as existsSync44 } from "fs";
+import { join as join36 } from "path";
 function detectManifest(baseDir) {
   for (const manifest of MANIFEST_ORDER) {
-    if (existsSync43(join35(baseDir, manifest)))
+    if (existsSync44(join36(baseDir, manifest)))
       return manifest;
   }
   return null;
@@ -22062,7 +22299,7 @@ function cleanDependency(entry) {
 }
 function readPackageJson(baseDir) {
   try {
-    const raw = JSON.parse(readFileSync26(join35(baseDir, "package.json"), "utf-8"));
+    const raw = JSON.parse(readFileSync27(join36(baseDir, "package.json"), "utf-8"));
     if (!raw || typeof raw !== "object")
       return null;
     const profile = {
@@ -22086,7 +22323,7 @@ function readPackageJson(baseDir) {
 }
 function readPyproject(baseDir) {
   try {
-    const content = readFileSync26(join35(baseDir, "pyproject.toml"), "utf-8");
+    const content = readFileSync27(join36(baseDir, "pyproject.toml"), "utf-8");
     const profile = { runtime: "python", deps: [], devDeps: [], scripts: {} };
     const nameMatch = content.match(/^\s*name\s*=\s*"([^"]+)"/m);
     if (nameMatch)
@@ -22102,7 +22339,7 @@ function readPyproject(baseDir) {
 }
 function readCargo(baseDir) {
   try {
-    const content = readFileSync26(join35(baseDir, "Cargo.toml"), "utf-8");
+    const content = readFileSync27(join36(baseDir, "Cargo.toml"), "utf-8");
     const profile = { runtime: "rust", deps: [], devDeps: [], scripts: {} };
     const nameMatch = content.match(/^\s*name\s*=\s*"([^"]+)"/m);
     if (nameMatch)
@@ -22126,7 +22363,7 @@ function readCargo(baseDir) {
 }
 function readGoMod(baseDir) {
   try {
-    const content = readFileSync26(join35(baseDir, "go.mod"), "utf-8");
+    const content = readFileSync27(join36(baseDir, "go.mod"), "utf-8");
     const profile = { runtime: "go", deps: [], devDeps: [], scripts: {} };
     const moduleMatch = content.match(/^module\s+(\S+)/m);
     if (moduleMatch)
@@ -22144,7 +22381,7 @@ function readGoMod(baseDir) {
 }
 function readRequirements(baseDir) {
   try {
-    const content = readFileSync26(join35(baseDir, "requirements.txt"), "utf-8");
+    const content = readFileSync27(join36(baseDir, "requirements.txt"), "utf-8");
     const profile = { runtime: "python", deps: [], devDeps: [], scripts: {} };
     for (const line of content.split(`
 `)) {
@@ -22602,8 +22839,8 @@ var init_mcp = __esm(() => {
 });
 
 // src/modules/memory/module.ts
-import { homedir as homedir10 } from "os";
-import { join as join36 } from "path";
+import { homedir as homedir11 } from "os";
+import { join as join37 } from "path";
 
 class MemoryModule {
   name = "memory";
@@ -22612,7 +22849,7 @@ class MemoryModule {
     if (storeOrDir instanceof MemoryStore) {
       this.store = storeOrDir;
     } else {
-      const dir = storeOrDir || join36(homedir10(), ".mma", "memory");
+      const dir = storeOrDir || join37(homedir11(), ".mma", "memory");
       this.store = new MemoryStore(dir);
     }
   }
@@ -22698,16 +22935,16 @@ var init_module8 = __esm(() => {
 });
 
 // src/core/version.ts
-import { existsSync as existsSync44, readFileSync as readFileSync27 } from "fs";
-import { join as join37, dirname as dirname13 } from "path";
+import { existsSync as existsSync45, readFileSync as readFileSync28 } from "fs";
+import { join as join38, dirname as dirname13 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 function readMmaVersion() {
   const here = dirname13(fileURLToPath2(import.meta.url));
-  const candidates = [join37(here, "..", "..", "package.json"), join37(here, "..", "package.json")];
+  const candidates = [join38(here, "..", "..", "package.json"), join38(here, "..", "package.json")];
   for (const p of candidates) {
-    if (existsSync44(p)) {
+    if (existsSync45(p)) {
       try {
-        const raw = JSON.parse(readFileSync27(p, "utf8"));
+        const raw = JSON.parse(readFileSync28(p, "utf8"));
         if (raw.version)
           return raw.version;
       } catch {}
@@ -22718,21 +22955,21 @@ function readMmaVersion() {
 var init_version = () => {};
 
 // src/core/environment.ts
-import { existsSync as existsSync45, readFileSync as readFileSync28, readdirSync as readdirSync15 } from "fs";
+import { existsSync as existsSync46, readFileSync as readFileSync29, readdirSync as readdirSync16 } from "fs";
 import { spawnSync as spawnSync2 } from "child_process";
 import { createRequire as createRequire2 } from "module";
-import { join as join38, dirname as dirname14 } from "path";
+import { join as join39, dirname as dirname14 } from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
-import { arch, homedir as homedir11, hostname as hostname2, platform as platform9, release } from "os";
+import { arch, homedir as homedir12, hostname as hostname2, platform as platform9, release } from "os";
 import { env as env2 } from "process";
 function readEngineRequirement() {
   const here = dirname14(fileURLToPath3(import.meta.url));
-  const candidates = [join38(here, "..", "..", "package.json"), join38(here, "..", "package.json")];
+  const candidates = [join39(here, "..", "..", "package.json"), join39(here, "..", "package.json")];
   for (const p of candidates) {
-    if (!existsSync45(p))
+    if (!existsSync46(p))
       continue;
     try {
-      const raw = JSON.parse(readFileSync28(p, "utf8"));
+      const raw = JSON.parse(readFileSync29(p, "utf8"));
       if (raw.engines?.node)
         return String(raw.engines.node);
     } catch {}
@@ -22795,7 +23032,7 @@ function toolVersion(cmd) {
 function playwrightBrowsersDir() {
   if (process.env.PLAYWRIGHT_BROWSERS_PATH)
     return process.env.PLAYWRIGHT_BROWSERS_PATH;
-  return process.platform === "win32" ? join38(homedir11(), "AppData", "Local", "ms-playwright") : join38(homedir11(), ".cache", "ms-playwright");
+  return process.platform === "win32" ? join39(homedir12(), "AppData", "Local", "ms-playwright") : join39(homedir12(), ".cache", "ms-playwright");
 }
 function playwrightInfo() {
   let installed = false;
@@ -22804,15 +23041,15 @@ function playwrightInfo() {
   try {
     const require2 = createRequire2(import.meta.url);
     const pkgPath = require2.resolve("playwright/package.json");
-    installed = existsSync45(pkgPath);
-    version = JSON.parse(readFileSync28(pkgPath, "utf8")).version || "";
+    installed = existsSync46(pkgPath);
+    version = JSON.parse(readFileSync29(pkgPath, "utf8")).version || "";
   } catch {
     installed = false;
   }
   let browsersInstalled = false;
   try {
-    if (existsSync45(browsersDir)) {
-      browsersInstalled = readdirSync15(browsersDir).some((d) => /chrom/i.test(d));
+    if (existsSync46(browsersDir)) {
+      browsersInstalled = readdirSync16(browsersDir).some((d) => /chrom/i.test(d));
     }
   } catch {
     browsersInstalled = false;
@@ -22874,7 +23111,7 @@ function collectEnvironment(opts) {
       release: release(),
       hostname: hostname2(),
       shell: env2.SHELL || env2.ComSpec || "unknown",
-      home: homedir11(),
+      home: homedir12(),
       cwd: process.cwd()
     },
     paths: { configDir: opts.configDir, baseDir: opts.baseDir || process.cwd() },
@@ -22905,9 +23142,9 @@ __export(exports_bootstrap, {
   buildSystemInfo: () => buildSystemInfo,
   bootstrap: () => bootstrap
 });
-import { homedir as homedir12 } from "os";
-import { join as join39, resolve as resolve23 } from "path";
-import { existsSync as existsSync46, readFileSync as readFileSync29, writeFileSync as writeFileSync15 } from "fs";
+import { homedir as homedir13 } from "os";
+import { join as join40, resolve as resolve23 } from "path";
+import { existsSync as existsSync47, readFileSync as readFileSync30, writeFileSync as writeFileSync16 } from "fs";
 function buildSystemInfo(config, baseDir, profileCompressed) {
   const now = new Date().toISOString().replace("T", " ").slice(0, 19);
   const isWin = profileCompressed.toLowerCase().includes("win32");
@@ -22960,9 +23197,9 @@ function buildSystemInfo(config, baseDir, profileCompressed) {
 `);
 }
 async function bootstrap(configDir, projectDir, noAgentsMd, exitOnComplete) {
-  const dir = configDir || join39(homedir12(), ".mma");
-  const projectConfigPath = projectDir ? join39(projectDir, ".mmrc") : join39(process.cwd(), ".mmrc");
-  const config = loadConfig({ configDir: dir, projectConfigPath });
+  const dir = configDir || join40(homedir13(), ".mma");
+  const projectConfigPath = projectDir ? join40(projectDir, ".mmrc") : join40(process.cwd(), ".mmrc");
+  const { config, legacyDetected } = loadConfig({ configDir: dir, projectConfigPath });
   setLocale(config.locale);
   try {
     const { globalAuditNotifier: globalAuditNotifier2 } = await Promise.resolve().then(() => (init_audit_notifier(), exports_audit_notifier));
@@ -22971,7 +23208,7 @@ async function bootstrap(configDir, projectDir, noAgentsMd, exitOnComplete) {
     }
   } catch {}
   const logger = new Logger(config.logLevel);
-  logger.setLogDir(join39(dir, "logs"));
+  logger.setLogDir(join40(dir, "logs"));
   logger.debug("MMA bootstrap", {
     version: config.version,
     model: config.model
@@ -22993,7 +23230,7 @@ async function bootstrap(configDir, projectDir, noAgentsMd, exitOnComplete) {
       logger.info(`Model ${config.model} loaded in ${loadResult.loadTime}s`);
     }
   }
-  const profile = new UserProfile(join39(dir));
+  const profile = new UserProfile(join40(dir));
   profile.load() || profile.collect();
   profile.save();
   const providerManager = new ProviderManager(config.provider, {
@@ -23019,7 +23256,7 @@ async function bootstrap(configDir, projectDir, noAgentsMd, exitOnComplete) {
   for (const warning of envReport.warnings) {
     logger.warn(warning);
   }
-  const projectMapCacheDir = join39(baseDir, ".mma");
+  const projectMapCacheDir = join40(baseDir, ".mma");
   const indexerModule = new IndexerModule({
     baseDir,
     cacheDir: projectMapCacheDir
@@ -23030,9 +23267,9 @@ async function bootstrap(configDir, projectDir, noAgentsMd, exitOnComplete) {
     logger.warn(`Project indexing failed: ${err.message}`);
   }
   const skillsLoader = new SkillsLoader;
-  const builtinDir = join39(import.meta.dirname, "skills", "builtin");
-  const globalDir = join39(homedir12(), ".agents", "skills");
-  const projectSkillsDir = join39(baseDir, ".mma", "skills");
+  const builtinDir = join40(import.meta.dirname, "skills", "builtin");
+  const globalDir = join40(homedir13(), ".agents", "skills");
+  const projectSkillsDir = join40(baseDir, ".mma", "skills");
   const availableSkills = skillsLoader.loadFromAllSources(builtinDir, globalDir, projectSkillsDir);
   const skillsBudget = Math.floor(config.contextWindow * config.skills.budget);
   const skillsModule = new SkillsModule(availableSkills, skillsBudget);
@@ -23048,11 +23285,11 @@ async function bootstrap(configDir, projectDir, noAgentsMd, exitOnComplete) {
     essential: true,
     estimatedTokens: Math.ceil(systemInfoContent.length / 4)
   };
-  const agentsMdGlobal = join39(dir, "AGENTS.md");
-  if (!existsSync46(agentsMdGlobal)) {
-    writeFileSync15(agentsMdGlobal, "", "utf-8");
+  const agentsMdGlobal = join40(dir, "AGENTS.md");
+  if (!existsSync47(agentsMdGlobal)) {
+    writeFileSync16(agentsMdGlobal, "", "utf-8");
   }
-  const sessionDir = join39(dir, "sessions");
+  const sessionDir = join40(dir, "sessions");
   const sessionStore = new SessionStore(sessionDir);
   sessionStore.init();
   const sessionManager = new SessionManager(sessionStore, {
@@ -23117,10 +23354,7 @@ async function bootstrap(configDir, projectDir, noAgentsMd, exitOnComplete) {
   const hallucinationDetector = new HallucinationDetector(baseDir, llmProvider);
   const moduleRegistry = new ModuleRegistry;
   const execModule = new ExecutionModule(baseDir, config.stuckThreshold, config.errorWebSearch?.threshold ?? 5);
-  const activeMeta = sessionManager.getActiveMeta();
-  if (activeMeta && activeMeta.messageCount > 0) {
-    execModule.restorePlan();
-  }
+  execModule.restorePlan();
   moduleRegistry.register(execModule);
   execModule.setHallucinationDetector(hallucinationDetector);
   const sessionModule = new SessionModule(sessionManager);
@@ -23129,7 +23363,7 @@ async function bootstrap(configDir, projectDir, noAgentsMd, exitOnComplete) {
   const mcpModule = new MCPModule(config);
   await mcpModule.initialize();
   moduleRegistry.register(mcpModule);
-  const memoryStore = new MemoryStore(join39(dir, "memory"));
+  const memoryStore = new MemoryStore(join40(dir, "memory"));
   const memoryModule = new MemoryModule(memoryStore);
   moduleRegistry.register(memoryModule);
   if (config.browser.enabled) {
@@ -23183,8 +23417,8 @@ async function bootstrap(configDir, projectDir, noAgentsMd, exitOnComplete) {
   pluginManager.register(plugin);
   pluginManager.register(plugin2);
   const pluginLoader = new PluginLoader;
-  const globalPluginsDir = join39(homedir12(), ".mma", "plugins");
-  const projectPluginsDir = join39(baseDir, ".mma", "plugins");
+  const globalPluginsDir = join40(homedir13(), ".mma", "plugins");
+  const projectPluginsDir = join40(baseDir, ".mma", "plugins");
   const mmaVersion = readMmaVersion();
   pluginLoader.loadFromDir(globalPluginsDir, pluginManager, logger, {
     source: "global",
@@ -23210,13 +23444,13 @@ async function bootstrap(configDir, projectDir, noAgentsMd, exitOnComplete) {
   const skipAgentsMd = noAgentsMd === true;
   if (!skipAgentsMd) {
     const agentsMdCandidates = [
-      join39(baseDir, "AGENTS.md"),
-      join39(baseDir, ".mma", "AGENTS.md"),
-      join39(dir, "AGENTS.md")
+      join40(baseDir, "AGENTS.md"),
+      join40(baseDir, ".mma", "AGENTS.md"),
+      join40(dir, "AGENTS.md")
     ];
     for (const p of agentsMdCandidates) {
-      if (existsSync46(p)) {
-        const content = readFileSync29(p, "utf-8").trim();
+      if (existsSync47(p)) {
+        const content = readFileSync30(p, "utf-8").trim();
         if (content) {
           agentsMdBlocks.push({
             content,
@@ -23292,7 +23526,8 @@ async function bootstrap(configDir, projectDir, noAgentsMd, exitOnComplete) {
     configDir: dir,
     baseDir,
     noAgentsMd: skipAgentsMd,
-    envReport
+    envReport,
+    legacyDetected
   };
 }
 var init_bootstrap = __esm(() => {
@@ -24020,8 +24255,16 @@ async function runSetup(externalRl) {
     securityFlagsBlock = (await ask(rl, t("setup.security_flags_block"), "n")).toLowerCase() === "y";
     securityPathsDeny = (await ask(rl, t("setup.security_paths_deny"), "Y")).toLowerCase() !== "n";
   }
-  if (ownRl)
+  if (ownRl) {
     rl.close();
+    process.stdin.removeAllListeners("data");
+    process.stdin.removeAllListeners("keypress");
+    if (typeof process.stdin.setRawMode === "function") {
+      process.stdin.setRawMode(false);
+    }
+    process.stdin.pause();
+    process.stdin.resume();
+  }
   const answers = {
     provider,
     apiBase,
@@ -24081,21 +24324,21 @@ __export(exports_manifest, {
   getCertMark: () => getCertMark,
   MANIFEST_PATH: () => MANIFEST_PATH
 });
-import { existsSync as existsSync47, readFileSync as readFileSync30, mkdirSync as mkdirSync18, writeFileSync as writeFileSync16 } from "fs";
-import { homedir as homedir14 } from "os";
-import { join as join41 } from "path";
+import { existsSync as existsSync48, readFileSync as readFileSync31, mkdirSync as mkdirSync19, writeFileSync as writeFileSync17 } from "fs";
+import { homedir as homedir15 } from "os";
+import { join as join42 } from "path";
 function readManifest(path = MANIFEST_PATH) {
   try {
-    if (existsSync47(path)) {
-      const raw = JSON.parse(readFileSync30(path, "utf-8"));
+    if (existsSync48(path)) {
+      const raw = JSON.parse(readFileSync31(path, "utf-8"));
       return { version: 1, certifications: raw.certifications ?? [] };
     }
   } catch {}
   return { version: 1, certifications: [] };
 }
 function saveManifest(m, path = MANIFEST_PATH) {
-  mkdirSync18(join41(homedir14(), ".mma"), { recursive: true });
-  writeFileSync16(path, JSON.stringify(m, null, 2), "utf-8");
+  mkdirSync19(join42(homedir15(), ".mma"), { recursive: true });
+  writeFileSync17(path, JSON.stringify(m, null, 2), "utf-8");
 }
 function upsertCertification(entry, path = MANIFEST_PATH) {
   const m = readManifest(path);
@@ -24129,7 +24372,7 @@ function getCertMark(model, providerUrl, currentVersion, path = MANIFEST_PATH) {
 }
 var MANIFEST_PATH;
 var init_manifest = __esm(() => {
-  MANIFEST_PATH = join41(homedir14(), ".mma", "certifications.json");
+  MANIFEST_PATH = join42(homedir15(), ".mma", "certifications.json");
 });
 
 // node_modules/yaml/dist/nodes/identity.js
@@ -31252,8 +31495,8 @@ var init_scenarios = __esm(() => {
 });
 
 // src/modules/certification/loader.ts
-import { existsSync as existsSync48, readdirSync as readdirSync16, readFileSync as readFileSync31 } from "fs";
-import { join as join42 } from "path";
+import { existsSync as existsSync49, readdirSync as readdirSync17, readFileSync as readFileSync32 } from "fs";
+import { join as join43 } from "path";
 function validateScenario(s) {
   const errors2 = [];
   const isSkip = s.mode === "skip";
@@ -31302,12 +31545,12 @@ function loadScenarios(userDir) {
     else
       scenarios.push(s);
   }
-  if (userDir && existsSync48(userDir)) {
-    for (const file of readdirSync16(userDir)) {
+  if (userDir && existsSync49(userDir)) {
+    for (const file of readdirSync17(userDir)) {
       if (!file.endsWith(".yaml") && !file.endsWith(".yml"))
         continue;
       try {
-        const raw = readFileSync31(join42(userDir, file), "utf-8");
+        const raw = readFileSync32(join43(userDir, file), "utf-8");
         const data = $parse(raw);
         const parsed = normalizeScenario(data, file);
         const errs = validateScenario(parsed);
@@ -31360,8 +31603,8 @@ var init_loader3 = __esm(() => {
 });
 
 // src/modules/certification/fact-checker.ts
-import { existsSync as existsSync49, readFileSync as readFileSync32, statSync as statSync9 } from "fs";
-import { join as join43 } from "path";
+import { existsSync as existsSync50, readFileSync as readFileSync33, statSync as statSync9 } from "fs";
+import { join as join44 } from "path";
 function checkSandbox(sandboxDir, checks, exitCode, output) {
   const failures = [];
   for (const check of checks) {
@@ -31378,16 +31621,16 @@ function runCheck2(sandboxDir, check, exitCode, output) {
     case "outputContains":
       return output.includes(check.text);
     case "fileExists":
-      return isFile(join43(sandboxDir, check.path));
+      return isFile(join44(sandboxDir, check.path));
     case "fileNotExists":
-      return !existsSync49(join43(sandboxDir, check.path));
+      return !existsSync50(join44(sandboxDir, check.path));
     case "dirExists":
-      return isDir(join43(sandboxDir, check.path));
+      return isDir(join44(sandboxDir, check.path));
     case "fileContent": {
-      const abs = join43(sandboxDir, check.path);
+      const abs = join44(sandboxDir, check.path);
       if (!isFile(abs))
         return false;
-      const content = readFileSync32(abs, "utf-8");
+      const content = readFileSync33(abs, "utf-8");
       if (check.contains !== undefined)
         return content.includes(check.contains);
       if (check.equals !== undefined)
@@ -31395,10 +31638,10 @@ function runCheck2(sandboxDir, check, exitCode, output) {
       return false;
     }
     case "fileRegex": {
-      const abs = join43(sandboxDir, check.path);
+      const abs = join44(sandboxDir, check.path);
       if (!isFile(abs))
         return false;
-      return new RegExp(check.pattern).test(readFileSync32(abs, "utf-8"));
+      return new RegExp(check.pattern).test(readFileSync33(abs, "utf-8"));
     }
     default:
       return false;
@@ -31406,14 +31649,14 @@ function runCheck2(sandboxDir, check, exitCode, output) {
 }
 function isFile(p) {
   try {
-    return existsSync49(p) && statSync9(p).isFile();
+    return existsSync50(p) && statSync9(p).isFile();
   } catch {
     return false;
   }
 }
 function isDir(p) {
   try {
-    return existsSync49(p) && statSync9(p).isDirectory();
+    return existsSync50(p) && statSync9(p).isDirectory();
   } catch {
     return false;
   }
@@ -31444,9 +31687,9 @@ var init_fact_checker = () => {};
 
 // src/modules/certification/runner.ts
 import { spawn as spawn9 } from "child_process";
-import { existsSync as existsSync50, mkdirSync as mkdirSync19, rmSync as rmSync4, cpSync as cpSync2 } from "fs";
+import { existsSync as existsSync51, mkdirSync as mkdirSync20, rmSync as rmSync4, cpSync as cpSync2 } from "fs";
 import { platform as platform10 } from "os";
-import { join as join44, resolve as resolve24, dirname as dirname15 } from "path";
+import { join as join45, resolve as resolve24, dirname as dirname16 } from "path";
 async function runScenario(scenario, opts) {
   if (scenario.mode === "skip") {
     return {
@@ -31465,7 +31708,7 @@ async function runScenario(scenario, opts) {
   let passed = 0;
   let firstError;
   for (let i = 1;i <= reps; i++) {
-    const sandbox = join44(opts.sandboxBase, `run-${scenario.id}-${i}`);
+    const sandbox = join45(opts.sandboxBase, `run-${scenario.id}-${i}`);
     let failures = [];
     let exitCode = -1;
     let output = "";
@@ -31524,27 +31767,27 @@ ${res.stderr}`;
 }
 function prepareSandbox(sandbox, scenario, mmaRoot) {
   rmSync4(sandbox, { recursive: true, force: true });
-  mkdirSync19(sandbox, { recursive: true });
+  mkdirSync20(sandbox, { recursive: true });
   for (const f of scenario.fixtures ?? []) {
-    const src = join44(mmaRoot, f.source);
-    if (!existsSync50(src)) {
+    const src = join45(mmaRoot, f.source);
+    if (!existsSync51(src)) {
       throw new Error(`fixture missing: ${f.source}`);
     }
-    const dest = join44(sandbox, f.dest);
-    mkdirSync19(dirname15(dest), { recursive: true });
+    const dest = join45(sandbox, f.dest);
+    mkdirSync20(dirname16(dest), { recursive: true });
     cpSync2(src, dest);
   }
 }
 function resolveMmaEntry(mmaRoot) {
-  const dev = join44(mmaRoot, "src", "cli", "main.ts");
-  if (existsSync50(dev))
+  const dev = join45(mmaRoot, "src", "cli", "main.ts");
+  if (existsSync51(dev))
     return dev;
-  return join44(mmaRoot, "dist", "main.js");
+  return join45(mmaRoot, "dist", "main.js");
 }
 function findMmaRoot(fromDir) {
   const candidates = [resolve24(fromDir, "..", "..", ".."), resolve24(fromDir, "..")];
   for (const c of candidates) {
-    if (existsSync50(join44(c, "package.json")))
+    if (existsSync51(join45(c, "package.json")))
       return c;
   }
   return process.cwd();
@@ -31611,16 +31854,16 @@ __export(exports_cli, {
   certList: () => certList
 });
 import { rmSync as rmSync5 } from "fs";
-import { homedir as homedir15 } from "os";
-import { join as join45, dirname as dirname16 } from "path";
+import { homedir as homedir16 } from "os";
+import { join as join46, dirname as dirname17 } from "path";
 import { fileURLToPath as fileURLToPath4 } from "url";
-import { existsSync as existsSync51, readFileSync as readFileSync33 } from "fs";
+import { existsSync as existsSync52, readFileSync as readFileSync34 } from "fs";
 function readVersion() {
-  const candidates = [join45(MMA_ROOT, "package.json")];
+  const candidates = [join46(MMA_ROOT, "package.json")];
   for (const p of candidates) {
-    if (existsSync51(p)) {
+    if (existsSync52(p)) {
       try {
-        const raw = JSON.parse(readFileSync33(p, "utf-8"));
+        const raw = JSON.parse(readFileSync34(p, "utf-8"));
         if (raw.version)
           return raw.version;
       } catch {}
@@ -31656,7 +31899,7 @@ async function certify(opts) {
     return;
   }
   console.log(t("cli.cert_started", { model: opts.name, provider: providerUrl }));
-  const sandboxBase = join45(process.cwd(), ".mma", "certification");
+  const sandboxBase = join46(process.cwd(), ".mma", "certification");
   const results = [];
   const total = selected.length;
   let idx = 0;
@@ -31768,9 +32011,9 @@ var init_cli = __esm(() => {
   init_loader3();
   init_runner2();
   init_manifest();
-  HERE = dirname16(fileURLToPath4(import.meta.url));
+  HERE = dirname17(fileURLToPath4(import.meta.url));
   MMA_ROOT = findMmaRoot(HERE);
-  USER_SCENARIO_DIR = join45(homedir15(), ".mma", "certification", "scenarios");
+  USER_SCENARIO_DIR = join46(homedir16(), ".mma", "certification", "scenarios");
 });
 
 // src/cli/repl-commands.ts
@@ -31779,8 +32022,9 @@ __export(exports_repl_commands, {
   registerAllCommands: () => registerAllCommands,
   COMMAND_GROUPS: () => COMMAND_GROUPS
 });
-import { join as join47 } from "path";
-import { homedir as homedir17 } from "os";
+import { join as join48, dirname as dirname19 } from "path";
+import { homedir as homedir18 } from "os";
+import { existsSync as existsSync54 } from "fs";
 function registerAllCommands(ctx) {
   registerBuiltinCommands(ctx);
   registerMmaCommands(ctx);
@@ -31837,7 +32081,7 @@ function registerMmaCommands(ctx) {
       }
       try {
         const { loadFileAsDataUrl: loadFileAsDataUrl2, loadUrlAsDataUrl: loadUrlAsDataUrl2, readClipboardImage: readClipboardImage2 } = await Promise.resolve().then(() => (init_image_utils(), exports_image_utils));
-        const { existsSync: existsSync52 } = await import("fs");
+        const { existsSync: existsSync55 } = await import("fs");
         const { resolve: resolve25 } = await import("path");
         let dataUrl;
         let label;
@@ -31857,7 +32101,7 @@ function registerMmaCommands(ctx) {
           label = source;
         } else {
           const absPath = resolve25(process.cwd(), source);
-          if (!existsSync52(absPath)) {
+          if (!existsSync55(absPath)) {
             console.log(pc2.red(t("image.not_found", { path: source })));
             return;
           }
@@ -31910,6 +32154,31 @@ function registerMmaCommands(ctx) {
       }
     }
   });
+  ctx.registerCommand({
+    name: "config migrate",
+    description: t("cli.migrate_config"),
+    action: async () => {
+      const { hasDomainFiles: hasDomainFiles3 } = await Promise.resolve().then(() => (init_domains(), exports_domains));
+      const { loadConfig: loadCfg } = await Promise.resolve().then(() => (init_config2(), exports_config));
+      const configDir = ctx.configDir;
+      const configPath = join48(configDir, "config.json");
+      if (hasDomainFiles3(configDir)) {
+        console.log(pc2.yellow(t("config.migrate_no_legacy")));
+        return;
+      }
+      if (!existsSync54(configPath)) {
+        console.log(pc2.yellow(t("config.migrate_no_legacy")));
+        return;
+      }
+      console.log(t("config.migrate_start"));
+      const { config } = loadCfg({ configDir, projectConfigPath: join48(configDir, ".mmrc") });
+      saveConfig(config, configPath, configDir);
+      const { renameSync: renameSync3, readdirSync: readdirSync18 } = await import("fs");
+      renameSync3(configPath, configPath + ".bak");
+      const domainFiles = readdirSync18(join48(configDir, "config")).filter((f) => f.endsWith(".json"));
+      console.log(pc2.green(t("config.migrate_done", { count: String(domainFiles.length) })));
+    }
+  });
   ctx.registerCommand({
     name: "reasoning",
     description: t("repl.reasoning"),
@@ -31948,7 +32217,7 @@ function registerMmaCommands(ctx) {
       console.log(pc2.yellow(t("repl.wizard_running")));
       await ctx.withExclusiveInput(async () => {
         const answers = await runSetup(ctx.rl);
-        const configPath = join47(homedir17(), ".mma", "config.json");
+        const configPath = join48(homedir18(), ".mma", "config.json");
         ctx.config.provider.type = answers.provider;
         ctx.config.provider.baseUrl = answers.apiBase;
         ctx.config.provider.apiKey = answers.apiKey;
@@ -31956,7 +32225,7 @@ function registerMmaCommands(ctx) {
         ctx.config.contextWindow = answers.contextWindow;
         ctx.config.maxToolIterations = answers.maxToolIterations;
         ctx.config.locale = answers.locale;
-        saveConfig(ctx.config, configPath);
+        saveConfig(ctx.config, configPath, dirname19(configPath));
         await ctx.agent.reconfigure(ctx.config);
         console.log(pc2.green(t("cli.config_saved")));
       });
@@ -32070,8 +32339,8 @@ Excluded blocks: ${info.excluded.length}`));
           return;
         }
         ctx.config.model = name;
-        const configPath = join47(homedir17(), ".mma", "config.json");
-        saveConfig(ctx.config, configPath);
+        const configPath = join48(homedir18(), ".mma", "config.json");
+        saveConfig(ctx.config, configPath, dirname19(configPath));
         await ctx.agent.reconfigure(ctx.config);
         console.log(pc2.green(t("repl.model_set", { name })));
         return;
@@ -32095,8 +32364,8 @@ Excluded blocks: ${info.excluded.length}`));
         return;
       }
       ctx.config.contextWindow = size;
-      const configPath = join47(homedir17(), ".mma", "config.json");
-      saveConfig(ctx.config, configPath);
+      const configPath = join48(homedir18(), ".mma", "config.json");
+      saveConfig(ctx.config, configPath, dirname19(configPath));
       await ctx.agent.reconfigure(ctx.config);
       console.log(pc2.green(t("cli.context_set", { size })));
     }
@@ -32110,12 +32379,12 @@ Excluded blocks: ${info.excluded.length}`));
       if (ctx.sessionManager && ctx.config.session.autoSave) {}
       ctx.agent.shutdown();
       const { loadConfig: loadConfig2 } = await Promise.resolve().then(() => (init_config2(), exports_config));
-      const { homedir: homedir18 } = await import("os");
-      const { join: join48 } = await import("path");
+      const { homedir: homedir19 } = await import("os");
+      const { join: join49 } = await import("path");
       const configDir = ctx.configDir;
       const baseDir = ctx.baseDir;
-      const projectConfigPath = join48(baseDir, ".mmrc");
-      const freshConfig = loadConfig2({ configDir, projectConfigPath });
+      const projectConfigPath = join49(baseDir, ".mmrc");
+      const { config: freshConfig } = loadConfig2({ configDir, projectConfigPath });
       Object.assign(ctx.config, freshConfig);
       const { bootstrap: bootstrap2 } = await Promise.resolve().then(() => (init_bootstrap(), exports_bootstrap));
       const result = await bootstrap2(configDir, baseDir, false, false);
@@ -32517,14 +32786,15 @@ init_config2();
 init_setup();
 init_i18n();
 init_colors();
-import { join as join46 } from "path";
-import { homedir as homedir16 } from "os";
+import { join as join47, dirname as dirname18 } from "path";
+import { homedir as homedir17 } from "os";
+import { existsSync as existsSync53 } from "fs";
 
 // src/cli/security-commands.ts
 init_bootstrap();
 init_config2();
-import { join as join40 } from "path";
-import { homedir as homedir13 } from "os";
+import { join as join41, dirname as dirname15 } from "path";
+import { homedir as homedir14 } from "os";
 
 // src/modules/security/security-policies.ts
 init_security();
@@ -33037,7 +33307,7 @@ function createSecurityCommand(program2) {
     }
   });
   securityCmd.command("set-policy").argument("<preset>", t("cli.security.preset")).description(t("cli.security.set_policy")).action(async (preset) => {
-    const configPath = join40(homedir13(), ".mma", "config.json");
+    const configPath = join41(homedir14(), ".mma", "config.json");
     const { config: appConfig } = await bootstrap();
     const validPresets = ["strict", "balanced", "permissive"];
     if (!validPresets.includes(preset)) {
@@ -33047,12 +33317,12 @@ function createSecurityCommand(program2) {
     const policy = getSecurityPolicy(preset);
     const newSecurityConfig = applySecurityPolicy(preset);
     appConfig.security = newSecurityConfig;
-    saveConfig(appConfig, configPath);
+    saveConfig(appConfig, configPath, dirname15(configPath));
     console.log(t("cli.security.policy_applied", { name: policy.name }));
     console.log(t("cli.security.policy_description", { description: policy.description }));
   });
   securityCmd.command("enable-encryption").description(t("cli.security.enable_encryption")).action(async () => {
-    const configPath = join40(homedir13(), ".mma", "config.json");
+    const configPath = join41(homedir14(), ".mma", "config.json");
     const { config: appConfig } = await bootstrap();
     appConfig.security = appConfig.security || {};
     appConfig.security.sessionEncryption = {
@@ -33060,11 +33330,11 @@ function createSecurityCommand(program2) {
       encryptHistory: true,
       encryptSessionLog: true
     };
-    saveConfig(appConfig, configPath);
+    saveConfig(appConfig, configPath, dirname15(configPath));
     console.log(t("cli.security.encryption_enabled"));
   });
   securityCmd.command("disable-encryption").description(t("cli.security.disable_encryption")).action(async () => {
-    const configPath = join40(homedir13(), ".mma", "config.json");
+    const configPath = join41(homedir14(), ".mma", "config.json");
     const { config: appConfig } = await bootstrap();
     appConfig.security = appConfig.security || {};
     appConfig.security.sessionEncryption = {
@@ -33072,11 +33342,11 @@ function createSecurityCommand(program2) {
       encryptHistory: false,
       encryptSessionLog: false
     };
-    saveConfig(appConfig, configPath);
+    saveConfig(appConfig, configPath, dirname15(configPath));
     console.log(t("cli.security.encryption_disabled"));
   });
   securityCmd.command("enable-audit").description(t("cli.security.enable_audit")).action(async () => {
-    const configPath = join40(homedir13(), ".mma", "config.json");
+    const configPath = join41(homedir14(), ".mma", "config.json");
     const { config: appConfig } = await bootstrap();
     appConfig.security = appConfig.security || {};
     appConfig.security.auditNotifier = {
@@ -33086,11 +33356,11 @@ function createSecurityCommand(program2) {
       maxRetries: 3,
       webhookTimeout: 5000
     };
-    saveConfig(appConfig, configPath);
+    saveConfig(appConfig, configPath, dirname15(configPath));
     console.log(t("cli.security.audit_enabled"));
   });
   securityCmd.command("disable-audit").description(t("cli.security.disable_audit")).action(async () => {
-    const configPath = join40(homedir13(), ".mma", "config.json");
+    const configPath = join41(homedir14(), ".mma", "config.json");
     const { config: appConfig } = await bootstrap();
     appConfig.security = appConfig.security || {};
     appConfig.security.auditNotifier = {
@@ -33098,7 +33368,7 @@ function createSecurityCommand(program2) {
       maxRetries: 3,
       webhookTimeout: 5000
     };
-    saveConfig(appConfig, configPath);
+    saveConfig(appConfig, configPath, dirname15(configPath));
     console.log(t("cli.security.audit_disabled"));
   });
   securityCmd.command("audit-stats").description(t("cli.security.audit_stats")).action(async () => {
@@ -33160,7 +33430,7 @@ function createProgram() {
   const program2 = new Command().name("mma").description(t("cli.description")).version(version).option("--no-agents-md", t("cli.no_agents_md")).option("-d, --dir <path>", t("cli.dir")).option("-e, --exit-on-complete", t("cli.exit_on_complete")).option("-j, --json", t("cli.json"));
   program2.command("init").description(t("cli.init")).action(async () => {
     const answers = await runSetup();
-    const configPath = join46(homedir16(), ".mma", "config.json");
+    const configPath = join47(homedir17(), ".mma", "config.json");
     const { config } = await bootstrap();
     config.provider.type = answers.provider;
     config.provider.baseUrl = answers.apiBase;
@@ -33200,12 +33470,12 @@ function createProgram() {
         config.security.paths.denied = [];
       }
     }
-    saveConfig(config, configPath);
+    saveConfig(config, configPath, dirname18(configPath));
     console.log(t("cli.config_saved"));
   });
   const configCmd = program2.command("config").description(t("cli.manage_config"));
   configCmd.command("set").argument("<key>", t("cli.config_key")).argument("<value>", "Config value").description(t("cli.set_value")).action(async (key, value) => {
-    const configPath = join46(homedir16(), ".mma", "config.json");
+    const configPath = join47(homedir17(), ".mma", "config.json");
     const { config } = await bootstrap();
     const keys = key.split(".");
     let obj = config;
@@ -33225,13 +33495,36 @@ function createProgram() {
       obj[lastKey] = parseFloat(value);
     else
       obj[lastKey] = value;
-    saveConfig(config, configPath);
+    saveConfig(config, configPath, dirname18(configPath));
     console.log(t("cli.set_done", { key, value }));
   });
   configCmd.command("show").description(t("cli.show_config")).action(async () => {
     const { config } = await bootstrap();
     console.log(JSON.stringify(config, null, 2));
   });
+  configCmd.command("migrate").description(t("cli.migrate_config")).action(async () => {
+    const { loadConfig: loadConfig2 } = await Promise.resolve().then(() => (init_config2(), exports_config));
+    const { hasDomainFiles: hasDomainFiles3 } = await Promise.resolve().then(() => (init_domains(), exports_domains));
+    const configDir = join47(homedir17(), ".mma");
+    const configPath = join47(configDir, "config.json");
+    if (hasDomainFiles3(configDir)) {
+      console.log(pc2.yellow(t("config.migrate_no_legacy")));
+      return;
+    }
+    if (!existsSync53(configPath)) {
+      console.log(pc2.yellow(t("config.migrate_no_legacy")));
+      return;
+    }
+    console.log(t("config.migrate_start"));
+    const { config } = loadConfig2({ configDir, projectConfigPath: join47(configDir, ".mmrc") });
+    saveConfig(config, configPath, configDir);
+    const bakPath = configPath + ".bak";
+    const { renameSync: renameSync3 } = await import("fs");
+    renameSync3(configPath, bakPath);
+    const { readdirSync: readdirSync18 } = await import("fs");
+    const domainFiles = readdirSync18(join47(configDir, "config")).filter((f) => f.endsWith(".json"));
+    console.log(pc2.green(t("config.migrate_done", { count: String(domainFiles.length) })));
+  });
   const model = program2.command("model").description(t("cli.manage_models"));
   model.command("list").description(t("cli.list_models")).action(async () => {
     const { config } = await bootstrap();
@@ -33268,10 +33561,10 @@ function createProgram() {
     console.log(t("cli.model_hint"));
   });
   model.command("use").argument("<name>", "Model name").description(t("cli.set_model")).action(async (name) => {
-    const configPath = join46(homedir16(), ".mma", "config.json");
+    const configPath = join47(homedir17(), ".mma", "config.json");
     const { config } = await bootstrap();
     config.model = name;
-    saveConfig(config, configPath);
+    saveConfig(config, configPath, dirname18(configPath));
     console.log(t("cli.model_set", { name }));
   });
   model.command("certify").argument("<name>", "Model name").option("--provider-url <url>", t("cli.cert_provider_url")).option("--provider-key <key>", t("cli.cert_provider_key")).option("--context-window <n>", t("cli.cert_context_window")).option("--tags <tags>", t("cli.cert_tags"), "core").option("--reps <n>", t("cli.cert_reps")).option("--force", t("cli.cert_force")).option("--clean", t("cli.cert_clean")).description(t("cli.certify")).action(async (name, cmdOpts) => {
@@ -33304,7 +33597,7 @@ function createProgram() {
     await uncertify2(name, config);
   });
   program2.command("context").description(t("cli.manage_context")).argument("<size>", "Context window size in tokens").action(async (size) => {
-    const configPath = join46(homedir16(), ".mma", "config.json");
+    const configPath = join47(homedir17(), ".mma", "config.json");
     const { config } = await bootstrap();
     const contextWindow = parseInt(size, 10);
     if (isNaN(contextWindow) || contextWindow < 1024) {
@@ -33312,7 +33605,7 @@ function createProgram() {
       return;
     }
     config.contextWindow = contextWindow;
-    saveConfig(config, configPath);
+    saveConfig(config, configPath, dirname18(configPath));
     console.log(t("cli.context_set", { size: contextWindow }));
   });
   const provider = program2.command("provider").description(t("cli.manage_providers"));
@@ -33350,7 +33643,7 @@ function createProgram() {
     console.log(t("cli.base_url"), config.provider.baseUrl);
   });
   provider.command("use").argument("<name>", "Provider name").description(t("cli.set_provider")).action(async (name) => {
-    const configPath = join46(homedir16(), ".mma", "config.json");
+    const configPath = join47(homedir17(), ".mma", "config.json");
     const { config, agent } = await bootstrap();
     if (config.provider.entries && config.provider.entries.length > 0) {
       try {
@@ -33366,14 +33659,14 @@ function createProgram() {
     if (baseUrl) {
       config.provider.baseUrl = baseUrl;
     }
-    saveConfig(config, configPath);
+    saveConfig(config, configPath, dirname18(configPath));
     console.log(t("cli.provider_set", { name }));
     if (baseUrl) {
       console.log(t("cli.provider_base_hint", { baseUrl }));
     }
   });
   provider.command("add").argument("<name>", "Provider type or label").option("--url <url>", "Base URL").option("--key <key>", "API key").option("--priority <n>", "Fallback priority (lower = tried first)").option("--context-window <n>", "Context window override for this entry").option("--rpm <n>", "Max requests per minute for this entry").option("--parallel <n>", "Max parallel tasks for this entry").description(t("cli.add_provider")).action(async (name, opts) => {
-    const configPath = join46(homedir16(), ".mma", "config.json");
+    const configPath = join47(homedir17(), ".mma", "config.json");
     const { config } = await bootstrap();
     const entries = Array.isArray(config.provider.entries) ? config.provider.entries : [];
     if (entries.length === 0) {
@@ -33405,7 +33698,7 @@ function createProgram() {
     });
     config.provider.entries = entries;
     config.provider.active = config.provider.active || config.provider.type;
-    saveConfig(config, configPath);
+    saveConfig(config, configPath, dirname18(configPath));
     console.log(pc2.green(t("cli.provider_added", { name })));
     console.log(t("cli.provider_switch_hint"));
   });
@@ -33742,6 +34035,10 @@ class LineEditor {
           this.lastWasCR = false;
           return;
         }
+        if (this.questionCb) {
+          this.submit();
+          return;
+        }
         this.insertNewline();
         return;
       case "backspace":
@@ -34278,9 +34575,9 @@ class LineEditor {
 }
 
 // src/cli/repl.ts
-import { existsSync as existsSync52, readFileSync as readFileSync34, writeFileSync as writeFileSync17 } from "fs";
-import { join as join48 } from "path";
-import { homedir as homedir18 } from "os";
+import { existsSync as existsSync55, readFileSync as readFileSync37, writeFileSync as writeFileSync18 } from "fs";
+import { join as join49 } from "path";
+import { homedir as homedir19 } from "os";
 
 // src/cli/completer.ts
 class SlashCommandProvider {
@@ -34864,7 +35161,6 @@ ${pc2.dim(marker)} ${friendlyTool(tool)}${summary ? ` ${pc2.dim(summary)}` : ""}
 
 // src/cli/repl.ts
 init_box();
-init_string_width();
 init_i18n();
 init_repl_commands();
 
@@ -35050,6 +35346,22 @@ function formatContextBar(used, limit, compactions, quality) {
   }
   return line;
 }
+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();
+    }
+  };
+}
 
 class Repl {
   completer = new Completer;
@@ -35088,10 +35400,10 @@ class Repl {
     this.envReport = envReport;
     this.execModule = execModule;
     this.slog = new SessionLogger(sessionManager, logger);
-    this.configDir = configDir || join48(homedir18(), ".mma");
+    this.configDir = configDir || join49(homedir19(), ".mma");
     this.baseDir = baseDir || process.cwd();
     this.noAgentsMd = noAgentsMd === true;
-    this.historyPath = historyPath ?? join48(homedir18(), ".mma", "repl-history");
+    this.historyPath = historyPath ?? join49(homedir19(), ".mma", "repl-history");
     this.loadHistory();
     this.rl = process.stdin.isTTY ? new LineEditor({
       input: process.stdin,
@@ -35122,11 +35434,24 @@ class Repl {
     registerAllCommands(this);
     this.setupCompleter();
     this.setupListeners();
+    if (pluginManager) {
+      pluginManager.setHostBridge(createHostBridge({
+        isBusy: () => this.agentRunning,
+        addPendingImage: (url) => {
+          this.agent.contextManager?.addPendingImage?.({
+            type: "image_url",
+            image_url: { url }
+          });
+        },
+        runAgent: (text) => this.runAgent(text),
+        interruptRun: () => this.agent.shutdown()
+      }));
+    }
   }
   loadHistory() {
-    if (existsSync52(this.historyPath)) {
+    if (existsSync55(this.historyPath)) {
       try {
-        const raw = readFileSync34(this.historyPath, "utf-8");
+        const raw = readFileSync37(this.historyPath, "utf-8");
         this.history = raw.split(`
 `).filter(Boolean).slice(-this.maxHistory);
       } catch {
@@ -35136,7 +35461,7 @@ class Repl {
   }
   saveHistory() {
     const allHistory = this.history.slice(-this.maxHistory);
-    writeFileSync17(this.historyPath, allHistory.join(`
+    writeFileSync18(this.historyPath, allHistory.join(`
 `), "utf-8");
   }
   setupCompleter() {
@@ -35523,11 +35848,11 @@ ${t("image.clipboard_empty")}`));
       row(t("repl.agents_label"), pc2.red(t("repl.disabled")));
     } else {
       const agentsMdCandidates = [
-        join48(this.baseDir, "AGENTS.md"),
-        join48(this.baseDir, ".mma", "AGENTS.md"),
-        join48(this.configDir, "AGENTS.md")
+        join49(this.baseDir, "AGENTS.md"),
+        join49(this.baseDir, ".mma", "AGENTS.md"),
+        join49(this.configDir, "AGENTS.md")
       ];
-      const foundAgents = agentsMdCandidates.filter((p) => existsSync52(p));
+      const foundAgents = agentsMdCandidates.filter((p) => existsSync55(p));
       if (foundAgents.length > 0) {
         for (const p of foundAgents) {
           row(t("repl.agents_label"), pc2.dim(p));
@@ -35538,24 +35863,35 @@ ${t("image.clipboard_empty")}`));
     }
     const meta = this.sessionManager?.getActiveMeta();
     if (meta) {
-      const sessionPath = join48(this.configDir, "sessions", meta.id);
+      const sessionPath = join49(this.configDir, "sessions", meta.id);
       row(t("repl.session_label"), `${pc2.cyan(meta.name)} ${pc2.dim(`(${meta.id.slice(0, 12)})`)}  —  ${meta.messageCount} msgs  ${pc2.dim(sessionPath)}`);
     }
-    const headerWidth = Math.max(50, Math.min(96, process.stdout.columns || 96));
     const isTty2 = process.stdout.isTTY === true;
     const lspEnabled = isTty2 && (this.config.lsp ?? DEFAULT_LSP_CONFIG).enabled !== false;
-    if (lspEnabled) {
-      row(t("repl.lsp_label"), pc2.dim("…"));
-    }
     for (const line of info) {
       console.log(pc2.dim(line).trimEnd());
     }
     console.log();
+    try {
+      const { existsSync: exists } = await import("fs");
+      const { join: pathJoin } = await import("path");
+      const { hasDomainFiles: hasDomainFiles3 } = await Promise.resolve().then(() => (init_domains(), exports_domains));
+      const legacyPath = pathJoin(this.configDir, "config.json");
+      if (exists(legacyPath) && !hasDomainFiles3(this.configDir)) {
+        console.log(pc2.yellow(`  ${t("config.legacy_hint")}`));
+        console.log();
+      }
+    } catch {}
     this.rl.prompt();
     if (lspEnabled) {
       this.probeLspBanner().then((lspSummary) => {
-        if (lspSummary)
-          this.updateLspRow(headerWidth, lspSummary);
+        if (lspSummary) {
+          const line = `${pc2.green(t("repl.agent"))}${pc2.yellow(t("repl.lsp_label"))} ${lspSummary}`;
+          process.stdout.write(`\x1B[2K\r${divider()}
+${line}
+`);
+          this.rl.prompt();
+        }
       }).catch(() => {});
     }
     if ((this.config.provider.entries?.length ?? 0) > 1) {
@@ -35571,17 +35907,6 @@ ${t("image.clipboard_empty")}`));
       }).catch(() => {});
     }
   }
-  updateLspRow(headerWidth, summary) {
-    if (this.agentRunning || !process.stdout.isTTY)
-      return;
-    if ((process.stdout.columns ?? 96) < headerWidth)
-      return;
-    const rowText = `${pc2.yellow(t("repl.lsp_label"))} ${summary.replace(/\s+/g, " ").trim()}`;
-    if (stringWidth(rowText) > headerWidth)
-      return;
-    const line = pc2.dim(rowText);
-    process.stdout.write(`\x1B[2A\r\x1B[2K${line}\x1B[2B\r`);
-  }
   async probeLspBanner() {
     const config = this.config.lsp ?? DEFAULT_LSP_CONFIG;
     try {
@@ -35653,9 +35978,9 @@ init_setup();
 init_config2();
 init_i18n();
 init_colors();
-import { existsSync as existsSync53 } from "fs";
-import { join as join50 } from "path";
-import { homedir as homedir20 } from "os";
+import { existsSync as existsSync56 } from "fs";
+import { join as join51, dirname as dirname20 } from "path";
+import { homedir as homedir21 } from "os";
 
 // src/modules/updater/index.ts
 init_checker();
@@ -35758,10 +36083,10 @@ class UpdaterModule {
 init_environment();
 init_data_sanitizer();
 init_i18n();
-import { appendFileSync as appendFileSync7, mkdirSync as mkdirSync20 } from "fs";
-import { join as join49 } from "path";
-import { homedir as homedir19 } from "os";
-var CRASH_LOG_DIR = join49(homedir19(), ".mma", "logs");
+import { appendFileSync as appendFileSync7, mkdirSync as mkdirSync21 } from "fs";
+import { join as join50 } from "path";
+import { homedir as homedir20 } from "os";
+var CRASH_LOG_DIR = join50(homedir20(), ".mma", "logs");
 var CRASH_LOG_FILE = "crash.jsonl";
 function formatCrashEntry(type2, err) {
   const message = err instanceof Error ? err.message : String(err);
@@ -35771,13 +36096,13 @@ function formatCrashEntry(type2, err) {
     type: type2,
     message: sanitizeLogMessage(message),
     stack: sanitizeLogMessage(stack),
-    environment: collectEnvironment({ configDir: homedir19(), scanTools: false })
+    environment: collectEnvironment({ configDir: homedir20(), scanTools: false })
   };
 }
 function writeCrashEntry(dir, entry) {
   try {
-    mkdirSync20(dir, { recursive: true });
-    appendFileSync7(join49(dir, CRASH_LOG_FILE), JSON.stringify(entry) + `
+    mkdirSync21(dir, { recursive: true });
+    appendFileSync7(join50(dir, CRASH_LOG_FILE), JSON.stringify(entry) + `
 `, "utf-8");
   } catch {}
 }
@@ -35835,7 +36160,10 @@ async function main() {
   }
   if (program2.args.length > 0) {
     const prompt = program2.args.join(" ");
-    const { agent, config, baseDir } = await bootstrap(undefined, projectDir, noAgentsMd, exitOnComplete);
+    const { agent, config, baseDir, legacyDetected } = await bootstrap(undefined, projectDir, noAgentsMd, exitOnComplete);
+    if (legacyDetected) {
+      console.error(pc2.yellow(`  ${t("config.legacy_hint")}`));
+    }
     const updater = exitOnComplete ? undefined : startAutoUpdate(config);
     if (jsonMode) {
       const result2 = await agent.run(prompt);
@@ -35882,31 +36210,48 @@ async function main() {
     await updater?.waitForIdle();
     process.exit(exitCode);
   } else {
-    const configPath = join50(homedir20(), ".mma", "config.json");
-    if (!existsSync53(configPath)) {
+    const mmaDir = join51(homedir21(), ".mma");
+    const legacyConfigPath = join51(mmaDir, "config.json");
+    let hasAnyConfig = existsSync56(legacyConfigPath);
+    if (!hasAnyConfig) {
+      try {
+        const { hasDomainFiles: hasDomainFiles3 } = await Promise.resolve().then(() => (init_domains(), exports_domains));
+        hasAnyConfig = hasDomainFiles3(mmaDir);
+      } catch {}
+    }
+    const {
+      agent,
+      config,
+      sessionManager,
+      skillsModule,
+      pluginManager,
+      execModule,
+      configDir,
+      baseDir,
+      logger,
+      envReport
+    } = await bootstrap(undefined, projectDir, noAgentsMd, exitOnComplete);
+    const repl = new Repl(agent, config, sessionManager, skillsModule, pluginManager, configDir, baseDir, noAgentsMd, logger, true, envReport, undefined, execModule);
+    if (!hasAnyConfig) {
       console.log(pc2.yellow(`
   ` + t("cli.first_run") + `
 `));
-      const answers = await runSetup();
-      const config2 = loadConfig({
-        configDir: join50(homedir20(), ".mma"),
-        projectConfigPath: projectDir ? join50(projectDir, ".mmrc") : join50(process.cwd(), ".mmrc")
-      });
-      config2.provider.type = answers.provider;
-      config2.provider.baseUrl = answers.apiBase;
-      config2.provider.apiKey = answers.apiKey;
-      config2.model = answers.model;
-      config2.contextWindow = answers.contextWindow;
-      config2.maxToolIterations = answers.maxToolIterations;
-      config2.locale = answers.locale;
-      if (config2.security) {
-        config2.security.enabled = true;
-        config2.security.bash.enabled = true;
-        config2.security.bash.blockDangerousFlags = answers.securityFlagsBlock || config2.security.bash.blockDangerousFlags;
+      const answers = await runSetup(repl.rl);
+      config.provider.type = answers.provider;
+      config.provider.baseUrl = answers.apiBase;
+      config.provider.apiKey = answers.apiKey;
+      config.model = answers.model;
+      config.contextWindow = answers.contextWindow;
+      config.maxToolIterations = answers.maxToolIterations;
+      config.locale = answers.locale;
+      if (config.security) {
+        config.security.enabled = true;
+        config.security.bash.enabled = true;
+        config.security.bash.blockDangerousFlags = answers.securityFlagsBlock || config.security.bash.blockDangerousFlags;
         if (answers.securityBashBlock) {
-          config2.security.bash.blacklist = [
+          config.security.bash.blacklist = [
             ...new Set([
-              ...config2.security.bash.blacklist,
+              ...config.security.bash.blacklist,
               "rm",
               "dd",
               "chmod",
@@ -35927,25 +36272,13 @@ async function main() {
           ];
         }
         if (!answers.securityPathsDeny) {
-          config2.security.paths.denied = [];
+          config.security.paths.denied = [];
         }
       }
-      saveConfig(config2, configPath);
+      saveConfig(config, legacyConfigPath, dirname20(legacyConfigPath));
+      await agent.reconfigure(config);
     }
-    const {
-      agent,
-      config,
-      sessionManager,
-      skillsModule,
-      pluginManager,
-      execModule,
-      configDir,
-      baseDir,
-      logger,
-      envReport
-    } = await bootstrap(undefined, projectDir, noAgentsMd, exitOnComplete);
     startAutoUpdate(config);
-    const repl = new Repl(agent, config, sessionManager, skillsModule, pluginManager, configDir, baseDir, noAgentsMd, logger, true, envReport, undefined, execModule);
     await repl.start();
   }
 }