opencode-swarm 7.50.3 → 7.51.0

package/dist/index.js

@@ -69,7 +69,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "opencode-swarm",
-    version: "7.50.3",
+    version: "7.51.0",
     description: "Architect-centric agentic swarm plugin for OpenCode - hub-and-spoke orchestration with SME consultation, code generation, and QA review",
     main: "dist/index.js",
     types: "dist/index.d.ts",
@@ -191,7 +191,7 @@ var init_tool_metadata = __esm(() => {
       agents: ["architect", "reviewer", "critic_oversight"]
     },
     syntax_check: {
-      description: "syntax validation",
+      description: "check syntax of source files using tree-sitter parsers across multiple languages, returning per-file errors",
       agents: ["architect", "coder", "test_engineer"]
     },
     placeholder_scan: {
@@ -199,7 +199,7 @@ var init_tool_metadata = __esm(() => {
       agents: ["architect", "reviewer"]
     },
     imports: {
-      description: "dependency audit",
+      description: "find all consumers that import from a given file — use before refactoring shared modules to avoid breaking unseen dependents",
       agents: [
         "architect",
         "sme",
@@ -217,11 +217,11 @@ var init_tool_metadata = __esm(() => {
       ]
     },
     lint: {
-      description: "code quality",
+      description: "run project linter in check or fix mode; supports biome, eslint, ruff, clippy, and more, returns structured results",
       agents: ["architect", "reviewer", "coder"]
     },
     secretscan: {
-      description: "secret detection",
+      description: "scan for secrets (API keys, tokens, passwords) via regex and entropy; returns redacted previews, excludes common dirs",
       agents: ["architect", "reviewer", "critic_oversight"]
     },
     sast_scan: {
@@ -229,7 +229,7 @@ var init_tool_metadata = __esm(() => {
       agents: ["architect", "reviewer", "critic_oversight"]
     },
     build_check: {
-      description: "build verification",
+      description: "discover and run build, typecheck, and test commands for various project ecosystems in the working directory",
       agents: ["architect", "coder", "test_engineer"]
     },
     pre_check_batch: {
@@ -241,7 +241,7 @@ var init_tool_metadata = __esm(() => {
       agents: ["architect"]
     },
     symbols: {
-      description: "code symbol search",
+      description: "extract exported symbols (functions, classes, interfaces, types) from source files; supports TypeScript, JavaScript, and Python",
       agents: [
         "architect",
         "sme",
@@ -312,7 +312,7 @@ var init_tool_metadata = __esm(() => {
       agents: ["architect"]
     },
     checkpoint: {
-      description: "state snapshots",
+      description: "create named git checkpoints for save, restore, and delete — use before risky operations to enable rollback",
       agents: ["architect"]
     },
     pkg_audit: {
@@ -356,6 +356,10 @@ var init_tool_metadata = __esm(() => {
         "explorer"
       ]
     },
+    git_blame: {
+      description: "per-line git blame metadata: sha, author, date, summary for each line in a file",
+      agents: ["reviewer", "explorer", "architect"]
+    },
     gitingest: {
       description: "fetch a GitHub repository full content via gitingest.com",
       agents: ["architect", "docs", "explorer"]
@@ -40728,6 +40732,7 @@ function isParallelGuidancePhaseComplete(phase) {
   return phase.status === "complete" || phase.status === "completed" || phase.status === "closed";
 }
 async function getEvidenceTaskId(session, directory) {
+  let resolvedPlanPath;
   const primary = session.currentTaskId ?? session.lastCoderDelegationTaskId;
   if (primary)
     return primary;
@@ -40740,12 +40745,12 @@ async function getEvidenceTaskId(session, directory) {
     }
     const resolvedDirectory = path19.resolve(directory);
     const planPath = path19.join(resolvedDirectory, ".swarm", "plan.json");
-    const resolvedPlanPath = path19.resolve(planPath);
+    resolvedPlanPath = path19.resolve(planPath);
     if (!resolvedPlanPath.startsWith(resolvedDirectory + path19.sep) && resolvedPlanPath !== resolvedDirectory) {
       return null;
     }
     const planContent = await fs12.promises.readFile(resolvedPlanPath, "utf-8");
-    const plan = JSON.parse(planContent);
+    const plan = EvidenceTaskIdPlanSchema.parse(JSON.parse(planContent));
     if (!plan || !Array.isArray(plan.phases)) {
       return null;
     }
@@ -40759,6 +40764,11 @@ async function getEvidenceTaskId(session, directory) {
       }
     }
   } catch (err2) {
+    if (err2 instanceof ZodError) {
+      const issueSummary = err2.issues.slice(0, 3).map((issue2) => issue2.message).join("; ");
+      warn(`[delegation-gate] getEvidenceTaskId ignored invalid plan schema at ${resolvedPlanPath ?? "unknown path"}: ${issueSummary}`);
+      return null;
+    }
     if (process.env.DEBUG_SWARM && err2 instanceof Error) {
       warn(`[delegation-gate] getEvidenceTaskId error: ${err2.message} (code=${err2.code ?? "none"})`);
     }
@@ -41405,8 +41415,9 @@ ${warningLines.join(`
     toolAfter
   };
 }
-var pendingCoderScopeByTaskId, ACTIVE_PARALLEL_TASK_STATES;
+var EvidenceTaskIdPlanSchema, pendingCoderScopeByTaskId, ACTIVE_PARALLEL_TASK_STATES;
 var init_delegation_gate = __esm(() => {
+  init_zod();
   init_schema();
   init_manager();
   init_state();
@@ -41416,6 +41427,14 @@ var init_delegation_gate = __esm(() => {
   init_guardrails();
   init_normalize_tool_name();
   init_utils2();
+  EvidenceTaskIdPlanSchema = exports_external.object({
+    phases: exports_external.array(exports_external.object({
+      tasks: exports_external.array(exports_external.object({
+        id: exports_external.string(),
+        status: exports_external.string().optional()
+      }).passthrough()).optional()
+    }).passthrough()).optional()
+  }).passthrough();
   pendingCoderScopeByTaskId = new Map;
   ACTIVE_PARALLEL_TASK_STATES = new Set([
     "coder_delegated",
@@ -74590,11 +74609,14 @@ async function defaultSelectTestFramework(profile, dir) {
 function defaultBuildTestCommand(profile, framework, files, dir = ".", opts = {}) {
   const scope = opts.scope ?? "all";
   const coverage = opts.coverage ?? false;
+  const bail = opts.bail ?? false;
   switch (framework) {
     case "bun": {
       const args2 = ["bun", "test"];
       if (coverage)
         args2.push("--coverage");
+      if (bail)
+        args2.push("--bail");
       if (scope !== "all" && files.length > 0)
         args2.push(...files);
       return args2;
@@ -74610,6 +74632,8 @@ function defaultBuildTestCommand(profile, framework, files, dir = ".", opts = {}
       ];
       if (coverage)
         args2.push("--coverage");
+      if (bail)
+        args2.push("--bail");
       if (scope !== "all" && files.length > 0)
         args2.push(...files);
       return args2;
@@ -74618,12 +74642,16 @@ function defaultBuildTestCommand(profile, framework, files, dir = ".", opts = {}
       const args2 = ["npx", "jest", "--json"];
       if (coverage)
         args2.push("--coverage");
+      if (bail)
+        args2.push("--bail");
       if (scope !== "all" && files.length > 0)
         args2.push(...files);
       return args2;
     }
     case "mocha": {
       const args2 = ["npx", "mocha"];
+      if (bail)
+        args2.push("--bail");
       if (scope !== "all" && files.length > 0)
         args2.push(...files);
       return args2;
@@ -74633,6 +74661,8 @@ function defaultBuildTestCommand(profile, framework, files, dir = ".", opts = {}
       const args2 = isWindows ? ["python", "-m", "pytest"] : ["python3", "-m", "pytest"];
       if (coverage)
         args2.push("--cov=.", "--cov-report=term-missing");
+      if (bail)
+        args2.push("-x");
       if (scope !== "all" && files.length > 0)
         args2.push(...files);
       return args2;
@@ -74686,6 +74716,8 @@ function defaultBuildTestCommand(profile, framework, files, dir = ".", opts = {}
       return isCommandAvailable("flutter") ? ["flutter", "test", ...files] : ["dart", "test", ...files];
     case "rspec": {
       const args2 = isCommandAvailable("bundle") ? ["bundle", "exec", "rspec"] : ["rspec"];
+      if (bail)
+        args2.push("--fail-fast");
       if (scope !== "all" && files.length > 0)
         args2.push(...files);
       return args2;
@@ -76660,6 +76692,10 @@ function validateArgs2(args2) {
     if (typeof obj.coverage !== "boolean")
       return false;
   }
+  if (obj.bail !== undefined) {
+    if (typeof obj.bail !== "boolean")
+      return false;
+  }
   if (obj.timeout_ms !== undefined) {
     if (typeof obj.timeout_ms !== "number")
       return false;
@@ -76735,7 +76771,7 @@ async function detectTestFrameworkViaDispatch(cwd) {
     return "none";
   }
 }
-async function buildTestCommandViaDispatch(framework, scope, files, coverage, baseDir) {
+async function buildTestCommandViaDispatch(framework, scope, files, coverage, baseDir, bail) {
   if (framework === "none")
     return null;
   try {
@@ -76744,7 +76780,8 @@ async function buildTestCommandViaDispatch(framework, scope, files, coverage, ba
     if (backend?.buildTestCommand) {
       const cmd = backend.buildTestCommand(framework, files, baseDir, {
         scope,
-        coverage
+        coverage,
+        bail
       });
       if (cmd)
         return cmd;
@@ -77113,12 +77150,14 @@ function getTargetedExecutionUnsupportedReason(framework) {
       return null;
   }
 }
-function buildTestCommand2(framework, scope, files, coverage, baseDir) {
+function buildTestCommand2(framework, scope, files, coverage, baseDir, bail) {
   switch (framework) {
     case "bun": {
       const args2 = ["bun", "test"];
       if (coverage)
         args2.push("--coverage");
+      if (bail)
+        args2.push("--bail");
       if (scope !== "all" && files.length > 0) {
         args2.push(...files);
       }
@@ -77135,6 +77174,8 @@ function buildTestCommand2(framework, scope, files, coverage, baseDir) {
       ];
       if (coverage)
         args2.push("--coverage");
+      if (bail)
+        args2.push("--bail=1");
       if (scope !== "all" && files.length > 0) {
         args2.push(...files);
       }
@@ -77144,6 +77185,8 @@ function buildTestCommand2(framework, scope, files, coverage, baseDir) {
       const args2 = ["npx", "jest", "--json"];
       if (coverage)
         args2.push("--coverage");
+      if (bail)
+        args2.push("--bail");
       if (scope !== "all" && files.length > 0) {
         args2.push(...files);
       }
@@ -77151,6 +77194,8 @@ function buildTestCommand2(framework, scope, files, coverage, baseDir) {
     }
     case "mocha": {
       const args2 = ["npx", "mocha"];
+      if (bail)
+        args2.push("--bail");
       if (scope !== "all" && files.length > 0) {
         args2.push(...files);
       }
@@ -77161,6 +77206,8 @@ function buildTestCommand2(framework, scope, files, coverage, baseDir) {
       const args2 = isWindows ? ["python", "-m", "pytest"] : ["python3", "-m", "pytest"];
       if (coverage)
         args2.push("--cov=.", "--cov-report=term-missing");
+      if (bail)
+        args2.push("-x");
       if (scope !== "all" && files.length > 0) {
         args2.push(...files);
       }
@@ -77217,6 +77264,8 @@ function buildTestCommand2(framework, scope, files, coverage, baseDir) {
       return isCommandAvailable("flutter") ? ["flutter", "test", ...files] : ["dart", "test", ...files];
     case "rspec": {
       const args2 = isCommandAvailable("bundle") ? ["bundle", "exec", "rspec"] : ["rspec"];
+      if (bail)
+        args2.push("--fail-fast");
       if (scope !== "all" && files.length > 0) {
         args2.push(...files);
       }
@@ -77602,7 +77651,7 @@ async function readBoundedStream(stream, maxBytes) {
   }
   return { text: decoder.decode(combined), truncated };
 }
-async function runTests(framework, scope, files, coverage, timeout_ms, cwd) {
+async function runTests(framework, scope, files, coverage, timeout_ms, cwd, bail) {
   if (scope !== "all" && files.length > 0) {
     const unsupportedReason = getTargetedExecutionUnsupportedReason(framework);
     if (unsupportedReason) {
@@ -77617,7 +77666,7 @@ async function runTests(framework, scope, files, coverage, timeout_ms, cwd) {
     }
   }
   const useDispatchBuild = process.env.SWARM_LANG_BACKEND !== "legacy";
-  const command = useDispatchBuild ? await buildTestCommandViaDispatch(framework, scope, files, coverage, cwd) ?? buildTestCommand2(framework, scope, files, coverage, cwd) : buildTestCommand2(framework, scope, files, coverage, cwd);
+  const command = useDispatchBuild ? await buildTestCommandViaDispatch(framework, scope, files, coverage, cwd, bail) ?? buildTestCommand2(framework, scope, files, coverage, cwd, bail) : buildTestCommand2(framework, scope, files, coverage, cwd, bail);
   if (!command) {
     return {
       success: false,
@@ -77965,6 +78014,7 @@ var init_test_runner = __esm(() => {
       scope: exports_external.enum(["all", "convention", "graph", "impact"]).optional().describe('Test scope: "all" runs full suite, "convention" accepts direct test files or maps source files to tests by naming, "graph" finds related tests via imports from source files, "impact" finds tests covering changed source files via test-impact analysis'),
       files: exports_external.array(exports_external.string()).optional().describe('Specific files to test. For "convention", pass source files or direct test files. For "graph" and "impact", pass source files only.'),
       coverage: exports_external.boolean().optional().describe("Enable coverage reporting if supported"),
+      bail: exports_external.boolean().optional().describe("Stop running tests after the first failure. Default false. Note: coverage may be incomplete when bail=true with coverage=true."),
       timeout_ms: exports_external.number().optional().describe("Timeout in milliseconds (default 60000, max 300000)"),
       allow_full_suite: exports_external.boolean().optional().describe('Explicit opt-in for scope "all". Required because full-suite output can destabilize SSE streaming.'),
       working_directory: exports_external.string().optional().describe("Explicit project root directory. When provided, tests run relative to this path instead of the plugin context directory. Use this when CWD differs from the actual project root.")
@@ -78065,6 +78115,7 @@ var init_test_runner = __esm(() => {
       }
       const _files = args2.files || [];
       const coverage = args2.coverage || false;
+      const bail = args2.bail || false;
       const timeout_ms = Math.min(args2.timeout_ms || DEFAULT_TIMEOUT_MS, MAX_TIMEOUT_MS);
       const useDispatch = process.env.SWARM_LANG_BACKEND !== "legacy";
       let framework;
@@ -78303,7 +78354,7 @@ var init_test_runner = __esm(() => {
         };
         return JSON.stringify(errorResult, null, 2);
       }
-      const result = await runTests(framework, effectiveScope, testFiles, coverage, timeout_ms, workingDir);
+      const result = await runTests(framework, effectiveScope, testFiles, coverage, timeout_ms, workingDir, bail);
       recordAndAnalyzeResults(result, testFiles, workingDir, _files.length > 0 ? _files : undefined, result.testCases);
       let historyReport;
       if (!result.success && result.totals && result.totals.failed > 0) {
@@ -78319,6 +78370,9 @@ var init_test_runner = __esm(() => {
       if (graphFallbackReason && result.message) {
         result.message = `${result.message} (${graphFallbackReason})`;
       }
+      if (bail && coverage && result.message) {
+        result.message = `${result.message} (coverage may be incomplete: bail=true stopped early)`;
+      }
       return JSON.stringify(result, null, 2);
     }
   });
@@ -78523,7 +78577,7 @@ async function runLintCheck(dir, linter, timeoutMs) {
 async function runTestsCheck(_dir, scope, timeoutMs) {
   const startTime = Date.now();
   try {
-    const result = await runTests("none", scope, [], false, timeoutMs, _dir);
+    const result = await runTests("none", scope, [], false, timeoutMs, _dir, false);
     if (!result.success) {
       return {
         type: "tests",
@@ -91315,7 +91369,7 @@ async function scanDocIndex(directory) {
   const resolvedDirectory = await realpath3(directory).catch(() => directory);
   const discoveredFiles = [];
   let rootReadable = false;
-  const walkDir = async (dir) => {
+  const walkDir2 = async (dir) => {
     let entries;
     try {
       entries = await readdir6(dir, { withFileTypes: true });
@@ -91343,8 +91397,8 @@ async function scanDocIndex(directory) {
         }
       }
       if (isDir) {
-        if (!SKIP_DIRECTORIES3.has(entry.name)) {
-          await walkDir(path94.join(dir, entry.name));
+        if (!SKIP_DIRECTORIES4.has(entry.name)) {
+          await walkDir2(path94.join(dir, entry.name));
         }
         continue;
       }
@@ -91386,7 +91440,7 @@ async function scanDocIndex(directory) {
       });
     }
   };
-  await walkDir(directory);
+  await walkDir2(directory);
   if (!rootReadable) {
     return {
       manifest: {
@@ -91531,13 +91585,13 @@ async function extractDocConstraints(directory, taskFiles, taskDescription) {
   }
   return { extracted: extractedCount, skipped: skippedCount, details };
 }
-var SKIP_DIRECTORIES3, SKIP_PATTERNS, MAX_SUMMARY_LENGTH = 200, MAX_INDEXED_FILES = 100, READ_LINES_LIMIT = 30, MIN_LESSON_LENGTH = 15, MAX_CONSTRAINTS_PER_DOC = 5, MAX_CONSTRAINT_LENGTH = 200, RELEVANCE_THRESHOLD = 0.1, DEDUP_THRESHOLD = 0.6, CONSTRAINT_PATTERNS, ACTION_WORDS, doc_scan, doc_extract;
+var SKIP_DIRECTORIES4, SKIP_PATTERNS, MAX_SUMMARY_LENGTH = 200, MAX_INDEXED_FILES = 100, READ_LINES_LIMIT = 30, MIN_LESSON_LENGTH = 15, MAX_CONSTRAINTS_PER_DOC = 5, MAX_CONSTRAINT_LENGTH = 200, RELEVANCE_THRESHOLD = 0.1, DEDUP_THRESHOLD = 0.6, CONSTRAINT_PATTERNS, ACTION_WORDS, doc_scan, doc_extract;
 var init_doc_scan = __esm(() => {
   init_zod();
   init_schema();
   init_knowledge_store();
   init_create_tool();
-  SKIP_DIRECTORIES3 = new Set([
+  SKIP_DIRECTORIES4 = new Set([
     "node_modules",
     ".git",
     ".swarm",
@@ -92391,11 +92445,11 @@ __export(exports_design_doc_drift, {
   runDesignDocDriftCheck: () => runDesignDocDriftCheck,
   _internals: () => _internals60
 });
-import * as fs98 from "node:fs";
-import * as path137 from "node:path";
+import * as fs99 from "node:fs";
+import * as path138 from "node:path";
 function mtimeMsOrNull(absPath) {
   try {
-    return fs98.statSync(absPath).mtimeMs;
+    return fs99.statSync(absPath).mtimeMs;
   } catch {
     return null;
   }
@@ -92403,40 +92457,40 @@ function mtimeMsOrNull(absPath) {
 function resolveAnchorWithin(directory, anchor) {
   if (!anchor || typeof anchor !== "string")
     return null;
-  const root = path137.resolve(directory);
-  const resolved = path137.resolve(root, anchor);
-  const rel = path137.relative(root, resolved);
-  if (rel.startsWith("..") || path137.isAbsolute(rel))
+  const root = path138.resolve(directory);
+  const resolved = path138.resolve(root, anchor);
+  const rel = path138.relative(root, resolved);
+  if (rel.startsWith("..") || path138.isAbsolute(rel))
     return null;
   return resolved;
 }
 async function runDesignDocDriftCheck(directory, phase, outDir) {
   try {
-    const root = path137.resolve(directory);
-    const outAbs = path137.resolve(root, outDir);
-    const outRel = path137.relative(root, outAbs);
-    if (outRel.startsWith("..") || path137.isAbsolute(outRel)) {
+    const root = path138.resolve(directory);
+    const outAbs = path138.resolve(root, outDir);
+    const outRel = path138.relative(root, outAbs);
+    if (outRel.startsWith("..") || path138.isAbsolute(outRel)) {
       return null;
     }
     const docMtimes = new Map;
     const checkedDocs = [];
     const missingDocs = [];
     for (const [docName, relFile] of Object.entries(DESIGN_DOC_FILES)) {
-      const abs = path137.join(outAbs, relFile);
+      const abs = path138.join(outAbs, relFile);
       const mtime = mtimeMsOrNull(abs);
       docMtimes.set(docName, mtime);
       if (mtime === null) {
-        missingDocs.push(path137.join(outDir, relFile));
+        missingDocs.push(path138.join(outDir, relFile));
       } else {
-        checkedDocs.push(path137.join(outDir, relFile));
+        checkedDocs.push(path138.join(outDir, relFile));
       }
     }
-    const traceabilityAbs = path137.join(outAbs, TRACEABILITY_REL);
+    const traceabilityAbs = path138.join(outAbs, TRACEABILITY_REL);
     let registry3 = null;
     try {
-      const stat9 = await fs98.promises.stat(traceabilityAbs);
+      const stat9 = await fs99.promises.stat(traceabilityAbs);
       if (stat9.size <= MAX_TRACEABILITY_BYTES) {
-        const raw = await fs98.promises.readFile(traceabilityAbs, "utf-8");
+        const raw = await fs99.promises.readFile(traceabilityAbs, "utf-8");
         const parsed = JSON.parse(raw);
         registry3 = parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : null;
       }
@@ -92444,7 +92498,7 @@ async function runDesignDocDriftCheck(directory, phase, outDir) {
       registry3 = null;
     }
     const noDocs = checkedDocs.length === 0 || registry3 === null;
-    const specMtime = mtimeMsOrNull(path137.join(root, ".swarm", "spec.md"));
+    const specMtime = mtimeMsOrNull(path138.join(root, ".swarm", "spec.md"));
     const staleSections = [];
     if (!noDocs && Array.isArray(registry3?.sections)) {
       for (const section of registry3.sections) {
@@ -92500,8 +92554,8 @@ async function runDesignDocDriftCheck(directory, phase, outDir) {
     };
     const filename = `${DOC_DRIFT_REPORT_PREFIX}${phase}.json`;
     const filePath = validateSwarmPath(directory, filename);
-    await fs98.promises.mkdir(path137.dirname(filePath), { recursive: true });
-    await fs98.promises.writeFile(filePath, JSON.stringify(report, null, 2), "utf-8");
+    await fs99.promises.mkdir(path138.dirname(filePath), { recursive: true });
+    await fs99.promises.writeFile(filePath, JSON.stringify(report, null, 2), "utf-8");
     getGlobalEventBus().publish("curator.docdrift.completed", {
       phase,
       verdict,
@@ -92531,10 +92585,10 @@ var init_design_doc_drift = __esm(() => {
     domain: "domain.md",
     "technical-spec": "technical-spec.md",
     "behavior-spec": "behavior-spec.md",
-    "reference-impl": path137.join("reference", "reference-impl.md"),
-    "idiom-notes": path137.join("reference", "idiom-notes.md")
+    "reference-impl": path138.join("reference", "reference-impl.md"),
+    "idiom-notes": path138.join("reference", "idiom-notes.md")
   };
-  TRACEABILITY_REL = path137.join("reference", "traceability.json");
+  TRACEABILITY_REL = path138.join("reference", "traceability.json");
   _internals60 = {
     mtimeMsOrNull,
     resolveAnchorWithin,
@@ -92549,12 +92603,12 @@ __export(exports_project_context, {
   _internals: () => _internals71,
   LANG_BACKEND_DETECTION_TIMEOUT_MS: () => LANG_BACKEND_DETECTION_TIMEOUT_MS
 });
-import * as fs122 from "node:fs";
-import * as path166 from "node:path";
+import * as fs123 from "node:fs";
+import * as path167 from "node:path";
 function detectFileExists2(directory, pattern) {
   if (pattern.includes("*") || pattern.includes("?")) {
     try {
-      const files = fs122.readdirSync(directory);
+      const files = fs123.readdirSync(directory);
       const regex = new RegExp(`^${pattern.replace(/\./g, "\\.").replace(/\*/g, ".*").replace(/\?/g, ".")}$`);
       return files.some((f) => regex.test(f));
     } catch {
@@ -92562,7 +92616,7 @@ function detectFileExists2(directory, pattern) {
     }
   }
   try {
-    fs122.accessSync(path166.join(directory, pattern));
+    fs123.accessSync(path167.join(directory, pattern));
     return true;
   } catch {
     return false;
@@ -92571,7 +92625,7 @@ function detectFileExists2(directory, pattern) {
 function selectTestCommandFromScriptsTest(backend, directory) {
   let pkgRaw;
   try {
-    pkgRaw = fs122.readFileSync(path166.join(directory, "package.json"), "utf-8");
+    pkgRaw = fs123.readFileSync(path167.join(directory, "package.json"), "utf-8");
   } catch {
     return null;
   }
@@ -92680,7 +92734,7 @@ var init_project_context = __esm(() => {
 init_package();
 init_agents2();
 init_critic();
-import * as path167 from "node:path";
+import * as path168 from "node:path";
 
 // src/background/index.ts
 init_event_bus();
@@ -95444,7 +95498,29 @@ init_path_security();
 import * as fs49 from "node:fs";
 import * as path79 from "node:path";
 var MAX_FILE_SIZE_BYTES2 = 1024 * 1024;
+var MAX_WORKSPACE_RESULTS = 50;
+var MAX_WORKSPACE_SCANNED_FILES = 200;
+var WORKSPACE_TIMEOUT_MS = 1e4;
 var WINDOWS_RESERVED_NAMES = /^(con|prn|aux|nul|com[1-9]|lpt[1-9])(\.|:|$)/i;
+var SYMBOL_EXTENSIONS = new Set([
+  ".ts",
+  ".tsx",
+  ".js",
+  ".jsx",
+  ".mjs",
+  ".cjs",
+  ".py"
+]);
+var SKIP_DIRECTORIES2 = new Set([
+  "node_modules",
+  ".git",
+  "dist",
+  "build",
+  "out",
+  ".next",
+  "coverage",
+  "__pycache__"
+]);
 function containsWindowsAttacks(str) {
   if (/:[^\\/]/.test(str)) {
     return true;
@@ -95689,28 +95765,135 @@ function extractPythonSymbols(filePath, cwd) {
     return a.name.localeCompare(b.name);
   });
 }
+function findSourceFiles(cwd, maxFiles) {
+  const files = [];
+  walkDir(cwd, cwd, files, maxFiles);
+  return files;
+}
+function walkDir(currentDir, rootDir, files, maxFiles) {
+  let entries;
+  try {
+    entries = fs49.readdirSync(currentDir, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  entries.sort((a, b) => a.name.toLowerCase().localeCompare(b.name.toLowerCase()));
+  for (const entry of entries) {
+    if (files.length >= maxFiles)
+      return;
+    if (SKIP_DIRECTORIES2.has(entry.name))
+      continue;
+    const fullPath = path79.join(currentDir, entry.name);
+    if (entry.isDirectory()) {
+      walkDir(fullPath, rootDir, files, maxFiles);
+    } else if (entry.isFile() && SYMBOL_EXTENSIONS.has(path79.extname(entry.name).toLowerCase())) {
+      files.push(path79.relative(rootDir, fullPath));
+    }
+  }
+}
+function searchWorkspaceSymbols(cwd, name2, exportedOnly = true) {
+  const startTime = Date.now();
+  const sourceFiles = findSourceFiles(cwd, MAX_WORKSPACE_SCANNED_FILES);
+  const files = [];
+  let scannedCount = 0;
+  let truncated = false;
+  if (sourceFiles.length >= MAX_WORKSPACE_SCANNED_FILES) {
+    truncated = true;
+  }
+  let totalSymbols = 0;
+  for (const relFile of sourceFiles) {
+    if (Date.now() - startTime > WORKSPACE_TIMEOUT_MS) {
+      truncated = true;
+      break;
+    }
+    scannedCount++;
+    let syms;
+    const ext = path79.extname(relFile).toLowerCase();
+    switch (ext) {
+      case ".ts":
+      case ".tsx":
+      case ".js":
+      case ".jsx":
+      case ".mjs":
+      case ".cjs":
+        syms = extractTSSymbols(relFile, cwd);
+        break;
+      case ".py":
+        syms = extractPythonSymbols(relFile, cwd);
+        break;
+      default:
+        continue;
+    }
+    if (exportedOnly) {
+      syms = syms.filter((s) => s.exported);
+    }
+    if (name2) {
+      syms = syms.filter((s) => s.name.includes(name2));
+    }
+    if (syms.length > 0) {
+      const remaining = MAX_WORKSPACE_RESULTS - totalSymbols;
+      if (remaining <= 0) {
+        truncated = true;
+        break;
+      }
+      const cappedSyms = syms.slice(0, remaining);
+      files.push({
+        file: relFile,
+        symbolCount: cappedSyms.length,
+        symbols: cappedSyms
+      });
+      totalSymbols += cappedSyms.length;
+      if (totalSymbols >= MAX_WORKSPACE_RESULTS) {
+        truncated = syms.length > remaining || scannedCount < sourceFiles.length;
+        break;
+      }
+    }
+  }
+  return {
+    query: { workspace: true, name: name2 },
+    fileCount: files.length,
+    scannedFileCount: scannedCount,
+    totalSymbols,
+    files,
+    truncated
+  };
+}
 var symbols = createSwarmTool({
   description: "Extract all exported symbols from a source file: functions with signatures, " + "classes with public members, interfaces, types, enums, constants. " + "Supports TypeScript/JavaScript and Python. Use for architect planning, " + "designer scaffolding, and understanding module public API surface.",
   args: {
-    file: exports_external.string().describe('File path to extract symbols from (e.g., "src/auth/login.ts")'),
-    exported_only: exports_external.boolean().default(true).describe("If true, only return exported/public symbols. If false, include all top-level symbols.")
+    file: exports_external.string().optional().describe('File path to extract symbols from (e.g., "src/auth/login.ts"). Required when not using workspace mode.'),
+    exported_only: exports_external.boolean().default(true).describe("If true, only return exported/public symbols. If false, include all top-level symbols."),
+    workspace: exports_external.boolean().optional().describe("When true, search across the workspace instead of a single file. Returns per-file symbol summaries."),
+    name: exports_external.string().optional().describe("Search for symbols by name (case-sensitive substring match). When provided without workspace, only searches the specified file.")
   },
   execute: async (args2, directory) => {
     let file3;
     let exportedOnly = true;
+    let workspace = false;
+    let name2;
     try {
       const obj = args2;
-      file3 = String(obj.file);
+      file3 = obj.file != null && typeof obj.file === "string" ? obj.file : undefined;
       exportedOnly = obj.exported_only === true;
+      workspace = obj.workspace === true;
+      name2 = obj.name != null && typeof obj.name === "string" ? obj.name : undefined;
     } catch {
       return JSON.stringify({
         file: "<unknown>",
-        error: "Invalid arguments: could not extract file path",
+        error: "Invalid arguments: could not extract parameters",
         symbols: []
       }, null, 2);
     }
     const cwd = directory;
-    const ext = path79.extname(file3);
+    if (workspace) {
+      return JSON.stringify(searchWorkspaceSymbols(cwd, name2, exportedOnly), null, 2);
+    }
+    if (!file3) {
+      return JSON.stringify({
+        error: "file parameter is required when not using workspace mode",
+        symbols: []
+      }, null, 2);
+    }
     if (containsControlChars(file3)) {
       return JSON.stringify({
         file: file3,
@@ -95739,6 +95922,7 @@ var symbols = createSwarmTool({
         symbols: []
       }, null, 2);
     }
+    const ext = path79.extname(file3);
     let syms;
     switch (ext) {
       case ".ts":
@@ -95762,6 +95946,9 @@ var symbols = createSwarmTool({
     if (exportedOnly) {
       syms = syms.filter((s) => s.exported);
     }
+    if (name2) {
+      syms = syms.filter((s) => s.name.includes(name2));
+    }
     return JSON.stringify({
       file: file3,
       symbolCount: syms.length,
@@ -95910,7 +96097,7 @@ var _internals43 = {
   extractPythonSymbols,
   parseFileImports
 };
-var SKIP_DIRECTORIES2 = new Set([
+var SKIP_DIRECTORIES3 = new Set([
   "node_modules",
   ".git",
   "dist",
@@ -96143,7 +96330,7 @@ async function findSourceFilesAsync(dir, stats, options) {
       if (isWalkBudgetExceeded(ctx) || isFileCapReached(ctx, files.length)) {
         break;
       }
-      if (SKIP_DIRECTORIES2.has(entry.name)) {
+      if (SKIP_DIRECTORIES3.has(entry.name)) {
         ctx.stats.skippedDirs++;
         continue;
       }
@@ -98147,7 +98334,7 @@ var DEFAULT_SKIP_DIRS = new Set([
 var MAX_FILE_SIZE_BYTES3 = 1024 * 1024;
 var DEFAULT_MAX_FILES = 1e4;
 var SOURCE_EXT_SET = new Set(SOURCE_EXTENSIONS2);
-function findSourceFiles(workspaceRoot, skipDirs = DEFAULT_SKIP_DIRS) {
+function findSourceFiles2(workspaceRoot, skipDirs = DEFAULT_SKIP_DIRS) {
   const out2 = [];
   const stack = [workspaceRoot];
   while (stack.length > 0) {
@@ -98184,7 +98371,7 @@ function findSourceFiles(workspaceRoot, skipDirs = DEFAULT_SKIP_DIRS) {
 }
 async function buildRepoGraph(workspaceRoot, options = {}) {
   const skipDirs = options.skipDirs ? new Set([...DEFAULT_SKIP_DIRS, ...options.skipDirs]) : DEFAULT_SKIP_DIRS;
-  let files = findSourceFiles(workspaceRoot, skipDirs);
+  let files = findSourceFiles2(workspaceRoot, skipDirs);
   const cap = typeof options.maxFiles === "number" && options.maxFiles > 0 ? options.maxFiles : DEFAULT_MAX_FILES;
   if (files.length > cap) {
     files = files.slice(0, cap);
@@ -108666,6 +108853,7 @@ ${body2}`);
 }
 
 // src/council/council-evidence-writer.ts
+init_zod();
 init_task_file();
 import { appendFileSync as appendFileSync12, existsSync as existsSync63, mkdirSync as mkdirSync29, readFileSync as readFileSync45 } from "node:fs";
 import { join as join95 } from "node:path";
@@ -108673,6 +108861,7 @@ var EVIDENCE_DIR2 = ".swarm/evidence";
 var VALID_TASK_ID = /^\d+\.\d+(\.\d+)*$/;
 var COUNCIL_GATE_NAME = "council";
 var COUNCIL_AGENT_ID = "architect";
+var EvidenceFileSchema = exports_external.record(exports_external.string(), exports_external.unknown());
 var _internals53 = {
   withTaskEvidenceLock
 };
@@ -108712,10 +108901,8 @@ async function writeCouncilEvidence(workingDir, synthesis) {
     const existingRoot = Object.create(null);
     if (existsSync63(filePath)) {
       try {
-        const parsed = JSON.parse(readFileSync45(filePath, "utf-8"));
-        if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
-          safeAssignOwnProps(existingRoot, parsed);
-        }
+        const parsed = EvidenceFileSchema.parse(JSON.parse(readFileSync45(filePath, "utf-8")));
+        safeAssignOwnProps(existingRoot, parsed);
       } catch {}
     }
     const existingGatesRaw = existingRoot.gates;
@@ -109073,9 +109260,19 @@ function buildFinalCouncilFeedback(projectSummary, verdict, vetoedBy, requiredFi
 }
 
 // src/council/criteria-store.ts
+init_zod();
 import { existsSync as existsSync64, mkdirSync as mkdirSync30, readFileSync as readFileSync46, writeFileSync as writeFileSync22 } from "node:fs";
 import { join as join96 } from "node:path";
 var COUNCIL_DIR = ".swarm/council";
+var CouncilCriteriaSchema = exports_external.object({
+  taskId: exports_external.string(),
+  criteria: exports_external.array(exports_external.object({
+    id: exports_external.string(),
+    description: exports_external.string(),
+    mandatory: exports_external.boolean()
+  })),
+  declaredAt: exports_external.string()
+});
 function writeCriteria(workingDir, taskId, criteria) {
   const dir = join96(workingDir, COUNCIL_DIR);
   mkdirSync30(dir, { recursive: true });
@@ -109091,11 +109288,7 @@ function readCriteria(workingDir, taskId) {
   if (!existsSync64(filePath))
     return null;
   try {
-    const parsed = JSON.parse(readFileSync46(filePath, "utf-8"));
-    if (parsed && typeof parsed === "object" && typeof parsed.taskId === "string" && Array.isArray(parsed.criteria)) {
-      return parsed;
-    }
-    return null;
+    return CouncilCriteriaSchema.parse(JSON.parse(readFileSync46(filePath, "utf-8")));
   } catch {
     return null;
   }
@@ -110231,10 +110424,12 @@ var diff = createSwarmTool({
   description: "Analyze git diff for changed files, exports, interfaces, and function signatures. Returns structured output with contract change detection.",
   args: {
     base: exports_external.string().optional().describe('Base ref to diff against (default: HEAD). Use "staged" for staged changes, "unstaged" for working tree changes.'),
-    paths: exports_external.array(exports_external.string()).optional().describe("Optional file paths to restrict diff scope.")
+    paths: exports_external.array(exports_external.string()).optional().describe("Optional file paths to restrict diff scope."),
+    summaryOnly: exports_external.boolean().optional().describe("When true, return only file list with additions/deletions counts and hasContractChanges. No hunk content or AST diff. Default false.")
   },
   async execute(args2, directory, _ctx) {
     const typedArgs = args2;
+    const summaryOnly = typedArgs.summaryOnly === true;
     try {
       let fileExistsInRef = function(refPath) {
         try {
@@ -110312,13 +110507,6 @@ var diff = createSwarmTool({
         cwd: directory,
         stdio: ["ignore", "pipe", "pipe"]
       });
-      const fullDiffOutput = child_process7.execFileSync("git", fullDiffArgs, {
-        encoding: "utf-8",
-        timeout: DIFF_TIMEOUT_MS,
-        maxBuffer: MAX_BUFFER_BYTES,
-        cwd: directory,
-        stdio: ["ignore", "pipe", "pipe"]
-      });
       const files = [];
       const numstatLines = numstatOutput.split(`
 `);
@@ -110333,6 +110521,50 @@ var diff = createSwarmTool({
           files.push({ path: path118, additions, deletions });
         }
       }
+      if (summaryOnly) {
+        let hasContractChanges2 = false;
+        try {
+          const contractDiffArgs = [...gitArgs, "-U0"];
+          if (typedArgs.paths?.length) {
+            contractDiffArgs.push("--", ...typedArgs.paths);
+          }
+          const contractDiffOutput = child_process7.execFileSync("git", contractDiffArgs, {
+            encoding: "utf-8",
+            timeout: DIFF_TIMEOUT_MS,
+            maxBuffer: MAX_BUFFER_BYTES,
+            cwd: directory,
+            stdio: ["ignore", "pipe", "pipe"]
+          });
+          const contractDiffLines = contractDiffOutput.split(`
+`);
+          for (const line of contractDiffLines) {
+            for (const pattern of CONTRACT_PATTERNS) {
+              if (pattern.test(line)) {
+                hasContractChanges2 = true;
+                break;
+              }
+            }
+            if (hasContractChanges2)
+              break;
+          }
+        } catch {
+          hasContractChanges2 = true;
+        }
+        const result2 = {
+          files,
+          contractChanges: [],
+          hasContractChanges: hasContractChanges2,
+          summary: `${files.length} files changed (summary only)`
+        };
+        return JSON.stringify(result2, null, 2);
+      }
+      const fullDiffOutput = child_process7.execFileSync("git", fullDiffArgs, {
+        encoding: "utf-8",
+        timeout: DIFF_TIMEOUT_MS,
+        maxBuffer: MAX_BUFFER_BYTES,
+        cwd: directory,
+        stdio: ["ignore", "pipe", "pipe"]
+      });
       const contractChanges = [];
       const diffLines = fullDiffOutput.split(`
 `);
@@ -111398,13 +111630,389 @@ var get_qa_gate_profile = createSwarmTool({
   }
 });
 
+// src/tools/git-blame.ts
+init_zod();
+init_path_security();
+init_create_tool();
+import * as child_process9 from "node:child_process";
+import * as fs83 from "node:fs";
+import * as path121 from "node:path";
+var BLAME_TIMEOUT_MS = 30000;
+var MAX_OUTPUT_LINES2 = 500;
+var MAX_PATH_LENGTH2 = 500;
+var MAX_LINE_NUMBER = 1e6;
+var SHELL_METACHARACTERS3 = /[;|&$`(){}<>!'"]/;
+var BINARY_EXTENSIONS = new Set([
+  ".png",
+  ".jpg",
+  ".jpeg",
+  ".gif",
+  ".bmp",
+  ".ico",
+  ".svg",
+  ".webp",
+  ".mp3",
+  ".mp4",
+  ".wav",
+  ".avi",
+  ".mov",
+  ".wmv",
+  ".flv",
+  ".zip",
+  ".tar",
+  ".gz",
+  ".rar",
+  ".7z",
+  ".bz2",
+  ".pdf",
+  ".doc",
+  ".docx",
+  ".xls",
+  ".xlsx",
+  ".ppt",
+  ".pptx",
+  ".exe",
+  ".dll",
+  ".so",
+  ".dylib",
+  ".bin",
+  ".dat",
+  ".o",
+  ".obj",
+  ".woff",
+  ".woff2",
+  ".ttf",
+  ".eot",
+  ".otf",
+  ".sqlite",
+  ".db"
+]);
+function validateFilePath(filePath) {
+  if (!filePath || filePath.length === 0) {
+    return "file path is required";
+  }
+  if (filePath.length > MAX_PATH_LENGTH2) {
+    return `file path exceeds maximum length of ${MAX_PATH_LENGTH2}`;
+  }
+  if (path121.isAbsolute(filePath)) {
+    return "absolute paths are not allowed; use a relative path from the project root";
+  }
+  if (containsPathTraversal(filePath)) {
+    return "path traversal detected";
+  }
+  if (containsControlChars(filePath)) {
+    return "file path contains control characters";
+  }
+  if (SHELL_METACHARACTERS3.test(filePath)) {
+    return "file path contains shell metacharacters";
+  }
+  if (filePath.startsWith("-")) {
+    return 'file path cannot start with "-"';
+  }
+  return null;
+}
+function validateLineNumber(value, name2) {
+  if (typeof value === "undefined")
+    return null;
+  if (typeof value !== "number" || !Number.isInteger(value) || value < 1) {
+    return `${name2} must be a positive integer`;
+  }
+  if (value > MAX_LINE_NUMBER) {
+    return `${name2} exceeds maximum value of ${MAX_LINE_NUMBER}`;
+  }
+  return null;
+}
+function isBinaryFile2(filePath) {
+  const ext = path121.extname(filePath).toLowerCase();
+  return BINARY_EXTENSIONS.has(ext);
+}
+function parsePorcelainBlame(output, linesCap) {
+  const entries = [];
+  const outputLines = output.split(`
+`);
+  const cappedLines = outputLines.slice(0, linesCap * 8);
+  const commitCache = new Map;
+  let currentSha = "";
+  let currentLine = 0;
+  let currentAuthor = "";
+  let currentAuthorTime = "";
+  let currentSummary = "";
+  for (const rawLine of cappedLines) {
+    const headerMatch = rawLine.match(/^([0-9a-f]{40})\s+(\d+)\s+(\d+)/);
+    if (headerMatch) {
+      currentSha = headerMatch[1];
+      currentLine = Number.parseInt(headerMatch[3], 10);
+      const cached3 = commitCache.get(currentSha);
+      if (cached3) {
+        currentAuthor = cached3.author;
+        currentAuthorTime = cached3.authorTime;
+        currentSummary = cached3.summary;
+      } else {
+        currentAuthor = "";
+        currentAuthorTime = "";
+        currentSummary = "";
+      }
+      continue;
+    }
+    if (rawLine.startsWith("author ")) {
+      currentAuthor = rawLine.slice(7);
+      let meta3 = commitCache.get(currentSha);
+      if (!meta3) {
+        meta3 = { author: "", authorTime: "", summary: "" };
+        commitCache.set(currentSha, meta3);
+      }
+      meta3.author = currentAuthor;
+      continue;
+    }
+    if (rawLine.startsWith("author-time ")) {
+      currentAuthorTime = rawLine.slice(12);
+      let meta3 = commitCache.get(currentSha);
+      if (!meta3) {
+        meta3 = { author: "", authorTime: "", summary: "" };
+        commitCache.set(currentSha, meta3);
+      }
+      meta3.authorTime = currentAuthorTime;
+      continue;
+    }
+    if (rawLine.startsWith("summary ")) {
+      currentSummary = rawLine.slice(8);
+      let meta3 = commitCache.get(currentSha);
+      if (!meta3) {
+        meta3 = { author: "", authorTime: "", summary: "" };
+        commitCache.set(currentSha, meta3);
+      }
+      meta3.summary = currentSummary;
+      continue;
+    }
+    if (rawLine.startsWith("\t")) {
+      entries.push({
+        line: currentLine,
+        sha: currentSha.slice(0, 8),
+        author: currentAuthor,
+        authorTime: currentAuthorTime,
+        summary: currentSummary,
+        content: rawLine.slice(1)
+      });
+      if (entries.length >= linesCap)
+        break;
+    }
+  }
+  return entries.slice(0, linesCap);
+}
+var git_blame = createSwarmTool({
+  description: "Analyze per-line git blame metadata for a file. Returns sha (abbreviated), author, date (ISO), summary, and content for each line. Uses git blame --porcelain. Rejects binary files and validates paths.",
+  args: {
+    file: exports_external.string().describe("Relative file path to blame (required, relative to project root)"),
+    start: exports_external.number().optional().describe("Optional start line number (1-indexed). Requires end parameter."),
+    end: exports_external.number().optional().describe("Optional end line number (1-indexed, inclusive). Requires start parameter.")
+  },
+  async execute(args2, directory) {
+    let fileInput;
+    let startInput;
+    let endInput;
+    try {
+      if (args2 && typeof args2 === "object") {
+        const obj = args2;
+        fileInput = typeof obj.file === "string" ? obj.file : undefined;
+        startInput = typeof obj.start === "number" ? obj.start : undefined;
+        endInput = typeof obj.end === "number" ? obj.end : undefined;
+      }
+    } catch {}
+    if (!fileInput) {
+      return JSON.stringify({
+        error: "file path is required",
+        file: String(fileInput ?? ""),
+        lineCount: 0,
+        lines: []
+      });
+    }
+    const file3 = fileInput;
+    const pathError = validateFilePath(file3);
+    if (pathError) {
+      return JSON.stringify({
+        error: pathError,
+        file: file3,
+        lineCount: 0,
+        lines: []
+      });
+    }
+    const startError = validateLineNumber(startInput, "start");
+    if (startError) {
+      return JSON.stringify({
+        error: startError,
+        file: file3,
+        lineCount: 0,
+        lines: []
+      });
+    }
+    const endError = validateLineNumber(endInput, "end");
+    if (endError) {
+      return JSON.stringify({
+        error: endError,
+        file: file3,
+        lineCount: 0,
+        lines: []
+      });
+    }
+    if (startInput !== undefined && endInput === undefined || startInput === undefined && endInput !== undefined) {
+      return JSON.stringify({
+        error: "both start and end must be provided together for a line range",
+        file: file3,
+        lineCount: 0,
+        lines: []
+      });
+    }
+    if (startInput !== undefined && endInput !== undefined && startInput > endInput) {
+      return JSON.stringify({
+        error: "start must be less than or equal to end",
+        file: file3,
+        lineCount: 0,
+        lines: []
+      });
+    }
+    const resolvedPath = path121.resolve(directory, file3);
+    if (!fs83.existsSync(resolvedPath)) {
+      return JSON.stringify({
+        error: `file not found: ${file3}`,
+        file: file3,
+        lineCount: 0,
+        lines: []
+      });
+    }
+    const realDir = fs83.realpathSync(directory);
+    const realPath = fs83.realpathSync(resolvedPath);
+    const relative25 = path121.relative(realDir, realPath);
+    if (relative25.startsWith("..") || path121.isAbsolute(relative25)) {
+      return JSON.stringify({
+        error: "file path resolves outside the workspace",
+        file: file3,
+        lineCount: 0,
+        lines: []
+      });
+    }
+    const stat9 = fs83.statSync(resolvedPath);
+    if (stat9.isDirectory()) {
+      return JSON.stringify({
+        error: "path is a directory, not a file",
+        file: file3,
+        lineCount: 0,
+        lines: []
+      });
+    }
+    if (isBinaryFile2(file3)) {
+      return JSON.stringify({
+        error: "binary files are not supported for git blame",
+        file: file3,
+        lineCount: 0,
+        lines: []
+      });
+    }
+    const gitArgs = ["blame", "--porcelain"];
+    if (startInput !== undefined && endInput !== undefined) {
+      gitArgs.push("-L", `${startInput},${endInput}`);
+    }
+    gitArgs.push("--", file3);
+    const result = child_process9.spawnSync("git", gitArgs, {
+      cwd: directory,
+      encoding: "utf-8",
+      timeout: BLAME_TIMEOUT_MS,
+      windowsHide: true,
+      maxBuffer: 5 * 1024 * 1024,
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    if (result.error) {
+      const isTimeout = "code" in result.error && result.error.code === "ETIMEDOUT";
+      if (isTimeout) {
+        return JSON.stringify({
+          error: "git blame timed out",
+          file: file3,
+          lineCount: 0,
+          lines: []
+        });
+      }
+      const message = result.error instanceof Error ? result.error.message : String(result.error);
+      if (message.includes("ENOENT") || message.includes("not found")) {
+        return JSON.stringify({
+          error: "git is not available or not in PATH",
+          file: file3,
+          lineCount: 0,
+          lines: []
+        });
+      }
+      return JSON.stringify({
+        error: `git execution failed: ${message}`,
+        file: file3,
+        lineCount: 0,
+        lines: []
+      });
+    }
+    if (result.status !== 0) {
+      const stderr = (result.stderr ?? "").trim();
+      if (stderr.includes("not a git repository") || stderr.includes("not in a git repository")) {
+        return JSON.stringify({
+          error: "not a git repository",
+          file: file3,
+          lineCount: 0,
+          lines: []
+        });
+      }
+      if (stderr.includes("no such path") || stderr.includes("did not match any files")) {
+        return JSON.stringify({
+          error: `file not tracked by git: ${file3}`,
+          file: file3,
+          lineCount: 0,
+          lines: []
+        });
+      }
+      return JSON.stringify({
+        error: `git blame failed: ${stderr || `exit code ${result.status}`}`,
+        file: file3,
+        lineCount: 0,
+        lines: []
+      });
+    }
+    if (result.signal === "SIGTERM" || result.signal === "SIGKILL") {
+      return JSON.stringify({
+        error: "git blame timed out",
+        file: file3,
+        lineCount: 0,
+        lines: []
+      });
+    }
+    const stdout = result.stdout ?? "";
+    if (!stdout.trim()) {
+      return JSON.stringify({
+        error: "no blame output (file may be empty or untracked)",
+        file: file3,
+        lineCount: 0,
+        lines: []
+      });
+    }
+    const rawEntries = parsePorcelainBlame(stdout, MAX_OUTPUT_LINES2);
+    const lines = rawEntries.map((entry) => ({
+      line: entry.line,
+      sha: entry.sha,
+      author: entry.author,
+      date: Number.parseInt(entry.authorTime, 10) > 0 ? new Date(Number.parseInt(entry.authorTime, 10) * 1000).toISOString().slice(0, 10) : entry.authorTime,
+      summary: entry.summary,
+      content: entry.content
+    }));
+    const resultJson = {
+      file: file3,
+      lineCount: lines.length,
+      lines
+    };
+    return JSON.stringify(resultJson, null, 2);
+  }
+});
+
 // src/tools/gitingest.ts
 init_zod();
 init_create_tool();
 var GITINGEST_TIMEOUT_MS = 1e4;
 var GITINGEST_MAX_RESPONSE_BYTES = 5242880;
 var GITINGEST_MAX_RETRIES = 2;
-var delay = (ms) => new Promise((resolve43) => setTimeout(resolve43, ms));
+var delay = (ms) => new Promise((resolve44) => setTimeout(resolve44, ms));
 async function fetchGitingest(args2) {
   for (let attempt = 0;attempt <= GITINGEST_MAX_RETRIES; attempt++) {
     try {
@@ -111492,8 +112100,8 @@ var gitingest = createSwarmTool({
 init_zod();
 init_create_tool();
 init_path_security();
-import * as fs83 from "node:fs";
-import * as path121 from "node:path";
+import * as fs84 from "node:fs";
+import * as path122 from "node:path";
 var MAX_FILE_PATH_LENGTH2 = 500;
 var MAX_SYMBOL_LENGTH = 256;
 var MAX_FILE_SIZE_BYTES7 = 1024 * 1024;
@@ -111540,8 +112148,8 @@ function validateSymbolInput(symbol3) {
   }
   return null;
 }
-function isBinaryFile2(filePath, buffer) {
-  const ext = path121.extname(filePath).toLowerCase();
+function isBinaryFile3(filePath, buffer) {
+  const ext = path122.extname(filePath).toLowerCase();
   if (ext === ".json" || ext === ".md" || ext === ".txt") {
     return false;
   }
@@ -111565,15 +112173,15 @@ function parseImports(content, targetFile, targetSymbol) {
   const imports = [];
   let _resolvedTarget;
   try {
-    _resolvedTarget = path121.resolve(targetFile);
+    _resolvedTarget = path122.resolve(targetFile);
   } catch {
     _resolvedTarget = targetFile;
   }
-  const targetBasename = path121.basename(targetFile, path121.extname(targetFile));
+  const targetBasename = path122.basename(targetFile, path122.extname(targetFile));
   const targetWithExt = targetFile;
   const targetWithoutExt = targetFile.replace(/\.(ts|tsx|js|jsx|mjs|cjs)$/i, "");
-  const normalizedTargetWithExt = path121.normalize(targetWithExt).replace(/\\/g, "/");
-  const normalizedTargetWithoutExt = path121.normalize(targetWithoutExt).replace(/\\/g, "/");
+  const normalizedTargetWithExt = path122.normalize(targetWithExt).replace(/\\/g, "/");
+  const normalizedTargetWithoutExt = path122.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];
@@ -111596,9 +112204,9 @@ function parseImports(content, targetFile, targetSymbol) {
     }
     const _normalizedModule = modulePath.replace(/^\.\//, "").replace(/^\.\.\\/, "../");
     let isMatch = false;
-    const _targetDir = path121.dirname(targetFile);
-    const targetExt = path121.extname(targetFile);
-    const targetBasenameNoExt = path121.basename(targetFile, targetExt);
+    const _targetDir = path122.dirname(targetFile);
+    const targetExt = path122.extname(targetFile);
+    const targetBasenameNoExt = path122.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, "");
@@ -111638,7 +112246,7 @@ function parseImports(content, targetFile, targetSymbol) {
   }
   return imports;
 }
-var SKIP_DIRECTORIES4 = new Set([
+var SKIP_DIRECTORIES5 = new Set([
   "node_modules",
   ".git",
   "dist",
@@ -111652,10 +112260,10 @@ var SKIP_DIRECTORIES4 = new Set([
   ".svn",
   ".hg"
 ]);
-function findSourceFiles2(dir, files = [], stats = { skippedDirs: [], skippedFiles: 0, fileErrors: [] }) {
+function findSourceFiles3(dir, files = [], stats = { skippedDirs: [], skippedFiles: 0, fileErrors: [] }) {
   let entries;
   try {
-    entries = fs83.readdirSync(dir);
+    entries = fs84.readdirSync(dir);
   } catch (e) {
     stats.fileErrors.push({
       path: dir,
@@ -111665,14 +112273,14 @@ function findSourceFiles2(dir, files = [], stats = { skippedDirs: [], skippedFil
   }
   entries.sort((a, b) => a.toLowerCase().localeCompare(b.toLowerCase()));
   for (const entry of entries) {
-    if (SKIP_DIRECTORIES4.has(entry)) {
-      stats.skippedDirs.push(path121.join(dir, entry));
+    if (SKIP_DIRECTORIES5.has(entry)) {
+      stats.skippedDirs.push(path122.join(dir, entry));
       continue;
     }
-    const fullPath = path121.join(dir, entry);
+    const fullPath = path122.join(dir, entry);
     let stat9;
     try {
-      stat9 = fs83.statSync(fullPath);
+      stat9 = fs84.statSync(fullPath);
     } catch (e) {
       stats.fileErrors.push({
         path: fullPath,
@@ -111681,9 +112289,9 @@ function findSourceFiles2(dir, files = [], stats = { skippedDirs: [], skippedFil
       continue;
     }
     if (stat9.isDirectory()) {
-      findSourceFiles2(fullPath, files, stats);
+      findSourceFiles3(fullPath, files, stats);
     } else if (stat9.isFile()) {
-      const ext = path121.extname(fullPath).toLowerCase();
+      const ext = path122.extname(fullPath).toLowerCase();
       if (SUPPORTED_EXTENSIONS3.includes(ext)) {
         files.push(fullPath);
       }
@@ -111740,8 +112348,8 @@ var imports = createSwarmTool({
       return JSON.stringify(errorResult, null, 2);
     }
     try {
-      const targetFile = path121.resolve(file3);
-      if (!fs83.existsSync(targetFile)) {
+      const targetFile = path122.resolve(file3);
+      if (!fs84.existsSync(targetFile)) {
         const errorResult = {
           error: `target file not found: ${file3}`,
           target: file3,
@@ -111751,7 +112359,7 @@ var imports = createSwarmTool({
         };
         return JSON.stringify(errorResult, null, 2);
       }
-      const targetStat = fs83.statSync(targetFile);
+      const targetStat = fs84.statSync(targetFile);
       if (!targetStat.isFile()) {
         const errorResult = {
           error: "target must be a file, not a directory",
@@ -111762,13 +112370,13 @@ var imports = createSwarmTool({
         };
         return JSON.stringify(errorResult, null, 2);
       }
-      const baseDir = path121.dirname(targetFile);
+      const baseDir = path122.dirname(targetFile);
       const scanStats = {
         skippedDirs: [],
         skippedFiles: 0,
         fileErrors: []
       };
-      const sourceFiles = findSourceFiles2(baseDir, [], scanStats);
+      const sourceFiles = findSourceFiles3(baseDir, [], scanStats);
       const filesToScan = sourceFiles.filter((f) => f !== targetFile).sort((a, b) => a.toLowerCase().localeCompare(b.toLowerCase())).slice(0, MAX_CONSUMERS * 10);
       const consumers = [];
       let skippedFileCount = 0;
@@ -111777,13 +112385,13 @@ var imports = createSwarmTool({
         if (consumers.length >= MAX_CONSUMERS)
           break;
         try {
-          const stat9 = fs83.statSync(filePath);
+          const stat9 = fs84.statSync(filePath);
           if (stat9.size > MAX_FILE_SIZE_BYTES7) {
             skippedFileCount++;
             continue;
           }
-          const buffer = fs83.readFileSync(filePath);
-          if (isBinaryFile2(filePath, buffer)) {
+          const buffer = fs84.readFileSync(filePath);
+          if (isBinaryFile3(filePath, buffer)) {
             skippedFileCount++;
             continue;
           }
@@ -112150,7 +112758,7 @@ init_zod();
 init_config();
 init_knowledge_store();
 init_create_tool();
-import { existsSync as existsSync69 } from "node:fs";
+import { existsSync as existsSync70 } from "node:fs";
 var DEFAULT_LIMIT = 10;
 var MAX_LESSON_LENGTH = 200;
 var VALID_CATEGORIES3 = [
@@ -112226,14 +112834,14 @@ function validateLimit(limit) {
 }
 async function readSwarmKnowledge(directory) {
   const swarmPath = resolveSwarmKnowledgePath(directory);
-  if (!existsSync69(swarmPath)) {
+  if (!existsSync70(swarmPath)) {
     return [];
   }
   return readKnowledge(swarmPath);
 }
 async function readHiveKnowledge() {
   const hivePath = resolveHiveKnowledgePath();
-  if (!existsSync69(hivePath)) {
+  if (!existsSync70(hivePath)) {
     return [];
   }
   return readKnowledge(hivePath);
@@ -112658,12 +113266,12 @@ var lean_turbo_acquire_locks = createSwarmTool({
 // src/tools/lean-turbo-plan-lanes.ts
 init_zod();
 init_constants();
-import * as fs85 from "node:fs";
-import * as path123 from "node:path";
+import * as fs86 from "node:fs";
+import * as path124 from "node:path";
 
 // src/turbo/lean/conflicts.ts
-import * as fs84 from "node:fs";
-import * as path122 from "node:path";
+import * as fs85 from "node:fs";
+import * as path123 from "node:path";
 var DEFAULT_GLOBAL_FILES = [
   "package.json",
   "package-lock.json",
@@ -112790,12 +113398,12 @@ function isProtectedPath3(normalizedPath) {
   return false;
 }
 function readTaskScopes(directory, taskId) {
-  const scopePath = path122.join(directory, ".swarm", "scopes", `scope-${taskId}.json`);
+  const scopePath = path123.join(directory, ".swarm", "scopes", `scope-${taskId}.json`);
   try {
-    if (!fs84.existsSync(scopePath)) {
+    if (!fs85.existsSync(scopePath)) {
       return null;
     }
-    const raw = fs84.readFileSync(scopePath, "utf-8");
+    const raw = fs85.readFileSync(scopePath, "utf-8");
     const parsed = JSON.parse(raw);
     if (!parsed || !Array.isArray(parsed.files)) {
       return null;
@@ -113178,12 +113786,12 @@ function createEmptyPlan(phaseNumber, planId) {
 // src/tools/lean-turbo-plan-lanes.ts
 init_create_tool();
 function readPlanJson(directory) {
-  const planPath = path123.join(directory, ".swarm", "plan.json");
-  if (!fs85.existsSync(planPath)) {
+  const planPath = path124.join(directory, ".swarm", "plan.json");
+  if (!fs86.existsSync(planPath)) {
     return null;
   }
   try {
-    return JSON.parse(fs85.readFileSync(planPath, "utf-8"));
+    return JSON.parse(fs86.readFileSync(planPath, "utf-8"));
   } catch {
     return null;
   }
@@ -113233,16 +113841,16 @@ init_config();
 
 // src/turbo/lean/reviewer.ts
 init_state();
-import * as fs87 from "node:fs/promises";
-import * as path125 from "node:path";
+import * as fs88 from "node:fs/promises";
+import * as path126 from "node:path";
 
 // src/turbo/lean/evidence.ts
 init_bun_compat();
 import { rmSync as rmSync6 } from "node:fs";
-import * as fs86 from "node:fs/promises";
-import * as path124 from "node:path";
+import * as fs87 from "node:fs/promises";
+import * as path125 from "node:path";
 function leanTurboEvidenceDir(directory, phase) {
-  return path124.join(directory, ".swarm", "evidence", String(phase), "lean-turbo");
+  return path125.join(directory, ".swarm", "evidence", String(phase), "lean-turbo");
 }
 function validateLaneId(laneId) {
   if (laneId.length === 0) {
@@ -113264,21 +113872,21 @@ function validateLaneId(laneId) {
 function laneEvidencePath(directory, phase, laneId) {
   validateLaneId(laneId);
   const expectedDir = leanTurboEvidenceDir(directory, phase);
-  const resolvedPath = path124.resolve(path124.join(expectedDir, `${laneId}.json`));
-  const resolvedDir = path124.resolve(expectedDir);
-  if (!resolvedPath.startsWith(resolvedDir + path124.sep) && resolvedPath !== resolvedDir) {
+  const resolvedPath = path125.resolve(path125.join(expectedDir, `${laneId}.json`));
+  const resolvedDir = path125.resolve(expectedDir);
+  if (!resolvedPath.startsWith(resolvedDir + path125.sep) && resolvedPath !== resolvedDir) {
     throw new Error(`Invalid laneId: path traversal detected (got "${laneId}")`);
   }
   return resolvedPath;
 }
 async function atomicWriteJson(filePath, data) {
   const content = JSON.stringify(data, null, 2);
-  const dir = path124.dirname(filePath);
-  await fs86.mkdir(dir, { recursive: true });
+  const dir = path125.dirname(filePath);
+  await fs87.mkdir(dir, { recursive: true });
   const tempPath = `${filePath}.tmp.${process.pid}.${Date.now()}.${Math.random().toString(36).slice(2)}`;
   try {
     await bunWrite(tempPath, content);
-    await fs86.rename(tempPath, filePath);
+    await fs87.rename(tempPath, filePath);
   } catch (error93) {
     try {
       rmSync6(tempPath, { force: true });
@@ -113287,7 +113895,7 @@ async function atomicWriteJson(filePath, data) {
   }
 }
 function phaseEvidencePath(directory, phase) {
-  return path124.join(leanTurboEvidenceDir(directory, phase), "lean-turbo-phase.json");
+  return path125.join(leanTurboEvidenceDir(directory, phase), "lean-turbo-phase.json");
 }
 async function writeLaneEvidence(directory, phase, evidence) {
   const targetPath = laneEvidencePath(directory, phase, evidence.laneId);
@@ -113297,7 +113905,7 @@ async function readPhaseEvidence(directory, phase) {
   const targetPath = phaseEvidencePath(directory, phase);
   let content;
   try {
-    content = await fs86.readFile(targetPath, "utf-8");
+    content = await fs87.readFile(targetPath, "utf-8");
   } catch (error93) {
     const code = error93.code;
     if (code === "ENOENT" || code === "ENOTDIR") {
@@ -113315,7 +113923,7 @@ async function listLaneEvidence(directory, phase) {
   const evidenceDir = leanTurboEvidenceDir(directory, phase);
   let entries;
   try {
-    entries = await fs86.readdir(evidenceDir);
+    entries = await fs87.readdir(evidenceDir);
   } catch (error93) {
     const code = error93.code;
     if (code === "ENOENT" || code === "ENOTDIR") {
@@ -113331,10 +113939,10 @@ async function listLaneEvidence(directory, phase) {
     if (entry === "lean-turbo-phase.json") {
       continue;
     }
-    const filePath = path124.join(evidenceDir, entry);
+    const filePath = path125.join(evidenceDir, entry);
     let content;
     try {
-      content = await fs86.readFile(filePath, "utf-8");
+      content = await fs87.readFile(filePath, "utf-8");
     } catch {
       continue;
     }
@@ -113462,9 +114070,9 @@ function parseReviewerVerdict(responseText) {
   return { verdict, reason };
 }
 async function writeReviewerEvidence(directory, phase, verdict, reason) {
-  const evidenceDir = path125.join(directory, ".swarm", "evidence", String(phase));
-  await fs87.mkdir(evidenceDir, { recursive: true });
-  const evidencePath = path125.join(evidenceDir, "lean-turbo-reviewer.json");
+  const evidenceDir = path126.join(directory, ".swarm", "evidence", String(phase));
+  await fs88.mkdir(evidenceDir, { recursive: true });
+  const evidencePath = path126.join(evidenceDir, "lean-turbo-reviewer.json");
   const content = JSON.stringify({
     phase,
     verdict,
@@ -113473,11 +114081,11 @@ async function writeReviewerEvidence(directory, phase, verdict, reason) {
   }, null, 2);
   const tempPath = `${evidencePath}.tmp.${process.pid}.${Date.now()}`;
   try {
-    await fs87.writeFile(tempPath, content, "utf-8");
-    await fs87.rename(tempPath, evidencePath);
+    await fs88.writeFile(tempPath, content, "utf-8");
+    await fs88.rename(tempPath, evidencePath);
   } catch (error93) {
     try {
-      await fs87.unlink(tempPath);
+      await fs88.unlink(tempPath);
     } catch {}
     throw error93;
   }
@@ -114275,8 +114883,8 @@ init_lint();
 // src/tools/lint-spec.ts
 init_spec_schema();
 init_create_tool();
-import * as fs88 from "node:fs";
-import * as path126 from "node:path";
+import * as fs89 from "node:fs";
+import * as path127 from "node:path";
 var SPEC_FILE_NAME = "spec.md";
 var SWARM_DIR2 = ".swarm";
 var OBLIGATION_KEYWORDS = ["MUST", "SHALL", "SHOULD", "MAY"];
@@ -114329,8 +114937,8 @@ var lint_spec = createSwarmTool({
   async execute(_args, directory) {
     const errors5 = [];
     const warnings = [];
-    const specPath = path126.join(directory, SWARM_DIR2, SPEC_FILE_NAME);
-    if (!fs88.existsSync(specPath)) {
+    const specPath = path127.join(directory, SWARM_DIR2, SPEC_FILE_NAME);
+    if (!fs89.existsSync(specPath)) {
       const result2 = {
         valid: false,
         specMtime: null,
@@ -114349,12 +114957,12 @@ var lint_spec = createSwarmTool({
     }
     let specMtime = null;
     try {
-      const stats = fs88.statSync(specPath);
+      const stats = fs89.statSync(specPath);
       specMtime = stats.mtime.toISOString();
     } catch {}
     let content;
     try {
-      content = fs88.readFileSync(specPath, "utf-8");
+      content = fs89.readFileSync(specPath, "utf-8");
     } catch (e) {
       const result2 = {
         valid: false,
@@ -114400,13 +115008,13 @@ var lint_spec = createSwarmTool({
 
 // src/tools/mutation-test.ts
 init_zod();
-import * as fs89 from "node:fs";
-import * as path128 from "node:path";
+import * as fs90 from "node:fs";
+import * as path129 from "node:path";
 
 // src/mutation/engine.ts
-import { spawnSync as spawnSync8 } from "node:child_process";
+import { spawnSync as spawnSync9 } from "node:child_process";
 import { unlinkSync as unlinkSync18, writeFileSync as writeFileSync24 } from "node:fs";
-import * as path127 from "node:path";
+import * as path128 from "node:path";
 
 // src/mutation/equivalence.ts
 function isStaticallyEquivalent(originalCode, mutatedCode) {
@@ -114541,7 +115149,7 @@ var _internals57 = {
   executeMutation,
   computeReport,
   executeMutationSuite,
-  spawnSync: spawnSync8
+  spawnSync: spawnSync9
 };
 async function executeMutation(patch, testCommand, _testFiles, workingDir) {
   const startTime = Date.now();
@@ -114552,7 +115160,7 @@ async function executeMutation(patch, testCommand, _testFiles, workingDir) {
   let patchFile;
   try {
     const safeId2 = patch.id.replace(/[^a-zA-Z0-9_-]/g, "_");
-    patchFile = path127.join(workingDir, `.mutation_patch_${safeId2}.diff`);
+    patchFile = path128.join(workingDir, `.mutation_patch_${safeId2}.diff`);
     try {
       writeFileSync24(patchFile, patch.patch);
     } catch (writeErr) {
@@ -114956,8 +115564,8 @@ var mutation_test = createSwarmTool({
       ];
       for (const filePath of uniquePaths) {
         try {
-          const resolvedPath = path128.resolve(cwd, filePath);
-          sourceFiles.set(filePath, fs89.readFileSync(resolvedPath, "utf-8"));
+          const resolvedPath = path129.resolve(cwd, filePath);
+          sourceFiles.set(filePath, fs90.readFileSync(resolvedPath, "utf-8"));
         } catch {}
       }
       const report = await executeMutationSuite(typedArgs.patches, typedArgs.test_command, typedArgs.files, cwd, undefined, undefined, sourceFiles.size > 0 ? sourceFiles : undefined);
@@ -114977,30 +115585,30 @@ init_zod();
 init_config();
 init_schema();
 init_manager2();
-import * as fs99 from "node:fs";
-import * as path138 from "node:path";
+import * as fs100 from "node:fs";
+import * as path139 from "node:path";
 
 // src/full-auto/phase-approval.ts
 init_utils2();
 init_logger();
 init_state2();
-import * as fs90 from "node:fs";
-import * as path129 from "node:path";
+import * as fs91 from "node:fs";
+import * as path130 from "node:path";
 var APPROVAL_TTL_MS = 24 * 60 * 60 * 1000;
 function readEvidenceDir(directory, phase) {
   try {
-    const dirPath = validateSwarmPath(directory, path129.posix.join("evidence", String(phase)));
-    if (!fs90.existsSync(dirPath))
+    const dirPath = validateSwarmPath(directory, path130.posix.join("evidence", String(phase)));
+    if (!fs91.existsSync(dirPath))
       return [];
-    const entries = fs90.readdirSync(dirPath);
-    return entries.filter((e) => e.startsWith("full-auto-") && e.endsWith(".json")).map((e) => path129.join(dirPath, e));
+    const entries = fs91.readdirSync(dirPath);
+    return entries.filter((e) => e.startsWith("full-auto-") && e.endsWith(".json")).map((e) => path130.join(dirPath, e));
   } catch {
     return [];
   }
 }
 function parseEvidence(filePath) {
   try {
-    const raw = fs90.readFileSync(filePath, "utf-8");
+    const raw = fs91.readFileSync(filePath, "utf-8");
     const parsed = JSON.parse(raw);
     return parsed;
   } catch (error93) {
@@ -115089,9 +115697,9 @@ function verifyFullAutoPhaseApproval(directory, sessionID, phase, config3) {
 function phaseIsExplicitlyNonCode(directory, phase) {
   try {
     const planPath = validateSwarmPath(directory, "plan.json");
-    if (!fs90.existsSync(planPath))
+    if (!fs91.existsSync(planPath))
       return false;
-    const raw = fs90.readFileSync(planPath, "utf-8");
+    const raw = fs91.readFileSync(planPath, "utf-8");
     const plan = JSON.parse(raw);
     const phases = Array.isArray(plan.phases) ? plan.phases : [];
     const entry = phases.find((p) => p.id === phase || p.phase === phase);
@@ -115133,20 +115741,20 @@ init_file_locks();
 init_plan_schema();
 init_ledger();
 init_manager();
-import * as fs91 from "node:fs";
-import * as path130 from "node:path";
+import * as fs92 from "node:fs";
+import * as path131 from "node:path";
 async function writeCheckpoint(directory) {
   try {
     const plan = await loadPlan(directory);
     if (!plan)
       return;
-    const swarmDir = path130.join(directory, ".swarm");
-    fs91.mkdirSync(swarmDir, { recursive: true });
-    const jsonPath = path130.join(swarmDir, "SWARM_PLAN.json");
-    const mdPath = path130.join(swarmDir, "SWARM_PLAN.md");
-    fs91.writeFileSync(jsonPath, JSON.stringify(plan, null, 2), "utf8");
+    const swarmDir = path131.join(directory, ".swarm");
+    fs92.mkdirSync(swarmDir, { recursive: true });
+    const jsonPath = path131.join(swarmDir, "SWARM_PLAN.json");
+    const mdPath = path131.join(swarmDir, "SWARM_PLAN.md");
+    fs92.writeFileSync(jsonPath, JSON.stringify(plan, null, 2), "utf8");
     const md = derivePlanMarkdown(plan);
-    fs91.writeFileSync(mdPath, md, "utf8");
+    fs92.writeFileSync(mdPath, md, "utf8");
   } catch (error93) {
     console.warn(`[checkpoint] Failed to write SWARM_PLAN checkpoint: ${error93 instanceof Error ? error93.message : String(error93)}`);
   }
@@ -115161,8 +115769,8 @@ init_telemetry();
 
 // src/turbo/lean/phase-ready.ts
 init_file_locks();
-import * as fs92 from "node:fs";
-import * as path131 from "node:path";
+import * as fs93 from "node:fs";
+import * as path132 from "node:path";
 init_state3();
 var DEFAULT_CONFIG3 = {
   phase_reviewer: true,
@@ -115171,10 +115779,10 @@ var DEFAULT_CONFIG3 = {
 };
 function defaultReadPlanJson(dir) {
   try {
-    const planPath = path131.join(dir, ".swarm", "plan.json");
-    if (!fs92.existsSync(planPath))
+    const planPath = path132.join(dir, ".swarm", "plan.json");
+    if (!fs93.existsSync(planPath))
       return null;
-    const raw = fs92.readFileSync(planPath, "utf-8");
+    const raw = fs93.readFileSync(planPath, "utf-8");
     const plan = JSON.parse(raw);
     if (typeof plan !== "object" || plan === null || !Array.isArray(plan.phases)) {
       return null;
@@ -115186,11 +115794,11 @@ function defaultReadPlanJson(dir) {
 }
 function readReviewerEvidenceFromFile(directory, phase) {
   try {
-    const evidencePath = path131.join(directory, ".swarm", "evidence", String(phase), "lean-turbo-reviewer.json");
-    if (!fs92.existsSync(evidencePath)) {
+    const evidencePath = path132.join(directory, ".swarm", "evidence", String(phase), "lean-turbo-reviewer.json");
+    if (!fs93.existsSync(evidencePath)) {
       return null;
     }
-    const raw = fs92.readFileSync(evidencePath, "utf-8");
+    const raw = fs93.readFileSync(evidencePath, "utf-8");
     const parsed = JSON.parse(raw);
     if (typeof parsed !== "object" || parsed === null || typeof parsed.verdict !== "string") {
       return null;
@@ -115206,11 +115814,11 @@ function readReviewerEvidenceFromFile(directory, phase) {
 }
 function readCriticEvidenceFromFile(directory, phase) {
   try {
-    const evidencePath = path131.join(directory, ".swarm", "evidence", String(phase), "lean-turbo-critic.json");
-    if (!fs92.existsSync(evidencePath)) {
+    const evidencePath = path132.join(directory, ".swarm", "evidence", String(phase), "lean-turbo-critic.json");
+    if (!fs93.existsSync(evidencePath)) {
       return null;
     }
-    const raw = fs92.readFileSync(evidencePath, "utf-8");
+    const raw = fs93.readFileSync(evidencePath, "utf-8");
     const parsed = JSON.parse(raw);
     if (typeof parsed !== "object" || parsed === null || typeof parsed.verdict !== "string") {
       return null;
@@ -115225,10 +115833,10 @@ function readCriticEvidenceFromFile(directory, phase) {
   }
 }
 function listLaneEvidenceSync(directory, phase) {
-  const evidenceDir = path131.join(directory, ".swarm", "evidence", String(phase), "lean-turbo");
+  const evidenceDir = path132.join(directory, ".swarm", "evidence", String(phase), "lean-turbo");
   let entries;
   try {
-    entries = fs92.readdirSync(evidenceDir);
+    entries = fs93.readdirSync(evidenceDir);
   } catch {
     return [];
   }
@@ -115295,8 +115903,8 @@ function verifyLeanTurboPhaseReady(directory, phase, sessionIDOrConfig, config3)
     ...DEFAULT_CONFIG3,
     ...actualConfig
   };
-  const statePath = path131.join(directory, ".swarm", "turbo-state.json");
-  if (!fs92.existsSync(statePath)) {
+  const statePath = path132.join(directory, ".swarm", "turbo-state.json");
+  if (!fs93.existsSync(statePath)) {
     return {
       ok: false,
       reason: "Lean Turbo state unreadable or missing"
@@ -115483,10 +116091,10 @@ function verifyLeanTurboPhaseReady(directory, phase, sessionIDOrConfig, config3)
     }
   }
   if (mergedConfig.integrated_diff_required) {
-    const evidencePath = path131.join(directory, ".swarm", "evidence", String(phase), "lean-turbo-phase.json");
+    const evidencePath = path132.join(directory, ".swarm", "evidence", String(phase), "lean-turbo-phase.json");
     let hasDiff = false;
     try {
-      const content = fs92.readFileSync(evidencePath, "utf-8");
+      const content = fs93.readFileSync(evidencePath, "utf-8");
       const evidence = JSON.parse(content);
       hasDiff = !!evidence.integratedDiffSummary;
     } catch {}
@@ -115634,15 +116242,15 @@ async function runCompletionVerifyGate(ctx) {
 init_qa_gate_profile();
 init_manager();
 init_state();
-import * as fs93 from "node:fs";
-import * as path132 from "node:path";
+import * as fs94 from "node:fs";
+import * as path133 from "node:path";
 async function runDriftGate(ctx) {
   const { phase, dir, sessionID, agentsDispatched, safeWarn } = ctx;
   let driftCheckEnabled = true;
   let driftHasSpecMd = false;
   try {
-    const specMdPath = path132.join(dir, ".swarm", "spec.md");
-    driftHasSpecMd = fs93.existsSync(specMdPath);
+    const specMdPath = path133.join(dir, ".swarm", "spec.md");
+    driftHasSpecMd = fs94.existsSync(specMdPath);
     const gatePlan = await loadPlan(dir);
     if (gatePlan) {
       const gatePlanId = derivePlanId(gatePlan);
@@ -115669,9 +116277,9 @@ async function runDriftGate(ctx) {
   }
   let phaseType;
   try {
-    const planPath = path132.join(dir, ".swarm", "plan.json");
-    if (fs93.existsSync(planPath)) {
-      const planRaw = fs93.readFileSync(planPath, "utf-8");
+    const planPath = path133.join(dir, ".swarm", "plan.json");
+    if (fs94.existsSync(planPath)) {
+      const planRaw = fs94.readFileSync(planPath, "utf-8");
       const plan = JSON.parse(planRaw);
       const targetPhase = plan.phases?.find((p) => p.id === phase);
       phaseType = targetPhase?.type;
@@ -115688,11 +116296,11 @@ async function runDriftGate(ctx) {
     };
   }
   try {
-    const driftEvidencePath = path132.join(dir, ".swarm", "evidence", String(phase), "drift-verifier.json");
+    const driftEvidencePath = path133.join(dir, ".swarm", "evidence", String(phase), "drift-verifier.json");
     let driftVerdictFound = false;
     let driftVerdictApproved = false;
     try {
-      const driftEvidenceContent = fs93.readFileSync(driftEvidencePath, "utf-8");
+      const driftEvidenceContent = fs94.readFileSync(driftEvidencePath, "utf-8");
       const driftEvidence = JSON.parse(driftEvidenceContent);
       const entries = driftEvidence.entries ?? [];
       for (const entry of entries) {
@@ -115724,9 +116332,9 @@ async function runDriftGate(ctx) {
         let incompleteTaskCount = 0;
         let planParseable = false;
         try {
-          const planPath = path132.join(dir, ".swarm", "plan.json");
-          if (fs93.existsSync(planPath)) {
-            const planRaw = fs93.readFileSync(planPath, "utf-8");
+          const planPath = path133.join(dir, ".swarm", "plan.json");
+          if (fs94.existsSync(planPath)) {
+            const planRaw = fs94.readFileSync(planPath, "utf-8");
             const plan = JSON.parse(planRaw);
             planParseable = true;
             const planPhase = plan.phases?.find((p) => p.id === phase);
@@ -115805,8 +116413,8 @@ async function runDriftGate(ctx) {
 init_qa_gate_profile();
 init_manager();
 init_state();
-import * as fs94 from "node:fs";
-import * as path133 from "node:path";
+import * as fs95 from "node:fs";
+import * as path134 from "node:path";
 async function runFinalCouncilGate(ctx) {
   const { phase, dir, sessionID, agentsDispatched, safeWarn } = ctx;
   let finalCouncilEnabled = false;
@@ -115823,11 +116431,11 @@ async function runFinalCouncilGate(ctx) {
           const effective = getEffectiveGates(profile, overrides);
           if (effective.final_council === true) {
             finalCouncilEnabled = true;
-            const fcPath = path133.join(dir, ".swarm", "evidence", "final-council.json");
+            const fcPath = path134.join(dir, ".swarm", "evidence", "final-council.json");
             let fcVerdictFound = false;
             let _fcVerdict;
             try {
-              const fcContent = fs94.readFileSync(fcPath, "utf-8");
+              const fcContent = fs95.readFileSync(fcPath, "utf-8");
               const fcBundle = JSON.parse(fcContent);
               for (const entry of fcBundle.entries ?? []) {
                 if (typeof entry.type === "string" && entry.type === "final-council" && typeof entry.verdict === "string") {
@@ -115952,8 +116560,8 @@ async function runFinalCouncilGate(ctx) {
 init_qa_gate_profile();
 init_manager();
 init_state();
-import * as fs95 from "node:fs";
-import * as path134 from "node:path";
+import * as fs96 from "node:fs";
+import * as path135 from "node:path";
 async function runHallucinationGate(ctx) {
   const { phase, dir, sessionID, agentsDispatched, safeWarn } = ctx;
   try {
@@ -115966,11 +116574,11 @@ async function runHallucinationGate(ctx) {
         const overrides = session?.qaGateSessionOverrides ?? {};
         const effective = getEffectiveGates(profile, overrides);
         if (effective.hallucination_guard === true) {
-          const hgPath = path134.join(dir, ".swarm", "evidence", String(phase), "hallucination-guard.json");
+          const hgPath = path135.join(dir, ".swarm", "evidence", String(phase), "hallucination-guard.json");
           let hgVerdictFound = false;
           let hgVerdictApproved = false;
           try {
-            const hgContent = fs95.readFileSync(hgPath, "utf-8");
+            const hgContent = fs96.readFileSync(hgPath, "utf-8");
             const hgBundle = JSON.parse(hgContent);
             for (const entry of hgBundle.entries ?? []) {
               if (typeof entry.type === "string" && entry.type.includes("hallucination") && typeof entry.verdict === "string") {
@@ -116028,8 +116636,8 @@ async function runHallucinationGate(ctx) {
 init_qa_gate_profile();
 init_manager();
 init_state();
-import * as fs96 from "node:fs";
-import * as path135 from "node:path";
+import * as fs97 from "node:fs";
+import * as path136 from "node:path";
 async function runMutationGate(ctx) {
   const { phase, dir, sessionID, agentsDispatched, safeWarn } = ctx;
   try {
@@ -116042,11 +116650,11 @@ async function runMutationGate(ctx) {
         const overrides = session?.qaGateSessionOverrides ?? {};
         const effective = getEffectiveGates(profile, overrides);
         if (effective.mutation_test === true) {
-          const mgPath = path135.join(dir, ".swarm", "evidence", String(phase), "mutation-gate.json");
+          const mgPath = path136.join(dir, ".swarm", "evidence", String(phase), "mutation-gate.json");
           let mgVerdictFound = false;
           let mgVerdict;
           try {
-            const mgContent = fs96.readFileSync(mgPath, "utf-8");
+            const mgContent = fs97.readFileSync(mgPath, "utf-8");
             const mgBundle = JSON.parse(mgContent);
             for (const entry of mgBundle.entries ?? []) {
               if (typeof entry.type === "string" && entry.type === "mutation-gate" && typeof entry.verdict === "string") {
@@ -116104,8 +116712,8 @@ async function runMutationGate(ctx) {
 init_qa_gate_profile();
 init_manager();
 init_state();
-import * as fs97 from "node:fs";
-import * as path136 from "node:path";
+import * as fs98 from "node:fs";
+import * as path137 from "node:path";
 async function runPhaseCouncilGate(ctx) {
   const { phase, dir, sessionID, pluginConfig, agentsDispatched, safeWarn } = ctx;
   let councilModeEnabled = false;
@@ -116120,14 +116728,14 @@ async function runPhaseCouncilGate(ctx) {
         const effective = getEffectiveGates(profile, overrides);
         if (effective.council_mode === true) {
           councilModeEnabled = true;
-          const pcPath = path136.join(dir, ".swarm", "evidence", String(phase), "phase-council.json");
+          const pcPath = path137.join(dir, ".swarm", "evidence", String(phase), "phase-council.json");
           let pcVerdictFound = false;
           let _pcVerdict;
           let pcQuorumSize;
           let pcTimestamp;
           let pcPhaseNumber;
           try {
-            const pcContent = fs97.readFileSync(pcPath, "utf-8");
+            const pcContent = fs98.readFileSync(pcPath, "utf-8");
             const pcBundle = JSON.parse(pcContent);
             for (const entry of pcBundle.entries ?? []) {
               if (typeof entry.type === "string" && entry.type === "phase-council" && typeof entry.verdict === "string") {
@@ -116635,7 +117243,7 @@ async function executePhaseComplete(args2, workingDirectory, directory) {
   }
   if (retroFound && retroEntry?.lessons_learned && retroEntry.lessons_learned.length > 0) {
     try {
-      const projectName = path138.basename(dir);
+      const projectName = path139.basename(dir);
       const curationResult = await curateAndStoreSwarm(retroEntry.lessons_learned, projectName, { phase_number: phase }, dir, knowledgeConfig);
       if (curationResult) {
         const sessionState = swarmState.agentSessions.get(sessionID);
@@ -116735,14 +117343,14 @@ async function executePhaseComplete(args2, workingDirectory, directory) {
     const markerPath = validateSwarmPath(dir, "skill-usage-last-processed.json");
     let sinceTimestamp;
     try {
-      const markerData = JSON.parse(fs99.readFileSync(markerPath, "utf-8"));
+      const markerData = JSON.parse(fs100.readFileSync(markerPath, "utf-8"));
       sinceTimestamp = markerData.lastProcessedTimestamp;
     } catch {}
     const feedbackResult = await applySkillUsageFeedback(dir, {
       sinceTimestamp
     });
     try {
-      fs99.writeFileSync(markerPath, JSON.stringify({ lastProcessedTimestamp: new Date().toISOString() }), "utf-8");
+      fs100.writeFileSync(markerPath, JSON.stringify({ lastProcessedTimestamp: new Date().toISOString() }), "utf-8");
     } catch {}
     if (feedbackResult.processed > 0) {
       const sessionState = swarmState.agentSessions.get(sessionID);
@@ -116762,7 +117370,7 @@ async function executePhaseComplete(args2, workingDirectory, directory) {
   let phaseRequiredAgents;
   try {
     const planPath = validateSwarmPath(dir, "plan.json");
-    const planRaw = fs99.readFileSync(planPath, "utf-8");
+    const planRaw = fs100.readFileSync(planPath, "utf-8");
     const plan = JSON.parse(planRaw);
     const phaseObj = plan.phases.find((p) => p.id === phase);
     phaseRequiredAgents = phaseObj?.required_agents;
@@ -116777,7 +117385,7 @@ async function executePhaseComplete(args2, workingDirectory, directory) {
   if (agentsMissing.length > 0) {
     try {
       const planPath = validateSwarmPath(dir, "plan.json");
-      const planRaw = fs99.readFileSync(planPath, "utf-8");
+      const planRaw = fs100.readFileSync(planPath, "utf-8");
       const plan = JSON.parse(planRaw);
       const targetPhase = plan.phases.find((p) => p.id === phase);
       if (targetPhase && targetPhase.tasks.length > 0 && canInferMissingAgentsFromTaskGates(agentsMissing) && await allCompletedTasksHavePassedGateEvidence(dir, targetPhase.tasks)) {
@@ -116817,7 +117425,7 @@ async function executePhaseComplete(args2, workingDirectory, directory) {
   if (phaseCompleteConfig.regression_sweep?.enforce) {
     try {
       const planPath = validateSwarmPath(dir, "plan.json");
-      const planRaw = fs99.readFileSync(planPath, "utf-8");
+      const planRaw = fs100.readFileSync(planPath, "utf-8");
       const plan = JSON.parse(planRaw);
       const targetPhase = plan.phases.find((p) => p.id === phase);
       if (targetPhase) {
@@ -116871,7 +117479,7 @@ async function executePhaseComplete(args2, workingDirectory, directory) {
   }
   try {
     const eventsPath = validateSwarmPath(dir, "events.jsonl");
-    fs99.appendFileSync(eventsPath, `${JSON.stringify(event)}
+    fs100.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)}`);
@@ -116946,12 +117554,12 @@ async function executePhaseComplete(args2, workingDirectory, directory) {
         warnings.push(`Warning: failed to update plan.json phase status`);
         try {
           const planPath = validateSwarmPath(dir, "plan.json");
-          const planRaw = fs99.readFileSync(planPath, "utf-8");
+          const planRaw = fs100.readFileSync(planPath, "utf-8");
           const plan2 = JSON.parse(planRaw);
           const phaseObj = plan2.phases.find((p) => p.id === phase);
           if (phaseObj) {
             phaseObj.status = "complete";
-            fs99.writeFileSync(planPath, JSON.stringify(plan2, null, 2), "utf-8");
+            fs100.writeFileSync(planPath, JSON.stringify(plan2, null, 2), "utf-8");
           }
         } catch {}
       } else if (plan) {
@@ -116988,12 +117596,12 @@ async function executePhaseComplete(args2, workingDirectory, directory) {
       warnings.push(`Warning: failed to update plan.json phase status`);
       try {
         const planPath = validateSwarmPath(dir, "plan.json");
-        const planRaw = fs99.readFileSync(planPath, "utf-8");
+        const planRaw = fs100.readFileSync(planPath, "utf-8");
         const plan = JSON.parse(planRaw);
         const phaseObj = plan.phases.find((p) => p.id === phase);
         if (phaseObj) {
           phaseObj.status = "complete";
-          fs99.writeFileSync(planPath, JSON.stringify(plan, null, 2), "utf-8");
+          fs100.writeFileSync(planPath, JSON.stringify(plan, null, 2), "utf-8");
         }
       } catch {}
     }
@@ -117077,8 +117685,8 @@ init_discovery();
 init_utils();
 init_bun_compat();
 init_create_tool();
-import * as fs100 from "node:fs";
-import * as path139 from "node:path";
+import * as fs101 from "node:fs";
+import * as path140 from "node:path";
 var MAX_OUTPUT_BYTES6 = 52428800;
 var AUDIT_TIMEOUT_MS = 120000;
 function isValidEcosystem(value) {
@@ -117106,31 +117714,31 @@ function validateArgs3(args2) {
 function detectEcosystems(directory) {
   const ecosystems = [];
   const cwd = directory;
-  if (fs100.existsSync(path139.join(cwd, "package.json"))) {
+  if (fs101.existsSync(path140.join(cwd, "package.json"))) {
     ecosystems.push("npm");
   }
-  if (fs100.existsSync(path139.join(cwd, "pyproject.toml")) || fs100.existsSync(path139.join(cwd, "requirements.txt"))) {
+  if (fs101.existsSync(path140.join(cwd, "pyproject.toml")) || fs101.existsSync(path140.join(cwd, "requirements.txt"))) {
     ecosystems.push("pip");
   }
-  if (fs100.existsSync(path139.join(cwd, "Cargo.toml"))) {
+  if (fs101.existsSync(path140.join(cwd, "Cargo.toml"))) {
     ecosystems.push("cargo");
   }
-  if (fs100.existsSync(path139.join(cwd, "go.mod"))) {
+  if (fs101.existsSync(path140.join(cwd, "go.mod"))) {
     ecosystems.push("go");
   }
   try {
-    const files = fs100.readdirSync(cwd);
+    const files = fs101.readdirSync(cwd);
     if (files.some((f) => f.endsWith(".csproj") || f.endsWith(".sln"))) {
       ecosystems.push("dotnet");
     }
   } catch {}
-  if (fs100.existsSync(path139.join(cwd, "Gemfile")) || fs100.existsSync(path139.join(cwd, "Gemfile.lock"))) {
+  if (fs101.existsSync(path140.join(cwd, "Gemfile")) || fs101.existsSync(path140.join(cwd, "Gemfile.lock"))) {
     ecosystems.push("ruby");
   }
-  if (fs100.existsSync(path139.join(cwd, "pubspec.yaml"))) {
+  if (fs101.existsSync(path140.join(cwd, "pubspec.yaml"))) {
     ecosystems.push("dart");
   }
-  if (fs100.existsSync(path139.join(cwd, "composer.lock"))) {
+  if (fs101.existsSync(path140.join(cwd, "composer.lock"))) {
     ecosystems.push("composer");
   }
   return ecosystems;
@@ -117143,7 +117751,7 @@ async function runNpmAudit(directory) {
       stderr: "pipe",
       cwd: directory
     });
-    const timeoutPromise = new Promise((resolve47) => setTimeout(() => resolve47("timeout"), AUDIT_TIMEOUT_MS));
+    const timeoutPromise = new Promise((resolve48) => setTimeout(() => resolve48("timeout"), AUDIT_TIMEOUT_MS));
     const result = await Promise.race([
       Promise.all([proc.stdout.text(), proc.stderr.text()]).then(([stdout2, stderr2]) => ({ stdout: stdout2, stderr: stderr2 })),
       timeoutPromise
@@ -117263,7 +117871,7 @@ async function runPipAudit(directory) {
       stderr: "pipe",
       cwd: directory
     });
-    const timeoutPromise = new Promise((resolve47) => setTimeout(() => resolve47("timeout"), AUDIT_TIMEOUT_MS));
+    const timeoutPromise = new Promise((resolve48) => setTimeout(() => resolve48("timeout"), AUDIT_TIMEOUT_MS));
     const result = await Promise.race([
       Promise.all([proc.stdout.text(), proc.stderr.text()]).then(([stdout2, stderr2]) => ({ stdout: stdout2, stderr: stderr2 })),
       timeoutPromise
@@ -117391,7 +117999,7 @@ async function runCargoAudit(directory) {
       stderr: "pipe",
       cwd: directory
     });
-    const timeoutPromise = new Promise((resolve47) => setTimeout(() => resolve47("timeout"), AUDIT_TIMEOUT_MS));
+    const timeoutPromise = new Promise((resolve48) => setTimeout(() => resolve48("timeout"), AUDIT_TIMEOUT_MS));
     const result = await Promise.race([
       Promise.all([proc.stdout.text(), proc.stderr.text()]).then(([stdout2, stderr]) => ({ stdout: stdout2, stderr })),
       timeoutPromise
@@ -117515,7 +118123,7 @@ async function runGoAudit(directory) {
       stderr: "pipe",
       cwd: directory
     });
-    const timeoutPromise = new Promise((resolve47) => setTimeout(() => resolve47("timeout"), AUDIT_TIMEOUT_MS));
+    const timeoutPromise = new Promise((resolve48) => setTimeout(() => resolve48("timeout"), AUDIT_TIMEOUT_MS));
     const result = await Promise.race([
       Promise.all([proc.stdout.text(), proc.stderr.text()]).then(([stdout2, stderr]) => ({ stdout: stdout2, stderr })),
       timeoutPromise
@@ -117648,7 +118256,7 @@ async function runDotnetAudit(directory) {
       stderr: "pipe",
       cwd: directory
     });
-    const timeoutPromise = new Promise((resolve47) => setTimeout(() => resolve47("timeout"), AUDIT_TIMEOUT_MS));
+    const timeoutPromise = new Promise((resolve48) => setTimeout(() => resolve48("timeout"), AUDIT_TIMEOUT_MS));
     const result = await Promise.race([
       Promise.all([proc.stdout.text(), proc.stderr.text()]).then(([stdout2, stderr]) => ({ stdout: stdout2, stderr })),
       timeoutPromise
@@ -117764,7 +118372,7 @@ async function runBundleAudit(directory) {
       stderr: "pipe",
       cwd: directory
     });
-    const timeoutPromise = new Promise((resolve47) => setTimeout(() => resolve47("timeout"), AUDIT_TIMEOUT_MS));
+    const timeoutPromise = new Promise((resolve48) => setTimeout(() => resolve48("timeout"), AUDIT_TIMEOUT_MS));
     const result = await Promise.race([
       Promise.all([proc.stdout.text(), proc.stderr.text()]).then(([stdout2, stderr]) => ({ stdout: stdout2, stderr })),
       timeoutPromise
@@ -117909,7 +118517,7 @@ async function runDartAudit(directory) {
       stderr: "pipe",
       cwd: directory
     });
-    const timeoutPromise = new Promise((resolve47) => setTimeout(() => resolve47("timeout"), AUDIT_TIMEOUT_MS));
+    const timeoutPromise = new Promise((resolve48) => setTimeout(() => resolve48("timeout"), AUDIT_TIMEOUT_MS));
     const result = await Promise.race([
       Promise.all([proc.stdout.text(), proc.stderr.text()]).then(([stdout2, stderr]) => ({ stdout: stdout2, stderr })),
       timeoutPromise
@@ -118024,7 +118632,7 @@ async function runComposerAudit(directory) {
       stderr: "pipe",
       cwd: directory
     });
-    const timeoutPromise = new Promise((resolve47) => setTimeout(() => resolve47("timeout"), AUDIT_TIMEOUT_MS));
+    const timeoutPromise = new Promise((resolve48) => setTimeout(() => resolve48("timeout"), AUDIT_TIMEOUT_MS));
     const result = await Promise.race([
       Promise.all([proc.stdout.text(), proc.stderr.text()]).then(([stdout2, stderr]) => ({ stdout: stdout2, stderr })),
       timeoutPromise
@@ -118266,8 +118874,8 @@ var pkg_audit = createSwarmTool({
 // src/tools/placeholder-scan.ts
 init_zod();
 init_manager2();
-import * as fs101 from "node:fs";
-import * as path140 from "node:path";
+import * as fs102 from "node:fs";
+import * as path141 from "node:path";
 init_utils();
 init_create_tool();
 var MAX_FILE_SIZE = 1024 * 1024;
@@ -118390,7 +118998,7 @@ function isScaffoldFile(filePath) {
   if (SCAFFOLD_PATH_PATTERNS.some((pattern) => pattern.test(normalizedPath))) {
     return true;
   }
-  const filename = path140.basename(filePath);
+  const filename = path141.basename(filePath);
   if (SCAFFOLD_FILENAME_PATTERNS.some((pattern) => pattern.test(filename))) {
     return true;
   }
@@ -118407,7 +119015,7 @@ function isAllowedByGlobs(filePath, allowGlobs) {
     if (regex.test(normalizedPath)) {
       return true;
     }
-    const filename = path140.basename(filePath);
+    const filename = path141.basename(filePath);
     const filenameRegex = new RegExp(`^${regexPattern}$`, "i");
     if (filenameRegex.test(filename)) {
       return true;
@@ -118416,7 +119024,7 @@ function isAllowedByGlobs(filePath, allowGlobs) {
   return false;
 }
 function isParserSupported(filePath) {
-  const ext = path140.extname(filePath).toLowerCase();
+  const ext = path141.extname(filePath).toLowerCase();
   return SUPPORTED_PARSER_EXTENSIONS.has(ext);
 }
 function isPlanFile(filePath) {
@@ -118663,28 +119271,28 @@ async function placeholderScan(input, directory) {
   let filesScanned = 0;
   const filesWithFindings = new Set;
   for (const filePath of changed_files) {
-    const fullPath = path140.isAbsolute(filePath) ? filePath : path140.resolve(directory, filePath);
-    const resolvedDirectory = path140.resolve(directory);
-    if (!fullPath.startsWith(resolvedDirectory + path140.sep) && fullPath !== resolvedDirectory) {
+    const fullPath = path141.isAbsolute(filePath) ? filePath : path141.resolve(directory, filePath);
+    const resolvedDirectory = path141.resolve(directory);
+    if (!fullPath.startsWith(resolvedDirectory + path141.sep) && fullPath !== resolvedDirectory) {
       continue;
     }
-    if (!fs101.existsSync(fullPath)) {
+    if (!fs102.existsSync(fullPath)) {
       continue;
     }
     if (isAllowedByGlobs(filePath, allow_globs)) {
       continue;
     }
-    const relativeFilePath = path140.relative(directory, fullPath).replace(/\\/g, "/");
+    const relativeFilePath = path141.relative(directory, fullPath).replace(/\\/g, "/");
     if (FILE_ALLOWLIST.some((allowed) => relativeFilePath.endsWith(allowed))) {
       continue;
     }
     let content;
     try {
-      const stat9 = fs101.statSync(fullPath);
+      const stat9 = fs102.statSync(fullPath);
       if (stat9.size > MAX_FILE_SIZE) {
         continue;
       }
-      content = fs101.readFileSync(fullPath, "utf-8");
+      content = fs102.readFileSync(fullPath, "utf-8");
     } catch {
       continue;
     }
@@ -118746,8 +119354,8 @@ var placeholder_scan = createSwarmTool({
 });
 
 // src/tools/pre-check-batch.ts
-import * as fs105 from "node:fs";
-import * as path144 from "node:path";
+import * as fs106 from "node:fs";
+import * as path145 from "node:path";
 init_zod();
 init_manager2();
 init_utils();
@@ -118887,9 +119495,9 @@ var _internals61 = {
 init_zod();
 init_manager2();
 init_detector();
-import * as fs104 from "node:fs";
-import * as path143 from "node:path";
-import { extname as extname20 } from "node:path";
+import * as fs105 from "node:fs";
+import * as path144 from "node:path";
+import { extname as extname21 } from "node:path";
 
 // src/sast/rules/c.ts
 var cRules = [
@@ -119602,9 +120210,9 @@ function executeRulesSync(filePath, content, language) {
 }
 
 // src/sast/semgrep.ts
-import * as child_process9 from "node:child_process";
-import * as fs102 from "node:fs";
-import * as path141 from "node:path";
+import * as child_process10 from "node:child_process";
+import * as fs103 from "node:fs";
+import * as path142 from "node:path";
 var semgrepAvailableCache = null;
 var DEFAULT_RULES_DIR = ".swarm/semgrep-rules";
 var DEFAULT_TIMEOUT_MS3 = 30000;
@@ -119621,7 +120229,7 @@ function isSemgrepAvailable() {
     return semgrepAvailableCache;
   }
   try {
-    child_process9.execFileSync("semgrep", ["--version"], {
+    child_process10.execFileSync("semgrep", ["--version"], {
       encoding: "utf-8",
       stdio: "pipe"
     });
@@ -119685,8 +120293,8 @@ function mapSemgrepSeverity(severity) {
   }
 }
 async function executeWithTimeout(command, args2, options) {
-  return new Promise((resolve49) => {
-    const child = child_process9.spawn(command, args2, {
+  return new Promise((resolve50) => {
+    const child = child_process10.spawn(command, args2, {
       shell: false,
       cwd: options.cwd
     });
@@ -119694,7 +120302,7 @@ async function executeWithTimeout(command, args2, options) {
     let stderr = "";
     const timeout = setTimeout(() => {
       child.kill("SIGTERM");
-      resolve49({
+      resolve50({
         stdout,
         stderr: "Process timed out",
         exitCode: 124
@@ -119708,7 +120316,7 @@ async function executeWithTimeout(command, args2, options) {
     });
     child.on("close", (code) => {
       clearTimeout(timeout);
-      resolve49({
+      resolve50({
         stdout,
         stderr,
         exitCode: code ?? 0
@@ -119716,7 +120324,7 @@ async function executeWithTimeout(command, args2, options) {
     });
     child.on("error", (err2) => {
       clearTimeout(timeout);
-      resolve49({
+      resolve50({
         stdout,
         stderr: err2.message,
         exitCode: 1
@@ -119791,14 +120399,14 @@ async function runSemgrep(options) {
 }
 function getRulesDirectory(projectRoot) {
   if (projectRoot) {
-    return path141.resolve(projectRoot, DEFAULT_RULES_DIR);
+    return path142.resolve(projectRoot, DEFAULT_RULES_DIR);
   }
   return DEFAULT_RULES_DIR;
 }
 function hasBundledRules(projectRoot) {
   const rulesDir = getRulesDirectory(projectRoot);
   try {
-    return fs102.existsSync(rulesDir);
+    return fs103.existsSync(rulesDir);
   } catch {
     return false;
   }
@@ -119811,25 +120419,25 @@ init_create_tool();
 // src/tools/sast-baseline.ts
 init_utils2();
 import * as crypto11 from "node:crypto";
-import * as fs103 from "node:fs";
-import * as path142 from "node:path";
+import * as fs104 from "node:fs";
+import * as path143 from "node:path";
 var BASELINE_SCHEMA_VERSION = "1.0.0";
 var MAX_BASELINE_FINDINGS = 2000;
 var MAX_BASELINE_BYTES = 2 * 1048576;
 var LOCK_RETRY_DELAYS_MS = [50, 100, 200, 400, 800];
 function normalizeFindingPath(directory, file3) {
-  const resolved = path142.isAbsolute(file3) ? file3 : path142.resolve(directory, file3);
-  const rel = path142.relative(path142.resolve(directory), resolved);
+  const resolved = path143.isAbsolute(file3) ? file3 : path143.resolve(directory, file3);
+  const rel = path143.relative(path143.resolve(directory), resolved);
   return rel.replace(/\\/g, "/");
 }
 function baselineRelPath(phase) {
-  return path142.join("evidence", String(phase), "sast-baseline.json");
+  return path143.join("evidence", String(phase), "sast-baseline.json");
 }
 function tempRelPath(phase) {
-  return path142.join("evidence", String(phase), `sast-baseline.json.tmp.${Date.now()}.${process.pid}`);
+  return path143.join("evidence", String(phase), `sast-baseline.json.tmp.${Date.now()}.${process.pid}`);
 }
 function lockRelPath(phase) {
-  return path142.join("evidence", String(phase), "sast-baseline.json.lock");
+  return path143.join("evidence", String(phase), "sast-baseline.json.lock");
 }
 function getLine(lines, idx) {
   if (idx < 0 || idx >= lines.length)
@@ -119846,7 +120454,7 @@ function fingerprintFinding(finding, directory, occurrenceIndex) {
   }
   const lineNum = finding.location.line;
   try {
-    const content = fs103.readFileSync(finding.location.file, "utf-8");
+    const content = fs104.readFileSync(finding.location.file, "utf-8");
     const lines = content.split(`
 `);
     const idx = lineNum - 1;
@@ -119877,7 +120485,7 @@ function assignOccurrenceIndices(findings, directory) {
     try {
       if (relFile.startsWith(".."))
         throw new Error("escapes workspace");
-      const content = fs103.readFileSync(finding.location.file, "utf-8");
+      const content = fs104.readFileSync(finding.location.file, "utf-8");
       const lines = content.split(`
 `);
       const idx = lineNum - 1;
@@ -119906,16 +120514,16 @@ function assignOccurrenceIndices(findings, directory) {
 async function acquireLock2(lockPath) {
   for (let attempt = 0;attempt <= LOCK_RETRY_DELAYS_MS.length; attempt++) {
     try {
-      const fd = fs103.openSync(lockPath, "wx");
-      fs103.closeSync(fd);
+      const fd = fs104.openSync(lockPath, "wx");
+      fs104.closeSync(fd);
       return () => {
         try {
-          fs103.unlinkSync(lockPath);
+          fs104.unlinkSync(lockPath);
         } catch {}
       };
     } catch {
       if (attempt < LOCK_RETRY_DELAYS_MS.length) {
-        await new Promise((resolve50) => setTimeout(resolve50, LOCK_RETRY_DELAYS_MS[attempt]));
+        await new Promise((resolve51) => setTimeout(resolve51, LOCK_RETRY_DELAYS_MS[attempt]));
       }
     }
   }
@@ -119950,13 +120558,13 @@ async function captureOrMergeBaseline(directory, phase, findings, engine, scanne
       message: e instanceof Error ? e.message : "Path validation failed"
     };
   }
-  fs103.mkdirSync(path142.dirname(baselinePath), { recursive: true });
-  fs103.mkdirSync(path142.dirname(tempPath), { recursive: true });
+  fs104.mkdirSync(path143.dirname(baselinePath), { recursive: true });
+  fs104.mkdirSync(path143.dirname(tempPath), { recursive: true });
   const releaseLock = await acquireLock2(lockPath);
   try {
     let existing = null;
     try {
-      const raw = fs103.readFileSync(baselinePath, "utf-8");
+      const raw = fs104.readFileSync(baselinePath, "utf-8");
       const parsed = JSON.parse(raw);
       if (parsed.schema_version === BASELINE_SCHEMA_VERSION) {
         existing = parsed;
@@ -120016,8 +120624,8 @@ async function captureOrMergeBaseline(directory, phase, findings, engine, scanne
           message: `Baseline would exceed size cap (${json4.length} bytes > ${MAX_BASELINE_BYTES})`
         };
       }
-      fs103.writeFileSync(tempPath, json4, "utf-8");
-      fs103.renameSync(tempPath, baselinePath);
+      fs104.writeFileSync(tempPath, json4, "utf-8");
+      fs104.renameSync(tempPath, baselinePath);
       return {
         status: "merged",
         path: baselinePath,
@@ -120048,8 +120656,8 @@ async function captureOrMergeBaseline(directory, phase, findings, engine, scanne
         message: `Baseline would exceed size cap (${json3.length} bytes > ${MAX_BASELINE_BYTES})`
       };
     }
-    fs103.writeFileSync(tempPath, json3, "utf-8");
-    fs103.renameSync(tempPath, baselinePath);
+    fs104.writeFileSync(tempPath, json3, "utf-8");
+    fs104.renameSync(tempPath, baselinePath);
     return {
       status: "written",
       path: baselinePath,
@@ -120074,7 +120682,7 @@ function loadBaseline(directory, phase) {
     };
   }
   try {
-    const raw = fs103.readFileSync(baselinePath, "utf-8");
+    const raw = fs104.readFileSync(baselinePath, "utf-8");
     const parsed = JSON.parse(raw);
     if (parsed.schema_version !== BASELINE_SCHEMA_VERSION) {
       return {
@@ -120122,17 +120730,17 @@ var SEVERITY_ORDER = {
 };
 function shouldSkipFile(filePath) {
   try {
-    const stats = fs104.statSync(filePath);
+    const stats = fs105.statSync(filePath);
     if (stats.size > MAX_FILE_SIZE_BYTES8) {
       return { skip: true, reason: "file too large" };
     }
     if (stats.size === 0) {
       return { skip: true, reason: "empty file" };
     }
-    const fd = fs104.openSync(filePath, "r");
+    const fd = fs105.openSync(filePath, "r");
     const buffer = Buffer.alloc(8192);
-    const bytesRead = fs104.readSync(fd, buffer, 0, 8192, 0);
-    fs104.closeSync(fd);
+    const bytesRead = fs105.readSync(fd, buffer, 0, 8192, 0);
+    fs105.closeSync(fd);
     if (bytesRead > 0) {
       let nullCount = 0;
       for (let i2 = 0;i2 < bytesRead; i2++) {
@@ -120171,7 +120779,7 @@ function countBySeverity(findings) {
 }
 function scanFileWithTierA(filePath, language) {
   try {
-    const content = fs104.readFileSync(filePath, "utf-8");
+    const content = fs105.readFileSync(filePath, "utf-8");
     const findings = executeRulesSync(filePath, content, language);
     return findings.map((f) => ({
       rule_id: f.rule_id,
@@ -120224,13 +120832,13 @@ async function sastScan(input, directory, config3) {
       _filesSkipped++;
       continue;
     }
-    const resolvedPath = path143.isAbsolute(filePath) ? filePath : path143.resolve(directory, filePath);
-    const resolvedDirectory = path143.resolve(directory);
-    if (!resolvedPath.startsWith(resolvedDirectory + path143.sep) && resolvedPath !== resolvedDirectory) {
+    const resolvedPath = path144.isAbsolute(filePath) ? filePath : path144.resolve(directory, filePath);
+    const resolvedDirectory = path144.resolve(directory);
+    if (!resolvedPath.startsWith(resolvedDirectory + path144.sep) && resolvedPath !== resolvedDirectory) {
       _filesSkipped++;
       continue;
     }
-    if (!fs104.existsSync(resolvedPath)) {
+    if (!fs105.existsSync(resolvedPath)) {
       _filesSkipped++;
       continue;
     }
@@ -120239,7 +120847,7 @@ async function sastScan(input, directory, config3) {
       _filesSkipped++;
       continue;
     }
-    const ext = extname20(resolvedPath).toLowerCase();
+    const ext = extname21(resolvedPath).toLowerCase();
     const profile = getProfileForFile(resolvedPath);
     const langDef = getLanguageForExtension(ext);
     if (!profile && !langDef) {
@@ -120541,20 +121149,20 @@ function validatePath(inputPath, baseDir, workspaceDir) {
   let resolved;
   const isWinAbs = isWindowsAbsolutePath(inputPath);
   if (isWinAbs) {
-    resolved = path144.win32.resolve(inputPath);
-  } else if (path144.isAbsolute(inputPath)) {
-    resolved = path144.resolve(inputPath);
+    resolved = path145.win32.resolve(inputPath);
+  } else if (path145.isAbsolute(inputPath)) {
+    resolved = path145.resolve(inputPath);
   } else {
-    resolved = path144.resolve(baseDir, inputPath);
+    resolved = path145.resolve(baseDir, inputPath);
   }
-  const workspaceResolved = path144.resolve(workspaceDir);
-  let relative28;
+  const workspaceResolved = path145.resolve(workspaceDir);
+  let relative29;
   if (isWinAbs) {
-    relative28 = path144.win32.relative(workspaceResolved, resolved);
+    relative29 = path145.win32.relative(workspaceResolved, resolved);
   } else {
-    relative28 = path144.relative(workspaceResolved, resolved);
+    relative29 = path145.relative(workspaceResolved, resolved);
   }
-  if (relative28.startsWith("..")) {
+  if (relative29.startsWith("..")) {
     return "path traversal detected";
   }
   return null;
@@ -120617,7 +121225,7 @@ async function runLintOnFiles(linter, files, workspaceDir) {
     if (typeof file3 !== "string") {
       continue;
     }
-    const resolvedPath = path144.resolve(file3);
+    const resolvedPath = path145.resolve(file3);
     const validationError = validatePath(resolvedPath, workspaceDir, workspaceDir);
     if (validationError) {
       continue;
@@ -120774,7 +121382,7 @@ async function runSecretscanWithFiles(files, directory) {
         skippedFiles++;
         continue;
       }
-      const resolvedPath = path144.resolve(file3);
+      const resolvedPath = path145.resolve(file3);
       const validationError = validatePath(resolvedPath, directory, directory);
       if (validationError) {
         skippedFiles++;
@@ -120792,14 +121400,14 @@ async function runSecretscanWithFiles(files, directory) {
       };
     }
     for (const file3 of validatedFiles) {
-      const ext = path144.extname(file3).toLowerCase();
+      const ext = path145.extname(file3).toLowerCase();
       if (DEFAULT_EXCLUDE_EXTENSIONS2.has(ext)) {
         skippedFiles++;
         continue;
       }
       let stat9;
       try {
-        stat9 = fs105.statSync(file3);
+        stat9 = fs106.statSync(file3);
       } catch {
         skippedFiles++;
         continue;
@@ -120810,7 +121418,7 @@ async function runSecretscanWithFiles(files, directory) {
       }
       let content;
       try {
-        const buffer = fs105.readFileSync(file3);
+        const buffer = fs106.readFileSync(file3);
         if (buffer.includes(0)) {
           skippedFiles++;
           continue;
@@ -121011,7 +121619,7 @@ function classifySastFindings(findings, changedLineRanges, directory) {
   const preexistingFindings = [];
   for (const finding of findings) {
     const filePath = finding.location.file;
-    const normalised = path144.relative(directory, filePath).replace(/\\/g, "/");
+    const normalised = path145.relative(directory, filePath).replace(/\\/g, "/");
     const changedLines = changedLineRanges.get(normalised);
     if (changedLines?.has(finding.location.line)) {
       newFindings.push(finding);
@@ -121062,7 +121670,7 @@ async function runPreCheckBatch(input, workspaceDir, contextDir) {
       warn(`pre_check_batch: Invalid file path: ${file3}`);
       continue;
     }
-    changedFiles.push(path144.resolve(directory, file3));
+    changedFiles.push(path145.resolve(directory, file3));
   }
   if (changedFiles.length === 0) {
     warn("pre_check_batch: No valid files after validation, skipping all tools (fail-closed)");
@@ -121263,9 +121871,9 @@ var pre_check_batch = createSwarmTool({
       };
       return JSON.stringify(errorResult, null, 2);
     }
-    const resolvedDirectory = path144.resolve(typedArgs.directory);
-    const workspaceAnchor = path144.resolve(directory);
-    if (resolvedDirectory !== workspaceAnchor && resolvedDirectory.startsWith(workspaceAnchor + path144.sep)) {
+    const resolvedDirectory = path145.resolve(typedArgs.directory);
+    const workspaceAnchor = path145.resolve(directory);
+    if (resolvedDirectory !== workspaceAnchor && resolvedDirectory.startsWith(workspaceAnchor + path145.sep)) {
       const subDirError = `directory "${typedArgs.directory}" is a subdirectory of the project root — pre_check_batch requires the project root directory "${workspaceAnchor}"`;
       const subDirResult = {
         gates_passed: false,
@@ -121317,7 +121925,7 @@ var pre_check_batch = createSwarmTool({
 
 // src/tools/repo-map.ts
 init_zod();
-import * as path145 from "node:path";
+import * as path146 from "node:path";
 init_path_security();
 init_create_tool();
 var VALID_ACTIONS = [
@@ -121342,7 +121950,7 @@ function validateFile(p) {
     return "file contains control characters";
   if (containsPathTraversal(p))
     return "file contains path traversal";
-  if (path145.isAbsolute(p) || /^[a-zA-Z]:[\\/]/.test(p)) {
+  if (path146.isAbsolute(p) || /^[a-zA-Z]:[\\/]/.test(p)) {
     return "file must be a workspace-relative path, not absolute";
   }
   return null;
@@ -121365,8 +121973,8 @@ function ok(action, payload) {
 }
 function toRelativeGraphPath(input, workspaceRoot) {
   const normalized = input.replace(/\\/g, "/");
-  if (path145.isAbsolute(normalized)) {
-    const rel = path145.relative(workspaceRoot, normalized).replace(/\\/g, "/");
+  if (path146.isAbsolute(normalized)) {
+    const rel = path146.relative(workspaceRoot, normalized).replace(/\\/g, "/");
     return normalizeGraphPath2(rel);
   }
   return normalizeGraphPath2(normalized);
@@ -121511,8 +122119,8 @@ var repo_map = createSwarmTool({
 // src/tools/req-coverage.ts
 init_zod();
 init_create_tool();
-import * as fs106 from "node:fs";
-import * as path146 from "node:path";
+import * as fs107 from "node:fs";
+import * as path147 from "node:path";
 var SPEC_FILE = ".swarm/spec.md";
 var EVIDENCE_DIR4 = ".swarm/evidence";
 var OBLIGATION_KEYWORDS2 = ["MUST", "SHOULD", "SHALL"];
@@ -121571,19 +122179,19 @@ function extractObligationAndText(id, lineText) {
 var PHASE_TASK_ID_REGEX = /^\d+\.\d+(\.\d+)*$/;
 function readTouchedFiles(evidenceDir, phase, cwd) {
   const touchedFiles = new Set;
-  if (!fs106.existsSync(evidenceDir) || !fs106.statSync(evidenceDir).isDirectory()) {
+  if (!fs107.existsSync(evidenceDir) || !fs107.statSync(evidenceDir).isDirectory()) {
     return [];
   }
   let entries;
   try {
-    entries = fs106.readdirSync(evidenceDir);
+    entries = fs107.readdirSync(evidenceDir);
   } catch {
     return [];
   }
   for (const entry of entries) {
-    const entryPath = path146.join(evidenceDir, entry);
+    const entryPath = path147.join(evidenceDir, entry);
     try {
-      const stat9 = fs106.statSync(entryPath);
+      const stat9 = fs107.statSync(entryPath);
       if (!stat9.isDirectory()) {
         continue;
       }
@@ -121597,14 +122205,14 @@ function readTouchedFiles(evidenceDir, phase, cwd) {
     if (entryPhase !== String(phase)) {
       continue;
     }
-    const evidenceFilePath = path146.join(entryPath, "evidence.json");
+    const evidenceFilePath = path147.join(entryPath, "evidence.json");
     try {
-      const resolvedPath = path146.resolve(evidenceFilePath);
-      const evidenceDirResolved = path146.resolve(evidenceDir);
-      if (!resolvedPath.startsWith(evidenceDirResolved + path146.sep)) {
+      const resolvedPath = path147.resolve(evidenceFilePath);
+      const evidenceDirResolved = path147.resolve(evidenceDir);
+      if (!resolvedPath.startsWith(evidenceDirResolved + path147.sep)) {
         continue;
       }
-      const stat9 = fs106.lstatSync(evidenceFilePath);
+      const stat9 = fs107.lstatSync(evidenceFilePath);
       if (!stat9.isFile()) {
         continue;
       }
@@ -121616,7 +122224,7 @@ function readTouchedFiles(evidenceDir, phase, cwd) {
     }
     let content;
     try {
-      content = fs106.readFileSync(evidenceFilePath, "utf-8");
+      content = fs107.readFileSync(evidenceFilePath, "utf-8");
     } catch {
       continue;
     }
@@ -121635,7 +122243,7 @@ function readTouchedFiles(evidenceDir, phase, cwd) {
             if (Array.isArray(diffEntry.files_changed)) {
               for (const file3 of diffEntry.files_changed) {
                 if (typeof file3 === "string") {
-                  touchedFiles.add(path146.resolve(cwd, file3));
+                  touchedFiles.add(path147.resolve(cwd, file3));
                 }
               }
             }
@@ -121648,12 +122256,12 @@ function readTouchedFiles(evidenceDir, phase, cwd) {
 }
 function searchFileForKeywords(filePath, keywords, cwd) {
   try {
-    const resolvedPath = path146.resolve(filePath);
-    const cwdResolved = path146.resolve(cwd);
+    const resolvedPath = path147.resolve(filePath);
+    const cwdResolved = path147.resolve(cwd);
     if (!resolvedPath.startsWith(cwdResolved)) {
       return false;
     }
-    const content = fs106.readFileSync(resolvedPath, "utf-8");
+    const content = fs107.readFileSync(resolvedPath, "utf-8");
     for (const keyword of keywords) {
       const regex = new RegExp(`\\b${keyword}\\b`, "i");
       if (regex.test(content)) {
@@ -121783,10 +122391,10 @@ var req_coverage = createSwarmTool({
       }, null, 2);
     }
     const cwd = inputDirectory || directory;
-    const specPath = path146.join(cwd, SPEC_FILE);
+    const specPath = path147.join(cwd, SPEC_FILE);
     let specContent;
     try {
-      specContent = fs106.readFileSync(specPath, "utf-8");
+      specContent = fs107.readFileSync(specPath, "utf-8");
     } catch (readError) {
       return JSON.stringify({
         success: false,
@@ -121810,7 +122418,7 @@ var req_coverage = createSwarmTool({
         message: "No FR requirements found in spec.md"
       }, null, 2);
     }
-    const evidenceDir = path146.join(cwd, EVIDENCE_DIR4);
+    const evidenceDir = path147.join(cwd, EVIDENCE_DIR4);
     const touchedFiles = readTouchedFiles(evidenceDir, phase, cwd);
     const analyzedRequirements = [];
     let coveredCount = 0;
@@ -121836,12 +122444,12 @@ var req_coverage = createSwarmTool({
       requirements: analyzedRequirements
     };
     const reportFilename = `req-coverage-phase-${phase}.json`;
-    const reportPath = path146.join(evidenceDir, reportFilename);
+    const reportPath = path147.join(evidenceDir, reportFilename);
     try {
-      if (!fs106.existsSync(evidenceDir)) {
-        fs106.mkdirSync(evidenceDir, { recursive: true });
+      if (!fs107.existsSync(evidenceDir)) {
+        fs107.mkdirSync(evidenceDir, { recursive: true });
       }
-      fs106.writeFileSync(reportPath, JSON.stringify(result, null, 2), "utf-8");
+      fs107.writeFileSync(reportPath, JSON.stringify(result, null, 2), "utf-8");
     } catch (writeError) {
       console.warn(`Failed to write coverage report: ${writeError instanceof Error ? writeError.message : String(writeError)}`);
     }
@@ -121925,8 +122533,8 @@ init_plan_schema();
 init_qa_gate_profile();
 init_file_locks();
 import * as crypto12 from "node:crypto";
-import * as fs107 from "node:fs";
-import * as path147 from "node:path";
+import * as fs108 from "node:fs";
+import * as path148 from "node:path";
 init_ledger();
 init_manager();
 init_state();
@@ -122007,17 +122615,17 @@ async function executeSavePlan(args2, fallbackDir) {
     };
   }
   if (args2.working_directory && fallbackDir) {
-    const resolvedTarget = path147.resolve(args2.working_directory);
-    const resolvedRoot = path147.resolve(fallbackDir);
+    const resolvedTarget = path148.resolve(args2.working_directory);
+    const resolvedRoot = path148.resolve(fallbackDir);
     let fallbackExists = false;
     try {
-      fs107.accessSync(resolvedRoot, fs107.constants.F_OK);
+      fs108.accessSync(resolvedRoot, fs108.constants.F_OK);
       fallbackExists = true;
     } catch {
       fallbackExists = false;
     }
     if (fallbackExists) {
-      const isSubdirectory = resolvedTarget.startsWith(resolvedRoot + path147.sep);
+      const isSubdirectory = resolvedTarget.startsWith(resolvedRoot + path148.sep);
       if (isSubdirectory) {
         return {
           success: false,
@@ -122033,11 +122641,11 @@ async function executeSavePlan(args2, fallbackDir) {
   let specMtime;
   let specHash;
   if (process.env.SWARM_SKIP_SPEC_GATE !== "1") {
-    const specPath = path147.join(targetWorkspace, ".swarm", "spec.md");
+    const specPath = path148.join(targetWorkspace, ".swarm", "spec.md");
     try {
-      const stat9 = await fs107.promises.stat(specPath);
+      const stat9 = await fs108.promises.stat(specPath);
       specMtime = stat9.mtime.toISOString();
-      const content = await fs107.promises.readFile(specPath, "utf8");
+      const content = await fs108.promises.readFile(specPath, "utf8");
       specHash = crypto12.createHash("sha256").update(content).digest("hex");
     } catch {
       return {
@@ -122049,10 +122657,10 @@ async function executeSavePlan(args2, fallbackDir) {
     }
   }
   if (process.env.SWARM_SKIP_GATE_SELECTION !== "1") {
-    const contextPath = path147.join(targetWorkspace, ".swarm", "context.md");
+    const contextPath = path148.join(targetWorkspace, ".swarm", "context.md");
     let contextContent = "";
     try {
-      contextContent = await fs107.promises.readFile(contextPath, "utf8");
+      contextContent = await fs108.promises.readFile(contextPath, "utf8");
     } catch {}
     const hasPendingSection = contextContent.includes("## Pending QA Gate Selection");
     if (!hasPendingSection) {
@@ -122339,14 +122947,14 @@ async function executeSavePlan(args2, fallbackDir) {
       }
       await writeCheckpoint(dir).catch(() => {});
       try {
-        const markerPath = path147.join(dir, ".swarm", ".plan-write-marker");
+        const markerPath = path148.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 fs107.promises.writeFile(markerPath, marker, "utf8");
+        await fs108.promises.writeFile(markerPath, marker, "utf8");
       } catch {}
       const warnings = [];
       let criticReviewFound = false;
@@ -122362,7 +122970,7 @@ async function executeSavePlan(args2, fallbackDir) {
       return {
         success: true,
         message: "Plan saved successfully",
-        plan_path: path147.join(dir, ".swarm", "plan.json"),
+        plan_path: path148.join(dir, ".swarm", "plan.json"),
         phases_count: plan.phases.length,
         tasks_count: tasksCount,
         ...resolvedProfile !== undefined ? { execution_profile: resolvedProfile } : {},
@@ -122428,8 +123036,8 @@ var save_plan = createSwarmTool({
 // src/tools/sbom-generate.ts
 init_zod();
 init_manager2();
-import * as fs108 from "node:fs";
-import * as path148 from "node:path";
+import * as fs109 from "node:fs";
+import * as path149 from "node:path";
 
 // src/sbom/detectors/index.ts
 init_utils();
@@ -123277,9 +123885,9 @@ function findManifestFiles(rootDir) {
   const patterns = [...new Set(allDetectors.flatMap((d) => d.patterns))];
   function searchDir(dir) {
     try {
-      const entries = fs108.readdirSync(dir, { withFileTypes: true });
+      const entries = fs109.readdirSync(dir, { withFileTypes: true });
       for (const entry of entries) {
-        const fullPath = path148.join(dir, entry.name);
+        const fullPath = path149.join(dir, entry.name);
         if (entry.name.startsWith(".") || entry.name === "node_modules" || entry.name === "dist" || entry.name === "build" || entry.name === "target") {
           continue;
         }
@@ -123288,7 +123896,7 @@ function findManifestFiles(rootDir) {
         } else if (entry.isFile()) {
           for (const pattern of patterns) {
             if (simpleGlobToRegex(pattern).test(entry.name)) {
-              manifestFiles.push(path148.relative(rootDir, fullPath));
+              manifestFiles.push(path149.relative(rootDir, fullPath));
               break;
             }
           }
@@ -123304,13 +123912,13 @@ function findManifestFilesInDirs(directories, workingDir) {
   const patterns = [...new Set(allDetectors.flatMap((d) => d.patterns))];
   for (const dir of directories) {
     try {
-      const entries = fs108.readdirSync(dir, { withFileTypes: true });
+      const entries = fs109.readdirSync(dir, { withFileTypes: true });
       for (const entry of entries) {
-        const fullPath = path148.join(dir, entry.name);
+        const fullPath = path149.join(dir, entry.name);
         if (entry.isFile()) {
           for (const pattern of patterns) {
             if (simpleGlobToRegex(pattern).test(entry.name)) {
-              found.push(path148.relative(workingDir, fullPath));
+              found.push(path149.relative(workingDir, fullPath));
               break;
             }
           }
@@ -123323,11 +123931,11 @@ function findManifestFilesInDirs(directories, workingDir) {
 function getDirectoriesFromChangedFiles(changedFiles, workingDir) {
   const dirs = new Set;
   for (const file3 of changedFiles) {
-    let currentDir = path148.dirname(file3);
+    let currentDir = path149.dirname(file3);
     while (true) {
-      if (currentDir && currentDir !== "." && currentDir !== path148.sep) {
-        dirs.add(path148.join(workingDir, currentDir));
-        const parent = path148.dirname(currentDir);
+      if (currentDir && currentDir !== "." && currentDir !== path149.sep) {
+        dirs.add(path149.join(workingDir, currentDir));
+        const parent = path149.dirname(currentDir);
         if (parent === currentDir)
           break;
         currentDir = parent;
@@ -123341,7 +123949,7 @@ function getDirectoriesFromChangedFiles(changedFiles, workingDir) {
 }
 function ensureOutputDir(outputDir) {
   try {
-    fs108.mkdirSync(outputDir, { recursive: true });
+    fs109.mkdirSync(outputDir, { recursive: true });
   } catch (error93) {
     if (!error93 || error93.code !== "EEXIST") {
       throw error93;
@@ -123411,7 +124019,7 @@ var sbom_generate = createSwarmTool({
     const changedFiles = obj.changed_files;
     const relativeOutputDir = obj.output_dir || DEFAULT_OUTPUT_DIR;
     const workingDir = directory;
-    const outputDir = path148.isAbsolute(relativeOutputDir) ? relativeOutputDir : path148.join(workingDir, relativeOutputDir);
+    const outputDir = path149.isAbsolute(relativeOutputDir) ? relativeOutputDir : path149.join(workingDir, relativeOutputDir);
     let manifestFiles = [];
     if (scope === "all") {
       manifestFiles = findManifestFiles(workingDir);
@@ -123434,11 +124042,11 @@ var sbom_generate = createSwarmTool({
     const processedFiles = [];
     for (const manifestFile of manifestFiles) {
       try {
-        const fullPath = path148.isAbsolute(manifestFile) ? manifestFile : path148.join(workingDir, manifestFile);
-        if (!fs108.existsSync(fullPath)) {
+        const fullPath = path149.isAbsolute(manifestFile) ? manifestFile : path149.join(workingDir, manifestFile);
+        if (!fs109.existsSync(fullPath)) {
           continue;
         }
-        const content = fs108.readFileSync(fullPath, "utf-8");
+        const content = fs109.readFileSync(fullPath, "utf-8");
         const components = detectComponents(manifestFile, content);
         processedFiles.push(manifestFile);
         if (components.length > 0) {
@@ -123451,8 +124059,8 @@ var sbom_generate = createSwarmTool({
     const bom = generateCycloneDX(allComponents);
     const bomJson = serializeCycloneDX(bom);
     const filename = generateSbomFilename();
-    const outputPath = path148.join(outputDir, filename);
-    fs108.writeFileSync(outputPath, bomJson, "utf-8");
+    const outputPath = path149.join(outputDir, filename);
+    fs109.writeFileSync(outputPath, bomJson, "utf-8");
     const verdict = processedFiles.length > 0 ? "pass" : "pass";
     try {
       const timestamp = new Date().toISOString();
@@ -123495,8 +124103,8 @@ var sbom_generate = createSwarmTool({
 // src/tools/schema-drift.ts
 init_zod();
 init_create_tool();
-import * as fs109 from "node:fs";
-import * as path149 from "node:path";
+import * as fs110 from "node:fs";
+import * as path150 from "node:path";
 var SPEC_CANDIDATES = [
   "openapi.json",
   "openapi.yaml",
@@ -123528,28 +124136,28 @@ function normalizePath5(p) {
 }
 function discoverSpecFile(cwd, specFileArg) {
   if (specFileArg) {
-    const resolvedPath = path149.resolve(cwd, specFileArg);
-    const normalizedCwd = cwd.endsWith(path149.sep) ? cwd : cwd + path149.sep;
+    const resolvedPath = path150.resolve(cwd, specFileArg);
+    const normalizedCwd = cwd.endsWith(path150.sep) ? cwd : cwd + path150.sep;
     if (!resolvedPath.startsWith(normalizedCwd) && resolvedPath !== cwd) {
       throw new Error("Invalid spec_file: path traversal detected");
     }
-    const ext = path149.extname(resolvedPath).toLowerCase();
+    const ext = path150.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 = fs109.statSync(resolvedPath);
+    const stats = fs110.statSync(resolvedPath);
     if (stats.size > MAX_SPEC_SIZE) {
       throw new Error(`Invalid spec_file: file exceeds ${MAX_SPEC_SIZE / 1024 / 1024}MB limit`);
     }
-    if (!fs109.existsSync(resolvedPath)) {
+    if (!fs110.existsSync(resolvedPath)) {
       throw new Error(`Spec file not found: ${resolvedPath}`);
     }
     return resolvedPath;
   }
   for (const candidate of SPEC_CANDIDATES) {
-    const candidatePath = path149.resolve(cwd, candidate);
-    if (fs109.existsSync(candidatePath)) {
-      const stats = fs109.statSync(candidatePath);
+    const candidatePath = path150.resolve(cwd, candidate);
+    if (fs110.existsSync(candidatePath)) {
+      const stats = fs110.statSync(candidatePath);
       if (stats.size <= MAX_SPEC_SIZE) {
         return candidatePath;
       }
@@ -123558,8 +124166,8 @@ function discoverSpecFile(cwd, specFileArg) {
   return null;
 }
 function parseSpec(specFile) {
-  const content = fs109.readFileSync(specFile, "utf-8");
-  const ext = path149.extname(specFile).toLowerCase();
+  const content = fs110.readFileSync(specFile, "utf-8");
+  const ext = path150.extname(specFile).toLowerCase();
   if (ext === ".json") {
     return parseJsonSpec(content);
   }
@@ -123627,15 +124235,15 @@ function parseYamlSpec(content) {
 }
 function extractRoutes(cwd) {
   const routes = [];
-  function walkDir(dir) {
+  function walkDir2(dir) {
     let entries;
     try {
-      entries = fs109.readdirSync(dir, { withFileTypes: true });
+      entries = fs110.readdirSync(dir, { withFileTypes: true });
     } catch {
       return;
     }
     for (const entry of entries) {
-      const fullPath = path149.join(dir, entry.name);
+      const fullPath = path150.join(dir, entry.name);
       if (entry.isSymbolicLink()) {
         continue;
       }
@@ -123643,9 +124251,9 @@ function extractRoutes(cwd) {
         if (SKIP_DIRS.includes(entry.name)) {
           continue;
         }
-        walkDir(fullPath);
+        walkDir2(fullPath);
       } else if (entry.isFile()) {
-        const ext = path149.extname(entry.name).toLowerCase();
+        const ext = path150.extname(entry.name).toLowerCase();
         const baseName = entry.name.toLowerCase();
         if (![".ts", ".js", ".mjs"].includes(ext)) {
           continue;
@@ -123658,12 +124266,12 @@ function extractRoutes(cwd) {
       }
     }
   }
-  walkDir(cwd);
+  walkDir2(cwd);
   return routes;
 }
 function extractRoutesFromFile(filePath) {
   const routes = [];
-  const content = fs109.readFileSync(filePath, "utf-8");
+  const content = fs110.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;
@@ -123813,8 +124421,8 @@ init_zod();
 init_bun_compat();
 init_path_security();
 init_create_tool();
-import * as fs110 from "node:fs";
-import * as path150 from "node:path";
+import * as fs111 from "node:fs";
+import * as path151 from "node:path";
 var DEFAULT_MAX_RESULTS = 100;
 var DEFAULT_MAX_LINES = 200;
 var REGEX_TIMEOUT_MS = 5000;
@@ -123850,11 +124458,11 @@ function containsWindowsAttacks4(str) {
 }
 function isPathInWorkspace3(filePath, workspace) {
   try {
-    const resolvedPath = path150.resolve(workspace, filePath);
-    const realWorkspace = fs110.realpathSync(workspace);
-    const realResolvedPath = fs110.realpathSync(resolvedPath);
-    const relativePath = path150.relative(realWorkspace, realResolvedPath);
-    if (relativePath.startsWith("..") || path150.isAbsolute(relativePath)) {
+    const resolvedPath = path151.resolve(workspace, filePath);
+    const realWorkspace = fs111.realpathSync(workspace);
+    const realResolvedPath = fs111.realpathSync(resolvedPath);
+    const relativePath = path151.relative(realWorkspace, realResolvedPath);
+    if (relativePath.startsWith("..") || path151.isAbsolute(relativePath)) {
       return false;
     }
     return true;
@@ -123867,12 +124475,12 @@ function validatePathForRead2(filePath, workspace) {
 }
 function findRgInEnvPath() {
   const searchPath = process.env.PATH ?? "";
-  for (const dir of searchPath.split(path150.delimiter)) {
+  for (const dir of searchPath.split(path151.delimiter)) {
     if (!dir)
       continue;
     const isWindows = process.platform === "win32";
-    const candidate = path150.join(dir, isWindows ? "rg.exe" : "rg");
-    if (fs110.existsSync(candidate))
+    const candidate = path151.join(dir, isWindows ? "rg.exe" : "rg");
+    if (fs111.existsSync(candidate))
       return candidate;
   }
   return null;
@@ -123926,7 +124534,7 @@ async function ripgrepSearch(opts) {
       stderr: "pipe",
       cwd: opts.workspace
     });
-    const timeout = new Promise((resolve56) => setTimeout(() => resolve56("timeout"), REGEX_TIMEOUT_MS));
+    const timeout = new Promise((resolve57) => setTimeout(() => resolve57("timeout"), REGEX_TIMEOUT_MS));
     const exitPromise = proc.exited;
     const result = await Promise.race([exitPromise, timeout]);
     if (result === "timeout") {
@@ -123999,10 +124607,10 @@ function collectFiles(dir, workspace, includeGlobs, excludeGlobs) {
     return files;
   }
   try {
-    const entries = fs110.readdirSync(dir, { withFileTypes: true });
+    const entries = fs111.readdirSync(dir, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = path150.join(dir, entry.name);
-      const relativePath = path150.relative(workspace, fullPath);
+      const fullPath = path151.join(dir, entry.name);
+      const relativePath = path151.relative(workspace, fullPath);
       if (!validatePathForRead2(fullPath, workspace)) {
         continue;
       }
@@ -124043,13 +124651,13 @@ async function fallbackSearch(opts) {
   const matches = [];
   let total = 0;
   for (const file3 of files) {
-    const fullPath = path150.join(opts.workspace, file3);
+    const fullPath = path151.join(opts.workspace, file3);
     if (!validatePathForRead2(fullPath, opts.workspace)) {
       continue;
     }
     let stats;
     try {
-      stats = fs110.statSync(fullPath);
+      stats = fs111.statSync(fullPath);
       if (stats.size > MAX_FILE_SIZE_BYTES10) {
         continue;
       }
@@ -124058,7 +124666,7 @@ async function fallbackSearch(opts) {
     }
     let content;
     try {
-      content = fs110.readFileSync(fullPath, "utf-8");
+      content = fs111.readFileSync(fullPath, "utf-8");
     } catch {
       continue;
     }
@@ -124170,7 +124778,7 @@ var search = createSwarmTool({
         message: "Exclude pattern contains invalid Windows-specific sequence"
       }, null, 2);
     }
-    if (!fs110.existsSync(directory)) {
+    if (!fs111.existsSync(directory)) {
       return JSON.stringify({
         error: true,
         type: "unknown",
@@ -124456,7 +125064,7 @@ init_config();
 init_schema();
 init_create_tool();
 import { mkdir as mkdir24, rename as rename10, writeFile as writeFile19 } from "node:fs/promises";
-import * as path151 from "node:path";
+import * as path152 from "node:path";
 var MAX_SPEC_BYTES = 256 * 1024;
 var spec_write = createSwarmTool({
   description: "Write the canonical project spec to .swarm/spec.md. Atomic write, size-bounded (256 KiB), heading-required. Honors spec_writer.allow_spec_write.",
@@ -124497,14 +125105,14 @@ var spec_write = createSwarmTool({
         reason: 'spec must contain at least one top-level "# Heading"'
       }, null, 2);
     }
-    const target = path151.join(directory, ".swarm", "spec.md");
-    await mkdir24(path151.dirname(target), { recursive: true });
+    const target = path152.join(directory, ".swarm", "spec.md");
+    await mkdir24(path152.dirname(target), { recursive: true });
     const tmp = `${target}.tmp-${process.pid}-${Date.now()}`;
     let finalContent = content;
     if (mode === "append") {
       try {
-        const fs111 = await import("node:fs/promises");
-        const prior = await fs111.readFile(target, "utf-8");
+        const fs112 = await import("node:fs/promises");
+        const prior = await fs112.readFile(target, "utf-8");
         finalContent = `${prior.replace(/\s+$/, "")}
 
 ${content}
@@ -124527,14 +125135,14 @@ ${content}
 init_zod();
 init_loader();
 import {
-  existsSync as existsSync85,
+  existsSync as existsSync86,
   mkdirSync as mkdirSync36,
   readFileSync as readFileSync72,
   renameSync as renameSync22,
   unlinkSync as unlinkSync20,
   writeFileSync as writeFileSync30
 } from "node:fs";
-import path152 from "node:path";
+import path153 from "node:path";
 init_create_tool();
 init_resolve_working_directory();
 var VerdictSchema2 = exports_external.object({
@@ -124664,7 +125272,7 @@ var submit_phase_council_verdicts = createSwarmTool({
   }
 });
 function getPhaseMutationGapFinding(phaseNumber, workingDir) {
-  const mutationGatePath = path152.join(workingDir, ".swarm", "evidence", String(phaseNumber), "mutation-gate.json");
+  const mutationGatePath = path153.join(workingDir, ".swarm", "evidence", String(phaseNumber), "mutation-gate.json");
   try {
     const raw = readFileSync72(mutationGatePath, "utf-8");
     const parsed = JSON.parse(raw);
@@ -124726,9 +125334,9 @@ function getPhaseMutationGapFinding(phaseNumber, workingDir) {
   }
 }
 function writePhaseCouncilEvidence(workingDir, synthesis) {
-  const evidenceDir = path152.join(workingDir, ".swarm", "evidence", String(synthesis.phaseNumber));
+  const evidenceDir = path153.join(workingDir, ".swarm", "evidence", String(synthesis.phaseNumber));
   mkdirSync36(evidenceDir, { recursive: true });
-  const evidenceFile = path152.join(evidenceDir, "phase-council.json");
+  const evidenceFile = path153.join(evidenceDir, "phase-council.json");
   const evidenceBundle = {
     entries: [
       {
@@ -124764,7 +125372,7 @@ function writePhaseCouncilEvidence(workingDir, synthesis) {
     writeFileSync30(tempFile, JSON.stringify(evidenceBundle, null, 2), "utf-8");
     renameSync22(tempFile, evidenceFile);
   } finally {
-    if (existsSync85(tempFile)) {
+    if (existsSync86(tempFile)) {
       unlinkSync20(tempFile);
     }
   }
@@ -124789,8 +125397,30 @@ function formatMutationGapFeedback(finding) {
 init_zod();
 init_path_security();
 init_create_tool();
-import * as fs111 from "node:fs";
-import * as path153 from "node:path";
+import * as fs112 from "node:fs";
+import * as path154 from "node:path";
+var BINARY_EXTENSIONS2 = new Set([
+  ".png",
+  ".jpg",
+  ".jpeg",
+  ".gif",
+  ".bmp",
+  ".ico",
+  ".svg",
+  ".woff",
+  ".woff2",
+  ".ttf",
+  ".eot",
+  ".mp3",
+  ".mp4",
+  ".avi",
+  ".mov",
+  ".pdf",
+  ".zip",
+  ".tar",
+  ".gz",
+  ".rar"
+]);
 var WINDOWS_RESERVED_NAMES5 = /^(con|prn|aux|nul|com[1-9]|lpt[1-9])(\.|:|$)/i;
 function containsWindowsAttacks5(str) {
   if (/:[^\\/]/.test(str))
@@ -124804,14 +125434,14 @@ function containsWindowsAttacks5(str) {
 }
 function isPathInWorkspace4(filePath, workspace) {
   try {
-    const resolvedPath = path153.resolve(workspace, filePath);
-    if (!fs111.existsSync(resolvedPath)) {
+    const resolvedPath = path154.resolve(workspace, filePath);
+    if (!fs112.existsSync(resolvedPath)) {
       return true;
     }
-    const realWorkspace = fs111.realpathSync(workspace);
-    const realResolvedPath = fs111.realpathSync(resolvedPath);
-    const relativePath = path153.relative(realWorkspace, realResolvedPath);
-    if (relativePath.startsWith("..") || path153.isAbsolute(relativePath)) {
+    const realWorkspace = fs112.realpathSync(workspace);
+    const realResolvedPath = fs112.realpathSync(resolvedPath);
+    const relativePath = path154.relative(realWorkspace, realResolvedPath);
+    if (relativePath.startsWith("..") || path154.isAbsolute(relativePath)) {
       return false;
     }
     return true;
@@ -124819,7 +125449,7 @@ function isPathInWorkspace4(filePath, workspace) {
     return false;
   }
 }
-function validateFilePath(filePath, workspace) {
+function validateFilePath2(filePath, workspace) {
   if (!filePath || filePath.trim() === "")
     return false;
   if (containsPathTraversal(filePath))
@@ -124831,8 +125461,7 @@ function validateFilePath(filePath, workspace) {
   return isPathInWorkspace4(filePath, workspace);
 }
 function findContextMatch(content, contextBefore, contextAfter, oldContent) {
-  const lines = content.split(`
-`);
+  const lines = splitDiffLines(content);
   if ((!contextBefore || contextBefore.length === 0) && (!contextAfter || contextAfter.length === 0)) {
     return null;
   }
@@ -124854,8 +125483,7 @@ function findContextMatch(content, contextBefore, contextAfter, oldContent) {
                 };
               } else {
                 if (oldContent && oldContent.length > 0) {
-                  const oldContentLines = oldContent.split(`
-`);
+                  const oldContentLines = splitDiffLines(oldContent);
                   const betweenLines = lines.slice(afterStart, j);
                   if (arraysEqual2(betweenLines, oldContentLines)) {
                     return {
@@ -124879,8 +125507,7 @@ function findContextMatch(content, contextBefore, contextAfter, oldContent) {
           return null;
         } else {
           if (oldContent && oldContent.length > 0) {
-            const oldContentLines = oldContent.split(`
-`);
+            const oldContentLines = splitDiffLines(oldContent);
             for (let k = afterStart;k <= lines.length - oldContentLines.length; k++) {
               const candidate = lines.slice(k, k + oldContentLines.length);
               if (arraysEqual2(candidate, oldContentLines)) {
@@ -124928,23 +125555,117 @@ function arraysEqual2(a, b) {
   }
   return true;
 }
-function validateOldContent(lines, startIndex, endIndex, oldContent) {
+function isBinaryFile4(filePath) {
+  const ext = path154.extname(filePath).toLowerCase();
+  return BINARY_EXTENSIONS2.has(ext);
+}
+function splitDiffLines(content) {
+  if (content === "")
+    return [];
+  return content.endsWith(`
+`) ? content.slice(0, -1).split(`
+`) : content.split(`
+`);
+}
+function generateFileHeader(file3) {
+  return `diff --git a/${file3} b/${file3}
+` + `--- a/${file3}
+` + `+++ b/${file3}
+`;
+}
+function generateHunk(content, contextMatch, oldContent, newContent) {
+  const lines = splitDiffLines(content);
+  const originalEndsWithNewline = content.endsWith(`
+`);
+  const newContentEndsWithNewline = newContent.endsWith(`
+`);
+  const removalStartIdx = contextMatch.startLineIndex + contextMatch.matchedBefore.length;
+  const removalLines = oldContent ? splitDiffLines(oldContent) : [];
+  const removalEndIdx = removalLines.length > 0 ? removalStartIdx + removalLines.length - 1 : removalStartIdx - 1;
+  const additionLines = splitDiffLines(newContent);
+  const isAdjacentCase = contextMatch.matchedAfter.length > 0 && contextMatch.endLineIndex >= 0 && contextMatch.endLineIndex < lines.length && lines[contextMatch.endLineIndex] === contextMatch.matchedAfter[contextMatch.matchedAfter.length - 1];
+  const contextAfterStartInFile = isAdjacentCase ? contextMatch.endLineIndex - contextMatch.matchedAfter.length + 1 : contextMatch.endLineIndex + 1;
+  const overlapSkipCount = Math.max(0, removalLines.length > 0 ? removalEndIdx + 1 - contextAfterStartInFile : 0);
+  const effectiveContextAfterCount = Math.max(0, contextMatch.matchedAfter.length - overlapSkipCount);
+  const oldStart = contextMatch.matchedBefore.length > 0 ? contextMatch.startLineIndex + 1 : removalStartIdx + 1;
+  const newStart = oldStart;
+  const oldCount = contextMatch.matchedBefore.length + removalLines.length + effectiveContextAfterCount;
+  const newCount = contextMatch.matchedBefore.length + additionLines.length + effectiveContextAfterCount;
+  const hunkLines = [];
+  let lastOldSidePos = -1;
+  let lastNewSidePos = -1;
+  for (const line of contextMatch.matchedBefore) {
+    const idx = hunkLines.length;
+    hunkLines.push(` ${line}`);
+    lastOldSidePos = idx;
+    lastNewSidePos = idx;
+  }
+  for (const line of removalLines) {
+    const idx = hunkLines.length;
+    hunkLines.push(`-${line}`);
+    lastOldSidePos = idx;
+  }
+  for (const line of additionLines) {
+    const idx = hunkLines.length;
+    hunkLines.push(`+${line}`);
+    lastNewSidePos = idx;
+  }
+  for (let k = overlapSkipCount;k < contextMatch.matchedAfter.length; k++) {
+    const idx = hunkLines.length;
+    hunkLines.push(` ${contextMatch.matchedAfter[k]}`);
+    lastOldSidePos = idx;
+    lastNewSidePos = idx;
+  }
+  const lastOldSideFileIdx = effectiveContextAfterCount > 0 ? contextAfterStartInFile + contextMatch.matchedAfter.length - 1 : removalLines.length > 0 ? removalEndIdx : contextMatch.matchedBefore.length > 0 ? contextMatch.startLineIndex + contextMatch.matchedBefore.length - 1 : -1;
+  const isAtEof = lastOldSideFileIdx === lines.length - 1;
+  const needsOldMarker = isAtEof && !originalEndsWithNewline && lastOldSidePos >= 0;
+  const newSideEndsWithNewline = effectiveContextAfterCount > 0 ? originalEndsWithNewline : additionLines.length > 0 ? newContentEndsWithNewline : true;
+  const needsNewMarker = isAtEof && !newSideEndsWithNewline && lastNewSidePos >= 0;
+  const finalLines = [];
+  let pendingOldMarker = needsOldMarker;
+  let pendingNewMarker = needsNewMarker;
+  for (let i2 = 0;i2 < hunkLines.length; i2++) {
+    finalLines.push(hunkLines[i2]);
+    if (pendingOldMarker && i2 === lastOldSidePos) {
+      finalLines.push("\");
+      pendingOldMarker = false;
+    }
+    if (pendingNewMarker && i2 === lastNewSidePos) {
+      finalLines.push("\");
+      pendingNewMarker = false;
+    }
+  }
+  const oldCountStr = oldCount === 0 ? "0" : String(oldCount);
+  const newCountStr = newCount === 0 ? "0" : String(newCount);
+  let diff2 = "";
+  diff2 += `@@ -${oldStart},${oldCountStr} +${newStart},${newCountStr} @@
+`;
+  diff2 += finalLines.join(`
+`);
+  diff2 += `
+`;
+  return diff2;
+}
+function validateOldContent(lines, contextMatch, oldContent) {
   if (!oldContent) {
     return { valid: true };
   }
-  const currentContent = lines.slice(startIndex, endIndex + 1).join(`
-`);
-  if (currentContent !== oldContent) {
+  const expectedLines = splitDiffLines(oldContent);
+  const removalStartIdx = contextMatch.startLineIndex + contextMatch.matchedBefore.length;
+  const actualLines = lines.slice(removalStartIdx, removalStartIdx + expectedLines.length);
+  if (!arraysEqual2(actualLines, expectedLines)) {
     return {
       valid: false,
-      expected: oldContent,
-      actual: currentContent
+      expected: expectedLines.join(`
+`),
+      actual: actualLines.join(`
+`)
     };
   }
   return { valid: true };
 }
 var suggestPatch = createSwarmTool({
-  description: "Suggest a structured patch for specified files without modifying them. " + "Returns context-based patch proposals with anchors for reviewer use. " + "This is a read-only tool — it does not modify any files.",
+  description: "Suggest a structured patch for specified files without modifying them. " + "Returns context-based patch proposals with anchors for reviewer use. " + 'When format="unified", also produces a unified diff string consumable by apply_patch. ' + "This is a read-only tool — it does not modify any files.",
   args: {
     targetFiles: exports_external.array(exports_external.string()).describe("Array of file paths to patch").min(1),
     changes: exports_external.array(exports_external.object({
@@ -124953,7 +125674,8 @@ var suggestPatch = createSwarmTool({
       contextAfter: exports_external.array(exports_external.string()).optional().describe("Lines after the change region (anchor)"),
       oldContent: exports_external.string().optional().describe("Current content to be replaced"),
       newContent: exports_external.string().describe("New content to replace with")
-    })).describe("Array of change descriptions with context anchors").min(1)
+    })).describe("Array of change descriptions with context anchors").min(1),
+    format: exports_external.enum(["json", "unified"]).optional().default("json").describe('Output format: "json" (default, existing structured output) or "unified" (unified diff string for apply_patch)')
   },
   execute: async (args2, directory) => {
     if (!args2 || typeof args2 !== "object") {
@@ -124967,6 +125689,7 @@ var suggestPatch = createSwarmTool({
     const obj = args2;
     const targetFiles = obj.targetFiles ?? [];
     const changes = obj.changes ?? [];
+    const format = obj.format ?? "json";
     if (!targetFiles || targetFiles.length === 0) {
       return JSON.stringify({
         success: false,
@@ -124983,7 +125706,7 @@ var suggestPatch = createSwarmTool({
         message: "changes cannot be empty"
       }, null, 2);
     }
-    if (!fs111.existsSync(directory)) {
+    if (!fs112.existsSync(directory)) {
       return JSON.stringify({
         success: false,
         error: true,
@@ -124994,9 +125717,28 @@ var suggestPatch = createSwarmTool({
     const patches = [];
     const filesModifiedSet = new Set;
     const errors5 = [];
+    const unifiedDiffEntries = [];
     const targetFileSet = new Set(targetFiles);
+    const skippedBinaryFiles = new Set;
+    if (format === "unified") {
+      for (const change of changes) {
+        if (isBinaryFile4(change.file)) {
+          errors5.push({
+            success: false,
+            error: true,
+            type: "parse-error",
+            message: `Binary files are not supported in unified diff mode: ${change.file}`,
+            details: { location: change.file }
+          });
+          skippedBinaryFiles.add(change.file);
+        }
+      }
+    }
     for (let changeIndex = 0;changeIndex < changes.length; changeIndex++) {
       const change = changes[changeIndex];
+      if (format === "unified" && skippedBinaryFiles.has(change.file)) {
+        continue;
+      }
       if (!targetFileSet.has(change.file)) {
         errors5.push({
           success: false,
@@ -125007,7 +125749,7 @@ var suggestPatch = createSwarmTool({
         });
         continue;
       }
-      if (!validateFilePath(change.file, directory)) {
+      if (!validateFilePath2(change.file, directory)) {
         errors5.push({
           success: false,
           error: true,
@@ -125019,8 +125761,8 @@ var suggestPatch = createSwarmTool({
         });
         continue;
       }
-      const fullPath = path153.resolve(directory, change.file);
-      if (!fs111.existsSync(fullPath)) {
+      const fullPath = path154.resolve(directory, change.file);
+      if (!fs112.existsSync(fullPath)) {
         errors5.push({
           success: false,
           error: true,
@@ -125034,7 +125776,7 @@ var suggestPatch = createSwarmTool({
       }
       let content;
       try {
-        content = fs111.readFileSync(fullPath, "utf-8");
+        content = fs112.readFileSync(fullPath, "utf-8");
       } catch (err3) {
         errors5.push({
           success: false,
@@ -125060,9 +125802,8 @@ var suggestPatch = createSwarmTool({
         });
         continue;
       }
-      const lines = content.split(`
-`);
-      const oldContentValidation = validateOldContent(lines, contextMatch.startLineIndex + contextMatch.matchedBefore.length, contextMatch.endLineIndex - contextMatch.matchedAfter.length + 1, change.oldContent);
+      const lines = splitDiffLines(content);
+      const oldContentValidation = validateOldContent(lines, contextMatch, change.oldContent);
       if (!oldContentValidation.valid) {
         errors5.push({
           success: false,
@@ -125089,14 +125830,51 @@ var suggestPatch = createSwarmTool({
         hunkIndex: changeIndex
       });
       filesModifiedSet.add(change.file);
+      if (format === "unified") {
+        unifiedDiffEntries.push({
+          file: change.file,
+          contextMatch,
+          oldContent: change.oldContent,
+          newContent: change.newContent
+        });
+      }
     }
     if (patches.length > 0) {
-      return JSON.stringify({
+      const baseResult = {
         success: true,
         patches,
         filesModified: Array.from(filesModifiedSet),
         ...errors5.length > 0 && { errors: errors5 }
-      }, null, 2);
+      };
+      if (format === "unified") {
+        const fileGroups = new Map;
+        for (const entry of unifiedDiffEntries) {
+          const group = fileGroups.get(entry.file) ?? [];
+          group.push(entry);
+          fileGroups.set(entry.file, group);
+        }
+        const unifiedParts = [];
+        for (const [file3, entries] of fileGroups) {
+          entries.sort((a, b) => a.contextMatch.startLineIndex - b.contextMatch.startLineIndex);
+          const entryFullPath = path154.resolve(directory, file3);
+          let entryContent;
+          try {
+            entryContent = fs112.readFileSync(entryFullPath, "utf-8");
+          } catch {
+            continue;
+          }
+          unifiedParts.push(generateFileHeader(file3));
+          for (const entry of entries) {
+            unifiedParts.push(generateHunk(entryContent, entry.contextMatch, entry.oldContent, entry.newContent));
+          }
+        }
+        const unifiedPatch = unifiedParts.join("");
+        return JSON.stringify({
+          ...baseResult,
+          unifiedPatch
+        }, null, 2);
+      }
+      return JSON.stringify(baseResult, null, 2);
     }
     if (errors5.length === 1) {
       return JSON.stringify(errors5[0], null, 2);
@@ -125422,8 +126200,8 @@ function getContextAgent3(ctx) {
 init_zod();
 init_manager2();
 init_detector();
-import * as fs112 from "node:fs";
-import * as path154 from "node:path";
+import * as fs113 from "node:fs";
+import * as path155 from "node:path";
 init_create_tool();
 var MAX_FILE_SIZE2 = 2 * 1024 * 1024;
 var BINARY_CHECK_BYTES = 8192;
@@ -125489,7 +126267,7 @@ async function syntaxCheck(input, directory, config3) {
   if (languages?.length) {
     const lowerLangs = languages.map((l) => l.toLowerCase());
     filesToCheck = filesToCheck.filter((file3) => {
-      const ext = path154.extname(file3.path).toLowerCase();
+      const ext = path155.extname(file3.path).toLowerCase();
       const langDef = getLanguageForExtension(ext);
       const fileProfile = getProfileForFile(file3.path);
       const langId = fileProfile?.id || langDef?.id;
@@ -125502,7 +126280,7 @@ async function syntaxCheck(input, directory, config3) {
   let skippedCount = 0;
   for (const fileInfo of filesToCheck) {
     const { path: filePath } = fileInfo;
-    const fullPath = path154.isAbsolute(filePath) ? filePath : path154.join(directory, filePath);
+    const fullPath = path155.isAbsolute(filePath) ? filePath : path155.join(directory, filePath);
     const result = {
       path: filePath,
       language: "",
@@ -125532,7 +126310,7 @@ async function syntaxCheck(input, directory, config3) {
       }
       let content;
       try {
-        content = fs112.readFileSync(fullPath, "utf8");
+        content = fs113.readFileSync(fullPath, "utf8");
       } catch {
         result.skipped_reason = "file_read_error";
         skippedCount++;
@@ -125551,7 +126329,7 @@ async function syntaxCheck(input, directory, config3) {
         results.push(result);
         continue;
       }
-      const ext = path154.extname(filePath).toLowerCase();
+      const ext = path155.extname(filePath).toLowerCase();
       const langDef = getLanguageForExtension(ext);
       result.language = profile?.id || langDef?.id || "unknown";
       const errors5 = extractSyntaxErrors(parser, content);
@@ -125649,8 +126427,8 @@ init_zod();
 init_utils();
 init_create_tool();
 init_path_security();
-import * as fs113 from "node:fs";
-import * as path155 from "node:path";
+import * as fs114 from "node:fs";
+import * as path156 from "node:path";
 var MAX_TEXT_LENGTH = 200;
 var MAX_FILE_SIZE_BYTES11 = 1024 * 1024;
 var SUPPORTED_EXTENSIONS4 = new Set([
@@ -125673,7 +126451,7 @@ var SUPPORTED_EXTENSIONS4 = new Set([
   ".swift",
   ".kt"
 ]);
-var SKIP_DIRECTORIES5 = new Set([
+var SKIP_DIRECTORIES6 = new Set([
   "node_modules",
   "dist",
   "build",
@@ -125716,9 +126494,9 @@ function validatePathsInput(paths, cwd) {
     return { error: "paths contains path traversal", resolvedPath: null };
   }
   try {
-    const resolvedPath = path155.resolve(paths);
-    const normalizedCwd = path155.resolve(cwd);
-    const normalizedResolved = path155.resolve(resolvedPath);
+    const resolvedPath = path156.resolve(paths);
+    const normalizedCwd = path156.resolve(cwd);
+    const normalizedResolved = path156.resolve(resolvedPath);
     if (!normalizedResolved.startsWith(normalizedCwd)) {
       return {
         error: "paths must be within the current working directory",
@@ -125734,30 +126512,30 @@ function validatePathsInput(paths, cwd) {
   }
 }
 function isSupportedExtension(filePath) {
-  const ext = path155.extname(filePath).toLowerCase();
+  const ext = path156.extname(filePath).toLowerCase();
   return SUPPORTED_EXTENSIONS4.has(ext);
 }
-function findSourceFiles3(dir, files = []) {
+function findSourceFiles4(dir, files = []) {
   let entries;
   try {
-    entries = fs113.readdirSync(dir);
+    entries = fs114.readdirSync(dir);
   } catch {
     return files;
   }
   entries.sort((a, b) => a.toLowerCase().localeCompare(b.toLowerCase()));
   for (const entry of entries) {
-    if (SKIP_DIRECTORIES5.has(entry)) {
+    if (SKIP_DIRECTORIES6.has(entry)) {
       continue;
     }
-    const fullPath = path155.join(dir, entry);
+    const fullPath = path156.join(dir, entry);
     let stat9;
     try {
-      stat9 = fs113.statSync(fullPath);
+      stat9 = fs114.statSync(fullPath);
     } catch {
       continue;
     }
     if (stat9.isDirectory()) {
-      findSourceFiles3(fullPath, files);
+      findSourceFiles4(fullPath, files);
     } else if (stat9.isFile()) {
       if (isSupportedExtension(fullPath)) {
         files.push(fullPath);
@@ -125845,7 +126623,7 @@ var todo_extract = createSwarmTool({
       return JSON.stringify(errorResult, null, 2);
     }
     const scanPath = resolvedPath;
-    if (!fs113.existsSync(scanPath)) {
+    if (!fs114.existsSync(scanPath)) {
       const errorResult = {
         error: `path not found: ${pathsInput}`,
         total: 0,
@@ -125855,13 +126633,13 @@ var todo_extract = createSwarmTool({
       return JSON.stringify(errorResult, null, 2);
     }
     const filesToScan = [];
-    const stat9 = fs113.statSync(scanPath);
+    const stat9 = fs114.statSync(scanPath);
     if (stat9.isFile()) {
       if (isSupportedExtension(scanPath)) {
         filesToScan.push(scanPath);
       } else {
         const errorResult = {
-          error: `unsupported file extension: ${path155.extname(scanPath)}`,
+          error: `unsupported file extension: ${path156.extname(scanPath)}`,
           total: 0,
           byPriority: { high: 0, medium: 0, low: 0 },
           entries: []
@@ -125869,16 +126647,16 @@ var todo_extract = createSwarmTool({
         return JSON.stringify(errorResult, null, 2);
       }
     } else {
-      findSourceFiles3(scanPath, filesToScan);
+      findSourceFiles4(scanPath, filesToScan);
     }
     const allEntries = [];
     for (const filePath of filesToScan) {
       try {
-        const fileStat = fs113.statSync(filePath);
+        const fileStat = fs114.statSync(filePath);
         if (fileStat.size > MAX_FILE_SIZE_BYTES11) {
           continue;
         }
-        const content = fs113.readFileSync(filePath, "utf-8");
+        const content = fs114.readFileSync(filePath, "utf-8");
         const entries = parseTodoComments(content, filePath, tagsSet);
         allEntries.push(...entries);
       } catch {}
@@ -125910,18 +126688,18 @@ init_loader();
 init_schema();
 init_qa_gate_profile();
 init_gate_evidence();
-import * as fs117 from "node:fs";
-import * as path159 from "node:path";
+import * as fs118 from "node:fs";
+import * as path160 from "node:path";
 
 // src/hooks/diff-scope.ts
 init_bun_compat();
-import * as fs115 from "node:fs";
-import * as path157 from "node:path";
+import * as fs116 from "node:fs";
+import * as path158 from "node:path";
 
 // src/utils/gitignore-warning.ts
 init_bun_compat();
-import * as fs114 from "node:fs";
-import * as path156 from "node:path";
+import * as fs115 from "node:fs";
+import * as path157 from "node:path";
 var _internals67 = { bunSpawn };
 var _swarmGitExcludedChecked = false;
 function fileCoversSwarm(content) {
@@ -125995,16 +126773,16 @@ async function ensureSwarmGitExcluded(directory, options = {}) {
     const excludeRelPath = excludePathRaw.trim();
     if (!excludeRelPath)
       return;
-    const excludePath = path156.isAbsolute(excludeRelPath) ? excludeRelPath : path156.join(directory, excludeRelPath);
+    const excludePath = path157.isAbsolute(excludeRelPath) ? excludeRelPath : path157.join(directory, excludeRelPath);
     if (checkIgnoreExitCode !== 0) {
       try {
-        fs114.mkdirSync(path156.dirname(excludePath), { recursive: true });
+        fs115.mkdirSync(path157.dirname(excludePath), { recursive: true });
         let existing = "";
         try {
-          existing = fs114.readFileSync(excludePath, "utf8");
+          existing = fs115.readFileSync(excludePath, "utf8");
         } catch {}
         if (!fileCoversSwarm(existing)) {
-          fs114.appendFileSync(excludePath, `
+          fs115.appendFileSync(excludePath, `
 # opencode-swarm local runtime state
 .swarm/
 `, "utf8");
@@ -126042,10 +126820,10 @@ async function ensureSwarmGitExcluded(directory, options = {}) {
 var _internals68 = { bunSpawn };
 function getDeclaredScope(taskId, directory) {
   try {
-    const planPath = path157.join(directory, ".swarm", "plan.json");
-    if (!fs115.existsSync(planPath))
+    const planPath = path158.join(directory, ".swarm", "plan.json");
+    if (!fs116.existsSync(planPath))
       return null;
-    const raw = fs115.readFileSync(planPath, "utf-8");
+    const raw = fs116.readFileSync(planPath, "utf-8");
     const plan = JSON.parse(raw);
     for (const phase of plan.phases ?? []) {
       for (const task of phase.tasks ?? []) {
@@ -126147,8 +126925,8 @@ init_telemetry();
 
 // src/turbo/lean/task-completion.ts
 init_file_locks();
-import * as fs116 from "node:fs";
-import * as path158 from "node:path";
+import * as fs117 from "node:fs";
+import * as path159 from "node:path";
 var _internals69 = {
   listActiveLocks,
   verifyLeanTurboTaskCompletion
@@ -126167,7 +126945,7 @@ var TIER_3_PATTERNS = [
 ];
 function matchesTier3Pattern(files) {
   for (const file3 of files) {
-    const fileName = path158.basename(file3);
+    const fileName = path159.basename(file3);
     for (const pattern of TIER_3_PATTERNS) {
       if (pattern.test(fileName)) {
         return true;
@@ -126179,14 +126957,14 @@ function matchesTier3Pattern(files) {
 function verifyLeanTurboTaskCompletion(directory, taskId, sessionID) {
   let persisted = null;
   try {
-    const statePath = path158.join(directory, ".swarm", "turbo-state.json");
-    if (!fs116.existsSync(statePath)) {
+    const statePath = path159.join(directory, ".swarm", "turbo-state.json");
+    if (!fs117.existsSync(statePath)) {
       return {
         ok: false,
         reason: "Lean Turbo state file not found"
       };
     }
-    const raw = fs116.readFileSync(statePath, "utf-8");
+    const raw = fs117.readFileSync(statePath, "utf-8");
     persisted = JSON.parse(raw);
   } catch {
     return {
@@ -126263,11 +127041,11 @@ function verifyLeanTurboTaskCompletion(directory, taskId, sessionID) {
     };
   }
   const phase = runState.phase ?? 0;
-  const evidencePath = path158.join(directory, ".swarm", "evidence", String(phase), "lean-turbo", `${lane.laneId}.json`);
-  const expectedDir = path158.join(directory, ".swarm", "evidence", String(phase), "lean-turbo");
-  const resolvedPath = path158.resolve(evidencePath);
-  const resolvedDir = path158.resolve(expectedDir);
-  if (!resolvedPath.startsWith(resolvedDir + path158.sep) && resolvedPath !== resolvedDir) {
+  const evidencePath = path159.join(directory, ".swarm", "evidence", String(phase), "lean-turbo", `${lane.laneId}.json`);
+  const expectedDir = path159.join(directory, ".swarm", "evidence", String(phase), "lean-turbo");
+  const resolvedPath = path159.resolve(evidencePath);
+  const resolvedDir = path159.resolve(expectedDir);
+  if (!resolvedPath.startsWith(resolvedDir + path159.sep) && resolvedPath !== resolvedDir) {
     return {
       ok: false,
       reason: `Lane ID causes path traversal: ${lane.laneId}`,
@@ -126279,7 +127057,7 @@ function verifyLeanTurboTaskCompletion(directory, taskId, sessionID) {
       }
     };
   }
-  if (!fs116.existsSync(evidencePath)) {
+  if (!fs117.existsSync(evidencePath)) {
     return {
       ok: false,
       reason: `Lane ${lane.laneId} evidence file not found: ${evidencePath}`,
@@ -126307,8 +127085,8 @@ function verifyLeanTurboTaskCompletion(directory, taskId, sessionID) {
   }
   let filesTouched = [];
   try {
-    const planPath = path158.join(directory, ".swarm", "plan.json");
-    const planRaw = fs116.readFileSync(planPath, "utf-8");
+    const planPath = path159.join(directory, ".swarm", "plan.json");
+    const planRaw = fs117.readFileSync(planPath, "utf-8");
     const plan = JSON.parse(planRaw);
     for (const planPhase of plan.phases ?? []) {
       for (const task of planPhase.tasks ?? []) {
@@ -126391,7 +127169,7 @@ var TIER_3_PATTERNS2 = [
 ];
 function matchesTier3Pattern2(files) {
   for (const file3 of files) {
-    const fileName = path159.basename(file3);
+    const fileName = path160.basename(file3);
     for (const pattern of TIER_3_PATTERNS2) {
       if (pattern.test(fileName)) {
         return true;
@@ -126430,8 +127208,8 @@ function checkReviewerGate(taskId, workingDirectory, stageBParallelEnabled = fal
     if (!skipStandardTurboBypass && hasActiveTurboMode()) {
       const resolvedDir2 = workingDirectory;
       try {
-        const planPath = path159.join(resolvedDir2, ".swarm", "plan.json");
-        const planRaw = fs117.readFileSync(planPath, "utf-8");
+        const planPath = path160.join(resolvedDir2, ".swarm", "plan.json");
+        const planRaw = fs118.readFileSync(planPath, "utf-8");
         const plan = JSON.parse(planRaw);
         for (const planPhase of plan.phases ?? []) {
           for (const task of planPhase.tasks ?? []) {
@@ -126508,8 +127286,8 @@ function checkReviewerGate(taskId, workingDirectory, stageBParallelEnabled = fal
     }
     if (resolvedDir) {
       try {
-        const planPath = path159.join(resolvedDir, ".swarm", "plan.json");
-        const planRaw = fs117.readFileSync(planPath, "utf-8");
+        const planPath = path160.join(resolvedDir, ".swarm", "plan.json");
+        const planRaw = fs118.readFileSync(planPath, "utf-8");
         const plan = JSON.parse(planRaw);
         for (const planPhase of plan.phases ?? []) {
           for (const task of planPhase.tasks ?? []) {
@@ -126744,8 +127522,8 @@ async function executeUpdateTaskStatus(args2, fallbackDir, ctx) {
     };
   }
   directory = resolveResult.directory;
-  const planPath = path159.join(directory, ".swarm", "plan.json");
-  if (!fs117.existsSync(planPath)) {
+  const planPath = path160.join(directory, ".swarm", "plan.json");
+  if (!fs118.existsSync(planPath)) {
     return {
       success: false,
       message: `Invalid working_directory: plan not found in "${directory}"`,
@@ -126753,9 +127531,9 @@ async function executeUpdateTaskStatus(args2, fallbackDir, ctx) {
     };
   }
   if (fallbackDir && directory !== fallbackDir) {
-    const canonicalDir = fs117.realpathSync(path159.resolve(directory));
-    const canonicalRoot = fs117.realpathSync(path159.resolve(fallbackDir));
-    if (canonicalDir.startsWith(canonicalRoot + path159.sep)) {
+    const canonicalDir = fs118.realpathSync(path160.resolve(directory));
+    const canonicalRoot = fs118.realpathSync(path160.resolve(fallbackDir));
+    if (canonicalDir.startsWith(canonicalRoot + path160.sep)) {
       return {
         success: false,
         message: `Invalid working_directory: "${directory}" is a subdirectory of ` + `the project root "${fallbackDir}". Pass the project root path or ` + `omit working_directory entirely.`,
@@ -126767,22 +127545,22 @@ async function executeUpdateTaskStatus(args2, fallbackDir, ctx) {
   }
   if (args2.status === "in_progress") {
     try {
-      const evidencePath = path159.join(directory, ".swarm", "evidence", `${args2.task_id}.json`);
-      fs117.mkdirSync(path159.dirname(evidencePath), { recursive: true });
-      const fd = fs117.openSync(evidencePath, "wx");
+      const evidencePath = path160.join(directory, ".swarm", "evidence", `${args2.task_id}.json`);
+      fs118.mkdirSync(path160.dirname(evidencePath), { recursive: true });
+      const fd = fs118.openSync(evidencePath, "wx");
       let writeOk = false;
       try {
-        fs117.writeSync(fd, JSON.stringify({
+        fs118.writeSync(fd, JSON.stringify({
           taskId: args2.task_id,
           required_gates: [],
           gates: {}
         }, null, 2));
         writeOk = true;
       } finally {
-        fs117.closeSync(fd);
+        fs118.closeSync(fd);
         if (!writeOk) {
           try {
-            fs117.unlinkSync(evidencePath);
+            fs118.unlinkSync(evidencePath);
           } catch {}
         }
       }
@@ -126792,8 +127570,8 @@ async function executeUpdateTaskStatus(args2, fallbackDir, ctx) {
     recoverTaskStateFromDelegations(args2.task_id, directory);
     let phaseRequiresReviewer = true;
     try {
-      const planPath2 = path159.join(directory, ".swarm", "plan.json");
-      const planRaw = fs117.readFileSync(planPath2, "utf-8");
+      const planPath2 = path160.join(directory, ".swarm", "plan.json");
+      const planRaw = fs118.readFileSync(planPath2, "utf-8");
       const plan = JSON.parse(planRaw);
       const taskPhase = plan.phases.find((p) => p.tasks.some((t) => t.id === args2.task_id));
       if (taskPhase?.required_agents && !taskPhase.required_agents.includes("reviewer")) {
@@ -127021,7 +127799,7 @@ init_utils2();
 init_redaction();
 import { createHash as createHash12 } from "node:crypto";
 import { appendFile as appendFile14, mkdir as mkdir25 } from "node:fs/promises";
-import * as path160 from "node:path";
+import * as path161 from "node:path";
 var EVIDENCE_CACHE_FILE = "evidence-cache/documents.jsonl";
 var MAX_EVIDENCE_TEXT_LENGTH = 4000;
 async function writeEvidenceDocuments(directory, inputs, now = () => new Date) {
@@ -127029,7 +127807,7 @@ async function writeEvidenceDocuments(directory, inputs, now = () => new Date) {
   const capturedAt = now().toISOString();
   const records = inputs.map((input) => createEvidenceDocumentRecord(input, capturedAt)).filter((record3) => record3 !== null);
   if (records.length > 0) {
-    await mkdir25(path160.dirname(filePath), { recursive: true });
+    await mkdir25(path161.dirname(filePath), { recursive: true });
     await appendFile14(filePath, `${records.map((record3) => JSON.stringify(record3)).join(`
 `)}
 `, "utf-8");
@@ -127226,7 +128004,7 @@ init_schema3();
 init_store();
 init_create_tool();
 init_resolve_working_directory();
-import * as path161 from "node:path";
+import * as path162 from "node:path";
 var FindingSchema2 = exports_external.object({
   severity: exports_external.enum(["low", "medium", "high", "critical"]),
   category: exports_external.string().min(1),
@@ -127290,7 +128068,7 @@ var write_architecture_supervisor_evidence = createSwarmTool({
       if (config3.architectural_supervision?.persist_knowledge_recommendations && args2.knowledge_recommendations.length > 0) {
         const knowledgeConfig = KnowledgeConfigSchema.parse(config3.knowledge ?? {});
         const lessons = args2.knowledge_recommendations.map((r) => r.lesson);
-        const result = await curateAndStoreSwarm(lessons, path161.basename(dirResult.directory), { phase_number: args2.phase }, dirResult.directory, knowledgeConfig, { skipAutoPromotion: true });
+        const result = await curateAndStoreSwarm(lessons, path162.basename(dirResult.directory), { phase_number: args2.phase }, dirResult.directory, knowledgeConfig, { skipAutoPromotion: true });
         knowledgeProposed = result.stored;
       }
     } catch {}
@@ -127325,8 +128103,8 @@ init_utils2();
 init_ledger();
 init_manager();
 init_create_tool();
-import fs118 from "node:fs";
-import path162 from "node:path";
+import fs119 from "node:fs";
+import path163 from "node:path";
 function normalizeVerdict(verdict) {
   switch (verdict) {
     case "APPROVED":
@@ -127374,7 +128152,7 @@ async function executeWriteDriftEvidence(args2, directory) {
     entries: [evidenceEntry]
   };
   const filename = "drift-verifier.json";
-  const relativePath = path162.join("evidence", String(phase), filename);
+  const relativePath = path163.join("evidence", String(phase), filename);
   let validatedPath;
   try {
     validatedPath = validateSwarmPath(directory, relativePath);
@@ -127385,12 +128163,12 @@ async function executeWriteDriftEvidence(args2, directory) {
       message: error93 instanceof Error ? error93.message : "Failed to validate path"
     }, null, 2);
   }
-  const evidenceDir = path162.dirname(validatedPath);
+  const evidenceDir = path163.dirname(validatedPath);
   try {
-    await fs118.promises.mkdir(evidenceDir, { recursive: true });
-    const tempPath = path162.join(evidenceDir, `.${filename}.tmp`);
-    await fs118.promises.writeFile(tempPath, JSON.stringify(evidenceContent, null, 2), "utf-8");
-    await fs118.promises.rename(tempPath, validatedPath);
+    await fs119.promises.mkdir(evidenceDir, { recursive: true });
+    const tempPath = path163.join(evidenceDir, `.${filename}.tmp`);
+    await fs119.promises.writeFile(tempPath, JSON.stringify(evidenceContent, null, 2), "utf-8");
+    await fs119.promises.rename(tempPath, validatedPath);
     let snapshotInfo;
     let snapshotError;
     let qaProfileLocked;
@@ -127484,8 +128262,8 @@ var write_drift_evidence = createSwarmTool({
 // src/tools/write-final-council-evidence.ts
 init_zod();
 init_loader();
-import fs119 from "node:fs";
-import path163 from "node:path";
+import fs120 from "node:fs";
+import path164 from "node:path";
 init_utils2();
 init_manager();
 init_create_tool();
@@ -127573,7 +128351,7 @@ async function executeWriteFinalCouncilEvidence(args2, directory) {
     timestamp: synthesis.timestamp
   };
   const filename = "final-council.json";
-  const relativePath = path163.join("evidence", filename);
+  const relativePath = path164.join("evidence", filename);
   let validatedPath;
   try {
     validatedPath = validateSwarmPath(directory, relativePath);
@@ -127587,12 +128365,12 @@ async function executeWriteFinalCouncilEvidence(args2, directory) {
   const evidenceContent = {
     entries: [evidenceEntry]
   };
-  const evidenceDir = path163.dirname(validatedPath);
+  const evidenceDir = path164.dirname(validatedPath);
   try {
-    await fs119.promises.mkdir(evidenceDir, { recursive: true });
-    const tempPath = path163.join(evidenceDir, `.${filename}.tmp`);
-    await fs119.promises.writeFile(tempPath, JSON.stringify(evidenceContent, null, 2), "utf-8");
-    await fs119.promises.rename(tempPath, validatedPath);
+    await fs120.promises.mkdir(evidenceDir, { recursive: true });
+    const tempPath = path164.join(evidenceDir, `.${filename}.tmp`);
+    await fs120.promises.writeFile(tempPath, JSON.stringify(evidenceContent, null, 2), "utf-8");
+    await fs120.promises.rename(tempPath, validatedPath);
     return JSON.stringify({
       success: true,
       phase: input.phase,
@@ -127649,8 +128427,8 @@ var write_final_council_evidence = createSwarmTool({
 init_zod();
 init_utils2();
 init_create_tool();
-import fs120 from "node:fs";
-import path164 from "node:path";
+import fs121 from "node:fs";
+import path165 from "node:path";
 function normalizeVerdict2(verdict) {
   switch (verdict) {
     case "APPROVED":
@@ -127698,7 +128476,7 @@ async function executeWriteHallucinationEvidence(args2, directory) {
     entries: [evidenceEntry]
   };
   const filename = "hallucination-guard.json";
-  const relativePath = path164.join("evidence", String(phase), filename);
+  const relativePath = path165.join("evidence", String(phase), filename);
   let validatedPath;
   try {
     validatedPath = validateSwarmPath(directory, relativePath);
@@ -127709,12 +128487,12 @@ async function executeWriteHallucinationEvidence(args2, directory) {
       message: error93 instanceof Error ? error93.message : "Failed to validate path"
     }, null, 2);
   }
-  const evidenceDir = path164.dirname(validatedPath);
+  const evidenceDir = path165.dirname(validatedPath);
   try {
-    await fs120.promises.mkdir(evidenceDir, { recursive: true });
-    const tempPath = path164.join(evidenceDir, `.${filename}.tmp`);
-    await fs120.promises.writeFile(tempPath, JSON.stringify(evidenceContent, null, 2), "utf-8");
-    await fs120.promises.rename(tempPath, validatedPath);
+    await fs121.promises.mkdir(evidenceDir, { recursive: true });
+    const tempPath = path165.join(evidenceDir, `.${filename}.tmp`);
+    await fs121.promises.writeFile(tempPath, JSON.stringify(evidenceContent, null, 2), "utf-8");
+    await fs121.promises.rename(tempPath, validatedPath);
     return JSON.stringify({
       success: true,
       phase,
@@ -127761,8 +128539,8 @@ var write_hallucination_evidence = createSwarmTool({
 init_zod();
 init_utils2();
 init_create_tool();
-import fs121 from "node:fs";
-import path165 from "node:path";
+import fs122 from "node:fs";
+import path166 from "node:path";
 function normalizeVerdict3(verdict) {
   switch (verdict) {
     case "PASS":
@@ -127836,7 +128614,7 @@ async function executeWriteMutationEvidence(args2, directory) {
     entries: [evidenceEntry]
   };
   const filename = "mutation-gate.json";
-  const relativePath = path165.join("evidence", String(phase), filename);
+  const relativePath = path166.join("evidence", String(phase), filename);
   let validatedPath;
   try {
     validatedPath = validateSwarmPath(directory, relativePath);
@@ -127847,12 +128625,12 @@ async function executeWriteMutationEvidence(args2, directory) {
       message: error93 instanceof Error ? error93.message : "Failed to validate path"
     }, null, 2);
   }
-  const evidenceDir = path165.dirname(validatedPath);
+  const evidenceDir = path166.dirname(validatedPath);
   try {
-    await fs121.promises.mkdir(evidenceDir, { recursive: true });
-    const tempPath = path165.join(evidenceDir, `.${filename}.tmp`);
-    await fs121.promises.writeFile(tempPath, JSON.stringify(evidenceContent, null, 2), "utf-8");
-    await fs121.promises.rename(tempPath, validatedPath);
+    await fs122.promises.mkdir(evidenceDir, { recursive: true });
+    const tempPath = path166.join(evidenceDir, `.${filename}.tmp`);
+    await fs122.promises.writeFile(tempPath, JSON.stringify(evidenceContent, null, 2), "utf-8");
+    await fs122.promises.rename(tempPath, validatedPath);
     return JSON.stringify({
       success: true,
       phase,
@@ -127934,6 +128712,7 @@ var TOOL_MANIFEST = defineHandlers({
   mutation_test: () => mutation_test,
   generate_mutants: () => generate_mutants,
   detect_domains: () => detect_domains,
+  git_blame: () => git_blame,
   gitingest: () => gitingest,
   retrieve_summary: () => retrieve_summary,
   extract_code_blocks: () => extract_code_blocks,
@@ -128298,7 +129077,7 @@ async function initializeOpenCodeSwarm(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 = path167.resolve(ctx.directory, ".swarm");
+    const swarmDir = path168.resolve(ctx.directory, ".swarm");
     statusArtifact = new ASA(swarmDir);
     statusArtifact.updateConfig(automationConfig.mode, automationConfig.capabilities);
     if (automationConfig.capabilities?.evidence_auto_summaries === true) {
@@ -128812,7 +129591,7 @@ ${promptRaw}`;
                   const meta3 = readSkillMetadata(s.skillPath, ctx.directory);
                   let desc = meta3.description || "";
                   if (!desc || desc === "No description provided") {
-                    desc = path167.basename(path167.dirname(s.skillPath));
+                    desc = path168.basename(path168.dirname(s.skillPath));
                   }
                   desc = desc.replace(/,/g, ";");
                   return `file:${s.skillPath} (-- ${desc})`;
@@ -128822,7 +129601,7 @@ ${promptRaw}`;
 
 ${promptRaw}`;
                 argsRecord.prompt = newPrompt;
-                const skillNames = topSkills.map((s) => `${path167.basename(s.skillPath)} (score: ${s.score.toFixed(2)})`).join(", ");
+                const skillNames = topSkills.map((s) => `${path168.basename(s.skillPath)} (score: ${s.score.toFixed(2)})`).join(", ");
                 console.warn(`[skill-propagation-gate] Injected skills: ${skillNames}`);
                 for (const skill of topSkills) {
                   try {