micro-models-agent 0.28.17 → 0.29.1

package/dist/main.js

@@ -2256,6 +2256,13 @@ var init_defaults = __esm(() => {
     skills: {
       budget: 0.15
     },
+    subagent: {
+      resultMode: "text",
+      maxSummaryChars: 2000,
+      artifactsDir: ".mma/artifacts",
+      stableSystemPrompt: true,
+      maxParallelChunkQueries: 4
+    },
     lsp: DEFAULT_LSP_CONFIG
   };
 });
@@ -2367,6 +2374,10 @@ var init_en = __esm(() => {
     "tool.friendly.mcp_call": "MCP call",
     "tool.truncated": "[Truncated: {tokens} tokens removed]",
     "tool.subagent_queued": "Sub-agent task queued: {task}",
+    "tool.subagent_artifact": `Sub-agent completed. Full result saved to artifact: {path}
+Iterations: {iterations}
+Summary:
+{summary}`,
     "tool.pipeline_started": 'Pipeline "{name}" execution started. Pipeline engine is a stub — run dispatched.',
     "tool.mcp_call": "MCP call: {server}/{tool} with {args}",
     "tool.action_required": "Action is required.",
@@ -2387,6 +2398,8 @@ var init_en = __esm(() => {
     "tool.question.unanswered": "Unanswered",
     "tool.question.answered": "User has answered your questions: {formatted}. You can now continue with the user's answers in mind.",
     "tool.name_or_task": 'Provide either "name" or "task" parameter',
+    "tool.chunk_query_no_query": "chunk_query: a query string is required.",
+    "tool.chunk_query_no_input": "chunk_query: provide input_path or text.",
     "tool.invalid_params": "Invalid parameters",
     "tool.skill_budget": 'Skill "{name}" loaded ({tokens} tokens, {remaining} remaining in skills budget). Skill content is now in system prompt — no need to reload after context compaction.',
     "tool.skill_available_hint": "Available skills",
@@ -2926,6 +2939,10 @@ var init_ru = __esm(() => {
     "tool.friendly.mcp_call": "MCP вызов",
     "tool.truncated": "[Обрезано: удалено {tokens} токенов]",
     "tool.subagent_queued": "Задача подагенту добавлена: {task}",
+    "tool.subagent_artifact": `Суб-агент завершён. Полный результат сохранён в артефакт: {path}
+Итераций: {iterations}
+Сводка:
+{summary}`,
     "tool.pipeline_started": 'Пайплайн "{name}" запущен. Движок пайплайнов — заглушка, задача отправлена.',
     "tool.mcp_call": "MCP вызов: {server}/{tool} с {args}",
     "tool.action_required": "Требуется действие.",
@@ -2946,6 +2963,8 @@ var init_ru = __esm(() => {
     "tool.question.unanswered": "Без ответа",
     "tool.question.answered": "Пользователь ответил на ваши вопросы: {formatted}. Теперь продолжайте с учётом ответов.",
     "tool.name_or_task": 'Укажите параметр "name" или "task"',
+    "tool.chunk_query_no_query": "chunk_query: требуется строка запроса.",
+    "tool.chunk_query_no_input": "chunk_query: укажите input_path или text.",
     "tool.invalid_params": "Неверные параметры",
     "tool.skill_budget": 'Скилл "{name}" загружен ({tokens} токенов, осталось {remaining} в бюджете скиллов). Контент скилла теперь в системном промпте — перезагрузка после компрессии не нужна.',
     "tool.skill_available_hint": "Доступные скиллы",
@@ -4832,12 +4851,12 @@ class OpenAICompatProvider {
     };
     this.rateLimiter = createRateLimiter(config.rateLimits);
   }
-  async* chat(messages, tools, signal) {
+  async* chat(messages, tools, signal, options) {
     if (!this.rateLimiter.canMakeRequest()) {
       throw new Error(`Rate limit exceeded: ${this.rateLimiter.getConfig().maxRequestsPerMinute} requests per minute`);
     }
     this.rateLimiter.recordRequest();
-    const streamResult = this.doStream(messages, tools, signal);
+    const streamResult = this.doStream(messages, tools, signal, options);
     let hasToolCall = false;
     let hasText = false;
     let reasoningAcc = "";
@@ -4852,19 +4871,22 @@ class OpenAICompatProvider {
       yield chunk;
     }
     if (!hasToolCall && !hasText) {
-      const fallback = await this.doNonStreaming(messages, tools, signal);
+      const fallback = await this.doNonStreaming(messages, tools, signal, options);
       for (const chunk of fallback) {
         yield chunk;
       }
     }
   }
-  async* doStream(messages, tools, signal) {
+  async* doStream(messages, tools, signal, options) {
     const body = {
       model: this.model,
       messages,
       stream: true,
-      max_tokens: this.config.maxCompletionTokens ?? 4096
+      max_tokens: options?.maxTokens ?? this.config.maxCompletionTokens ?? 4096
     };
+    if (options?.reasoningEffort) {
+      body.reasoning_effort = options.reasoningEffort;
+    }
     if (tools && tools.length > 0) {
       body.tools = tools.map((t2) => ({
         type: "function",
@@ -5000,13 +5022,16 @@ class OpenAICompatProvider {
       reader.releaseLock();
     }
   }
-  async doNonStreaming(messages, tools, signal) {
+  async doNonStreaming(messages, tools, signal, options) {
     const body = {
       model: this.model,
       messages,
       stream: false,
-      max_tokens: this.config.maxCompletionTokens ?? 4096
+      max_tokens: options?.maxTokens ?? this.config.maxCompletionTokens ?? 4096
     };
+    if (options?.reasoningEffort) {
+      body.reasoning_effort = options.reasoningEffort;
+    }
     if (tools && tools.length > 0) {
       body.tools = tools.map((t2) => ({
         type: "function",
@@ -5354,14 +5379,15 @@ class ToolExecutor {
       if (tool.interactive) {
         result = await tool.handler(this.ctx, call.arguments);
       } else {
+        const timeoutMs = tool.timeoutMs ?? TOOL_EXECUTION_TIMEOUT_MS;
         const timeoutPromise = new Promise((_, reject) => {
           setTimeout(() => {
             killByCallId(call.id);
             reject(new Error(t("tool.timeout", {
               name: call.name,
-              seconds: TOOL_EXECUTION_TIMEOUT_MS / 1000
+              seconds: Math.round(timeoutMs / 1000)
             })));
-          }, TOOL_EXECUTION_TIMEOUT_MS);
+          }, timeoutMs);
         });
         const racePromises = [
           tool.handler(this.ctx, call.arguments),
@@ -7084,18 +7110,28 @@ function decodeLineToUtf8(buf) {
   }
   return buf.toString("latin1");
 }
+function sleepSync(ms) {
+  try {
+    Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
+  } catch {}
+}
+function taskkillPid(pid) {
+  try {
+    spawnSync("taskkill", ["/pid", String(pid), "/T", "/F"], {
+      windowsHide: true,
+      stdio: "ignore",
+      timeout: 5000
+    });
+  } catch {}
+}
 function killTree(child) {
   const pid = child.pid;
   if (!pid)
     return;
   if (platform() === "win32") {
-    try {
-      spawnSync("taskkill", ["/pid", String(pid), "/T", "/F"], {
-        windowsHide: true,
-        stdio: "ignore",
-        timeout: 3000
-      });
-    } catch {}
+    taskkillPid(pid);
+    sleepSync(150);
+    taskkillPid(pid);
     return;
   }
   try {
@@ -9424,6 +9460,59 @@ var init_stuck_detector = __esm(() => {
   init_i18n();
 });
 
+// src/modules/artifacts/store.ts
+import { existsSync as existsSync18, mkdirSync as mkdirSync11, readFileSync as readFileSync9, writeFileSync as writeFileSync7 } from "node:fs";
+import { resolve as resolve10, relative, isAbsolute } from "node:path";
+
+class ArtifactStore {
+  root;
+  constructor(opts) {
+    const artifactsDir = opts.artifactsDir || ".mma/artifacts";
+    this.root = resolve10(opts.baseDir, artifactsDir, opts.sessionId);
+  }
+  static sanitizeName(name) {
+    const stripped = name.replace(/^(\.\.?[\\/])+/g, "").replace(/^\.{1,2}$/, "");
+    const cleaned = stripped.replace(/[^a-zA-Z0-9._-]/g, "_").replace(/_{2,}/g, "_").replace(/^_+|_+$/g, "");
+    if (cleaned === "" || cleaned === "." || cleaned === "..") {
+      return "artifact";
+    }
+    return cleaned;
+  }
+  static isInside(root, candidate) {
+    const rel = relative(root, candidate);
+    if (rel === "")
+      return true;
+    return !rel.startsWith("..") && !isAbsolute(rel);
+  }
+  save(name, content, ext = "md") {
+    const safe = ArtifactStore.sanitizeName(name);
+    const dir = resolve10(this.root);
+    mkdirSync11(dir, { recursive: true });
+    const abs = resolve10(dir, `${safe}.${ext}`);
+    if (!ArtifactStore.isInside(dir, abs)) {
+      throw new Error(`Artifact path escapes root: ${abs}`);
+    }
+    writeFileSync7(abs, content, "utf8");
+    return abs;
+  }
+  read(path) {
+    const abs = resolve10(this.root, path);
+    if (!ArtifactStore.isInside(this.root, abs))
+      return null;
+    if (!existsSync18(abs))
+      return null;
+    return readFileSync9(abs, "utf8");
+  }
+  summary(content, maxChars) {
+    if (content.length <= maxChars)
+      return content;
+    const head = content.slice(0, maxChars).trimEnd();
+    return `${head}
+…[truncated: ${content.length - maxChars} chars]`;
+  }
+}
+var init_store = () => {};
+
 // src/modules/execution/moe-executor.ts
 function isTransientError(error) {
   return TRANSIENT_ERROR_PATTERNS.some((p) => error.includes(p));
@@ -9515,14 +9604,38 @@ ${(subtask.success_criteria || []).map((c) => `- ${c}`).join(`
         read_only_files: readOnlyFiles,
         tool_tags: expertConfig.tool_tags
       };
+      if (deps.config.subagent?.resultMode === "file") {
+        subagentArgs.result_mode = "file";
+        subagentArgs.artifact_name = subtask.id;
+      }
       const result = await subagentTool.handler({
         config: deps.config,
         baseDir: deps.baseDir,
         logger: deps.logger,
         llmProvider: deps.llmProvider,
-        toolExecutor: deps.toolExecutor
+        toolExecutor: deps.toolExecutor,
+        sessionId: "moe"
       }, subagentArgs);
       if (result.success) {
+        if (deps.config.subagent?.resultMode === "file") {
+          const pathMatch = result.output.match(/saved to artifact: (.+)/);
+          const abs = pathMatch ? pathMatch[1].trim() : "";
+          if (abs) {
+            const store = new ArtifactStore({
+              baseDir: deps.baseDir,
+              sessionId: "moe"
+            });
+            const full = store.read(abs.split(/[\\/]/).pop() || "");
+            deps.logger.debug(`MoE subtask "${subtask.id}" attached artifact ${abs} (${full?.length ?? 0} chars) to Router`);
+            return {
+              subtaskId: subtask.id,
+              success: true,
+              summary: `Artifact: ${abs}`,
+              result: full ?? result.output,
+              durationMs: Date.now() - startTime
+            };
+          }
+        }
         return {
           subtaskId: subtask.id,
           success: true,
@@ -9682,6 +9795,7 @@ var TRANSIENT_ERROR_PATTERNS;
 var init_moe_executor = __esm(() => {
   init_stuck_detector();
   init_i18n();
+  init_store();
   TRANSIENT_ERROR_PATTERNS = [
     "timeout",
     "Timeout",
@@ -9701,8 +9815,8 @@ var init_moe_executor = __esm(() => {
 });
 
 // src/modules/execution/verifier.ts
-import { existsSync as existsSync18 } from "fs";
-import { resolve as resolve10, extname as extname2 } from "path";
+import { existsSync as existsSync19 } from "fs";
+import { resolve as resolve11, extname as extname2 } from "path";
 import { spawn as spawn2 } from "child_process";
 
 class StepVerifier {
@@ -9711,8 +9825,8 @@ class StepVerifier {
     this.baseDir = baseDir;
   }
   async checkFileExists(path) {
-    const resolved = resolve10(this.baseDir, path);
-    const exists = existsSync18(resolved);
+    const resolved = resolve11(this.baseDir, path);
+    const exists = existsSync19(resolved);
     return {
       passed: exists,
       message: exists ? t("verify.file_exists", { path }) : t("verify.file_not_found", { path })
@@ -9727,8 +9841,8 @@ class StepVerifier {
     }
   }
   async runTypeCheck() {
-    const tsconfigPath = resolve10(this.baseDir, "tsconfig.json");
-    if (!existsSync18(tsconfigPath)) {
+    const tsconfigPath = resolve11(this.baseDir, "tsconfig.json");
+    if (!existsSync19(tsconfigPath)) {
       return { passed: true, message: "No tsconfig.json found — skipping type check" };
     }
     try {
@@ -9740,8 +9854,8 @@ class StepVerifier {
     }
   }
   async runTests() {
-    const pkgPath = resolve10(this.baseDir, "package.json");
-    if (!existsSync18(pkgPath)) {
+    const pkgPath = resolve11(this.baseDir, "package.json");
+    if (!existsSync19(pkgPath)) {
       return { passed: true, message: "No package.json found — skipping tests" };
     }
     try {
@@ -9793,7 +9907,7 @@ class StepVerifier {
       const result = await this.checkFileExists(filePath);
       results.push(result);
       if (result.passed) {
-        const fullPath = resolve10(this.baseDir, filePath);
+        const fullPath = resolve11(this.baseDir, filePath);
         if (!await this.validateSyntax(fullPath)) {
           syntaxValid = false;
           results.push({ passed: false, message: t("verify.syntax_error", { path: filePath }) });
@@ -9834,7 +9948,7 @@ class StepVerifier {
     return true;
   }
   runAsync(command, cwd, timeoutMs) {
-    return new Promise((resolve11, reject) => {
+    return new Promise((resolve12, reject) => {
       const child = spawn2(command, {
         cwd,
         shell: true,
@@ -9860,7 +9974,7 @@ class StepVerifier {
       child.on("close", (code) => {
         clearTimeout(timer);
         if (code === 0) {
-          resolve11({ stdout, stderr });
+          resolve12({ stdout, stderr });
         } else {
           const err = new Error(`Command failed with exit code ${code}`);
           err.stdout = stdout;
@@ -9991,7 +10105,7 @@ var init_agent_moe = __esm(() => {
 });
 
 // src/modules/memory/search.ts
-import { readFileSync as readFileSync9, existsSync as existsSync19 } from "fs";
+import { readFileSync as readFileSync10, existsSync as existsSync20 } from "fs";
 import { join as join10 } from "path";
 
 class MemorySearch {
@@ -10004,9 +10118,9 @@ class MemorySearch {
     const lowerQuery = query.toLowerCase();
     for (const name of MEMORY_FILES) {
       const path = join10(this.memoryDir, `${name}.md`);
-      if (!existsSync19(path))
+      if (!existsSync20(path))
         continue;
-      const content = readFileSync9(path, "utf-8");
+      const content = readFileSync10(path, "utf-8");
       const lines = content.split(`
 `);
       for (const line of lines) {
@@ -10016,9 +10130,9 @@ class MemorySearch {
       }
     }
     const prefsPath = join10(this.memoryDir, "preferences.json");
-    if (existsSync19(prefsPath)) {
+    if (existsSync20(prefsPath)) {
       try {
-        const prefs = JSON.parse(readFileSync9(prefsPath, "utf-8"));
+        const prefs = JSON.parse(readFileSync10(prefsPath, "utf-8"));
         for (const [key, value] of Object.entries(prefs)) {
           const searchStr = `${key}=${value}`;
           if (searchStr.toLowerCase().includes(lowerQuery)) {
@@ -10036,7 +10150,7 @@ var init_search = __esm(() => {
 });
 
 // src/modules/memory/store.ts
-import { readFileSync as readFileSync10, writeFileSync as writeFileSync7, appendFileSync as appendFileSync5, existsSync as existsSync20, mkdirSync as mkdirSync11 } from "fs";
+import { readFileSync as readFileSync11, writeFileSync as writeFileSync8, appendFileSync as appendFileSync5, existsSync as existsSync21, mkdirSync as mkdirSync12 } from "fs";
 import { join as join11 } from "path";
 
 class MemoryStore {
@@ -10046,23 +10160,23 @@ class MemoryStore {
     this.ensureDir();
     for (const name of MEMORY_FILES2) {
       const path = join11(this.memoryDir, `${name}.md`);
-      if (!existsSync20(path)) {
-        writeFileSync7(path, `# ${name.charAt(0).toUpperCase() + name.slice(1)}
+      if (!existsSync21(path)) {
+        writeFileSync8(path, `# ${name.charAt(0).toUpperCase() + name.slice(1)}
 
 `, "utf-8");
       }
     }
   }
   ensureDir() {
-    if (!existsSync20(this.memoryDir)) {
-      mkdirSync11(this.memoryDir, { recursive: true });
+    if (!existsSync21(this.memoryDir)) {
+      mkdirSync12(this.memoryDir, { recursive: true });
     }
   }
   read(name) {
     const path = join11(this.memoryDir, `${name}.md`);
-    if (!existsSync20(path))
+    if (!existsSync21(path))
       return "";
-    return readFileSync10(path, "utf-8");
+    return readFileSync11(path, "utf-8");
   }
   append(name, entry) {
     const path = join11(this.memoryDir, `${name}.md`);
@@ -10080,10 +10194,10 @@ class MemoryStore {
   }
   getPreferences() {
     const path = this.prefsPath();
-    if (!existsSync20(path))
+    if (!existsSync21(path))
       return {};
     try {
-      return JSON.parse(readFileSync10(path, "utf-8"));
+      return JSON.parse(readFileSync11(path, "utf-8"));
     } catch {
       return {};
     }
@@ -10091,14 +10205,14 @@ class MemoryStore {
   setPreference(key, value) {
     const prefs = this.getPreferences();
     prefs[key] = value;
-    writeFileSync7(this.prefsPath(), JSON.stringify(prefs, null, 2), "utf-8");
+    writeFileSync8(this.prefsPath(), JSON.stringify(prefs, null, 2), "utf-8");
   }
   deletePreference(key) {
     const prefs = this.getPreferences();
     if (!(key in prefs))
       return false;
     delete prefs[key];
-    writeFileSync7(this.prefsPath(), JSON.stringify(prefs, null, 2), "utf-8");
+    writeFileSync8(this.prefsPath(), JSON.stringify(prefs, null, 2), "utf-8");
     return true;
   }
   appendRule(category, pattern, cause, solution) {
@@ -10109,7 +10223,7 @@ class MemoryStore {
   }
 }
 var MEMORY_FILES2;
-var init_store = __esm(() => {
+var init_store2 = __esm(() => {
   init_search();
   MEMORY_FILES2 = ["conventions", "decisions", "errors", "facts"];
 });
@@ -10784,7 +10898,7 @@ var init_agent = __esm(() => {
   init_processes();
   init_session_logger();
   init_agent_moe();
-  init_store();
+  init_store2();
   init_verifier();
 });
 
@@ -11244,8 +11358,8 @@ var init_js_identifiers = __esm(() => {
 });
 
 // src/modules/hallucination/factual.ts
-import { existsSync as existsSync21, readdirSync as readdirSync5 } from "fs";
-import { resolve as resolve11, isAbsolute, join as join13 } from "path";
+import { existsSync as existsSync22, readdirSync as readdirSync5 } from "fs";
+import { resolve as resolve12, isAbsolute as isAbsolute2, join as join13 } from "path";
 function looksLikeFilePath(s) {
   const lower = s.toLowerCase();
   if (TECH_NAMES.has(lower))
@@ -11290,15 +11404,15 @@ class FactualCheck {
     return { status: "pass" };
   }
   pathExists(fp) {
-    if (isAbsolute(fp))
-      return existsSync21(fp);
+    if (isAbsolute2(fp))
+      return existsSync22(fp);
     if (!fp.includes("/") && !fp.includes("\\")) {
       return this.bareNameExists(fp);
     }
-    return existsSync21(resolve11(this.baseDir, fp));
+    return existsSync22(resolve12(this.baseDir, fp));
   }
   bareNameExists(name) {
-    if (existsSync21(resolve11(this.baseDir, name)))
+    if (existsSync22(resolve12(this.baseDir, name)))
       return true;
     if (this.indexHas(name))
       return true;
@@ -11692,7 +11806,18 @@ class PluginManager {
 }
 
 // src/tools/subagent.ts
-var subagentTool;
+function buildSubagentSystemPrompt(context, stable) {
+  if (stable)
+    return SUBAGENT_SYSTEM_PROMPT_TEMPLATE;
+  return `You are a sub-agent working on a specific task. ${context ? `Context: ${context}` : ""}`;
+}
+var SUBAGENT_SYSTEM_PROMPT_TEMPLATE = `You are a sub-agent working on a specific task. You have your own context window and tool set.
+
+Workflow rules:
+- Prefer small, focused steps. Verify your own work (typecheck/tests) before finishing.
+- For large outputs, write the result to a file with write_file instead of reproducing it in your answer.
+- If the task is big and decomposable, delegate parts to the subagent tool instead of doing everything in one context.
+- When you finish, return a concise final answer; do not repeat file contents verbatim if you already wrote them to disk.`, subagentTool;
 var init_subagent = __esm(() => {
   init_i18n();
   init_agent();
@@ -11700,6 +11825,7 @@ var init_subagent = __esm(() => {
   init_detector();
   init_audit_log();
   init_session_isolation();
+  init_store();
   subagentTool = {
     name: "subagent",
     description: "Spawn an isolated sub-agent to work on a task independently. The sub-agent has its own context and executes autonomously. Use for parallel work or complex sub-tasks.",
@@ -11741,6 +11867,15 @@ var init_subagent = __esm(() => {
           type: "array",
           items: { type: "string" },
           description: "Tool tags to expose to the sub-agent"
+        },
+        result_mode: {
+          type: "string",
+          enum: ["text", "file"],
+          description: '"file": persist the full result to an artifact and return a path + summary (pass-by-reference). "text" (default): return the full text into context.'
+        },
+        artifact_name: {
+          type: "string",
+          description: "Artifact file name (sanitized). Default: subagent-<timestamp>."
         }
       },
       required: ["task"]
@@ -11788,10 +11923,10 @@ var init_subagent = __esm(() => {
         const parentScope = ctx.scope;
         ctx.toolExecutor.setScope(scope || { allowed_files: [], read_only_files: [] });
         const systemPrompt = {
-          content: `You are a sub-agent working on a specific task. ${context ? `Context: ${context}` : ""}`,
+          content: buildSubagentSystemPrompt(context, ctx.config.subagent?.stableSystemPrompt !== false),
           priority: "critical",
           essential: true,
-          estimatedTokens: 100
+          estimatedTokens: 150
         };
         const subDeps = {
           config: ctx.config,
@@ -11814,16 +11949,38 @@ Context: ${context}` : task;
         let scopeRestored = false;
         try {
           const result = await subAgent.run(fullTask);
-          return result.success ? {
+          if (!result.success) {
+            return {
+              success: false,
+              output: `Sub-agent failed: ${result.error}
+Partial output: ${result.text}`
+            };
+          }
+          const resultMode = args.result_mode || ctx.config.subagent?.resultMode || "text";
+          if (resultMode === "file") {
+            const store = new ArtifactStore({
+              baseDir: ctx.baseDir,
+              sessionId: ctx.sessionId || "default",
+              artifactsDir: ctx.config.subagent?.artifactsDir
+            });
+            const abs = store.save(args.artifact_name || `subagent-${Date.now()}`, result.text, "md");
+            const summary = store.summary(result.text, ctx.config.subagent?.maxSummaryChars ?? 2000);
+            ctx.logger.debug(`subagent result persisted to artifact ${abs} (${result.text.length} chars, ${result.iterationCount} iterations)`);
+            return {
+              success: true,
+              output: t("tool.subagent_artifact", {
+                path: abs,
+                iterations: String(result.iterationCount),
+                summary
+              })
+            };
+          }
+          return {
             success: true,
             output: `Sub-agent completed:
 ${result.text}
 
 Iterations: ${result.iterationCount}`
-          } : {
-            success: false,
-            output: `Sub-agent failed: ${result.error}
-Partial output: ${result.text}`
           };
         } finally {
           if (!scopeRestored) {
@@ -11837,6 +11994,229 @@ Partial output: ${result.text}`
   };
 });
 
+// src/tools/scope-check.ts
+import { resolve as resolve13, normalize as normalize4 } from "path";
+function isPathInScope2(baseDir, targetPath, scope) {
+  const baseResolved = resolve13(baseDir);
+  const targetResolved = resolve13(baseDir, normalize4(targetPath));
+  if (!targetResolved.startsWith(baseResolved)) {
+    return { allowed: false, reason: "Path is outside the base working directory" };
+  }
+  if (!scope)
+    return { allowed: true };
+  const isRead = scope.read_only_files.some((f) => targetResolved.startsWith(resolve13(baseDir, f)));
+  const isWrite = scope.allowed_files.some((f) => targetResolved.startsWith(resolve13(baseDir, f)));
+  if (isWrite)
+    return { allowed: true };
+  if (isRead)
+    return { allowed: true, reason: "Read-only file" };
+  return { allowed: false, reason: "Path is not within the allowed scope for this sub-agent" };
+}
+var init_scope_check = () => {};
+
+// src/modules/context/chunk-query.ts
+function splitTextIntoChunks(text, chunkChars) {
+  if (chunkChars <= 0)
+    throw new Error("chunkChars must be > 0");
+  if (text.length <= chunkChars)
+    return [text];
+  const lines = text.split(`
+`);
+  const chunks = [];
+  let current = [];
+  let size = 0;
+  for (const line of lines) {
+    if (current.length > 0 && size + line.length + 1 > chunkChars) {
+      chunks.push(current.join(`
+`));
+      current = [];
+      size = 0;
+    }
+    current.push(line);
+    size += line.length + 1;
+  }
+  if (current.length > 0)
+    chunks.push(current.join(`
+`));
+  return chunks;
+}
+async function chatText(provider, messages, maxTokens, reasoningEffort) {
+  let out = "";
+  for await (const chunk of provider.chat(messages, undefined, undefined, {
+    maxTokens,
+    reasoningEffort
+  })) {
+    if (chunk.type === "text" && chunk.content)
+      out += chunk.content;
+  }
+  return out;
+}
+async function runChunkQuery(provider, text, query, opts = {}) {
+  const chunkChars = opts.chunkChars ?? 12000;
+  const maxParallel = Math.max(1, opts.maxParallel ?? 4);
+  const maxChunkTokens = opts.maxChunkTokens ?? 1024;
+  const maxSynthesisTokens = opts.maxSynthesisTokens ?? 2048;
+  const reasoningEffort = opts.reasoningEffort ?? "none";
+  const chunks = splitTextIntoChunks(text, chunkChars);
+  const answers = new Array(chunks.length);
+  const chunkSystem = opts.querySystemPrompt ?? DEFAULT_CHUNK_SYSTEM_PROMPT;
+  const logger = opts.logger;
+  if (chunks.length === 1) {
+    logger?.debug(`runChunkQuery: single chunk (${text.length} chars), no chunking needed`);
+  } else {
+    logger?.debug(`runChunkQuery: ${chunks.length} chunks over ${text.length} chars (chunkChars=${chunkChars}, maxParallel=${maxParallel})`);
+  }
+  let cursor = 0;
+  let inFlight = 0;
+  let maxParallelObserved = 0;
+  const workers = Array.from({ length: Math.min(maxParallel, chunks.length) }, async () => {
+    while (cursor < chunks.length) {
+      const idx = cursor++;
+      inFlight++;
+      maxParallelObserved = Math.max(maxParallelObserved, inFlight);
+      try {
+        answers[idx] = await chatText(provider, [
+          { role: "system", content: chunkSystem },
+          { role: "user", content: `Query: ${query}
+
+Text:
+${chunks[idx]}` }
+        ], maxChunkTokens, reasoningEffort);
+      } finally {
+        inFlight--;
+      }
+    }
+  });
+  await Promise.all(workers);
+  let synthesis = "";
+  if (opts.synthesize !== false && chunks.length > 0) {
+    const joined = answers.map((a, i) => `--- Chunk ${i + 1}/${chunks.length} ---
+${a}`).join(`
+
+`);
+    logger?.debug(`runChunkQuery: synthesis pass over ${chunks.length} answers`);
+    synthesis = await chatText(provider, [
+      {
+        role: "system",
+        content: opts.synthesisSystemPrompt ?? DEFAULT_SYNTHESIS_SYSTEM_PROMPT
+      },
+      { role: "user", content: `Query: ${query}
+
+Chunk answers:
+${joined}` }
+    ], maxSynthesisTokens, reasoningEffort);
+  }
+  logger?.debug(`runChunkQuery: done, ${chunks.length} chunks, max parallel observed ${maxParallelObserved}, synthesis ${synthesis.length} chars`);
+  return {
+    chunks: chunks.length,
+    answers,
+    synthesis,
+    totalChars: text.length,
+    maxParallelObserved
+  };
+}
+var DEFAULT_CHUNK_SYSTEM_PROMPT = 'Answer the query using ONLY the provided text. Be concise. If the text does not contain the answer, say "NO_EVIDENCE".', DEFAULT_SYNTHESIS_SYSTEM_PROMPT = "You are given a query and per-chunk answers over a large text. Produce the final answer to the query, combining evidence from the chunks. If no chunk had evidence, say so.";
+
+// src/tools/chunk-query.ts
+import { readFileSync as readFileSync12 } from "node:fs";
+import { resolve as resolve14 } from "node:path";
+var chunkQueryTool;
+var init_chunk_query = __esm(() => {
+  init_i18n();
+  init_scope_check();
+  chunkQueryTool = {
+    name: "chunk_query",
+    description: "Answer a query over a large text (file or inline) by splitting it into chunks and querying the model per chunk in parallel, then optionally synthesizing a final answer. Use when the input is too large for the context window.",
+    tags: ["research", "code"],
+    timeoutMs: 300000,
+    parameters: {
+      type: "object",
+      properties: {
+        query: {
+          type: "string",
+          description: "The question to answer over the text."
+        },
+        input_path: {
+          type: "string",
+          description: "Path to the large text file (scope-checked). Preferred over text."
+        },
+        text: {
+          type: "string",
+          description: "Inline text. Use only when a file path is not available."
+        },
+        chunk_chars: {
+          type: "number",
+          description: "Approximate chunk size in chars (default 12000)."
+        },
+        max_parallel: {
+          type: "number",
+          description: "Max parallel chunk queries (default from config.subagent.maxParallelChunkQueries)."
+        },
+        max_chunk_tokens: {
+          type: "number",
+          description: "Cap on generated tokens per chunk call (default 1024)."
+        },
+        max_synthesis_tokens: {
+          type: "number",
+          description: "Cap on generated tokens for the synthesis call (default 2048)."
+        },
+        reasoning_effort: {
+          type: "string",
+          enum: ["none", "low", "medium", "high"],
+          description: 'Reasoning effort for chunk/synthesis calls (default "none"). "none" prevents long thinking chains from eating the token budget on reasoning models.'
+        },
+        synthesize: {
+          type: "boolean",
+          description: "Run a final synthesis call over chunk answers (default true)."
+        }
+      },
+      required: ["query"]
+    },
+    handler: async (ctx, args) => {
+      const query = String(args.query || "");
+      const inputPath = args.input_path ? String(args.input_path) : undefined;
+      const text = args.text ? String(args.text) : undefined;
+      if (!query)
+        return { success: false, output: t("tool.chunk_query_no_query") };
+      if (!inputPath && !text)
+        return { success: false, output: t("tool.chunk_query_no_input") };
+      let content = text || "";
+      if (inputPath) {
+        const check = isPathInScope2(ctx.baseDir, inputPath, ctx.scope);
+        if (!check.allowed) {
+          return { success: false, output: `[SCOPE] ${check.reason || "Path not allowed"}` };
+        }
+        try {
+          content = readFileSync12(resolve14(ctx.baseDir, inputPath), "utf8");
+        } catch (e) {
+          return { success: false, output: `Cannot read ${inputPath}: ${e.message}` };
+        }
+      }
+      if (!ctx.llmProvider) {
+        return { success: false, output: "chunk_query: missing llmProvider in context" };
+      }
+      const maxParallel = typeof args.max_parallel === "number" ? args.max_parallel : ctx.config.subagent?.maxParallelChunkQueries ?? 4;
+      const res = await runChunkQuery(ctx.llmProvider, content, query, {
+        chunkChars: typeof args.chunk_chars === "number" ? args.chunk_chars : undefined,
+        maxParallel,
+        synthesize: typeof args.synthesize === "boolean" ? args.synthesize : undefined,
+        maxChunkTokens: typeof args.max_chunk_tokens === "number" ? args.max_chunk_tokens : undefined,
+        maxSynthesisTokens: typeof args.max_synthesis_tokens === "number" ? args.max_synthesis_tokens : undefined,
+        reasoningEffort: ["none", "low", "medium", "high"].includes(args.reasoning_effort) ? args.reasoning_effort : undefined,
+        logger: ctx.logger
+      });
+      ctx.logger.debug(`chunk_query: ${res.chunks} chunk(s), ${res.totalChars} chars, max parallel ${res.maxParallelObserved}`);
+      return {
+        success: true,
+        output: `[chunk_query] ${res.chunks} chunk(s), ${res.totalChars} chars, max parallel ${res.maxParallelObserved}
+
+${res.synthesis || res.answers.join(`
+`)}`
+      };
+    }
+  };
+});
+
 // src/modules/security/network-validator.ts
 function isUrlAllowed(url, securityConfig) {
   if (!securityConfig?.enabled) {
@@ -12586,7 +12966,7 @@ class MCPClient {
     }
   }
   connectStdio() {
-    return new Promise((resolve12, reject) => {
+    return new Promise((resolve15, reject) => {
       const child = spawn3(this.config.command, this.config.args || [], {
         env: { ...process.env, ...this.config.env },
         stdio: ["pipe", "pipe", "pipe"]
@@ -12610,7 +12990,7 @@ class MCPClient {
         this._connected = true;
         this.process = child;
         _resolved = true;
-        resolve12();
+        resolve15();
       });
     });
   }
@@ -12679,7 +13059,7 @@ class MCPClient {
     if (!this.process) {
       throw new Error("Not connected to MCP server");
     }
-    return new Promise((resolve12, reject) => {
+    return new Promise((resolve15, reject) => {
       const request = {
         jsonrpc: "2.0",
         id: Date.now(),
@@ -12703,7 +13083,7 @@ class MCPClient {
                 if (response.error) {
                   reject(new Error(response.error.message));
                 } else {
-                  resolve12(response.result?.tools || []);
+                  resolve15(response.result?.tools || []);
                 }
                 return;
               }
@@ -12785,8 +13165,8 @@ class MCPClient {
         arguments: args
       }
     };
-    return new Promise((resolve12, reject) => {
-      this.pendingResolve = resolve12;
+    return new Promise((resolve15, reject) => {
+      this.pendingResolve = resolve15;
       this.pendingReject = reject;
       const timeout = this.config.timeout || 30000;
       const timer = setTimeout(() => {
@@ -12813,7 +13193,7 @@ class MCPClient {
         if (result.error) {
           reject(new Error(result.error.message));
         } else {
-          resolve12(result.result || result);
+          resolve15(result.result || result);
         }
       }).catch((err) => {
         clearTimeout(timer);
@@ -12827,7 +13207,7 @@ class MCPClient {
     if (!this.process) {
       throw new Error("Not connected to MCP server");
     }
-    return new Promise((resolve12, reject) => {
+    return new Promise((resolve15, reject) => {
       const request = {
         jsonrpc: "2.0",
         id: Date.now(),
@@ -12855,7 +13235,7 @@ class MCPClient {
                 if (response.error) {
                   reject(new Error(response.error.message));
                 } else {
-                  resolve12(response.result);
+                  resolve15(response.result);
                 }
                 return;
               }
@@ -13057,7 +13437,7 @@ import { join as join15 } from "path";
 var CATEGORIES, rememberTool;
 var init_remember = __esm(() => {
   init_i18n();
-  init_store();
+  init_store2();
   CATEGORIES = ["preferences", "conventions", "decisions", "errors", "facts"];
   rememberTool = {
     name: "remember",
@@ -13184,7 +13564,7 @@ function searchCategory(store, category, query) {
 var CATEGORIES2, recallTool;
 var init_recall = __esm(() => {
   init_i18n();
-  init_store();
+  init_store2();
   CATEGORIES2 = ["preferences", "conventions", "decisions", "errors", "facts"];
   recallTool = {
     name: "recall",
@@ -13883,7 +14263,7 @@ __export(exports_image_utils, {
   detectMime: () => detectMime,
   bufferToDataUrl: () => bufferToDataUrl
 });
-import { readFileSync as readFileSync12 } from "fs";
+import { readFileSync as readFileSync14 } from "fs";
 import { extname as extname3 } from "path";
 function detectMime(filePath) {
   const ext = extname3(filePath).toLowerCase();
@@ -13904,7 +14284,7 @@ async function readClipboardImage() {
 async function readClipboardFallback() {
   const { platform: platform3 } = await import("os");
   const { execSync } = await import("child_process");
-  const { readFileSync: readFileSync13, unlinkSync: unlinkSync4 } = await import("fs");
+  const { readFileSync: readFileSync15, unlinkSync: unlinkSync4 } = await import("fs");
   const { join: join19 } = await import("path");
   const tmpPath = join19(process.env.TEMP || process.env.TMP || "/tmp", `mma-clip-${Date.now()}.png`);
   try {
@@ -13913,7 +14293,7 @@ async function readClipboardFallback() {
     } else {
       return null;
     }
-    const buf = readFileSync13(tmpPath);
+    const buf = readFileSync15(tmpPath);
     unlinkSync4(tmpPath);
     return buf.length > 0 ? buf : null;
   } catch {
@@ -13924,7 +14304,7 @@ async function readClipboardFallback() {
   }
 }
 async function loadFileAsDataUrl(filePath) {
-  const buf = readFileSync12(filePath);
+  const buf = readFileSync14(filePath);
   if (typeof Bun !== "undefined" && typeof Bun.Image !== "undefined") {
     try {
       const img = new Bun.Image(buf);
@@ -13984,8 +14364,8 @@ var init_image_utils = __esm(() => {
 });
 
 // src/tools/attach-image.ts
-import { existsSync as existsSync23 } from "fs";
-import { resolve as resolve12 } from "path";
+import { existsSync as existsSync24 } from "fs";
+import { resolve as resolve15 } from "path";
 var attachImageTool;
 var init_attach_image = __esm(() => {
   init_i18n();
@@ -14026,16 +14406,16 @@ var init_attach_image = __esm(() => {
           const result = await loadUrlAsDataUrl(source);
           dataUrl = result.dataUrl;
         } else {
-          const absPath = resolve12(ctx.baseDir, source);
-          if (!existsSync23(absPath)) {
+          const absPath = resolve15(ctx.baseDir, source);
+          if (!existsSync24(absPath)) {
             return {
               success: false,
               output: t("image.not_found", { path: source })
             };
           }
           if (ctx.scope) {
-            const { isPathInScope: isPathInScope2 } = await Promise.resolve().then(() => (init_path_validator(), exports_path_validator));
-            const validation = isPathInScope2(ctx.baseDir, absPath, ctx.scope);
+            const { isPathInScope: isPathInScope3 } = await Promise.resolve().then(() => (init_path_validator(), exports_path_validator));
+            const validation = isPathInScope3(ctx.baseDir, absPath, ctx.scope);
             if (!validation.allowed) {
               logSecurityBlock(ctx.sessionId, "file_read", validation.reason ?? "attach_image out of scope", absPath);
               return {
@@ -14087,6 +14467,7 @@ function registerAllTools(registry2, skillsModule) {
     fileInfoTool,
     bashTool,
     subagentTool,
+    chunkQueryTool,
     processListTool,
     processLogTool,
     processKillTool,
@@ -14122,6 +14503,7 @@ var init_tools = __esm(() => {
   init_process_log();
   init_process_kill();
   init_subagent();
+  init_chunk_query();
   init_web_search();
   init_web_fetch();
   init_web_browse();
@@ -14183,12 +14565,12 @@ class ModuleRegistry {
 }
 
 // src/modules/plugins/loader.ts
-import { readdirSync as readdirSync7, existsSync as existsSync24, statSync as statSync5 } from "fs";
+import { readdirSync as readdirSync7, existsSync as existsSync25, statSync as statSync5 } from "fs";
 import { join as join19 } from "path";
 
 class PluginLoader {
   loadFromDir(dirPath, pluginManager, logger) {
-    if (!existsSync24(dirPath))
+    if (!existsSync25(dirPath))
       return;
     const entries = readdirSync7(dirPath);
     for (const entry of entries) {
@@ -14216,8 +14598,8 @@ var init_loader = __esm(() => {
 
 // src/modules/plugins/builtin/lint-on-write.ts
 import { spawn as spawn4, execSync } from "child_process";
-import { existsSync as existsSync25, readFileSync as readFileSync13 } from "fs";
-import { resolve as resolve13, extname as extname4, join as join20 } from "path";
+import { existsSync as existsSync26, readFileSync as readFileSync15 } from "fs";
+import { resolve as resolve16, extname as extname4, join as join20 } from "path";
 import { platform as platform3 } from "os";
 function contentHash(content) {
   let h = 5381;
@@ -14262,8 +14644,8 @@ class LintOnWritePlugin {
     const path = String(call.arguments.path || "");
     if (!path)
       return;
-    const fullPath = resolve13(ctx.baseDir, path);
-    if (!existsSync25(fullPath))
+    const fullPath = resolve16(ctx.baseDir, path);
+    if (!existsSync26(fullPath))
       return;
     const ext = extname4(fullPath);
     const syntaxError = await this.checkSyntax(fullPath, ext, ctx.baseDir);
@@ -14280,7 +14662,7 @@ class LintOnWritePlugin {
     if (ext === ".ts" || ext === ".tsx") {
       let content = "";
       try {
-        content = readFileSync13(filePath, "utf-8");
+        content = readFileSync15(filePath, "utf-8");
       } catch {
         return null;
       }
@@ -14320,10 +14702,10 @@ class LintOnWritePlugin {
   async runProjectLint(ctx, result) {
     try {
       const packageJsonPath = join20(ctx.baseDir, "package.json");
-      if (!existsSync25(packageJsonPath)) {
+      if (!existsSync26(packageJsonPath)) {
         return;
       }
-      const packageJson = JSON.parse(readFileSync13(packageJsonPath, "utf-8"));
+      const packageJson = JSON.parse(readFileSync15(packageJsonPath, "utf-8"));
       const lintScript = packageJson.scripts?.lint;
       if (!lintScript) {
         return;
@@ -14340,7 +14722,7 @@ class LintOnWritePlugin {
   }
   async runProjectTypeCheck(ctx, result) {
     const tsconfigPath = join20(ctx.baseDir, "tsconfig.json");
-    if (!existsSync25(tsconfigPath)) {
+    if (!existsSync26(tsconfigPath)) {
       return;
     }
     const now = Date.now();
@@ -14381,7 +14763,7 @@ class LintOnWritePlugin {
   }
 }
 function runAsync(command, cwd, timeoutMs) {
-  return new Promise((resolve14, reject) => {
+  return new Promise((resolve17, reject) => {
     const child = spawn4(command, {
       cwd,
       shell: true,
@@ -14410,7 +14792,7 @@ function runAsync(command, cwd, timeoutMs) {
       stdout += decoder.decode();
       stderr += decoder.decode();
       if (code === 0) {
-        resolve14({ stdout, stderr });
+        resolve17({ stdout, stderr });
       } else {
         const err = new Error(`Command failed with exit code ${code}`);
         err.stdout = stdout;
@@ -14582,8 +14964,8 @@ class PlanTracker {
 var init_tracker = () => {};
 
 // src/modules/execution/auditor.ts
-import { existsSync as existsSync26, readdirSync as readdirSync8 } from "fs";
-import { resolve as resolve14, join as join21 } from "path";
+import { existsSync as existsSync27, readdirSync as readdirSync8 } from "fs";
+import { resolve as resolve17, join as join21 } from "path";
 function findTestFile(dir, depth = 0) {
   if (depth > 5)
     return null;
@@ -14673,8 +15055,8 @@ class Auditor {
     const missingFiles = [];
     const existingFiles = [];
     for (const filePath of uniqueFiles) {
-      const resolved = resolve14(this.baseDir, filePath);
-      if (existsSync26(resolved)) {
+      const resolved = resolve17(this.baseDir, filePath);
+      if (existsSync27(resolved)) {
         existingFiles.push(filePath);
       } else {
         missingFiles.push(filePath);
@@ -14753,11 +15135,11 @@ var init_auditor = __esm(() => {
 });
 
 // src/modules/execution/plan-store.ts
-import { readFileSync as readFileSync14, writeFileSync as writeFileSync8, mkdirSync as mkdirSync12, existsSync as existsSync27, readdirSync as readdirSync9, rmSync } from "fs";
+import { readFileSync as readFileSync16, writeFileSync as writeFileSync9, mkdirSync as mkdirSync13, existsSync as existsSync28, readdirSync as readdirSync9, rmSync } from "fs";
 import { join as join22 } from "path";
 function readPlanFile(path, fallbackBaseDir) {
   try {
-    const raw = readFileSync14(path, "utf-8");
+    const raw = readFileSync16(path, "utf-8");
     if (!raw.trim())
       return null;
     const parsed = JSON.parse(raw);
@@ -14776,10 +15158,10 @@ function readPlanFile(path, fallbackBaseDir) {
   }
 }
 function writePlanFile(path, plan) {
-  writeFileSync8(path, JSON.stringify(plan, null, 2), "utf-8");
+  writeFileSync9(path, JSON.stringify(plan, null, 2), "utf-8");
 }
 function listDir(dir, baseDir) {
-  if (!existsSync27(dir))
+  if (!existsSync28(dir))
     return [];
   const files = readdirSync9(dir).filter((f) => f.endsWith(".json"));
   return files.map((f) => readPlanFile(join22(dir, f), baseDir)).filter((p) => p !== null);
@@ -14804,16 +15186,16 @@ class PlanStore {
   legacyPath;
   constructor(baseDir) {
     const mmaDir = join22(baseDir, ".mma");
-    if (!existsSync27(mmaDir))
-      mkdirSync12(mmaDir, { recursive: true });
+    if (!existsSync28(mmaDir))
+      mkdirSync13(mmaDir, { recursive: true });
     this.baseDir = baseDir;
     this.plansDir = join22(mmaDir, "plans");
     this.draftsDir = join22(this.plansDir, "drafts");
     this.archiveDir = join22(this.plansDir, "archive");
     this.legacyPath = join22(mmaDir, LEGACY_FILE);
     for (const dir of [this.plansDir, this.draftsDir, this.archiveDir]) {
-      if (!existsSync27(dir))
-        mkdirSync12(dir, { recursive: true });
+      if (!existsSync28(dir))
+        mkdirSync13(dir, { recursive: true });
     }
   }
   activePath() {
@@ -14824,12 +15206,12 @@ class PlanStore {
   }
   loadActive() {
     const activePath = this.activePath();
-    if (existsSync27(activePath)) {
+    if (existsSync28(activePath)) {
       const plan = readPlanFile(activePath, this.baseDir);
       if (plan)
         return plan;
     }
-    if (existsSync27(this.legacyPath)) {
+    if (existsSync28(this.legacyPath)) {
       const legacy = readPlanFile(this.legacyPath, this.baseDir);
       if (legacy) {
         this.saveActive(legacy);
@@ -14843,7 +15225,7 @@ class PlanStore {
   }
   clearActive() {
     const p = this.activePath();
-    if (existsSync27(p))
+    if (existsSync28(p))
       rmSync(p, { force: true });
   }
   saveDraft(plan) {
@@ -14851,11 +15233,11 @@ class PlanStore {
   }
   loadDraft(id) {
     const p = join22(this.draftsDir, `${id}.json`);
-    return existsSync27(p) ? readPlanFile(p, this.baseDir) : null;
+    return existsSync28(p) ? readPlanFile(p, this.baseDir) : null;
   }
   removeDraft(id) {
     const p = join22(this.draftsDir, `${id}.json`);
-    if (existsSync27(p))
+    if (existsSync28(p))
       rmSync(p, { force: true });
   }
   listDrafts() {
@@ -14874,7 +15256,7 @@ class PlanStore {
   }
   removeArchived(id) {
     const p = join22(this.archiveDir, `${id}.json`);
-    if (existsSync27(p))
+    if (existsSync28(p))
       rmSync(p, { force: true });
   }
   listAll() {
@@ -14968,8 +15350,8 @@ var init_plan_coverage = __esm(() => {
 });
 
 // src/modules/execution/module.ts
-import { existsSync as existsSync28, readFileSync as readFileSync15 } from "fs";
-import { resolve as resolve15 } from "path";
+import { existsSync as existsSync29, readFileSync as readFileSync17 } from "fs";
+import { resolve as resolve18 } from "path";
 
 class ExecutionModule {
   name = "execution";
@@ -15624,7 +16006,7 @@ Tool "${this.stuckDetector.getLastFailedTool()}" is failing. Try "${alternative}
         "poetry.lock",
         "requirements.txt"
       ];
-      const hasLockFile = lockFiles.some((f) => existsSync28(resolve15(this.baseDir, f)));
+      const hasLockFile = lockFiles.some((f) => existsSync29(resolve18(this.baseDir, f)));
       if (!hasLockFile) {
         if (contextManager) {
           const hints = this.depsGateHints.get(step.id) || 0;
@@ -15644,13 +16026,13 @@ Tool "${this.stuckDetector.getLastFailedTool()}" is failing. Try "${alternative}
     }
     if (stepPaths.length === 0)
       return;
-    const allExist = stepPaths.every((p) => existsSync28(resolve15(this.baseDir, p)));
+    const allExist = stepPaths.every((p) => existsSync29(resolve18(this.baseDir, p)));
     if (!allExist)
       return;
     const emptyFiles = [];
     for (const p of stepPaths) {
       try {
-        const content = readFileSync15(resolve15(this.baseDir, p), "utf-8");
+        const content = readFileSync17(resolve18(this.baseDir, p), "utf-8");
         if (content.trim().length < 10) {
           emptyFiles.push(p);
         }
@@ -15707,9 +16089,9 @@ var init_module = __esm(() => {
 
 // src/modules/security/session-encryption.ts
 import {
-  readFileSync as readFileSync16,
-  writeFileSync as writeFileSync9,
-  existsSync as existsSync29,
+  readFileSync as readFileSync18,
+  writeFileSync as writeFileSync10,
+  existsSync as existsSync30,
   readdirSync as readdirSync10,
   unlinkSync as unlinkSync4
 } from "fs";
@@ -15767,23 +16149,23 @@ class SessionFileEncryptor {
     return lines.map((line) => this.decryptFileContent(line));
   }
   readSessionFile(filePath) {
-    const content = readFileSync16(filePath, "utf8");
+    const content = readFileSync18(filePath, "utf8");
     return this.decryptFileContent(content);
   }
   writeSessionFile(filePath, content) {
     const encrypted = this.encryptFileContent(content);
-    writeFileSync9(filePath, encrypted, "utf8");
+    writeFileSync10(filePath, encrypted, "utf8");
   }
   readSessionJSON(filePath) {
-    const content = readFileSync16(filePath, "utf8");
+    const content = readFileSync18(filePath, "utf8");
     return this.decryptJSON(content);
   }
   writeSessionJSON(filePath, obj) {
     const content = this.encryptJSON(obj);
-    writeFileSync9(filePath, content, "utf8");
+    writeFileSync10(filePath, content, "utf8");
   }
   readSessionJSONL(filePath) {
-    const content = readFileSync16(filePath, "utf8");
+    const content = readFileSync18(filePath, "utf8");
     const lines = content.split(`
 `).filter((line) => line.trim());
     const decryptedLines = this.decryptJSONL(lines);
@@ -15797,7 +16179,7 @@ class SessionFileEncryptor {
   }
   appendToSessionJSONL(filePath, obj) {
     const encryptedLine = this.encryptFileContent(JSON.stringify(obj));
-    writeFileSync9(filePath, encryptedLine + `
+    writeFileSync10(filePath, encryptedLine + `
 `, {
       flag: "a",
       encoding: "utf8"
@@ -15809,11 +16191,11 @@ class SessionFileEncryptor {
     const files = readdirSync10(sessionDir);
     for (const file of files) {
       const filePath = join23(sessionDir, file);
-      if (existsSync29(filePath) && !file.endsWith(".enc")) {
+      if (existsSync30(filePath) && !file.endsWith(".enc")) {
         try {
-          const content = readFileSync16(filePath, "utf8");
+          const content = readFileSync18(filePath, "utf8");
           const encrypted = this.encryptFileContent(content);
-          writeFileSync9(filePath + ".enc", encrypted, "utf8");
+          writeFileSync10(filePath + ".enc", encrypted, "utf8");
           unlinkSync4(filePath);
         } catch {}
       }
@@ -15828,9 +16210,9 @@ class SessionFileEncryptor {
         const encFilePath = join23(sessionDir, file);
         const decFilePath = encFilePath.slice(0, -4);
         try {
-          const content = readFileSync16(encFilePath, "utf8");
+          const content = readFileSync18(encFilePath, "utf8");
           const decrypted = this.decryptFileContent(content);
-          writeFileSync9(decFilePath, decrypted, "utf8");
+          writeFileSync10(decFilePath, decrypted, "utf8");
           unlinkSync4(encFilePath);
         } catch {}
       }
@@ -15850,12 +16232,12 @@ var init_session_encryption = __esm(() => {
 
 // src/modules/session/store.ts
 import {
-  existsSync as existsSync30,
-  mkdirSync as mkdirSync13,
+  existsSync as existsSync31,
+  mkdirSync as mkdirSync14,
   readdirSync as readdirSync11,
-  readFileSync as readFileSync17,
+  readFileSync as readFileSync19,
   rmSync as rmSync2,
-  writeFileSync as writeFileSync10,
+  writeFileSync as writeFileSync11,
   appendFileSync as appendFileSync6
 } from "fs";
 import { join as join24 } from "path";
@@ -15885,7 +16267,7 @@ class SessionStore {
     return this.encryptor?.isEnabled() ?? false;
   }
   init() {
-    mkdirSync13(this.baseDir, { recursive: true });
+    mkdirSync14(this.baseDir, { recursive: true });
   }
   sessionDir(id) {
     return join24(this.baseDir, id);
@@ -15900,17 +16282,17 @@ class SessionStore {
     return join24(this.sessionDir(id), "session.jsonl");
   }
   sessionExists(id) {
-    return existsSync30(this.metaPath(id));
+    return existsSync31(this.metaPath(id));
   }
   saveMeta(id, meta) {
     this._metaCache.set(id, meta);
     const dir = this.sessionDir(id);
-    mkdirSync13(dir, { recursive: true });
+    mkdirSync14(dir, { recursive: true });
     const content = JSON.stringify(meta, null, 2);
     if (this.encryptor) {
-      writeFileSync10(this.metaPath(id), this.encryptor.encryptFileContent(content), "utf-8");
+      writeFileSync11(this.metaPath(id), this.encryptor.encryptFileContent(content), "utf-8");
     } else {
-      writeFileSync10(this.metaPath(id), content, "utf-8");
+      writeFileSync11(this.metaPath(id), content, "utf-8");
     }
   }
   loadMeta(id) {
@@ -15918,10 +16300,10 @@ class SessionStore {
     if (cached)
       return cached;
     const path = this.metaPath(id);
-    if (!existsSync30(path))
+    if (!existsSync31(path))
       return null;
     try {
-      const raw = readFileSync17(path, "utf-8");
+      const raw = readFileSync19(path, "utf-8");
       const content = this.encryptor ? this.encryptor.decryptFileContent(raw) : raw;
       const meta = JSON.parse(content);
       this._metaCache.set(id, meta);
@@ -15932,7 +16314,7 @@ class SessionStore {
   }
   appendMessage(id, msg) {
     const dir = this.sessionDir(id);
-    mkdirSync13(dir, { recursive: true });
+    mkdirSync14(dir, { recursive: true });
     const line = JSON.stringify(msg);
     if (this.encryptor?.isEnabled()) {
       appendFileSync6(this.historyPath(id), this.encryptor.encryptFileContent(line) + `
@@ -15950,10 +16332,10 @@ class SessionStore {
   }
   loadHistory(id) {
     const path = this.historyPath(id);
-    if (!existsSync30(path))
+    if (!existsSync31(path))
       return [];
     try {
-      const raw = readFileSync17(path, "utf-8");
+      const raw = readFileSync19(path, "utf-8");
       const lines = raw.split(`
 `).filter(Boolean);
       const parseLine = (line) => {
@@ -15979,7 +16361,7 @@ class SessionStore {
   }
   appendSessionLog(id, entry) {
     const dir = this.sessionDir(id);
-    mkdirSync13(dir, { recursive: true });
+    mkdirSync14(dir, { recursive: true });
     const line = JSON.stringify(entry);
     if (this.encryptor?.isEnabled()) {
       appendFileSync6(this.sessionLogPath(id), this.encryptor.encryptFileContent(line) + `
@@ -15991,10 +16373,10 @@ class SessionStore {
   }
   loadSessionLog(id) {
     const path = this.sessionLogPath(id);
-    if (!existsSync30(path))
+    if (!existsSync31(path))
       return [];
     try {
-      const raw = readFileSync17(path, "utf-8");
+      const raw = readFileSync19(path, "utf-8");
       const lines = raw.split(`
 `).filter(Boolean);
       const parseLine = (line) => {
@@ -16019,7 +16401,7 @@ class SessionStore {
     }
   }
   listSessions() {
-    if (!existsSync30(this.baseDir))
+    if (!existsSync31(this.baseDir))
       return [];
     const entries = readdirSync11(this.baseDir, { withFileTypes: true });
     const sessions = [];
@@ -16036,7 +16418,7 @@ class SessionStore {
   deleteSession(id) {
     this._metaCache.delete(id);
     const dir = this.sessionDir(id);
-    if (existsSync30(dir)) {
+    if (existsSync31(dir)) {
       rmSync2(dir, { recursive: true, force: true });
     }
   }
@@ -16048,18 +16430,18 @@ class SessionStore {
       const updatedAt = new Date(session2.updatedAt);
       if (updatedAt < thirtyDaysAgo) {
         const historyPath = this.historyPath(session2.id);
-        if (existsSync30(historyPath)) {
-          const content = readFileSync17(historyPath, "utf-8");
+        if (existsSync31(historyPath)) {
+          const content = readFileSync19(historyPath, "utf-8");
           const compressed = gzipSync(content);
           const gzPath = join24(this.baseDir, `${session2.id}.jsonl.gz`);
-          writeFileSync10(gzPath, compressed);
+          writeFileSync11(gzPath, compressed);
           rmSync2(historyPath);
         }
       }
     }
   }
 }
-var init_store2 = __esm(() => {
+var init_store3 = __esm(() => {
   init_session_encryption();
 });
 
@@ -16239,7 +16621,7 @@ var init_module2 = __esm(() => {
 
 // src/modules/session/index.ts
 var init_session2 = __esm(() => {
-  init_store2();
+  init_store3();
   init_manager2();
   init_module2();
 });
@@ -16261,7 +16643,7 @@ class ProfileCompressor {
 }
 
 // src/modules/user-profile/profile.ts
-import { readFileSync as readFileSync18, writeFileSync as writeFileSync11, existsSync as existsSync31, mkdirSync as mkdirSync14 } from "fs";
+import { readFileSync as readFileSync20, writeFileSync as writeFileSync12, existsSync as existsSync32, mkdirSync as mkdirSync15 } from "fs";
 import { join as join25 } from "path";
 import { homedir as homedir9, hostname, platform as platform4, type } from "os";
 import { env } from "process";
@@ -16286,17 +16668,17 @@ class UserProfile {
     return this.info;
   }
   save() {
-    if (!existsSync31(this.profileDir)) {
-      mkdirSync14(this.profileDir, { recursive: true });
+    if (!existsSync32(this.profileDir)) {
+      mkdirSync15(this.profileDir, { recursive: true });
     }
-    writeFileSync11(join25(this.profileDir, "profile.json"), JSON.stringify({ ...this.info, preferences: this.preferences }, null, 2), "utf-8");
+    writeFileSync12(join25(this.profileDir, "profile.json"), JSON.stringify({ ...this.info, preferences: this.preferences }, null, 2), "utf-8");
   }
   load() {
     const path = join25(this.profileDir, "profile.json");
-    if (!existsSync31(path))
+    if (!existsSync32(path))
       return null;
     try {
-      const data = JSON.parse(readFileSync18(path, "utf-8"));
+      const data = JSON.parse(readFileSync20(path, "utf-8"));
       this.info = {
         platform: data.platform,
         os: data.os,
@@ -16331,12 +16713,12 @@ class UserProfile {
 var init_profile = () => {};
 
 // src/modules/skills/loader.ts
-import { readdirSync as readdirSync12, readFileSync as readFileSync19, existsSync as existsSync32, statSync as statSync6 } from "fs";
+import { readdirSync as readdirSync12, readFileSync as readFileSync21, existsSync as existsSync33, statSync as statSync6 } from "fs";
 import { join as join26 } from "path";
 
 class SkillsLoader {
   loadFromDir(dirPath) {
-    if (!existsSync32(dirPath))
+    if (!existsSync33(dirPath))
       return [];
     const skills = [];
     this.scanDir(dirPath, skills);
@@ -16353,7 +16735,7 @@ class SkillsLoader {
       }
       if (!entry.endsWith(".md") && !entry.endsWith(".skill.md"))
         continue;
-      const content = readFileSync19(fullPath, "utf-8");
+      const content = readFileSync21(fullPath, "utf-8");
       const parsed = this.parseSkillFile(content, fullPath);
       if (parsed)
         skills.push(parsed);
@@ -16587,7 +16969,7 @@ var init_browser2 = __esm(() => {
 
 // src/modules/lsp/client.ts
 import { spawn as spawn5, execSync as execSync2 } from "child_process";
-import { resolve as resolve16 } from "path";
+import { resolve as resolve19 } from "path";
 
 class LspClient {
   process = null;
@@ -16603,7 +16985,7 @@ class LspClient {
     const timeout = config.timeout ?? DEFAULT_TIMEOUT;
     try {
       await this.startServer(config, baseDir);
-      const rootUri = this.pathToUri(resolve16(baseDir));
+      const rootUri = this.pathToUri(resolve19(baseDir));
       const initResult = await this.sendRequest("initialize", {
         processId: process.pid,
         rootUri,
@@ -16612,11 +16994,11 @@ class LspClient {
       }, timeout);
       this.initialized = true;
       this.sendNotification("initialized", {});
-      const uri = this.pathToUri(resolve16(filePath));
+      const uri = this.pathToUri(resolve19(filePath));
       const fs2 = await import("fs");
       const content = fs2.readFileSync(filePath, "utf-8");
-      const diagPromise = new Promise((resolve17) => {
-        this.diagnosticsResolve = resolve17;
+      const diagPromise = new Promise((resolve20) => {
+        this.diagnosticsResolve = resolve20;
         this.diagnostics = [];
         this.diagnosticsTimer = setTimeout(() => {
           if (this.diagnosticsResolve) {
@@ -16648,7 +17030,7 @@ class LspClient {
         throw new Error(`${config.command} not found in PATH`);
       }
     }
-    return new Promise((resolve17, reject) => {
+    return new Promise((resolve20, reject) => {
       const args = config.args ?? [];
       const proc = spawn5(config.command, args, {
         stdio: ["pipe", "pipe", "pipe"],
@@ -16661,7 +17043,7 @@ class LspClient {
       });
       proc.stderr.on("data", () => {});
       proc.once("spawn", () => {
-        resolve17();
+        resolve20();
       });
       this.process = proc;
       setTimeout(() => {
@@ -16738,9 +17120,9 @@ class LspClient {
     }
   }
   sendRequest(method, params, timeout) {
-    return new Promise((resolve17, reject) => {
+    return new Promise((resolve20, reject) => {
       const id = ++this.requestId;
-      this.pending.set(id, { resolve: resolve17, reject });
+      this.pending.set(id, { resolve: resolve20, reject });
       const message = JSON.stringify({ jsonrpc: "2.0", id, method, params });
       this.write(message);
       setTimeout(() => {
@@ -16818,8 +17200,8 @@ var DEFAULT_TIMEOUT = 15000;
 var init_client2 = () => {};
 
 // src/modules/lsp/module.ts
-import { existsSync as existsSync33 } from "fs";
-import { resolve as resolve17 } from "path";
+import { existsSync as existsSync34 } from "fs";
+import { resolve as resolve20 } from "path";
 
 class LspModule {
   name = "lsp";
@@ -16843,8 +17225,8 @@ class LspModule {
         const filePath = String(call.arguments.path ?? "");
         if (!filePath)
           return;
-        const fullPath = resolve17(_ctx.baseDir, filePath);
-        if (!existsSync33(fullPath))
+        const fullPath = resolve20(_ctx.baseDir, filePath);
+        if (!existsSync34(fullPath))
           return;
         const serverConfig = getServerForFile(fullPath, self.config);
         if (!serverConfig)
@@ -16902,8 +17284,8 @@ var init_lsp = __esm(() => {
 });
 
 // src/modules/indexer/walker.ts
-import { readdirSync as readdirSync13, readFileSync as readFileSync20, statSync as statSync7, existsSync as existsSync34, watch } from "fs";
-import { join as join27, relative, extname as extname5 } from "path";
+import { readdirSync as readdirSync13, readFileSync as readFileSync22, statSync as statSync7, existsSync as existsSync35, watch } from "fs";
+import { join as join27, relative as relative2, extname as extname5 } from "path";
 
 class Indexer {
   baseDir;
@@ -16930,7 +17312,7 @@ class Indexer {
     let totalSize = 0;
     let count = 0;
     const walkDir = (dir) => {
-      if (!existsSync34(dir))
+      if (!existsSync35(dir))
         return;
       let entries;
       try {
@@ -16942,7 +17324,7 @@ class Indexer {
         if (count >= this.MAX_FILES)
           return;
         const fullPath = join27(dir, entry);
-        const relPath = relative(this.baseDir, fullPath);
+        const relPath = relative2(this.baseDir, fullPath);
         const stat = statSync7(fullPath);
         if (stat.isDirectory()) {
           if (!IGNORE_DIRS.has(entry)) {
@@ -16952,7 +17334,7 @@ class Indexer {
           const ext = extname5(entry).toLowerCase();
           const language = LANGUAGES[ext];
           if (language) {
-            const content = readFileSync20(fullPath, "utf-8");
+            const content = readFileSync22(fullPath, "utf-8");
             const exports = this.extractExports(content, language);
             files.push({ path: relPath, language, exports, size: stat.size });
             totalSize += stat.size;
@@ -17004,7 +17386,7 @@ var init_walker = __esm(() => {
 });
 
 // src/modules/indexer/cache.ts
-import { readFileSync as readFileSync21, writeFileSync as writeFileSync12, existsSync as existsSync35, mkdirSync as mkdirSync15, rmSync as rmSync3 } from "fs";
+import { readFileSync as readFileSync23, writeFileSync as writeFileSync13, existsSync as existsSync36, mkdirSync as mkdirSync16, rmSync as rmSync3 } from "fs";
 import { join as join28 } from "path";
 
 class IndexCache {
@@ -17016,10 +17398,10 @@ class IndexCache {
   load() {
     if (this.cache)
       return this.cache;
-    if (!existsSync35(this.cachePath))
+    if (!existsSync36(this.cachePath))
       return null;
     try {
-      this.cache = JSON.parse(readFileSync21(this.cachePath, "utf-8"));
+      this.cache = JSON.parse(readFileSync23(this.cachePath, "utf-8"));
       return this.cache;
     } catch {
       return null;
@@ -17028,13 +17410,13 @@ class IndexCache {
   save(result) {
     this.cache = result;
     const dir = join28(this.cachePath, "..");
-    if (!existsSync35(dir))
-      mkdirSync15(dir, { recursive: true });
-    writeFileSync12(this.cachePath, JSON.stringify(result), "utf-8");
+    if (!existsSync36(dir))
+      mkdirSync16(dir, { recursive: true });
+    writeFileSync13(this.cachePath, JSON.stringify(result), "utf-8");
   }
   invalidate() {
     this.cache = null;
-    if (existsSync35(this.cachePath)) {
+    if (existsSync36(this.cachePath)) {
       try {
         rmSync3(this.cachePath);
       } catch {}
@@ -17434,7 +17816,7 @@ class MemoryModule {
   }
 }
 var init_module8 = __esm(() => {
-  init_store();
+  init_store2();
   init_remember();
   init_recall();
 });
@@ -17446,8 +17828,8 @@ __export(exports_bootstrap, {
   bootstrap: () => bootstrap
 });
 import { homedir as homedir11 } from "os";
-import { join as join30, resolve as resolve18 } from "path";
-import { existsSync as existsSync36, readFileSync as readFileSync22, writeFileSync as writeFileSync13 } from "fs";
+import { join as join30, resolve as resolve21 } from "path";
+import { existsSync as existsSync37, readFileSync as readFileSync24, 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");
@@ -17516,7 +17898,7 @@ async function bootstrap(configDir, projectDir, noAgentsMd, exitOnComplete) {
     retry: config.retry,
     rateLimits: config.security?.rateLimits
   });
-  const baseDir = projectDir ? resolve18(projectDir) : process.cwd();
+  const baseDir = projectDir ? resolve21(projectDir) : process.cwd();
   const projectMapCacheDir = join30(baseDir, ".mma");
   const indexerModule = new IndexerModule({
     baseDir,
@@ -17545,8 +17927,8 @@ async function bootstrap(configDir, projectDir, noAgentsMd, exitOnComplete) {
     estimatedTokens: Math.ceil(systemInfoContent.length / 4)
   };
   const agentsMdGlobal = join30(dir, "AGENTS.md");
-  if (!existsSync36(agentsMdGlobal)) {
-    writeFileSync13(agentsMdGlobal, "", "utf-8");
+  if (!existsSync37(agentsMdGlobal)) {
+    writeFileSync14(agentsMdGlobal, "", "utf-8");
   }
   const sessionDir = join30(dir, "sessions");
   const sessionStore = new SessionStore(sessionDir);
@@ -17689,8 +18071,8 @@ async function bootstrap(configDir, projectDir, noAgentsMd, exitOnComplete) {
       join30(dir, "AGENTS.md")
     ];
     for (const p of agentsMdCandidates) {
-      if (existsSync36(p)) {
-        const content = readFileSync22(p, "utf-8").trim();
+      if (existsSync37(p)) {
+        const content = readFileSync24(p, "utf-8").trim();
         if (content) {
           agentsMdBlocks.push({
             content,
@@ -18317,10 +18699,10 @@ function menuList(items) {
     console.log(l);
 }
 function ask(rl, question, defaultValue) {
-  return new Promise((resolve19) => {
+  return new Promise((resolve22) => {
     const prompt = defaultValue ? `${question} [${defaultValue}]: ` : `${question}: `;
     rl.question(prompt, (answer) => {
-      resolve19(answer.trim() || defaultValue || "");
+      resolve22(answer.trim() || defaultValue || "");
     });
   });
 }
@@ -18539,21 +18921,21 @@ __export(exports_manifest, {
   getCertMark: () => getCertMark,
   MANIFEST_PATH: () => MANIFEST_PATH
 });
-import { existsSync as existsSync37, readFileSync as readFileSync23, mkdirSync as mkdirSync16, writeFileSync as writeFileSync14 } from "fs";
+import { existsSync as existsSync38, readFileSync as readFileSync25, mkdirSync as mkdirSync17, writeFileSync as writeFileSync15 } from "fs";
 import { homedir as homedir13 } from "os";
 import { join as join32 } from "path";
 function readManifest(path = MANIFEST_PATH) {
   try {
-    if (existsSync37(path)) {
-      const raw = JSON.parse(readFileSync23(path, "utf-8"));
+    if (existsSync38(path)) {
+      const raw = JSON.parse(readFileSync25(path, "utf-8"));
       return { version: 1, certifications: raw.certifications ?? [] };
     }
   } catch {}
   return { version: 1, certifications: [] };
 }
 function saveManifest(m, path = MANIFEST_PATH) {
-  mkdirSync16(join32(homedir13(), ".mma"), { recursive: true });
-  writeFileSync14(path, JSON.stringify(m, null, 2), "utf-8");
+  mkdirSync17(join32(homedir13(), ".mma"), { recursive: true });
+  writeFileSync15(path, JSON.stringify(m, null, 2), "utf-8");
 }
 function upsertCertification(entry, path = MANIFEST_PATH) {
   const m = readManifest(path);
@@ -25710,7 +26092,7 @@ var init_scenarios = __esm(() => {
 });
 
 // src/modules/certification/loader.ts
-import { existsSync as existsSync38, readdirSync as readdirSync14, readFileSync as readFileSync24 } from "fs";
+import { existsSync as existsSync39, readdirSync as readdirSync14, readFileSync as readFileSync26 } from "fs";
 import { join as join33 } from "path";
 function validateScenario(s) {
   const errors2 = [];
@@ -25760,12 +26142,12 @@ function loadScenarios(userDir) {
     else
       scenarios.push(s);
   }
-  if (userDir && existsSync38(userDir)) {
+  if (userDir && existsSync39(userDir)) {
     for (const file of readdirSync14(userDir)) {
       if (!file.endsWith(".yaml") && !file.endsWith(".yml"))
         continue;
       try {
-        const raw = readFileSync24(join33(userDir, file), "utf-8");
+        const raw = readFileSync26(join33(userDir, file), "utf-8");
         const data = $parse(raw);
         const parsed = normalizeScenario(data, file);
         const errs = validateScenario(parsed);
@@ -25818,7 +26200,7 @@ var init_loader3 = __esm(() => {
 });
 
 // src/modules/certification/fact-checker.ts
-import { existsSync as existsSync39, readFileSync as readFileSync25, statSync as statSync8 } from "fs";
+import { existsSync as existsSync40, readFileSync as readFileSync27, statSync as statSync8 } from "fs";
 import { join as join34 } from "path";
 function checkSandbox(sandboxDir, checks, exitCode, output) {
   const failures = [];
@@ -25838,14 +26220,14 @@ function runCheck(sandboxDir, check, exitCode, output) {
     case "fileExists":
       return isFile(join34(sandboxDir, check.path));
     case "fileNotExists":
-      return !existsSync39(join34(sandboxDir, check.path));
+      return !existsSync40(join34(sandboxDir, check.path));
     case "dirExists":
       return isDir(join34(sandboxDir, check.path));
     case "fileContent": {
       const abs = join34(sandboxDir, check.path);
       if (!isFile(abs))
         return false;
-      const content = readFileSync25(abs, "utf-8");
+      const content = readFileSync27(abs, "utf-8");
       if (check.contains !== undefined)
         return content.includes(check.contains);
       if (check.equals !== undefined)
@@ -25856,7 +26238,7 @@ function runCheck(sandboxDir, check, exitCode, output) {
       const abs = join34(sandboxDir, check.path);
       if (!isFile(abs))
         return false;
-      return new RegExp(check.pattern).test(readFileSync25(abs, "utf-8"));
+      return new RegExp(check.pattern).test(readFileSync27(abs, "utf-8"));
     }
     default:
       return false;
@@ -25864,14 +26246,14 @@ function runCheck(sandboxDir, check, exitCode, output) {
 }
 function isFile(p) {
   try {
-    return existsSync39(p) && statSync8(p).isFile();
+    return existsSync40(p) && statSync8(p).isFile();
   } catch {
     return false;
   }
 }
 function isDir(p) {
   try {
-    return existsSync39(p) && statSync8(p).isDirectory();
+    return existsSync40(p) && statSync8(p).isDirectory();
   } catch {
     return false;
   }
@@ -25902,9 +26284,9 @@ var init_fact_checker = () => {};
 
 // src/modules/certification/runner.ts
 import { spawn as spawn6 } from "child_process";
-import { existsSync as existsSync40, mkdirSync as mkdirSync17, rmSync as rmSync4, cpSync as cpSync2 } from "fs";
+import { existsSync as existsSync41, mkdirSync as mkdirSync18, rmSync as rmSync4, cpSync as cpSync2 } from "fs";
 import { platform as platform5 } from "os";
-import { join as join35, resolve as resolve19, dirname as dirname8 } from "path";
+import { join as join35, resolve as resolve22, dirname as dirname8 } from "path";
 async function runScenario(scenario, opts) {
   if (scenario.mode === "skip") {
     return {
@@ -25982,30 +26364,30 @@ ${res.stderr}`;
 }
 function prepareSandbox(sandbox, scenario, mmaRoot) {
   rmSync4(sandbox, { recursive: true, force: true });
-  mkdirSync17(sandbox, { recursive: true });
+  mkdirSync18(sandbox, { recursive: true });
   for (const f of scenario.fixtures ?? []) {
     const src = join35(mmaRoot, f.source);
-    if (!existsSync40(src)) {
+    if (!existsSync41(src)) {
       throw new Error(`fixture missing: ${f.source}`);
     }
     const dest = join35(sandbox, f.dest);
-    mkdirSync17(dirname8(dest), { recursive: true });
+    mkdirSync18(dirname8(dest), { recursive: true });
     cpSync2(src, dest);
   }
 }
 function resolveMmaEntry(mmaRoot) {
   const dev = join35(mmaRoot, "src", "cli", "main.ts");
-  if (existsSync40(dev))
+  if (existsSync41(dev))
     return dev;
   return join35(mmaRoot, "dist", "main.js");
 }
 function findMmaRoot(fromDir) {
   const candidates = [
-    resolve19(fromDir, "..", "..", ".."),
-    resolve19(fromDir, "..")
+    resolve22(fromDir, "..", "..", ".."),
+    resolve22(fromDir, "..")
   ];
   for (const c of candidates) {
-    if (existsSync40(join35(c, "package.json")))
+    if (existsSync41(join35(c, "package.json")))
       return c;
   }
   return process.cwd();
@@ -26075,13 +26457,13 @@ import { rmSync as rmSync5 } from "fs";
 import { homedir as homedir14 } from "os";
 import { join as join36, dirname as dirname9 } from "path";
 import { fileURLToPath } from "url";
-import { existsSync as existsSync41, readFileSync as readFileSync26 } from "fs";
+import { existsSync as existsSync42, readFileSync as readFileSync28 } from "fs";
 function readVersion() {
   const candidates = [join36(MMA_ROOT, "package.json")];
   for (const p of candidates) {
-    if (existsSync41(p)) {
+    if (existsSync42(p)) {
       try {
-        const raw = JSON.parse(readFileSync26(p, "utf-8"));
+        const raw = JSON.parse(readFileSync28(p, "utf-8"));
         if (raw.version)
           return raw.version;
       } catch {}
@@ -26242,7 +26624,7 @@ __export(exports_repl_commands, {
 });
 import { join as join38, dirname as dirname11 } from "path";
 import { homedir as homedir16 } from "os";
-import { existsSync as existsSync43, readFileSync as readFileSync28 } from "fs";
+import { existsSync as existsSync44, readFileSync as readFileSync30 } from "fs";
 import { fileURLToPath as fileURLToPath3 } from "url";
 function readVersion3() {
   const here = dirname11(fileURLToPath3(import.meta.url));
@@ -26251,9 +26633,9 @@ function readVersion3() {
     join38(here, "..", "package.json")
   ];
   for (const p of candidates) {
-    if (existsSync43(p)) {
+    if (existsSync44(p)) {
       try {
-        const raw = JSON.parse(readFileSync28(p, "utf8"));
+        const raw = JSON.parse(readFileSync30(p, "utf8"));
         if (raw.version)
           return raw.version;
       } catch {}
@@ -26317,8 +26699,8 @@ function registerMmaCommands(ctx) {
       }
       try {
         const { loadFileAsDataUrl: loadFileAsDataUrl2, loadUrlAsDataUrl: loadUrlAsDataUrl2, readClipboardImage: readClipboardImage2 } = await Promise.resolve().then(() => (init_image_utils(), exports_image_utils));
-        const { existsSync: existsSync44 } = await import("fs");
-        const { resolve: resolve20 } = await import("path");
+        const { existsSync: existsSync45 } = await import("fs");
+        const { resolve: resolve23 } = await import("path");
         let dataUrl;
         let label;
         if (source.toLowerCase() === "clipboard") {
@@ -26336,8 +26718,8 @@ function registerMmaCommands(ctx) {
           dataUrl = result.dataUrl;
           label = source;
         } else {
-          const absPath = resolve20(process.cwd(), source);
-          if (!existsSync44(absPath)) {
+          const absPath = resolve23(process.cwd(), source);
+          if (!existsSync45(absPath)) {
             console.log(pc2.red(t("image.not_found", { path: source })));
             return;
           }
@@ -26875,7 +27257,7 @@ init_setup();
 init_i18n();
 import { join as join37, dirname as dirname10 } from "path";
 import { homedir as homedir15 } from "os";
-import { existsSync as existsSync42, readFileSync as readFileSync27 } from "fs";
+import { existsSync as existsSync43, readFileSync as readFileSync29 } from "fs";
 
 // src/cli/security-commands.ts
 init_bootstrap();
@@ -27503,9 +27885,9 @@ function readVersion2() {
     join37(here, "..", "package.json")
   ];
   for (const p of candidates) {
-    if (existsSync42(p)) {
+    if (existsSync43(p)) {
       try {
-        const raw = JSON.parse(readFileSync27(p, "utf8"));
+        const raw = JSON.parse(readFileSync29(p, "utf8"));
         if (raw.version)
           return raw.version;
       } catch {}
@@ -27732,7 +28114,7 @@ init_bootstrap();
 // src/cli/repl.ts
 init_colors();
 import * as readline2 from "readline";
-import { existsSync as existsSync44, readFileSync as readFileSync29, writeFileSync as writeFileSync15 } from "fs";
+import { existsSync as existsSync45, readFileSync as readFileSync31, writeFileSync as writeFileSync16 } from "fs";
 import { join as join39, dirname as dirname12 } from "path";
 import { homedir as homedir17 } from "os";
 import { fileURLToPath as fileURLToPath4 } from "url";
@@ -28251,9 +28633,9 @@ function readVersion4() {
     join39(here, "..", "package.json")
   ];
   for (const p of candidates) {
-    if (existsSync44(p)) {
+    if (existsSync45(p)) {
       try {
-        const raw = JSON.parse(readFileSync29(p, "utf8"));
+        const raw = JSON.parse(readFileSync31(p, "utf8"));
         if (raw.version)
           return raw.version;
       } catch {}
@@ -28331,9 +28713,9 @@ class Repl {
     this.setupListeners();
   }
   loadHistory() {
-    if (existsSync44(this.historyPath)) {
+    if (existsSync45(this.historyPath)) {
       try {
-        const raw = readFileSync29(this.historyPath, "utf-8");
+        const raw = readFileSync31(this.historyPath, "utf-8");
         this.history = raw.split(`
 `).filter(Boolean).slice(-this.maxHistory);
       } catch {
@@ -28343,7 +28725,7 @@ class Repl {
   }
   saveHistory() {
     const allHistory = this.history.slice(-this.maxHistory);
-    writeFileSync15(this.historyPath, allHistory.join(`
+    writeFileSync16(this.historyPath, allHistory.join(`
 `), "utf-8");
   }
   setupCompleter() {
@@ -28668,7 +29050,7 @@ ${t("image.clipboard_empty")}`));
         join39(this.baseDir, ".mma", "AGENTS.md"),
         join39(this.configDir, "AGENTS.md")
       ];
-      const foundAgents = agentsMdCandidates.filter((p) => existsSync44(p));
+      const foundAgents = agentsMdCandidates.filter((p) => existsSync45(p));
       if (foundAgents.length > 0) {
         for (const p of foundAgents) {
           row(t("repl.agents_label"), pc2.dim(p));
@@ -28705,7 +29087,7 @@ init_setup();
 init_config2();
 init_i18n();
 init_colors();
-import { existsSync as existsSync45 } from "fs";
+import { existsSync as existsSync46 } from "fs";
 import { join as join40 } from "path";
 import { homedir as homedir18 } from "os";
 async function main() {
@@ -28774,7 +29156,7 @@ async function main() {
     agent.shutdown();
   } else {
     const configPath = join40(homedir18(), ".mma", "config.json");
-    if (!existsSync45(configPath)) {
+    if (!existsSync46(configPath)) {
       console.log(pc2.yellow(`
   ` + t("cli.first_run") + `
 `));