micro-models-agent 0.25.0 → 0.27.0

package/dist/main.js

@@ -2391,7 +2391,7 @@ var init_en = __esm(() => {
     "tool.interactive_disabled": "Interactive tool is disabled in exit-on-complete mode. Proceed without asking the user.",
     "proc.started": `Started background process {id} (PID {pid}).
 Command: {command}`,
-    "proc.detected_hint": "[Long-running command detected — started in background]",
+    "proc.promoted_hint": "Command still running after {ms} ms — moved to the background",
     "proc.manage_hint": "Check output: process_log id={id}. Stop it: process_kill id={id}. List all: process_list.",
     "proc.none": "No background processes running.",
     "proc.not_found": "Process not found: {id}",
@@ -2400,7 +2400,6 @@ Command: {command}`,
     "proc.list_header": "Background processes",
     "proc.log_header": "Process {id} ({status}) output:",
     "proc.log_empty": "(no output yet)",
-    "proc.timed_out": "Command timed out after {ms} ms and was killed.",
     "proc.hint": "Manage them with {list}, {log}, {kill}.",
     "proc.status_running": "running",
     "proc.status_exited": "exited",
@@ -2717,7 +2716,7 @@ Use this knowledge to answer the user's question.`,
     "hall.repetitive": "Response too repetitive ({pct}% overlap)",
     "hall.uncertainty": "Uncertainty markers: {markers}",
     "hall.unknown_paths": "Mentioned file paths not found in known files: {paths}",
-    "hall.contradiction": 'Contradicts previous decision: "{decision}" in {location}',
+    "hall.contradiction_llm": "Contradicts an earlier decision{reason}",
     "hall.uncertainty_prefix": `
 
 [⚠️ Uncertainty] `,
@@ -2936,7 +2935,7 @@ var init_ru = __esm(() => {
     "tool.interactive_disabled": "Интерактивный инструмент отключён в режиме exit-on-complete. Продолжай без вопроса пользователю.",
     "proc.started": `Фоновый процесс запущен: {id} (PID {pid}).
 Команда: {command}`,
-    "proc.detected_hint": "[Обнаружена длительная команда — запущена в фоне]",
+    "proc.promoted_hint": "Команда всё ещё выполняется через {ms} мс — переведена в фоновый режим",
     "proc.manage_hint": "Проверить вывод: process_log id={id}. Остановить: process_kill id={id}. Список всех: process_list.",
     "proc.none": "Фоновых процессов нет.",
     "proc.not_found": "Процесс не найден: {id}",
@@ -2945,7 +2944,6 @@ var init_ru = __esm(() => {
     "proc.list_header": "Фоновые процессы",
     "proc.log_header": "Вывод процесса {id} ({status}):",
     "proc.log_empty": "(вывода пока нет)",
-    "proc.timed_out": "Команда превысила таймаут {ms} мс и была остановлена.",
     "proc.hint": "Управление: {list}, {log}, {kill}.",
     "proc.status_running": "работает",
     "proc.status_exited": "завершён",
@@ -3262,7 +3260,7 @@ var init_ru = __esm(() => {
     "hall.repetitive": "Слишком повторяющийся ответ ({pct}% совпадение)",
     "hall.uncertainty": "Маркеры неопределённости: {markers}",
     "hall.unknown_paths": "Упомянутые файлы не найдены: {paths}",
-    "hall.contradiction": 'Противоречит предыдущему решению: "{decision}" в {location}',
+    "hall.contradiction_llm": "Противоречит ранее принятому решению{reason}",
     "hall.uncertainty_prefix": `
 
 [⚠️ Неопределённость] `,
@@ -4929,8 +4927,12 @@ class ToolRegistry {
 }
 
 // src/modules/processes/runner.ts
-import { spawn } from "child_process";
-import { platform } from "os";
+function registerKillable(callId, kill) {
+  activeChildren.set(callId, { kill });
+}
+function unregisterKillable(callId) {
+  activeChildren.delete(callId);
+}
 function killByCallId(callId) {
   const entry = activeChildren.get(callId);
   if (!entry)
@@ -4941,95 +4943,6 @@ function killByCallId(callId) {
   } catch {}
   return true;
 }
-function killTree(child) {
-  const pid = child.pid;
-  if (!pid)
-    return;
-  if (platform() === "win32") {
-    spawn("taskkill", ["/pid", String(pid), "/T", "/F"], {
-      windowsHide: true,
-      stdio: "ignore"
-    });
-    return;
-  }
-  try {
-    process.kill(-pid, "SIGTERM");
-  } catch {
-    try {
-      child.kill("SIGKILL");
-    } catch {}
-  }
-}
-function runCommand(command, options = {}) {
-  const {
-    cwd,
-    callId,
-    timeoutMs = 120000,
-    maxBuffer = 10 * 1024 * 1024
-  } = options;
-  return new Promise((resolve) => {
-    let timedOut = false;
-    let stdout = "";
-    let stderr = "";
-    const child = spawn(command, {
-      cwd,
-      shell: true,
-      windowsHide: true,
-      detached: platform() !== "win32",
-      stdio: ["ignore", "pipe", "pipe"]
-    });
-    const stdoutRef = { value: stdout };
-    const stderrRef = { value: stderr };
-    const decoder = platform() === "win32" ? new TextDecoder("ibm866") : null;
-    const decodeChunk = (chunk) => decoder ? decoder.decode(chunk, { stream: true }) : chunk.toString("utf-8");
-    child.stdout?.on("data", (chunk) => {
-      const text = decodeChunk(chunk);
-      const next = stdoutRef.value.length + text.length;
-      if (next > maxBuffer) {
-        stdoutRef.value = stdoutRef.value.slice(stdoutRef.value.length + text.length - maxBuffer) + text;
-      } else {
-        stdoutRef.value = stdoutRef.value + text;
-      }
-    });
-    child.stderr?.on("data", (chunk) => {
-      const text = decodeChunk(chunk);
-      const next = stderrRef.value.length + text.length;
-      if (next > maxBuffer) {
-        stderrRef.value = stderrRef.value.slice(stderrRef.value.length + text.length - maxBuffer) + text;
-      } else {
-        stderrRef.value = stderrRef.value + text;
-      }
-    });
-    const entry = {
-      kill: () => killTree(child)
-    };
-    if (callId) {
-      activeChildren.set(callId, entry);
-    }
-    const timer = setTimeout(() => {
-      timedOut = true;
-      killTree(child);
-    }, timeoutMs);
-    child.on("error", () => {
-      clearTimeout(timer);
-      if (callId)
-        activeChildren.delete(callId);
-      resolve({
-        stdout: stdoutRef.value,
-        stderr: stderrRef.value,
-        code: null,
-        signal: null,
-        timedOut
-      });
-    });
-    child.on("close", (code, signal) => {
-      clearTimeout(timer);
-      if (callId)
-        activeChildren.delete(callId);
-      resolve({ stdout: stdoutRef.value, stderr: stderrRef.value, code, signal, timedOut });
-    });
-  });
-}
 var activeChildren;
 var init_runner = __esm(() => {
   activeChildren = new Map;
@@ -5045,6 +4958,16 @@ class ToolExecutor {
     this.ctx = ctx;
     this.pluginManager = pluginManager;
   }
+  async executeByName(name, args, ctx) {
+    const prevCtx = this.ctx;
+    if (ctx)
+      this.ctx = ctx;
+    try {
+      return await this.execute({ id: `redirect_${Date.now()}`, name, arguments: args });
+    } finally {
+      this.ctx = prevCtx;
+    }
+  }
   async execute(call, signal) {
     const tool = this.registry.get(call.name);
     if (!tool) {
@@ -6810,14 +6733,14 @@ var init_command_validator = __esm(() => {
 });
 
 // src/modules/processes/registry.ts
-import { spawn as spawn2 } from "child_process";
-import { platform as platform2 } from "os";
-function killTree2(child) {
+import { spawn } from "child_process";
+import { platform } from "os";
+function killTree(child) {
   const pid = child.pid;
   if (!pid)
     return;
-  if (platform2() === "win32") {
-    spawn2("taskkill", ["/pid", String(pid), "/T", "/F"], {
+  if (platform() === "win32") {
+    spawn("taskkill", ["/pid", String(pid), "/T", "/F"], {
       windowsHide: true,
       stdio: "ignore"
     });
@@ -6835,6 +6758,7 @@ function killTree2(child) {
 class ProcessRegistry {
   procs = new Map;
   children = new Map;
+  exitWaiters = new Map;
   start(command, cwd, sessionId) {
     const id = `proc_${Date.now()}_${++seq}`;
     const entry = {
@@ -6850,46 +6774,76 @@ class ProcessRegistry {
     };
     this.trimOldEntries();
     this.procs.set(id, entry);
-    const child = spawn2(command, {
-      cwd,
-      shell: true,
-      windowsHide: true,
-      detached: platform2() !== "win32",
-      stdio: ["ignore", "pipe", "pipe"]
-    });
+    let child;
+    try {
+      child = spawn(command, {
+        cwd,
+        shell: true,
+        windowsHide: true,
+        detached: platform() !== "win32",
+        stdio: ["ignore", "pipe", "pipe"]
+      });
+    } catch (e) {
+      entry.status = "killed";
+      entry.spawnError = e?.message || String(e);
+      entry.log.push(`[process error] ${entry.spawnError}`);
+      return entry;
+    }
     this.children.set(id, child);
     entry.pid = child.pid ?? 0;
-    let partial = "";
+    const decoder = platform() === "win32" ? new TextDecoder("ibm866") : null;
+    let buf = "";
+    const pushLine = (line) => {
+      if (entry.log.length >= MAX_LOG_LINES) {
+        entry.log.shift();
+      }
+      entry.log.push(line);
+    };
     const append = (chunk) => {
-      const text = partial + chunk.toString();
-      const lines = text.split(/\r?\n/);
-      partial = lines.pop() ?? "";
+      const decoded = decoder ? decoder.decode(chunk, { stream: true }) : chunk.toString();
+      buf += decoded;
+      const lines = buf.split(/\r?\n/);
+      buf = lines.pop() ?? "";
       for (const line of lines) {
-        if (entry.log.length >= MAX_LOG_LINES) {
-          entry.log.shift();
-        }
-        entry.log.push(line);
+        pushLine(line);
+      }
+    };
+    const flush = () => {
+      if (decoder) {
+        buf += decoder.decode();
+      }
+      if (buf) {
+        pushLine(buf);
+        buf = "";
       }
     };
+    const resolveExit = () => {
+      this.exitWaiters.get(id)?.resolve();
+    };
     child.stdout?.on("data", append);
     child.stderr?.on("data", append);
     child.on("error", (err) => {
       if (entry.status === "running") {
         entry.status = "killed";
       }
+      entry.spawnError = err.message;
       append(Buffer.from(`[process error] ${err.message}`));
+      resolveExit();
     });
     child.on("close", (code) => {
+      flush();
       if (entry.status === "running") {
         entry.status = "exited";
       }
       entry.exitCode = code;
       this.children.delete(id);
-      if (partial) {
-        entry.log.push(partial);
-        partial = "";
-      }
+      resolveExit();
     });
+    let resolve10;
+    const promise = new Promise((r) => {
+      resolve10 = r;
+    });
+    this.exitWaiters.set(id, { promise, resolve: resolve10 });
     return entry;
   }
   list(sessionId) {
@@ -6917,7 +6871,7 @@ class ProcessRegistry {
       entry.status = "killed";
       const child = this.children.get(id);
       if (child) {
-        killTree2(child);
+        killTree(child);
       }
     }
     return true;
@@ -6929,71 +6883,61 @@ class ProcessRegistry {
     }
     return targets.length;
   }
+  waitForExit(id, timeoutMs) {
+    const entry = this.procs.get(id);
+    const waiter = this.exitWaiters.get(id);
+    if (!entry || entry.status !== "running" || !waiter) {
+      return Promise.resolve(true);
+    }
+    return new Promise((resolve10) => {
+      const timer = setTimeout(() => resolve10(false), timeoutMs);
+      waiter.promise.then(() => {
+        clearTimeout(timer);
+        resolve10(true);
+      });
+    });
+  }
+  remove(id) {
+    const entry = this.procs.get(id);
+    if (!entry)
+      return false;
+    if (entry.status === "running") {
+      const child = this.children.get(id);
+      if (child) {
+        killTree(child);
+      }
+      entry.status = "killed";
+    }
+    this.procs.delete(id);
+    this.children.delete(id);
+    this.exitWaiters.delete(id);
+    return true;
+  }
   trimOldEntries() {
     if (this.procs.size < MAX_KEPT_PROCESSES)
       return;
     const sorted = Array.from(this.procs.values()).sort((a, b) => a.startedAt.localeCompare(b.startedAt));
     const toRemove = sorted.slice(0, sorted.length - MAX_KEPT_PROCESSES + 1);
     for (const entry of toRemove) {
-      if (entry.status === "running") {
-        const child = this.children.get(entry.id);
-        if (child) {
-          killTree2(child);
-        }
-      }
-      this.procs.delete(entry.id);
-      this.children.delete(entry.id);
+      this.remove(entry.id);
     }
   }
 }
-var MAX_LOG_LINES = 300, MAX_KEPT_PROCESSES = 20, seq = 0, processRegistry;
+var MAX_LOG_LINES = 2000, MAX_KEPT_PROCESSES = 20, seq = 0, processRegistry;
 var init_registry = __esm(() => {
   processRegistry = new ProcessRegistry;
 });
 
-// src/modules/processes/detect.ts
-function isLongRunningCommand(command) {
-  return LONG_RUNNING_PATTERNS.some((pattern) => pattern.test(command));
-}
-var LONG_RUNNING_PATTERNS;
-var init_detect2 = __esm(() => {
-  LONG_RUNNING_PATTERNS = [
-    /\b(npm|pnpm|yarn|bun|npx)\s+(run\s+)?(dev|start|serve|preview|watch|server)\b/i,
-    /\b(deno|node)\s+.*\b(run\s+)?(dev|serve|watch|server)\b/i,
-    /(^|\s)--watch\b/i,
-    /(^|\s)-w\b/i,
-    /\bnodemon\b/i,
-    /\btsx watch\b/i,
-    /\b(ts-node|tsc)\s+.*--watch\b/i,
-    /\bvite(?!\s+(build|create))\b/i,
-    /\bwebpack(-dev-server|\s+serve)\b/i,
-    /\bastro dev\b/i,
-    /\bnext (dev|start)\b/i,
-    /\bnuxt (dev|start)\b/i,
-    /\bsvelte-kit (dev|preview)\b/i,
-    /\bgatsby develop\b/i,
-    /\bdocker(-compose)?\s+.*\bup\b/i,
-    /\buvicorn\b|\bgunicorn\b/i,
-    /\bpython\s+-m\s+http\.server\b/i,
-    /\bflask run\b/i,
-    /\bphp artisan serve\b/i,
-    /\brails (server|s)\b/i,
-    /\bvitest watch\b/i,
-    /\bjest --watch\b/i
-  ];
-});
-
 // src/modules/processes/index.ts
 var init_processes = __esm(() => {
   init_runner();
   init_registry();
-  init_detect2();
 });
 
 // src/tools/bash.ts
-import { platform as platform3 } from "os";
+import { platform as platform2 } from "os";
 function adaptCommandForWindows(command) {
-  if (platform3() !== "win32")
+  if (platform2() !== "win32")
     return command;
   const trimmed = command.trim();
   if (trimmed.startsWith("mkdir -p ")) {
@@ -7002,9 +6946,45 @@ function adaptCommandForWindows(command) {
   if (trimmed === "mkdir -p" || trimmed.startsWith("mkdir -p ")) {
     return trimmed.replace(/mkdir -p/g, "mkdir");
   }
+  const firstWord = trimmed.split(/\s+/)[0]?.split(/[\\/]/).pop();
+  const translated = firstWord ? UNIX_TO_WIN_TRANSLATE[firstWord] : undefined;
+  if (translated && !trimmed.includes("|") && !trimmed.includes(">") && !trimmed.includes("&&") && !trimmed.includes(";")) {
+    return trimmed.replace(firstWord, translated);
+  }
   return command;
 }
-var BASH_TIMEOUT_MS = 120000, UNIX_TO_WIN_HINTS, bashTool;
+function detectToolCallInBash(command) {
+  const match = command.trim().match(/^([\w-]+)\s+(.+)$/s);
+  if (!match)
+    return null;
+  const tool = match[1];
+  const rest = match[2].trim();
+  if (!/^[a-z][a-z0-9_]+$/.test(tool))
+    return null;
+  if (!rest.includes("=") && !rest.startsWith("{"))
+    return null;
+  return { tool, args: rest };
+}
+function parseToolArgs(raw) {
+  const trimmed = raw.trim();
+  if (trimmed.startsWith("{")) {
+    try {
+      return JSON.parse(trimmed);
+    } catch {}
+  }
+  const args = {};
+  const tokens = trimmed.match(/(?:[^\s"']+|"[^"]*"|'[^']*')+/g) ?? [];
+  for (const token of tokens) {
+    const eq = token.indexOf("=");
+    if (eq > 0) {
+      const key = token.slice(0, eq);
+      const value = token.slice(eq + 1);
+      args[key] = value.replace(/^["']|["']$/g, "");
+    }
+  }
+  return args;
+}
+var BASH_GRACE_MS = 5000, SPAWN_SETTLE_MS = 100, bashGraceMs, UNIX_TO_WIN_HINTS, UNIX_TO_WIN_TRANSLATE, bashTool;
 var init_bash = __esm(() => {
   init_command_validator();
   init_audit_log();
@@ -7012,6 +6992,7 @@ var init_bash = __esm(() => {
   init_security();
   init_processes();
   init_i18n();
+  bashGraceMs = BASH_GRACE_MS;
   UNIX_TO_WIN_HINTS = {
     ls: 'Use "dir" or the list_dir tool instead.',
     pwd: 'Use "echo %cd%" or the file_info tool instead.',
@@ -7028,23 +7009,40 @@ var init_bash = __esm(() => {
     wc: "Use the read_file tool instead.",
     diff: "Use the diff tool instead.",
     which: 'Use "where" instead.',
-    echo: "echo works on Windows, but avoid pipes (|)."
+    echo: "echo works on Windows, but avoid pipes (|).",
+    "Get-Content": 'The shell is cmd.exe, not PowerShell. Use "type" or the read_file tool instead.',
+    "Select-Object": "The shell is cmd.exe, not PowerShell. Use the read_file tool with offset/limit instead."
+  };
+  UNIX_TO_WIN_TRANSLATE = {
+    ls: "dir",
+    pwd: "echo %cd%",
+    cat: "type",
+    wc: 'find /c /v ""'
   };
   bashTool = {
     name: "bash",
-    description: "Execute a shell command and return its output. Use for running tests, build, git, and shell operations. Long-running commands (dev servers, watchers) start in the background and return a process id immediately — manage them with process_list, process_log, process_kill. Set background=true to force background execution.",
+    description: "Execute a shell command and return its output. Use for running tests, build, git, and shell operations. Commands that are still running after a few seconds are automatically moved to the background and return a process id — manage them with process_list, process_log, process_kill. Set background=true to return a process id immediately for commands you know are long-running (dev servers, watchers).",
     tags: ["shell", "code"],
     parameters: {
       type: "object",
       properties: {
         command: { type: "string", description: "Shell command to execute" },
         workdir: { type: "string", description: "Working directory (default: baseDir)" },
-        background: { type: "boolean", description: "Start the command in the background and return immediately with a process id (default: auto-detect long-running commands)" }
+        background: { type: "boolean", description: "Return a process id immediately without waiting (default: commands still running after a few seconds are auto-promoted to the background)" }
       },
       required: ["command"]
     },
     handler: async (ctx, args) => {
       const originalCommand = String(args.command);
+      const toolCall = detectToolCallInBash(originalCommand);
+      if (toolCall && toolCall.tool !== "bash" && ctx.toolExecutor) {
+        const redirected = await ctx.toolExecutor.executeByName(toolCall.tool, parseToolArgs(toolCall.args), ctx);
+        return {
+          success: redirected.success,
+          output: `[redirected to tool "${toolCall.tool}"]
+${redirected.output}`
+        };
+      }
       const command = adaptCommandForWindows(originalCommand);
       const workdir = args.workdir ? String(args.workdir) : ctx.baseDir;
       const appConfig = ctx.config || {};
@@ -7062,68 +7060,67 @@ Hint: Use the "workdir" parameter to run commands in a specific directory instea
       if (securityConfig?.logCommands) {
         logBashCommand(ctx.sessionId, sanitizeCommandForLog(command), false, `Working directory: ${workdir}`);
       }
-      const background = args.background === true || isLongRunningCommand(command);
-      if (background) {
-        const entry = processRegistry.start(command, workdir, ctx.sessionId);
-        if (securityConfig?.logCommands) {
-          logBashCommand(ctx.sessionId, sanitizeCommandForLog(command), true, `Started in background: ${entry.id} (PID ${entry.pid})`);
-        }
-        const explicit = args.background === true;
-        return {
-          success: true,
-          output: `${t("proc.started", {
-            id: entry.id,
-            pid: entry.pid,
-            command
-          })}${explicit ? "" : `
-${t("proc.detected_hint")}`}
-${t("proc.manage_hint", {
-            id: entry.id
-          })}`
-        };
+      const entry = processRegistry.start(command, workdir, ctx.sessionId);
+      if (ctx.activeCallId) {
+        registerKillable(ctx.activeCallId, () => processRegistry.kill(entry.id));
       }
       try {
-        const res = await runCommand(command, {
-          cwd: workdir,
-          callId: ctx.activeCallId,
-          timeoutMs: BASH_TIMEOUT_MS
-        });
-        const parts = [res.stdout.trimEnd(), res.stderr.trimEnd()].filter(Boolean);
-        let output = parts.join(`
+        const settleMs = args.background === true ? SPAWN_SETTLE_MS : bashGraceMs;
+        const exited = await processRegistry.waitForExit(entry.id, settleMs);
+        if (exited) {
+          if (entry.spawnError) {
+            return {
+              success: false,
+              output: `[process error] ${entry.spawnError}
+Hint: check the "workdir" path exists and the command is valid for this OS.`
+            };
+          }
+          const code = entry.exitCode;
+          let output2 = entry.log.join(`
 `);
-        if (res.timedOut) {
-          output = `${output ? output + `
-` : ""}${t("proc.timed_out", {
-            ms: BASH_TIMEOUT_MS
-          })}`;
-        } else if (!output && res.code !== 0) {
-          output = `(exit code ${res.code})`;
-        }
-        if (platform3() === "win32" && res.code !== 0) {
-          const firstWord = command.trim().split(/\s+/)[0]?.split(/[\\/]/).pop();
-          const hint = firstWord ? UNIX_TO_WIN_HINTS[firstWord] : undefined;
-          if (hint) {
-            output = `${output}
+          processRegistry.remove(entry.id);
+          if (!output2 && code !== 0) {
+            output2 = `(exit code ${code})`;
+          }
+          if (platform2() === "win32" && code !== 0) {
+            const firstWord = command.trim().split(/\s+/)[0]?.split(/[\\/]/).pop();
+            const hint = firstWord ? UNIX_TO_WIN_HINTS[firstWord] : undefined;
+            if (hint) {
+              output2 = `${output2}
 
 Hint: "${firstWord}" may not work on Windows. ${hint}`;
+            }
           }
-        }
-        if (securityConfig?.logCommands) {
-          logBashCommand(ctx.sessionId, sanitizeCommandForLog(command), res.code === 0, `Working directory: ${workdir}, Output length: ${res.stdout.length}`);
-        }
-        const lines = output.split(`
+          if (securityConfig?.logCommands) {
+            logBashCommand(ctx.sessionId, sanitizeCommandForLog(command), code === 0, `Working directory: ${workdir}, Output length: ${output2.length}`);
+          }
+          const lines = output2.split(`
 `);
-        if (lines.length > MAX_PREVIEW_LINES) {
-          output = lines.slice(0, MAX_PREVIEW_LINES).join(`
+          if (lines.length > MAX_PREVIEW_LINES) {
+            output2 = lines.slice(0, MAX_PREVIEW_LINES).join(`
 `) + `
 ... (${lines.length - MAX_PREVIEW_LINES} more lines)`;
+          }
+          return { success: code === 0, output: output2 };
         }
-        return { success: res.code === 0, output };
-      } catch (e) {
+        const explicit = args.background === true;
+        const output = `${t("proc.started", {
+          id: entry.id,
+          pid: entry.pid,
+          command
+        })}${explicit ? "" : `
+${t("proc.promoted_hint", { ms: settleMs })}`}
+${t("proc.manage_hint", {
+          id: entry.id
+        })}`;
         if (securityConfig?.logCommands) {
-          logBashCommand(ctx.sessionId, sanitizeCommandForLog(command), false, `Working directory: ${workdir}, Error: ${e.message?.slice(0, 100) || ""}`);
+          logBashCommand(ctx.sessionId, sanitizeCommandForLog(command), true, `Started in background: ${entry.id} (PID ${entry.pid})`);
+        }
+        return { success: true, output };
+      } finally {
+        if (ctx.activeCallId) {
+          unregisterKillable(ctx.activeCallId);
         }
-        return { success: false, output: e.message || String(e) };
       }
     }
   };
@@ -7423,6 +7420,15 @@ class SessionLogger {
       iteration
     });
   }
+  logPlan(event, detail, iteration) {
+    this.session?.appendLog({
+      ts: new Date().toISOString(),
+      type: "plan",
+      content: detail,
+      tool: event,
+      ...iteration !== undefined ? { iteration } : {}
+    });
+  }
 }
 
 // node_modules/jsonrepair/lib/esm/utils/JSONRepairError.js
@@ -8548,76 +8554,394 @@ function filterToolsByTags(tools, toolTags) {
   });
 }
 
-// src/modules/execution/moe-executor.ts
-function isTransientError(error) {
-  return TRANSIENT_ERROR_PATTERNS.some((p) => error.includes(p));
-}
-function sleep(ms) {
-  return new Promise((r) => setTimeout(r, ms));
-}
-function topologicalSort(subtasks) {
-  const sorted = [];
-  const remaining = new Set(subtasks.map((s) => s.id));
-  const subtaskMap = new Map(subtasks.map((s) => [s.id, s]));
-  while (remaining.size > 0) {
-    const ready = [];
-    for (const id of remaining) {
-      const sub = subtaskMap.get(id);
-      const depsSatisfied = (sub.depends_on || []).every((d) => !remaining.has(d));
-      if (depsSatisfied) {
-        ready.push(sub);
-      }
-    }
-    if (ready.length === 0) {
-      break;
-    }
-    sorted.push(ready);
-    for (const r of ready) {
-      remaining.delete(r.id);
+// src/modules/execution/stuck-detector.ts
+class StuckDetector {
+  threshold;
+  errorThreshold;
+  iterationsOnCurrentStep = 0;
+  currentStepId = null;
+  toolErrors = new Map;
+  currentStepDescription = "";
+  recentToolCalls = [];
+  maxRecentCalls = 10;
+  repetitionThreshold = 3;
+  consecutiveFailures = 0;
+  lastFailedTool = "";
+  lastErrorOutput = "";
+  escalationCount = 0;
+  escalationThreshold = 3;
+  fileRewriteCount = new Map;
+  fileRewriteThreshold = 3;
+  constructor(threshold = 8, errorThreshold = 3) {
+    this.threshold = threshold;
+    this.errorThreshold = errorThreshold;
+  }
+  recordIteration(stepId) {
+    if (stepId === this.currentStepId) {
+      this.iterationsOnCurrentStep++;
+    } else {
+      this.resetStepState(stepId);
     }
   }
-  return sorted;
-}
-async function executeSubtask(subtask, deps, _sharedContext) {
-  const startTime = Date.now();
-  const expertConfig = getExpertConfig(deps.config, subtask.expert_tag);
-  if (!expertConfig) {
-    return {
-      subtaskId: subtask.id,
-      success: false,
-      summary: `Unknown expert_tag: ${subtask.expert_tag}`,
-      result: "",
-      error: `No expert config found for tag "${subtask.expert_tag}"`,
-      durationMs: Date.now() - startTime
-    };
+  recordToolCall(name, args) {
+    const argsKey = JSON.stringify(args);
+    this.recentToolCalls.push({ name, argsKey });
+    if (this.recentToolCalls.length > this.maxRecentCalls) {
+      this.recentToolCalls.shift();
+    }
   }
-  const subagentTool = deps.toolRegistry.get("subagent");
-  if (!subagentTool) {
-    return {
-      subtaskId: subtask.id,
-      success: false,
-      summary: "Subagent tool not registered",
-      result: "",
-      error: "Subagent tool not found in registry",
-      durationMs: Date.now() - startTime
-    };
+  recordToolError(toolName, output) {
+    this.toolErrors.set(toolName, (this.toolErrors.get(toolName) || 0) + 1);
+    this.consecutiveFailures++;
+    this.lastFailedTool = toolName;
+    if (output)
+      this.lastErrorOutput = output;
   }
-  const allTools = deps.toolRegistry.getAll();
-  const filteredTools = filterToolsByTags(allTools, expertConfig.tool_tags);
-  if (filteredTools.length === 0) {
-    return {
-      subtaskId: subtask.id,
-      success: false,
-      summary: `No tools available for expert "${subtask.expert_tag}" (tags: ${expertConfig.tool_tags.join(", ")})`,
-      result: "",
-      error: "No matching tools",
-      durationMs: Date.now() - startTime
-    };
+  getLastErrorOutput() {
+    return this.lastErrorOutput;
+  }
+  getLastFailedTool() {
+    return this.lastFailedTool;
+  }
+  getIterationsOnCurrentStep() {
+    return this.iterationsOnCurrentStep;
+  }
+  recordToolSuccess() {
+    this.consecutiveFailures = 0;
+    this.lastFailedTool = "";
+    this.escalationCount = 0;
+  }
+  setCurrentStep(stepId, description) {
+    if (stepId !== this.currentStepId) {
+      this.resetStepState(stepId);
+    }
+    this.currentStepDescription = description;
+  }
+  isStuck() {
+    return this.iterationsOnCurrentStep > this.threshold;
+  }
+  hasRepetitiveErrors(toolName) {
+    if (toolName) {
+      return (this.toolErrors.get(toolName) || 0) >= this.errorThreshold;
+    }
+    return Array.from(this.toolErrors.values()).some((c) => c >= this.errorThreshold);
+  }
+  hasRepetitiveToolCalls() {
+    if (this.recentToolCalls.length < this.repetitionThreshold)
+      return false;
+    const last = this.recentToolCalls[this.recentToolCalls.length - 1];
+    let count = 1;
+    for (let i = this.recentToolCalls.length - 2;i >= 0; i--) {
+      if (this.recentToolCalls[i].name === last.name && this.recentToolCalls[i].argsKey === last.argsKey) {
+        count++;
+      } else {
+        break;
+      }
+    }
+    return count >= this.repetitionThreshold;
+  }
+  hasConsecutiveFailures() {
+    return this.consecutiveFailures >= this.errorThreshold;
+  }
+  getConsecutiveFailuresCount() {
+    return this.consecutiveFailures;
+  }
+  recordEscalation() {
+    this.escalationCount++;
+  }
+  shouldEscalate() {
+    return this.escalationCount >= this.escalationThreshold;
+  }
+  resetEscalation() {
+    this.escalationCount = 0;
+  }
+  getEscalationCount() {
+    return this.escalationCount;
+  }
+  getHints() {
+    const hints = [];
+    const desc = this.currentStepDescription.toLowerCase();
+    if (desc.includes("install") || desc.includes("npm") || desc.includes("pip")) {
+      hints.push("Check if a lock file exists (package-lock.json, poetry.lock). If missing, run the install command first.");
+    }
+    if (desc.includes("test") || desc.includes("spec")) {
+      hints.push("Make sure the source files exist and have real code before running tests.");
+    }
+    if (desc.includes("build") || desc.includes("compile")) {
+      hints.push("Check that all dependencies are installed and source files are not empty.");
+    }
+    if (desc.includes("deploy") || desc.includes("publish")) {
+      hints.push("Verify credentials and network access before deploying.");
+    }
+    if (this.hasRepetitiveToolCalls()) {
+      hints.push("You are calling the same tool repeatedly with the same arguments. Try a different approach.");
+    }
+    if (this.hasConsecutiveFailures()) {
+      hints.push("Multiple different tools are failing. Check if the environment is set up correctly.");
+    }
+    return hints;
+  }
+  getActionableHints() {
+    const hints = [];
+    const error = this.lastErrorOutput;
+    if (!error)
+      return hints;
+    if (/Cannot read properties of undefined|is not a function|is not a constructor/i.test(error)) {
+      if (/node_modules/.test(error)) {
+        hints.push("A dependency is incompatible with your Node.js version. Check if there is an alternative package or use a different runtime.");
+      }
+    }
+    if (/TS1005|TS1003|TS1109|TS1128|TS1434/i.test(error)) {
+      hints.push("TypeScript syntax error. Read the error message carefully — it tells you the exact line and column. Fix the syntax before retrying.");
+    }
+    if (/TS2322|TS2345|TS2769|TS7006|TS7016/i.test(error)) {
+      hints.push("TypeScript type mismatch. Check the type signature of the function/API you are using. If a package lacks type declarations, install @types/<package> or use skipLibCheck.");
+    }
+    if (/Cannot find module|Module not found|ERR_MODULE_NOT_FOUND/i.test(error)) {
+      hints.push("Module not found. Run npm install or check if the import path is correct.");
+    }
+    if (/EACCES|EPERM|permission denied/i.test(error)) {
+      hints.push("Permission denied. Check file permissions or run with appropriate privileges.");
+    }
+    if (/ECONNREFUSED|ETIMEDOUT|ENOTFOUND|fetch failed/i.test(error)) {
+      hints.push("Network error. Check if the server is running and accessible.");
+    }
+    if (/is not recognized|command not found|not found in path/i.test(error)) {
+      hints.push("Command not found. Check if the tool is installed and in PATH.");
+    }
+    if (this.hasExcessiveRewrites()) {
+      const file = this.getExcessiveRewriteFile();
+      hints.push(`File ${file} has been rewritten ${this.getFileRewriteCount(file)} times without success. Stop rewriting and try a fundamentally different approach.`);
+    }
+    return hints;
+  }
+  getToolAlternative() {
+    const tool = this.lastFailedTool;
+    const error = this.lastErrorOutput;
+    if (!tool)
+      return null;
+    if (/Cannot read properties of undefined|is not a function|TypeError|ReferenceError/i.test(error)) {
+      const alternatives = {
+        "ts-node": "tsx",
+        jest: "vitest",
+        mocha: "vitest",
+        webpack: "vite",
+        rollup: "vite",
+        parcel: "vite",
+        babel: "tsc",
+        eslint: "biome",
+        prettier: "biome"
+      };
+      for (const [failed, alt] of Object.entries(alternatives)) {
+        if (tool.includes(failed) || error.includes(failed)) {
+          return alt;
+        }
+      }
+    }
+    return null;
+  }
+  recordFileRewrite(filePath) {
+    const count = (this.fileRewriteCount.get(filePath) || 0) + 1;
+    this.fileRewriteCount.set(filePath, count);
+  }
+  getFileRewriteCount(filePath) {
+    return this.fileRewriteCount.get(filePath) || 0;
+  }
+  hasExcessiveRewrites() {
+    return Array.from(this.fileRewriteCount.values()).some((c) => c >= this.fileRewriteThreshold);
+  }
+  getExcessiveRewriteFile() {
+    for (const [file, count] of this.fileRewriteCount) {
+      if (count >= this.fileRewriteThreshold)
+        return file;
+    }
+    return null;
+  }
+  getRepetitiveToolMessage() {
+    if (!this.hasRepetitiveToolCalls())
+      return "";
+    const last = this.recentToolCalls[this.recentToolCalls.length - 1];
+    return t("exec.repetitive_tool", {
+      tool: last.name,
+      count: this.repetitionThreshold
+    });
+  }
+  getStuckReason() {
+    if (this.isStuck()) {
+      return t("exec.stuck", {
+        stepId: String(this.currentStepId ?? "?"),
+        description: this.currentStepDescription,
+        iterations: this.iterationsOnCurrentStep
+      });
+    }
+    const errorTool = Array.from(this.toolErrors.entries()).find(([_, c]) => c >= this.errorThreshold);
+    if (errorTool) {
+      return t("exec.tool_errors", { tool: errorTool[0], count: errorTool[1] });
+    }
+    return "";
+  }
+  getRecoveryMessage() {
+    if (this.isStuck()) {
+      return t("exec.stuck_recovery", {
+        iterations: this.iterationsOnCurrentStep,
+        stepId: String(this.currentStepId ?? "?"),
+        description: this.currentStepDescription
+      });
+    }
+    const errorTool = Array.from(this.toolErrors.entries()).find(([_, c]) => c >= this.errorThreshold);
+    if (errorTool) {
+      return t("exec.tool_errors_recovery", {
+        tool: errorTool[0],
+        count: errorTool[1]
+      });
+    }
+    if (this.hasConsecutiveFailures()) {
+      return t("exec.consecutive_failures_recovery", {
+        count: this.consecutiveFailures
+      });
+    }
+    if (this.hasRepetitiveToolCalls()) {
+      return this.getRepetitiveToolMessage();
+    }
+    return "";
+  }
+  checkOffTrack(toolName, call) {
+    if (!this.currentStepDescription)
+      return null;
+    const toolArgStr = JSON.stringify(call.arguments).toLowerCase();
+    const pathInStep = (this.currentStepDescription.match(/\b[\w./-]+\.[a-z]+/gi) || []).map((p) => p.toLowerCase());
+    const pathInCall = (toolArgStr.match(/\b[\w./-]+\.[a-z]+/gi) || []).map((p) => p.toLowerCase());
+    const overlaps = pathInCall.some((p) => pathInStep.some((s) => p.includes(s) || s.includes(p)));
+    if (!overlaps && pathInStep.length > 0 && pathInCall.length > 0) {
+      return t("exec.off_track", {
+        stepId: String(this.currentStepId),
+        description: this.currentStepDescription,
+        tool: toolName
+      });
+    }
+    return null;
+  }
+  reset() {
+    this.currentStepId = null;
+    this.iterationsOnCurrentStep = 0;
+    this.toolErrors.clear();
+    this.consecutiveFailures = 0;
+    this.lastFailedTool = "";
+    this.lastErrorOutput = "";
+    this.recentToolCalls = [];
+    this.fileRewriteCount.clear();
+    this.escalationCount = 0;
+  }
+  resetStepState(stepId) {
+    this.currentStepId = stepId;
+    this.iterationsOnCurrentStep = 1;
+    this.toolErrors.clear();
+    this.consecutiveFailures = 0;
+    this.lastFailedTool = "";
+    this.lastErrorOutput = "";
+    this.recentToolCalls = [];
+    this.fileRewriteCount.clear();
+    this.escalationCount = 0;
+  }
+}
+var init_stuck_detector = __esm(() => {
+  init_i18n();
+});
+
+// src/modules/skills/error-skill-map.ts
+function suggestSkill(errorOutput) {
+  for (const { pattern, skill } of ERROR_SKILL_MAP) {
+    if (pattern.test(errorOutput))
+      return skill;
+  }
+  return null;
+}
+var ERROR_SKILL_MAP;
+var init_error_skill_map = __esm(() => {
+  ERROR_SKILL_MAP = [
+    { pattern: /TS\d{4}:/i, skill: "typescript-expert" },
+    { pattern: /Cannot find name|No overload matches/i, skill: "typescript-type-expert" },
+    { pattern: /ts-node|tsx.*error/i, skill: "typescript-expert" },
+    { pattern: /Module not found|Cannot resolve module/i, skill: "typescript-expert" },
+    { pattern: /ECONNREFUSED|ETIMEDOUT|fetch failed/i, skill: "devops-expert" },
+    { pattern: /permission denied|EACCES/i, skill: "linux-server-expert" },
+    { pattern: /docker|container/i, skill: "docker-expert" },
+    { pattern: /jest|vitest|test.*fail/i, skill: "vitest-testing-expert" }
+  ];
+});
+
+// src/modules/execution/moe-executor.ts
+function isTransientError(error) {
+  return TRANSIENT_ERROR_PATTERNS.some((p) => error.includes(p));
+}
+function sleep(ms) {
+  return new Promise((r) => setTimeout(r, ms));
+}
+function topologicalSort(subtasks) {
+  const sorted = [];
+  const remaining = new Set(subtasks.map((s) => s.id));
+  const subtaskMap = new Map(subtasks.map((s) => [s.id, s]));
+  while (remaining.size > 0) {
+    const ready = [];
+    for (const id of remaining) {
+      const sub = subtaskMap.get(id);
+      const depsSatisfied = (sub.depends_on || []).every((d) => !remaining.has(d));
+      if (depsSatisfied) {
+        ready.push(sub);
+      }
+    }
+    if (ready.length === 0) {
+      break;
+    }
+    sorted.push(ready);
+    for (const r of ready) {
+      remaining.delete(r.id);
+    }
+  }
+  return sorted;
+}
+async function executeSubtask(subtask, deps, _sharedContext) {
+  const startTime = Date.now();
+  const expertConfig = getExpertConfig(deps.config, subtask.expert_tag);
+  if (!expertConfig) {
+    return {
+      subtaskId: subtask.id,
+      success: false,
+      summary: `Unknown expert_tag: ${subtask.expert_tag}`,
+      result: "",
+      error: `No expert config found for tag "${subtask.expert_tag}"`,
+      durationMs: Date.now() - startTime
+    };
+  }
+  const subagentTool = deps.toolRegistry.get("subagent");
+  if (!subagentTool) {
+    return {
+      subtaskId: subtask.id,
+      success: false,
+      summary: "Subagent tool not registered",
+      result: "",
+      error: "Subagent tool not found in registry",
+      durationMs: Date.now() - startTime
+    };
+  }
+  const allTools = deps.toolRegistry.getAll();
+  const filteredTools = filterToolsByTags(allTools, expertConfig.tool_tags);
+  if (filteredTools.length === 0) {
+    return {
+      subtaskId: subtask.id,
+      success: false,
+      summary: `No tools available for expert "${subtask.expert_tag}" (tags: ${expertConfig.tool_tags.join(", ")})`,
+      result: "",
+      error: "No matching tools",
+      durationMs: Date.now() - startTime
+    };
   }
   const maxAttempts = expertConfig.max_attempts || 3;
   let lastError = "";
   let lastResult = null;
+  const stuckDetector = new StuckDetector(maxAttempts * 2, maxAttempts);
   for (let attempt = 1;attempt <= maxAttempts; attempt++) {
+    stuckDetector.recordIteration(1);
     try {
       const allowedFiles = subtask.allowed_files || [];
       const readOnlyFiles = subtask.read_only_files || [];
@@ -8655,44 +8979,90 @@ ${(subtask.success_criteria || []).map((c) => `- ${c}`).join(`
       }
       lastError = result.output;
       lastResult = result;
+      stuckDetector.recordToolError("subagent", result.output);
+      if (attempt < maxAttempts) {
+        const hints2 = stuckDetector.getActionableHints();
+        const recovery = stuckDetector.getRecoveryMessage();
+        if (hints2.length > 0) {
+          deps.logger.debug(`Hint for subtask "${subtask.id}" retry: ${hints2.join("; ")}`);
+        }
+        if (recovery) {
+          deps.logger.debug(`Recovery for subtask "${subtask.id}": ${recovery}`);
+        }
+      }
       if (isTransientError(lastError) && attempt < maxAttempts) {
         const delay = Math.min(1000 * Math.pow(2, attempt - 1), 8000);
         deps.logger.debug(`Retrying subtask "${subtask.id}" (attempt ${attempt}/${maxAttempts}) after ${delay}ms: transient error`);
         await sleep(delay);
         continue;
       }
+      const hints = stuckDetector.getActionableHints();
+      const suggestedSkill = suggestSkill(lastError);
+      let errorDetail = result.output;
+      if (hints.length > 0) {
+        errorDetail += `
+
+${t("exec.hints", { hints: hints.map((h) => `- ${h}`).join(`
+`) })}`;
+      }
+      if (suggestedSkill) {
+        errorDetail += `
+
+Consider loading the "${suggestedSkill}" skill for expert guidance.`;
+      }
       return {
         subtaskId: subtask.id,
         success: false,
         summary: `Failed: ${subtask.id}`,
         result: result.output,
-        error: result.output,
+        error: errorDetail,
         durationMs: Date.now() - startTime
       };
     } catch (e) {
       lastError = e.message;
+      stuckDetector.recordToolError("subagent", e.message);
       if (isTransientError(lastError) && attempt < maxAttempts) {
         const delay = Math.min(1000 * Math.pow(2, attempt - 1), 8000);
         deps.logger.debug(`Retrying subtask "${subtask.id}" (attempt ${attempt}/${maxAttempts}) after ${delay}ms: ${lastError}`);
         await sleep(delay);
         continue;
       }
+      const hints = stuckDetector.getActionableHints();
+      const suggestedSkill = suggestSkill(lastError);
+      let errorDetail = e.message;
+      if (hints.length > 0) {
+        errorDetail += `
+
+${t("exec.hints", { hints: hints.map((h) => `- ${h}`).join(`
+`) })}`;
+      }
+      if (suggestedSkill) {
+        errorDetail += `
+
+Consider loading the "${suggestedSkill}" skill for expert guidance.`;
+      }
       return {
         subtaskId: subtask.id,
         success: false,
         summary: `Error: ${subtask.id}`,
         result: "",
-        error: e.message,
+        error: errorDetail,
         durationMs: Date.now() - startTime
       };
     }
   }
+  const stuckReason = stuckDetector.getStuckReason();
+  let finalError = lastError;
+  if (stuckReason) {
+    finalError += `
+${stuckReason}`;
+  }
   return {
     subtaskId: subtask.id,
     success: false,
     summary: `Failed after ${maxAttempts} attempts: ${subtask.id}`,
     result: "",
-    error: lastError,
+    error: finalError,
     durationMs: Date.now() - startTime
   };
 }
@@ -8751,6 +9121,9 @@ class MoEExecutor {
 }
 var TRANSIENT_ERROR_PATTERNS;
 var init_moe_executor = __esm(() => {
+  init_stuck_detector();
+  init_error_skill_map();
+  init_i18n();
   TRANSIENT_ERROR_PATTERNS = [
     "timeout",
     "Timeout",
@@ -8772,7 +9145,7 @@ var init_moe_executor = __esm(() => {
 // src/modules/execution/verifier.ts
 import { existsSync as existsSync17 } from "fs";
 import { resolve as resolve10, extname as extname2 } from "path";
-import { execSync as execSync2 } from "child_process";
+import { spawn as spawn2 } from "child_process";
 
 class StepVerifier {
   baseDir;
@@ -8789,12 +9162,7 @@ class StepVerifier {
   }
   async runScript(scriptName) {
     try {
-      execSync2(`bun run ${scriptName}`, {
-        cwd: this.baseDir,
-        encoding: "utf-8",
-        timeout: 60000,
-        stdio: "pipe"
-      });
+      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 }) };
@@ -8806,12 +9174,7 @@ class StepVerifier {
       return { passed: true, message: "No tsconfig.json found — skipping type check" };
     }
     try {
-      execSync2("npx tsc --noEmit", {
-        cwd: this.baseDir,
-        encoding: "utf-8",
-        timeout: 60000,
-        stdio: "pipe"
-      });
+      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;
@@ -8873,7 +9236,7 @@ class StepVerifier {
       results.push(result);
       if (result.passed) {
         const fullPath = resolve10(this.baseDir, filePath);
-        if (!this.validateSyntax(fullPath)) {
+        if (!await this.validateSyntax(fullPath)) {
           syntaxValid = false;
           results.push({ passed: false, message: t("verify.syntax_error", { path: filePath }) });
         }
@@ -8885,11 +9248,11 @@ class StepVerifier {
       failed: results.filter((r) => !r.passed)
     };
   }
-  validateSyntax(filePath) {
+  async validateSyntax(filePath) {
     const ext = extname2(filePath);
     if (ext === ".ts" || ext === ".tsx") {
       try {
-        execSync2(`npx tsc --noEmit --skipLibCheck ${filePath}`, { stdio: "pipe", timeout: 1e4 });
+        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")) {
@@ -8904,7 +9267,7 @@ class StepVerifier {
     }
     if (ext === ".js" || ext === ".jsx") {
       try {
-        execSync2(`node --check ${filePath}`, { stdio: "pipe", timeout: 5000 });
+        await this.runAsync(`node --check ${filePath}`, this.baseDir, 5000);
         return true;
       } catch {
         return false;
@@ -8912,6 +9275,44 @@ class StepVerifier {
     }
     return true;
   }
+  runAsync(command, cwd, timeoutMs) {
+    return new Promise((resolve11, 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) {
+          resolve11({ 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();
@@ -9240,6 +9641,17 @@ ${t("tool.truncated", { tokens: Math.ceil(removedChars / 2) })}`;
         logger,
         sessionManager: sessionManager?.getActiveMeta()
       });
+      if (config.session?.baselineCheck !== false) {
+        const verifier = new StepVerifier(baseDir);
+        verifier.runTypeCheck().then((tc) => {
+          if (!tc.passed) {
+            logger.warn(`Baseline typecheck has issues: ${tc.message?.slice(0, 500)}`);
+            onMeta?.(pc.yellow(`
+⚠ Baseline typecheck has issues
+`));
+          }
+        }).catch(() => {});
+      }
     }
     contextManager.addMessage({ role: "user", content: input });
     slog.logUser(input);
@@ -9287,7 +9699,10 @@ ${t("tool.truncated", { tokens: Math.ceil(removedChars / 2) })}`;
         logger,
         lastUserMessage: input,
         contextManager,
-        onMeta
+        onMeta,
+        sessionLog: {
+          plan: (event, detail, iter) => slog.logPlan(event, detail, iter)
+        }
       });
       if (contextManager.needsCompaction()) {
         contextManager.compact();
@@ -9296,6 +9711,12 @@ ${t("tool.truncated", { tokens: Math.ceil(removedChars / 2) })}`;
       }
       const currentTokens = contextManager.getEstimatedTokens();
       const budget2 = contextManager.getBudget();
+      const quality = contextManager.getQuality();
+      if (quality < QUALITY_TRIGGER_THRESHOLD && contextManager.getCompactionCount() > 0) {
+        contextManager.compact();
+        logger.warn(`Low context quality (${quality}%) — forced compaction`);
+        slog.logCompaction(`quality-triggered compaction (${quality}% < ${QUALITY_TRIGGER_THRESHOLD}%), iteration ${iteration}`, iteration, currentTokens, budget2.history);
+      }
       if (currentTokens > budget2.history) {
         contextManager.compact();
         logger.warn(`Context overflow (${currentTokens} > ${budget2.history}), forced compaction`);
@@ -9423,6 +9844,14 @@ ${t("tool.truncated", { tokens: Math.ceil(removedChars / 2) })}`;
           const duration = Date.now() - startTime;
           if (!result.success)
             anyToolFailed = true;
+          if (result.success && call.arguments.path) {
+            const filePath = String(call.arguments.path);
+            if (call.name === "write_file" || call.name === "edit_file") {
+              hallucinationDetector.getConsistencyCheck().trackCreatedFile(filePath);
+            } else if (call.name === "delete_file") {
+              hallucinationDetector.getConsistencyCheck().trackDeletedFile(filePath);
+            }
+          }
           pluginManager.runOnToolEnd({ iteration, logger }, { id: call.id, name: call.name, arguments: call.arguments }, result, duration);
           if (result.display) {
             onMeta?.(`
@@ -9507,14 +9936,15 @@ ${taskReminder}</system-summary>`
         const ctxBar = pc.green("█".repeat(filled)) + pc.dim("░".repeat(barLen - filled));
         const pctColor = ctxPct >= 75 ? pc.yellow : pc.dim;
         const compCount = contextManager.getCompactionCount();
-        const quality = contextManager.getQuality();
-        const qualityColor = quality >= 70 ? pc.green : quality >= 40 ? pc.yellow : pc.red;
+        const quality2 = contextManager.getQuality();
+        const qualityColor = quality2 >= 70 ? pc.green : quality2 >= 40 ? pc.yellow : pc.red;
         onMeta?.(`
-  ${ctxBar}  ${pctColor(`${ctxPct}%`)}  ${pc.dim(`ctx: ${ctxTokens}/${ctxBudget.history}`)}  ${pc.dim(`compactions: ${compCount}`)}  ${qualityColor(`quality: ${quality}%`)}
+  ${ctxBar}  ${pctColor(`${ctxPct}%`)}  ${pc.dim(`ctx: ${ctxTokens}/${ctxBudget.history}`)}  ${pc.dim(`compactions: ${compCount}`)}  ${qualityColor(`quality: ${quality2}%`)}
 `);
         continue;
       }
-      const hallucinationResult = hallucinationDetector.validate(textContent);
+      hallucinationDetector.getConfidenceCheck().setPreviousResponse(lastText);
+      const hallucinationResult = await hallucinationDetector.validate(textContent);
       if (hallucinationResult.status === "block") {
         logger.warn(`Response blocked: ${hallucinationResult.reason}`);
         return {
@@ -9570,6 +10000,14 @@ ${taskReminder}</system-summary>`
         slog.logAssistant(textContent, reasoningContent, undefined, iteration);
       }
       lastText = textContent;
+      {
+        const decisionPatterns = [
+          ...textContent.matchAll(/(?:plan|decided|decision|решено|план|решение):\s*(.+?)(?:\n|$)/gi)
+        ];
+        for (const match of decisionPatterns) {
+          hallucinationDetector.getConsistencyCheck().trackDecision(match[1].trim(), "agent_response");
+        }
+      }
       if (!sawToolCall) {
         if (this.deps.finalAudit) {
           const audit = await this.deps.finalAudit();
@@ -9677,7 +10115,7 @@ ${taskReminder}</system-summary>`
     });
   }
 }
-var TOOL_RESULT_MAX_TOKENS_RATIO = 0.3, TOOL_RESULT_ABSOLUTE_MAX_CHARS = 15000;
+var TOOL_RESULT_MAX_TOKENS_RATIO = 0.3, TOOL_RESULT_ABSOLUTE_MAX_CHARS = 15000, QUALITY_TRIGGER_THRESHOLD = 40;
 var init_agent = __esm(() => {
   init_i18n();
   init_colors();
@@ -9685,6 +10123,7 @@ var init_agent = __esm(() => {
   init_processes();
   init_agent_moe();
   init_store();
+  init_verifier();
 });
 
 // src/modules/context/manager.ts
@@ -9990,53 +10429,16 @@ class ConsistencyCheck {
   getCreatedFiles() {
     return Array.from(this.createdFiles);
   }
-  validate(response) {
-    const lower = response.toLowerCase();
-    for (const d of this.decisions) {
-      const decisionWords = d.decision.toLowerCase().split(/\s+/).filter((w) => w.length > 3);
-      const contradicts = decisionWords.some((word) => {
-        if (lower.includes(`instead of ${word}`))
-          return true;
-        if (lower.includes(`not ${word}`))
-          return true;
-        if (lower.includes(`replacing ${word} with`))
-          return true;
-        if (lower.includes(`switching to`))
-          return true;
-        if (lower.includes(`changing from ${word}`))
-          return true;
-        if (lower.includes(`abandoning ${word}`))
-          return true;
-        if (lower.includes(`вместо ${word}`))
-          return true;
-        if (lower.includes(`заменяя ${word}`))
-          return true;
-        if (lower.includes(`заменяем ${word}`))
-          return true;
-        if (lower.includes(`переключаемся на`))
-          return true;
-        if (lower.includes(`от ${word} к`))
-          return true;
-        if (lower.includes(`отказываемся от ${word}`))
-          return true;
-        return false;
-      });
-      if (contradicts) {
-        return {
-          status: "warn",
-          reason: t("hall.contradiction", {
-            decision: d.decision,
-            location: d.location
-          })
-        };
-      }
-    }
-    return { status: "pass" };
+  getDeletedFiles() {
+    return Array.from(this.deletedFiles);
+  }
+  getDecisions() {
+    return this.decisions;
+  }
+  hasDecisions() {
+    return this.decisions.length > 0;
   }
 }
-var init_consistency = __esm(() => {
-  init_i18n();
-});
 
 // src/modules/hallucination/confidence.ts
 class ConfidenceCheck {
@@ -10078,19 +10480,193 @@ class ConfidenceCheck {
         };
       }
     }
-    return { status: "pass" };
-  }
-  calculateOverlap(a, b) {
-    const wordsA = new Set(a.toLowerCase().split(/\s+/));
-    const wordsB = b.toLowerCase().split(/\s+/);
-    if (wordsB.length === 0)
-      return 0;
-    const matches = wordsB.filter((w) => wordsA.has(w));
-    return matches.length / wordsB.length;
+    return { status: "pass" };
+  }
+  calculateOverlap(a, b) {
+    const wordsA = new Set(a.toLowerCase().split(/\s+/));
+    const wordsB = b.toLowerCase().split(/\s+/);
+    if (wordsB.length === 0)
+      return 0;
+    const matches = wordsB.filter((w) => wordsA.has(w));
+    return matches.length / wordsB.length;
+  }
+}
+var MIN_CHARS = 1, MIN_WORDS = 5;
+var init_confidence = __esm(() => {
+  init_i18n();
+});
+
+// src/modules/hallucination/factual.ts
+import { existsSync as existsSync20 } from "fs";
+import { resolve as resolve11, isAbsolute } from "path";
+function looksLikeFilePath(s) {
+  const lower = s.toLowerCase();
+  if (TECH_NAMES.has(lower))
+    return false;
+  if (!s.includes("/") && !s.includes("\\") && !s.match(/^\w+\.[a-z]{2,4}$/i))
+    return false;
+  const ext = s.split(".").pop()?.toLowerCase() || "";
+  return !NON_FILE_EXTENSIONS.has(ext);
+}
+
+class FactualCheck {
+  baseDir;
+  constructor(baseDir) {
+    this.baseDir = baseDir;
+  }
+  validate(response) {
+    const filePaths = this.extractFilePaths(response);
+    if (filePaths.length === 0)
+      return { status: "pass" };
+    const nonExistent = [];
+    for (const fp of filePaths) {
+      const abs = isAbsolute(fp) ? fp : resolve11(this.baseDir, fp);
+      if (!existsSync20(abs)) {
+        nonExistent.push(fp);
+      }
+    }
+    if (nonExistent.length > 0) {
+      return {
+        status: "warn",
+        reason: t("hall.unknown_paths", {
+          paths: nonExistent.slice(0, 5).join(", ")
+        })
+      };
+    }
+    return { status: "pass" };
+  }
+  extractFilePaths(text) {
+    const pattern = /\b(?:[a-zA-Z]:[\\/])?[\w./\\-]+\.[a-z]{2,6}\b/gi;
+    const matches = text.match(pattern) || [];
+    return [...new Set(matches)].filter(looksLikeFilePath);
+  }
+}
+var NON_FILE_EXTENSIONS, TECH_NAMES;
+var init_factual = __esm(() => {
+  init_i18n();
+  NON_FILE_EXTENSIONS = new Set([
+    "com",
+    "org",
+    "net",
+    "gov",
+    "edu",
+    "io",
+    "dev",
+    "app",
+    "co",
+    "ai",
+    "ru",
+    "de",
+    "fr",
+    "uk",
+    "us",
+    "es",
+    "it",
+    "jp",
+    "cn",
+    "br"
+  ]);
+  TECH_NAMES = new Set([
+    "node.js",
+    "react.js",
+    "vue.js",
+    "next.js",
+    "angular.js",
+    "express.js",
+    "deno.js",
+    "qwik.js",
+    "svelte.js",
+    "jquery.js"
+  ]);
+});
+
+// src/modules/hallucination/llm-judge.ts
+class LLMJudge {
+  provider;
+  constructor(provider) {
+    this.provider = provider;
+  }
+  async validate(response, consistency) {
+    const decisions = consistency.getDecisions();
+    if (decisions.length === 0) {
+      return { status: "pass" };
+    }
+    const shown = decisions.slice(-MAX_DECISIONS_SHOWN);
+    const decisionLines = shown.map((d, i) => `${i + 1}. [${d.location || "agent"}] "${d.decision}"`).join(`
+`);
+    const system = `You are a consistency checker for an AI coding agent. The agent previously made these decisions:
+
+${decisionLines}
+
+Decide whether the agent's NEW response contradicts any of these decisions. A contradiction means reversing or abandoning a previously stated approach (e.g. switching to a different framework, changing a chosen strategy, or undoing a decision that was explicitly made).
+
+Reply with ONLY valid JSON, no other text:
+- {"contradicts": false}
+- {"contradicts": true, "reason": "short explanation"}`;
+    const user = `Agent's new response:
+
+${response.slice(0, MAX_RESPONSE_CHARS)}`;
+    try {
+      const verdictText = await this.askJudge([
+        { role: "system", content: system },
+        { role: "user", content: user }
+      ]);
+      const verdict = this.parseVerdict(verdictText);
+      if (verdict.contradicts) {
+        const reason = verdict.reason?.trim() ? ` — ${verdict.reason.trim()}` : "";
+        return {
+          status: "warn",
+          reason: t("hall.contradiction_llm", { reason })
+        };
+      }
+      return { status: "pass" };
+    } catch {
+      return { status: "pass" };
+    }
+  }
+  async askJudge(messages) {
+    let text = "";
+    let timer;
+    const consume = (async () => {
+      for await (const chunk of this.provider.chat(messages, [])) {
+        if (chunk.type === "text" && chunk.content) {
+          text += chunk.content;
+        }
+      }
+      return text;
+    })();
+    const timeout = new Promise((_, reject) => {
+      timer = setTimeout(() => reject(new Error("LLM judge timed out")), JUDGE_TIMEOUT_MS);
+    });
+    try {
+      return await Promise.race([consume, timeout]);
+    } finally {
+      if (timer)
+        clearTimeout(timer);
+    }
+  }
+  parseVerdict(text) {
+    const block = text.match(/\{[\s\S]*\}/);
+    if (block) {
+      try {
+        const obj = JSON.parse(block[0]);
+        if (typeof obj.contradicts === "boolean") {
+          return {
+            contradicts: obj.contradicts,
+            reason: typeof obj.reason === "string" ? obj.reason : undefined
+          };
+        }
+      } catch {}
+    }
+    const lower = text.toLowerCase();
+    if (lower.includes('"contradicts": true') || /^yes\b/.test(lower.trim())) {
+      return { contradicts: true, reason: text.slice(0, 200) };
+    }
+    return { contradicts: false };
   }
 }
-var MIN_CHARS = 1, MIN_WORDS = 5;
-var init_confidence = __esm(() => {
+var JUDGE_TIMEOUT_MS = 15000, MAX_DECISIONS_SHOWN = 6, MAX_RESPONSE_CHARS = 2000;
+var init_llm_judge = __esm(() => {
   init_i18n();
 });
 
@@ -10098,9 +10674,13 @@ var init_confidence = __esm(() => {
 class HallucinationDetector {
   consistency;
   confidence;
-  constructor() {
+  factual;
+  judge;
+  constructor(baseDir, llmProvider) {
     this.consistency = new ConsistencyCheck;
     this.confidence = new ConfidenceCheck;
+    this.factual = baseDir ? new FactualCheck(baseDir) : null;
+    this.judge = llmProvider ? new LLMJudge(llmProvider) : null;
   }
   getConsistencyCheck() {
     return this.consistency;
@@ -10108,15 +10688,19 @@ class HallucinationDetector {
   getConfidenceCheck() {
     return this.confidence;
   }
-  validate(response) {
+  async validate(response) {
     const confidenceResult = this.confidence.validate(response);
     if (confidenceResult.status === "retry" || confidenceResult.status === "block") {
       return confidenceResult;
     }
-    const consistencyResult = this.consistency.validate(response);
+    const factualResult = this.factual?.validate(response);
+    if (factualResult && factualResult.status !== "pass") {
+      return factualResult;
+    }
+    const judgeResult = this.judge ? await this.judge.validate(response, this.consistency) : null;
     const warnings = [];
-    if (consistencyResult.status === "warn")
-      warnings.push(consistencyResult.reason || "");
+    if (judgeResult && judgeResult.status === "warn")
+      warnings.push(judgeResult.reason || "");
     if (confidenceResult.status === "warn")
       warnings.push(confidenceResult.reason || "");
     if (warnings.length > 0) {
@@ -10126,8 +10710,9 @@ class HallucinationDetector {
   }
 }
 var init_detector = __esm(() => {
-  init_consistency();
   init_confidence();
+  init_factual();
+  init_llm_judge();
 });
 
 // src/modules/plugins/manager.ts
@@ -10370,7 +10955,7 @@ var init_subagent = __esm(() => {
       try {
         const subContextManager = new ContextManager(ctx.config.contextWindow, ctx.config.contextBudget);
         const subPluginManager = new PluginManager;
-        const hallucinationDetector = new HallucinationDetector;
+        const hallucinationDetector = new HallucinationDetector(ctx.baseDir, ctx.llmProvider);
         const systemPrompt = {
           content: `You are a sub-agent working on a specific task. ${context ? `Context: ${context}` : ""}`,
           priority: "critical",
@@ -10896,7 +11481,7 @@ async function runStep(ctx, step, params, outputs) {
         toolExecutor: ctx.toolExecutor,
         pluginManager: subPluginManager,
         contextManager: subContextManager,
-        hallucinationDetector: new HallucinationDetector,
+        hallucinationDetector: new HallucinationDetector(ctx.baseDir, ctx.llmProvider),
         logger: ctx.logger,
         baseDir: ctx.baseDir,
         scope: ctx.scope,
@@ -11126,7 +11711,7 @@ class MCPClient {
     }
   }
   connectStdio() {
-    return new Promise((resolve11, reject) => {
+    return new Promise((resolve12, reject) => {
       const child = spawn3(this.config.command, this.config.args || [], {
         env: { ...process.env, ...this.config.env },
         stdio: ["pipe", "pipe", "pipe"]
@@ -11144,7 +11729,7 @@ class MCPClient {
       child.on("spawn", () => {
         this._connected = true;
         this.process = child;
-        resolve11();
+        resolve12();
       });
     });
   }
@@ -11213,7 +11798,7 @@ class MCPClient {
     if (!this.process) {
       throw new Error("Not connected to MCP server");
     }
-    return new Promise((resolve11, reject) => {
+    return new Promise((resolve12, reject) => {
       const request = {
         jsonrpc: "2.0",
         id: Date.now(),
@@ -11237,7 +11822,7 @@ class MCPClient {
                 if (response.error) {
                   reject(new Error(response.error.message));
                 } else {
-                  resolve11(response.result?.tools || []);
+                  resolve12(response.result?.tools || []);
                 }
                 return;
               }
@@ -11319,8 +11904,8 @@ class MCPClient {
         arguments: args
       }
     };
-    return new Promise((resolve11, reject) => {
-      this.pendingResolve = resolve11;
+    return new Promise((resolve12, reject) => {
+      this.pendingResolve = resolve12;
       this.pendingReject = reject;
       const timeout = this.config.timeout || 30000;
       const timer = setTimeout(() => {
@@ -11347,7 +11932,7 @@ class MCPClient {
         if (result.error) {
           reject(new Error(result.error.message));
         } else {
-          resolve11(result.result || result);
+          resolve12(result.result || result);
         }
       }).catch((err) => {
         clearTimeout(timer);
@@ -11361,7 +11946,7 @@ class MCPClient {
     if (!this.process) {
       throw new Error("Not connected to MCP server");
     }
-    return new Promise((resolve11, reject) => {
+    return new Promise((resolve12, reject) => {
       const request = {
         jsonrpc: "2.0",
         id: Date.now(),
@@ -11389,7 +11974,7 @@ class MCPClient {
                 if (response.error) {
                   reject(new Error(response.error.message));
                 } else {
-                  resolve11(response.result);
+                  resolve12(response.result);
                 }
                 return;
               }
@@ -12377,14 +12962,14 @@ async function readClipboardImage() {
   return readClipboardFallback();
 }
 async function readClipboardFallback() {
-  const { platform: platform4 } = await import("os");
-  const { execSync: execSync3 } = await import("child_process");
+  const { platform: platform3 } = await import("os");
+  const { execSync: execSync2 } = await import("child_process");
   const { readFileSync: readFileSync13, unlinkSync: unlinkSync3 } = await import("fs");
   const { join: join16 } = await import("path");
   const tmpPath = join16(process.env.TEMP || process.env.TMP || "/tmp", `mma-clip-${Date.now()}.png`);
   try {
-    if (platform4() === "linux") {
-      execSync3(`xclip -selection clipboard -t image/png -o > "${tmpPath}" 2>/dev/null`, { timeout: 5000 });
+    if (platform3() === "linux") {
+      execSync2(`xclip -selection clipboard -t image/png -o > "${tmpPath}" 2>/dev/null`, { timeout: 5000 });
     } else {
       return null;
     }
@@ -12459,8 +13044,8 @@ var init_image_utils = __esm(() => {
 });
 
 // src/tools/attach-image.ts
-import { existsSync as existsSync21 } from "fs";
-import { resolve as resolve11 } from "path";
+import { existsSync as existsSync22 } from "fs";
+import { resolve as resolve12 } from "path";
 var attachImageTool;
 var init_attach_image = __esm(() => {
   init_i18n();
@@ -12501,8 +13086,8 @@ var init_attach_image = __esm(() => {
           const result = await loadUrlAsDataUrl(source);
           dataUrl = result.dataUrl;
         } else {
-          const absPath = resolve11(ctx.baseDir, source);
-          if (!existsSync21(absPath)) {
+          const absPath = resolve12(ctx.baseDir, source);
+          if (!existsSync22(absPath)) {
             return {
               success: false,
               output: t("image.not_found", { path: source })
@@ -12658,12 +13243,12 @@ class ModuleRegistry {
 }
 
 // src/modules/plugins/loader.ts
-import { readdirSync as readdirSync5, existsSync as existsSync22, statSync as statSync4 } from "fs";
+import { readdirSync as readdirSync5, existsSync as existsSync23, statSync as statSync4 } from "fs";
 import { join as join16 } from "path";
 
 class PluginLoader {
   loadFromDir(dirPath, pluginManager, logger) {
-    if (!existsSync22(dirPath))
+    if (!existsSync23(dirPath))
       return;
     const entries = readdirSync5(dirPath);
     for (const entry of entries) {
@@ -12690,9 +13275,9 @@ var init_loader = __esm(() => {
 });
 
 // src/modules/plugins/builtin/lint-on-write.ts
-import { execSync as execSync3 } from "child_process";
-import { existsSync as existsSync23, readFileSync as readFileSync13 } from "fs";
-import { resolve as resolve12, extname as extname4, join as join17 } from "path";
+import { spawn as spawn4 } from "child_process";
+import { existsSync as existsSync24, readFileSync as readFileSync13 } from "fs";
+import { resolve as resolve13, extname as extname4, join as join17 } from "path";
 
 class LintOnWritePlugin {
   name = "lint-on-write";
@@ -12707,11 +13292,11 @@ class LintOnWritePlugin {
     const path = String(call.arguments.path || "");
     if (!path)
       return;
-    const fullPath = resolve12(ctx.baseDir, path);
-    if (!existsSync23(fullPath))
+    const fullPath = resolve13(ctx.baseDir, path);
+    if (!existsSync24(fullPath))
       return;
     const ext = extname4(fullPath);
-    const syntaxError = this.checkSyntax(fullPath, ext, ctx.baseDir);
+    const syntaxError = await this.checkSyntax(fullPath, ext, ctx.baseDir);
     if (syntaxError) {
       result.output += `
 
@@ -12721,10 +13306,10 @@ class LintOnWritePlugin {
     await this.runProjectLint(ctx, result);
     await this.runProjectTypeCheck(ctx, result);
   }
-  checkSyntax(filePath, ext, baseDir) {
+  async checkSyntax(filePath, ext, baseDir) {
     if (ext === ".ts" || ext === ".tsx") {
       try {
-        execSync3(`npx tsc --noEmit --skipLibCheck "${filePath}"`, { cwd: baseDir, stdio: "pipe", timeout: 1e4 });
+        await runAsync(`npx tsc --noEmit --skipLibCheck "${filePath}"`, baseDir, 1e4);
         return null;
       } catch (err) {
         if (err.status === 127 || err.message.includes("not found") || err.message.includes("ENOENT")) {
@@ -12741,7 +13326,7 @@ class LintOnWritePlugin {
     }
     if (ext === ".js" || ext === ".jsx") {
       try {
-        execSync3(`node --check "${filePath}"`, { cwd: baseDir, stdio: "pipe", timeout: 5000 });
+        await runAsync(`node --check "${filePath}"`, baseDir, 5000);
         return null;
       } catch (err) {
         const stderr = err.stderr?.toString() || "";
@@ -12755,7 +13340,7 @@ class LintOnWritePlugin {
   async runProjectLint(ctx, result) {
     try {
       const packageJsonPath = join17(ctx.baseDir, "package.json");
-      if (!existsSync23(packageJsonPath)) {
+      if (!existsSync24(packageJsonPath)) {
         return;
       }
       const packageJson = JSON.parse(readFileSync13(packageJsonPath, "utf-8"));
@@ -12764,7 +13349,7 @@ class LintOnWritePlugin {
         return;
       }
       ctx.logger.debug(`Running lint: ${lintScript}`);
-      execSync3(lintScript, { cwd: ctx.baseDir, stdio: "pipe" });
+      await runAsync(lintScript, ctx.baseDir, 30000);
       ctx.logger.debug("Lint passed");
     } catch (err) {
       ctx.logger.warn(`Lint failed: ${err.message}`);
@@ -12775,7 +13360,7 @@ class LintOnWritePlugin {
   }
   async runProjectTypeCheck(ctx, result) {
     const tsconfigPath = join17(ctx.baseDir, "tsconfig.json");
-    if (!existsSync23(tsconfigPath)) {
+    if (!existsSync24(tsconfigPath)) {
       return;
     }
     const now = Date.now();
@@ -12799,7 +13384,7 @@ class LintOnWritePlugin {
   }
   async runTscCheck(baseDir) {
     try {
-      execSync3(`npx tsc --noEmit --skipLibCheck`, { cwd: baseDir, stdio: "pipe", timeout: 30000 });
+      await runAsync(`npx tsc --noEmit --skipLibCheck`, baseDir, 30000);
       return null;
     } catch (err) {
       if (err.status === 127 || err.message.includes("not found") || err.message.includes("ENOENT")) {
@@ -12815,6 +13400,44 @@ class LintOnWritePlugin {
     }
   }
 }
+function runAsync(command, cwd, timeoutMs) {
+  return new Promise((resolve14, reject) => {
+    const child = spawn4(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 projectTypeCheckPromise = null, projectTypeCheckTimestamp = 0, TYPE_CHECK_DEBOUNCE_MS = 2000, plugin;
 var init_lint_on_write = __esm(() => {
   plugin = new LintOnWritePlugin;
@@ -12859,380 +13482,105 @@ class PlanCreator {
       "make",
       "develop"
     ];
-    const words = task.split(/\s+/);
-    const hasActionWord = actionWords.some((w) => task.toLowerCase().includes(w));
-    return hasActionWord && words.length > 8;
-  }
-  static createPlan(title, stepDescriptions, baseDir) {
-    const stepCount = stepDescriptions.length;
-    return {
-      id: generatePlanId(),
-      title: `[${stepCount} ст.] ${title}`,
-      steps: stepDescriptions.map((desc, i) => ({
-        id: i + 1,
-        description: desc,
-        status: "pending"
-      })),
-      createdAt: new Date().toISOString(),
-      baseDir
-    };
-  }
-  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}`);
-    }
-    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;
-  }
-  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/stuck-detector.ts
-class StuckDetector {
-  threshold;
-  errorThreshold;
-  iterationsOnCurrentStep = 0;
-  currentStepId = null;
-  toolErrors = new Map;
-  currentStepDescription = "";
-  recentToolCalls = [];
-  maxRecentCalls = 10;
-  repetitionThreshold = 3;
-  consecutiveFailures = 0;
-  lastFailedTool = "";
-  lastErrorOutput = "";
-  escalationCount = 0;
-  escalationThreshold = 3;
-  fileRewriteCount = new Map;
-  fileRewriteThreshold = 3;
-  constructor(threshold = 8, errorThreshold = 3) {
-    this.threshold = threshold;
-    this.errorThreshold = errorThreshold;
-  }
-  recordIteration(stepId) {
-    if (stepId === this.currentStepId) {
-      this.iterationsOnCurrentStep++;
-    } else {
-      this.currentStepId = stepId;
-      this.iterationsOnCurrentStep = 1;
-    }
-  }
-  recordToolCall(name, args) {
-    const argsKey = JSON.stringify(args);
-    this.recentToolCalls.push({ name, argsKey });
-    if (this.recentToolCalls.length > this.maxRecentCalls) {
-      this.recentToolCalls.shift();
-    }
-  }
-  recordToolError(toolName, output) {
-    this.toolErrors.set(toolName, (this.toolErrors.get(toolName) || 0) + 1);
-    this.consecutiveFailures++;
-    this.lastFailedTool = toolName;
-    if (output)
-      this.lastErrorOutput = output;
-  }
-  getLastErrorOutput() {
-    return this.lastErrorOutput;
-  }
-  getLastFailedTool() {
-    return this.lastFailedTool;
-  }
-  getIterationsOnCurrentStep() {
-    return this.iterationsOnCurrentStep;
-  }
-  recordToolSuccess() {
-    this.consecutiveFailures = 0;
-    this.lastFailedTool = "";
-    this.escalationCount = 0;
-  }
-  setCurrentStep(stepId, description) {
-    if (stepId !== this.currentStepId) {
-      this.currentStepId = stepId;
-      this.iterationsOnCurrentStep = 1;
-    }
-    this.currentStepDescription = description;
-  }
-  isStuck() {
-    return this.iterationsOnCurrentStep > this.threshold;
-  }
-  hasRepetitiveErrors(toolName) {
-    if (toolName) {
-      return (this.toolErrors.get(toolName) || 0) >= this.errorThreshold;
-    }
-    return Array.from(this.toolErrors.values()).some((c) => c >= this.errorThreshold);
-  }
-  hasRepetitiveToolCalls() {
-    if (this.recentToolCalls.length < this.repetitionThreshold)
-      return false;
-    const last = this.recentToolCalls[this.recentToolCalls.length - 1];
-    let count = 1;
-    for (let i = this.recentToolCalls.length - 2;i >= 0; i--) {
-      if (this.recentToolCalls[i].name === last.name && this.recentToolCalls[i].argsKey === last.argsKey) {
-        count++;
-      } else {
-        break;
-      }
-    }
-    return count >= this.repetitionThreshold;
-  }
-  hasConsecutiveFailures() {
-    return this.consecutiveFailures >= this.errorThreshold;
-  }
-  getConsecutiveFailuresCount() {
-    return this.consecutiveFailures;
-  }
-  recordEscalation() {
-    this.escalationCount++;
-  }
-  shouldEscalate() {
-    return this.escalationCount >= this.escalationThreshold;
-  }
-  resetEscalation() {
-    this.escalationCount = 0;
-  }
-  getEscalationCount() {
-    return this.escalationCount;
-  }
-  getHints() {
-    const hints = [];
-    const desc = this.currentStepDescription.toLowerCase();
-    if (desc.includes("install") || desc.includes("npm") || desc.includes("pip")) {
-      hints.push("Check if a lock file exists (package-lock.json, poetry.lock). If missing, run the install command first.");
-    }
-    if (desc.includes("test") || desc.includes("spec")) {
-      hints.push("Make sure the source files exist and have real code before running tests.");
-    }
-    if (desc.includes("build") || desc.includes("compile")) {
-      hints.push("Check that all dependencies are installed and source files are not empty.");
-    }
-    if (desc.includes("deploy") || desc.includes("publish")) {
-      hints.push("Verify credentials and network access before deploying.");
-    }
-    if (this.hasRepetitiveToolCalls()) {
-      hints.push("You are calling the same tool repeatedly with the same arguments. Try a different approach.");
-    }
-    if (this.hasConsecutiveFailures()) {
-      hints.push("Multiple different tools are failing. Check if the environment is set up correctly.");
-    }
-    return hints;
+    const words = task.split(/\s+/);
+    const hasActionWord = actionWords.some((w) => task.toLowerCase().includes(w));
+    return hasActionWord && words.length > 8;
   }
-  getActionableHints() {
-    const hints = [];
-    const error = this.lastErrorOutput;
-    if (!error)
-      return hints;
-    if (/Cannot read properties of undefined|is not a function|is not a constructor/i.test(error)) {
-      if (/node_modules/.test(error)) {
-        hints.push("A dependency is incompatible with your Node.js version. Check if there is an alternative package or use a different runtime.");
-      }
-    }
-    if (/TS1005|TS1003|TS1109|TS1128|TS1434/i.test(error)) {
-      hints.push("TypeScript syntax error. Read the error message carefully — it tells you the exact line and column. Fix the syntax before retrying.");
-    }
-    if (/TS2322|TS2345|TS2769|TS7006|TS7016/i.test(error)) {
-      hints.push("TypeScript type mismatch. Check the type signature of the function/API you are using. If a package lacks type declarations, install @types/<package> or use skipLibCheck.");
-    }
-    if (/Cannot find module|Module not found|ERR_MODULE_NOT_FOUND/i.test(error)) {
-      hints.push("Module not found. Run npm install or check if the import path is correct.");
-    }
-    if (/EACCES|EPERM|permission denied/i.test(error)) {
-      hints.push("Permission denied. Check file permissions or run with appropriate privileges.");
-    }
-    if (/ECONNREFUSED|ETIMEDOUT|ENOTFOUND|fetch failed/i.test(error)) {
-      hints.push("Network error. Check if the server is running and accessible.");
-    }
-    if (/is not recognized|command not found|not found in path/i.test(error)) {
-      hints.push("Command not found. Check if the tool is installed and in PATH.");
-    }
-    if (this.hasExcessiveRewrites()) {
-      const file = this.getExcessiveRewriteFile();
-      hints.push(`File ${file} has been rewritten ${this.getFileRewriteCount(file)} times without success. Stop rewriting and try a fundamentally different approach.`);
-    }
-    return hints;
+  static createPlan(title, stepDescriptions, baseDir) {
+    const stepCount = stepDescriptions.length;
+    return {
+      id: generatePlanId(),
+      title: `[${stepCount} ст.] ${title}`,
+      steps: stepDescriptions.map((desc, i) => ({
+        id: i + 1,
+        description: desc,
+        status: "pending"
+      })),
+      createdAt: new Date().toISOString(),
+      baseDir
+    };
   }
-  getToolAlternative() {
-    const tool = this.lastFailedTool;
-    const error = this.lastErrorOutput;
-    if (!tool)
-      return null;
-    if (/Cannot read properties of undefined|is not a function|TypeError|ReferenceError/i.test(error)) {
-      const alternatives = {
-        "ts-node": "tsx",
-        jest: "vitest",
-        mocha: "vitest",
-        webpack: "vite",
-        rollup: "vite",
-        parcel: "vite",
-        babel: "tsc",
-        eslint: "biome",
-        prettier: "biome"
-      };
-      for (const [failed, alt] of Object.entries(alternatives)) {
-        if (tool.includes(failed) || error.includes(failed)) {
-          return alt;
-        }
-      }
+  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}`);
     }
-    return null;
+    return lines.join(`
+`);
   }
-  recordFileRewrite(filePath) {
-    const count = (this.fileRewriteCount.get(filePath) || 0) + 1;
-    this.fileRewriteCount.set(filePath, count);
+}
+
+// src/modules/execution/tracker.ts
+class PlanTracker {
+  plan;
+  currentStepIndex = 0;
+  constructor(plan) {
+    this.plan = plan;
   }
-  getFileRewriteCount(filePath) {
-    return this.fileRewriteCount.get(filePath) || 0;
+  getPlan() {
+    return this.plan;
   }
-  hasExcessiveRewrites() {
-    return Array.from(this.fileRewriteCount.values()).some((c) => c >= this.fileRewriteThreshold);
+  getCurrentStepIndex() {
+    return this.currentStepIndex;
   }
-  getExcessiveRewriteFile() {
-    for (const [file, count] of this.fileRewriteCount) {
-      if (count >= this.fileRewriteThreshold)
-        return file;
-    }
-    return null;
+  getCurrentStep() {
+    return this.plan.steps[this.currentStepIndex];
   }
-  getRepetitiveToolMessage() {
-    if (!this.hasRepetitiveToolCalls())
-      return "";
-    const last = this.recentToolCalls[this.recentToolCalls.length - 1];
-    return t("exec.repetitive_tool", {
-      tool: last.name,
-      count: this.repetitionThreshold
-    });
+  getStep(id) {
+    return this.plan.steps.find((s) => s.id === id);
   }
-  getStuckReason() {
-    if (this.isStuck()) {
-      return t("exec.stuck", {
-        stepId: String(this.currentStepId ?? "?"),
-        description: this.currentStepDescription,
-        iterations: this.iterationsOnCurrentStep
-      });
-    }
-    const errorTool = Array.from(this.toolErrors.entries()).find(([_, c]) => c >= this.errorThreshold);
-    if (errorTool) {
-      return t("exec.tool_errors", { tool: errorTool[0], count: errorTool[1] });
-    }
-    return "";
+  updateStepStatus(id, status) {
+    const step = this.getStep(id);
+    if (step)
+      step.status = status;
   }
-  getRecoveryMessage() {
-    if (this.isStuck()) {
-      return t("exec.stuck_recovery", {
-        iterations: this.iterationsOnCurrentStep,
-        stepId: String(this.currentStepId ?? "?"),
-        description: this.currentStepDescription
-      });
-    }
-    const errorTool = Array.from(this.toolErrors.entries()).find(([_, c]) => c >= this.errorThreshold);
-    if (errorTool) {
-      return t("exec.tool_errors_recovery", {
-        tool: errorTool[0],
-        count: errorTool[1]
-      });
-    }
-    if (this.hasConsecutiveFailures()) {
-      return t("exec.consecutive_failures_recovery", {
-        count: this.consecutiveFailures
-      });
-    }
-    if (this.hasRepetitiveToolCalls()) {
-      return this.getRepetitiveToolMessage();
+  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 "";
+    return false;
   }
-  checkOffTrack(toolName, call) {
-    if (!this.currentStepDescription)
-      return null;
-    const toolArgStr = JSON.stringify(call.arguments).toLowerCase();
-    const pathInStep = (this.currentStepDescription.match(/\b[\w./-]+\.[a-z]+/gi) || []).map((p) => p.toLowerCase());
-    const pathInCall = (toolArgStr.match(/\b[\w./-]+\.[a-z]+/gi) || []).map((p) => p.toLowerCase());
-    const overlaps = pathInCall.some((p) => pathInStep.some((s) => p.includes(s) || s.includes(p)));
-    if (!overlaps && pathInStep.length > 0 && pathInCall.length > 0) {
-      return t("exec.off_track", {
-        stepId: String(this.currentStepId),
-        description: this.currentStepDescription,
-        tool: toolName
-      });
+  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 null;
   }
-  reset() {
-    this.iterationsOnCurrentStep = 0;
-    this.toolErrors.clear();
-    this.consecutiveFailures = 0;
-    this.lastFailedTool = "";
+  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_stuck_detector = __esm(() => {
-  init_i18n();
-});
+var init_tracker = () => {};
 
 // src/modules/execution/auditor.ts
-import { existsSync as existsSync24 } from "fs";
-import { resolve as resolve13 } from "path";
+import { existsSync as existsSync25 } from "fs";
+import { resolve as resolve14 } from "path";
 
 class Auditor {
   baseDir;
@@ -13246,8 +13594,8 @@ class Auditor {
     const missingFiles = [];
     const existingFiles = [];
     for (const filePath of uniqueFiles) {
-      const resolved = resolve13(this.baseDir, filePath);
-      if (existsSync24(resolved)) {
+      const resolved = resolve14(this.baseDir, filePath);
+      if (existsSync25(resolved)) {
         existingFiles.push(filePath);
       } else {
         missingFiles.push(filePath);
@@ -13282,14 +13630,14 @@ var init_auditor = __esm(() => {
 });
 
 // src/modules/execution/plan-persister.ts
-import { readFileSync as readFileSync14, writeFileSync as writeFileSync9, mkdirSync as mkdirSync11, existsSync as existsSync25 } from "fs";
+import { readFileSync as readFileSync14, writeFileSync as writeFileSync9, mkdirSync as mkdirSync11, existsSync as existsSync26 } from "fs";
 import { join as join18 } from "path";
 
 class PlanPersister {
   filePath;
   constructor(baseDir) {
     const mmaDir = join18(baseDir, ".mma");
-    if (!existsSync25(mmaDir)) {
+    if (!existsSync26(mmaDir)) {
       mkdirSync11(mmaDir, { recursive: true });
     }
     this.filePath = join18(mmaDir, "plan.json");
@@ -13306,7 +13654,7 @@ class PlanPersister {
     writeFileSync9(this.filePath, JSON.stringify(file, null, 2), "utf-8");
   }
   load() {
-    if (!existsSync25(this.filePath))
+    if (!existsSync26(this.filePath))
       return null;
     try {
       const raw = readFileSync14(this.filePath, "utf-8");
@@ -13323,7 +13671,7 @@ class PlanPersister {
     }
   }
   clear() {
-    if (existsSync25(this.filePath)) {
+    if (existsSync26(this.filePath)) {
       writeFileSync9(this.filePath, "", "utf-8");
     }
   }
@@ -13394,31 +13742,9 @@ var init_plan_coverage = __esm(() => {
   ]);
 });
 
-// src/modules/skills/error-skill-map.ts
-function suggestSkill(errorOutput) {
-  for (const { pattern, skill } of ERROR_SKILL_MAP) {
-    if (pattern.test(errorOutput))
-      return skill;
-  }
-  return null;
-}
-var ERROR_SKILL_MAP;
-var init_error_skill_map = __esm(() => {
-  ERROR_SKILL_MAP = [
-    { pattern: /TS\d{4}:/i, skill: "typescript-expert" },
-    { pattern: /Cannot find name|No overload matches/i, skill: "typescript-type-expert" },
-    { pattern: /ts-node|tsx.*error/i, skill: "typescript-expert" },
-    { pattern: /Module not found|Cannot resolve module/i, skill: "typescript-expert" },
-    { pattern: /ECONNREFUSED|ETIMEDOUT|fetch failed/i, skill: "devops-expert" },
-    { pattern: /permission denied|EACCES/i, skill: "linux-server-expert" },
-    { pattern: /docker|container/i, skill: "docker-expert" },
-    { pattern: /jest|vitest|test.*fail/i, skill: "vitest-testing-expert" }
-  ];
-});
-
 // src/modules/execution/module.ts
-import { existsSync as existsSync26, readFileSync as readFileSync15 } from "fs";
-import { resolve as resolve14 } from "path";
+import { existsSync as existsSync27, readFileSync as readFileSync15 } from "fs";
+import { resolve as resolve15 } from "path";
 
 class ExecutionModule {
   name = "execution";
@@ -13447,10 +13773,7 @@ class ExecutionModule {
     if (!plan)
       return false;
     this.tracker = new PlanTracker(plan);
-    while (this.tracker.getCurrentStep()?.status === "done" || this.tracker.getCurrentStep()?.status === "skipped") {
-      if (!this.tracker.advance())
-        break;
-    }
+    this.tracker.syncCurrentStep();
     return true;
   }
   getTracker() {
@@ -13562,9 +13885,11 @@ ${display}`,
             this.tracker.updateStepStatus(Number(args.step), args.status || "done");
             if (args.note)
               this.tracker.addNote(Number(args.step), String(args.note));
+            this.tracker.syncCurrentStep();
             this.persister.save(this.tracker.getPlan());
             const progress = this.tracker.getProgressString();
             const display = this.tracker.toPromptBlock();
+            _ctx.sessionLog?.plan("step-update", `${t("plan.step_status", { step: String(args.step), status: String(args.status || "done") })} | ${progress} | current: step ${this.tracker.getCurrentStepIndex() + 1}`);
             return {
               success: true,
               output: `${t("plan.step_status", { step: String(args.step), status: String(args.status || "done") })}
@@ -13683,6 +14008,7 @@ Sub-tasks: ${note}`
         const stuckReason = this.stuckDetector.getStuckReason();
         if (stuckReason) {
           ctx.logger?.warn(stuckReason);
+          ctx.sessionLog?.plan("stuck-warning", stuckReason, typeof ctx.iteration === "number" ? ctx.iteration : undefined);
         }
         if (this.stuckDetector.isStuck() || this.stuckDetector.hasRepetitiveToolCalls()) {
           const currentIter = typeof ctx.iteration === "number" ? ctx.iteration : 0;
@@ -13800,7 +14126,7 @@ Tool "${this.stuckDetector.getLastFailedTool()}" is failing. Try "${alternative}
               }
             }
           }
-          this.advancePlanIfStepComplete(ctx.contextManager);
+          this.advancePlanIfStepComplete(ctx.contextManager, ctx.sessionLog);
         }
       }
     };
@@ -13840,7 +14166,7 @@ Tool "${this.stuckDetector.getLastFailedTool()}" is failing. Try "${alternative}
       tool: call.name
     });
   }
-  advancePlanIfStepComplete(contextManager) {
+  advancePlanIfStepComplete(contextManager, sessionLog) {
     const step = this.tracker?.getCurrentStep();
     if (!step)
       return;
@@ -13860,7 +14186,7 @@ Tool "${this.stuckDetector.getLastFailedTool()}" is failing. Try "${alternative}
         "poetry.lock",
         "requirements.txt"
       ];
-      const hasLockFile = lockFiles.some((f) => existsSync26(resolve14(this.baseDir, f)));
+      const hasLockFile = lockFiles.some((f) => existsSync27(resolve15(this.baseDir, f)));
       if (!hasLockFile) {
         if (contextManager) {
           contextManager.addMessage({
@@ -13873,13 +14199,13 @@ Tool "${this.stuckDetector.getLastFailedTool()}" is failing. Try "${alternative}
     }
     if (stepPaths.length === 0)
       return;
-    const allExist = stepPaths.every((p) => existsSync26(resolve14(this.baseDir, p)));
+    const allExist = stepPaths.every((p) => existsSync27(resolve15(this.baseDir, p)));
     if (!allExist)
       return;
     const emptyFiles = [];
     for (const p of stepPaths) {
       try {
-        const content = readFileSync15(resolve14(this.baseDir, p), "utf-8");
+        const content = readFileSync15(resolve15(this.baseDir, p), "utf-8");
         if (content.trim().length < 10) {
           emptyFiles.push(p);
         }
@@ -13896,6 +14222,7 @@ Tool "${this.stuckDetector.getLastFailedTool()}" is failing. Try "${alternative}
     const hadNext = this.tracker?.advance() ?? false;
     if (this.tracker) {
       this.persister.save(this.tracker.getPlan());
+      sessionLog?.plan("auto-advance", `Step ${step.id} auto-completed | ${this.tracker.getProgressString()} | current: step ${this.tracker.getCurrentStepIndex() + 1}`);
     }
     if (contextManager) {
       const nextStep = hadNext ? this.tracker?.getCurrentStep() : null;
@@ -13934,7 +14261,7 @@ var init_module = __esm(() => {
 });
 
 // src/modules/security/session-encryption.ts
-import { readFileSync as readFileSync16, writeFileSync as writeFileSync10, existsSync as existsSync27, readdirSync as readdirSync6, unlinkSync as unlinkSync3 } from "fs";
+import { readFileSync as readFileSync16, writeFileSync as writeFileSync10, existsSync as existsSync28, readdirSync as readdirSync6, unlinkSync as unlinkSync3 } from "fs";
 import { join as join19 } from "path";
 import { homedir as homedir8 } from "os";
 
@@ -14017,7 +14344,7 @@ class SessionFileEncryptor {
     const files = readdirSync6(sessionDir);
     for (const file of files) {
       const filePath = join19(sessionDir, file);
-      if (existsSync27(filePath) && !file.endsWith(".enc")) {
+      if (existsSync28(filePath) && !file.endsWith(".enc")) {
         try {
           const content = readFileSync16(filePath, "utf8");
           const encrypted = this.encryptFileContent(content);
@@ -14058,7 +14385,7 @@ var init_session_encryption = __esm(() => {
 
 // src/modules/session/store.ts
 import {
-  existsSync as existsSync28,
+  existsSync as existsSync29,
   mkdirSync as mkdirSync12,
   readdirSync as readdirSync7,
   readFileSync as readFileSync17,
@@ -14104,7 +14431,7 @@ class SessionStore {
     return join20(this.sessionDir(id), "session.jsonl");
   }
   sessionExists(id) {
-    return existsSync28(this.metaPath(id));
+    return existsSync29(this.metaPath(id));
   }
   saveMeta(id, meta) {
     const dir = this.sessionDir(id);
@@ -14118,7 +14445,7 @@ class SessionStore {
   }
   loadMeta(id) {
     const path = this.metaPath(id);
-    if (!existsSync28(path))
+    if (!existsSync29(path))
       return null;
     try {
       const raw = readFileSync17(path, "utf-8");
@@ -14148,7 +14475,7 @@ class SessionStore {
   }
   loadHistory(id) {
     const path = this.historyPath(id);
-    if (!existsSync28(path))
+    if (!existsSync29(path))
       return [];
     try {
       const raw = readFileSync17(path, "utf-8");
@@ -14177,7 +14504,7 @@ class SessionStore {
   }
   loadSessionLog(id) {
     const path = this.sessionLogPath(id);
-    if (!existsSync28(path))
+    if (!existsSync29(path))
       return [];
     try {
       const raw = readFileSync17(path, "utf-8");
@@ -14193,7 +14520,7 @@ class SessionStore {
     }
   }
   listSessions() {
-    if (!existsSync28(this.baseDir))
+    if (!existsSync29(this.baseDir))
       return [];
     const entries = readdirSync7(this.baseDir, { withFileTypes: true });
     const sessions = [];
@@ -14209,7 +14536,7 @@ class SessionStore {
   }
   deleteSession(id) {
     const dir = this.sessionDir(id);
-    if (existsSync28(dir)) {
+    if (existsSync29(dir)) {
       rmSync(dir, { recursive: true, force: true });
     }
   }
@@ -14221,7 +14548,7 @@ class SessionStore {
       const updatedAt = new Date(session2.updatedAt);
       if (updatedAt < thirtyDaysAgo) {
         const historyPath = this.historyPath(session2.id);
-        if (existsSync28(historyPath)) {
+        if (existsSync29(historyPath)) {
           const content = readFileSync17(historyPath, "utf-8");
           const compressed = gzipSync(content);
           const gzPath = join20(this.baseDir, `${session2.id}.jsonl.gz`);
@@ -14431,9 +14758,9 @@ class ProfileCompressor {
 }
 
 // src/modules/user-profile/profile.ts
-import { readFileSync as readFileSync18, writeFileSync as writeFileSync12, existsSync as existsSync29, mkdirSync as mkdirSync13 } from "fs";
+import { readFileSync as readFileSync18, writeFileSync as writeFileSync12, existsSync as existsSync30, mkdirSync as mkdirSync13 } from "fs";
 import { join as join21 } from "path";
-import { homedir as homedir9, hostname, platform as platform4, type } from "os";
+import { homedir as homedir9, hostname, platform as platform3, type } from "os";
 import { env } from "process";
 
 class UserProfile {
@@ -14445,7 +14772,7 @@ class UserProfile {
   }
   collect() {
     this.info = {
-      platform: platform4(),
+      platform: platform3(),
       os: `${type()} ${hostname()}`,
       hostname: hostname(),
       shell: env.SHELL || env.ComSpec || "unknown",
@@ -14456,14 +14783,14 @@ class UserProfile {
     return this.info;
   }
   save() {
-    if (!existsSync29(this.profileDir)) {
+    if (!existsSync30(this.profileDir)) {
       mkdirSync13(this.profileDir, { recursive: true });
     }
     writeFileSync12(join21(this.profileDir, "profile.json"), JSON.stringify({ ...this.info, preferences: this.preferences }, null, 2), "utf-8");
   }
   load() {
     const path = join21(this.profileDir, "profile.json");
-    if (!existsSync29(path))
+    if (!existsSync30(path))
       return null;
     try {
       const data = JSON.parse(readFileSync18(path, "utf-8"));
@@ -14501,12 +14828,12 @@ class UserProfile {
 var init_profile = () => {};
 
 // src/modules/skills/loader.ts
-import { readdirSync as readdirSync8, readFileSync as readFileSync19, existsSync as existsSync30, statSync as statSync5 } from "fs";
+import { readdirSync as readdirSync8, readFileSync as readFileSync19, existsSync as existsSync31, statSync as statSync5 } from "fs";
 import { join as join22 } from "path";
 
 class SkillsLoader {
   loadFromDir(dirPath) {
-    if (!existsSync30(dirPath))
+    if (!existsSync31(dirPath))
       return [];
     const skills = [];
     this.scanDir(dirPath, skills);
@@ -14795,8 +15122,8 @@ var init_browser2 = __esm(() => {
 });
 
 // src/modules/lsp/client.ts
-import { spawn as spawn4, execSync as execSync4 } from "child_process";
-import { resolve as resolve15 } from "path";
+import { spawn as spawn5, execSync as execSync2 } from "child_process";
+import { resolve as resolve16 } from "path";
 
 class LspClient {
   process = null;
@@ -14812,7 +15139,7 @@ class LspClient {
     const timeout = config.timeout ?? DEFAULT_TIMEOUT;
     try {
       await this.startServer(config, baseDir);
-      const rootUri = this.pathToUri(resolve15(baseDir));
+      const rootUri = this.pathToUri(resolve16(baseDir));
       const initResult = await this.sendRequest("initialize", {
         processId: process.pid,
         rootUri,
@@ -14821,11 +15148,11 @@ class LspClient {
       }, timeout);
       this.initialized = true;
       this.sendNotification("initialized", {});
-      const uri = this.pathToUri(resolve15(filePath));
+      const uri = this.pathToUri(resolve16(filePath));
       const fs2 = await import("fs");
       const content = fs2.readFileSync(filePath, "utf-8");
-      const diagPromise = new Promise((resolve16) => {
-        this.diagnosticsResolve = resolve16;
+      const diagPromise = new Promise((resolve17) => {
+        this.diagnosticsResolve = resolve17;
         this.diagnostics = [];
         this.diagnosticsTimer = setTimeout(() => {
           if (this.diagnosticsResolve) {
@@ -14852,14 +15179,14 @@ class LspClient {
   async startServer(config, baseDir) {
     if (config.autoInstall === false) {
       try {
-        execSync4(`where ${config.command}`, { stdio: "pipe", timeout: 3000 });
+        execSync2(`where ${config.command}`, { stdio: "pipe", timeout: 3000 });
       } catch {
         throw new Error(`${config.command} not found in PATH`);
       }
     }
-    return new Promise((resolve16, reject) => {
+    return new Promise((resolve17, reject) => {
       const args = config.args ?? [];
-      const proc = spawn4(config.command, args, {
+      const proc = spawn5(config.command, args, {
         stdio: ["pipe", "pipe", "pipe"],
         env: { ...process.env, ...config.env },
         cwd: baseDir
@@ -14870,7 +15197,7 @@ class LspClient {
       });
       proc.stderr.on("data", () => {});
       proc.once("spawn", () => {
-        resolve16();
+        resolve17();
       });
       this.process = proc;
       setTimeout(() => {
@@ -14942,9 +15269,9 @@ class LspClient {
     }
   }
   sendRequest(method, params, timeout) {
-    return new Promise((resolve16, reject) => {
+    return new Promise((resolve17, reject) => {
       const id = ++this.requestId;
-      this.pending.set(id, { resolve: resolve16, reject });
+      this.pending.set(id, { resolve: resolve17, reject });
       const message = JSON.stringify({ jsonrpc: "2.0", id, method, params });
       this.write(message);
       setTimeout(() => {
@@ -15022,8 +15349,8 @@ var DEFAULT_TIMEOUT = 15000;
 var init_client2 = () => {};
 
 // src/modules/lsp/module.ts
-import { existsSync as existsSync31 } from "fs";
-import { resolve as resolve16 } from "path";
+import { existsSync as existsSync32 } from "fs";
+import { resolve as resolve17 } from "path";
 
 class LspModule {
   name = "lsp";
@@ -15047,8 +15374,8 @@ class LspModule {
         const filePath = String(call.arguments.path ?? "");
         if (!filePath)
           return;
-        const fullPath = resolve16(_ctx.baseDir, filePath);
-        if (!existsSync31(fullPath))
+        const fullPath = resolve17(_ctx.baseDir, filePath);
+        if (!existsSync32(fullPath))
           return;
         const serverConfig = getServerForFile(fullPath, self.config);
         if (!serverConfig)
@@ -15106,7 +15433,7 @@ var init_lsp = __esm(() => {
 });
 
 // src/modules/indexer/walker.ts
-import { readdirSync as readdirSync9, readFileSync as readFileSync20, statSync as statSync6, existsSync as existsSync32, watch } from "fs";
+import { readdirSync as readdirSync9, readFileSync as readFileSync20, statSync as statSync6, existsSync as existsSync33, watch } from "fs";
 import { join as join23, relative, extname as extname5 } from "path";
 
 class Indexer {
@@ -15134,7 +15461,7 @@ class Indexer {
     let totalSize = 0;
     let count = 0;
     const walkDir = (dir) => {
-      if (!existsSync32(dir))
+      if (!existsSync33(dir))
         return;
       let entries;
       try {
@@ -15208,7 +15535,7 @@ var init_walker = __esm(() => {
 });
 
 // src/modules/indexer/cache.ts
-import { readFileSync as readFileSync21, writeFileSync as writeFileSync13, existsSync as existsSync33, mkdirSync as mkdirSync14, rmSync as rmSync2 } from "fs";
+import { readFileSync as readFileSync21, writeFileSync as writeFileSync13, existsSync as existsSync34, mkdirSync as mkdirSync14, rmSync as rmSync2 } from "fs";
 import { join as join24 } from "path";
 
 class IndexCache {
@@ -15220,7 +15547,7 @@ class IndexCache {
   load() {
     if (this.cache)
       return this.cache;
-    if (!existsSync33(this.cachePath))
+    if (!existsSync34(this.cachePath))
       return null;
     try {
       this.cache = JSON.parse(readFileSync21(this.cachePath, "utf-8"));
@@ -15232,13 +15559,13 @@ class IndexCache {
   save(result) {
     this.cache = result;
     const dir = join24(this.cachePath, "..");
-    if (!existsSync33(dir))
+    if (!existsSync34(dir))
       mkdirSync14(dir, { recursive: true });
     writeFileSync13(this.cachePath, JSON.stringify(result), "utf-8");
   }
   invalidate() {
     this.cache = null;
-    if (existsSync33(this.cachePath)) {
+    if (existsSync34(this.cachePath)) {
       try {
         rmSync2(this.cachePath);
       } catch {}
@@ -15649,8 +15976,8 @@ __export(exports_bootstrap, {
   bootstrap: () => bootstrap
 });
 import { homedir as homedir11 } from "os";
-import { join as join26, resolve as resolve17 } from "path";
-import { existsSync as existsSync34, readFileSync as readFileSync22, writeFileSync as writeFileSync14 } from "fs";
+import { join as join26, resolve as resolve18 } from "path";
+import { existsSync as existsSync35, readFileSync as readFileSync22, writeFileSync as writeFileSync14 } from "fs";
 function buildSystemInfo(config, baseDir, profileCompressed) {
   const now = new Date().toISOString().replace("T", " ").slice(0, 19);
   const isWin = profileCompressed.toLowerCase().includes("win32");
@@ -15669,9 +15996,9 @@ function buildSystemInfo(config, baseDir, profileCompressed) {
     `- DRY: Do not duplicate code, logic, or configuration — reuse existing utilities and patterns.`
   ];
   if (isWin) {
-    lines.push(``, `Windows environment — use Windows-compatible commands:`, `- Use "dir" instead of "ls". Use "dir /b" for bare listing.`, `- Use "type" or "Get-Content" instead of "cat".`, `- Use "cd" instead of "pwd". Use "echo %cd%" to print working directory.`, `- Use "copy" instead of "cp", "move" instead of "mv", "del" instead of "rm".`, `- Do not use "mkdir -p" — Windows mkdir creates intermediate dirs by default. Use the create_dir tool instead.`, `- Do not use "head" or "tail" — they are Unix commands. Use "Select-Object -First N" or "Get-Content ... | Select-Object -First N" instead (PowerShell).`, `- Use forward slashes (/) or escaped backslashes (\\\\) in file paths.`, `- Your working directory is: ${baseDir}`);
+    lines.push(``, `Windows environment — use Windows-compatible commands (shell is cmd.exe, not PowerShell):`, `- Use "dir" instead of "ls". Use "dir /b" for bare listing. For file listings prefer the list_dir tool.`, `- Use "type" instead of "cat". For reading files prefer the read_file tool.`, `- Use "cd" instead of "pwd". Use "echo %cd%" to print working directory.`, `- Use "copy" instead of "cp", "move" instead of "mv", "del" instead of "rm".`, `- Do not use "mkdir -p" — Windows mkdir creates intermediate dirs by default. Use the create_dir tool instead.`, `- Do not use "head" or "tail" — they are Unix commands. Use the read_file tool with offset/limit instead.`, `- Do not use "grep" — use the grep tool instead. Do not use PowerShell cmdlets (Get-Content, Select-Object, cat) in bash — the shell is cmd.exe.`, `- Use forward slashes (/) or escaped backslashes (\\\\) in file paths.`, `- Your working directory is: ${baseDir}`);
   }
-  lines.push(``, `Bash tool rules:`, `- Use the "workdir" parameter to run commands in a specific directory. Prefer workdir over "cd dir && cmd" chaining.`, `- Run one command per tool call. Split multi-step shell operations into separate bash calls.`, `- Background processes (dev servers, watchers, long-running npm install): use the "background: true" parameter or the tool will auto-detect and background them. Check output with process_log.`);
+  lines.push(``, `Bash tool rules:`, `- Use the "workdir" parameter to run commands in a specific directory. Prefer workdir over "cd dir && cmd" chaining.`, `- Run one command per tool call. Split multi-step shell operations into separate bash calls.`, `- Dev servers, watchers and other long-running processes: pass "background: true" to get a process id immediately. Without it, any command still running after a few seconds is automatically moved to the background — check output with process_log.`);
   lines.push(``, `=== DEVELOPMENT RULES — follow these strictly ===`, ``, `1. DEPENDENCIES FIRST: Before writing any source code, ALWAYS install project dependencies (e.g., "npm install", "pip install -r requirements.txt", "cargo build", "go mod tidy"). Verify the package manager's lock file or dependency directory exists. Never write code that imports/uses packages that aren't installed yet.`, `2. TOOLKIT/FWK FIRST: If the task specifies a framework or UI library, initialize and configure it BEFORE writing application code. Run its project init command first, then add components/modules. Never write your own version of what the framework already provides.`, `3. ONE STEP AT A TIME: Follow the plan sequentially. Complete step N before starting step N+1. When a step is done: verify the deliverables exist and have real content (not empty), then call "plan update step=N status=done". Do not redo completed work.`, `4. VERIFY YOUR WORK: After creating/modifying files, verify they exist on disk. After installing dependencies, verify the package manager completed successfully. After any command, check its output for errors. Don't assume operations succeeded.`, `5. NO PREMATURE WORK: Do not create files for future steps. Do not add imports/references to packages or modules that haven't been installed yet. Do not reference files or components that don't exist yet. Build incrementally — one layer at a time.`, `6. WHEN STUCK: If a command fails 2+ times, STOP and try a different approach. Write files directly instead of using commands. Ask the user for help. Never repeat the same failing command more than twice.`, ``, `=== PLAN QUALITY RULES — your plan MUST follow these ===`, ``, `- Each step must describe CONCRETE deliverables: exact filenames with paths, exact packages to install, exact CLI commands to run. Avoid vague steps — be specific.`, `- A step like "Настройка проекта" or "Setup the project" is too vague — describe what exactly needs to be configured or set up.`, `- A step like "Создать src/components/Header.tsx с навигацией и логотипом, добавить в src/App.tsx импорт <Header />" is GOOD.`, `- Include file extensions (.tsx, .css, .json) and directory paths. Every step must mention at least one file or command.`, `- The plan must cover EVERYTHING needed: init → deps → framework setup → code → verification.`, `- Number of steps: 5-8 for a typical task. Too few means you're being vague. Too many means you're over-splitting.`);
   if (config.autoPlan) {
     lines.push(``, `Plan rule (MANDATORY): For ANY task that requires creating files, installing packages, or multiple actions — you MUST create a plan using the "plan" tool BEFORE starting work. Each step must describe a concrete deliverable (specific files to create, packages to install, commands to run). Do not combine unrelated work into one step.`);
@@ -15728,7 +16055,7 @@ async function bootstrap(configDir, projectDir, noAgentsMd, exitOnComplete) {
     retry: config.retry,
     rateLimits: config.security?.rateLimits
   });
-  const baseDir = projectDir ? resolve17(projectDir) : process.cwd();
+  const baseDir = projectDir ? resolve18(projectDir) : process.cwd();
   const projectMapCacheDir = join26(baseDir, ".mma");
   const indexerModule = new IndexerModule({
     baseDir,
@@ -15757,7 +16084,7 @@ async function bootstrap(configDir, projectDir, noAgentsMd, exitOnComplete) {
     estimatedTokens: 250
   };
   const agentsMdGlobal = join26(dir, "AGENTS.md");
-  if (!existsSync34(agentsMdGlobal)) {
+  if (!existsSync35(agentsMdGlobal)) {
     writeFileSync14(agentsMdGlobal, "", "utf-8");
   }
   const sessionDir = join26(dir, "sessions");
@@ -15797,12 +16124,23 @@ async function bootstrap(configDir, projectDir, noAgentsMd, exitOnComplete) {
           timestamp: new Date().toISOString()
         });
       }
+    },
+    sessionLog: {
+      plan: (event, detail, iteration) => {
+        sessionManager.appendLog({
+          ts: new Date().toISOString(),
+          type: "plan",
+          tool: event,
+          content: detail,
+          ...iteration !== undefined ? { iteration } : {}
+        });
+      }
     }
   };
   const toolExecutor = new ToolExecutor(toolRegistry, toolCtx, pluginManager);
   toolCtx.llmProvider = llmProvider;
   toolCtx.toolExecutor = toolExecutor;
-  const hallucinationDetector = new HallucinationDetector;
+  const hallucinationDetector = new HallucinationDetector(baseDir, llmProvider);
   const moduleRegistry = new ModuleRegistry;
   const execModule = new ExecutionModule(baseDir, config.stuckThreshold);
   execModule.restorePlan();
@@ -15888,7 +16226,7 @@ async function bootstrap(configDir, projectDir, noAgentsMd, exitOnComplete) {
       join26(dir, "AGENTS.md")
     ];
     for (const p of agentsMdCandidates) {
-      if (existsSync34(p)) {
+      if (existsSync35(p)) {
         const content = readFileSync22(p, "utf-8").trim();
         if (content) {
           agentsMdBlocks.push({
@@ -16506,10 +16844,10 @@ function menuList(items) {
     console.log(l);
 }
 function ask(rl, question, defaultValue) {
-  return new Promise((resolve18) => {
+  return new Promise((resolve19) => {
     const prompt = defaultValue ? `${question} [${defaultValue}]: ` : `${question}: `;
     rl.question(prompt, (answer) => {
-      resolve18(answer.trim() || defaultValue || "");
+      resolve19(answer.trim() || defaultValue || "");
     });
   });
 }
@@ -16728,12 +17066,12 @@ __export(exports_manifest, {
   getCertMark: () => getCertMark,
   MANIFEST_PATH: () => MANIFEST_PATH
 });
-import { existsSync as existsSync35, readFileSync as readFileSync23, mkdirSync as mkdirSync15, writeFileSync as writeFileSync15 } from "fs";
+import { existsSync as existsSync36, readFileSync as readFileSync23, mkdirSync as mkdirSync15, writeFileSync as writeFileSync15 } from "fs";
 import { homedir as homedir13 } from "os";
 import { join as join28 } from "path";
 function readManifest(path = MANIFEST_PATH) {
   try {
-    if (existsSync35(path)) {
+    if (existsSync36(path)) {
       const raw = JSON.parse(readFileSync23(path, "utf-8"));
       return { version: 1, certifications: raw.certifications ?? [] };
     }
@@ -23899,7 +24237,7 @@ var init_scenarios = __esm(() => {
 });
 
 // src/modules/certification/loader.ts
-import { existsSync as existsSync36, readdirSync as readdirSync10, readFileSync as readFileSync24 } from "fs";
+import { existsSync as existsSync37, readdirSync as readdirSync10, readFileSync as readFileSync24 } from "fs";
 import { join as join29 } from "path";
 function validateScenario(s) {
   const errors2 = [];
@@ -23949,7 +24287,7 @@ function loadScenarios(userDir) {
     else
       scenarios.push(s);
   }
-  if (userDir && existsSync36(userDir)) {
+  if (userDir && existsSync37(userDir)) {
     for (const file of readdirSync10(userDir)) {
       if (!file.endsWith(".yaml") && !file.endsWith(".yml"))
         continue;
@@ -24007,7 +24345,7 @@ var init_loader3 = __esm(() => {
 });
 
 // src/modules/certification/fact-checker.ts
-import { existsSync as existsSync37, readFileSync as readFileSync25, statSync as statSync7 } from "fs";
+import { existsSync as existsSync38, readFileSync as readFileSync25, statSync as statSync7 } from "fs";
 import { join as join30 } from "path";
 function checkSandbox(sandboxDir, checks, exitCode, output) {
   const failures = [];
@@ -24027,7 +24365,7 @@ function runCheck(sandboxDir, check, exitCode, output) {
     case "fileExists":
       return isFile(join30(sandboxDir, check.path));
     case "fileNotExists":
-      return !existsSync37(join30(sandboxDir, check.path));
+      return !existsSync38(join30(sandboxDir, check.path));
     case "dirExists":
       return isDir(join30(sandboxDir, check.path));
     case "fileContent": {
@@ -24053,14 +24391,14 @@ function runCheck(sandboxDir, check, exitCode, output) {
 }
 function isFile(p) {
   try {
-    return existsSync37(p) && statSync7(p).isFile();
+    return existsSync38(p) && statSync7(p).isFile();
   } catch {
     return false;
   }
 }
 function isDir(p) {
   try {
-    return existsSync37(p) && statSync7(p).isDirectory();
+    return existsSync38(p) && statSync7(p).isDirectory();
   } catch {
     return false;
   }
@@ -24090,10 +24428,10 @@ function describe(check) {
 var init_fact_checker = () => {};
 
 // src/modules/certification/runner.ts
-import { spawn as spawn5 } from "child_process";
-import { existsSync as existsSync38, mkdirSync as mkdirSync16, rmSync as rmSync3, cpSync as cpSync2 } from "fs";
-import { platform as platform5 } from "os";
-import { join as join31, resolve as resolve18, dirname as dirname9 } from "path";
+import { spawn as spawn6 } from "child_process";
+import { existsSync as existsSync39, mkdirSync as mkdirSync16, rmSync as rmSync3, cpSync as cpSync2 } from "fs";
+import { platform as platform4 } from "os";
+import { join as join31, resolve as resolve19, dirname as dirname9 } from "path";
 async function runScenario(scenario, opts) {
   if (scenario.mode === "skip") {
     return {
@@ -24174,7 +24512,7 @@ function prepareSandbox(sandbox, scenario, mmaRoot) {
   mkdirSync16(sandbox, { recursive: true });
   for (const f of scenario.fixtures ?? []) {
     const src = join31(mmaRoot, f.source);
-    if (!existsSync38(src)) {
+    if (!existsSync39(src)) {
       throw new Error(`fixture missing: ${f.source}`);
     }
     const dest = join31(sandbox, f.dest);
@@ -24184,27 +24522,27 @@ function prepareSandbox(sandbox, scenario, mmaRoot) {
 }
 function resolveMmaEntry(mmaRoot) {
   const dev = join31(mmaRoot, "src", "cli", "main.ts");
-  if (existsSync38(dev))
+  if (existsSync39(dev))
     return dev;
   return join31(mmaRoot, "dist", "main.js");
 }
 function findMmaRoot(fromDir) {
   const candidates = [
-    resolve18(fromDir, "..", "..", ".."),
-    resolve18(fromDir, "..")
+    resolve19(fromDir, "..", "..", ".."),
+    resolve19(fromDir, "..")
   ];
   for (const c of candidates) {
-    if (existsSync38(join31(c, "package.json")))
+    if (existsSync39(join31(c, "package.json")))
       return c;
   }
   return process.cwd();
 }
-function killTree3(child) {
+function killTree2(child) {
   const pid = child.pid;
   if (!pid)
     return;
-  if (platform5() === "win32") {
-    spawn5("taskkill", ["/pid", String(pid), "/T", "/F"], {
+  if (platform4() === "win32") {
+    spawn6("taskkill", ["/pid", String(pid), "/T", "/F"], {
       windowsHide: true,
       stdio: "ignore"
     });
@@ -24219,7 +24557,7 @@ function killTree3(child) {
   }
 }
 var defaultRunner = (env2, cwd, args, timeoutMs) => new Promise((resolvePromise) => {
-  const child = spawn5(process.execPath, args, {
+  const child = spawn6(process.execPath, args, {
     cwd,
     env: env2,
     windowsHide: true,
@@ -24236,7 +24574,7 @@ var defaultRunner = (env2, cwd, args, timeoutMs) => new Promise((resolvePromise)
   });
   const timer = setTimeout(() => {
     timedOut = true;
-    killTree3(child);
+    killTree2(child);
   }, timeoutMs);
   child.on("close", (code) => {
     clearTimeout(timer);
@@ -24264,13 +24602,13 @@ import { rmSync as rmSync4 } from "fs";
 import { homedir as homedir14 } from "os";
 import { join as join32, dirname as dirname10 } from "path";
 import { fileURLToPath } from "url";
-import { existsSync as existsSync39, readFileSync as readFileSync26 } from "fs";
+import { existsSync as existsSync40, readFileSync as readFileSync26 } from "fs";
 function readVersion() {
   const candidates = [
     join32(MMA_ROOT, "package.json")
   ];
   for (const p of candidates) {
-    if (existsSync39(p)) {
+    if (existsSync40(p)) {
       const raw = JSON.parse(readFileSync26(p, "utf-8"));
       if (raw.version)
         return raw.version;
@@ -24425,7 +24763,7 @@ __export(exports_repl_commands, {
 });
 import { join as join34, dirname as dirname12 } from "path";
 import { homedir as homedir16 } from "os";
-import { existsSync as existsSync41, readFileSync as readFileSync28 } from "fs";
+import { existsSync as existsSync42, readFileSync as readFileSync28 } from "fs";
 import { fileURLToPath as fileURLToPath3 } from "url";
 function readVersion3() {
   const here = dirname12(fileURLToPath3(import.meta.url));
@@ -24434,7 +24772,7 @@ function readVersion3() {
     join34(here, "..", "package.json")
   ];
   for (const p of candidates) {
-    if (existsSync41(p)) {
+    if (existsSync42(p)) {
       const raw = JSON.parse(readFileSync28(p, "utf8"));
       if (raw.version)
         return raw.version;
@@ -24498,8 +24836,8 @@ function registerMmaCommands(ctx) {
       }
       try {
         const { loadFileAsDataUrl: loadFileAsDataUrl2, loadUrlAsDataUrl: loadUrlAsDataUrl2, readClipboardImage: readClipboardImage2 } = await Promise.resolve().then(() => (init_image_utils(), exports_image_utils));
-        const { existsSync: existsSync42 } = await import("fs");
-        const { resolve: resolve19 } = await import("path");
+        const { existsSync: existsSync43 } = await import("fs");
+        const { resolve: resolve20 } = await import("path");
         let dataUrl;
         let label;
         if (source.toLowerCase() === "clipboard") {
@@ -24517,8 +24855,8 @@ function registerMmaCommands(ctx) {
           dataUrl = result.dataUrl;
           label = source;
         } else {
-          const absPath = resolve19(process.cwd(), source);
-          if (!existsSync42(absPath)) {
+          const absPath = resolve20(process.cwd(), source);
+          if (!existsSync43(absPath)) {
             console.log(pc.red(t("image.not_found", { path: source })));
             return;
           }
@@ -25055,7 +25393,7 @@ init_setup();
 init_i18n();
 import { join as join33, dirname as dirname11 } from "path";
 import { homedir as homedir15 } from "os";
-import { existsSync as existsSync40, readFileSync as readFileSync27 } from "fs";
+import { existsSync as existsSync41, readFileSync as readFileSync27 } from "fs";
 
 // src/cli/security-commands.ts
 init_bootstrap();
@@ -25683,7 +26021,7 @@ function readVersion2() {
     join33(here, "..", "package.json")
   ];
   for (const p of candidates) {
-    if (existsSync40(p)) {
+    if (existsSync41(p)) {
       const raw = JSON.parse(readFileSync27(p, "utf8"));
       if (raw.version)
         return raw.version;
@@ -25910,7 +26248,7 @@ init_bootstrap();
 // src/cli/repl.ts
 init_colors();
 import * as readline2 from "readline";
-import { existsSync as existsSync42, readFileSync as readFileSync29, writeFileSync as writeFileSync16 } from "fs";
+import { existsSync as existsSync43, readFileSync as readFileSync29, writeFileSync as writeFileSync16 } from "fs";
 import { join as join35, dirname as dirname13 } from "path";
 import { homedir as homedir17 } from "os";
 import { fileURLToPath as fileURLToPath4 } from "url";
@@ -26377,7 +26715,7 @@ function readVersion4() {
     join35(here, "..", "package.json")
   ];
   for (const p of candidates) {
-    if (existsSync42(p)) {
+    if (existsSync43(p)) {
       const raw = JSON.parse(readFileSync29(p, "utf8"));
       if (raw.version)
         return raw.version;
@@ -26453,7 +26791,7 @@ class Repl {
     this.setupListeners();
   }
   loadHistory() {
-    if (existsSync42(this.historyPath)) {
+    if (existsSync43(this.historyPath)) {
       try {
         const raw = readFileSync29(this.historyPath, "utf-8");
         this.history = raw.split(`
@@ -26767,7 +27105,7 @@ ${t("image.attached", { source: "clipboard", size: `${sizeKb} KB` })}`));
         join35(this.baseDir, ".mma", "AGENTS.md"),
         join35(this.configDir, "AGENTS.md")
       ];
-      const foundAgents = agentsMdCandidates.filter((p) => existsSync42(p));
+      const foundAgents = agentsMdCandidates.filter((p) => existsSync43(p));
       if (foundAgents.length > 0) {
         for (const p of foundAgents) {
           row(t("repl.agents_label"), pc.dim(p));
@@ -26804,7 +27142,7 @@ init_setup();
 init_config2();
 init_i18n();
 init_colors();
-import { existsSync as existsSync43 } from "fs";
+import { existsSync as existsSync44 } from "fs";
 import { join as join36 } from "path";
 import { homedir as homedir18 } from "os";
 async function main() {
@@ -26870,7 +27208,7 @@ async function main() {
     agent.shutdown();
   } else {
     const configPath = join36(homedir18(), ".mma", "config.json");
-    if (!existsSync43(configPath)) {
+    if (!existsSync44(configPath)) {
       console.log(pc.yellow(`
   ` + t("cli.first_run") + `
 `));