micro-models-agent 0.41.0 → 0.41.2

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"
         ],
@@ -2494,6 +2514,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,6 +2554,7 @@ 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.",
@@ -3127,6 +3149,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,6 +3189,7 @@ 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": "Укажите путь (файл или каталог) для проверки.",
@@ -3979,6 +4003,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 +4092,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 +4133,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
@@ -10192,245 +10243,750 @@ 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();
-  }
-  onMeta?.(`\uD83E\uDD16 Planning with MoE mode...
-`);
-  onPhase?.("thinking");
-  const planResult = await orchestrator.plan(input);
-  onPhase?.("done");
-  if ("error" in planResult) {
-    logger.warn(`MoE plan failed: ${planResult.error} — falling back to single-agent`);
-    return fallback();
-  }
-  const { plan } = planResult;
-  onMeta?.(`\uD83D\uDCCB Plan created: "${plan.title}" (${plan.subtasks.length} subtasks)
-`);
-  const validation = validatePlan(plan, config);
-  if (!validation.valid) {
-    const applied = applyAutoFixes(plan, validation.autoFixes);
-    const retry = validatePlan(applied, config);
-    if (!retry.valid) {
-      logger.warn(`MoE plan validation failed: ${retry.errors.join("; ")} — falling back to single-agent`);
-      onMeta?.(`⚠️ Plan validation failed. Falling back to single-agent mode.
-`);
-      return fallback();
-    }
-    Object.assign(plan, applied);
-    onMeta?.(`\uD83D\uDD27 Auto-fixed ${validation.autoFixes.length} plan issues.
-`);
+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 moeDeps = {
-    config,
-    toolRegistry: toolExecutor.getRegistry(),
-    toolExecutor,
-    llmProvider,
-    logger,
-    baseDir
+  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) {
+    logger.warn(`MoE plan failed: ${planResult.error} — falling back to single-agent`);
+    return fallback();
+  }
+  const { plan } = planResult;
+  onMeta?.(`\uD83D\uDCCB Plan created: "${plan.title}" (${plan.subtasks.length} subtasks)
+`);
+  const validation = validatePlan(plan, config);
+  if (!validation.valid) {
+    const applied = applyAutoFixes(plan, validation.autoFixes);
+    const retry = validatePlan(applied, config);
+    if (!retry.valid) {
+      logger.warn(`MoE plan validation failed: ${retry.errors.join("; ")} — falling back to single-agent`);
+      onMeta?.(`⚠️ Plan validation failed. Falling back to single-agent mode.
+`);
+      return fallback();
+    }
+    Object.assign(plan, applied);
+    onMeta?.(`\uD83D\uDD27 Auto-fixed ${validation.autoFixes.length} plan issues.
+`);
+  }
+  const moeDeps = {
+    config,
+    toolRegistry: toolExecutor.getRegistry(),
+    toolExecutor,
+    llmProvider,
+    logger,
+    baseDir
   };
   const executor = new MoEExecutor(moeDeps);
   onMeta?.(`⚙️ Executing ${plan.subtasks.length} subtasks...
@@ -10640,6 +11196,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 +12400,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 +12437,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 +12477,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 +12655,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 +12667,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 +12769,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 +13140,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 +13264,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 +13332,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}` };
         }
@@ -13323,7 +13674,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 +13761,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 +14218,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 +14242,7 @@ class MCPClient {
         this._connected = true;
         this.process = child;
         _resolved = true;
-        resolve15();
+        resolve17();
       });
     });
   }
@@ -13960,7 +14311,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 +14335,7 @@ class MCPClient {
                 if (response.error) {
                   reject(new Error(response.error.message));
                 } else {
-                  resolve15(response.result?.tools || []);
+                  resolve17(response.result?.tools || []);
                 }
                 return;
               }
@@ -14066,8 +14417,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 +14445,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 +14459,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 +14487,7 @@ class MCPClient {
                 if (response.error) {
                   reject(new Error(response.error.message));
                 } else {
-                  resolve15(response.result);
+                  resolve17(response.result);
                 }
                 return;
               }
@@ -14247,7 +14598,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 +14642,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 +14657,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 +14684,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 +14696,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 +14708,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 +14729,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 +14738,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 +14747,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 +14769,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 +14809,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 +14847,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 +14880,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 +14963,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 +15001,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 +15014,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 +15046,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 +15574,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 +15937,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 +16087,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 +16168,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 +16210,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 +16467,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 +16485,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 +16535,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 +16582,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 +16639,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 +16652,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 +16707,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 +16736,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;
@@ -16453,399 +16809,110 @@ class PlanCreator {
         status: "pending",
         kind: kinds?.[i] ?? "create"
       })),
-      createdAt: new Date().toISOString(),
-      baseDir
-    };
-  }
-  static replan(plan, newSteps, title) {
-    const kept = plan.steps.filter((s) => s.status === "done" || s.status === "skipped");
-    const baseTitle = plan.title.replace(/^\[\d+[^]]*\]\s*/, "");
-    const newTitle = title || baseTitle;
-    const totalSteps = kept.length + newSteps.length;
-    const added = newSteps.map((desc, i) => ({
-      id: kept.length + i + 1,
-      description: desc,
-      status: "pending",
-      kind: "create"
-    }));
-    return {
-      id: plan.id,
-      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;
+      createdAt: new Date().toISOString(),
+      baseDir
+    };
+  }
+  static replan(plan, newSteps, title) {
+    const kept = plan.steps.filter((s) => s.status === "done" || s.status === "skipped");
+    const baseTitle = plan.title.replace(/^\[\d+[^]]*\]\s*/, "");
+    const newTitle = title || baseTitle;
+    const totalSteps = kept.length + newSteps.length;
+    const added = newSteps.map((desc, i) => ({
+      id: kept.length + i + 1,
+      description: desc,
+      status: "pending",
+      kind: "create"
+    }));
+    return {
+      id: plan.id,
+      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}`);
       }
     }
-  };
-  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 +17346,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 +17415,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 +17593,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", {
@@ -17814,7 +17916,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;
@@ -17850,7 +17958,7 @@ class ExecutionModule {
     };
   }
   getSystemPromptBlock() {
-    if (!this.tracker)
+    if (!this.tracker || this.tracker.isComplete())
       return null;
     return {
       content: this.tracker.toPromptBlock(),
@@ -17864,8 +17972,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({
@@ -18030,6 +18142,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));
@@ -19183,7 +19301,7 @@ class LspClient {
     } catch {} finally {
       if (this.process) {
         try {
-          this.process.kill();
+          killTree(this.process);
         } catch {}
         this.process = null;
       }
@@ -19228,6 +19346,7 @@ class LspClient {
 var DEFAULT_TIMEOUT = 15000;
 var init_client2 = __esm(() => {
   init_command();
+  init_registry();
 });
 
 // src/modules/lsp/check-tool.ts
@@ -20648,9 +20767,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 +20850,6 @@ async function bootstrap(configDir, projectDir, noAgentsMd, exitOnComplete) {
     ...moduleRegistry.collectPromptBlocks(["indexer"]),
     ...agentsMdBlocks
   ];
-  if (startupCheckBlock)
-    promptBlocks.push(startupCheckBlock);
   const agentDeps = {
     config,
     llmProvider,
@@ -20769,6 +20884,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
@@ -32078,6 +32199,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 +32208,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 +32233,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 +32842,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 +32867,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;