micro-models-agent 0.41.0 → 0.42.0

package/dist/main.js

@@ -2092,15 +2092,31 @@ var init_config = __esm(() => {
     servers: {
       typescript: {
         command: "npx",
-        args: ["typescript-language-server", "--stdio"],
-        timeout: 20000,
+        args: [
+          "--yes",
+          "--package",
+          "typescript-language-server",
+          "--package",
+          "typescript@5",
+          "typescript-language-server",
+          "--stdio"
+        ],
+        timeout: 30000,
         autoInstall: true,
         workspaceMarkers: ["package.json", "tsconfig.json"]
       },
       javascript: {
         command: "npx",
-        args: ["typescript-language-server", "--stdio"],
-        timeout: 15000,
+        args: [
+          "--yes",
+          "--package",
+          "typescript-language-server",
+          "--package",
+          "typescript@5",
+          "typescript-language-server",
+          "--stdio"
+        ],
+        timeout: 30000,
         autoInstall: true,
         workspaceMarkers: ["package.json", "tsconfig.json"]
       },
@@ -2142,6 +2158,8 @@ var init_config = __esm(() => {
           "--yes",
           "--package",
           "vscode-langservers-extracted",
+          "--package",
+          "typescript@5",
           "vscode-html-language-server",
           "--stdio"
         ],
@@ -2155,6 +2173,8 @@ var init_config = __esm(() => {
           "--yes",
           "--package",
           "vscode-langservers-extracted",
+          "--package",
+          "typescript@5",
           "vscode-css-language-server",
           "--stdio"
         ],
@@ -2267,6 +2287,17 @@ var init_defaults = __esm(() => {
       viewportHeight: 720,
       navigationTimeout: 15000
     },
+    webSearch: {
+      enabled: true
+    },
+    errorWebSearch: {
+      enabled: true,
+      threshold: 5,
+      maxResults: 5,
+      maxQueryChars: 200,
+      maxSearchesPerSession: 3,
+      requestTimeoutMs: 1e4
+    },
     ui: {
       spinner: true,
       toolStyle: "inline",
@@ -2456,6 +2487,7 @@ Summary:
     "tool.no_results": 'No results found for "{query}"',
     "tool.search_results": `Search results for "{query}":
 {results}`,
+    "tool.web_search_disabled": "Web search is disabled (webSearch.enabled: false). Use file/system tools only.",
     "tool.history_results": `History results for "{query}":
 {results}`,
     "tool.no_history": 'No history entries matching "{query}"',
@@ -2494,6 +2526,7 @@ Command: {command}`,
     "plan.title_steps": 'Plan "{title}" created with {count} steps',
     "plan.step_marked": "Step {step} marked as {status}",
     "plan.aborted": "Plan aborted",
+    "plan.completed_archived": "Plan {id} is complete ({done}/{total} steps) — archived. You may create a new plan for new work (plan create), or reply with your final answer.",
     "plan.unknown_action": "Unknown plan action: {action}",
     "plan.updated": "Plan updated: {title} ({steps} steps)",
     "plan.acknowledged": "Plan {action}: acknowledged",
@@ -2533,12 +2566,14 @@ Command: {command}`,
     "verify.script_passed": "Script '{script}' passed",
     "verify.script_failed": "Script '{script}' failed: {message}",
     "verify.syntax_error": "Syntax error in: {path}",
+    "verify.no_files": "Step {step} has no named files to verify — run a real check instead (bash: bun run build / bun test / lsp_check) and confirm the result.",
     "lsp.unavailable": "static checks are unavailable (server not found). Verify via the project's own build/test instead.",
     "lsp.check_disabled": "LSP checks are disabled in the config.",
     "lsp.check_no_path": "Provide a path (file or directory) to check.",
     "lsp.check_notfound": "Path not found: {path}",
     "lsp.check_unsupported": "No LSP server configured for: {path}",
     "lsp.check_clean": "No errors or warnings detected ({count} file(s) checked).",
+    "lsp.checked_files": "Checked {count} file(s):",
     "lsp.startup_header": "[Existing project errors (checked at session start) — fix these before continuing]:",
     "cli.description": "Micro Models Agent — AI coding agent for small models",
     "cli.init": "Run interactive setup wizard",
@@ -2838,6 +2873,11 @@ Use this knowledge to answer the user's question.`,
 {hints}`,
     "exec.file_rewrite_warning": "⚠️ File {file} has been rewritten {count} times. Consider a different approach — the current fix strategy is not working.",
     "exec.forbidden_cmd": 'STOP using "{cmd}" via the bash tool — it is not a native Windows cmd.exe command and has failed repeatedly this session. Use the dedicated tool instead: grep → the grep tool, ls/dir → list_dir, find → glob, rm → delete_file, sed → edit_file, touch → write_file, which → `where`, cp/mv → move_file, diff → read_file. Do NOT call bash for this purpose again.',
+    "exec.error_search_results": `The error "{sig}" has occurred {count} times. Web search found:
+{results}
+Apply a matching solution from these results. If none is relevant — do NOT repeat the same approach; change strategy or honestly report being stuck.`,
+    "exec.error_search_failed": 'Web search returned nothing for "{query}".',
+    "exec.error_search_no_query": "Error output is not meaningful — skipping the web search.",
     "exec.npm_exec_hint": '"could not determine executable to run" — no "bin" for that package/script. Use "npm run <script>" (script must exist in package.json) or "bunx <pkg>" for a package that declares a bin.',
     "hall.max_retries_exhausted": "Model returned empty or insufficient responses after multiple retries",
     "hall.short_response": "Response too short or empty",
@@ -2887,6 +2927,7 @@ Use this knowledge to answer the user's question.`,
     "ui.success_prefix": "✓ ",
     "ui.warning_prefix": "⚠ ",
     "ui.thinking": "Thinking…",
+    "ui.tool_running": "{tool}…",
     "ui.step_context": "step {id}: {desc}",
     "indexer.map_header": "Project map",
     "indexer.top_directories": "Top directories",
@@ -3089,6 +3130,7 @@ var init_ru = __esm(() => {
     "tool.no_results": 'Нет результатов по "{query}"',
     "tool.search_results": `Результаты поиска "{query}":
 {results}`,
+    "tool.web_search_disabled": "Веб-поиск отключён (webSearch.enabled: false). Используй только файловые и системные инструменты.",
     "tool.history_results": `Результаты истории "{query}":
 {results}`,
     "tool.no_history": 'Нет записей истории по "{query}"',
@@ -3127,6 +3169,7 @@ var init_ru = __esm(() => {
     "plan.title_steps": 'План "{title}" создан с {count} шагами',
     "plan.step_marked": "Шаг {step} отмечен как {status}",
     "plan.aborted": "План отменён",
+    "plan.completed_archived": "План {id} завершён ({done}/{total} шагов) — архивирован. Для новой задачи создай новый план (plan create) или дай финальный ответ.",
     "plan.unknown_action": "Неизвестное действие плана: {action}",
     "plan.updated": "План обновлён: {title} ({steps} шагов)",
     "plan.acknowledged": "План {action}: принято",
@@ -3166,12 +3209,14 @@ var init_ru = __esm(() => {
     "verify.script_passed": "Скрипт '{script}' пройден",
     "verify.script_failed": "Скрипт '{script}' не пройден: {message}",
     "verify.syntax_error": "Синтаксическая ошибка в: {path}",
+    "verify.no_files": "Шаг {step} не содержит именованных файлов для проверки — выполни реальную проверку (bun run build / bun test / lsp_check) и подтверди результат.",
     "lsp.unavailable": "статические проверки недоступны (сервер не найден). Проверяйте через собственный build/test проекта.",
     "lsp.check_disabled": "LSP-проверки отключены в конфигурации.",
     "lsp.check_no_path": "Укажите путь (файл или каталог) для проверки.",
     "lsp.check_notfound": "Путь не найден: {path}",
     "lsp.check_unsupported": "Для файла не настроен LSP-сервер: {path}",
     "lsp.check_clean": "Ошибок и предупреждений не обнаружено (проверено файлов: {count}).",
+    "lsp.checked_files": "Проверено файлов: {count}:",
     "lsp.startup_header": "[Существующие ошибки проекта (проверено при старте сессии) — исправьте их перед продолжением]:",
     "cli.description": "Micro Models Agent — ИИ-агент для кодинга на малых моделях",
     "cli.init": "Запустить мастер настройки",
@@ -3471,6 +3516,11 @@ var init_ru = __esm(() => {
 {hints}`,
     "exec.file_rewrite_warning": "⚠️ Файл {file} был перезаписан {count} раз. Попробуйте другой подход — текущая стратегия исправлений не работает.",
     "exec.forbidden_cmd": 'ПРЕКРАТИ использовать "{cmd}" через bash — это не команда Windows cmd.exe, и она уже неоднократно падала в этой сессии. Используй предназначенный тул: grep → тул grep, ls/dir → list_dir, find → glob, rm → delete_file, sed → edit_file, touch → write_file, which → `where`, cp/mv → move_file, diff → read_file. Больше не вызывай bash для этого.',
+    "exec.error_search_results": `Ошибка "{sig}" повторилась {count} раз. Поиск в интернете нашёл:
+{results}
+Примени подходящее решение из результатов. Если ни один результат не релевантен — НЕ повторяй тот же подход, смени стратегию или честно сообщи о застревании.`,
+    "exec.error_search_failed": 'Поиск в интернете для "{query}" ничего не дал.',
+    "exec.error_search_no_query": "Текст ошибки незначимый — поиск в интернете пропущен.",
     "exec.npm_exec_hint": '"could not determine executable to run" — у пакета/скрипта нет "bin". Используй "npm run <script>" (скрипт должен быть в package.json) или "bunx <pkg>" для пакета с объявленным bin.',
     "hall.max_retries_exhausted": "Модель вернула пустой или недостаточный ответ после нескольких попыток",
     "hall.short_response": "Слишком короткий или пустой ответ",
@@ -3520,6 +3570,7 @@ var init_ru = __esm(() => {
     "ui.success_prefix": "✓ ",
     "ui.warning_prefix": "⚠ ",
     "ui.thinking": "Думаю…",
+    "ui.tool_running": "{tool}…",
     "ui.step_context": "шаг {id}: {desc}",
     "indexer.map_header": "Карта проекта",
     "indexer.top_directories": "Основные директории",
@@ -3979,6 +4030,23 @@ function regexReviver(_key, value) {
   }
   return value;
 }
+function normalizeLspServerArgs(config) {
+  const servers = config.lsp?.servers;
+  if (!servers)
+    return;
+  for (const [lang, legacy] of Object.entries(LEGACY_LSP_SERVER_ARGS)) {
+    const server = servers[lang];
+    const def = DEFAULT_LSP_CONFIG.servers[lang];
+    if (!server || server.command !== "npx" || !def)
+      continue;
+    const storedArgs = Array.isArray(server.args) ? server.args : null;
+    const isLegacy = storedArgs === null || JSON.stringify(storedArgs) === JSON.stringify(legacy.args);
+    if (isLegacy) {
+      server.args = def.args;
+      server.timeout = def.timeout;
+    }
+  }
+}
 function loadJSON(path) {
   try {
     if (existsSync4(path)) {
@@ -4051,6 +4119,7 @@ function loadConfig(options) {
   if (config.security?.contentScan?.dangerousPatterns) {
     config.security.contentScan.dangerousPatterns = restoreDangerousPatterns(config.security.contentScan.dangerousPatterns, DEFAULT_SECURITY_CONFIG.contentScan.dangerousPatterns);
   }
+  normalizeLspServerArgs(config);
   config = applyEnvVars(config);
   try {
     const encryptor = new ConfigEncryptor;
@@ -4091,13 +4160,22 @@ function saveConfig(config, configPath) {
     writeFileSync3(configPath, JSON.stringify(config, regexReplacer, 2), "utf-8");
   }
 }
+var LEGACY_LSP_SERVER_ARGS;
 var init_config2 = __esm(() => {
   init_defaults();
   init_security();
+  init_config();
   init_i18n();
   init_detect();
   init_backup();
   init_encryption();
+  LEGACY_LSP_SERVER_ARGS = {
+    typescript: { args: ["typescript-language-server", "--stdio"], timeout: 30000 },
+    javascript: { args: ["typescript-language-server", "--stdio"], timeout: 30000 },
+    json: { args: ["vscode-json-languageserver", "--stdio"], timeout: 30000 },
+    html: { args: ["vscode-html-languageserver", "--stdio"], timeout: 60000 },
+    css: { args: ["vscode-css-languageserver", "--stdio"], timeout: 60000 }
+  };
 });
 
 // src/modules/security/data-sanitizer.ts
@@ -9413,6 +9491,41 @@ function filterToolsByTags(tools, toolTags) {
 }
 
 // src/modules/execution/stuck-detector.ts
+function normalizeErrorSignature(toolName, output) {
+  if (!output)
+    return null;
+  const cleaned = output.replace(ANSI_RE, "").replace(ERROR_LOC_RE, " <path>").split(`
+`).map((l) => l.trim()).filter(Boolean).join(" ").replace(/\s+/g, " ").trim();
+  if (!cleaned)
+    return null;
+  return `${toolName}::${cleaned.slice(0, SIGNATURE_MAX_CHARS)}`;
+}
+function isSearchableError(output) {
+  if (!output || !output.trim())
+    return false;
+  const text = output.trim();
+  return SEARCHABLE_PATTERNS.some((p) => p.test(text));
+}
+function buildSearchQuery(stepDescription, lastBashCommand, lastErrorOutput, toolName, maxQueryChars) {
+  const errorText = (lastErrorOutput || "").replace(ANSI_RE, "").replace(ERROR_LOC_RE, " <path>").split(`
+`).map((l) => l.trim()).filter(Boolean).slice(0, 3).join(" ").replace(/\s+/g, " ").trim();
+  const context = `${stepDescription} ${lastBashCommand}`.toLowerCase();
+  const runtime = RUNTIME_WORDS.find((w) => context.includes(w)) || "";
+  const framework = FRAMEWORK_WORDS.find((w) => context.includes(w)) || "";
+  let query;
+  if (errorText) {
+    query = runtime && !errorText.toLowerCase().includes(runtime) ? `${runtime} ${errorText}` : errorText;
+    if (framework && !query.toLowerCase().includes(framework))
+      query = `${query} ${framework}`;
+    query = `${query} how to fix`;
+  } else if (runtime || framework) {
+    query = `${[runtime, framework, "error", "how to fix"].filter(Boolean).join(" ")}`;
+  } else {
+    query = `${toolName} ${stepDescription} how to fix`;
+  }
+  return query.slice(0, maxQueryChars);
+}
+
 class StuckDetector {
   threshold;
   errorThreshold;
@@ -9434,9 +9547,13 @@ class StuckDetector {
   lastBashOutput = "";
   emptyBashRunCount = 0;
   readOnlyStreak = 0;
-  constructor(threshold = 6, errorThreshold = 3) {
+  errorSignatureCounts = new Map;
+  searchedErrorSignatures = new Set;
+  webSearchThreshold;
+  constructor(threshold = 6, errorThreshold = 3, webSearchThreshold = 5) {
     this.threshold = threshold;
     this.errorThreshold = errorThreshold;
+    this.webSearchThreshold = webSearchThreshold;
   }
   recordIteration(stepId) {
     if (stepId === this.currentStepId) {
@@ -9466,6 +9583,10 @@ class StuckDetector {
     this.lastFailedTool = toolName;
     if (output)
       this.lastErrorOutput = output;
+    const sig = normalizeErrorSignature(toolName, output);
+    if (sig) {
+      this.errorSignatureCounts.set(sig, (this.errorSignatureCounts.get(sig) || 0) + 1);
+    }
   }
   getLastErrorOutput() {
     return this.lastErrorOutput;
@@ -9489,6 +9610,26 @@ class StuckDetector {
   getLastFailedTool() {
     return this.lastFailedTool;
   }
+  getRepeatedErrorSignature() {
+    for (const [sig, count] of this.errorSignatureCounts) {
+      if (count >= this.webSearchThreshold && !this.searchedErrorSignatures.has(sig)) {
+        return sig;
+      }
+    }
+    return null;
+  }
+  getErrorSignatureCount(sig) {
+    return this.errorSignatureCounts.get(sig) || 0;
+  }
+  markErrorSearched(sig) {
+    this.searchedErrorSignatures.add(sig);
+  }
+  unmarkErrorSearched(sig) {
+    this.searchedErrorSignatures.delete(sig);
+  }
+  hasErrorSearched(sig) {
+    return this.searchedErrorSignatures.has(sig);
+  }
   getIterationsOnCurrentStep() {
     return this.iterationsOnCurrentStep;
   }
@@ -9761,6 +9902,8 @@ class StuckDetector {
     this.lastBashOutput = "";
     this.emptyBashRunCount = 0;
     this.readOnlyStreak = 0;
+    this.errorSignatureCounts.clear();
+    this.searchedErrorSignatures.clear();
   }
   resetStepProgress() {
     this.currentStepId = null;
@@ -9774,6 +9917,8 @@ class StuckDetector {
     this.lastBashCommand = "";
     this.lastBashOutput = "";
     this.emptyBashRunCount = 0;
+    this.errorSignatureCounts.clear();
+    this.searchedErrorSignatures.clear();
   }
   resetStepState(stepId) {
     this.currentStepId = stepId;
@@ -9788,9 +9933,11 @@ class StuckDetector {
     this.lastBashOutput = "";
     this.emptyBashRunCount = 0;
     this.readOnlyStreak = 0;
+    this.errorSignatureCounts.clear();
+    this.searchedErrorSignatures.clear();
   }
 }
-var READ_ONLY_TOOLS, READ_ONLY_LOOP_THRESHOLD = 10;
+var READ_ONLY_TOOLS, READ_ONLY_LOOP_THRESHOLD = 10, ANSI_RE, ERROR_LOC_RE, SIGNATURE_MAX_CHARS = 120, SEARCHABLE_PATTERNS, RUNTIME_WORDS, FRAMEWORK_WORDS;
 var init_stuck_detector = __esm(() => {
   init_i18n();
   READ_ONLY_TOOLS = new Set([
@@ -9814,6 +9961,55 @@ var init_stuck_detector = __esm(() => {
     "verify",
     "load_skill"
   ]);
+  ANSI_RE = /\x1b\[[0-9;]*m/g;
+  ERROR_LOC_RE = /(?:[A-Za-z]:[\\/])?(?:[\w.@+-]+[\\/])+[\w.@+-]+\.[a-zA-Z0-9]{1,6}(?::\d+(?::\d+)?)?/g;
+  SEARCHABLE_PATTERNS = [
+    /error TS\d+/i,
+    /ERR_[A-Z_]+/,
+    /ENOENT|EACCES|EPERM|ECONNREFUSED|ETIMEDOUT|ECONNRESET|ENOTFOUND|EADDRINUSE/i,
+    /Cannot find module|Module not found|ERR_MODULE_NOT_FOUND/i,
+    /TypeError|ReferenceError|SyntaxError|RangeError/i,
+    /is not a function|is not defined|is not a constructor/i,
+    /Cannot read properties of/i,
+    /failed to (compile|build|resolve|parse)/i,
+    /fatal error|panic/i
+  ];
+  RUNTIME_WORDS = [
+    "bun",
+    "node",
+    "deno",
+    "npm",
+    "yarn",
+    "pnpm",
+    "pip",
+    "pip3",
+    "python",
+    "python3",
+    "tsc",
+    "tsx",
+    "npx",
+    "go",
+    "cargo",
+    "gradle",
+    "maven",
+    "make"
+  ];
+  FRAMEWORK_WORDS = [
+    "react",
+    "vue",
+    "angular",
+    "svelte",
+    "vite",
+    "next",
+    "nest",
+    "express",
+    "fastify",
+    "flask",
+    "django",
+    "spring",
+    "webpack",
+    "tailwind"
+  ];
 });
 
 // src/modules/artifacts/store.ts
@@ -10192,215 +10388,720 @@ function findProjectRoot(filePath, baseDir, markers) {
 }
 var init_project_root = () => {};
 
-// src/modules/execution/verifier.ts
-import { existsSync as existsSync20 } from "fs";
-import { resolve as resolve11, extname as extname2, join as join11 } from "path";
-import { spawn as spawn2 } from "child_process";
-
-class StepVerifier {
-  baseDir;
-  constructor(baseDir) {
-    this.baseDir = baseDir;
-  }
-  async checkFileExists(path) {
-    const resolved = resolve11(this.baseDir, path);
-    const exists = existsSync20(resolved);
-    return {
-      passed: exists,
-      message: exists ? t("verify.file_exists", { path }) : t("verify.file_not_found", { path })
-    };
-  }
-  async runScript(scriptName) {
-    try {
-      await this.runAsync(`bun run ${scriptName}`, this.baseDir, 60000);
-      return { passed: true, message: t("verify.script_passed", { script: scriptName }) };
-    } catch (e) {
-      return {
-        passed: false,
-        message: t("verify.script_failed", { script: scriptName, message: e.message })
-      };
-    }
-  }
-  async runTypeCheck() {
-    const tsconfigPath = resolve11(this.baseDir, "tsconfig.json");
-    if (!existsSync20(tsconfigPath)) {
-      return { passed: true, message: "No tsconfig.json found — skipping type check" };
-    }
-    try {
-      await this.runAsync("npx tsc --noEmit", this.baseDir, 60000);
-      return { passed: true, message: "TypeScript type check passed" };
-    } catch (e) {
-      const stderr = e.stderr?.toString() || e.stdout?.toString() || e.message;
-      return { passed: false, message: `TypeScript type check failed: ${stderr.slice(0, 500)}` };
-    }
-  }
-  async runTypeCheckForFile(filePath) {
-    const projectRoot = findProjectRoot(filePath, this.baseDir, ["tsconfig.json", "package.json"]);
-    const tsconfigPath = join11(projectRoot, "tsconfig.json");
-    if (!existsSync20(tsconfigPath)) {
-      return { passed: true, message: "No tsconfig.json found — skipping type check" };
-    }
-    try {
-      await this.runAsync("npx tsc --noEmit --skipLibCheck", projectRoot, 60000);
-      return { passed: true, message: "TypeScript type check passed" };
-    } catch (e) {
-      const stderr = e.stderr?.toString() || e.stdout?.toString() || e.message;
-      return { passed: false, message: `TypeScript type check failed: ${stderr.slice(0, 500)}` };
-    }
-  }
-  async runTests() {
-    const pkgPath = resolve11(this.baseDir, "package.json");
-    if (!existsSync20(pkgPath)) {
-      return { passed: true, message: "No package.json found — skipping tests" };
-    }
-    try {
-      const pkg = JSON.parse(__require("fs").readFileSync(pkgPath, "utf-8"));
-      if (!pkg.scripts?.test) {
-        return { passed: true, message: "No test script defined — skipping tests" };
-      }
-    } catch {}
-    return this.runScript("test");
-  }
-  async verifyArtifactFiles(files) {
-    return Promise.all(files.map((f) => this.checkFileExists(f)));
-  }
-  async verifyMoEManifest(plan, config, allToolTags) {
-    const errors = [];
-    const warnings = [];
-    const details = [];
-    const expertErrors = validateExpertConfig(config, allToolTags);
-    for (const err of expertErrors) {
-      errors.push(err);
-      details.push({ passed: false, message: err });
-    }
-    const tscResult = await this.runTypeCheck();
-    details.push(tscResult);
-    if (!tscResult.passed) {
-      errors.push(tscResult.message);
-    }
-    for (const sub of plan.subtasks) {
-      const fileChecks = await this.verifyArtifactFiles(sub.allowed_files || []);
-      for (const check of fileChecks) {
-        details.push(check);
-        if (!check.passed) {
-          errors.push(check.message);
-        }
-      }
-    }
-    return {
-      success: errors.length === 0,
-      errors,
-      warnings,
-      details
-    };
-  }
-  async verifyStep(stepDescription) {
-    const fileMatches = stepDescription.match(/\b[\w./-]+\.[a-z]+/gi) || [];
-    const results = [];
-    let syntaxValid = true;
-    for (const filePath of fileMatches) {
-      const result = await this.checkFileExists(filePath);
-      results.push(result);
-      if (result.passed) {
-        const fullPath = resolve11(this.baseDir, filePath);
-        if (!await this.validateSyntax(fullPath)) {
-          syntaxValid = false;
-          results.push({ passed: false, message: t("verify.syntax_error", { path: filePath }) });
-        }
-      }
-    }
-    return {
-      passed: results.every((r) => r.passed),
-      syntaxValid,
-      failed: results.filter((r) => !r.passed)
-    };
-  }
-  async validateSyntax(filePath) {
-    const ext = extname2(filePath);
-    if (ext === ".ts" || ext === ".tsx" || ext === ".cts" || ext === ".mts") {
-      try {
-        await this.runAsync(`npx tsc --noEmit --skipLibCheck ${filePath}`, this.baseDir, 1e4);
-        return true;
-      } catch (err) {
-        if (err.status === 127 || err.message.includes("not found") || err.message.includes("ENOENT")) {
-          return true;
-        }
-        const stderr = err.stderr?.toString() || "";
-        if (stderr.includes("error TS") && !stderr.includes("Cannot find module")) {
-          return false;
-        }
-        return true;
-      }
-    }
-    if (ext === ".js" || ext === ".jsx" || ext === ".cjs" || ext === ".mjs") {
-      try {
-        await this.runAsync(`node --check ${filePath}`, this.baseDir, 5000);
-        return true;
-      } catch {
-        return false;
-      }
-    }
-    return true;
-  }
-  runAsync(command, cwd, timeoutMs) {
-    return new Promise((resolve12, reject) => {
-      const child = spawn2(command, {
-        cwd,
-        shell: true,
-        windowsHide: true,
-        stdio: ["ignore", "pipe", "pipe"]
-      });
-      let stdout = "";
-      let stderr = "";
-      child.stdout?.on("data", (d) => {
-        stdout += d.toString();
-      });
-      child.stderr?.on("data", (d) => {
-        stderr += d.toString();
-      });
-      const timer = setTimeout(() => {
-        child.kill();
-        reject(new Error(`Command timed out after ${timeoutMs}ms`));
-      }, timeoutMs);
-      child.on("error", (err) => {
-        clearTimeout(timer);
-        reject(err);
-      });
-      child.on("close", (code) => {
-        clearTimeout(timer);
-        if (code === 0) {
-          resolve12({ stdout, stderr });
-        } else {
-          const err = new Error(`Command failed with exit code ${code}`);
-          err.stdout = stdout;
-          err.stderr = stderr;
-          err.status = code;
-          reject(err);
-        }
-      });
-    });
-  }
+// src/modules/hallucination/js-identifiers.ts
+function isJsMemberAccess(candidate) {
+  const lower = candidate.toLowerCase();
+  const m = lower.match(/^([\w-]+)\./);
+  return m !== null && JS_GLOBALS.has(m[1]);
 }
-var init_verifier = __esm(() => {
-  init_i18n();
-  init_project_root();
-});
-
-// src/core/agent-moe.ts
-async function runWithMoE(deps, input, fallback, opts = {}) {
-  const { config, llmProvider, logger, toolExecutor, baseDir } = deps;
-  const { onMeta, onPhase } = opts;
-  const orchestrator = new OrchestratorClient({
-    model: config.orchestrator.model,
-    provider: config.orchestrator.provider
-  }, llmProvider);
-  if (!orchestrator.isEnabled()) {
-    logger.debug("MoE enabled but no orchestrator model configured — falling back to single-agent");
-    return fallback();
+function isFilePathLike(s) {
+  const lower = s.toLowerCase();
+  if (TECH_NAMES.has(lower))
+    return false;
+  if (isJsMemberAccess(s))
+    return false;
+  const ext = s.split(".").pop()?.toLowerCase() || "";
+  if (!s.includes("/") && !s.includes("\\")) {
+    if (!/^\w+\.[a-z]{1,6}$/i.test(s))
+      return false;
+    return FILE_EXTENSIONS.has(ext);
   }
-  onMeta?.(`\uD83E\uDD16 Planning with MoE mode...
-`);
-  onPhase?.("thinking");
+  const last = s.split(/[\\/]/).pop() ?? "";
+  const lastDot = last.lastIndexOf(".");
+  if (lastDot <= 0)
+    return false;
+  return true;
+}
+function extractFileLikeTokens(text) {
+  const matches = text.match(FILE_TOKEN_RE) || [];
+  return [...new Set(matches.filter(isFilePathLike))];
+}
+function stripUrls(text) {
+  return text.replace(/\bhttps?:\/\/[^\s"'<>]+/gi, " ");
+}
+var JS_GLOBALS, FILE_EXTENSIONS, TECH_NAMES, FILE_TOKEN_RE;
+var init_js_identifiers = __esm(() => {
+  JS_GLOBALS = new Set([
+    "process",
+    "console",
+    "math",
+    "json",
+    "global",
+    "globalthis",
+    "window",
+    "document",
+    "buffer",
+    "module",
+    "require",
+    "exports",
+    "url",
+    "promise",
+    "array",
+    "object",
+    "string",
+    "number",
+    "boolean",
+    "symbol",
+    "date",
+    "regexp",
+    "error",
+    "map",
+    "set",
+    "weakmap",
+    "weakset",
+    "proxy",
+    "reflect",
+    "intl",
+    "crypto",
+    "performance",
+    "fetch",
+    "navigator",
+    "location",
+    "settimeout",
+    "setinterval",
+    "cleartimeout",
+    "clearinterval",
+    "queuemicrotask",
+    "structuredclone",
+    "textencoder",
+    "textdecoder",
+    "atomics",
+    "sharedarraybuffer",
+    "dataview",
+    "arraybuffer",
+    "bigint",
+    "infinity",
+    "nan",
+    "undefined",
+    "bun",
+    "deno",
+    "node"
+  ]);
+  FILE_EXTENSIONS = new Set([
+    "ts",
+    "tsx",
+    "js",
+    "jsx",
+    "mjs",
+    "cjs",
+    "py",
+    "pyc",
+    "rb",
+    "go",
+    "rs",
+    "java",
+    "jar",
+    "kt",
+    "kts",
+    "c",
+    "h",
+    "cc",
+    "cpp",
+    "cxx",
+    "hpp",
+    "hh",
+    "cs",
+    "php",
+    "swift",
+    "m",
+    "mm",
+    "lua",
+    "pl",
+    "sh",
+    "bash",
+    "zsh",
+    "fish",
+    "bat",
+    "cmd",
+    "ps1",
+    "vue",
+    "svelte",
+    "dart",
+    "json",
+    "jsonc",
+    "json5",
+    "yaml",
+    "yml",
+    "toml",
+    "ini",
+    "cfg",
+    "conf",
+    "env",
+    "xml",
+    "html",
+    "htm",
+    "md",
+    "markdown",
+    "rst",
+    "txt",
+    "log",
+    "csv",
+    "tsv",
+    "lock",
+    "sql",
+    "sqlite",
+    "db",
+    "wasm",
+    "map",
+    "css",
+    "scss",
+    "sass",
+    "less",
+    "svg",
+    "png",
+    "jpg",
+    "jpeg",
+    "gif",
+    "webp",
+    "bmp",
+    "ico",
+    "avif",
+    "tiff",
+    "pdf",
+    "doc",
+    "docx",
+    "xls",
+    "xlsx",
+    "ppt",
+    "pptx",
+    "odt",
+    "ods",
+    "zip",
+    "gz",
+    "tar",
+    "tgz",
+    "bz2",
+    "xz",
+    "7z",
+    "rar",
+    "bin",
+    "exe",
+    "dll",
+    "so",
+    "o",
+    "a",
+    "dylib"
+  ]);
+  TECH_NAMES = new Set([
+    "node.js",
+    "react.js",
+    "vue.js",
+    "next.js",
+    "angular.js",
+    "express.js",
+    "deno.js",
+    "qwik.js",
+    "svelte.js",
+    "jquery.js"
+  ]);
+  FILE_TOKEN_RE = /\b(?:[a-zA-Z]:[\\/])?[\w./\\-]+\.[a-z]{1,6}\b/gi;
+});
+
+// src/modules/execution/audit-runners.ts
+import { existsSync as existsSync20, readdirSync as readdirSync5 } from "fs";
+import { dirname as dirname7, join as join11, resolve as resolve11 } from "path";
+function findTestFile(dir, depth = 0) {
+  if (depth > 5)
+    return null;
+  let entries;
+  try {
+    entries = readdirSync5(dir, { withFileTypes: true });
+  } catch {
+    return null;
+  }
+  for (const e of entries) {
+    const full = join11(dir, e.name);
+    if (e.isDirectory()) {
+      if (SKIP_DIRS.has(e.name))
+        continue;
+      const found = findTestFile(full, depth + 1);
+      if (found)
+        return found;
+    } else if (TEST_EXT_RE.test(e.name)) {
+      return full;
+    }
+  }
+  return null;
+}
+function hasTestStep(plan) {
+  return plan.steps.some((s) => TEST_STEP_RE.test(s.description));
+}
+function extractFailingNames(output, limit = 5) {
+  const names = [];
+  for (const m of output.matchAll(/\(fail\)\s*([^\n]+)/g)) {
+    const name = m[1].trim();
+    if (name && !names.includes(name))
+      names.push(name);
+    if (names.length >= limit)
+      break;
+  }
+  return names;
+}
+async function runTests(baseDir) {
+  const entry = processRegistry.start("bun test", baseDir);
+  const exited = await processRegistry.waitForExit(entry.id, 90000);
+  const output = entry.log.join(`
+`);
+  processRegistry.remove(entry.id);
+  if (!exited) {
+    return {
+      checked: true,
+      passed: true,
+      failed: 0,
+      passedCount: 0,
+      detail: "test run timed out after 90s — result unknown",
+      command: "bun test"
+    };
+  }
+  const run = detectTestResults(output);
+  if (!run) {
+    return {
+      checked: true,
+      passed: entry.exitCode === 0,
+      failed: entry.exitCode === 0 ? 0 : 1,
+      passedCount: 0,
+      detail: output.slice(0, 200).trim(),
+      command: "bun test"
+    };
+  }
+  const names = extractFailingNames(output);
+  return {
+    checked: true,
+    passed: run.failed === 0,
+    failed: run.failed,
+    passedCount: run.passed,
+    detail: names.length ? names.join("; ") : run.summary || `${run.failed} failed / ${run.passed} passed`,
+    command: "bun test"
+  };
+}
+function parseTypecheckErrors(output) {
+  const line = output.split(`
+`).find((l) => /error TS\d+/.test(l));
+  return line ? line.trim().slice(0, 300) : null;
+}
+function findTypecheckRoot(baseDir, existingFiles = []) {
+  const candidates = [baseDir, ...existingFiles];
+  let best = null;
+  for (const start of candidates) {
+    let dir = resolve11(start);
+    for (let depth = 0;depth <= 10; depth++) {
+      if (existsSync20(join11(dir, "tsconfig.json"))) {
+        if (!best || depth < best.depth)
+          best = { depth, root: dir };
+        break;
+      }
+      const parent = dirname7(dir);
+      if (parent === dir)
+        break;
+      dir = parent;
+    }
+  }
+  return best?.root ?? null;
+}
+async function runTypecheck(baseDir) {
+  const entry = processRegistry.start("npx --no-install tsc --noEmit --skipLibCheck", baseDir);
+  const exited = await processRegistry.waitForExit(entry.id, 90000);
+  const output = entry.log.join(`
+`);
+  processRegistry.remove(entry.id);
+  if (!exited)
+    return null;
+  return parseTypecheckErrors(output);
+}
+var SKIP_DIRS, TEST_EXT_RE, TEST_STEP_RE;
+var init_audit_runners = __esm(() => {
+  init_bash();
+  init_processes();
+  SKIP_DIRS = new Set([
+    "node_modules",
+    ".git",
+    ".mma",
+    "dist",
+    "build",
+    "coverage",
+    ".next",
+    ".nuxt",
+    "vendor"
+  ]);
+  TEST_EXT_RE = /\.(test|spec)\.[jt]sx?$/i;
+  TEST_STEP_RE = /\b(test(ing|s)?|тест(ы|ирование|ировать)?|провер\w*\s+тест|запустить\s+тест)\b|bun test|npm test|vitest|pytest|go test|jest|mocha/i;
+});
+
+// src/modules/execution/auditor.ts
+import { existsSync as existsSync21, readdirSync as readdirSync6 } from "fs";
+import { resolve as resolve12, join as join12, basename as basename2 } from "path";
+function findExistingFile(baseDir, filePath) {
+  const direct = resolve12(baseDir, filePath);
+  if (existsSync21(direct))
+    return direct;
+  const name = basename2(filePath).toLowerCase();
+  const suffix = filePath.replace(/\\/g, "/").toLowerCase();
+  let found = null;
+  const walk = (dir, depth) => {
+    if (found || depth > RESOLVE_MAX_DEPTH)
+      return;
+    let entries;
+    try {
+      entries = readdirSync6(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const e of entries) {
+      if (found)
+        return;
+      const full = join12(dir, e.name);
+      if (e.isDirectory()) {
+        if (SKIP_DIRS.has(e.name))
+          continue;
+        walk(full, depth + 1);
+      } else if (e.name.toLowerCase() === name || full.replace(/\\/g, "/").toLowerCase().endsWith("/" + suffix)) {
+        found = full;
+        return;
+      }
+    }
+  };
+  walk(baseDir, 0);
+  return found;
+}
+
+class Auditor {
+  baseDir;
+  constructor(baseDir) {
+    this.baseDir = baseDir;
+  }
+  async audit(plan) {
+    const doneCreate = plan.steps.filter((s) => s.status === "done" && s.kind !== "delete");
+    const doneDelete = plan.steps.filter((s) => s.status === "done" && s.kind === "delete");
+    const createText = doneCreate.map((s) => s.description.replace(/\([^)]*\)/g, " ")).join(" ");
+    const deleteText = doneDelete.map((s) => s.description.replace(/\([^)]*\)/g, " ")).join(" ");
+    const createFiles = extractFileLikeTokens(stripUrls(createText));
+    const deleteFiles = extractFileLikeTokens(stripUrls(deleteText));
+    const missingFiles = [];
+    const existingFiles = [];
+    const leftoverFiles = [];
+    for (const filePath of createFiles) {
+      const resolved = findExistingFile(this.baseDir, filePath);
+      if (resolved) {
+        existingFiles.push(resolved);
+      } else {
+        missingFiles.push(filePath);
+      }
+    }
+    for (const filePath of deleteFiles) {
+      if (findExistingFile(this.baseDir, filePath)) {
+        leftoverFiles.push(filePath);
+      }
+    }
+    let testRun = null;
+    if (hasTestStep(plan) && findTestFile(this.baseDir)) {
+      try {
+        testRun = await runTests(this.baseDir);
+      } catch {
+        testRun = null;
+      }
+    }
+    let typecheckError = null;
+    if (missingFiles.length === 0 && leftoverFiles.length === 0) {
+      const root = findTypecheckRoot(this.baseDir, existingFiles);
+      if (root) {
+        try {
+          typecheckError = await runTypecheck(root);
+        } catch {
+          typecheckError = null;
+        }
+      }
+    }
+    const doneSteps = plan.steps.filter((s) => s.status === "done").length;
+    const terminalSteps = plan.steps.filter((s) => s.status === "done" || s.status === "skipped").length;
+    const totalSteps = plan.steps.length;
+    const auditedFiles = [...new Set([...createFiles, ...deleteFiles])];
+    let massEditWarning = null;
+    if (auditedFiles.length > MASS_EDIT_THRESHOLD) {
+      massEditWarning = t("exec.mass_edit_warning", {
+        count: String(auditedFiles.length)
+      });
+    }
+    const testsFailing = testRun !== null && !testRun.passed;
+    const typecheckFailing = typecheckError !== null;
+    const passed = missingFiles.length === 0 && leftoverFiles.length === 0 && !testsFailing && !typecheckFailing;
+    const stepsPending = terminalSteps < totalSteps;
+    let summary;
+    if (missingFiles.length > 0) {
+      summary = t("exec.audit_fail", {
+        done: doneSteps,
+        total: totalSteps,
+        files: missingFiles.length
+      });
+    } else if (leftoverFiles.length > 0) {
+      summary = t("exec.audit_leftovers", {
+        done: doneSteps,
+        total: totalSteps,
+        files: leftoverFiles.length
+      });
+    } else if (testsFailing) {
+      summary = t("exec.audit_fail_tests", {
+        done: doneSteps,
+        total: totalSteps,
+        failed: String(testRun.failed),
+        passed: String(testRun.passedCount),
+        detail: testRun.detail
+      });
+    } else if (typecheckFailing) {
+      summary = t("exec.audit_fail_typecheck", {
+        done: doneSteps,
+        total: totalSteps,
+        missing: String(missingFiles.length),
+        typeError: typecheckError
+      });
+    } else if (stepsPending) {
+      summary = t("exec.audit_pending", {
+        done: doneSteps,
+        total: totalSteps
+      });
+    } else {
+      summary = t("exec.audit_pass", {
+        done: doneSteps,
+        total: totalSteps,
+        files: existingFiles.length
+      });
+    }
+    return {
+      passed,
+      missingFiles,
+      leftoverFiles,
+      createdFiles: existingFiles,
+      modifiedFiles: [],
+      summary,
+      massEditWarning,
+      testRun,
+      typecheckError
+    };
+  }
+}
+var MASS_EDIT_THRESHOLD = 10, RESOLVE_MAX_DEPTH = 8;
+var init_auditor = __esm(() => {
+  init_i18n();
+  init_js_identifiers();
+  init_audit_runners();
+  init_audit_runners();
+});
+
+// src/modules/execution/verifier.ts
+import { existsSync as existsSync22 } from "fs";
+import { resolve as resolve13, extname as extname2, join as join13 } from "path";
+import { spawn as spawn2 } from "child_process";
+
+class StepVerifier {
+  baseDir;
+  constructor(baseDir) {
+    this.baseDir = baseDir;
+  }
+  async checkFileExists(path) {
+    const resolved = resolve13(this.baseDir, path);
+    const exists = existsSync22(resolved);
+    return {
+      passed: exists,
+      message: exists ? t("verify.file_exists", { path }) : t("verify.file_not_found", { path })
+    };
+  }
+  async runScript(scriptName) {
+    try {
+      await this.runAsync(`bun run ${scriptName}`, this.baseDir, 60000);
+      return { passed: true, message: t("verify.script_passed", { script: scriptName }) };
+    } catch (e) {
+      return {
+        passed: false,
+        message: t("verify.script_failed", { script: scriptName, message: e.message })
+      };
+    }
+  }
+  async runTypeCheck() {
+    const tsconfigPath = resolve13(this.baseDir, "tsconfig.json");
+    if (!existsSync22(tsconfigPath)) {
+      return { passed: true, message: "No tsconfig.json found — skipping type check" };
+    }
+    try {
+      await this.runAsync("npx tsc --noEmit", this.baseDir, 60000);
+      return { passed: true, message: "TypeScript type check passed" };
+    } catch (e) {
+      const stderr = e.stderr?.toString() || e.stdout?.toString() || e.message;
+      return { passed: false, message: `TypeScript type check failed: ${stderr.slice(0, 500)}` };
+    }
+  }
+  async runTypeCheckForFile(filePath) {
+    const projectRoot = findProjectRoot(filePath, this.baseDir, ["tsconfig.json", "package.json"]);
+    const tsconfigPath = join13(projectRoot, "tsconfig.json");
+    if (!existsSync22(tsconfigPath)) {
+      return { passed: true, message: "No tsconfig.json found — skipping type check" };
+    }
+    try {
+      await this.runAsync("npx tsc --noEmit --skipLibCheck", projectRoot, 60000);
+      return { passed: true, message: "TypeScript type check passed" };
+    } catch (e) {
+      const stderr = e.stderr?.toString() || e.stdout?.toString() || e.message;
+      return { passed: false, message: `TypeScript type check failed: ${stderr.slice(0, 500)}` };
+    }
+  }
+  async runTests() {
+    const pkgPath = resolve13(this.baseDir, "package.json");
+    if (!existsSync22(pkgPath)) {
+      return { passed: true, message: "No package.json found — skipping tests" };
+    }
+    try {
+      const pkg = JSON.parse(__require("fs").readFileSync(pkgPath, "utf-8"));
+      if (!pkg.scripts?.test) {
+        return { passed: true, message: "No test script defined — skipping tests" };
+      }
+    } catch {}
+    return this.runScript("test");
+  }
+  async verifyArtifactFiles(files) {
+    return Promise.all(files.map((f) => this.checkFileExists(f)));
+  }
+  async verifyMoEManifest(plan, config, allToolTags) {
+    const errors = [];
+    const warnings = [];
+    const details = [];
+    const expertErrors = validateExpertConfig(config, allToolTags);
+    for (const err of expertErrors) {
+      errors.push(err);
+      details.push({ passed: false, message: err });
+    }
+    const tscResult = await this.runTypeCheck();
+    details.push(tscResult);
+    if (!tscResult.passed) {
+      errors.push(tscResult.message);
+    }
+    for (const sub of plan.subtasks) {
+      const fileChecks = await this.verifyArtifactFiles(sub.allowed_files || []);
+      for (const check of fileChecks) {
+        details.push(check);
+        if (!check.passed) {
+          errors.push(check.message);
+        }
+      }
+    }
+    return {
+      success: errors.length === 0,
+      errors,
+      warnings,
+      details
+    };
+  }
+  async verifyStep(stepDescription) {
+    const fileMatches = extractFileLikeTokens(stripUrls(stepDescription));
+    if (fileMatches.length === 0) {
+      return { passed: false, syntaxValid: true, failed: [], noFiles: true };
+    }
+    const results = [];
+    let syntaxValid = true;
+    for (const filePath of fileMatches) {
+      const resolved = findExistingFile(this.baseDir, filePath);
+      if (!resolved) {
+        results.push({ passed: false, message: t("verify.file_not_found", { path: filePath }) });
+        continue;
+      }
+      results.push({ passed: true, message: t("verify.file_exists", { path: filePath }) });
+      if (!await this.validateSyntax(resolved)) {
+        syntaxValid = false;
+        results.push({ passed: false, message: t("verify.syntax_error", { path: filePath }) });
+      }
+    }
+    return {
+      passed: results.every((r) => r.passed),
+      syntaxValid,
+      failed: results.filter((r) => !r.passed),
+      noFiles: false
+    };
+  }
+  async validateSyntax(filePath) {
+    const ext = extname2(filePath);
+    if (ext === ".ts" || ext === ".tsx" || ext === ".cts" || ext === ".mts") {
+      try {
+        await this.runAsync(`npx tsc --noEmit --skipLibCheck ${filePath}`, this.baseDir, 1e4);
+        return true;
+      } catch (err) {
+        if (err.status === 127 || err.message.includes("not found") || err.message.includes("ENOENT")) {
+          return true;
+        }
+        const stderr = err.stderr?.toString() || "";
+        if (stderr.includes("error TS") && !stderr.includes("Cannot find module")) {
+          return false;
+        }
+        return true;
+      }
+    }
+    if (ext === ".js" || ext === ".jsx" || ext === ".cjs" || ext === ".mjs") {
+      try {
+        await this.runAsync(`node --check ${filePath}`, this.baseDir, 5000);
+        return true;
+      } catch {
+        return false;
+      }
+    }
+    return true;
+  }
+  runAsync(command, cwd, timeoutMs) {
+    return new Promise((resolve14, reject) => {
+      const child = spawn2(command, {
+        cwd,
+        shell: true,
+        windowsHide: true,
+        stdio: ["ignore", "pipe", "pipe"]
+      });
+      let stdout = "";
+      let stderr = "";
+      child.stdout?.on("data", (d) => {
+        stdout += d.toString();
+      });
+      child.stderr?.on("data", (d) => {
+        stderr += d.toString();
+      });
+      const timer = setTimeout(() => {
+        child.kill();
+        reject(new Error(`Command timed out after ${timeoutMs}ms`));
+      }, timeoutMs);
+      child.on("error", (err) => {
+        clearTimeout(timer);
+        reject(err);
+      });
+      child.on("close", (code) => {
+        clearTimeout(timer);
+        if (code === 0) {
+          resolve14({ stdout, stderr });
+        } else {
+          const err = new Error(`Command failed with exit code ${code}`);
+          err.stdout = stdout;
+          err.stderr = stderr;
+          err.status = code;
+          reject(err);
+        }
+      });
+    });
+  }
+}
+var init_verifier = __esm(() => {
+  init_i18n();
+  init_project_root();
+  init_js_identifiers();
+  init_auditor();
+});
+
+// src/core/agent-moe.ts
+async function runWithMoE(deps, input, fallback, opts = {}) {
+  const { config, llmProvider, logger, toolExecutor, baseDir } = deps;
+  const { onMeta, onPhase } = opts;
+  const orchestrator = new OrchestratorClient({
+    model: config.orchestrator.model,
+    provider: config.orchestrator.provider
+  }, llmProvider);
+  if (!orchestrator.isEnabled()) {
+    logger.debug("MoE enabled but no orchestrator model configured — falling back to single-agent");
+    return fallback();
+  }
+  onMeta?.(`\uD83E\uDD16 Planning with MoE mode...
+`);
+  onPhase?.("thinking");
   const planResult = await orchestrator.plan(input);
   onPhase?.("done");
   if ("error" in planResult) {
@@ -10640,6 +11341,10 @@ ${t("tool.truncated", { tokens: Math.ceil(removedChars / 2) })}`;
       logger.debug(`Session started: ${sessionManager.getActive()}`);
     }
     if (!this.systemPromptAdded && !contextManager.getActiveHistory().some((m) => m.role === "system")) {
+      const lazy = this.deps.lazyPromptBlocks ? await this.deps.lazyPromptBlocks() : [];
+      if (lazy.length > 0) {
+        this.deps.promptBlocks.push(...lazy);
+      }
       const { prompt: systemPrompt, excluded } = this.buildSystemPrompt();
       contextManager.addMessage({ role: "system", content: systemPrompt });
       this.systemPromptAdded = true;
@@ -11840,218 +12545,9 @@ var init_confidence = __esm(() => {
   init_i18n();
 });
 
-// src/modules/hallucination/js-identifiers.ts
-function isJsMemberAccess(candidate) {
-  const lower = candidate.toLowerCase();
-  const m = lower.match(/^([\w-]+)\./);
-  return m !== null && JS_GLOBALS.has(m[1]);
-}
-function isFilePathLike(s) {
-  const lower = s.toLowerCase();
-  if (TECH_NAMES.has(lower))
-    return false;
-  if (isJsMemberAccess(s))
-    return false;
-  const ext = s.split(".").pop()?.toLowerCase() || "";
-  if (!s.includes("/") && !s.includes("\\")) {
-    if (!/^\w+\.[a-z]{1,6}$/i.test(s))
-      return false;
-    return FILE_EXTENSIONS.has(ext);
-  }
-  const last = s.split(/[\\/]/).pop() ?? "";
-  const lastDot = last.lastIndexOf(".");
-  if (lastDot <= 0)
-    return false;
-  return true;
-}
-function extractFileLikeTokens(text) {
-  const matches = text.match(FILE_TOKEN_RE) || [];
-  return [...new Set(matches.filter(isFilePathLike))];
-}
-function stripUrls(text) {
-  return text.replace(/\bhttps?:\/\/[^\s"'<>]+/gi, " ");
-}
-var JS_GLOBALS, FILE_EXTENSIONS, TECH_NAMES, FILE_TOKEN_RE;
-var init_js_identifiers = __esm(() => {
-  JS_GLOBALS = new Set([
-    "process",
-    "console",
-    "math",
-    "json",
-    "global",
-    "globalthis",
-    "window",
-    "document",
-    "buffer",
-    "module",
-    "require",
-    "exports",
-    "url",
-    "promise",
-    "array",
-    "object",
-    "string",
-    "number",
-    "boolean",
-    "symbol",
-    "date",
-    "regexp",
-    "error",
-    "map",
-    "set",
-    "weakmap",
-    "weakset",
-    "proxy",
-    "reflect",
-    "intl",
-    "crypto",
-    "performance",
-    "fetch",
-    "navigator",
-    "location",
-    "settimeout",
-    "setinterval",
-    "cleartimeout",
-    "clearinterval",
-    "queuemicrotask",
-    "structuredclone",
-    "textencoder",
-    "textdecoder",
-    "atomics",
-    "sharedarraybuffer",
-    "dataview",
-    "arraybuffer",
-    "bigint",
-    "infinity",
-    "nan",
-    "undefined",
-    "bun",
-    "deno",
-    "node"
-  ]);
-  FILE_EXTENSIONS = new Set([
-    "ts",
-    "tsx",
-    "js",
-    "jsx",
-    "mjs",
-    "cjs",
-    "py",
-    "pyc",
-    "rb",
-    "go",
-    "rs",
-    "java",
-    "jar",
-    "kt",
-    "kts",
-    "c",
-    "h",
-    "cc",
-    "cpp",
-    "cxx",
-    "hpp",
-    "hh",
-    "cs",
-    "php",
-    "swift",
-    "m",
-    "mm",
-    "lua",
-    "pl",
-    "sh",
-    "bash",
-    "zsh",
-    "fish",
-    "bat",
-    "cmd",
-    "ps1",
-    "vue",
-    "svelte",
-    "dart",
-    "json",
-    "jsonc",
-    "json5",
-    "yaml",
-    "yml",
-    "toml",
-    "ini",
-    "cfg",
-    "conf",
-    "env",
-    "xml",
-    "html",
-    "htm",
-    "md",
-    "markdown",
-    "rst",
-    "txt",
-    "log",
-    "csv",
-    "tsv",
-    "lock",
-    "sql",
-    "sqlite",
-    "db",
-    "wasm",
-    "map",
-    "css",
-    "scss",
-    "sass",
-    "less",
-    "svg",
-    "png",
-    "jpg",
-    "jpeg",
-    "gif",
-    "webp",
-    "bmp",
-    "ico",
-    "avif",
-    "tiff",
-    "pdf",
-    "doc",
-    "docx",
-    "xls",
-    "xlsx",
-    "ppt",
-    "pptx",
-    "odt",
-    "ods",
-    "zip",
-    "gz",
-    "tar",
-    "tgz",
-    "bz2",
-    "xz",
-    "7z",
-    "rar",
-    "bin",
-    "exe",
-    "dll",
-    "so",
-    "o",
-    "a",
-    "dylib"
-  ]);
-  TECH_NAMES = new Set([
-    "node.js",
-    "react.js",
-    "vue.js",
-    "next.js",
-    "angular.js",
-    "express.js",
-    "deno.js",
-    "qwik.js",
-    "svelte.js",
-    "jquery.js"
-  ]);
-  FILE_TOKEN_RE = /\b(?:[a-zA-Z]:[\\/])?[\w./\\-]+\.[a-z]{1,6}\b/gi;
-});
-
 // src/modules/hallucination/factual.ts
-import { existsSync as existsSync21, readdirSync as readdirSync5 } from "fs";
-import { resolve as resolve12, isAbsolute as isAbsolute2, join as join12 } from "path";
+import { existsSync as existsSync23, readdirSync as readdirSync7 } from "fs";
+import { resolve as resolve14, isAbsolute as isAbsolute2, join as join14 } from "path";
 
 class FactualCheck {
   baseDir;
@@ -12086,14 +12582,14 @@ class FactualCheck {
   }
   pathExists(fp) {
     if (isAbsolute2(fp))
-      return existsSync21(fp);
+      return existsSync23(fp);
     if (!fp.includes("/") && !fp.includes("\\")) {
       return this.bareNameExists(fp);
     }
-    return existsSync21(resolve12(this.baseDir, fp));
+    return existsSync23(resolve14(this.baseDir, fp));
   }
   bareNameExists(name) {
-    if (existsSync21(resolve12(this.baseDir, name)))
+    if (existsSync23(resolve14(this.baseDir, name)))
       return true;
     if (this.indexHas(name))
       return true;
@@ -12126,14 +12622,14 @@ class FactualCheck {
       return count;
     let entries;
     try {
-      entries = readdirSync5(dir, { withFileTypes: true });
+      entries = readdirSync7(dir, { withFileTypes: true });
     } catch {
       return count;
     }
     for (const entry of entries) {
       if (count >= FactualCheck.MAX_INDEXED_FILES)
         break;
-      const full = join12(dir, entry.name);
+      const full = join14(dir, entry.name);
       if (entry.isDirectory()) {
         if (!IGNORED_DIRS.has(entry.name)) {
           count = this.scanDir(full, index, count);
@@ -12304,8 +12800,8 @@ var init_detector = __esm(() => {
 });
 
 // src/modules/lsp/command.ts
-import { delimiter, join as join13 } from "path";
-import { existsSync as existsSync22 } from "fs";
+import { delimiter, join as join15 } from "path";
+import { existsSync as existsSync24 } from "fs";
 import { platform as platform3 } from "os";
 function resolveSpawnCommand(command, platformName = platform3(), pathEnv = process.env.PATH ?? "") {
   if (platformName !== "win32")
@@ -12316,8 +12812,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 = join13(dir, `${command}${ext}`);
-      if (existsSync22(candidate))
+      const candidate = join15(dir, `${command}${ext}`);
+      if (existsSync24(candidate))
         return `${command}${ext}`;
     }
   }
@@ -12418,8 +12914,8 @@ class Updater {
 }
 var defaultRunner = async (command, args, options) => {
   const { execFile } = await import("child_process");
-  return new Promise((resolve13) => {
-    execFile(command, args, options, (err) => resolve13({ error: err?.message }));
+  return new Promise((resolve15) => {
+    execFile(command, args, options, (err) => resolve15({ error: err?.message }));
   });
 };
 var init_checker = __esm(() => {
@@ -12789,17 +13285,17 @@ Iterations: ${result.iterationCount}`
 });
 
 // src/tools/scope-check.ts
-import { resolve as resolve13, normalize as normalize4 } from "path";
+import { resolve as resolve15, normalize as normalize4 } from "path";
 function isPathInScope2(baseDir, targetPath, scope) {
-  const baseResolved = resolve13(baseDir);
-  const targetResolved = resolve13(baseDir, normalize4(targetPath));
+  const baseResolved = resolve15(baseDir);
+  const targetResolved = resolve15(baseDir, normalize4(targetPath));
   if (!targetResolved.startsWith(baseResolved)) {
     return { allowed: false, reason: "Path is outside the base working directory" };
   }
   if (!scope)
     return { allowed: true };
-  const isRead = scope.read_only_files.some((f) => targetResolved.startsWith(resolve13(baseDir, f)));
-  const isWrite = scope.allowed_files.some((f) => targetResolved.startsWith(resolve13(baseDir, f)));
+  const isRead = scope.read_only_files.some((f) => targetResolved.startsWith(resolve15(baseDir, f)));
+  const isWrite = scope.allowed_files.some((f) => targetResolved.startsWith(resolve15(baseDir, f)));
   if (isWrite)
     return { allowed: true };
   if (isRead)
@@ -12913,7 +13409,7 @@ var DEFAULT_CHUNK_SYSTEM_PROMPT = 'Answer the query using ONLY the provided text
 
 // src/tools/chunk-query.ts
 import { readFileSync as readFileSync10 } from "node:fs";
-import { resolve as resolve14 } from "node:path";
+import { resolve as resolve16 } from "node:path";
 var chunkQueryTool;
 var init_chunk_query = __esm(() => {
   init_i18n();
@@ -12981,7 +13477,7 @@ var init_chunk_query = __esm(() => {
           return { success: false, output: `[SCOPE] ${check.reason || "Path not allowed"}` };
         }
         try {
-          content = readFileSync10(resolve14(ctx.baseDir, inputPath), "utf8");
+          content = readFileSync10(resolve16(ctx.baseDir, inputPath), "utf8");
         } catch (e) {
           return { success: false, output: `Cannot read ${inputPath}: ${e.message}` };
         }
@@ -13074,6 +13570,43 @@ var init_network_validator = __esm(() => {
 });
 
 // src/tools/web-search.ts
+async function performWebSearch(query, numResults, networkConfig, requestTimeoutMs) {
+  const url = `https://html.duckduckgo.com/html/?q=${encodeURIComponent(query)}`;
+  const validation = isUrlAllowed(url, networkConfig);
+  if (!validation.allowed) {
+    return {
+      success: false,
+      blocked: true,
+      results: [],
+      error: validation.reason || "URL blocked by security policy"
+    };
+  }
+  try {
+    const response = await fetch(url, {
+      signal: AbortSignal.timeout(requestTimeoutMs ?? networkConfig?.requestTimeout ?? 1e4)
+    });
+    const html = await response.text();
+    const results = [];
+    const snippetRegex = /<a[^>]+class="result__a"[^>]*href="([^"]*)"[^>]*>([\s\S]*?)<\/a>[\s\S]*?<a[^>]+class="result__snippet"[^>]*>([\s\S]*?)<\/a>/gi;
+    let match;
+    while ((match = snippetRegex.exec(html)) !== null && results.length < numResults) {
+      results.push({
+        url: match[1].trim(),
+        title: match[2].replace(/<[^>]+>/g, "").trim(),
+        snippet: match[3].replace(/<[^>]+>/g, "").trim()
+      });
+    }
+    return { success: true, results };
+  } catch (err) {
+    return { success: false, results: [], error: err.message };
+  }
+}
+function formatResults(results) {
+  return results.map((r, i) => `${i + 1}. ${r.title}
+   URL: ${r.url}
+   ${r.snippet}`).join(`
+`);
+}
 var webSearchTool;
 var init_web_search = __esm(() => {
   init_i18n();
@@ -13096,59 +13629,42 @@ var init_web_search = __esm(() => {
       required: ["query"]
     },
     handler: async (ctx, args) => {
+      if (ctx.config?.webSearch?.enabled === false) {
+        return { success: false, output: t("tool.web_search_disabled") };
+      }
       const query = String(args.query || "");
       const numResults = Number(args.numResults) || 5;
-      const url = `https://html.duckduckgo.com/html/?q=${encodeURIComponent(query)}`;
       const securityConfig = ctx.sessionContext ? getSessionSecurityConfig(ctx.config, ctx.sessionContext).network : ctx.config.security?.network;
-      const validation = isUrlAllowed(url, securityConfig);
-      if (!validation.allowed) {
-        logSecurityBlock(ctx.sessionId, "network_request", validation.reason || "URL blocked by security policy", sanitizeUrl(url));
-        return {
-          success: false,
-          output: `[SECURITY BLOCKED] Search URL is not allowed: ${validation.reason}`
-        };
-      }
-      try {
-        const response = await fetch(url, {
-          signal: AbortSignal.timeout(securityConfig?.requestTimeout || 1e4)
-        });
-        const html = await response.text();
-        const results = [];
-        const snippetRegex = /<a[^>]+class="result__a"[^>]*href="([^"]*)"[^>]*>([\s\S]*?)<\/a>[\s\S]*?<a[^>]+class="result__snippet"[^>]*>([\s\S]*?)<\/a>/gi;
-        let match;
-        let count = 0;
-        while ((match = snippetRegex.exec(html)) !== null && count < numResults) {
-          const href = match[1].trim();
-          const title = match[2].replace(/<[^>]+>/g, "").trim();
-          const snippet = match[3].replace(/<[^>]+>/g, "").trim();
-          results.push(`${count + 1}. ${title}
-   URL: ${href}
-   ${snippet}`);
-          count++;
-        }
-        logNetworkRequest(ctx.sessionId, sanitizeUrl(url), true, `Results: ${results.length}`);
-        if (results.length === 0) {
-          return { success: true, output: t("tool.no_results", { query }) };
-        }
+      const outcome = await performWebSearch(query, numResults, securityConfig);
+      const url = `https://html.duckduckgo.com/html/?q=${encodeURIComponent(query)}`;
+      if (outcome.blocked) {
+        logSecurityBlock(ctx.sessionId, "network_request", outcome.error || "URL blocked by security policy", sanitizeUrl(url));
         return {
-          success: true,
-          output: t("tool.search_results", {
-            query,
-            results: results.join(`
-`)
-          }),
-          display: t("tool.web_search_result", {
-            query,
-            count: String(results.length)
-          })
+          success: false,
+          output: t("error.search_failed", { message: String(outcome.error) })
         };
-      } catch (err) {
-        logNetworkRequest(ctx.sessionId, sanitizeUrl(url), false, `Error: ${err.message}`);
+      }
+      logNetworkRequest(ctx.sessionId, sanitizeUrl(url), outcome.success, `Results: ${outcome.results.length}`);
+      if (!outcome.success) {
         return {
           success: false,
-          output: t("error.search_failed", { message: err.message })
+          output: t("error.search_failed", { message: String(outcome.error) })
         };
       }
+      if (outcome.results.length === 0) {
+        return { success: true, output: t("tool.no_results", { query }) };
+      }
+      return {
+        success: true,
+        output: t("tool.search_results", {
+          query,
+          results: formatResults(outcome.results)
+        }),
+        display: t("tool.web_search_result", {
+          query,
+          count: String(outcome.results.length)
+        })
+      };
     }
   };
 });
@@ -13323,7 +13839,7 @@ var init_web_browse = __esm(() => {
 
 // src/tools/download-file.ts
 import { writeFileSync as writeFileSync8, mkdirSync as mkdirSync12 } from "fs";
-import { dirname as dirname8 } from "path";
+import { dirname as dirname9 } from "path";
 var MAX_DOWNLOAD_BYTES, downloadFileTool;
 var init_download_file = __esm(() => {
   init_i18n();
@@ -13410,7 +13926,7 @@ var init_download_file = __esm(() => {
             output: t("tool.download_too_large", { max: String(maxBytes) })
           };
         }
-        mkdirSync12(dirname8(resolved), { recursive: true });
+        mkdirSync12(dirname9(resolved), { recursive: true });
         writeFileSync8(resolved, buffer);
         const contentType = response.headers.get("content-type")?.split(";")[0]?.trim() || "unknown";
         logNetworkRequest(ctx.sessionId, sanitizeUrl(url), true, `Status: ${response.status}`);
@@ -13867,7 +14383,7 @@ class MCPClient {
     }
   }
   connectStdio() {
-    return new Promise((resolve15, reject) => {
+    return new Promise((resolve17, reject) => {
       const child = spawn3(this.config.command, this.config.args || [], {
         env: { ...process.env, ...this.config.env },
         stdio: ["pipe", "pipe", "pipe"]
@@ -13891,7 +14407,7 @@ class MCPClient {
         this._connected = true;
         this.process = child;
         _resolved = true;
-        resolve15();
+        resolve17();
       });
     });
   }
@@ -13960,7 +14476,7 @@ class MCPClient {
     if (!this.process) {
       throw new Error("Not connected to MCP server");
     }
-    return new Promise((resolve15, reject) => {
+    return new Promise((resolve17, reject) => {
       const request = {
         jsonrpc: "2.0",
         id: Date.now(),
@@ -13984,7 +14500,7 @@ class MCPClient {
                 if (response.error) {
                   reject(new Error(response.error.message));
                 } else {
-                  resolve15(response.result?.tools || []);
+                  resolve17(response.result?.tools || []);
                 }
                 return;
               }
@@ -14066,8 +14582,8 @@ class MCPClient {
         arguments: args
       }
     };
-    return new Promise((resolve15, reject) => {
-      this.pendingResolve = resolve15;
+    return new Promise((resolve17, reject) => {
+      this.pendingResolve = resolve17;
       this.pendingReject = reject;
       const timeout = this.config.timeout || 30000;
       const timer = setTimeout(() => {
@@ -14094,7 +14610,7 @@ class MCPClient {
         if (result.error) {
           reject(new Error(result.error.message));
         } else {
-          resolve15(result.result || result);
+          resolve17(result.result || result);
         }
       }).catch((err) => {
         clearTimeout(timer);
@@ -14108,7 +14624,7 @@ class MCPClient {
     if (!this.process) {
       throw new Error("Not connected to MCP server");
     }
-    return new Promise((resolve15, reject) => {
+    return new Promise((resolve17, reject) => {
       const request = {
         jsonrpc: "2.0",
         id: Date.now(),
@@ -14136,7 +14652,7 @@ class MCPClient {
                 if (response.error) {
                   reject(new Error(response.error.message));
                 } else {
-                  resolve15(response.result);
+                  resolve17(response.result);
                 }
                 return;
               }
@@ -14247,7 +14763,7 @@ ${JSON.stringify(result, null, 2)}`
 
 // src/tools/search-history.ts
 import * as fs from "fs";
-import { join as join14 } from "path";
+import { join as join16 } from "path";
 import { homedir as homedir5 } from "os";
 function searchFile(filePath, query, maxResults, results) {
   if (!fs.existsSync(filePath))
@@ -14291,7 +14807,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 = join14(homedir5(), ".mma", "sessions");
+      const sessionDir = join16(homedir5(), ".mma", "sessions");
       const results = [];
       try {
         if (!fs.existsSync(sessionDir)) {
@@ -14306,7 +14822,7 @@ var init_search_history = __esm(() => {
             continue;
           if (sessionId && entry.name !== sessionId)
             continue;
-          const historyFile = join14(sessionDir, entry.name, "history.jsonl");
+          const historyFile = join16(sessionDir, entry.name, "history.jsonl");
           searchFile(historyFile, query, maxResults, results);
           if (results.length >= maxResults)
             break;
@@ -14333,8 +14849,8 @@ var init_search_history = __esm(() => {
 });
 
 // src/modules/memory/search.ts
-import { readFileSync as readFileSync12, existsSync as existsSync24 } from "fs";
-import { join as join15 } from "path";
+import { readFileSync as readFileSync12, existsSync as existsSync26 } from "fs";
+import { join as join17 } from "path";
 
 class MemorySearch {
   memoryDir;
@@ -14345,8 +14861,8 @@ class MemorySearch {
     const results = [];
     const lowerQuery = query.toLowerCase();
     for (const name of MEMORY_FILES) {
-      const path = join15(this.memoryDir, `${name}.md`);
-      if (!existsSync24(path))
+      const path = join17(this.memoryDir, `${name}.md`);
+      if (!existsSync26(path))
         continue;
       const content = readFileSync12(path, "utf-8");
       const lines = content.split(`
@@ -14357,8 +14873,8 @@ class MemorySearch {
         }
       }
     }
-    const prefsPath = join15(this.memoryDir, "preferences.json");
-    if (existsSync24(prefsPath)) {
+    const prefsPath = join17(this.memoryDir, "preferences.json");
+    if (existsSync26(prefsPath)) {
       try {
         const prefs = JSON.parse(readFileSync12(prefsPath, "utf-8"));
         for (const [key, value] of Object.entries(prefs)) {
@@ -14378,8 +14894,8 @@ var init_search = __esm(() => {
 });
 
 // src/modules/memory/store.ts
-import { readFileSync as readFileSync13, writeFileSync as writeFileSync9, appendFileSync as appendFileSync5, existsSync as existsSync25, mkdirSync as mkdirSync13 } from "fs";
-import { join as join16 } from "path";
+import { readFileSync as readFileSync13, writeFileSync as writeFileSync9, appendFileSync as appendFileSync5, existsSync as existsSync27, mkdirSync as mkdirSync13 } from "fs";
+import { join as join18 } from "path";
 
 class MemoryStore {
   memoryDir;
@@ -14387,8 +14903,8 @@ class MemoryStore {
     this.memoryDir = memoryDir;
     this.ensureDir();
     for (const name of MEMORY_FILES2) {
-      const path = join16(this.memoryDir, `${name}.md`);
-      if (!existsSync25(path)) {
+      const path = join18(this.memoryDir, `${name}.md`);
+      if (!existsSync27(path)) {
         writeFileSync9(path, `# ${name.charAt(0).toUpperCase() + name.slice(1)}
 
 `, "utf-8");
@@ -14396,18 +14912,18 @@ class MemoryStore {
     }
   }
   ensureDir() {
-    if (!existsSync25(this.memoryDir)) {
+    if (!existsSync27(this.memoryDir)) {
       mkdirSync13(this.memoryDir, { recursive: true });
     }
   }
   read(name) {
-    const path = join16(this.memoryDir, `${name}.md`);
-    if (!existsSync25(path))
+    const path = join18(this.memoryDir, `${name}.md`);
+    if (!existsSync27(path))
       return "";
     return readFileSync13(path, "utf-8");
   }
   append(name, entry) {
-    const path = join16(this.memoryDir, `${name}.md`);
+    const path = join18(this.memoryDir, `${name}.md`);
     const timestamp = new Date().toISOString().replace("T", " ").slice(0, 19);
     const formatted = `- **${timestamp}** — ${entry}
 `;
@@ -14418,11 +14934,11 @@ class MemoryStore {
     return searchModule.query(query);
   }
   prefsPath() {
-    return join16(this.memoryDir, "preferences.json");
+    return join18(this.memoryDir, "preferences.json");
   }
   getPreferences() {
     const path = this.prefsPath();
-    if (!existsSync25(path))
+    if (!existsSync27(path))
       return {};
     try {
       return JSON.parse(readFileSync13(path, "utf-8"));
@@ -14458,7 +14974,7 @@ var init_store2 = __esm(() => {
 
 // src/tools/remember.ts
 import { homedir as homedir6 } from "os";
-import { join as join17 } from "path";
+import { join as join19 } from "path";
 var CATEGORIES, rememberTool;
 var init_remember = __esm(() => {
   init_i18n();
@@ -14496,7 +15012,7 @@ var init_remember = __esm(() => {
       if (!CATEGORIES.includes(category)) {
         return { success: false, output: t("tool.invalid_params") };
       }
-      const memoryDir = join17(homedir6(), ".mma", "memory");
+      const memoryDir = join19(homedir6(), ".mma", "memory");
       const store = new MemoryStore(memoryDir);
       try {
         if (category === "preferences") {
@@ -14529,7 +15045,7 @@ var init_remember = __esm(() => {
 
 // src/tools/recall.ts
 import { homedir as homedir7 } from "os";
-import { join as join18 } from "path";
+import { join as join20 } from "path";
 function formatAll(store) {
   const parts = [];
   const prefs = store.getPreferences();
@@ -14612,7 +15128,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 = join18(homedir7(), ".mma", "memory");
+      const memoryDir = join20(homedir7(), ".mma", "memory");
       const store = new MemoryStore(memoryDir);
       try {
         if (!query && !category) {
@@ -14650,9 +15166,9 @@ var init_recall = __esm(() => {
 });
 
 // src/modules/browser/bridge-path.ts
-import { existsSync as existsSync26 } from "fs";
+import { existsSync as existsSync28 } from "fs";
 function pickExistingPath(candidates, fallback = candidates[0]) {
-  return candidates.find((p) => existsSync26(p)) ?? fallback;
+  return candidates.find((p) => existsSync28(p)) ?? fallback;
 }
 var init_bridge_path = () => {};
 
@@ -14663,13 +15179,13 @@ __export(exports_bridge_client, {
 });
 import { spawn as spawn4 } from "child_process";
 import { createInterface } from "readline";
-import { dirname as dirname9, join as join19 } from "path";
+import { dirname as dirname10, join as join21 } from "path";
 import { fileURLToPath } from "url";
 function bridgeScriptPath() {
-  const dir = dirname9(fileURLToPath(import.meta.url));
+  const dir = dirname10(fileURLToPath(import.meta.url));
   const candidates = [
-    join19(dir, "bridge-server.mjs"),
-    join19(dir, "modules", "browser", "bridge-server.mjs")
+    join21(dir, "bridge-server.mjs"),
+    join21(dir, "modules", "browser", "bridge-server.mjs")
   ];
   return pickExistingPath(candidates);
 }
@@ -14695,14 +15211,14 @@ class BridgeDriver {
       return this.send(cmd, params, true);
     }
     const id = this.nextId++;
-    const response = await new Promise((resolve15, reject) => {
+    const response = await new Promise((resolve17, reject) => {
       const timer = setTimeout(() => {
         this.pending.delete(id);
         reject(new Error(`Bridge timeout waiting for "${cmd}"`));
       }, BRIDGE_REQUEST_TIMEOUT_MS);
       this.pending.set(id, (resp) => {
         clearTimeout(timer);
-        resolve15(resp);
+        resolve17(resp);
       });
       this.proc.stdin.write(JSON.stringify({ id, cmd, params }) + `
 `);
@@ -15223,15 +15739,15 @@ function buildTextExtractionScript() {
 
 // src/modules/browser/cookie-store.ts
 import { readFile, writeFile, mkdir } from "fs/promises";
-import { join as join20 } from "path";
+import { join as join22 } from "path";
 
 class CookieStore {
   filePath;
   constructor(cookieDir) {
-    this.filePath = join20(cookieDir, "cookies.json");
+    this.filePath = join22(cookieDir, "cookies.json");
   }
   async save(cookies) {
-    await mkdir(join20(this.filePath, ".."), { recursive: true });
+    await mkdir(join22(this.filePath, ".."), { recursive: true });
     await writeFile(this.filePath, JSON.stringify(cookies, null, 2), "utf-8");
   }
   async load() {
@@ -15586,10 +16102,10 @@ var init_session = __esm(() => {
 });
 
 // src/tools/browser.ts
-import { join as join21 } from "path";
+import { join as join23 } from "path";
 function getSession(ctx) {
   if (!session) {
-    const cookieDir = join21(ctx.baseDir, ".mma", "browser");
+    const cookieDir = join23(ctx.baseDir, ".mma", "browser");
     session = new BrowserSession({
       ...DEFAULT_BROWSER_CONFIG,
       headless: ctx.config.browser?.headless ?? true,
@@ -15736,8 +16252,8 @@ async function readClipboardFallback() {
   const { platform: platform5 } = await import("os");
   const { execSync } = await import("child_process");
   const { readFileSync: readFileSync15, unlinkSync: unlinkSync4 } = await import("fs");
-  const { join: join22 } = await import("path");
-  const tmpPath = join22(process.env.TEMP || process.env.TMP || "/tmp", `mma-clip-${Date.now()}.png`);
+  const { join: join24 } = await import("path");
+  const tmpPath = join24(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`, {
@@ -15817,8 +16333,8 @@ var init_image_utils = __esm(() => {
 });
 
 // src/tools/attach-image.ts
-import { existsSync as existsSync27 } from "fs";
-import { resolve as resolve15 } from "path";
+import { existsSync as existsSync29 } from "fs";
+import { resolve as resolve17 } from "path";
 var attachImageTool;
 var init_attach_image = __esm(() => {
   init_i18n();
@@ -15859,8 +16375,8 @@ var init_attach_image = __esm(() => {
           const result = await loadUrlAsDataUrl(source);
           dataUrl = result.dataUrl;
         } else {
-          const absPath = resolve15(ctx.baseDir, source);
-          if (!existsSync27(absPath)) {
+          const absPath = resolve17(ctx.baseDir, source);
+          if (!existsSync29(absPath)) {
             return {
               success: false,
               output: t("image.not_found", { path: source })
@@ -16116,16 +16632,16 @@ class ModuleRegistry {
 }
 
 // src/modules/plugins/loader.ts
-import { readdirSync as readdirSync7, existsSync as existsSync28, statSync as statSync5 } from "fs";
-import { join as join22, basename as basename2 } from "path";
+import { readdirSync as readdirSync9, existsSync as existsSync30, statSync as statSync5 } from "fs";
+import { join as join24, basename as basename3 } from "path";
 
 class PluginLoader {
   loadFromDir(dirPath, pluginManager, logger, options) {
-    if (!existsSync28(dirPath))
+    if (!existsSync30(dirPath))
       return;
-    const entries = readdirSync7(dirPath).sort();
+    const entries = readdirSync9(dirPath).sort();
     for (const entry of entries) {
-      const fullPath = join22(dirPath, entry);
+      const fullPath = join24(dirPath, entry);
       const stat = statSync5(fullPath);
       if (stat.isFile()) {
         if (!entry.endsWith(".ts") && !entry.endsWith(".js"))
@@ -16134,15 +16650,15 @@ class PluginLoader {
       } else if (stat.isDirectory()) {
         const entryFile = this.findEntryFile(fullPath);
         if (entryFile) {
-          this.tryLoad(entryFile, `${entry}/${basename2(entryFile)}`, pluginManager, logger, options);
+          this.tryLoad(entryFile, `${entry}/${basename3(entryFile)}`, pluginManager, logger, options);
         }
       }
     }
   }
   findEntryFile(dir) {
     for (const name of FOLDER_ENTRY_NAMES) {
-      const candidate = join22(dir, name);
-      if (existsSync28(candidate))
+      const candidate = join24(dir, name);
+      if (existsSync30(candidate))
         return candidate;
     }
     return null;
@@ -16184,8 +16700,8 @@ var init_loader = __esm(() => {
 
 // src/modules/plugins/builtin/lint-on-write.ts
 import { spawn as spawn5, execSync } from "child_process";
-import { existsSync as existsSync29, readFileSync as readFileSync15 } from "fs";
-import { resolve as resolve16, extname as extname4, join as join23 } from "path";
+import { existsSync as existsSync31, readFileSync as readFileSync15 } from "fs";
+import { resolve as resolve18, extname as extname4, join as join25 } from "path";
 import { platform as platform5 } from "os";
 function contentHash(content) {
   let h = 5381;
@@ -16231,8 +16747,8 @@ class LintOnWritePlugin {
     const path = String(call.arguments.path || "");
     if (!path)
       return;
-    const fullPath = resolve16(ctx.baseDir, path);
-    if (!existsSync29(fullPath))
+    const fullPath = resolve18(ctx.baseDir, path);
+    if (!existsSync31(fullPath))
       return;
     const ext = extname4(fullPath);
     const syntaxError = await this.checkSyntax(fullPath, ext, ctx.baseDir);
@@ -16288,8 +16804,8 @@ class LintOnWritePlugin {
   }
   async runProjectLint(ctx, result) {
     try {
-      const packageJsonPath = join23(ctx.baseDir, "package.json");
-      if (!existsSync29(packageJsonPath)) {
+      const packageJsonPath = join25(ctx.baseDir, "package.json");
+      if (!existsSync31(packageJsonPath)) {
         return;
       }
       const packageJson = JSON.parse(readFileSync15(packageJsonPath, "utf-8"));
@@ -16301,16 +16817,21 @@ class LintOnWritePlugin {
       await runAsync(lintScript, ctx.baseDir, 30000);
       ctx.logger.debug("Lint passed");
     } catch (err) {
+      const stderr = (err.stderr?.toString?.() || "").trim();
+      const stdout = (err.stdout?.toString?.() || "").trim();
+      const detail = (stderr || stdout || err.message).split(`
+`).filter(Boolean).slice(-5).join(`
+`);
       ctx.logger.warn(`Lint failed: ${err.message}`);
       result.output += `
 
-[Project lint failed]: ${err.message}`;
+[Project lint failed]: ${detail}`;
     }
   }
   async runProjectTypeCheck(filePath, baseDir, result) {
     const projectRoot = findProjectRoot(filePath, baseDir, ["tsconfig.json", "package.json"]);
-    const tsconfigPath = join23(projectRoot, "tsconfig.json");
-    if (!existsSync29(tsconfigPath)) {
+    const tsconfigPath = join25(projectRoot, "tsconfig.json");
+    if (!existsSync31(tsconfigPath)) {
       return;
     }
     const now = Date.now();
@@ -16351,7 +16872,7 @@ class LintOnWritePlugin {
   }
 }
 function runAsync(command, cwd, timeoutMs) {
-  return new Promise((resolve17, reject) => {
+  return new Promise((resolve19, reject) => {
     const child = spawn5(command, {
       cwd,
       shell: true,
@@ -16380,7 +16901,7 @@ function runAsync(command, cwd, timeoutMs) {
       stdout += decoder.decode();
       stderr += decoder.decode();
       if (code === 0) {
-        resolve17({ stdout, stderr });
+        resolve19({ stdout, stderr });
       } else {
         const err = new Error(`Command failed with exit code ${code}`);
         err.stdout = stdout;
@@ -16473,379 +16994,90 @@ class PlanCreator {
       title: `[${totalSteps}] ${newTitle}`,
       steps: [...kept, ...added],
       createdAt: plan.createdAt,
-      baseDir: plan.baseDir,
-      name: plan.name
-    };
-  }
-  static toPromptBlock(plan, currentStepIndex) {
-    const date = plan.createdAt.slice(0, 10);
-    const lines = [
-      `[${plan.id}] ${plan.title}`,
-      `Dir: ${plan.baseDir}`,
-      `Created: ${date} | Progress: ${plan.steps.filter((s) => s.status === "done").length}/${plan.steps.length} done, current: step ${currentStepIndex + 1}`,
-      ``
-    ];
-    for (const step of plan.steps) {
-      const icon = step.status === "done" ? "[x]" : step.status === "in_progress" ? "[*]" : step.status === "failed" ? "[!]" : step.status === "skipped" ? "[-]" : "[ ]";
-      const note = step.note ? ` — ${step.note}` : "";
-      lines.push(`${icon} ${step.id}. ${step.description}${note}`);
-      for (const sub of step.subtasks ?? []) {
-        lines.push(`    ${sub.done ? "[x]" : "[ ]"} ${sub.text}`);
-      }
-    }
-    return lines.join(`
-`);
-  }
-}
-
-// src/modules/execution/tracker.ts
-class PlanTracker {
-  plan;
-  currentStepIndex = 0;
-  constructor(plan) {
-    this.plan = plan;
-  }
-  getPlan() {
-    return this.plan;
-  }
-  getCurrentStepIndex() {
-    return this.currentStepIndex;
-  }
-  getCurrentStep() {
-    return this.plan.steps[this.currentStepIndex];
-  }
-  getStep(id) {
-    return this.plan.steps.find((s) => s.id === id);
-  }
-  updateStepStatus(id, status) {
-    const step = this.getStep(id);
-    if (step)
-      step.status = status;
-  }
-  addNote(id, note) {
-    const step = this.getStep(id);
-    if (step)
-      step.note = note;
-  }
-  advance() {
-    if (this.currentStepIndex < this.plan.steps.length - 1) {
-      this.currentStepIndex++;
-      this.plan.steps[this.currentStepIndex].status = "in_progress";
-      return true;
-    }
-    return false;
-  }
-  syncCurrentStep() {
-    while (this.currentStepIndex < this.plan.steps.length - 1 && (this.plan.steps[this.currentStepIndex].status === "done" || this.plan.steps[this.currentStepIndex].status === "skipped")) {
-      this.currentStepIndex++;
-    }
-  }
-  isComplete() {
-    return this.plan.steps.every((s) => s.status === "done" || s.status === "skipped");
-  }
-  getProgressString() {
-    const done = this.plan.steps.filter((s) => s.status === "done").length;
-    const total = this.plan.steps.length;
-    const pct = total > 0 ? Math.round(done / total * 100) : 0;
-    const barWidth = 10;
-    const filled = Math.round(done / total * barWidth);
-    const bar = "█".repeat(filled) + "░".repeat(barWidth - filled);
-    return `[${this.plan.id}] ${this.plan.title}  ${done}/${total}  ${bar}  ${pct}%`;
-  }
-  toPromptBlock() {
-    return PlanCreator.toPromptBlock(this.plan, this.currentStepIndex);
-  }
-}
-var init_tracker = () => {};
-
-// src/modules/execution/audit-runners.ts
-import { existsSync as existsSync30, readdirSync as readdirSync8 } from "fs";
-import { dirname as dirname10, join as join24, resolve as resolve17 } from "path";
-function findTestFile(dir, depth = 0) {
-  if (depth > 5)
-    return null;
-  let entries;
-  try {
-    entries = readdirSync8(dir, { withFileTypes: true });
-  } catch {
-    return null;
-  }
-  for (const e of entries) {
-    const full = join24(dir, e.name);
-    if (e.isDirectory()) {
-      if (SKIP_DIRS.has(e.name))
-        continue;
-      const found = findTestFile(full, depth + 1);
-      if (found)
-        return found;
-    } else if (TEST_EXT_RE.test(e.name)) {
-      return full;
-    }
-  }
-  return null;
-}
-function hasTestStep(plan) {
-  return plan.steps.some((s) => TEST_STEP_RE.test(s.description));
-}
-function extractFailingNames(output, limit = 5) {
-  const names = [];
-  for (const m of output.matchAll(/\(fail\)\s*([^\n]+)/g)) {
-    const name = m[1].trim();
-    if (name && !names.includes(name))
-      names.push(name);
-    if (names.length >= limit)
-      break;
-  }
-  return names;
-}
-async function runTests(baseDir) {
-  const entry = processRegistry.start("bun test", baseDir);
-  const exited = await processRegistry.waitForExit(entry.id, 90000);
-  const output = entry.log.join(`
-`);
-  processRegistry.remove(entry.id);
-  if (!exited) {
-    return {
-      checked: true,
-      passed: true,
-      failed: 0,
-      passedCount: 0,
-      detail: "test run timed out after 90s — result unknown",
-      command: "bun test"
-    };
-  }
-  const run = detectTestResults(output);
-  if (!run) {
-    return {
-      checked: true,
-      passed: entry.exitCode === 0,
-      failed: entry.exitCode === 0 ? 0 : 1,
-      passedCount: 0,
-      detail: output.slice(0, 200).trim(),
-      command: "bun test"
-    };
-  }
-  const names = extractFailingNames(output);
-  return {
-    checked: true,
-    passed: run.failed === 0,
-    failed: run.failed,
-    passedCount: run.passed,
-    detail: names.length ? names.join("; ") : run.summary || `${run.failed} failed / ${run.passed} passed`,
-    command: "bun test"
-  };
-}
-function parseTypecheckErrors(output) {
-  const line = output.split(`
-`).find((l) => /error TS\d+/.test(l));
-  return line ? line.trim().slice(0, 300) : null;
-}
-function findTypecheckRoot(baseDir, existingFiles = []) {
-  const candidates = [baseDir, ...existingFiles];
-  let best = null;
-  for (const start of candidates) {
-    let dir = resolve17(start);
-    for (let depth = 0;depth <= 10; depth++) {
-      if (existsSync30(join24(dir, "tsconfig.json"))) {
-        if (!best || depth < best.depth)
-          best = { depth, root: dir };
-        break;
-      }
-      const parent = dirname10(dir);
-      if (parent === dir)
-        break;
-      dir = parent;
-    }
-  }
-  return best?.root ?? null;
-}
-async function runTypecheck(baseDir) {
-  const entry = processRegistry.start("npx --no-install tsc --noEmit --skipLibCheck", baseDir);
-  const exited = await processRegistry.waitForExit(entry.id, 90000);
-  const output = entry.log.join(`
-`);
-  processRegistry.remove(entry.id);
-  if (!exited)
-    return null;
-  return parseTypecheckErrors(output);
-}
-var SKIP_DIRS, TEST_EXT_RE, TEST_STEP_RE;
-var init_audit_runners = __esm(() => {
-  init_bash();
-  init_processes();
-  SKIP_DIRS = new Set([
-    "node_modules",
-    ".git",
-    ".mma",
-    "dist",
-    "build",
-    "coverage",
-    ".next",
-    ".nuxt",
-    "vendor"
-  ]);
-  TEST_EXT_RE = /\.(test|spec)\.[jt]sx?$/i;
-  TEST_STEP_RE = /\b(test(ing|s)?|тест(ы|ирование|ировать)?|провер\w*\s+тест|запустить\s+тест)\b|bun test|npm test|vitest|pytest|go test|jest|mocha/i;
-});
-
-// src/modules/execution/auditor.ts
-import { existsSync as existsSync31, readdirSync as readdirSync9 } from "fs";
-import { resolve as resolve18, join as join25, basename as basename3 } from "path";
-function findExistingFile(baseDir, filePath) {
-  const direct = resolve18(baseDir, filePath);
-  if (existsSync31(direct))
-    return direct;
-  const name = basename3(filePath).toLowerCase();
-  const suffix = filePath.replace(/\\/g, "/").toLowerCase();
-  let found = null;
-  const walk = (dir, depth) => {
-    if (found || depth > RESOLVE_MAX_DEPTH)
-      return;
-    let entries;
-    try {
-      entries = readdirSync9(dir, { withFileTypes: true });
-    } catch {
-      return;
-    }
-    for (const e of entries) {
-      if (found)
-        return;
-      const full = join25(dir, e.name);
-      if (e.isDirectory()) {
-        if (SKIP_DIRS.has(e.name))
-          continue;
-        walk(full, depth + 1);
-      } else if (e.name.toLowerCase() === name || full.replace(/\\/g, "/").toLowerCase().endsWith("/" + suffix)) {
-        found = full;
-        return;
+      baseDir: plan.baseDir,
+      name: plan.name
+    };
+  }
+  static toPromptBlock(plan, currentStepIndex) {
+    const date = plan.createdAt.slice(0, 10);
+    const lines = [
+      `[${plan.id}] ${plan.title}`,
+      `Dir: ${plan.baseDir}`,
+      `Created: ${date} | Progress: ${plan.steps.filter((s) => s.status === "done").length}/${plan.steps.length} done, current: step ${currentStepIndex + 1}`,
+      ``
+    ];
+    for (const step of plan.steps) {
+      const icon = step.status === "done" ? "[x]" : step.status === "in_progress" ? "[*]" : step.status === "failed" ? "[!]" : step.status === "skipped" ? "[-]" : "[ ]";
+      const note = step.note ? ` — ${step.note}` : "";
+      lines.push(`${icon} ${step.id}. ${step.description}${note}`);
+      for (const sub of step.subtasks ?? []) {
+        lines.push(`    ${sub.done ? "[x]" : "[ ]"} ${sub.text}`);
       }
     }
-  };
-  walk(baseDir, 0);
-  return found;
+    return lines.join(`
+`);
+  }
 }
 
-class Auditor {
-  baseDir;
-  constructor(baseDir) {
-    this.baseDir = baseDir;
+// src/modules/execution/tracker.ts
+class PlanTracker {
+  plan;
+  currentStepIndex = 0;
+  constructor(plan) {
+    this.plan = plan;
   }
-  async audit(plan) {
-    const doneCreate = plan.steps.filter((s) => s.status === "done" && s.kind !== "delete");
-    const doneDelete = plan.steps.filter((s) => s.status === "done" && s.kind === "delete");
-    const createText = doneCreate.map((s) => s.description.replace(/\([^)]*\)/g, " ")).join(" ");
-    const deleteText = doneDelete.map((s) => s.description.replace(/\([^)]*\)/g, " ")).join(" ");
-    const createFiles = extractFileLikeTokens(stripUrls(createText));
-    const deleteFiles = extractFileLikeTokens(stripUrls(deleteText));
-    const missingFiles = [];
-    const existingFiles = [];
-    const leftoverFiles = [];
-    for (const filePath of createFiles) {
-      const resolved = findExistingFile(this.baseDir, filePath);
-      if (resolved) {
-        existingFiles.push(resolved);
-      } else {
-        missingFiles.push(filePath);
-      }
-    }
-    for (const filePath of deleteFiles) {
-      if (findExistingFile(this.baseDir, filePath)) {
-        leftoverFiles.push(filePath);
-      }
-    }
-    let testRun = null;
-    if (hasTestStep(plan) && findTestFile(this.baseDir)) {
-      try {
-        testRun = await runTests(this.baseDir);
-      } catch {
-        testRun = null;
-      }
-    }
-    let typecheckError = null;
-    if (missingFiles.length === 0 && leftoverFiles.length === 0) {
-      const root = findTypecheckRoot(this.baseDir, existingFiles);
-      if (root) {
-        try {
-          typecheckError = await runTypecheck(root);
-        } catch {
-          typecheckError = null;
-        }
-      }
-    }
-    const doneSteps = plan.steps.filter((s) => s.status === "done").length;
-    const terminalSteps = plan.steps.filter((s) => s.status === "done" || s.status === "skipped").length;
-    const totalSteps = plan.steps.length;
-    const auditedFiles = [...new Set([...createFiles, ...deleteFiles])];
-    let massEditWarning = null;
-    if (auditedFiles.length > MASS_EDIT_THRESHOLD) {
-      massEditWarning = t("exec.mass_edit_warning", {
-        count: String(auditedFiles.length)
-      });
+  getPlan() {
+    return this.plan;
+  }
+  getCurrentStepIndex() {
+    return this.currentStepIndex;
+  }
+  getCurrentStep() {
+    return this.plan.steps[this.currentStepIndex];
+  }
+  getStep(id) {
+    return this.plan.steps.find((s) => s.id === id);
+  }
+  updateStepStatus(id, status) {
+    const step = this.getStep(id);
+    if (step)
+      step.status = status;
+  }
+  addNote(id, note) {
+    const step = this.getStep(id);
+    if (step)
+      step.note = note;
+  }
+  advance() {
+    if (this.currentStepIndex < this.plan.steps.length - 1) {
+      this.currentStepIndex++;
+      this.plan.steps[this.currentStepIndex].status = "in_progress";
+      return true;
     }
-    const testsFailing = testRun !== null && !testRun.passed;
-    const typecheckFailing = typecheckError !== null;
-    const passed = missingFiles.length === 0 && leftoverFiles.length === 0 && !testsFailing && !typecheckFailing;
-    const stepsPending = terminalSteps < totalSteps;
-    let summary;
-    if (missingFiles.length > 0) {
-      summary = t("exec.audit_fail", {
-        done: doneSteps,
-        total: totalSteps,
-        files: missingFiles.length
-      });
-    } else if (leftoverFiles.length > 0) {
-      summary = t("exec.audit_leftovers", {
-        done: doneSteps,
-        total: totalSteps,
-        files: leftoverFiles.length
-      });
-    } else if (testsFailing) {
-      summary = t("exec.audit_fail_tests", {
-        done: doneSteps,
-        total: totalSteps,
-        failed: String(testRun.failed),
-        passed: String(testRun.passedCount),
-        detail: testRun.detail
-      });
-    } else if (typecheckFailing) {
-      summary = t("exec.audit_fail_typecheck", {
-        done: doneSteps,
-        total: totalSteps,
-        missing: String(missingFiles.length),
-        typeError: typecheckError
-      });
-    } else if (stepsPending) {
-      summary = t("exec.audit_pending", {
-        done: doneSteps,
-        total: totalSteps
-      });
-    } else {
-      summary = t("exec.audit_pass", {
-        done: doneSteps,
-        total: totalSteps,
-        files: existingFiles.length
-      });
+    return false;
+  }
+  syncCurrentStep() {
+    while (this.currentStepIndex < this.plan.steps.length - 1 && (this.plan.steps[this.currentStepIndex].status === "done" || this.plan.steps[this.currentStepIndex].status === "skipped")) {
+      this.currentStepIndex++;
     }
-    return {
-      passed,
-      missingFiles,
-      leftoverFiles,
-      createdFiles: existingFiles,
-      modifiedFiles: [],
-      summary,
-      massEditWarning,
-      testRun,
-      typecheckError
-    };
+  }
+  isComplete() {
+    return this.plan.steps.every((s) => s.status === "done" || s.status === "skipped");
+  }
+  getProgressString() {
+    const done = this.plan.steps.filter((s) => s.status === "done").length;
+    const total = this.plan.steps.length;
+    const pct = total > 0 ? Math.round(done / total * 100) : 0;
+    const barWidth = 10;
+    const filled = Math.round(done / total * barWidth);
+    const bar = "█".repeat(filled) + "░".repeat(barWidth - filled);
+    return `[${this.plan.id}] ${this.plan.title}  ${done}/${total}  ${bar}  ${pct}%`;
+  }
+  toPromptBlock() {
+    return PlanCreator.toPromptBlock(this.plan, this.currentStepIndex);
   }
 }
-var MASS_EDIT_THRESHOLD = 10, RESOLVE_MAX_DEPTH = 8;
-var init_auditor = __esm(() => {
-  init_i18n();
-  init_js_identifiers();
-  init_audit_runners();
-  init_audit_runners();
-});
+var init_tracker = () => {};
 
 // src/modules/execution/plan-store.ts
 import { readFileSync as readFileSync16, writeFileSync as writeFileSync10, mkdirSync as mkdirSync14, existsSync as existsSync32, readdirSync as readdirSync10, rmSync } from "fs";
@@ -17279,6 +17511,20 @@ ${display}`,
             return { success: false, output: t("plan.step_not_found") };
           }
           const status = String(args.status || "done");
+          if (tracker.isComplete()) {
+            const plan = tracker.getPlan();
+            deps.store.archivePlan(plan);
+            deps.trackerRef.current = null;
+            const done = plan.steps.filter((s) => s.status === "done").length;
+            return {
+              success: true,
+              output: t("plan.completed_archived", {
+                id: plan.id,
+                done: String(done),
+                total: String(plan.steps.length)
+              })
+            };
+          }
           if (status === "done" && target.status === "done") {
             const progress2 = tracker.getProgressString();
             const display2 = tracker.toPromptBlock();
@@ -17334,6 +17580,21 @@ ${progress2}`,
             tracker.addNote(Number(args.step), String(args.note));
           tracker.syncCurrentStep();
           deps.store.saveActive(tracker.getPlan());
+          if (tracker.isComplete()) {
+            const plan = tracker.getPlan();
+            deps.store.archivePlan(plan);
+            deps.trackerRef.current = null;
+            const done = plan.steps.filter((s) => s.status === "done").length;
+            return {
+              success: true,
+              output: `${t("plan.step_status", { step: String(args.step), status: String(args.status || "done") })}
+${t("plan.completed_archived", {
+                id: plan.id,
+                done: String(done),
+                total: String(plan.steps.length)
+              })}`
+            };
+          }
           const progress = tracker.getProgressString();
           const display = tracker.toPromptBlock();
           _ctx.sessionLog?.plan("step-update", `${t("plan.step_status", { step: String(args.step), status: String(args.status || "done") })} | ${progress} | current: step ${tracker.getCurrentStepIndex() + 1}`);
@@ -17497,6 +17758,12 @@ ${lines.join(`
         if (!step)
           return { success: false, output: t("plan.step_not_found") };
         const result = await deps.verifier.verifyStep(step.description);
+        if (result.noFiles) {
+          return {
+            success: true,
+            output: t("verify.no_files", { step: String(step.id) })
+          };
+        }
         return {
           success: result.passed,
           output: result.passed ? t("verify.passed") : t("verify.failed", {
@@ -17683,7 +17950,8 @@ Tool "${deps.stuckDetector.getLastFailedTool()}" is failing. Try "${alternative}
         deps.stuckDetector.recordBashOutput(String(call.arguments?.command ?? ""), String(result.output ?? ""));
       }
       const toolText = String(result.output ?? "");
-      if (/error TS\d+|\[Project typecheck failed\]|\[Syntax check failed\]/.test(toolText)) {
+      const hasTypeError = /error TS\d+|\[Project typecheck failed\]|\[Syntax check failed\]/.test(toolText);
+      if (hasTypeError) {
         deps.stuckDetector.recordToolError(call.name, toolText.slice(0, 300));
       }
       if (!result.success) {
@@ -17701,7 +17969,9 @@ Tool "${deps.stuckDetector.getLastFailedTool()}" is failing. Try "${alternative}
             }
           }
         }
-        deps.stuckDetector.recordToolError(call.name, result.output);
+        if (!hasTypeError) {
+          deps.stuckDetector.recordToolError(call.name, result.output);
+        }
         const actionableHints = deps.stuckDetector.getActionableHints();
         const alternative = deps.stuckDetector.getToolAlternative();
         if (actionableHints.length > 0 || alternative) {
@@ -17755,6 +18025,7 @@ Tool "${deps.stuckDetector.getLastFailedTool()}" is failing. Try "${alternative}
         }
         deps.advancePlanIfStepComplete(ctx.contextManager, ctx.sessionLog);
       }
+      deps.maybeSearchError(ctx, call);
     }
   };
 }
@@ -17780,6 +18051,12 @@ class ExecutionModule {
   _auditSkipsRemaining = 0;
   pendingMessages = [];
   forbiddenBashFailures = new Map;
+  searchRunner;
+  webSearchThreshold;
+  searchesThisSession = 0;
+  retryWebSearchSignatures = new Set;
+  lastErrorSearchAt = 0;
+  errorSearchCooldownMs;
   state = {
     lastRecoveryIteration: -STUCK_RECOVERY_COOLDOWN,
     consecutivePlanWarnings: 0,
@@ -17798,12 +18075,15 @@ class ExecutionModule {
       }
     };
   })();
-  constructor(baseDir, stuckThreshold = 6) {
+  constructor(baseDir, stuckThreshold = 6, webSearchThreshold = 5, searchRunner = performWebSearch, errorSearchCooldownMs = ERROR_SEARCH_MIN_INTERVAL_MS) {
     this.baseDir = baseDir;
     this.verifier = new StepVerifier(baseDir);
-    this.stuckDetector = new StuckDetector(stuckThreshold);
+    this.stuckDetector = new StuckDetector(stuckThreshold, 3, webSearchThreshold);
     this.auditor = new Auditor(baseDir);
     this.store = new PlanStore(baseDir);
+    this.webSearchThreshold = webSearchThreshold;
+    this.searchRunner = searchRunner;
+    this.errorSearchCooldownMs = errorSearchCooldownMs;
   }
   setPlan(plan) {
     this.tracker = new PlanTracker(plan);
@@ -17814,7 +18094,13 @@ class ExecutionModule {
     const plan = this.store.loadActive();
     if (!plan)
       return false;
-    this.tracker = new PlanTracker(plan);
+    const restored = new PlanTracker(plan);
+    if (restored.isComplete()) {
+      this.store.archivePlan(plan);
+      this.tracker = null;
+      return false;
+    }
+    this.tracker = restored;
     this.tracker.syncCurrentStep();
     this._auditSkipsRemaining = 1;
     return true;
@@ -17828,6 +18114,58 @@ class ExecutionModule {
   getStuckDetector() {
     return this.stuckDetector;
   }
+  maybeSearchError(ctx, call) {
+    if (ctx.config?.webSearch?.enabled === false)
+      return;
+    const cfg = ctx.config?.errorWebSearch;
+    if (!cfg?.enabled)
+      return;
+    const sig = this.stuckDetector.getRepeatedErrorSignature();
+    if (!sig)
+      return;
+    if (this.stuckDetector.hasErrorSearched(sig) && !this.retryWebSearchSignatures.has(sig))
+      return;
+    if (this.searchesThisSession >= (cfg.maxSearchesPerSession ?? 3))
+      return;
+    const lastError = this.stuckDetector.getLastErrorOutput();
+    if (!isSearchableError(lastError)) {
+      ctx.logger?.debug(t("exec.error_search_no_query"));
+      return;
+    }
+    const now = Date.now();
+    if (now - this.lastErrorSearchAt < this.errorSearchCooldownMs)
+      return;
+    const stepDesc = this.tracker?.getCurrentStep()?.description ?? "";
+    const query = buildSearchQuery(stepDesc, this.stuckDetector.getLastBashCommand(), lastError, call.name, cfg.maxQueryChars ?? 200);
+    const count = this.stuckDetector.getErrorSignatureCount(sig);
+    this.stuckDetector.markErrorSearched(sig);
+    this.searchesThisSession++;
+    this.lastErrorSearchAt = now;
+    const networkConfig = getSessionSecurityConfig(ctx.config, ctx.sessionContext).network;
+    this.searchRunner(query, cfg.maxResults ?? 5, networkConfig, cfg.requestTimeoutMs ?? 1e4).then((res) => {
+      if (!res.success || res.results.length === 0) {
+        if (!this.retryWebSearchSignatures.has(sig)) {
+          this.retryWebSearchSignatures.add(sig);
+          this.stuckDetector.unmarkErrorSearched(sig);
+        }
+        ctx.logger?.warn(t("exec.error_search_failed", { query }));
+        ctx.sessionLog?.plan("web-search", `empty/failed: ${query}`);
+        return;
+      }
+      const resultsText = res.results.map((r, i) => `${i + 1}. ${r.title} — ${r.url}
+   ${r.snippet}`).join(`
+`);
+      this.pendingMessages.push({
+        role: "user",
+        content: `<system-summary>${t("exec.error_search_results", {
+          sig,
+          count: String(count),
+          query,
+          results: resultsText
+        })}</system-summary>`
+      });
+    }).catch((e) => ctx.logger?.warn(`error web search: ${e.message}`));
+  }
   async runFinalAudit() {
     if (!this.tracker)
       return null;
@@ -17850,7 +18188,7 @@ class ExecutionModule {
     };
   }
   getSystemPromptBlock() {
-    if (!this.tracker)
+    if (!this.tracker || this.tracker.isComplete())
       return null;
     return {
       content: this.tracker.toPromptBlock(),
@@ -17864,8 +18202,12 @@ class ExecutionModule {
       return null;
     const plan = this.tracker.getPlan();
     const done = plan.steps.filter((s) => s.status === "done").length;
+    const total = plan.steps.length;
+    if (this.tracker.isComplete()) {
+      return `[${plan.id}] "${plan.title}" ${done}/${total} done — plan complete. You may create a new plan for new work (plan create), or reply with your final answer.`;
+    }
     const current = this.tracker.getCurrentStepIndex() + 1;
-    return `[${plan.id}] "${plan.title}" ${done}/${plan.steps.length} done, current: step ${current} — continue it (plan show / re-plan), do NOT create a new plan`;
+    return `[${plan.id}] "${plan.title}" ${done}/${total} done, current: step ${current} — continue it (plan show / re-plan), do NOT create a new plan`;
   }
   getToolDefinitions() {
     return createPlanToolDefinitions({
@@ -17889,7 +18231,8 @@ class ExecutionModule {
       forbiddenBashFailures: this.forbiddenBashFailures,
       state: this.state,
       checkPlanAlignment: (call) => this.checkPlanAlignment(call),
-      advancePlanIfStepComplete: (cm, sl) => this.advancePlanIfStepComplete(cm, sl)
+      advancePlanIfStepComplete: (cm, sl) => this.advancePlanIfStepComplete(cm, sl),
+      maybeSearchError: (ctx, call) => this.maybeSearchError(ctx, call)
     });
   }
   preserveActive() {
@@ -18030,6 +18373,12 @@ class ExecutionModule {
         content: `<system-summary>${nextMsg}</system-summary>`
       });
     }
+    if (this.tracker?.isComplete()) {
+      const completed = this.tracker.getPlan();
+      this.store.archivePlan(completed);
+      this.tracker = null;
+      sessionLog?.plan("auto-archive", `Plan ${completed.id} complete — archived`);
+    }
   }
   missingStepDeliverables(step) {
     const tokens = extractFileLikeTokens(stripUrls(step.description));
@@ -18080,6 +18429,7 @@ class ExecutionModule {
     return getMessageText(firstUser.content).trim();
   }
 }
+var ERROR_SEARCH_MIN_INTERVAL_MS = 30000;
 var init_module = __esm(() => {
   init_i18n();
   init_tracker();
@@ -18088,6 +18438,8 @@ var init_module = __esm(() => {
   init_auditor();
   init_plan_store();
   init_js_identifiers();
+  init_web_search();
+  init_session_isolation();
   init_plan_tool();
   init_execution_plugin();
 });
@@ -19183,7 +19535,7 @@ class LspClient {
     } catch {} finally {
       if (this.process) {
         try {
-          this.process.kill();
+          killTree(this.process);
         } catch {}
         this.process = null;
       }
@@ -19228,6 +19580,7 @@ class LspClient {
 var DEFAULT_TIMEOUT = 15000;
 var init_client2 = __esm(() => {
   init_command();
+  init_registry();
 });
 
 // src/modules/lsp/check-tool.ts
@@ -19283,7 +19636,7 @@ var init_check_tool = __esm(() => {
 
 // src/modules/lsp/module.ts
 import { existsSync as existsSync38 } from "fs";
-import { resolve as resolve22 } from "path";
+import { relative as relative3, resolve as resolve22 } from "path";
 
 class LspModule {
   name = "lsp";
@@ -19418,6 +19771,7 @@ ${items}`;
     const errors = [];
     const warnings = [];
     const notes = [];
+    const checkedFiles = [];
     let checked = 0;
     for (const file of files) {
       const serverConfig = getServerForFile(file, this.config);
@@ -19431,6 +19785,7 @@ ${items}`;
         const diags = await this.client.checkFile(file, ctx.baseDir, serverConfig, projectRoot);
         this.failuresByServer.set(key, 0);
         checked++;
+        checkedFiles.push(relative3(ctx.baseDir, file).replace(/\\/g, "/"));
         for (const d of diags) {
           if (d.severity === 1)
             errors.push({ file, diag: d });
@@ -19453,6 +19808,10 @@ ${items}`;
       }
     }
     const lines = [];
+    if (checked > 0) {
+      lines.push(t("lsp.checked_files", { count: String(checked) }));
+      lines.push(...checkedFiles.map((f) => `  ${f}`));
+    }
     if (errors.length > 0) {
       lines.push(`[LSP errors] (${errors.length}):`);
       lines.push(formatCheckDiagnostics(errors, ctx.baseDir));
@@ -19630,7 +19989,7 @@ var init_startup_check = __esm(() => {
 
 // src/modules/indexer/walker.ts
 import { readdirSync as readdirSync14, readFileSync as readFileSync22, statSync as statSync7, existsSync as existsSync40, watch } from "fs";
-import { join as join32, relative as relative3, extname as extname5 } from "path";
+import { join as join32, relative as relative4, extname as extname5 } from "path";
 
 class Indexer {
   baseDir;
@@ -19669,7 +20028,7 @@ class Indexer {
         if (count >= this.MAX_FILES)
           return;
         const fullPath = join32(dir, entry);
-        const relPath = relative3(this.baseDir, fullPath);
+        const relPath = relative4(this.baseDir, fullPath);
         const stat2 = statSync7(fullPath);
         if (stat2.isDirectory()) {
           if (!IGNORE_DIRS.has(entry)) {
@@ -20616,7 +20975,7 @@ async function bootstrap(configDir, projectDir, noAgentsMd, exitOnComplete) {
   toolCtx.toolExecutor = toolExecutor;
   const hallucinationDetector = new HallucinationDetector(baseDir, llmProvider);
   const moduleRegistry = new ModuleRegistry;
-  const execModule = new ExecutionModule(baseDir, config.stuckThreshold);
+  const execModule = new ExecutionModule(baseDir, config.stuckThreshold, config.errorWebSearch?.threshold ?? 5);
   const activeMeta = sessionManager.getActiveMeta();
   if (activeMeta && activeMeta.messageCount > 0) {
     execModule.restorePlan();
@@ -20648,9 +21007,7 @@ async function bootstrap(configDir, projectDir, noAgentsMd, exitOnComplete) {
     pluginManager.register(lspPlugin);
   }
   let startupCheckBlock = null;
-  if (!exitOnComplete && true) {
-    startupCheckBlock = await runStartupHealthCheck(config.lsp ?? DEFAULT_LSP_CONFIG, baseDir);
-  }
+  const startupCheckPromise = !exitOnComplete ? runStartupHealthCheck(config.lsp ?? DEFAULT_LSP_CONFIG, baseDir) : Promise.resolve(null);
   const moduleTools = moduleRegistry.collectToolDefinitions();
   for (const tool of moduleTools) {
     toolRegistry.register(tool);
@@ -20733,8 +21090,6 @@ async function bootstrap(configDir, projectDir, noAgentsMd, exitOnComplete) {
     ...moduleRegistry.collectPromptBlocks(["indexer"]),
     ...agentsMdBlocks
   ];
-  if (startupCheckBlock)
-    promptBlocks.push(startupCheckBlock);
   const agentDeps = {
     config,
     llmProvider,
@@ -20769,6 +21124,12 @@ async function bootstrap(configDir, projectDir, noAgentsMd, exitOnComplete) {
       return blocks;
     },
     finalAudit: () => execModule.runFinalAudit(),
+    lazyPromptBlocks: async () => {
+      if (startupCheckBlock)
+        return [startupCheckBlock];
+      startupCheckBlock = await startupCheckPromise ?? null;
+      return startupCheckBlock ? [startupCheckBlock] : [];
+    },
     sessionManager,
     memoryStore,
     exitOnComplete
@@ -30819,9 +31180,9 @@ import * as readline2 from "readline";
 
 // src/ui/line-math.ts
 init_string_width();
-var ANSI_RE = /\x1b\[[0-9;?]*[ -/]*[@-~]/g;
+var ANSI_RE2 = /\x1b\[[0-9;?]*[ -/]*[@-~]/g;
 function stripAnsi2(s) {
-  return s.replace(ANSI_RE, "");
+  return s.replace(ANSI_RE2, "");
 }
 function charLen(s) {
   return Array.from(s).length;
@@ -31875,6 +32236,7 @@ init_box();
 init_table();
 init_i18n();
 var GUTTER = "  ";
+var BUSY_TOOLS = new Set(["lsp_check"]);
 function toolMarker(tool) {
   switch (tool) {
     case "write_file":
@@ -31994,6 +32356,9 @@ ${pc2.dim("⚙")} ${friendlyTool(tool)}${summary ? ` ${pc2.dim(summary)}` : ""}$
       this.out.write(`
 ${pc2.dim(marker)} ${friendlyTool(tool)}${summary ? ` ${pc2.dim(summary)}` : ""}${step}
 `);
+      if (BUSY_TOOLS.has(tool)) {
+        this.spinner.start(t("ui.tool_running", { tool: friendlyTool(tool) }));
+      }
       return;
     }
     this.spinner.start(`${pc2.dim("⚙")} ${friendlyTool(tool)}${summary ? ` ${pc2.dim(summary)}` : ""}${step}`);
@@ -32078,6 +32443,7 @@ ${pc2.dim(marker)} ${friendlyTool(tool)}${summary ? ` ${pc2.dim(summary)}` : ""}
 
 // src/cli/repl.ts
 init_box();
+init_string_width();
 init_i18n();
 init_repl_commands();
 
@@ -32086,12 +32452,15 @@ init_client2();
 init_config();
 init_check_tool();
 init_project_root();
-var DEFAULT_PROBE_TIMEOUT_MS = 20000;
+var DEFAULT_PROBE_TIMEOUT_MS = 30000;
+var DEFAULT_PROBE_DEADLINE_MS = 60000;
+var DEFAULT_MAX_PARALLEL = 3;
 async function probeLspServers(config, baseDir, deps = {}) {
   if (!config.enabled)
     return { ok: [], failed: [], noneApplicable: true };
-  const client = deps.client ?? new LspClient;
-  const timeoutMs = deps.timeoutMs ?? DEFAULT_PROBE_TIMEOUT_MS;
+  const timeoutCap = deps.timeoutMs ?? DEFAULT_PROBE_TIMEOUT_MS;
+  const deadlineMs = deps.deadlineMs ?? DEFAULT_PROBE_DEADLINE_MS;
+  const maxParallel = deps.maxParallel ?? DEFAULT_MAX_PARALLEL;
   const collect = deps.collectFiles ?? collectCheckFiles;
   const files = await collect(baseDir, config);
   const seen = new Set;
@@ -32108,26 +32477,37 @@ async function probeLspServers(config, baseDir, deps = {}) {
   }
   if (servers.length === 0)
     return { ok: [], failed: [], noneApplicable: true };
-  const results = await Promise.all(servers.map(async ({ language, config: server }) => {
+  const ok = [];
+  const failed = [];
+  const deadline = Date.now() + deadlineMs;
+  const probeOne = async (language, server) => {
     const projectRoot = findProjectRoot(baseDir, baseDir, server.workspaceMarkers ?? []);
+    const serverTimeout = Math.min(server.timeout ?? timeoutCap, timeoutCap);
     const started = Date.now();
+    const probeClient = deps.client ?? new LspClient;
     try {
-      await client.probe(server, projectRoot, timeoutMs);
-      return { language, ok: true, durationMs: Date.now() - started };
+      await probeClient.probe(server, projectRoot, serverTimeout);
+      ok.push({ language, ok: true, durationMs: Date.now() - started });
     } catch (e) {
-      return {
+      failed.push({
         language,
         ok: false,
         error: e instanceof Error ? e.message : String(e),
         durationMs: Date.now() - started
-      };
+      });
     }
-  }));
-  return {
-    ok: results.filter((r) => r.ok),
-    failed: results.filter((r) => !r.ok),
-    noneApplicable: false
   };
+  for (let i = 0;i < servers.length; i += maxParallel) {
+    if (Date.now() >= deadline) {
+      for (const { language } of servers.slice(i)) {
+        failed.push({ language, ok: false, error: "timeout", durationMs: 0 });
+      }
+      break;
+    }
+    const wave = servers.slice(i, i + maxParallel);
+    await Promise.all(wave.map(({ language, config: server }) => probeOne(language, server)));
+  }
+  return { ok, failed, noneApplicable: false };
 }
 
 // src/cli/repl.ts
@@ -32706,10 +33086,6 @@ ${t("image.clipboard_empty")}`));
       const names = enabledServers.map(([name]) => name).join(", ");
       row(t("repl.mcp_label"), `${pc2.white(String(enabledServers.length))}  ${pc2.dim(`(${names})`)}`);
     }
-    const lspSummary = await this.probeLspBanner();
-    if (lspSummary) {
-      row(t("repl.lsp_label"), lspSummary);
-    }
     const cwd = process.cwd();
     row(t("repl.work_dir"), pc2.dim(cwd));
     if (this.noAgentsMd) {
@@ -32735,14 +33111,39 @@ ${t("image.clipboard_empty")}`));
       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));
-    for (const line of box(info, {
+    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("…"));
+    }
+    const boxLines = box(info, {
       title: t("repl.title", { version: version3 }),
       width: headerWidth
-    })) {
+    });
+    for (const line of boxLines) {
       console.log(line);
     }
     console.log();
     this.rl.prompt();
+    if (lspEnabled) {
+      this.probeLspBanner().then((lspSummary) => {
+        if (lspSummary)
+          this.updateLspRow(boxLines.length, headerWidth, lspSummary);
+      }).catch(() => {});
+    }
+  }
+  updateLspRow(boxLineCount, headerWidth, summary) {
+    if (this.agentRunning || !process.stdout.isTTY)
+      return;
+    if ((process.stdout.columns ?? 96) < headerWidth)
+      return;
+    const inner = headerWidth - 4;
+    const rowText = `${pc2.yellow(t("repl.lsp_label"))} ${summary.replace(/\s+/g, " ").trim()}`;
+    if (stringWidth(rowText) > inner)
+      return;
+    const padded = rowText + " ".repeat(Math.max(0, inner - stringWidth(rowText)));
+    const line = pc2.dim("│") + " " + padded + " " + pc2.dim("│");
+    process.stdout.write(`\x1B[2A\r\x1B[2K${line}\x1B[2B\r`);
   }
   async probeLspBanner() {
     const config = this.config.lsp ?? DEFAULT_LSP_CONFIG;