opencode-swarm 6.29.1 → 6.29.3

package/dist/index.js

@@ -14217,7 +14217,7 @@ var init_evidence_schema = __esm(() => {
   });
   RetrospectiveEvidenceSchema = BaseEvidenceSchema.extend({
     type: exports_external.literal("retrospective"),
-    phase_number: exports_external.number().int().min(0).max(99),
+    phase_number: exports_external.number().int().min(1).max(99),
     total_tool_calls: exports_external.number().int().min(0).max(9999),
     coder_revisions: exports_external.number().int().min(0).max(999),
     reviewer_rejections: exports_external.number().int().min(0).max(999),
@@ -14882,7 +14882,7 @@ var init_schema = __esm(() => {
   });
   IncrementalVerifyConfigSchema = exports_external.object({
     enabled: exports_external.boolean().default(true),
-    command: exports_external.string().nullable().default(null),
+    command: exports_external.union([exports_external.string(), exports_external.array(exports_external.string())]).nullable().default(null),
     timeoutMs: exports_external.number().int().min(1000).max(300000).default(30000),
     triggerAgents: exports_external.array(exports_external.string()).default(["coder"])
   });
@@ -37601,11 +37601,11 @@ ${JSON.stringify(symbolNames, null, 2)}`);
         throw toThrow;
       }, "quit_");
       var scriptDirectory = "";
-      function locateFile(path45) {
+      function locateFile(path46) {
         if (Module["locateFile"]) {
-          return Module["locateFile"](path45, scriptDirectory);
+          return Module["locateFile"](path46, scriptDirectory);
         }
-        return scriptDirectory + path45;
+        return scriptDirectory + path46;
       }
       __name(locateFile, "locateFile");
       var readAsync, readBinary;
@@ -39353,7 +39353,7 @@ var init_runtime = __esm(() => {
 });
 
 // src/index.ts
-import * as path55 from "path";
+import * as path56 from "path";
 
 // src/agents/index.ts
 init_config();
@@ -40183,6 +40183,7 @@ Activates when: user asks to "specify", "define requirements", "write a spec", o
      - Refine \u2192 delegate to MODE: CLARIFY-SPEC
    - If NO: proceed to generation (step 2)
    - If this is called from the stale spec archival path (MODE: PLAN option 1) \u2014 archival was already completed; skip this check and proceed directly to generation (step 2)
+1b. Run CODEBASE REALITY CHECK for any codebase references mentioned by the user or implied by the feature. Skip if work is purely greenfield (no existing codebase to check). Report discrepancies before proceeding to explorer.
 2. Delegate to \`{{AGENT_PREFIX}}explorer\` to scan the codebase for relevant context (existing patterns, related code, affected areas).
 3. Delegate to \`{{AGENT_PREFIX}}sme\` for domain research on the feature area to surface known constraints, best practices, and integration concerns.
 4. Generate \`.swarm/spec.md\` capturing:
@@ -40209,22 +40210,23 @@ Each requirement must be independently testable.
 Prefer informed defaults over asking the user \u2014 use \`[NEEDS CLARIFICATION]\` only when uncertainty could change scope, security, or core behavior.
 
 EXTERNAL PLAN IMPORT PATH \u2014 when the user provides an existing implementation plan (markdown content, pasted text, or a reference to a file):
-1. Read and parse the provided plan content.
-2. Reverse-engineer \`.swarm/spec.md\` from the plan:
+1. Run CODEBASE REALITY CHECK scoped to every file, function, API, and behavioral assumption in the provided plan. Report discrepancies to user before proceeding.
+2. Read and parse the provided plan content.
+3. Reverse-engineer \`.swarm/spec.md\` from the plan:
    - Derive FR-### functional requirements from task descriptions
    - Derive SC-### success criteria from acceptance criteria in tasks
    - Identify user scenarios from the plan's phase/feature groupings
    - Surface implicit assumptions as \`[NEEDS CLARIFICATION]\` markers
-3. Validate the provided plan against swarm task format requirements:
+4. Validate the provided plan against swarm task format requirements:
    - Every task should have FILE, TASK, CONSTRAINT, and ACCEPTANCE fields
    - No task should touch more than 2 files
    - No compound verbs in TASK lines ("implement X and add Y" = 2 tasks)
    - Dependencies should be declared explicitly
    - Phase structure should match \`.swarm/plan.md\` format
-4. Report gaps, format issues, and improvement suggestions to the user.
-5. Ask: "Should I also flesh out any areas that seem underspecified?"
+5. Report gaps, format issues, and improvement suggestions to the user.
+6. Ask: "Should I also flesh out any areas that seem underspecified?"
    - If yes: delegate to \`{{AGENT_PREFIX}}sme\` for targeted research on weak areas, then propose specific improvements.
-6. Output: both a \`.swarm/spec.md\` (extracted from the plan) and a validated version of the user's plan.
+7. Output: both a \`.swarm/spec.md\` (extracted from the plan) and a validated version of the user's plan.
 
 EXTERNAL PLAN RULES:
 - Surface ALL changes as suggestions \u2014 do not silently rewrite the user's plan.
@@ -40327,6 +40329,34 @@ User directives carried forward: {list any persistent directives}
 
 This briefing is a HARD REQUIREMENT for ALL phases. Skipping it is a process violation.
 
+### CODEBASE REALITY CHECK (Required Before Speccing or Planning)
+
+Before any spec generation, plan creation, or plan ingestion begins, the Architect must dispatch the Explorer agent in targeted, scoped chunks \u2014 one per logical area of the codebase referenced by the work (e.g., per module, per hook, per config surface). Each chunk must be explored with full depth rather than a broad surface pass.
+
+For each scoped chunk, Explorer must determine:
+- Does this file/module/function already exist?
+- If it exists, what is its current state? Does it already implement any part of what the plan or spec describes?
+- Is the plan's or user's assumption about the current state accurate? Flag any discrepancy between what is expected and what actually exists.
+- Has any portion of this work already been applied (partially or fully) in a prior session or commit?
+
+Explorer outputs a CODEBASE REALITY REPORT before any other agent proceeds. The report must list every referenced item with one of:
+  NOT STARTED | PARTIALLY DONE | ALREADY COMPLETE | ASSUMPTION INCORRECT
+
+Format:
+  REALITY CHECK: [N] references verified, [M] discrepancies found.
+    \u2713 src/hooks/incremental-verify.ts \u2014 exists, line 69 confirmed Bun.spawn
+    \u2717 src/services/status-service.ts \u2014 ASSUMPTION INCORRECT: compactionCount is no longer hardcoded (fixed in v6.29.1)
+    \u2713 src/config/evidence-schema.ts:107 \u2014 confirmed phase_number min(0)
+
+No implementation agent (coder, reviewer, test-engineer) may begin until this report is finalized.
+
+This check fires automatically in:
+- MODE: SPECIFY \u2014 before explorer dispatch for context (step 2)
+- MODE: PLAN \u2014 before plan generation or validation
+- EXTERNAL PLAN IMPORT PATH \u2014 before parsing the provided plan
+
+GREENFIELD EXEMPTION: If the work is purely greenfield (new project, no existing codebase references), skip this check.
+
 ### MODE: PLAN
 
 SPEC GATE (soft \u2014 check before planning):
@@ -40356,6 +40386,8 @@ SPEC GATE (soft \u2014 check before planning):
 
 This is a SOFT gate. When the user chooses "Skip and plan directly", proceed to the steps below exactly as before \u2014 do NOT modify any planning behavior.
 
+Run CODEBASE REALITY CHECK scoped to codebase elements referenced in spec.md or user constraints. Discrepancies must be reflected in the generated plan.
+
 Use the \`save_plan\` tool to create the implementation plan. Required parameters:
 - \`title\`: The real project name from the spec (NOT a placeholder like [Project])
 - \`swarm_id\`: The swarm identifier (e.g. "mega", "local", "paid")
@@ -45509,6 +45541,58 @@ async function checkSteeringDirectives(directory) {
     };
   }
 }
+async function checkCurator(directory) {
+  try {
+    const config3 = loadPluginConfig(directory);
+    if (!config3.curator?.enabled) {
+      return {
+        name: "Curator",
+        status: "\u2705",
+        detail: "Disabled (enable via curator.enabled)"
+      };
+    }
+    const summaryPath = path16.join(directory, ".swarm/curator-summary.json");
+    if (!existsSync6(summaryPath)) {
+      return {
+        name: "Curator",
+        status: "\u2705",
+        detail: "Enabled, no summary yet (waiting for first phase)"
+      };
+    }
+    try {
+      const content = readFileSync4(summaryPath, "utf-8");
+      const parsed = JSON.parse(content);
+      if (typeof parsed.schema_version !== "number" || parsed.schema_version !== 1) {
+        return {
+          name: "Curator",
+          status: "\u274C",
+          detail: `curator-summary.json has invalid schema_version (expected 1, got ${JSON.stringify(parsed.schema_version)})`
+        };
+      }
+      const phaseInfo = parsed.last_phase_covered !== undefined ? `phase ${parsed.last_phase_covered}` : "unknown phase";
+      const timeInfo = parsed.last_updated ? `, updated ${parsed.last_updated}` : "";
+      return {
+        name: "Curator",
+        status: "\u2705",
+        detail: `Summary present \u2014 covering ${phaseInfo}${timeInfo}`
+      };
+    } catch (err2) {
+      const message = err2 instanceof Error ? err2.message : "Unknown error";
+      return {
+        name: "Curator",
+        status: "\u274C",
+        detail: `curator-summary.json is corrupt or invalid: ${message}`
+      };
+    }
+  } catch (err2) {
+    const message = err2 instanceof Error ? err2.message : "Unknown error";
+    return {
+      name: "Curator",
+      status: "\u274C",
+      detail: `Could not check curator state: ${message}`
+    };
+  }
+}
 async function getDiagnoseData(directory) {
   const checks5 = [];
   const plan = await loadPlanJsonOnly(directory);
@@ -45613,6 +45697,7 @@ async function getDiagnoseData(directory) {
   checks5.push(await checkCheckpointManifest(directory));
   checks5.push(await checkEventStreamIntegrity(directory));
   checks5.push(await checkSteeringDirectives(directory));
+  checks5.push(await checkCurator(directory));
   const passCount = checks5.filter((c) => c.status === "\u2705").length;
   const totalCount = checks5.length;
   const allPassed = passCount === totalCount;
@@ -52432,53 +52517,111 @@ function createDarkMatterDetectorHook(directory) {
 // src/hooks/incremental-verify.ts
 import * as fs20 from "fs";
 import * as path32 from "path";
+
+// src/hooks/spawn-helper.ts
+import { spawn } from "child_process";
+function spawnAsync(command, cwd, timeoutMs) {
+  return new Promise((resolve11) => {
+    try {
+      const [cmd, ...args2] = command;
+      const proc = spawn(cmd, args2, { cwd, stdio: ["ignore", "pipe", "pipe"] });
+      let stdout = "";
+      let stderr = "";
+      let done = false;
+      proc.stdout.on("data", (d) => {
+        stdout += d;
+      });
+      proc.stderr.on("data", (d) => {
+        stderr += d;
+      });
+      const timer = setTimeout(() => {
+        if (done)
+          return;
+        done = true;
+        try {
+          proc.stdout.destroy();
+        } catch {}
+        try {
+          proc.stderr.destroy();
+        } catch {}
+        try {
+          proc.kill();
+        } catch {}
+        resolve11(null);
+      }, timeoutMs);
+      proc.on("close", (code) => {
+        if (done)
+          return;
+        done = true;
+        clearTimeout(timer);
+        resolve11({ exitCode: code ?? 1, stdout, stderr });
+      });
+      proc.on("error", () => {
+        if (done)
+          return;
+        done = true;
+        clearTimeout(timer);
+        resolve11(null);
+      });
+    } catch {
+      resolve11(null);
+    }
+  });
+}
+
+// src/hooks/incremental-verify.ts
+var emittedSkipAdvisories = new Set;
 function detectTypecheckCommand(projectDir) {
   const pkgPath = path32.join(projectDir, "package.json");
-  if (!fs20.existsSync(pkgPath))
-    return null;
-  try {
-    const pkg = JSON.parse(fs20.readFileSync(pkgPath, "utf8"));
-    const scripts = pkg.scripts;
-    if (scripts?.typecheck)
-      return ["bun", "run", "typecheck"];
-    if (scripts?.["type-check"])
-      return ["bun", "run", "type-check"];
-    const deps = {
-      ...pkg.dependencies,
-      ...pkg.devDependencies
-    };
-    if (!deps?.typescript && !fs20.existsSync(path32.join(projectDir, "tsconfig.json"))) {
+  if (fs20.existsSync(pkgPath)) {
+    try {
+      const pkg = JSON.parse(fs20.readFileSync(pkgPath, "utf8"));
+      const scripts = pkg.scripts;
+      if (scripts?.typecheck)
+        return { command: ["bun", "run", "typecheck"], language: "typescript" };
+      if (scripts?.["type-check"])
+        return {
+          command: ["bun", "run", "type-check"],
+          language: "typescript"
+        };
+      const deps = {
+        ...pkg.dependencies,
+        ...pkg.devDependencies
+      };
+      if (!deps?.typescript && !fs20.existsSync(path32.join(projectDir, "tsconfig.json"))) {}
+      const hasTSMarkers = deps?.typescript || fs20.existsSync(path32.join(projectDir, "tsconfig.json"));
+      if (hasTSMarkers) {
+        return { command: ["npx", "tsc", "--noEmit"], language: "typescript" };
+      }
+    } catch {
       return null;
     }
-    return ["npx", "tsc", "--noEmit"];
-  } catch {
-    return null;
   }
-}
-async function runWithTimeout(command, cwd, timeoutMs) {
+  if (fs20.existsSync(path32.join(projectDir, "go.mod"))) {
+    return { command: ["go", "vet", "./..."], language: "go" };
+  }
+  if (fs20.existsSync(path32.join(projectDir, "Cargo.toml"))) {
+    return { command: ["cargo", "check"], language: "rust" };
+  }
+  if (fs20.existsSync(path32.join(projectDir, "pyproject.toml")) || fs20.existsSync(path32.join(projectDir, "requirements.txt")) || fs20.existsSync(path32.join(projectDir, "setup.py"))) {
+    return { command: null, language: "python" };
+  }
   try {
-    const proc = Bun.spawn(command, {
-      cwd,
-      stdout: "pipe",
-      stderr: "pipe"
-    });
-    const timeoutHandle = setTimeout(() => {
-      try {
-        proc.kill();
-      } catch {}
-    }, timeoutMs);
-    try {
-      const [exitCode, stderr] = await Promise.all([
-        proc.exited,
-        new Response(proc.stderr).text()
-      ]);
-      return { exitCode, stderr };
-    } finally {
-      clearTimeout(timeoutHandle);
+    const entries = fs20.readdirSync(projectDir);
+    if (entries.some((f) => f.endsWith(".csproj") || f.endsWith(".sln"))) {
+      return {
+        command: ["dotnet", "build", "--no-restore"],
+        language: "csharp"
+      };
     }
-  } catch {
+  } catch {}
+  return null;
+}
+async function runWithTimeout(command, cwd, timeoutMs) {
+  const result = await spawnAsync(command, cwd, timeoutMs);
+  if (result === null)
     return null;
-  }
+  return { exitCode: result.exitCode, stderr: result.stderr };
 }
 function createIncrementalVerifyHook(config3, projectDir, injectMessage) {
   return {
@@ -52493,10 +52636,27 @@ function createIncrementalVerifyHook(config3, projectDir, injectMessage) {
       if (!config3.triggerAgents.includes(agentName) && !config3.triggerAgents.includes(subagentType)) {
         return;
       }
-      const command = config3.command != null ? config3.command.split(" ") : detectTypecheckCommand(projectDir);
-      if (!command)
+      let commandToRun = null;
+      if (config3.command != null) {
+        commandToRun = Array.isArray(config3.command) ? config3.command : config3.command.split(" ");
+      } else {
+        const detected = detectTypecheckCommand(projectDir);
+        if (detected === null) {
+          return;
+        }
+        if (detected.command === null) {
+          const dedupKey = `${input.sessionID}:${detected.language}`;
+          if (!emittedSkipAdvisories.has(dedupKey)) {
+            emittedSkipAdvisories.add(dedupKey);
+            injectMessage(input.sessionID, `POST-CODER CHECK SKIPPED: ${detected.language} project detected but no default checker available. Set incremental_verify.command in .swarm/config.json to enable.`);
+          }
+          return;
+        }
+        commandToRun = detected.command;
+      }
+      if (commandToRun === null)
         return;
-      const result = await runWithTimeout(command, projectDir, config3.timeoutMs);
+      const result = await runWithTimeout(commandToRun, projectDir, config3.timeoutMs);
       if (result === null) {
         return;
       }
@@ -53422,6 +53582,8 @@ ${cachedInjectionText}`;
 }
 
 // src/hooks/slop-detector.ts
+import * as fs22 from "fs";
+import * as path35 from "path";
 var WRITE_EDIT_TOOLS = new Set([
   "write",
   "edit",
@@ -53432,7 +53594,7 @@ function countMatches(text, pattern) {
   return (text.match(pattern) ?? []).length;
 }
 function checkAbstractionBloat(content, threshold) {
-  const newClasses = countMatches(content, /^\+.*\bclass\s+\w+/gm);
+  const newClasses = countMatches(content, /^\+.*\b(?:class|struct|impl)\s+\w+/gm);
   if (newClasses >= threshold) {
     return {
       type: "abstraction_bloat",
@@ -53442,8 +53604,8 @@ function checkAbstractionBloat(content, threshold) {
   return null;
 }
 function checkCommentStrip(content, threshold) {
-  const removedComments = countMatches(content, /^-\s*\/[/*]/gm);
-  const addedComments = countMatches(content, /^\+\s*\/[/*]/gm);
+  const removedComments = countMatches(content, /^-\s*(?:\/[/*]|#|--)/gm);
+  const addedComments = countMatches(content, /^\+\s*(?:\/[/*]|#|--)/gm);
   if (removedComments >= threshold && addedComments === 0) {
     return {
       type: "comment_strip",
@@ -53463,8 +53625,33 @@ function checkBoilerplateExplosion(content, taskDescription, threshold) {
   }
   return null;
 }
-async function checkDeadExports(content, projectDir, startTime) {
-  const exportMatches = content.matchAll(/^(?:export)\s+(?:function|class|const|type|interface)\s+(\w{3,})/gm);
+function walkFiles(dir, exts, deadline) {
+  const results = [];
+  try {
+    for (const entry of fs22.readdirSync(dir, { withFileTypes: true })) {
+      if (deadline !== undefined && Date.now() > deadline)
+        break;
+      if (entry.isSymbolicLink())
+        continue;
+      const full = path35.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        if (entry.name === "node_modules" || entry.name === ".git")
+          continue;
+        results.push(...walkFiles(full, exts, deadline));
+      } else if (entry.isFile()) {
+        if (exts.some((ext) => entry.name.endsWith(ext))) {
+          results.push(full);
+        }
+      }
+    }
+  } catch {}
+  return results;
+}
+function checkDeadExports(content, projectDir, startTime) {
+  const hasPackageJson = fs22.existsSync(path35.join(projectDir, "package.json"));
+  if (!hasPackageJson)
+    return null;
+  const exportMatches = content.matchAll(/^\+(?:export)\s+(?:function|class|const|type|interface)\s+(\w{3,})/gm);
   const newExports = [];
   for (const match of exportMatches) {
     if (match[1])
@@ -53472,19 +53659,19 @@ async function checkDeadExports(content, projectDir, startTime) {
   }
   if (newExports.length === 0)
     return null;
+  const files = walkFiles(projectDir, [".ts", ".tsx", ".js", ".jsx"], startTime + 480);
   const deadExports = [];
   for (const name2 of newExports) {
     if (Date.now() - startTime > 480)
       break;
     try {
       const importPattern = new RegExp(`\\bimport\\b[^;]*\\b${name2}\\b`, "g");
-      const glob = new Bun.Glob(`src/**/*.ts`);
       let found = false;
-      for await (const file3 of glob.scan(projectDir)) {
+      for (const file3 of files) {
         if (found || Date.now() - startTime > 480)
           break;
         try {
-          const text = await Bun.file(`${projectDir}/${file3}`).text();
+          const text = fs22.readFileSync(file3, "utf-8");
           if (importPattern.test(text))
             found = true;
           importPattern.lastIndex = 0;
@@ -53538,7 +53725,7 @@ function createSlopDetectorHook(config3, projectDir, injectSystemMessage) {
       } catch {}
       if (Date.now() - startTime < 400) {
         try {
-          const dead = await checkDeadExports(content, projectDir, startTime);
+          const dead = checkDeadExports(content, projectDir, startTime);
           if (dead)
             findings.push(dead);
         } catch {}
@@ -53557,7 +53744,7 @@ Review before proceeding.`;
 
 // src/hooks/steering-consumed.ts
 init_utils2();
-import * as fs22 from "fs";
+import * as fs23 from "fs";
 function recordSteeringConsumed(directory, directiveId) {
   try {
     const eventsPath = validateSwarmPath(directory, "events.jsonl");
@@ -53566,7 +53753,7 @@ function recordSteeringConsumed(directory, directiveId) {
       directiveId,
       timestamp: new Date().toISOString()
     };
-    fs22.appendFileSync(eventsPath, `${JSON.stringify(event)}
+    fs23.appendFileSync(eventsPath, `${JSON.stringify(event)}
 `, "utf-8");
   } catch {}
 }
@@ -53611,7 +53798,7 @@ init_config_doctor();
 
 // src/session/snapshot-reader.ts
 init_utils2();
-import path35 from "path";
+import path36 from "path";
 var VALID_TASK_WORKFLOW_STATES = [
   "idle",
   "coder_delegated",
@@ -53736,7 +53923,7 @@ function rehydrateState(snapshot) {
 async function reconcileTaskStatesFromPlan(directory) {
   let raw;
   try {
-    raw = await Bun.file(path35.join(directory, ".swarm/plan.json")).text();
+    raw = await Bun.file(path36.join(directory, ".swarm/plan.json")).text();
   } catch {
     return;
   }
@@ -53958,8 +54145,8 @@ var build_check = createSwarmTool({
 // src/tools/check-gate-status.ts
 init_dist();
 init_create_tool();
-import * as fs23 from "fs";
-import * as path36 from "path";
+import * as fs24 from "fs";
+import * as path37 from "path";
 var EVIDENCE_DIR = ".swarm/evidence";
 var TASK_ID_PATTERN2 = /^\d+\.\d+(\.\d+)*$/;
 function isValidTaskId3(taskId) {
@@ -53976,18 +54163,18 @@ function isValidTaskId3(taskId) {
   return TASK_ID_PATTERN2.test(taskId);
 }
 function isPathWithinSwarm(filePath, workspaceRoot) {
-  const normalizedWorkspace = path36.resolve(workspaceRoot);
-  const swarmPath = path36.join(normalizedWorkspace, ".swarm", "evidence");
-  const normalizedPath = path36.resolve(filePath);
+  const normalizedWorkspace = path37.resolve(workspaceRoot);
+  const swarmPath = path37.join(normalizedWorkspace, ".swarm", "evidence");
+  const normalizedPath = path37.resolve(filePath);
   return normalizedPath.startsWith(swarmPath);
 }
 function readEvidenceFile(evidencePath) {
-  if (!fs23.existsSync(evidencePath)) {
+  if (!fs24.existsSync(evidencePath)) {
     return null;
   }
   let content;
   try {
-    content = fs23.readFileSync(evidencePath, "utf-8");
+    content = fs24.readFileSync(evidencePath, "utf-8");
   } catch {
     return null;
   }
@@ -54039,7 +54226,7 @@ var check_gate_status = createSwarmTool({
       };
       return JSON.stringify(errorResult, null, 2);
     }
-    const evidencePath = path36.join(directory, EVIDENCE_DIR, `${taskIdInput}.json`);
+    const evidencePath = path37.join(directory, EVIDENCE_DIR, `${taskIdInput}.json`);
     if (!isPathWithinSwarm(evidencePath, directory)) {
       const errorResult = {
         taskId: taskIdInput,
@@ -54099,8 +54286,8 @@ var check_gate_status = createSwarmTool({
 init_tool();
 init_create_tool();
 import { spawnSync } from "child_process";
-import * as fs24 from "fs";
-import * as path37 from "path";
+import * as fs25 from "fs";
+import * as path38 from "path";
 var CHECKPOINT_LOG_PATH = ".swarm/checkpoints.json";
 var MAX_LABEL_LENGTH = 100;
 var GIT_TIMEOUT_MS = 30000;
@@ -54151,13 +54338,13 @@ function validateLabel(label) {
   return null;
 }
 function getCheckpointLogPath(directory) {
-  return path37.join(directory, CHECKPOINT_LOG_PATH);
+  return path38.join(directory, CHECKPOINT_LOG_PATH);
 }
 function readCheckpointLog(directory) {
   const logPath = getCheckpointLogPath(directory);
   try {
-    if (fs24.existsSync(logPath)) {
-      const content = fs24.readFileSync(logPath, "utf-8");
+    if (fs25.existsSync(logPath)) {
+      const content = fs25.readFileSync(logPath, "utf-8");
       const parsed = JSON.parse(content);
       if (!parsed.checkpoints || !Array.isArray(parsed.checkpoints)) {
         return { version: 1, checkpoints: [] };
@@ -54169,13 +54356,13 @@ function readCheckpointLog(directory) {
 }
 function writeCheckpointLog(log2, directory) {
   const logPath = getCheckpointLogPath(directory);
-  const dir = path37.dirname(logPath);
-  if (!fs24.existsSync(dir)) {
-    fs24.mkdirSync(dir, { recursive: true });
+  const dir = path38.dirname(logPath);
+  if (!fs25.existsSync(dir)) {
+    fs25.mkdirSync(dir, { recursive: true });
   }
   const tempPath = `${logPath}.tmp`;
-  fs24.writeFileSync(tempPath, JSON.stringify(log2, null, 2), "utf-8");
-  fs24.renameSync(tempPath, logPath);
+  fs25.writeFileSync(tempPath, JSON.stringify(log2, null, 2), "utf-8");
+  fs25.renameSync(tempPath, logPath);
 }
 function gitExec(args2) {
   const result = spawnSync("git", args2, {
@@ -54376,8 +54563,8 @@ var checkpoint = createSwarmTool({
 // src/tools/complexity-hotspots.ts
 init_dist();
 init_create_tool();
-import * as fs25 from "fs";
-import * as path38 from "path";
+import * as fs26 from "fs";
+import * as path39 from "path";
 var MAX_FILE_SIZE_BYTES2 = 256 * 1024;
 var DEFAULT_DAYS = 90;
 var DEFAULT_TOP_N = 20;
@@ -54506,11 +54693,11 @@ function estimateComplexity(content) {
 }
 function getComplexityForFile(filePath) {
   try {
-    const stat2 = fs25.statSync(filePath);
+    const stat2 = fs26.statSync(filePath);
     if (stat2.size > MAX_FILE_SIZE_BYTES2) {
       return null;
     }
-    const content = fs25.readFileSync(filePath, "utf-8");
+    const content = fs26.readFileSync(filePath, "utf-8");
     return estimateComplexity(content);
   } catch {
     return null;
@@ -54521,7 +54708,7 @@ async function analyzeHotspots(days, topN, extensions, directory) {
   const extSet = new Set(extensions.map((e) => e.startsWith(".") ? e : `.${e}`));
   const filteredChurn = new Map;
   for (const [file3, count] of churnMap) {
-    const ext = path38.extname(file3).toLowerCase();
+    const ext = path39.extname(file3).toLowerCase();
     if (extSet.has(ext)) {
       filteredChurn.set(file3, count);
     }
@@ -54531,8 +54718,8 @@ async function analyzeHotspots(days, topN, extensions, directory) {
   let analyzedFiles = 0;
   for (const [file3, churnCount] of filteredChurn) {
     let fullPath = file3;
-    if (!fs25.existsSync(fullPath)) {
-      fullPath = path38.join(cwd, file3);
+    if (!fs26.existsSync(fullPath)) {
+      fullPath = path39.join(cwd, file3);
     }
     const complexity = getComplexityForFile(fullPath);
     if (complexity !== null) {
@@ -54679,8 +54866,8 @@ var complexity_hotspots = createSwarmTool({
 });
 // src/tools/declare-scope.ts
 init_tool();
-import * as fs26 from "fs";
-import * as path39 from "path";
+import * as fs27 from "fs";
+import * as path40 from "path";
 init_create_tool();
 function validateTaskIdFormat(taskId) {
   const taskIdPattern = /^\d+\.\d+(\.\d+)*$/;
@@ -54759,8 +54946,8 @@ async function executeDeclareScope(args2, fallbackDir) {
         };
       }
     }
-    normalizedDir = path39.normalize(args2.working_directory);
-    const pathParts = normalizedDir.split(path39.sep);
+    normalizedDir = path40.normalize(args2.working_directory);
+    const pathParts = normalizedDir.split(path40.sep);
     if (pathParts.includes("..")) {
       return {
         success: false,
@@ -54770,11 +54957,11 @@ async function executeDeclareScope(args2, fallbackDir) {
         ]
       };
     }
-    const resolvedDir = path39.resolve(normalizedDir);
+    const resolvedDir = path40.resolve(normalizedDir);
     try {
-      const realPath = fs26.realpathSync(resolvedDir);
-      const planPath2 = path39.join(realPath, ".swarm", "plan.json");
-      if (!fs26.existsSync(planPath2)) {
+      const realPath = fs27.realpathSync(resolvedDir);
+      const planPath2 = path40.join(realPath, ".swarm", "plan.json");
+      if (!fs27.existsSync(planPath2)) {
         return {
           success: false,
           message: `Invalid working_directory: plan not found in "${realPath}"`,
@@ -54794,8 +54981,8 @@ async function executeDeclareScope(args2, fallbackDir) {
     }
   }
   const directory = normalizedDir ?? fallbackDir ?? process.cwd();
-  const planPath = path39.resolve(directory, ".swarm", "plan.json");
-  if (!fs26.existsSync(planPath)) {
+  const planPath = path40.resolve(directory, ".swarm", "plan.json");
+  if (!fs27.existsSync(planPath)) {
     return {
       success: false,
       message: "No plan found",
@@ -54804,7 +54991,7 @@ async function executeDeclareScope(args2, fallbackDir) {
   }
   let planContent;
   try {
-    planContent = JSON.parse(fs26.readFileSync(planPath, "utf-8"));
+    planContent = JSON.parse(fs27.readFileSync(planPath, "utf-8"));
   } catch {
     return {
       success: false,
@@ -54884,20 +55071,20 @@ function validateBase(base) {
 function validatePaths(paths) {
   if (!paths)
     return null;
-  for (const path40 of paths) {
-    if (!path40 || path40.length === 0) {
+  for (const path41 of paths) {
+    if (!path41 || path41.length === 0) {
       return "empty path not allowed";
     }
-    if (path40.length > MAX_PATH_LENGTH) {
+    if (path41.length > MAX_PATH_LENGTH) {
       return `path exceeds maximum length of ${MAX_PATH_LENGTH}`;
     }
-    if (SHELL_METACHARACTERS2.test(path40)) {
+    if (SHELL_METACHARACTERS2.test(path41)) {
       return "path contains shell metacharacters";
     }
-    if (path40.startsWith("-")) {
+    if (path41.startsWith("-")) {
       return 'path cannot start with "-" (option-like arguments not allowed)';
     }
-    if (CONTROL_CHAR_PATTERN2.test(path40)) {
+    if (CONTROL_CHAR_PATTERN2.test(path41)) {
       return "path contains control characters";
     }
   }
@@ -54977,8 +55164,8 @@ var diff = tool({
         if (parts2.length >= 3) {
           const additions = parseInt(parts2[0], 10) || 0;
           const deletions = parseInt(parts2[1], 10) || 0;
-          const path40 = parts2[2];
-          files.push({ path: path40, additions, deletions });
+          const path41 = parts2[2];
+          files.push({ path: path41, additions, deletions });
         }
       }
       const contractChanges = [];
@@ -55207,8 +55394,8 @@ Use these as DOMAIN values when delegating to @sme.`;
 // src/tools/evidence-check.ts
 init_dist();
 init_create_tool();
-import * as fs27 from "fs";
-import * as path40 from "path";
+import * as fs28 from "fs";
+import * as path41 from "path";
 var MAX_FILE_SIZE_BYTES3 = 1024 * 1024;
 var MAX_EVIDENCE_FILES = 1000;
 var EVIDENCE_DIR2 = ".swarm/evidence";
@@ -55238,9 +55425,9 @@ function validateRequiredTypes(input) {
   return null;
 }
 function isPathWithinSwarm2(filePath, cwd) {
-  const normalizedCwd = path40.resolve(cwd);
-  const swarmPath = path40.join(normalizedCwd, ".swarm");
-  const normalizedPath = path40.resolve(filePath);
+  const normalizedCwd = path41.resolve(cwd);
+  const swarmPath = path41.join(normalizedCwd, ".swarm");
+  const normalizedPath = path41.resolve(filePath);
   return normalizedPath.startsWith(swarmPath);
 }
 function parseCompletedTasks(planContent) {
@@ -55256,12 +55443,12 @@ function parseCompletedTasks(planContent) {
 }
 function readEvidenceFiles(evidenceDir, _cwd) {
   const evidence = [];
-  if (!fs27.existsSync(evidenceDir) || !fs27.statSync(evidenceDir).isDirectory()) {
+  if (!fs28.existsSync(evidenceDir) || !fs28.statSync(evidenceDir).isDirectory()) {
     return evidence;
   }
   let files;
   try {
-    files = fs27.readdirSync(evidenceDir);
+    files = fs28.readdirSync(evidenceDir);
   } catch {
     return evidence;
   }
@@ -55270,14 +55457,14 @@ function readEvidenceFiles(evidenceDir, _cwd) {
     if (!VALID_EVIDENCE_FILENAME_REGEX.test(filename)) {
       continue;
     }
-    const filePath = path40.join(evidenceDir, filename);
+    const filePath = path41.join(evidenceDir, filename);
     try {
-      const resolvedPath = path40.resolve(filePath);
-      const evidenceDirResolved = path40.resolve(evidenceDir);
+      const resolvedPath = path41.resolve(filePath);
+      const evidenceDirResolved = path41.resolve(evidenceDir);
       if (!resolvedPath.startsWith(evidenceDirResolved)) {
         continue;
       }
-      const stat2 = fs27.lstatSync(filePath);
+      const stat2 = fs28.lstatSync(filePath);
       if (!stat2.isFile()) {
         continue;
       }
@@ -55286,7 +55473,7 @@ function readEvidenceFiles(evidenceDir, _cwd) {
     }
     let fileStat;
     try {
-      fileStat = fs27.statSync(filePath);
+      fileStat = fs28.statSync(filePath);
       if (fileStat.size > MAX_FILE_SIZE_BYTES3) {
         continue;
       }
@@ -55295,7 +55482,7 @@ function readEvidenceFiles(evidenceDir, _cwd) {
     }
     let content;
     try {
-      content = fs27.readFileSync(filePath, "utf-8");
+      content = fs28.readFileSync(filePath, "utf-8");
     } catch {
       continue;
     }
@@ -55391,7 +55578,7 @@ var evidence_check = createSwarmTool({
       return JSON.stringify(errorResult, null, 2);
     }
     const requiredTypes = requiredTypesValue.split(",").map((t) => t.trim()).filter((t) => t.length > 0).map(normalizeEvidenceType);
-    const planPath = path40.join(cwd, PLAN_FILE);
+    const planPath = path41.join(cwd, PLAN_FILE);
     if (!isPathWithinSwarm2(planPath, cwd)) {
       const errorResult = {
         error: "plan file path validation failed",
@@ -55405,7 +55592,7 @@ var evidence_check = createSwarmTool({
     }
     let planContent;
     try {
-      planContent = fs27.readFileSync(planPath, "utf-8");
+      planContent = fs28.readFileSync(planPath, "utf-8");
     } catch {
       const result2 = {
         message: "No completed tasks found in plan.",
@@ -55423,7 +55610,7 @@ var evidence_check = createSwarmTool({
       };
       return JSON.stringify(result2, null, 2);
     }
-    const evidenceDir = path40.join(cwd, EVIDENCE_DIR2);
+    const evidenceDir = path41.join(cwd, EVIDENCE_DIR2);
     const evidence = readEvidenceFiles(evidenceDir, cwd);
     const { tasksWithFullEvidence, gaps } = analyzeGaps(completedTasks, evidence, requiredTypes);
     const completeness = completedTasks.length > 0 ? Math.round(tasksWithFullEvidence.length / completedTasks.length * 100) / 100 : 1;
@@ -55440,8 +55627,8 @@ var evidence_check = createSwarmTool({
 // src/tools/file-extractor.ts
 init_tool();
 init_create_tool();
-import * as fs28 from "fs";
-import * as path41 from "path";
+import * as fs29 from "fs";
+import * as path42 from "path";
 var EXT_MAP = {
   python: ".py",
   py: ".py",
@@ -55503,8 +55690,8 @@ var extract_code_blocks = createSwarmTool({
   execute: async (args2, directory) => {
     const { content, output_dir, prefix } = args2;
     const targetDir = output_dir || directory;
-    if (!fs28.existsSync(targetDir)) {
-      fs28.mkdirSync(targetDir, { recursive: true });
+    if (!fs29.existsSync(targetDir)) {
+      fs29.mkdirSync(targetDir, { recursive: true });
     }
     if (!content) {
       return "Error: content is required";
@@ -55522,16 +55709,16 @@ var extract_code_blocks = createSwarmTool({
       if (prefix) {
         filename = `${prefix}_${filename}`;
       }
-      let filepath = path41.join(targetDir, filename);
-      const base = path41.basename(filepath, path41.extname(filepath));
-      const ext = path41.extname(filepath);
+      let filepath = path42.join(targetDir, filename);
+      const base = path42.basename(filepath, path42.extname(filepath));
+      const ext = path42.extname(filepath);
       let counter = 1;
-      while (fs28.existsSync(filepath)) {
-        filepath = path41.join(targetDir, `${base}_${counter}${ext}`);
+      while (fs29.existsSync(filepath)) {
+        filepath = path42.join(targetDir, `${base}_${counter}${ext}`);
         counter++;
       }
       try {
-        fs28.writeFileSync(filepath, code.trim(), "utf-8");
+        fs29.writeFileSync(filepath, code.trim(), "utf-8");
         savedFiles.push(filepath);
       } catch (error93) {
         errors5.push(`Failed to save ${filename}: ${error93 instanceof Error ? error93.message : String(error93)}`);
@@ -55644,8 +55831,8 @@ var gitingest = tool({
 });
 // src/tools/imports.ts
 init_dist();
-import * as fs29 from "fs";
-import * as path42 from "path";
+import * as fs30 from "fs";
+import * as path43 from "path";
 var MAX_FILE_PATH_LENGTH2 = 500;
 var MAX_SYMBOL_LENGTH = 256;
 var MAX_FILE_SIZE_BYTES4 = 1024 * 1024;
@@ -55699,7 +55886,7 @@ function validateSymbolInput(symbol3) {
   return null;
 }
 function isBinaryFile2(filePath, buffer) {
-  const ext = path42.extname(filePath).toLowerCase();
+  const ext = path43.extname(filePath).toLowerCase();
   if (ext === ".json" || ext === ".md" || ext === ".txt") {
     return false;
   }
@@ -55723,15 +55910,15 @@ function parseImports(content, targetFile, targetSymbol) {
   const imports = [];
   let _resolvedTarget;
   try {
-    _resolvedTarget = path42.resolve(targetFile);
+    _resolvedTarget = path43.resolve(targetFile);
   } catch {
     _resolvedTarget = targetFile;
   }
-  const targetBasename = path42.basename(targetFile, path42.extname(targetFile));
+  const targetBasename = path43.basename(targetFile, path43.extname(targetFile));
   const targetWithExt = targetFile;
   const targetWithoutExt = targetFile.replace(/\.(ts|tsx|js|jsx|mjs|cjs)$/i, "");
-  const normalizedTargetWithExt = path42.normalize(targetWithExt).replace(/\\/g, "/");
-  const normalizedTargetWithoutExt = path42.normalize(targetWithoutExt).replace(/\\/g, "/");
+  const normalizedTargetWithExt = path43.normalize(targetWithExt).replace(/\\/g, "/");
+  const normalizedTargetWithoutExt = path43.normalize(targetWithoutExt).replace(/\\/g, "/");
   const importRegex = /import\s+(?:\{[\s\S]*?\}|(?:\*\s+as\s+\w+)|\w+)\s+from\s+['"`]([^'"`]+)['"`]|import\s+['"`]([^'"`]+)['"`]|require\s*\(\s*['"`]([^'"`]+)['"`]\s*\)/g;
   for (let match = importRegex.exec(content);match !== null; match = importRegex.exec(content)) {
     const modulePath = match[1] || match[2] || match[3];
@@ -55754,9 +55941,9 @@ function parseImports(content, targetFile, targetSymbol) {
     }
     const _normalizedModule = modulePath.replace(/^\.\//, "").replace(/^\.\.\\/, "../");
     let isMatch = false;
-    const _targetDir = path42.dirname(targetFile);
-    const targetExt = path42.extname(targetFile);
-    const targetBasenameNoExt = path42.basename(targetFile, targetExt);
+    const _targetDir = path43.dirname(targetFile);
+    const targetExt = path43.extname(targetFile);
+    const targetBasenameNoExt = path43.basename(targetFile, targetExt);
     const moduleNormalized = modulePath.replace(/\\/g, "/").replace(/^\.\//, "");
     const moduleName = modulePath.split(/[/\\]/).pop() || "";
     const moduleNameNoExt = moduleName.replace(/\.(ts|tsx|js|jsx|mjs|cjs)$/i, "");
@@ -55813,7 +56000,7 @@ var SKIP_DIRECTORIES2 = new Set([
 function findSourceFiles(dir, files = [], stats = { skippedDirs: [], skippedFiles: 0, fileErrors: [] }) {
   let entries;
   try {
-    entries = fs29.readdirSync(dir);
+    entries = fs30.readdirSync(dir);
   } catch (e) {
     stats.fileErrors.push({
       path: dir,
@@ -55824,13 +56011,13 @@ function findSourceFiles(dir, files = [], stats = { skippedDirs: [], skippedFile
   entries.sort((a, b) => a.toLowerCase().localeCompare(b.toLowerCase()));
   for (const entry of entries) {
     if (SKIP_DIRECTORIES2.has(entry)) {
-      stats.skippedDirs.push(path42.join(dir, entry));
+      stats.skippedDirs.push(path43.join(dir, entry));
       continue;
     }
-    const fullPath = path42.join(dir, entry);
+    const fullPath = path43.join(dir, entry);
     let stat2;
     try {
-      stat2 = fs29.statSync(fullPath);
+      stat2 = fs30.statSync(fullPath);
     } catch (e) {
       stats.fileErrors.push({
         path: fullPath,
@@ -55841,7 +56028,7 @@ function findSourceFiles(dir, files = [], stats = { skippedDirs: [], skippedFile
     if (stat2.isDirectory()) {
       findSourceFiles(fullPath, files, stats);
     } else if (stat2.isFile()) {
-      const ext = path42.extname(fullPath).toLowerCase();
+      const ext = path43.extname(fullPath).toLowerCase();
       if (SUPPORTED_EXTENSIONS.includes(ext)) {
         files.push(fullPath);
       }
@@ -55897,8 +56084,8 @@ var imports = tool({
       return JSON.stringify(errorResult, null, 2);
     }
     try {
-      const targetFile = path42.resolve(file3);
-      if (!fs29.existsSync(targetFile)) {
+      const targetFile = path43.resolve(file3);
+      if (!fs30.existsSync(targetFile)) {
         const errorResult = {
           error: `target file not found: ${file3}`,
           target: file3,
@@ -55908,7 +56095,7 @@ var imports = tool({
         };
         return JSON.stringify(errorResult, null, 2);
       }
-      const targetStat = fs29.statSync(targetFile);
+      const targetStat = fs30.statSync(targetFile);
       if (!targetStat.isFile()) {
         const errorResult = {
           error: "target must be a file, not a directory",
@@ -55919,7 +56106,7 @@ var imports = tool({
         };
         return JSON.stringify(errorResult, null, 2);
       }
-      const baseDir = path42.dirname(targetFile);
+      const baseDir = path43.dirname(targetFile);
       const scanStats = {
         skippedDirs: [],
         skippedFiles: 0,
@@ -55934,12 +56121,12 @@ var imports = tool({
         if (consumers.length >= MAX_CONSUMERS)
           break;
         try {
-          const stat2 = fs29.statSync(filePath);
+          const stat2 = fs30.statSync(filePath);
           if (stat2.size > MAX_FILE_SIZE_BYTES4) {
             skippedFileCount++;
             continue;
           }
-          const buffer = fs29.readFileSync(filePath);
+          const buffer = fs30.readFileSync(filePath);
           if (isBinaryFile2(filePath, buffer)) {
             skippedFileCount++;
             continue;
@@ -56004,7 +56191,7 @@ var imports = tool({
 });
 // src/tools/knowledge-query.ts
 init_dist();
-import { existsSync as existsSync27 } from "fs";
+import { existsSync as existsSync28 } from "fs";
 init_create_tool();
 var DEFAULT_LIMIT = 10;
 var MAX_LESSON_LENGTH = 200;
@@ -56074,14 +56261,14 @@ function validateLimit(limit) {
 }
 async function readSwarmKnowledge(directory) {
   const swarmPath = resolveSwarmKnowledgePath(directory);
-  if (!existsSync27(swarmPath)) {
+  if (!existsSync28(swarmPath)) {
     return [];
   }
   return readKnowledge(swarmPath);
 }
 async function readHiveKnowledge() {
   const hivePath = resolveHiveKnowledgePath();
-  if (!existsSync27(hivePath)) {
+  if (!existsSync28(hivePath)) {
     return [];
   }
   return readKnowledge(hivePath);
@@ -56240,8 +56427,8 @@ init_dist();
 init_config();
 init_schema();
 init_manager();
-import * as fs30 from "fs";
-import * as path43 from "path";
+import * as fs31 from "fs";
+import * as path44 from "path";
 init_utils2();
 init_create_tool();
 function safeWarn(message, error93) {
@@ -56436,7 +56623,7 @@ async function executePhaseComplete(args2, workingDirectory) {
   }
   if (retroFound && retroEntry?.lessons_learned && retroEntry.lessons_learned.length > 0) {
     try {
-      const projectName = path43.basename(dir);
+      const projectName = path44.basename(dir);
       const knowledgeConfig = {
         enabled: true,
         swarm_max_entries: 100,
@@ -56484,7 +56671,7 @@ async function executePhaseComplete(args2, workingDirectory) {
   if (agentsMissing.length > 0) {
     try {
       const planPath = validateSwarmPath(dir, "plan.json");
-      const planRaw = fs30.readFileSync(planPath, "utf-8");
+      const planRaw = fs31.readFileSync(planPath, "utf-8");
       const plan = JSON.parse(planRaw);
       const targetPhase = plan.phases.find((p) => p.id === phase);
       if (targetPhase && targetPhase.tasks.length > 0 && targetPhase.tasks.every((t) => t.status === "completed")) {
@@ -56525,7 +56712,7 @@ async function executePhaseComplete(args2, workingDirectory) {
   };
   try {
     const eventsPath = validateSwarmPath(dir, "events.jsonl");
-    fs30.appendFileSync(eventsPath, `${JSON.stringify(event)}
+    fs31.appendFileSync(eventsPath, `${JSON.stringify(event)}
 `, "utf-8");
   } catch (writeError) {
     warnings.push(`Warning: failed to write phase complete event: ${writeError instanceof Error ? writeError.message : String(writeError)}`);
@@ -56544,12 +56731,12 @@ async function executePhaseComplete(args2, workingDirectory) {
     }
     try {
       const planPath = validateSwarmPath(dir, "plan.json");
-      const planJson = fs30.readFileSync(planPath, "utf-8");
+      const planJson = fs31.readFileSync(planPath, "utf-8");
       const plan = JSON.parse(planJson);
       const phaseObj = plan.phases.find((p) => p.id === phase);
       if (phaseObj) {
         phaseObj.status = "completed";
-        fs30.writeFileSync(planPath, `${JSON.stringify(plan, null, 2)}
+        fs31.writeFileSync(planPath, `${JSON.stringify(plan, null, 2)}
 `, "utf-8");
       }
     } catch (error93) {
@@ -56599,8 +56786,8 @@ init_dist();
 init_discovery();
 init_utils();
 init_create_tool();
-import * as fs31 from "fs";
-import * as path44 from "path";
+import * as fs32 from "fs";
+import * as path45 from "path";
 var MAX_OUTPUT_BYTES5 = 52428800;
 var AUDIT_TIMEOUT_MS = 120000;
 function isValidEcosystem(value) {
@@ -56618,28 +56805,28 @@ function validateArgs3(args2) {
 function detectEcosystems(directory) {
   const ecosystems = [];
   const cwd = directory;
-  if (fs31.existsSync(path44.join(cwd, "package.json"))) {
+  if (fs32.existsSync(path45.join(cwd, "package.json"))) {
     ecosystems.push("npm");
   }
-  if (fs31.existsSync(path44.join(cwd, "pyproject.toml")) || fs31.existsSync(path44.join(cwd, "requirements.txt"))) {
+  if (fs32.existsSync(path45.join(cwd, "pyproject.toml")) || fs32.existsSync(path45.join(cwd, "requirements.txt"))) {
     ecosystems.push("pip");
   }
-  if (fs31.existsSync(path44.join(cwd, "Cargo.toml"))) {
+  if (fs32.existsSync(path45.join(cwd, "Cargo.toml"))) {
     ecosystems.push("cargo");
   }
-  if (fs31.existsSync(path44.join(cwd, "go.mod"))) {
+  if (fs32.existsSync(path45.join(cwd, "go.mod"))) {
     ecosystems.push("go");
   }
   try {
-    const files = fs31.readdirSync(cwd);
+    const files = fs32.readdirSync(cwd);
     if (files.some((f) => f.endsWith(".csproj") || f.endsWith(".sln"))) {
       ecosystems.push("dotnet");
     }
   } catch {}
-  if (fs31.existsSync(path44.join(cwd, "Gemfile")) || fs31.existsSync(path44.join(cwd, "Gemfile.lock"))) {
+  if (fs32.existsSync(path45.join(cwd, "Gemfile")) || fs32.existsSync(path45.join(cwd, "Gemfile.lock"))) {
     ecosystems.push("ruby");
   }
-  if (fs31.existsSync(path44.join(cwd, "pubspec.yaml"))) {
+  if (fs32.existsSync(path45.join(cwd, "pubspec.yaml"))) {
     ecosystems.push("dart");
   }
   return ecosystems;
@@ -57701,8 +57888,8 @@ var SUPPORTED_PARSER_EXTENSIONS = new Set([
 ]);
 // src/tools/pre-check-batch.ts
 init_dist();
-import * as fs34 from "fs";
-import * as path47 from "path";
+import * as fs35 from "fs";
+import * as path48 from "path";
 
 // node_modules/yocto-queue/index.js
 class Node2 {
@@ -57869,8 +58056,8 @@ init_lint();
 init_manager();
 
 // src/quality/metrics.ts
-import * as fs32 from "fs";
-import * as path45 from "path";
+import * as fs33 from "fs";
+import * as path46 from "path";
 var MAX_FILE_SIZE_BYTES5 = 256 * 1024;
 var MIN_DUPLICATION_LINES = 10;
 function estimateCyclomaticComplexity(content) {
@@ -57908,11 +58095,11 @@ function estimateCyclomaticComplexity(content) {
 }
 function getComplexityForFile2(filePath) {
   try {
-    const stat2 = fs32.statSync(filePath);
+    const stat2 = fs33.statSync(filePath);
     if (stat2.size > MAX_FILE_SIZE_BYTES5) {
       return null;
     }
-    const content = fs32.readFileSync(filePath, "utf-8");
+    const content = fs33.readFileSync(filePath, "utf-8");
     return estimateCyclomaticComplexity(content);
   } catch {
     return null;
@@ -57922,8 +58109,8 @@ async function computeComplexityDelta(files, workingDir) {
   let totalComplexity = 0;
   const analyzedFiles = [];
   for (const file3 of files) {
-    const fullPath = path45.isAbsolute(file3) ? file3 : path45.join(workingDir, file3);
-    if (!fs32.existsSync(fullPath)) {
+    const fullPath = path46.isAbsolute(file3) ? file3 : path46.join(workingDir, file3);
+    if (!fs33.existsSync(fullPath)) {
       continue;
     }
     const complexity = getComplexityForFile2(fullPath);
@@ -58044,8 +58231,8 @@ function countGoExports(content) {
 }
 function getExportCountForFile(filePath) {
   try {
-    const content = fs32.readFileSync(filePath, "utf-8");
-    const ext = path45.extname(filePath).toLowerCase();
+    const content = fs33.readFileSync(filePath, "utf-8");
+    const ext = path46.extname(filePath).toLowerCase();
     switch (ext) {
       case ".ts":
       case ".tsx":
@@ -58071,8 +58258,8 @@ async function computePublicApiDelta(files, workingDir) {
   let totalExports = 0;
   const analyzedFiles = [];
   for (const file3 of files) {
-    const fullPath = path45.isAbsolute(file3) ? file3 : path45.join(workingDir, file3);
-    if (!fs32.existsSync(fullPath)) {
+    const fullPath = path46.isAbsolute(file3) ? file3 : path46.join(workingDir, file3);
+    if (!fs33.existsSync(fullPath)) {
       continue;
     }
     const exports = getExportCountForFile(fullPath);
@@ -58105,16 +58292,16 @@ async function computeDuplicationRatio(files, workingDir) {
   let duplicateLines = 0;
   const analyzedFiles = [];
   for (const file3 of files) {
-    const fullPath = path45.isAbsolute(file3) ? file3 : path45.join(workingDir, file3);
-    if (!fs32.existsSync(fullPath)) {
+    const fullPath = path46.isAbsolute(file3) ? file3 : path46.join(workingDir, file3);
+    if (!fs33.existsSync(fullPath)) {
       continue;
     }
     try {
-      const stat2 = fs32.statSync(fullPath);
+      const stat2 = fs33.statSync(fullPath);
       if (stat2.size > MAX_FILE_SIZE_BYTES5) {
         continue;
       }
-      const content = fs32.readFileSync(fullPath, "utf-8");
+      const content = fs33.readFileSync(fullPath, "utf-8");
       const lines = content.split(`
 `).filter((line) => line.trim().length > 0);
       if (lines.length < MIN_DUPLICATION_LINES) {
@@ -58138,8 +58325,8 @@ function countCodeLines(content) {
   return lines.length;
 }
 function isTestFile(filePath) {
-  const basename8 = path45.basename(filePath);
-  const _ext = path45.extname(filePath).toLowerCase();
+  const basename8 = path46.basename(filePath);
+  const _ext = path46.extname(filePath).toLowerCase();
   const testPatterns = [
     ".test.",
     ".spec.",
@@ -58220,8 +58407,8 @@ function matchGlobSegment(globSegments, pathSegments) {
   }
   return gIndex === globSegments.length && pIndex === pathSegments.length;
 }
-function matchesGlobSegment(path46, glob) {
-  const normalizedPath = path46.replace(/\\/g, "/");
+function matchesGlobSegment(path47, glob) {
+  const normalizedPath = path47.replace(/\\/g, "/");
   const normalizedGlob = glob.replace(/\\/g, "/");
   if (normalizedPath.includes("//")) {
     return false;
@@ -58252,8 +58439,8 @@ function simpleGlobToRegex2(glob) {
 function hasGlobstar(glob) {
   return glob.includes("**");
 }
-function globMatches(path46, glob) {
-  const normalizedPath = path46.replace(/\\/g, "/");
+function globMatches(path47, glob) {
+  const normalizedPath = path47.replace(/\\/g, "/");
   if (!glob || glob === "") {
     if (normalizedPath.includes("//")) {
       return false;
@@ -58289,31 +58476,31 @@ function shouldExcludeFile(filePath, excludeGlobs) {
 async function computeTestToCodeRatio(workingDir, enforceGlobs, excludeGlobs) {
   let testLines = 0;
   let codeLines = 0;
-  const srcDir = path45.join(workingDir, "src");
-  if (fs32.existsSync(srcDir)) {
+  const srcDir = path46.join(workingDir, "src");
+  if (fs33.existsSync(srcDir)) {
     await scanDirectoryForLines(srcDir, enforceGlobs, excludeGlobs, false, (lines) => {
       codeLines += lines;
     });
   }
   const possibleSrcDirs = ["lib", "app", "source", "core"];
   for (const dir of possibleSrcDirs) {
-    const dirPath = path45.join(workingDir, dir);
-    if (fs32.existsSync(dirPath)) {
+    const dirPath = path46.join(workingDir, dir);
+    if (fs33.existsSync(dirPath)) {
       await scanDirectoryForLines(dirPath, enforceGlobs, excludeGlobs, false, (lines) => {
         codeLines += lines;
       });
     }
   }
-  const testsDir = path45.join(workingDir, "tests");
-  if (fs32.existsSync(testsDir)) {
+  const testsDir = path46.join(workingDir, "tests");
+  if (fs33.existsSync(testsDir)) {
     await scanDirectoryForLines(testsDir, ["**"], ["node_modules", "dist"], true, (lines) => {
       testLines += lines;
     });
   }
   const possibleTestDirs = ["test", "__tests__", "specs"];
   for (const dir of possibleTestDirs) {
-    const dirPath = path45.join(workingDir, dir);
-    if (fs32.existsSync(dirPath) && dirPath !== testsDir) {
+    const dirPath = path46.join(workingDir, dir);
+    if (fs33.existsSync(dirPath) && dirPath !== testsDir) {
       await scanDirectoryForLines(dirPath, ["**"], ["node_modules", "dist"], true, (lines) => {
         testLines += lines;
       });
@@ -58325,9 +58512,9 @@ async function computeTestToCodeRatio(workingDir, enforceGlobs, excludeGlobs) {
 }
 async function scanDirectoryForLines(dirPath, includeGlobs, excludeGlobs, isTestScan, callback) {
   try {
-    const entries = fs32.readdirSync(dirPath, { withFileTypes: true });
+    const entries = fs33.readdirSync(dirPath, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = path45.join(dirPath, entry.name);
+      const fullPath = path46.join(dirPath, entry.name);
       if (entry.isDirectory()) {
         if (entry.name === "node_modules" || entry.name === "dist" || entry.name === "build" || entry.name === ".git") {
           continue;
@@ -58335,7 +58522,7 @@ async function scanDirectoryForLines(dirPath, includeGlobs, excludeGlobs, isTest
         await scanDirectoryForLines(fullPath, includeGlobs, excludeGlobs, isTestScan, callback);
       } else if (entry.isFile()) {
         const relativePath = fullPath.replace(`${process.cwd()}/`, "");
-        const ext = path45.extname(entry.name).toLowerCase();
+        const ext = path46.extname(entry.name).toLowerCase();
         const validExts = [
           ".ts",
           ".tsx",
@@ -58371,7 +58558,7 @@ async function scanDirectoryForLines(dirPath, includeGlobs, excludeGlobs, isTest
             continue;
         }
         try {
-          const content = fs32.readFileSync(fullPath, "utf-8");
+          const content = fs33.readFileSync(fullPath, "utf-8");
           const lines = countCodeLines(content);
           callback(lines);
         } catch {}
@@ -58585,8 +58772,8 @@ async function qualityBudget(input, directory) {
 init_dist();
 init_manager();
 init_detector();
-import * as fs33 from "fs";
-import * as path46 from "path";
+import * as fs34 from "fs";
+import * as path47 from "path";
 import { extname as extname9 } from "path";
 
 // src/sast/rules/c.ts
@@ -59270,7 +59457,7 @@ function executeRulesSync(filePath, content, language) {
 }
 
 // src/sast/semgrep.ts
-import { execFile as execFile2, execFileSync as execFileSync2, spawn } from "child_process";
+import { execFile as execFile2, execFileSync as execFileSync2, spawn as spawn2 } from "child_process";
 import { promisify as promisify2 } from "util";
 var _execFileAsync = promisify2(execFile2);
 var semgrepAvailableCache = null;
@@ -59335,7 +59522,7 @@ function mapSemgrepSeverity(severity) {
 }
 async function executeWithTimeout(command, args2, options) {
   return new Promise((resolve15) => {
-    const child = spawn(command, args2, {
+    const child = spawn2(command, args2, {
       shell: false,
       cwd: options.cwd
     });
@@ -59453,17 +59640,17 @@ var SEVERITY_ORDER = {
 };
 function shouldSkipFile(filePath) {
   try {
-    const stats = fs33.statSync(filePath);
+    const stats = fs34.statSync(filePath);
     if (stats.size > MAX_FILE_SIZE_BYTES6) {
       return { skip: true, reason: "file too large" };
     }
     if (stats.size === 0) {
       return { skip: true, reason: "empty file" };
     }
-    const fd = fs33.openSync(filePath, "r");
+    const fd = fs34.openSync(filePath, "r");
     const buffer = Buffer.alloc(8192);
-    const bytesRead = fs33.readSync(fd, buffer, 0, 8192, 0);
-    fs33.closeSync(fd);
+    const bytesRead = fs34.readSync(fd, buffer, 0, 8192, 0);
+    fs34.closeSync(fd);
     if (bytesRead > 0) {
       let nullCount = 0;
       for (let i2 = 0;i2 < bytesRead; i2++) {
@@ -59502,7 +59689,7 @@ function countBySeverity(findings) {
 }
 function scanFileWithTierA(filePath, language) {
   try {
-    const content = fs33.readFileSync(filePath, "utf-8");
+    const content = fs34.readFileSync(filePath, "utf-8");
     const findings = executeRulesSync(filePath, content, language);
     return findings.map((f) => ({
       rule_id: f.rule_id,
@@ -59549,8 +59736,8 @@ async function sastScan(input, directory, config3) {
       _filesSkipped++;
       continue;
     }
-    const resolvedPath = path46.isAbsolute(filePath) ? filePath : path46.resolve(directory, filePath);
-    if (!fs33.existsSync(resolvedPath)) {
+    const resolvedPath = path47.isAbsolute(filePath) ? filePath : path47.resolve(directory, filePath);
+    if (!fs34.existsSync(resolvedPath)) {
       _filesSkipped++;
       continue;
     }
@@ -59748,18 +59935,18 @@ function validatePath(inputPath, baseDir, workspaceDir) {
   let resolved;
   const isWinAbs = isWindowsAbsolutePath(inputPath);
   if (isWinAbs) {
-    resolved = path47.win32.resolve(inputPath);
-  } else if (path47.isAbsolute(inputPath)) {
-    resolved = path47.resolve(inputPath);
+    resolved = path48.win32.resolve(inputPath);
+  } else if (path48.isAbsolute(inputPath)) {
+    resolved = path48.resolve(inputPath);
   } else {
-    resolved = path47.resolve(baseDir, inputPath);
+    resolved = path48.resolve(baseDir, inputPath);
   }
-  const workspaceResolved = path47.resolve(workspaceDir);
+  const workspaceResolved = path48.resolve(workspaceDir);
   let relative5;
   if (isWinAbs) {
-    relative5 = path47.win32.relative(workspaceResolved, resolved);
+    relative5 = path48.win32.relative(workspaceResolved, resolved);
   } else {
-    relative5 = path47.relative(workspaceResolved, resolved);
+    relative5 = path48.relative(workspaceResolved, resolved);
   }
   if (relative5.startsWith("..")) {
     return "path traversal detected";
@@ -59820,13 +60007,13 @@ async function runLintWrapped(files, directory, _config) {
 }
 async function runLintOnFiles(linter, files, workspaceDir) {
   const isWindows = process.platform === "win32";
-  const binDir = path47.join(workspaceDir, "node_modules", ".bin");
+  const binDir = path48.join(workspaceDir, "node_modules", ".bin");
   const validatedFiles = [];
   for (const file3 of files) {
     if (typeof file3 !== "string") {
       continue;
     }
-    const resolvedPath = path47.resolve(file3);
+    const resolvedPath = path48.resolve(file3);
     const validationError = validatePath(resolvedPath, workspaceDir, workspaceDir);
     if (validationError) {
       continue;
@@ -59844,10 +60031,10 @@ async function runLintOnFiles(linter, files, workspaceDir) {
   }
   let command;
   if (linter === "biome") {
-    const biomeBin = isWindows ? path47.join(binDir, "biome.EXE") : path47.join(binDir, "biome");
+    const biomeBin = isWindows ? path48.join(binDir, "biome.EXE") : path48.join(binDir, "biome");
     command = [biomeBin, "check", ...validatedFiles];
   } else {
-    const eslintBin = isWindows ? path47.join(binDir, "eslint.cmd") : path47.join(binDir, "eslint");
+    const eslintBin = isWindows ? path48.join(binDir, "eslint.cmd") : path48.join(binDir, "eslint");
     command = [eslintBin, ...validatedFiles];
   }
   try {
@@ -59984,7 +60171,7 @@ async function runSecretscanWithFiles(files, directory) {
         skippedFiles++;
         continue;
       }
-      const resolvedPath = path47.resolve(file3);
+      const resolvedPath = path48.resolve(file3);
       const validationError = validatePath(resolvedPath, directory, directory);
       if (validationError) {
         skippedFiles++;
@@ -60002,14 +60189,14 @@ async function runSecretscanWithFiles(files, directory) {
       };
     }
     for (const file3 of validatedFiles) {
-      const ext = path47.extname(file3).toLowerCase();
+      const ext = path48.extname(file3).toLowerCase();
       if (DEFAULT_EXCLUDE_EXTENSIONS2.has(ext)) {
         skippedFiles++;
         continue;
       }
       let stat2;
       try {
-        stat2 = fs34.statSync(file3);
+        stat2 = fs35.statSync(file3);
       } catch {
         skippedFiles++;
         continue;
@@ -60020,7 +60207,7 @@ async function runSecretscanWithFiles(files, directory) {
       }
       let content;
       try {
-        const buffer = fs34.readFileSync(file3);
+        const buffer = fs35.readFileSync(file3);
         if (buffer.includes(0)) {
           skippedFiles++;
           continue;
@@ -60161,7 +60348,7 @@ async function runPreCheckBatch(input, workspaceDir) {
       warn(`pre_check_batch: Invalid file path: ${file3}`);
       continue;
     }
-    changedFiles.push(path47.resolve(directory, file3));
+    changedFiles.push(path48.resolve(directory, file3));
   }
   if (changedFiles.length === 0) {
     warn("pre_check_batch: No valid files after validation, skipping all tools (fail-closed)");
@@ -60312,7 +60499,7 @@ var pre_check_batch = createSwarmTool({
       };
       return JSON.stringify(errorResult, null, 2);
     }
-    const resolvedDirectory = path47.resolve(typedArgs.directory);
+    const resolvedDirectory = path48.resolve(typedArgs.directory);
     const workspaceAnchor = resolvedDirectory;
     const dirError = validateDirectory3(resolvedDirectory, workspaceAnchor);
     if (dirError) {
@@ -60419,8 +60606,8 @@ ${paginatedContent}`;
 init_tool();
 init_manager2();
 init_create_tool();
-import * as fs35 from "fs";
-import * as path48 from "path";
+import * as fs36 from "fs";
+import * as path49 from "path";
 function detectPlaceholderContent(args2) {
   const issues = [];
   const placeholderPattern = /^\[\w[\w\s]*\]$/;
@@ -60524,19 +60711,19 @@ async function executeSavePlan(args2, fallbackDir) {
   try {
     await savePlan(dir, plan);
     try {
-      const markerPath = path48.join(dir, ".swarm", ".plan-write-marker");
+      const markerPath = path49.join(dir, ".swarm", ".plan-write-marker");
       const marker = JSON.stringify({
         source: "save_plan",
         timestamp: new Date().toISOString(),
         phases_count: plan.phases.length,
         tasks_count: tasksCount
       });
-      await fs35.promises.writeFile(markerPath, marker, "utf8");
+      await fs36.promises.writeFile(markerPath, marker, "utf8");
     } catch {}
     return {
       success: true,
       message: "Plan saved successfully",
-      plan_path: path48.join(dir, ".swarm", "plan.json"),
+      plan_path: path49.join(dir, ".swarm", "plan.json"),
       phases_count: plan.phases.length,
       tasks_count: tasksCount
     };
@@ -60574,8 +60761,8 @@ var save_plan = createSwarmTool({
 // src/tools/sbom-generate.ts
 init_dist();
 init_manager();
-import * as fs36 from "fs";
-import * as path49 from "path";
+import * as fs37 from "fs";
+import * as path50 from "path";
 
 // src/sbom/detectors/index.ts
 init_utils();
@@ -61421,9 +61608,9 @@ function findManifestFiles(rootDir) {
   const patterns = [...new Set(allDetectors.flatMap((d) => d.patterns))];
   function searchDir(dir) {
     try {
-      const entries = fs36.readdirSync(dir, { withFileTypes: true });
+      const entries = fs37.readdirSync(dir, { withFileTypes: true });
       for (const entry of entries) {
-        const fullPath = path49.join(dir, entry.name);
+        const fullPath = path50.join(dir, entry.name);
         if (entry.name.startsWith(".") || entry.name === "node_modules" || entry.name === "dist" || entry.name === "build" || entry.name === "target") {
           continue;
         }
@@ -61432,7 +61619,7 @@ function findManifestFiles(rootDir) {
         } else if (entry.isFile()) {
           for (const pattern of patterns) {
             if (simpleGlobToRegex(pattern).test(entry.name)) {
-              manifestFiles.push(path49.relative(rootDir, fullPath));
+              manifestFiles.push(path50.relative(rootDir, fullPath));
               break;
             }
           }
@@ -61448,13 +61635,13 @@ function findManifestFilesInDirs(directories, workingDir) {
   const patterns = [...new Set(allDetectors.flatMap((d) => d.patterns))];
   for (const dir of directories) {
     try {
-      const entries = fs36.readdirSync(dir, { withFileTypes: true });
+      const entries = fs37.readdirSync(dir, { withFileTypes: true });
       for (const entry of entries) {
-        const fullPath = path49.join(dir, entry.name);
+        const fullPath = path50.join(dir, entry.name);
         if (entry.isFile()) {
           for (const pattern of patterns) {
             if (simpleGlobToRegex(pattern).test(entry.name)) {
-              found.push(path49.relative(workingDir, fullPath));
+              found.push(path50.relative(workingDir, fullPath));
               break;
             }
           }
@@ -61467,11 +61654,11 @@ function findManifestFilesInDirs(directories, workingDir) {
 function getDirectoriesFromChangedFiles(changedFiles, workingDir) {
   const dirs = new Set;
   for (const file3 of changedFiles) {
-    let currentDir = path49.dirname(file3);
+    let currentDir = path50.dirname(file3);
     while (true) {
-      if (currentDir && currentDir !== "." && currentDir !== path49.sep) {
-        dirs.add(path49.join(workingDir, currentDir));
-        const parent = path49.dirname(currentDir);
+      if (currentDir && currentDir !== "." && currentDir !== path50.sep) {
+        dirs.add(path50.join(workingDir, currentDir));
+        const parent = path50.dirname(currentDir);
         if (parent === currentDir)
           break;
         currentDir = parent;
@@ -61485,7 +61672,7 @@ function getDirectoriesFromChangedFiles(changedFiles, workingDir) {
 }
 function ensureOutputDir(outputDir) {
   try {
-    fs36.mkdirSync(outputDir, { recursive: true });
+    fs37.mkdirSync(outputDir, { recursive: true });
   } catch (error93) {
     if (!error93 || error93.code !== "EEXIST") {
       throw error93;
@@ -61555,7 +61742,7 @@ var sbom_generate = createSwarmTool({
     const changedFiles = obj.changed_files;
     const relativeOutputDir = obj.output_dir || DEFAULT_OUTPUT_DIR;
     const workingDir = directory;
-    const outputDir = path49.isAbsolute(relativeOutputDir) ? relativeOutputDir : path49.join(workingDir, relativeOutputDir);
+    const outputDir = path50.isAbsolute(relativeOutputDir) ? relativeOutputDir : path50.join(workingDir, relativeOutputDir);
     let manifestFiles = [];
     if (scope === "all") {
       manifestFiles = findManifestFiles(workingDir);
@@ -61578,11 +61765,11 @@ var sbom_generate = createSwarmTool({
     const processedFiles = [];
     for (const manifestFile of manifestFiles) {
       try {
-        const fullPath = path49.isAbsolute(manifestFile) ? manifestFile : path49.join(workingDir, manifestFile);
-        if (!fs36.existsSync(fullPath)) {
+        const fullPath = path50.isAbsolute(manifestFile) ? manifestFile : path50.join(workingDir, manifestFile);
+        if (!fs37.existsSync(fullPath)) {
           continue;
         }
-        const content = fs36.readFileSync(fullPath, "utf-8");
+        const content = fs37.readFileSync(fullPath, "utf-8");
         const components = detectComponents(manifestFile, content);
         processedFiles.push(manifestFile);
         if (components.length > 0) {
@@ -61595,8 +61782,8 @@ var sbom_generate = createSwarmTool({
     const bom = generateCycloneDX(allComponents);
     const bomJson = serializeCycloneDX(bom);
     const filename = generateSbomFilename();
-    const outputPath = path49.join(outputDir, filename);
-    fs36.writeFileSync(outputPath, bomJson, "utf-8");
+    const outputPath = path50.join(outputDir, filename);
+    fs37.writeFileSync(outputPath, bomJson, "utf-8");
     const verdict = processedFiles.length > 0 ? "pass" : "pass";
     try {
       const timestamp = new Date().toISOString();
@@ -61638,8 +61825,8 @@ var sbom_generate = createSwarmTool({
 // src/tools/schema-drift.ts
 init_dist();
 init_create_tool();
-import * as fs37 from "fs";
-import * as path50 from "path";
+import * as fs38 from "fs";
+import * as path51 from "path";
 var SPEC_CANDIDATES = [
   "openapi.json",
   "openapi.yaml",
@@ -61671,28 +61858,28 @@ function normalizePath2(p) {
 }
 function discoverSpecFile(cwd, specFileArg) {
   if (specFileArg) {
-    const resolvedPath = path50.resolve(cwd, specFileArg);
-    const normalizedCwd = cwd.endsWith(path50.sep) ? cwd : cwd + path50.sep;
+    const resolvedPath = path51.resolve(cwd, specFileArg);
+    const normalizedCwd = cwd.endsWith(path51.sep) ? cwd : cwd + path51.sep;
     if (!resolvedPath.startsWith(normalizedCwd) && resolvedPath !== cwd) {
       throw new Error("Invalid spec_file: path traversal detected");
     }
-    const ext = path50.extname(resolvedPath).toLowerCase();
+    const ext = path51.extname(resolvedPath).toLowerCase();
     if (!ALLOWED_EXTENSIONS.includes(ext)) {
       throw new Error(`Invalid spec_file: must end in .json, .yaml, or .yml, got ${ext}`);
     }
-    const stats = fs37.statSync(resolvedPath);
+    const stats = fs38.statSync(resolvedPath);
     if (stats.size > MAX_SPEC_SIZE) {
       throw new Error(`Invalid spec_file: file exceeds ${MAX_SPEC_SIZE / 1024 / 1024}MB limit`);
     }
-    if (!fs37.existsSync(resolvedPath)) {
+    if (!fs38.existsSync(resolvedPath)) {
       throw new Error(`Spec file not found: ${resolvedPath}`);
     }
     return resolvedPath;
   }
   for (const candidate of SPEC_CANDIDATES) {
-    const candidatePath = path50.resolve(cwd, candidate);
-    if (fs37.existsSync(candidatePath)) {
-      const stats = fs37.statSync(candidatePath);
+    const candidatePath = path51.resolve(cwd, candidate);
+    if (fs38.existsSync(candidatePath)) {
+      const stats = fs38.statSync(candidatePath);
       if (stats.size <= MAX_SPEC_SIZE) {
         return candidatePath;
       }
@@ -61701,8 +61888,8 @@ function discoverSpecFile(cwd, specFileArg) {
   return null;
 }
 function parseSpec(specFile) {
-  const content = fs37.readFileSync(specFile, "utf-8");
-  const ext = path50.extname(specFile).toLowerCase();
+  const content = fs38.readFileSync(specFile, "utf-8");
+  const ext = path51.extname(specFile).toLowerCase();
   if (ext === ".json") {
     return parseJsonSpec(content);
   }
@@ -61773,12 +61960,12 @@ function extractRoutes(cwd) {
   function walkDir(dir) {
     let entries;
     try {
-      entries = fs37.readdirSync(dir, { withFileTypes: true });
+      entries = fs38.readdirSync(dir, { withFileTypes: true });
     } catch {
       return;
     }
     for (const entry of entries) {
-      const fullPath = path50.join(dir, entry.name);
+      const fullPath = path51.join(dir, entry.name);
       if (entry.isSymbolicLink()) {
         continue;
       }
@@ -61788,7 +61975,7 @@ function extractRoutes(cwd) {
         }
         walkDir(fullPath);
       } else if (entry.isFile()) {
-        const ext = path50.extname(entry.name).toLowerCase();
+        const ext = path51.extname(entry.name).toLowerCase();
         const baseName = entry.name.toLowerCase();
         if (![".ts", ".js", ".mjs"].includes(ext)) {
           continue;
@@ -61806,7 +61993,7 @@ function extractRoutes(cwd) {
 }
 function extractRoutesFromFile(filePath) {
   const routes = [];
-  const content = fs37.readFileSync(filePath, "utf-8");
+  const content = fs38.readFileSync(filePath, "utf-8");
   const lines = content.split(/\r?\n/);
   const expressRegex = /(?:app|router|server|express)\.(get|post|put|patch|delete|options|head)\s*\(\s*['"`]([^'"`]+)['"`]/g;
   const flaskRegex = /@(?:app|blueprint|bp)\.route\s*\(\s*['"]([^'"]+)['"]/g;
@@ -61957,8 +62144,8 @@ init_secretscan();
 // src/tools/symbols.ts
 init_tool();
 init_create_tool();
-import * as fs38 from "fs";
-import * as path51 from "path";
+import * as fs39 from "fs";
+import * as path52 from "path";
 var MAX_FILE_SIZE_BYTES7 = 1024 * 1024;
 var WINDOWS_RESERVED_NAMES = /^(con|prn|aux|nul|com[1-9]|lpt[1-9])(\.|:|$)/i;
 function containsControlCharacters(str) {
@@ -61987,11 +62174,11 @@ function containsWindowsAttacks(str) {
 }
 function isPathInWorkspace(filePath, workspace) {
   try {
-    const resolvedPath = path51.resolve(workspace, filePath);
-    const realWorkspace = fs38.realpathSync(workspace);
-    const realResolvedPath = fs38.realpathSync(resolvedPath);
-    const relativePath = path51.relative(realWorkspace, realResolvedPath);
-    if (relativePath.startsWith("..") || path51.isAbsolute(relativePath)) {
+    const resolvedPath = path52.resolve(workspace, filePath);
+    const realWorkspace = fs39.realpathSync(workspace);
+    const realResolvedPath = fs39.realpathSync(resolvedPath);
+    const relativePath = path52.relative(realWorkspace, realResolvedPath);
+    if (relativePath.startsWith("..") || path52.isAbsolute(relativePath)) {
       return false;
     }
     return true;
@@ -62003,17 +62190,17 @@ function validatePathForRead(filePath, workspace) {
   return isPathInWorkspace(filePath, workspace);
 }
 function extractTSSymbols(filePath, cwd) {
-  const fullPath = path51.join(cwd, filePath);
+  const fullPath = path52.join(cwd, filePath);
   if (!validatePathForRead(fullPath, cwd)) {
     return [];
   }
   let content;
   try {
-    const stats = fs38.statSync(fullPath);
+    const stats = fs39.statSync(fullPath);
     if (stats.size > MAX_FILE_SIZE_BYTES7) {
       throw new Error(`File too large: ${stats.size} bytes (max: ${MAX_FILE_SIZE_BYTES7})`);
     }
-    content = fs38.readFileSync(fullPath, "utf-8");
+    content = fs39.readFileSync(fullPath, "utf-8");
   } catch {
     return [];
   }
@@ -62155,17 +62342,17 @@ function extractTSSymbols(filePath, cwd) {
   });
 }
 function extractPythonSymbols(filePath, cwd) {
-  const fullPath = path51.join(cwd, filePath);
+  const fullPath = path52.join(cwd, filePath);
   if (!validatePathForRead(fullPath, cwd)) {
     return [];
   }
   let content;
   try {
-    const stats = fs38.statSync(fullPath);
+    const stats = fs39.statSync(fullPath);
     if (stats.size > MAX_FILE_SIZE_BYTES7) {
       throw new Error(`File too large: ${stats.size} bytes (max: ${MAX_FILE_SIZE_BYTES7})`);
     }
-    content = fs38.readFileSync(fullPath, "utf-8");
+    content = fs39.readFileSync(fullPath, "utf-8");
   } catch {
     return [];
   }
@@ -62238,7 +62425,7 @@ var symbols = createSwarmTool({
       }, null, 2);
     }
     const cwd = directory;
-    const ext = path51.extname(file3);
+    const ext = path52.extname(file3);
     if (containsControlCharacters(file3)) {
       return JSON.stringify({
         file: file3,
@@ -62309,8 +62496,8 @@ init_test_runner();
 init_dist();
 init_utils();
 init_create_tool();
-import * as fs39 from "fs";
-import * as path52 from "path";
+import * as fs40 from "fs";
+import * as path53 from "path";
 var MAX_TEXT_LENGTH = 200;
 var MAX_FILE_SIZE_BYTES8 = 1024 * 1024;
 var SUPPORTED_EXTENSIONS2 = new Set([
@@ -62381,9 +62568,9 @@ function validatePathsInput(paths, cwd) {
     return { error: "paths contains path traversal", resolvedPath: null };
   }
   try {
-    const resolvedPath = path52.resolve(paths);
-    const normalizedCwd = path52.resolve(cwd);
-    const normalizedResolved = path52.resolve(resolvedPath);
+    const resolvedPath = path53.resolve(paths);
+    const normalizedCwd = path53.resolve(cwd);
+    const normalizedResolved = path53.resolve(resolvedPath);
     if (!normalizedResolved.startsWith(normalizedCwd)) {
       return {
         error: "paths must be within the current working directory",
@@ -62399,13 +62586,13 @@ function validatePathsInput(paths, cwd) {
   }
 }
 function isSupportedExtension(filePath) {
-  const ext = path52.extname(filePath).toLowerCase();
+  const ext = path53.extname(filePath).toLowerCase();
   return SUPPORTED_EXTENSIONS2.has(ext);
 }
 function findSourceFiles2(dir, files = []) {
   let entries;
   try {
-    entries = fs39.readdirSync(dir);
+    entries = fs40.readdirSync(dir);
   } catch {
     return files;
   }
@@ -62414,10 +62601,10 @@ function findSourceFiles2(dir, files = []) {
     if (SKIP_DIRECTORIES3.has(entry)) {
       continue;
     }
-    const fullPath = path52.join(dir, entry);
+    const fullPath = path53.join(dir, entry);
     let stat2;
     try {
-      stat2 = fs39.statSync(fullPath);
+      stat2 = fs40.statSync(fullPath);
     } catch {
       continue;
     }
@@ -62510,7 +62697,7 @@ var todo_extract = createSwarmTool({
       return JSON.stringify(errorResult, null, 2);
     }
     const scanPath = resolvedPath;
-    if (!fs39.existsSync(scanPath)) {
+    if (!fs40.existsSync(scanPath)) {
       const errorResult = {
         error: `path not found: ${pathsInput}`,
         total: 0,
@@ -62520,13 +62707,13 @@ var todo_extract = createSwarmTool({
       return JSON.stringify(errorResult, null, 2);
     }
     const filesToScan = [];
-    const stat2 = fs39.statSync(scanPath);
+    const stat2 = fs40.statSync(scanPath);
     if (stat2.isFile()) {
       if (isSupportedExtension(scanPath)) {
         filesToScan.push(scanPath);
       } else {
         const errorResult = {
-          error: `unsupported file extension: ${path52.extname(scanPath)}`,
+          error: `unsupported file extension: ${path53.extname(scanPath)}`,
           total: 0,
           byPriority: { high: 0, medium: 0, low: 0 },
           entries: []
@@ -62539,11 +62726,11 @@ var todo_extract = createSwarmTool({
     const allEntries = [];
     for (const filePath of filesToScan) {
       try {
-        const fileStat = fs39.statSync(filePath);
+        const fileStat = fs40.statSync(filePath);
         if (fileStat.size > MAX_FILE_SIZE_BYTES8) {
           continue;
         }
-        const content = fs39.readFileSync(filePath, "utf-8");
+        const content = fs40.readFileSync(filePath, "utf-8");
         const entries = parseTodoComments(content, filePath, tagsSet);
         allEntries.push(...entries);
       } catch {}
@@ -62571,18 +62758,18 @@ var todo_extract = createSwarmTool({
 // src/tools/update-task-status.ts
 init_tool();
 init_schema();
-import * as fs41 from "fs";
-import * as path54 from "path";
+import * as fs42 from "fs";
+import * as path55 from "path";
 
 // src/hooks/diff-scope.ts
-import * as fs40 from "fs";
-import * as path53 from "path";
+import * as fs41 from "fs";
+import * as path54 from "path";
 function getDeclaredScope(taskId, directory) {
   try {
-    const planPath = path53.join(directory, ".swarm", "plan.json");
-    if (!fs40.existsSync(planPath))
+    const planPath = path54.join(directory, ".swarm", "plan.json");
+    if (!fs41.existsSync(planPath))
       return null;
-    const raw = fs40.readFileSync(planPath, "utf-8");
+    const raw = fs41.readFileSync(planPath, "utf-8");
     const plan = JSON.parse(raw);
     for (const phase of plan.phases ?? []) {
       for (const task of phase.tasks ?? []) {
@@ -62694,7 +62881,7 @@ var TIER_3_PATTERNS = [
 ];
 function matchesTier3Pattern(files) {
   for (const file3 of files) {
-    const fileName = path54.basename(file3);
+    const fileName = path55.basename(file3);
     for (const pattern of TIER_3_PATTERNS) {
       if (pattern.test(fileName)) {
         return true;
@@ -62716,8 +62903,8 @@ function checkReviewerGate(taskId, workingDirectory) {
     if (hasActiveTurboMode2()) {
       const resolvedDir2 = workingDirectory ?? process.cwd();
       try {
-        const planPath = path54.join(resolvedDir2, ".swarm", "plan.json");
-        const planRaw = fs41.readFileSync(planPath, "utf-8");
+        const planPath = path55.join(resolvedDir2, ".swarm", "plan.json");
+        const planRaw = fs42.readFileSync(planPath, "utf-8");
         const plan = JSON.parse(planRaw);
         for (const planPhase of plan.phases ?? []) {
           for (const task of planPhase.tasks ?? []) {
@@ -62736,8 +62923,8 @@ function checkReviewerGate(taskId, workingDirectory) {
     }
     const resolvedDir = workingDirectory ?? process.cwd();
     try {
-      const evidencePath = path54.join(resolvedDir, ".swarm", "evidence", `${taskId}.json`);
-      const raw = fs41.readFileSync(evidencePath, "utf-8");
+      const evidencePath = path55.join(resolvedDir, ".swarm", "evidence", `${taskId}.json`);
+      const raw = fs42.readFileSync(evidencePath, "utf-8");
       const evidence = JSON.parse(raw);
       if (evidence?.required_gates && Array.isArray(evidence.required_gates) && evidence?.gates) {
         const allGatesMet = evidence.required_gates.every((gate) => evidence.gates[gate] != null);
@@ -62777,8 +62964,8 @@ function checkReviewerGate(taskId, workingDirectory) {
     }
     try {
       const resolvedDir2 = workingDirectory ?? process.cwd();
-      const planPath = path54.join(resolvedDir2, ".swarm", "plan.json");
-      const planRaw = fs41.readFileSync(planPath, "utf-8");
+      const planPath = path55.join(resolvedDir2, ".swarm", "plan.json");
+      const planRaw = fs42.readFileSync(planPath, "utf-8");
       const plan = JSON.parse(planRaw);
       for (const planPhase of plan.phases ?? []) {
         for (const task of planPhase.tasks ?? []) {
@@ -62959,8 +63146,8 @@ async function executeUpdateTaskStatus(args2, fallbackDir) {
         };
       }
     }
-    normalizedDir = path54.normalize(args2.working_directory);
-    const pathParts = normalizedDir.split(path54.sep);
+    normalizedDir = path55.normalize(args2.working_directory);
+    const pathParts = normalizedDir.split(path55.sep);
     if (pathParts.includes("..")) {
       return {
         success: false,
@@ -62970,11 +63157,11 @@ async function executeUpdateTaskStatus(args2, fallbackDir) {
         ]
       };
     }
-    const resolvedDir = path54.resolve(normalizedDir);
+    const resolvedDir = path55.resolve(normalizedDir);
     try {
-      const realPath = fs41.realpathSync(resolvedDir);
-      const planPath = path54.join(realPath, ".swarm", "plan.json");
-      if (!fs41.existsSync(planPath)) {
+      const realPath = fs42.realpathSync(resolvedDir);
+      const planPath = path55.join(realPath, ".swarm", "plan.json");
+      if (!fs42.existsSync(planPath)) {
         return {
           success: false,
           message: `Invalid working_directory: plan not found in "${realPath}"`,
@@ -63168,7 +63355,7 @@ var OpenCodeSwarm = async (ctx) => {
     const { PreflightTriggerManager: PTM } = await Promise.resolve().then(() => (init_trigger(), exports_trigger));
     preflightTriggerManager = new PTM(automationConfig);
     const { AutomationStatusArtifact: ASA } = await Promise.resolve().then(() => (init_status_artifact(), exports_status_artifact));
-    const swarmDir = path55.resolve(ctx.directory, ".swarm");
+    const swarmDir = path56.resolve(ctx.directory, ".swarm");
     statusArtifact = new ASA(swarmDir);
     statusArtifact.updateConfig(automationConfig.mode, automationConfig.capabilities);
     if (automationConfig.capabilities?.evidence_auto_summaries === true) {