opencode-swarm 7.1.0 → 7.2.0

package/dist/index.js

@@ -33,7 +33,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "opencode-swarm",
-    version: "7.1.0",
+    version: "7.2.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",
@@ -15873,8 +15873,11 @@ var init_errors3 = __esm(() => {
 });
 
 // src/utils/logger.ts
+function isDebug() {
+  return process.env.OPENCODE_SWARM_DEBUG === "1";
+}
 function log(message, data) {
-  if (!DEBUG)
+  if (!isDebug())
     return;
   const timestamp = new Date().toISOString();
   if (data !== undefined) {
@@ -15884,7 +15887,7 @@ function log(message, data) {
   }
 }
 function warn(message, data) {
-  if (!DEBUG)
+  if (!isDebug())
     return;
   const timestamp = new Date().toISOString();
   if (data !== undefined) {
@@ -15901,10 +15904,6 @@ function error48(message, data) {
     console.error(`[opencode-swarm ${timestamp}] ERROR: ${message}`);
   }
 }
-var DEBUG;
-var init_logger = __esm(() => {
-  DEBUG = process.env.OPENCODE_SWARM_DEBUG === "1";
-});
 
 // src/utils/regex.ts
 function escapeRegex2(s) {
@@ -15918,7 +15917,6 @@ function simpleGlobToRegex(pattern, flags2 = "i") {
 // src/utils/index.ts
 var init_utils = __esm(() => {
   init_errors3();
-  init_logger();
 });
 
 // src/utils/bun-compat.ts
@@ -25138,7 +25136,6 @@ var init_guardrails = __esm(() => {
   init_telemetry();
   init_utils();
   init_bun_compat();
-  init_logger();
   init_conflict_resolution();
   init_delegation_gate();
   init_loop_detector();
@@ -26098,7 +26095,6 @@ var init_delegation_gate = __esm(() => {
   init_schema();
   init_state();
   init_telemetry();
-  init_logger();
   init_guardrails();
   init_normalize_tool_name();
   init_utils2();
@@ -40586,9 +40582,7 @@ function resetToRemoteBranch(cwd, options) {
   }
 }
 var GIT_TIMEOUT_MS2 = 30000;
-var init_branch = __esm(() => {
-  init_logger();
-});
+var init_branch = () => {};
 
 // src/hooks/knowledge-store.ts
 import { existsSync as existsSync9 } from "node:fs";
@@ -40915,7 +40909,7 @@ async function recordLessonsShown(directory, lessonIds, currentPhase) {
     await mkdir4(path16.dirname(shownFile), { recursive: true });
     await writeFile4(shownFile, JSON.stringify(shownData, null, 2), "utf-8");
   } catch {
-    console.warn("[swarm] Knowledge: failed to record shown lessons");
+    warn("[swarm] Knowledge: failed to record shown lessons");
   }
 }
 async function readMergedKnowledge(directory, config3, context) {
@@ -41065,7 +41059,7 @@ async function updateRetrievalOutcome(directory, phaseInfo, phaseSucceeded) {
     delete shownData[phaseInfo];
     await writeFile4(shownFile, JSON.stringify(shownData, null, 2), "utf-8");
   } catch {
-    console.warn("[swarm] Knowledge: failed to update retrieval outcomes");
+    warn("[swarm] Knowledge: failed to update retrieval outcomes");
   }
 }
 var JACCARD_THRESHOLD = 0.6, HIVE_TIER_BOOST = 0.05, SAME_PROJECT_PENALTY = -0.05;
@@ -41216,12 +41210,12 @@ function validateLesson(candidate, existingLessons, meta3) {
 }
 async function quarantineEntry(directory, entryId, reason, reportedBy) {
   if (!directory || directory.includes("..")) {
-    console.warn("[knowledge-validator] quarantineEntry: directory traversal attempt blocked");
+    warn("[knowledge-validator] quarantineEntry: directory traversal attempt blocked");
     return;
   }
   if (!entryId || entryId.includes("\x00") || entryId.includes(`
 `)) {
-    console.warn("[knowledge-validator] quarantineEntry: invalid entryId rejected");
+    warn("[knowledge-validator] quarantineEntry: invalid entryId rejected");
     return;
   }
   const validReportedBy = ["architect", "user", "auto"];
@@ -41281,12 +41275,12 @@ async function quarantineEntry(directory, entryId, reason, reportedBy) {
 }
 async function restoreEntry(directory, entryId) {
   if (!directory || directory.includes("..")) {
-    console.warn("[knowledge-validator] restoreEntry: directory traversal attempt blocked");
+    warn("[knowledge-validator] restoreEntry: directory traversal attempt blocked");
     return;
   }
   if (!entryId || entryId.includes("\x00") || entryId.includes(`
 `)) {
-    console.warn("[knowledge-validator] restoreEntry: invalid entryId rejected");
+    warn("[knowledge-validator] restoreEntry: invalid entryId rejected");
     return;
   }
   const knowledgePath = path17.join(directory, ".swarm", "knowledge.jsonl");
@@ -43245,9 +43239,7 @@ async function readCuratorSummary(directory) {
     }
     return parsed;
   } catch {
-    if (process.env.DEBUG_SWARM) {
-      console.warn("Failed to parse curator-summary.json: invalid JSON");
-    }
+    warn("Failed to parse curator-summary.json: invalid JSON");
     return null;
   }
 }
@@ -43280,9 +43272,7 @@ function filterPhaseEvents(eventsJsonl, phase, sinceTimestamp) {
         }
       }
     } catch {
-      if (process.env.DEBUG_SWARM) {
-        console.warn("filterPhaseEvents: skipping malformed line");
-      }
+      warn("filterPhaseEvents: skipping malformed line");
     }
   }
   return filtered;
@@ -43831,7 +43821,6 @@ var init_curator = __esm(() => {
   init_event_bus();
   init_manager();
   init_bun_compat();
-  init_logger();
   init_knowledge_store();
   init_knowledge_validator();
   init_utils2();
@@ -49256,7 +49245,6 @@ async function writeSentinel(sentinelPath, migrated, dropped) {
   await writeFile6(sentinelPath, JSON.stringify(sentinel, null, 2), "utf-8");
 }
 var init_knowledge_migrator = __esm(() => {
-  init_logger();
   init_knowledge_store();
   init_knowledge_validator();
 });
@@ -60219,13 +60207,13 @@ __export(exports_review_receipt, {
   buildApprovedReceipt: () => buildApprovedReceipt
 });
 import * as crypto5 from "node:crypto";
-import * as fs34 from "node:fs";
-import * as path48 from "node:path";
+import * as fs35 from "node:fs";
+import * as path49 from "node:path";
 function resolveReceiptsDir(directory) {
-  return path48.join(directory, ".swarm", "review-receipts");
+  return path49.join(directory, ".swarm", "review-receipts");
 }
 function resolveReceiptIndexPath(directory) {
-  return path48.join(resolveReceiptsDir(directory), "index.json");
+  return path49.join(resolveReceiptsDir(directory), "index.json");
 }
 function buildReceiptFilename(id, date9) {
   const dateStr = date9.toISOString().slice(0, 10);
@@ -60248,11 +60236,11 @@ function isScopeStale(receipt, currentContent) {
 }
 async function readReceiptIndex(directory) {
   const indexPath = resolveReceiptIndexPath(directory);
-  if (!fs34.existsSync(indexPath)) {
+  if (!fs35.existsSync(indexPath)) {
     return { schema_version: 1, entries: [] };
   }
   try {
-    const content = await fs34.promises.readFile(indexPath, "utf-8");
+    const content = await fs35.promises.readFile(indexPath, "utf-8");
     const parsed = JSON.parse(content);
     if (parsed.schema_version !== 1 || !Array.isArray(parsed.entries)) {
       return { schema_version: 1, entries: [] };
@@ -60264,21 +60252,21 @@ async function readReceiptIndex(directory) {
 }
 async function writeReceiptIndex(directory, index) {
   const indexPath = resolveReceiptIndexPath(directory);
-  const dir = path48.dirname(indexPath);
-  await fs34.promises.mkdir(dir, { recursive: true });
+  const dir = path49.dirname(indexPath);
+  await fs35.promises.mkdir(dir, { recursive: true });
   const tmpPath = `${indexPath}.tmp.${Date.now()}.${Math.random().toString(36).slice(2)}`;
-  await fs34.promises.writeFile(tmpPath, JSON.stringify(index, null, 2), "utf-8");
-  fs34.renameSync(tmpPath, indexPath);
+  await fs35.promises.writeFile(tmpPath, JSON.stringify(index, null, 2), "utf-8");
+  fs35.renameSync(tmpPath, indexPath);
 }
 async function persistReviewReceipt(directory, receipt) {
   const receiptsDir = resolveReceiptsDir(directory);
-  await fs34.promises.mkdir(receiptsDir, { recursive: true });
+  await fs35.promises.mkdir(receiptsDir, { recursive: true });
   const now = new Date(receipt.reviewed_at);
   const filename = buildReceiptFilename(receipt.id, now);
-  const receiptPath = path48.join(receiptsDir, filename);
+  const receiptPath = path49.join(receiptsDir, filename);
   const tmpPath = `${receiptPath}.tmp.${Date.now()}.${Math.random().toString(36).slice(2)}`;
-  await fs34.promises.writeFile(tmpPath, JSON.stringify(receipt, null, 2), "utf-8");
-  fs34.renameSync(tmpPath, receiptPath);
+  await fs35.promises.writeFile(tmpPath, JSON.stringify(receipt, null, 2), "utf-8");
+  fs35.renameSync(tmpPath, receiptPath);
   const index = await readReceiptIndex(directory);
   const entry = {
     id: receipt.id,
@@ -60297,9 +60285,9 @@ async function readReceiptById(directory, receiptId) {
   const entry = index.entries.find((e) => e.id === receiptId);
   if (!entry)
     return null;
-  const receiptPath = path48.join(resolveReceiptsDir(directory), entry.filename);
+  const receiptPath = path49.join(resolveReceiptsDir(directory), entry.filename);
   try {
-    const content = await fs34.promises.readFile(receiptPath, "utf-8");
+    const content = await fs35.promises.readFile(receiptPath, "utf-8");
     return JSON.parse(content);
   } catch {
     return null;
@@ -60310,9 +60298,9 @@ async function readReceiptsByScopeHash(directory, scopeHash) {
   const matching = index.entries.filter((e) => e.scope_hash === scopeHash).sort((a, b) => b.reviewed_at.localeCompare(a.reviewed_at));
   const receipts = [];
   for (const entry of matching) {
-    const receiptPath = path48.join(resolveReceiptsDir(directory), entry.filename);
+    const receiptPath = path49.join(resolveReceiptsDir(directory), entry.filename);
     try {
-      const content = await fs34.promises.readFile(receiptPath, "utf-8");
+      const content = await fs35.promises.readFile(receiptPath, "utf-8");
       receipts.push(JSON.parse(content));
     } catch {}
   }
@@ -60323,9 +60311,9 @@ async function readAllReceipts(directory) {
   const sorted = [...index.entries].sort((a, b) => b.reviewed_at.localeCompare(a.reviewed_at));
   const receipts = [];
   for (const entry of sorted) {
-    const receiptPath = path48.join(resolveReceiptsDir(directory), entry.filename);
+    const receiptPath = path49.join(resolveReceiptsDir(directory), entry.filename);
     try {
-      const content = await fs34.promises.readFile(receiptPath, "utf-8");
+      const content = await fs35.promises.readFile(receiptPath, "utf-8");
       receipts.push(JSON.parse(content));
     } catch {}
   }
@@ -60446,7 +60434,6 @@ var init_preflight_integration = __esm(() => {
   init_status_artifact();
   init_trigger();
   init_preflight_service();
-  init_logger();
 });
 
 // node_modules/web-tree-sitter/tree-sitter.js
@@ -61911,11 +61898,11 @@ ${JSON.stringify(symbolNames, null, 2)}`);
         throw toThrow;
       }, "quit_");
       var scriptDirectory = "";
-      function locateFile(path59) {
+      function locateFile(path60) {
         if (Module["locateFile"]) {
-          return Module["locateFile"](path59, scriptDirectory);
+          return Module["locateFile"](path60, scriptDirectory);
         }
-        return scriptDirectory + path59;
+        return scriptDirectory + path60;
       }
       __name(locateFile, "locateFile");
       var readAsync, readBinary;
@@ -63664,13 +63651,13 @@ __export(exports_runtime, {
   getInitializedLanguages: () => getInitializedLanguages,
   clearParserCache: () => clearParserCache
 });
-import * as path59 from "node:path";
+import * as path60 from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 async function initTreeSitter() {
   if (treeSitterInitialized) {
     return;
   }
-  const thisDir = path59.dirname(fileURLToPath2(import.meta.url));
+  const thisDir = path60.dirname(fileURLToPath2(import.meta.url));
   const isSource = thisDir.replace(/\\/g, "/").endsWith("/src/lang");
   if (isSource) {
     await Parser.init();
@@ -63678,7 +63665,7 @@ async function initTreeSitter() {
     const grammarsDir = getGrammarsDirAbsolute();
     await Parser.init({
       locateFile(scriptName) {
-        return path59.join(grammarsDir, scriptName);
+        return path60.join(grammarsDir, scriptName);
       }
     });
   }
@@ -63699,11 +63686,11 @@ function getWasmFileName(languageId) {
   return `tree-sitter-${sanitized}.wasm`;
 }
 function getGrammarsDirAbsolute() {
-  const thisDir = path59.dirname(fileURLToPath2(import.meta.url));
+  const thisDir = path60.dirname(fileURLToPath2(import.meta.url));
   const normalized = thisDir.replace(/\\/g, "/");
   const isSource = normalized.endsWith("/src/lang");
   const isCliBundle = normalized.endsWith("/cli");
-  return isSource ? path59.join(thisDir, "grammars") : isCliBundle ? path59.join(thisDir, "..", "lang", "grammars") : path59.join(thisDir, "lang", "grammars");
+  return isSource ? path60.join(thisDir, "grammars") : isCliBundle ? path60.join(thisDir, "..", "lang", "grammars") : path60.join(thisDir, "lang", "grammars");
 }
 async function loadGrammar(languageId) {
   if (typeof languageId !== "string" || languageId.length > 100) {
@@ -63719,9 +63706,9 @@ async function loadGrammar(languageId) {
   await initTreeSitter();
   const parser = new Parser;
   const wasmFileName = getWasmFileName(normalizedId);
-  const wasmPath = path59.join(getGrammarsDirAbsolute(), wasmFileName);
-  const { existsSync: existsSync30 } = await import("node:fs");
-  if (!existsSync30(wasmPath)) {
+  const wasmPath = path60.join(getGrammarsDirAbsolute(), wasmFileName);
+  const { existsSync: existsSync31 } = await import("node:fs");
+  if (!existsSync31(wasmPath)) {
     throw new Error(`Grammar file not found for ${languageId}: ${wasmPath}
 Make sure to run 'bun run build' to copy grammar files to dist/lang/grammars/`);
   }
@@ -63754,7 +63741,7 @@ async function isGrammarAvailable(languageId) {
   }
   try {
     const wasmFileName = getWasmFileName(normalizedId);
-    const wasmPath = path59.join(getGrammarsDirAbsolute(), wasmFileName);
+    const wasmPath = path60.join(getGrammarsDirAbsolute(), wasmFileName);
     const { statSync: statSync19 } = await import("node:fs");
     statSync19(wasmPath);
     return true;
@@ -63811,15 +63798,15 @@ __export(exports_doc_scan, {
   doc_extract: () => doc_extract
 });
 import * as crypto7 from "node:crypto";
-import * as fs43 from "node:fs";
+import * as fs44 from "node:fs";
 import { mkdir as mkdir10, readFile as readFile10, writeFile as writeFile9 } from "node:fs/promises";
-import * as path61 from "node:path";
+import * as path62 from "node:path";
 function normalizeSeparators(filePath) {
   return filePath.replace(/\\/g, "/");
 }
 function matchesDocPattern(filePath, patterns) {
   const normalizedPath = normalizeSeparators(filePath);
-  const basename9 = path61.basename(filePath);
+  const basename9 = path62.basename(filePath);
   for (const pattern of patterns) {
     if (!pattern.includes("/") && !pattern.includes("\\")) {
       if (basename9 === pattern) {
@@ -63875,7 +63862,7 @@ function stripMarkdown(text) {
   return text.replace(/\[([^\]]+)\]\([^)]+\)/g, "$1").replace(/\*\*([^*]+)\*\*/g, "$1").replace(/`([^`]+)`/g, "$1").replace(/^\s*[-*•]\s+/gm, "").replace(/^\s*\d+\.\s+/gm, "").trim();
 }
 async function scanDocIndex(directory) {
-  const manifestPath = path61.join(directory, ".swarm", "doc-manifest.json");
+  const manifestPath = path62.join(directory, ".swarm", "doc-manifest.json");
   const defaultPatterns = DocsConfigSchema.parse({}).doc_patterns;
   const extraPatterns = [
     "ARCHITECTURE.md",
@@ -63892,8 +63879,8 @@ async function scanDocIndex(directory) {
       let cacheValid = true;
       for (const file3 of existingManifest.files) {
         try {
-          const fullPath = path61.join(directory, file3.path);
-          const stat5 = fs43.statSync(fullPath);
+          const fullPath = path62.join(directory, file3.path);
+          const stat5 = fs44.statSync(fullPath);
           if (stat5.mtimeMs > file3.mtime) {
             cacheValid = false;
             break;
@@ -63911,7 +63898,7 @@ async function scanDocIndex(directory) {
   const discoveredFiles = [];
   let rawEntries;
   try {
-    rawEntries = fs43.readdirSync(directory, { recursive: true });
+    rawEntries = fs44.readdirSync(directory, { recursive: true });
   } catch {
     const manifest2 = {
       schema_version: 1,
@@ -63922,10 +63909,10 @@ async function scanDocIndex(directory) {
   }
   const entries = rawEntries.filter((e) => typeof e === "string");
   for (const entry of entries) {
-    const fullPath = path61.join(directory, entry);
+    const fullPath = path62.join(directory, entry);
     let stat5;
     try {
-      stat5 = fs43.statSync(fullPath);
+      stat5 = fs44.statSync(fullPath);
     } catch {
       continue;
     }
@@ -63954,11 +63941,11 @@ async function scanDocIndex(directory) {
     }
     let content;
     try {
-      content = fs43.readFileSync(fullPath, "utf-8");
+      content = fs44.readFileSync(fullPath, "utf-8");
     } catch {
       continue;
     }
-    const { title, summary } = extractTitleAndSummary(content, path61.basename(entry));
+    const { title, summary } = extractTitleAndSummary(content, path62.basename(entry));
     const lineCount = content.split(`
 `).length;
     discoveredFiles.push({
@@ -63984,7 +63971,7 @@ async function scanDocIndex(directory) {
     files: discoveredFiles
   };
   try {
-    await mkdir10(path61.dirname(manifestPath), { recursive: true });
+    await mkdir10(path62.dirname(manifestPath), { recursive: true });
     await writeFile9(manifestPath, JSON.stringify(manifest, null, 2), "utf-8");
   } catch {}
   return { manifest, cached: false };
@@ -64023,7 +64010,7 @@ function extractConstraintsFromContent(content) {
   return constraints;
 }
 async function extractDocConstraints(directory, taskFiles, taskDescription) {
-  const manifestPath = path61.join(directory, ".swarm", "doc-manifest.json");
+  const manifestPath = path62.join(directory, ".swarm", "doc-manifest.json");
   let manifest;
   try {
     const content = await readFile10(manifestPath, "utf-8");
@@ -64049,7 +64036,7 @@ async function extractDocConstraints(directory, taskFiles, taskDescription) {
     }
     let fullContent;
     try {
-      fullContent = await readFile10(path61.join(directory, docFile.path), "utf-8");
+      fullContent = await readFile10(path62.join(directory, docFile.path), "utf-8");
     } catch {
       skippedCount++;
       continue;
@@ -64072,7 +64059,7 @@ async function extractDocConstraints(directory, taskFiles, taskDescription) {
           tier: "swarm",
           lesson: constraint,
           category: "architecture",
-          tags: ["doc-scan", path61.basename(docFile.path)],
+          tags: ["doc-scan", path62.basename(docFile.path)],
           scope: "global",
           confidence: 0.5,
           status: "candidate",
@@ -64145,9 +64132,9 @@ var init_doc_scan = __esm(() => {
         }
       } catch {}
       if (force) {
-        const manifestPath = path61.join(directory, ".swarm", "doc-manifest.json");
+        const manifestPath = path62.join(directory, ".swarm", "doc-manifest.json");
         try {
-          fs43.unlinkSync(manifestPath);
+          fs44.unlinkSync(manifestPath);
         } catch {}
       }
       const { manifest, cached: cached3 } = await scanDocIndex(directory);
@@ -64335,11 +64322,11 @@ __export(exports_curator_drift, {
   readPriorDriftReports: () => readPriorDriftReports,
   buildDriftInjectionText: () => buildDriftInjectionText
 });
-import * as fs46 from "node:fs";
-import * as path64 from "node:path";
+import * as fs47 from "node:fs";
+import * as path65 from "node:path";
 async function readPriorDriftReports(directory) {
-  const swarmDir = path64.join(directory, ".swarm");
-  const entries = await fs46.promises.readdir(swarmDir).catch(() => null);
+  const swarmDir = path65.join(directory, ".swarm");
+  const entries = await fs47.promises.readdir(swarmDir).catch(() => null);
   if (entries === null)
     return [];
   const reportFiles = entries.filter((name2) => name2.startsWith(DRIFT_REPORT_PREFIX) && name2.endsWith(".json")).sort();
@@ -64365,10 +64352,10 @@ async function readPriorDriftReports(directory) {
 async function writeDriftReport(directory, report) {
   const filename = `${DRIFT_REPORT_PREFIX}${report.phase}.json`;
   const filePath = validateSwarmPath(directory, filename);
-  const swarmDir = path64.dirname(filePath);
-  await fs46.promises.mkdir(swarmDir, { recursive: true });
+  const swarmDir = path65.dirname(filePath);
+  await fs47.promises.mkdir(swarmDir, { recursive: true });
   try {
-    await fs46.promises.writeFile(filePath, JSON.stringify(report, null, 2), "utf-8");
+    await fs47.promises.writeFile(filePath, JSON.stringify(report, null, 2), "utf-8");
   } catch (err2) {
     throw new Error(`[curator-drift] Failed to write drift report to ${filePath}: ${String(err2)}`);
   }
@@ -64493,15 +64480,13 @@ function buildDriftInjectionText(report, maxChars) {
 var DRIFT_REPORT_PREFIX = "drift-report-phase-";
 var init_curator_drift = __esm(() => {
   init_event_bus();
-  init_logger();
   init_utils2();
 });
 
 // src/index.ts
 init_package();
 init_agents2();
-import * as fs87 from "node:fs";
-import * as path107 from "node:path";
+import * as path108 from "node:path";
 
 // src/background/index.ts
 init_event_bus();
@@ -64920,6 +64905,64 @@ function createSwarmCommandHandler(directory, agents) {
 // src/index.ts
 init_config();
 init_constants();
+
+// src/config/project-init.ts
+init_constants();
+import * as fs31 from "node:fs";
+import * as path48 from "node:path";
+var STARTER_CONTENT = `{}
+`;
+function writeProjectConfigIfNew(directory, quiet = false) {
+  try {
+    const opencodeDir = path48.join(directory, ".opencode");
+    const dest = path48.join(opencodeDir, "opencode-swarm.json");
+    try {
+      const stat4 = fs31.lstatSync(opencodeDir);
+      if (stat4.isSymbolicLink())
+        return;
+    } catch (err2) {
+      if (err2.code !== "ENOENT")
+        return;
+    }
+    if (!fs31.existsSync(opencodeDir)) {
+      fs31.mkdirSync(opencodeDir, { recursive: true });
+    }
+    try {
+      fs31.writeFileSync(dest, STARTER_CONTENT, {
+        encoding: "utf-8",
+        flag: "wx"
+      });
+      if (!quiet) {
+        console.warn("[opencode-swarm] Created .opencode/opencode-swarm.json — " + "edit it to customize agent LLMs for this project, or commit it to share settings with your team");
+      }
+    } catch (_writeErr) {}
+  } catch {}
+}
+function writeSwarmConfigExampleIfNew(projectDirectory) {
+  try {
+    const swarmDir = path48.join(projectDirectory, ".swarm");
+    const dest = path48.join(swarmDir, "config.example.json");
+    if (fs31.existsSync(dest))
+      return;
+    if (!fs31.existsSync(swarmDir)) {
+      fs31.mkdirSync(swarmDir, { recursive: true });
+    }
+    const example = {
+      agents: Object.fromEntries(Object.entries(DEFAULT_MODELS).filter(([name2]) => name2 !== "default").map(([name2, model]) => [
+        name2,
+        {
+          model,
+          fallback_models: ["opencode/gpt-5-nano", "opencode/big-pickle"]
+        }
+      ])),
+      max_iterations: 5
+    };
+    fs31.writeFileSync(dest, `${JSON.stringify(example, null, 2)}
+`, "utf-8");
+  } catch {}
+}
+
+// src/index.ts
 init_schema();
 
 // src/hooks/agent-activity.ts
@@ -64997,11 +65040,11 @@ async function doFlush(directory) {
     const activitySection = renderActivitySection();
     const updated = replaceOrAppendSection(existing, "## Agent Activity", activitySection);
     const flushedCount = swarmState.pendingEvents;
-    const path48 = nodePath2.join(directory, ".swarm", "context.md");
-    const tempPath = `${path48}.tmp`;
+    const path49 = nodePath2.join(directory, ".swarm", "context.md");
+    const tempPath = `${path49}.tmp`;
     try {
       await bunWrite(tempPath, updated);
-      renameSync11(tempPath, path48);
+      renameSync11(tempPath, path49);
     } catch (writeError) {
       try {
         unlinkSync8(tempPath);
@@ -65051,8 +65094,8 @@ ${content.substring(endIndex + 1)}`;
 // src/hooks/compaction-customizer.ts
 init_manager();
 init_utils2();
-import * as fs31 from "node:fs";
-import { join as join44 } from "node:path";
+import * as fs32 from "node:fs";
+import { join as join45 } from "node:path";
 function createCompactionCustomizerHook(config3, directory) {
   const enabled = config3.hooks?.compaction !== false;
   if (!enabled) {
@@ -65097,8 +65140,8 @@ function createCompactionCustomizerHook(config3, directory) {
         }
       }
       try {
-        const summariesDir = join44(directory, ".swarm", "summaries");
-        const files = await fs31.promises.readdir(summariesDir);
+        const summariesDir = join45(directory, ".swarm", "summaries");
+        const files = await fs32.promises.readdir(summariesDir);
         if (files.length > 0) {
           const count = files.length;
           output.context.push(`[CONTEXT OPTIMIZATION] Tool outputs from earlier in this session have been stored to disk. When compacting, replace any large tool output blocks (bash, test_runner, lint, diff results) with a one-line reference: "[Output stored — use /swarm retrieve to access full content]". Preserve the tool name, exit status, and any error messages. Discard raw output lines.`);
@@ -65584,7 +65627,7 @@ init_delegation_gate();
 
 // src/hooks/delegation-sanitizer.ts
 init_utils2();
-import * as fs32 from "node:fs";
+import * as fs33 from "node:fs";
 var SANITIZATION_PATTERNS = [
   /\b\d+(st|nd|rd|th)\s+(attempt|try|time)\b/gi,
   /\b(5th|fifth|final|last)\s+attempt\b/gi,
@@ -65655,7 +65698,7 @@ function createDelegationSanitizerHook(directory) {
               stripped_patterns: result.stripped,
               timestamp: new Date().toISOString()
             };
-            fs32.appendFileSync(eventsPath, `${JSON.stringify(event)}
+            fs33.appendFileSync(eventsPath, `${JSON.stringify(event)}
 `, "utf-8");
           } catch {}
         }
@@ -65721,9 +65764,8 @@ init_schema();
 init_file_locks();
 init_state();
 init_telemetry();
-init_logger();
 init_utils2();
-import * as fs33 from "node:fs";
+import * as fs34 from "node:fs";
 var END_OF_SENTENCE_QUESTION_PATTERN = /\?\s*$/;
 var PHASE_COMPLETION_PATTERNS = [
   /Ready for Phase (?:\d+|\[?N\+1\]?)\??/i,
@@ -65917,7 +65959,7 @@ async function writeAutoOversightEvent(directory, architectOutput, criticVerdict
   }
   try {
     const eventsPath = validateSwarmPath(dir, "events.jsonl");
-    fs33.appendFileSync(eventsPath, `${JSON.stringify(event)}
+    fs34.appendFileSync(eventsPath, `${JSON.stringify(event)}
 `, "utf-8");
   } catch (writeError) {
     error48(`[full-auto-intercept] Warning: failed to write auto_oversight event: ${writeError instanceof Error ? writeError.message : String(writeError)}`);
@@ -66229,7 +66271,7 @@ async function writeEscalationReport(directory, reason, architectOutput, interac
     if (currentPhase === undefined) {
       try {
         const planPath = validateSwarmPath(directory, "plan.json");
-        const planContent = fs33.readFileSync(planPath, "utf-8");
+        const planContent = fs34.readFileSync(planPath, "utf-8");
         const plan = JSON.parse(planContent);
         const incompletePhases = plan.phases.filter((p) => p.status !== "complete").sort((a, b) => b.id - a.id);
         currentPhase = incompletePhases[0]?.id;
@@ -66268,7 +66310,7 @@ ${currentPhase !== undefined ? `- **Phase Status**: Pending completion` : ""}
 This escalation requires human intervention. The swarm has been paused.
 Please review the architect's output above and provide guidance.
 `;
-    fs33.writeFileSync(reportPath, reportContent, "utf-8");
+    fs34.writeFileSync(reportPath, reportContent, "utf-8");
     log(`[full-auto-intercept] Escalation report written to: ${reportPath}`);
   } catch (error93) {
     error48(`[full-auto-intercept] Failed to write escalation report:`, error93 instanceof Error ? error93.message : String(error93));
@@ -66362,7 +66404,7 @@ init_schema();
 init_manager();
 init_curator();
 init_utils2();
-import * as path49 from "node:path";
+import * as path50 from "node:path";
 function createPhaseMonitorHook(directory, preflightManager, curatorRunner, delegateFactory) {
   let lastKnownPhase = null;
   const handler = async (input, _output) => {
@@ -66382,9 +66424,9 @@ function createPhaseMonitorHook(directory, preflightManager, curatorRunner, dele
           const llmDelegate = delegateFactory?.(sessionId);
           const initResult = await runner(directory, curatorConfig, llmDelegate);
           if (initResult.briefing) {
-            const briefingPath = path49.join(directory, ".swarm", "curator-briefing.md");
+            const briefingPath = path50.join(directory, ".swarm", "curator-briefing.md");
             const { mkdir: mkdir8, writeFile: writeFile8 } = await import("node:fs/promises");
-            await mkdir8(path49.dirname(briefingPath), { recursive: true });
+            await mkdir8(path50.dirname(briefingPath), { recursive: true });
             await writeFile8(briefingPath, initResult.briefing, "utf-8");
             const { buildApprovedReceipt: buildApprovedReceipt2, persistReviewReceipt: persistReviewReceipt2 } = await Promise.resolve().then(() => (init_review_receipt(), exports_review_receipt));
             const initReceipt = buildApprovedReceipt2({
@@ -66509,17 +66551,16 @@ ${originalText}`;
 }
 // src/hooks/repo-graph-builder.ts
 init_constants();
-import * as path52 from "node:path";
+import * as path53 from "node:path";
 
 // src/tools/repo-graph.ts
 init_utils2();
-init_logger();
 init_path_security();
 import * as fsSync3 from "node:fs";
-import { constants as constants4, existsSync as existsSync28, realpathSync as realpathSync6 } from "node:fs";
+import { constants as constants4, existsSync as existsSync29, realpathSync as realpathSync6 } from "node:fs";
 import * as fsPromises5 from "node:fs/promises";
 import * as os7 from "node:os";
-import * as path51 from "node:path";
+import * as path52 from "node:path";
 
 // src/utils/timeout.ts
 async function withTimeout(promise3, ms, timeoutError) {
@@ -66550,8 +66591,8 @@ function yieldToEventLoop() {
 init_zod();
 init_create_tool();
 init_path_security();
-import * as fs35 from "node:fs";
-import * as path50 from "node:path";
+import * as fs36 from "node:fs";
+import * as path51 from "node:path";
 var MAX_FILE_SIZE_BYTES2 = 1024 * 1024;
 var WINDOWS_RESERVED_NAMES = /^(con|prn|aux|nul|com[1-9]|lpt[1-9])(\.|:|$)/i;
 function containsWindowsAttacks(str) {
@@ -66568,11 +66609,11 @@ function containsWindowsAttacks(str) {
 }
 function isPathInWorkspace(filePath, workspace) {
   try {
-    const resolvedPath = path50.resolve(workspace, filePath);
-    const realWorkspace = fs35.realpathSync(workspace);
-    const realResolvedPath = fs35.realpathSync(resolvedPath);
-    const relativePath = path50.relative(realWorkspace, realResolvedPath);
-    if (relativePath.startsWith("..") || path50.isAbsolute(relativePath)) {
+    const resolvedPath = path51.resolve(workspace, filePath);
+    const realWorkspace = fs36.realpathSync(workspace);
+    const realResolvedPath = fs36.realpathSync(resolvedPath);
+    const relativePath = path51.relative(realWorkspace, realResolvedPath);
+    if (relativePath.startsWith("..") || path51.isAbsolute(relativePath)) {
       return false;
     }
     return true;
@@ -66584,17 +66625,17 @@ function validatePathForRead(filePath, workspace) {
   return isPathInWorkspace(filePath, workspace);
 }
 function extractTSSymbols(filePath, cwd) {
-  const fullPath = path50.join(cwd, filePath);
+  const fullPath = path51.join(cwd, filePath);
   if (!validatePathForRead(fullPath, cwd)) {
     return [];
   }
   let content;
   try {
-    const stats = fs35.statSync(fullPath);
+    const stats = fs36.statSync(fullPath);
     if (stats.size > MAX_FILE_SIZE_BYTES2) {
       throw new Error(`File too large: ${stats.size} bytes (max: ${MAX_FILE_SIZE_BYTES2})`);
     }
-    content = fs35.readFileSync(fullPath, "utf-8");
+    content = fs36.readFileSync(fullPath, "utf-8");
   } catch {
     return [];
   }
@@ -66736,17 +66777,17 @@ function extractTSSymbols(filePath, cwd) {
   });
 }
 function extractPythonSymbols(filePath, cwd) {
-  const fullPath = path50.join(cwd, filePath);
+  const fullPath = path51.join(cwd, filePath);
   if (!validatePathForRead(fullPath, cwd)) {
     return [];
   }
   let content;
   try {
-    const stats = fs35.statSync(fullPath);
+    const stats = fs36.statSync(fullPath);
     if (stats.size > MAX_FILE_SIZE_BYTES2) {
       throw new Error(`File too large: ${stats.size} bytes (max: ${MAX_FILE_SIZE_BYTES2})`);
     }
-    content = fs35.readFileSync(fullPath, "utf-8");
+    content = fs36.readFileSync(fullPath, "utf-8");
   } catch {
     return [];
   }
@@ -66819,7 +66860,7 @@ var symbols = createSwarmTool({
       }, null, 2);
     }
     const cwd = directory;
-    const ext = path50.extname(file3);
+    const ext = path51.extname(file3);
     if (containsControlChars(file3)) {
       return JSON.stringify({
         file: file3,
@@ -66883,7 +66924,7 @@ var symbols = createSwarmTool({
 var WINDOWS_RENAME_MAX_RETRIES2 = 3;
 var WINDOWS_RENAME_RETRY_DELAY_MS2 = 50;
 function normalizeGraphPath(filePath) {
-  return path51.normalize(filePath).replace(/\\/g, "/");
+  return path52.normalize(filePath).replace(/\\/g, "/");
 }
 var REPO_GRAPH_FILENAME = "repo-graph.json";
 var GRAPH_SCHEMA_VERSION = "1.0.0";
@@ -66992,8 +67033,8 @@ function resolveModuleSpecifier(workspaceRoot, sourceFile, specifier) {
   }
   try {
     if (specifier.startsWith(".")) {
-      const sourceDir = path51.dirname(sourceFile);
-      let resolved = path51.resolve(sourceDir, specifier);
+      const sourceDir = path52.dirname(sourceFile);
+      let resolved = path52.resolve(sourceDir, specifier);
       let realResolved;
       try {
         realResolved = realpathSync6(resolved);
@@ -67004,9 +67045,9 @@ function resolveModuleSpecifier(workspaceRoot, sourceFile, specifier) {
       try {
         realRoot = realpathSync6(workspaceRoot);
       } catch {
-        realRoot = path51.normalize(workspaceRoot);
+        realRoot = path52.normalize(workspaceRoot);
       }
-      if (!existsSync28(resolved)) {
+      if (!existsSync29(resolved)) {
         const EXTENSIONS = [
           ".ts",
           ".tsx",
@@ -67020,7 +67061,7 @@ function resolveModuleSpecifier(workspaceRoot, sourceFile, specifier) {
         let found = null;
         for (const ext of EXTENSIONS) {
           const candidate = resolved + ext;
-          if (existsSync28(candidate)) {
+          if (existsSync29(candidate)) {
             found = candidate;
             break;
           }
@@ -67036,9 +67077,9 @@ function resolveModuleSpecifier(workspaceRoot, sourceFile, specifier) {
           return null;
         }
       }
-      const normalizedResolved = path51.normalize(realResolved);
-      const normalizedRoot = path51.normalize(realRoot);
-      if (!normalizedResolved.startsWith(normalizedRoot + path51.sep) && normalizedResolved !== normalizedRoot) {
+      const normalizedResolved = path52.normalize(realResolved);
+      const normalizedRoot = path52.normalize(realRoot);
+      if (!normalizedResolved.startsWith(normalizedRoot + path52.sep) && normalizedResolved !== normalizedRoot) {
         return null;
       }
       return resolved;
@@ -67051,7 +67092,7 @@ function resolveModuleSpecifier(workspaceRoot, sourceFile, specifier) {
 function createEmptyGraph(workspaceRoot) {
   return {
     schema_version: GRAPH_SCHEMA_VERSION,
-    workspaceRoot: path51.normalize(workspaceRoot),
+    workspaceRoot: path52.normalize(workspaceRoot),
     nodes: {},
     edges: [],
     metadata: {
@@ -67085,10 +67126,10 @@ function addEdge(graph, edge) {
   }
 }
 function getCachedGraph(workspace) {
-  return graphCache.get(path51.normalize(workspace));
+  return graphCache.get(path52.normalize(workspace));
 }
 function setCachedGraph(workspace, graph, mtime) {
-  const normalized = path51.normalize(workspace);
+  const normalized = path52.normalize(workspace);
   graphCache.set(normalized, graph);
   dirtyFlags.set(normalized, false);
   if (mtime !== undefined) {
@@ -67096,10 +67137,10 @@ function setCachedGraph(workspace, graph, mtime) {
   }
 }
 function isDirty(workspace) {
-  return dirtyFlags.get(path51.normalize(workspace)) ?? false;
+  return dirtyFlags.get(path52.normalize(workspace)) ?? false;
 }
 function clearCache(workspace) {
-  const normalized = path51.normalize(workspace);
+  const normalized = path52.normalize(workspace);
   graphCache.delete(normalized);
   dirtyFlags.delete(normalized);
   mtimeCache.delete(normalized);
@@ -67112,12 +67153,12 @@ function getGraphPath(workspace) {
 }
 async function loadGraph(workspace) {
   validateWorkspace(workspace);
-  const normalized = path51.normalize(workspace);
+  const normalized = path52.normalize(workspace);
   const cached3 = getCachedGraph(normalized);
   if (cached3 && !isDirty(normalized)) {
     try {
       const graphPath = getGraphPath(workspace);
-      if (existsSync28(graphPath)) {
+      if (existsSync29(graphPath)) {
         const stats = await fsPromises5.stat(graphPath);
         const cachedMtime = mtimeCache.get(normalized);
         if (cachedMtime !== undefined && stats.mtimeMs !== cachedMtime) {
@@ -67134,7 +67175,7 @@ async function loadGraph(workspace) {
   }
   try {
     const graphPath = getGraphPath(workspace);
-    if (!existsSync28(graphPath)) {
+    if (!existsSync29(graphPath)) {
       return null;
     }
     const stats = await fsPromises5.stat(graphPath);
@@ -67206,28 +67247,28 @@ async function saveGraph(workspace, graph, options) {
   if (!Array.isArray(graph.edges)) {
     throw new Error("Graph must have edges array");
   }
-  const normalizedWorkspace = path51.normalize(workspace);
+  const normalizedWorkspace = path52.normalize(workspace);
   let realWorkspace;
   try {
     realWorkspace = realpathSync6(workspace);
   } catch {
     realWorkspace = normalizedWorkspace;
   }
-  const normalizedGraphRoot = path51.normalize(graph.workspaceRoot);
+  const normalizedGraphRoot = path52.normalize(graph.workspaceRoot);
   let realGraphRoot;
   try {
     realGraphRoot = realpathSync6(graph.workspaceRoot);
   } catch {
     realGraphRoot = normalizedGraphRoot;
   }
-  if (path51.normalize(realWorkspace) !== path51.normalize(realGraphRoot)) {
+  if (path52.normalize(realWorkspace) !== path52.normalize(realGraphRoot)) {
     throw new Error(`Graph workspaceRoot mismatch: graph was built for "${graph.workspaceRoot}" but save was called for "${workspace}"`);
   }
   const normalized = normalizedWorkspace;
   const graphPath = getGraphPath(workspace);
   updateGraphMetadata(graph);
   const tempPath = `${graphPath}.tmp.${Date.now()}.${Math.floor(Math.random() * 1e9)}`;
-  await fsPromises5.mkdir(path51.dirname(tempPath), { recursive: true });
+  await fsPromises5.mkdir(path52.dirname(tempPath), { recursive: true });
   let lastError = null;
   try {
     if (options?.createAtomic) {
@@ -67311,12 +67352,12 @@ function isRefusedWorkspaceRoot(target) {
   try {
     resolved = realpathSync6(target);
   } catch {
-    resolved = path51.resolve(target);
+    resolved = path52.resolve(target);
   }
   const refused = new Set;
   const add = (p) => {
     if (typeof p === "string" && p.length > 0) {
-      refused.add(path51.resolve(p));
+      refused.add(path52.resolve(p));
     }
   };
   add(os7.homedir());
@@ -67435,7 +67476,7 @@ async function findSourceFilesAsync(dir, stats, options) {
         ctx.stats.skippedDirs++;
         continue;
       }
-      const fullPath = path51.join(current, entry.name);
+      const fullPath = path52.join(current, entry.name);
       if (entry.isSymbolicLink() && !ctx.followSymlinks) {
         ctx.stats.skippedDirs++;
         continue;
@@ -67443,7 +67484,7 @@ async function findSourceFilesAsync(dir, stats, options) {
       if (entry.isDirectory()) {
         queue.push(fullPath);
       } else if (entry.isFile()) {
-        const ext = path51.extname(fullPath).toLowerCase();
+        const ext = path52.extname(fullPath).toLowerCase();
         if (SUPPORTED_EXTENSIONS.includes(ext)) {
           files.push(fullPath);
         }
@@ -67460,11 +67501,11 @@ async function findSourceFilesAsync(dir, stats, options) {
   return files;
 }
 function toModuleName(filePath, workspaceRoot) {
-  const relative9 = path51.relative(workspaceRoot, filePath);
-  return relative9.split(path51.sep).join("/");
+  const relative9 = path52.relative(workspaceRoot, filePath);
+  return relative9.split(path52.sep).join("/");
 }
 function getLanguage(filePath) {
-  const ext = path51.extname(filePath).toLowerCase();
+  const ext = path52.extname(filePath).toLowerCase();
   return EXTENSION_TO_LANGUAGE[ext] ?? "unknown";
 }
 function isBinaryContent(content) {
@@ -67479,8 +67520,8 @@ async function buildWorkspaceGraphAsync(workspaceRoot, options) {
   const maxFiles = options?.maxFiles ?? DEFAULT_WALK_FILE_CAP;
   const walkBudgetMs = options?.walkBudgetMs ?? DEFAULT_WALK_BUDGET_MS;
   const followSymlinks = options?.followSymlinks ?? false;
-  const absoluteRoot = path51.resolve(workspaceRoot);
-  if (!existsSync28(absoluteRoot)) {
+  const absoluteRoot = path52.resolve(workspaceRoot);
+  if (!existsSync29(absoluteRoot)) {
     throw new Error(`Workspace directory does not exist: ${workspaceRoot}`);
   }
   if (isRefusedWorkspaceRoot(absoluteRoot)) {
@@ -67549,15 +67590,15 @@ function scanFile(filePath, absoluteRoot, maxFileSize) {
   if (isBinaryContent(content)) {
     return { node: null, edges: [] };
   }
-  const ext = path51.extname(filePath).toLowerCase();
+  const ext = path52.extname(filePath).toLowerCase();
   let exports = [];
   try {
     if ([".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs"].includes(ext)) {
-      const relativePath = path51.relative(absoluteRoot, filePath);
+      const relativePath = path52.relative(absoluteRoot, filePath);
       const symbols2 = extractTSSymbols(relativePath, absoluteRoot);
       exports = symbols2.filter((s) => s.exported).map((s) => s.name);
     } else if (ext === ".py") {
-      const relativePath = path51.relative(absoluteRoot, filePath);
+      const relativePath = path52.relative(absoluteRoot, filePath);
       const symbols2 = extractPythonSymbols(relativePath, absoluteRoot);
       exports = symbols2.filter((s) => s.exported).map((s) => s.name);
     }
@@ -67601,12 +67642,12 @@ async function updateGraphForFiles(workspaceRoot, filePaths, options) {
     return graph2;
   }
   const graph = existingGraph;
-  const absoluteRoot = path51.resolve(workspaceRoot);
+  const absoluteRoot = path52.resolve(workspaceRoot);
   const maxFileSize = 1024 * 1024;
   const updatedPaths = new Set;
   for (const rawFilePath of filePaths) {
     const normalizedPath = normalizeGraphPath(rawFilePath);
-    const fileExists = existsSync28(rawFilePath);
+    const fileExists = existsSync29(rawFilePath);
     if (fileExists) {
       graph.edges = graph.edges.filter((e) => normalizeGraphPath(e.source) !== normalizedPath);
       const result = scanFile(rawFilePath, absoluteRoot, maxFileSize);
@@ -67645,9 +67686,7 @@ async function updateGraphForFiles(workspaceRoot, filePaths, options) {
   await saveGraph(workspaceRoot, graph);
   return graph;
 }
-
 // src/hooks/repo-graph-builder.ts
-init_logger();
 var SUPPORTED_EXTENSIONS2 = [
   ".ts",
   ".tsx",
@@ -67723,7 +67762,7 @@ function createRepoGraphBuilderHook(workspaceRoot, deps) {
       filePath = filePath.replace(/．/g, ".").replace(/／/g, "/").replace(/․/g, ".");
       if (!isSupportedSourceFile(filePath))
         return;
-      const absoluteFilePath = path52.isAbsolute(filePath) ? filePath : path52.resolve(workspaceRoot, filePath);
+      const absoluteFilePath = path53.isAbsolute(filePath) ? filePath : path53.resolve(workspaceRoot, filePath);
       const normalizedAbsolute = absoluteFilePath.replace(/\\/g, "/");
       const normalizedWorkspace = workspaceRoot.replace(/\\/g, "/");
       if (!normalizedAbsolute.startsWith(`${normalizedWorkspace}/`) && normalizedAbsolute !== normalizedWorkspace) {
@@ -67731,7 +67770,7 @@ function createRepoGraphBuilderHook(workspaceRoot, deps) {
       }
       try {
         await _updateGraphForFiles(workspaceRoot, [absoluteFilePath]);
-        log(`[repo-graph] Incremental update for ${path52.basename(filePath)}`);
+        log(`[repo-graph] Incremental update for ${path53.basename(filePath)}`);
       } catch (error93) {
         const message = error93 instanceof Error ? error93.message : String(error93);
         error48(`[repo-graph] Incremental update failed: ${message}`);
@@ -67749,15 +67788,15 @@ init_schema();
 init_manager2();
 init_detector();
 init_manager();
-import * as fs44 from "node:fs";
-import * as path62 from "node:path";
+import * as fs45 from "node:fs";
+import * as path63 from "node:path";
 
 // src/services/decision-drift-analyzer.ts
 init_utils2();
 init_manager();
 init_utils();
-import * as fs36 from "node:fs";
-import * as path53 from "node:path";
+import * as fs37 from "node:fs";
+import * as path54 from "node:path";
 var DEFAULT_DRIFT_CONFIG = {
   staleThresholdPhases: 1,
   detectContradictions: true,
@@ -67911,11 +67950,11 @@ async function analyzeDecisionDrift(directory, config3 = {}) {
         currentPhase = legacyPhase;
       }
     }
-    const contextPath = path53.join(directory, ".swarm", "context.md");
+    const contextPath = path54.join(directory, ".swarm", "context.md");
     let contextContent = "";
     try {
-      if (fs36.existsSync(contextPath)) {
-        contextContent = fs36.readFileSync(contextPath, "utf-8");
+      if (fs37.existsSync(contextPath)) {
+        contextContent = fs37.readFileSync(contextPath, "utf-8");
       }
     } catch (error93) {
       log("[DecisionDriftAnalyzer] context file read failed", {
@@ -68049,8 +68088,8 @@ init_utils();
 // src/hooks/adversarial-detector.ts
 init_constants();
 init_schema();
-import * as fs37 from "node:fs/promises";
-import * as path54 from "node:path";
+import * as fs38 from "node:fs/promises";
+import * as path55 from "node:path";
 function safeGet(obj, key) {
   if (!obj || !Object.hasOwn(obj, key))
     return;
@@ -68282,10 +68321,10 @@ async function handleDebuggingSpiral(match, taskId, directory) {
   let eventLogged = false;
   let checkpointCreated = false;
   try {
-    const swarmDir = path54.join(directory, ".swarm");
-    await fs37.mkdir(swarmDir, { recursive: true });
-    const eventsPath = path54.join(swarmDir, "events.jsonl");
-    await fs37.appendFile(eventsPath, `${formatDebuggingSpiralEvent(match, taskId)}
+    const swarmDir = path55.join(directory, ".swarm");
+    await fs38.mkdir(swarmDir, { recursive: true });
+    const eventsPath = path55.join(swarmDir, "events.jsonl");
+    await fs38.appendFile(eventsPath, `${formatDebuggingSpiralEvent(match, taskId)}
 `);
     eventLogged = true;
   } catch {}
@@ -68415,11 +68454,11 @@ function rankCandidates(candidates, config3) {
 init_knowledge_store();
 
 // src/hooks/repo-graph-injection.ts
-import * as fs41 from "node:fs";
+import * as fs42 from "node:fs";
 
 // src/graph/graph-builder.ts
-import * as fs39 from "node:fs";
-import * as path57 from "node:path";
+import * as fs40 from "node:fs";
+import * as path58 from "node:path";
 
 // node_modules/yocto-queue/index.js
 class Node {
@@ -68579,8 +68618,8 @@ function validateConcurrency(concurrency) {
 
 // src/graph/import-extractor.ts
 init_path_security();
-import * as fs38 from "node:fs";
-import * as path55 from "node:path";
+import * as fs39 from "node:fs";
+import * as path56 from "node:path";
 var SOURCE_EXTENSIONS2 = [
   ".ts",
   ".tsx",
@@ -68625,27 +68664,27 @@ function getLanguageFromExtension(ext) {
   return null;
 }
 function toRelForwardSlash(absPath, root) {
-  return path55.relative(root, absPath).replace(/\\/g, "/");
+  return path56.relative(root, absPath).replace(/\\/g, "/");
 }
 function tryResolveTSJS(rawModule, sourceFileAbs) {
   if (!rawModule.startsWith(".") && !rawModule.startsWith("/")) {
     return null;
   }
-  const sourceDir = path55.dirname(sourceFileAbs);
-  const baseAbs = path55.resolve(sourceDir, rawModule);
+  const sourceDir = path56.dirname(sourceFileAbs);
+  const baseAbs = path56.resolve(sourceDir, rawModule);
   const probe = (basePath) => {
     for (const ext of RESOLVE_EXTENSION_CANDIDATES) {
       const test = basePath + ext;
       try {
-        const stat5 = fs38.statSync(test);
+        const stat5 = fs39.statSync(test);
         if (stat5.isFile())
           return test;
       } catch {}
     }
     for (const indexFile of RESOLVE_INDEX_CANDIDATES) {
-      const test = path55.join(basePath, indexFile);
+      const test = path56.join(basePath, indexFile);
       try {
-        const stat5 = fs38.statSync(test);
+        const stat5 = fs39.statSync(test);
         if (stat5.isFile())
           return test;
       } catch {}
@@ -68673,13 +68712,13 @@ function tryResolvePython(rawModule, sourceFileAbs, workspaceRoot) {
   }
   const remainder = rawModule.slice(leadingDots).replace(/\./g, "/");
   const upDirs = "../".repeat(Math.max(0, leadingDots - 1));
-  const sourceDir = path55.dirname(sourceFileAbs);
-  const baseAbs = path55.resolve(sourceDir, upDirs + remainder);
+  const sourceDir = path56.dirname(sourceFileAbs);
+  const baseAbs = path56.resolve(sourceDir, upDirs + remainder);
   const accept = (test) => {
     try {
-      const stat5 = fs38.statSync(test);
+      const stat5 = fs39.statSync(test);
       if (stat5.isFile()) {
-        const rel = path55.relative(workspaceRoot, test).replace(/\\/g, "/");
+        const rel = path56.relative(workspaceRoot, test).replace(/\\/g, "/");
         if (rel.startsWith(".."))
           return null;
         return test;
@@ -68693,7 +68732,7 @@ function tryResolvePython(rawModule, sourceFileAbs, workspaceRoot) {
       return hit;
   }
   for (const indexFile of PY_INDEX_CANDIDATES) {
-    const hit = accept(path55.join(baseAbs, indexFile));
+    const hit = accept(path56.join(baseAbs, indexFile));
     if (hit)
       return hit;
   }
@@ -69064,14 +69103,14 @@ function parseRustUses(content) {
 }
 function extractImports2(opts) {
   const { absoluteFilePath, workspaceRoot } = opts;
-  const ext = path55.extname(absoluteFilePath).toLowerCase();
+  const ext = path56.extname(absoluteFilePath).toLowerCase();
   const language = getLanguageFromExtension(ext);
   if (!language)
     return [];
   let content = opts.content;
   if (content === undefined) {
     try {
-      content = fs38.readFileSync(absoluteFilePath, "utf-8");
+      content = fs39.readFileSync(absoluteFilePath, "utf-8");
     } catch {
       return [];
     }
@@ -69115,9 +69154,9 @@ function extractImports2(opts) {
 }
 
 // src/graph/symbol-extractor.ts
-import * as path56 from "node:path";
+import * as path57 from "node:path";
 function extractExportedSymbols(relativeFilePath, workspaceRoot) {
-  const ext = path56.extname(relativeFilePath).toLowerCase();
+  const ext = path57.extname(relativeFilePath).toLowerCase();
   const language = getLanguageFromExtension(ext);
   if (!language)
     return [];
@@ -69191,7 +69230,7 @@ function findSourceFiles(workspaceRoot, skipDirs = DEFAULT_SKIP_DIRS) {
     const dir = stack.pop();
     let entries;
     try {
-      entries = fs39.readdirSync(dir, { withFileTypes: true });
+      entries = fs40.readdirSync(dir, { withFileTypes: true });
     } catch {
       continue;
     }
@@ -69206,15 +69245,15 @@ function findSourceFiles(workspaceRoot, skipDirs = DEFAULT_SKIP_DIRS) {
       if (entry.isDirectory()) {
         if (skipDirs.has(entry.name))
           continue;
-        stack.push(path57.join(dir, entry.name));
+        stack.push(path58.join(dir, entry.name));
         continue;
       }
       if (!entry.isFile())
         continue;
-      const ext = path57.extname(entry.name).toLowerCase();
+      const ext = path58.extname(entry.name).toLowerCase();
       if (!SOURCE_EXT_SET.has(ext))
         continue;
-      out2.push(path57.join(dir, entry.name));
+      out2.push(path58.join(dir, entry.name));
     }
   }
   return out2;
@@ -69242,13 +69281,13 @@ async function buildRepoGraph(workspaceRoot, options = {}) {
   };
 }
 async function processFile(absoluteFilePath, workspaceRoot) {
-  const ext = path57.extname(absoluteFilePath).toLowerCase();
+  const ext = path58.extname(absoluteFilePath).toLowerCase();
   const language = getLanguageFromExtension(ext);
   if (!language)
     return null;
   let stats;
   try {
-    stats = fs39.statSync(absoluteFilePath);
+    stats = fs40.statSync(absoluteFilePath);
   } catch {
     return null;
   }
@@ -69258,11 +69297,11 @@ async function processFile(absoluteFilePath, workspaceRoot) {
     return null;
   let content;
   try {
-    content = fs39.readFileSync(absoluteFilePath, "utf-8");
+    content = fs40.readFileSync(absoluteFilePath, "utf-8");
   } catch {
     return null;
   }
-  const relPath = path57.relative(workspaceRoot, absoluteFilePath).replace(/\\/g, "/");
+  const relPath = path58.relative(workspaceRoot, absoluteFilePath).replace(/\\/g, "/");
   const imports = extractImports2({
     absoluteFilePath,
     workspaceRoot,
@@ -69503,17 +69542,17 @@ function formatSummary(opts) {
 }
 // src/graph/graph-store.ts
 import * as crypto6 from "node:crypto";
-import * as fs40 from "node:fs";
-import * as path58 from "node:path";
+import * as fs41 from "node:fs";
+import * as path59 from "node:path";
 var SWARM_DIR = ".swarm";
 function getGraphPath2(workspaceRoot) {
-  return path58.join(workspaceRoot, SWARM_DIR, REPO_GRAPH_FILENAME2);
+  return path59.join(workspaceRoot, SWARM_DIR, REPO_GRAPH_FILENAME2);
 }
 function loadGraph2(workspaceRoot) {
   const file3 = getGraphPath2(workspaceRoot);
   let raw;
   try {
-    raw = fs40.readFileSync(file3, "utf-8");
+    raw = fs41.readFileSync(file3, "utf-8");
   } catch {
     return null;
   }
@@ -69529,9 +69568,9 @@ function loadGraph2(workspaceRoot) {
 }
 function saveGraph2(workspaceRoot, graph) {
   const file3 = getGraphPath2(workspaceRoot);
-  const dir = path58.dirname(file3);
+  const dir = path59.dirname(file3);
   try {
-    const stat5 = fs40.lstatSync(dir);
+    const stat5 = fs41.lstatSync(dir);
     if (stat5.isSymbolicLink()) {
       throw new Error(`refusing to write graph: ${SWARM_DIR}/ is a symbolic link`);
     }
@@ -69539,14 +69578,14 @@ function saveGraph2(workspaceRoot, graph) {
     if (err2.code !== "ENOENT")
       throw err2;
   }
-  fs40.mkdirSync(dir, { recursive: true });
+  fs41.mkdirSync(dir, { recursive: true });
   const tmp = `${file3}.tmp.${crypto6.randomUUID()}`;
-  fs40.writeFileSync(tmp, JSON.stringify(graph), "utf-8");
+  fs41.writeFileSync(tmp, JSON.stringify(graph), "utf-8");
   try {
-    fs40.renameSync(tmp, file3);
+    fs41.renameSync(tmp, file3);
   } catch (renameErr) {
     try {
-      fs40.unlinkSync(tmp);
+      fs41.unlinkSync(tmp);
     } catch {}
     throw renameErr;
   }
@@ -69570,7 +69609,7 @@ function getCachedGraph2(directory) {
   const file3 = getGraphPath2(directory);
   let stat5;
   try {
-    stat5 = fs41.statSync(file3);
+    stat5 = fs42.statSync(file3);
   } catch {
     cache.delete(directory);
     return null;
@@ -69634,8 +69673,8 @@ function buildReviewerBlastRadiusBlock(directory, changedFiles) {
 
 // src/hooks/semantic-diff-injection.ts
 import * as child_process5 from "node:child_process";
-import * as fs42 from "node:fs";
-import * as path60 from "node:path";
+import * as fs43 from "node:fs";
+import * as path61 from "node:path";
 
 // src/diff/ast-diff.ts
 init_tree_sitter();
@@ -70382,17 +70421,17 @@ async function buildSemanticDiffBlock(directory, changedFiles, maxFiles = 10) {
     const fileConsumers = {};
     if (graph) {
       for (const f of filesToProcess) {
-        const relativePath = path60.isAbsolute(f) ? path60.relative(directory, f) : f;
+        const relativePath = path61.isAbsolute(f) ? path61.relative(directory, f) : f;
         const normalized = normalizeGraphPath2(relativePath);
         fileConsumers[normalized] = getImporters(graph, normalized).length;
         fileConsumers[f] = fileConsumers[normalized];
       }
     }
     for (const filePath of filesToProcess) {
-      const normalizedPath = path60.normalize(filePath);
-      const resolvedPath = path60.resolve(directory, normalizedPath);
-      const relativeToDir = path60.relative(directory, resolvedPath);
-      if (relativeToDir.startsWith("..") || path60.isAbsolute(relativeToDir)) {
+      const normalizedPath = path61.normalize(filePath);
+      const resolvedPath = path61.resolve(directory, normalizedPath);
+      const relativeToDir = path61.relative(directory, resolvedPath);
+      if (relativeToDir.startsWith("..") || path61.isAbsolute(relativeToDir)) {
         continue;
       }
       try {
@@ -70419,7 +70458,7 @@ async function buildSemanticDiffBlock(directory, changedFiles, maxFiles = 10) {
           stdio: "pipe",
           maxBuffer: 5 * 1024 * 1024
         }) : "";
-        const newContent = fs42.readFileSync(path60.join(directory, filePath), "utf-8");
+        const newContent = fs43.readFileSync(path61.join(directory, filePath), "utf-8");
         const astResult = await computeASTDiff(filePath, oldContent, newContent);
         if (astResult && (astResult.changes.length > 0 || astResult.error !== undefined)) {
           astDiffs.push(astResult);
@@ -70746,7 +70785,7 @@ function createSystemEnhancerHook(config3, directory) {
         } catch {}
         try {
           const darkMatterPath = validateSwarmPath(directory, "dark-matter.md");
-          if (!fs44.existsSync(darkMatterPath)) {
+          if (!fs45.existsSync(darkMatterPath)) {
             const {
               detectDarkMatter: detectDarkMatter2,
               formatDarkMatterOutput: formatDarkMatterOutput2,
@@ -70758,25 +70797,25 @@ function createSystemEnhancerHook(config3, directory) {
             });
             if (darkMatter && darkMatter.length > 0) {
               const darkMatterReport = formatDarkMatterOutput2(darkMatter);
-              await fs44.promises.writeFile(darkMatterPath, darkMatterReport, "utf-8");
+              await fs45.promises.writeFile(darkMatterPath, darkMatterReport, "utf-8");
               warn(`[system-enhancer] Dark matter scan complete: ${darkMatter.length} co-change patterns found`);
               try {
-                const projectName = path62.basename(path62.resolve(directory));
+                const projectName = path63.basename(path63.resolve(directory));
                 const knowledgeEntries = darkMatterToKnowledgeEntries2(darkMatter, projectName);
                 const knowledgePath = resolveSwarmKnowledgePath(directory);
                 const existingEntries = await readKnowledge(knowledgePath);
                 const existingLessons = new Set(existingEntries.map((e) => e.lesson));
                 const newEntries = knowledgeEntries.filter((e) => !existingLessons.has(e.lesson));
                 if (newEntries.length === 0) {
-                  console.warn(`[system-enhancer] No new knowledge entries (all duplicates)`);
+                  warn(`[system-enhancer] No new knowledge entries (all duplicates)`);
                 } else {
                   for (const entry of newEntries) {
                     await appendKnowledge(knowledgePath, entry);
                   }
-                  console.warn(`[system-enhancer] Created ${newEntries.length} new knowledge entries (${knowledgeEntries.length - newEntries.length} duplicates skipped)`);
+                  warn(`[system-enhancer] Created ${newEntries.length} new knowledge entries (${knowledgeEntries.length - newEntries.length} duplicates skipped)`);
                 }
               } catch (e) {
-                console.warn(`[system-enhancer] Failed to create knowledge entries: ${e}`);
+                warn(`[system-enhancer] Failed to create knowledge entries: ${e}`);
               }
             }
           }
@@ -70825,14 +70864,14 @@ function createSystemEnhancerHook(config3, directory) {
               if (handoffContent) {
                 const handoffPath = validateSwarmPath(directory, "handoff.md");
                 const consumedPath = validateSwarmPath(directory, "handoff-consumed.md");
-                if (fs44.existsSync(consumedPath)) {
+                if (fs45.existsSync(consumedPath)) {
                   warn("Duplicate handoff detected: handoff-consumed.md already exists");
-                  fs44.unlinkSync(consumedPath);
+                  fs45.unlinkSync(consumedPath);
                 }
-                fs44.renameSync(handoffPath, consumedPath);
+                fs45.renameSync(handoffPath, consumedPath);
                 try {
                   const promptPath = validateSwarmPath(directory, "handoff-prompt.md");
-                  fs44.unlinkSync(promptPath);
+                  fs45.unlinkSync(promptPath);
                 } catch {}
                 const handoffBlock = `## HANDOFF — Resuming from model switch
 The previous model's session ended. Here is your starting context:
@@ -70960,9 +70999,9 @@ ${lines.join(`
             try {
               const taskId_ccp = ccpSession?.currentTaskId;
               if (taskId_ccp && !taskId_ccp.includes("..") && !taskId_ccp.includes("/") && !taskId_ccp.includes("\\") && !taskId_ccp.includes("\x00")) {
-                const evidencePath = path62.join(directory, ".swarm", "evidence", `${taskId_ccp}.json`);
-                if (fs44.existsSync(evidencePath)) {
-                  const evidenceContent = fs44.readFileSync(evidencePath, "utf-8");
+                const evidencePath = path63.join(directory, ".swarm", "evidence", `${taskId_ccp}.json`);
+                if (fs45.existsSync(evidencePath)) {
+                  const evidenceContent = fs45.readFileSync(evidencePath, "utf-8");
                   const evidenceData = JSON.parse(evidenceContent);
                   const rejections = (evidenceData.bundle?.entries ?? []).filter((e) => e.type === "gate" && e.gate_type === "reviewer" && e.verdict === "reject");
                   if (rejections.length > 0) {
@@ -71226,11 +71265,11 @@ ${budgetWarning}`);
             if (handoffContent) {
               const handoffPath = validateSwarmPath(directory, "handoff.md");
               const consumedPath = validateSwarmPath(directory, "handoff-consumed.md");
-              if (fs44.existsSync(consumedPath)) {
+              if (fs45.existsSync(consumedPath)) {
                 warn("Duplicate handoff detected: handoff-consumed.md already exists");
-                fs44.unlinkSync(consumedPath);
+                fs45.unlinkSync(consumedPath);
               }
-              fs44.renameSync(handoffPath, consumedPath);
+              fs45.renameSync(handoffPath, consumedPath);
               const handoffBlock = `## HANDOFF — Resuming from model switch
 The previous model's session ended. Here is your starting context:
 
@@ -72107,8 +72146,8 @@ init_guardrails();
 init_hive_promoter();
 
 // src/hooks/incremental-verify.ts
-import * as fs45 from "node:fs";
-import * as path63 from "node:path";
+import * as fs46 from "node:fs";
+import * as path64 from "node:path";
 
 // src/hooks/spawn-helper.ts
 import * as child_process6 from "node:child_process";
@@ -72186,21 +72225,21 @@ function spawnAsync(command, cwd, timeoutMs) {
 // src/hooks/incremental-verify.ts
 var emittedSkipAdvisories = new Set;
 function detectPackageManager(projectDir) {
-  if (fs45.existsSync(path63.join(projectDir, "bun.lockb")))
+  if (fs46.existsSync(path64.join(projectDir, "bun.lockb")))
     return "bun";
-  if (fs45.existsSync(path63.join(projectDir, "pnpm-lock.yaml")))
+  if (fs46.existsSync(path64.join(projectDir, "pnpm-lock.yaml")))
     return "pnpm";
-  if (fs45.existsSync(path63.join(projectDir, "yarn.lock")))
+  if (fs46.existsSync(path64.join(projectDir, "yarn.lock")))
     return "yarn";
-  if (fs45.existsSync(path63.join(projectDir, "package-lock.json")))
+  if (fs46.existsSync(path64.join(projectDir, "package-lock.json")))
     return "npm";
   return "bun";
 }
 function detectTypecheckCommand(projectDir) {
-  const pkgPath = path63.join(projectDir, "package.json");
-  if (fs45.existsSync(pkgPath)) {
+  const pkgPath = path64.join(projectDir, "package.json");
+  if (fs46.existsSync(pkgPath)) {
     try {
-      const pkg = JSON.parse(fs45.readFileSync(pkgPath, "utf8"));
+      const pkg = JSON.parse(fs46.readFileSync(pkgPath, "utf8"));
       const scripts = pkg.scripts;
       if (scripts?.typecheck) {
         const pm = detectPackageManager(projectDir);
@@ -72214,8 +72253,8 @@ function detectTypecheckCommand(projectDir) {
         ...pkg.dependencies,
         ...pkg.devDependencies
       };
-      if (!deps?.typescript && !fs45.existsSync(path63.join(projectDir, "tsconfig.json"))) {}
-      const hasTSMarkers = deps?.typescript || fs45.existsSync(path63.join(projectDir, "tsconfig.json"));
+      if (!deps?.typescript && !fs46.existsSync(path64.join(projectDir, "tsconfig.json"))) {}
+      const hasTSMarkers = deps?.typescript || fs46.existsSync(path64.join(projectDir, "tsconfig.json"));
       if (hasTSMarkers) {
         return { command: ["npx", "tsc", "--noEmit"], language: "typescript" };
       }
@@ -72223,17 +72262,17 @@ function detectTypecheckCommand(projectDir) {
       return null;
     }
   }
-  if (fs45.existsSync(path63.join(projectDir, "go.mod"))) {
+  if (fs46.existsSync(path64.join(projectDir, "go.mod"))) {
     return { command: ["go", "vet", "./..."], language: "go" };
   }
-  if (fs45.existsSync(path63.join(projectDir, "Cargo.toml"))) {
+  if (fs46.existsSync(path64.join(projectDir, "Cargo.toml"))) {
     return { command: ["cargo", "check"], language: "rust" };
   }
-  if (fs45.existsSync(path63.join(projectDir, "pyproject.toml")) || fs45.existsSync(path63.join(projectDir, "requirements.txt")) || fs45.existsSync(path63.join(projectDir, "setup.py"))) {
+  if (fs46.existsSync(path64.join(projectDir, "pyproject.toml")) || fs46.existsSync(path64.join(projectDir, "requirements.txt")) || fs46.existsSync(path64.join(projectDir, "setup.py"))) {
     return { command: null, language: "python" };
   }
   try {
-    const entries = fs45.readdirSync(projectDir);
+    const entries = fs46.readdirSync(projectDir);
     if (entries.some((f) => f.endsWith(".csproj") || f.endsWith(".sln"))) {
       return {
         command: ["dotnet", "build", "--no-restore"],
@@ -72477,7 +72516,7 @@ function createKnowledgeInjectorHook(directory, config3) {
     const headroomChars = MODEL_LIMIT_CHARS - existingChars;
     const MIN_INJECT_CHARS = config3.context_budget_threshold ?? 300;
     if (headroomChars < MIN_INJECT_CHARS) {
-      console.warn(`[knowledge-injector] Skipping: only ${headroomChars} chars of headroom remain (existing: ${existingChars}, limit: ${MODEL_LIMIT_CHARS})`);
+      warn(`[knowledge-injector] Skipping: only ${headroomChars} chars of headroom remain (existing: ${existingChars}, limit: ${MODEL_LIMIT_CHARS})`);
       return;
     }
     const maxInjectChars = config3.inject_char_budget ?? 2000;
@@ -72579,7 +72618,7 @@ init_scope_persistence();
 init_state();
 init_delegation_gate();
 init_normalize_tool_name();
-import * as path65 from "node:path";
+import * as path66 from "node:path";
 var WRITE_TOOLS = new Set(WRITE_TOOL_NAMES);
 function createScopeGuardHook(config3, directory, injectAdvisory) {
   const enabled = config3.enabled ?? true;
@@ -72637,13 +72676,13 @@ function createScopeGuardHook(config3, directory, injectAdvisory) {
 }
 function isFileInScope(filePath, scopeEntries, directory) {
   const dir = directory ?? process.cwd();
-  const resolvedFile = path65.resolve(dir, filePath);
+  const resolvedFile = path66.resolve(dir, filePath);
   return scopeEntries.some((scope) => {
-    const resolvedScope = path65.resolve(dir, scope);
+    const resolvedScope = path66.resolve(dir, scope);
     if (resolvedFile === resolvedScope)
       return true;
-    const rel = path65.relative(resolvedScope, resolvedFile);
-    return rel.length > 0 && !rel.startsWith("..") && !path65.isAbsolute(rel);
+    const rel = path66.relative(resolvedScope, resolvedFile);
+    return rel.length > 0 && !rel.startsWith("..") && !path66.isAbsolute(rel);
   });
 }
 
@@ -72694,8 +72733,8 @@ function createSelfReviewHook(config3, injectAdvisory) {
 }
 
 // src/hooks/slop-detector.ts
-import * as fs47 from "node:fs";
-import * as path66 from "node:path";
+import * as fs48 from "node:fs";
+import * as path67 from "node:path";
 var WRITE_EDIT_TOOLS = new Set([
   "write",
   "edit",
@@ -72740,12 +72779,12 @@ function checkBoilerplateExplosion(content, taskDescription, threshold) {
 function walkFiles(dir, exts, deadline) {
   const results = [];
   try {
-    for (const entry of fs47.readdirSync(dir, { withFileTypes: true })) {
+    for (const entry of fs48.readdirSync(dir, { withFileTypes: true })) {
       if (deadline !== undefined && Date.now() > deadline)
         break;
       if (entry.isSymbolicLink())
         continue;
-      const full = path66.join(dir, entry.name);
+      const full = path67.join(dir, entry.name);
       if (entry.isDirectory()) {
         if (entry.name === "node_modules" || entry.name === ".git")
           continue;
@@ -72760,7 +72799,7 @@ function walkFiles(dir, exts, deadline) {
   return results;
 }
 function checkDeadExports(content, projectDir, startTime) {
-  const hasPackageJson = fs47.existsSync(path66.join(projectDir, "package.json"));
+  const hasPackageJson = fs48.existsSync(path67.join(projectDir, "package.json"));
   if (!hasPackageJson)
     return null;
   const exportMatches = content.matchAll(/^\+(?:export)\s+(?:function|class|const|type|interface)\s+(\w{3,})/gm);
@@ -72783,7 +72822,7 @@ function checkDeadExports(content, projectDir, startTime) {
         if (found || Date.now() - startTime > 480)
           break;
         try {
-          const text = fs47.readFileSync(file3, "utf-8");
+          const text = fs48.readFileSync(file3, "utf-8");
           if (importPattern.test(text))
             found = true;
           importPattern.lastIndex = 0;
@@ -72874,17 +72913,17 @@ function checkDuplicateUtility(content, projectDir, startTime, targetFile) {
   for (const utilDir of utilityDirs) {
     if (Date.now() > deadline)
       break;
-    const utilPath = path66.join(projectDir, utilDir);
-    if (!fs47.existsSync(utilPath))
+    const utilPath = path67.join(projectDir, utilDir);
+    if (!fs48.existsSync(utilPath))
       continue;
     const files = walkFiles(utilPath, [".ts", ".tsx", ".js", ".jsx"], deadline);
     for (const file3 of files) {
       if (Date.now() > deadline)
         break;
-      if (targetFile && path66.resolve(file3) === path66.resolve(targetFile))
+      if (targetFile && path67.resolve(file3) === path67.resolve(targetFile))
         continue;
       try {
-        const text = fs47.readFileSync(file3, "utf-8");
+        const text = fs48.readFileSync(file3, "utf-8");
         for (const name2 of newExports) {
           const exportPattern = new RegExp(`\\bexport\\s+(?:function|class|const|type|interface)\\s+${name2}\\b`);
           if (exportPattern.test(text)) {
@@ -72967,7 +73006,7 @@ Review before proceeding.`;
 // src/hooks/steering-consumed.ts
 init_bun_compat();
 init_utils2();
-import * as fs48 from "node:fs";
+import * as fs49 from "node:fs";
 function recordSteeringConsumed(directory, directiveId) {
   try {
     const eventsPath = validateSwarmPath(directory, "events.jsonl");
@@ -72976,7 +73015,7 @@ function recordSteeringConsumed(directory, directiveId) {
       directiveId,
       timestamp: new Date().toISOString()
     };
-    fs48.appendFileSync(eventsPath, `${JSON.stringify(event)}
+    fs49.appendFileSync(eventsPath, `${JSON.stringify(event)}
 `, "utf-8");
   } catch {}
 }
@@ -73018,15 +73057,15 @@ function createSteeringConsumedHook(directory) {
 
 // src/hooks/trajectory-logger.ts
 init_manager2();
-import * as fs50 from "node:fs/promises";
-import * as path68 from "node:path";
+import * as fs51 from "node:fs/promises";
+import * as path69 from "node:path";
 
 // src/prm/trajectory-store.ts
 init_utils2();
-import * as fs49 from "node:fs/promises";
-import * as path67 from "node:path";
+import * as fs50 from "node:fs/promises";
+import * as path68 from "node:path";
 function getTrajectoryPath(sessionId, directory) {
-  const relativePath = path67.join("trajectories", `${sessionId}.jsonl`);
+  const relativePath = path68.join("trajectories", `${sessionId}.jsonl`);
   return validateSwarmPath(directory, relativePath);
 }
 var _inMemoryTrajectoryCache = new Map;
@@ -73045,10 +73084,10 @@ async function appendTrajectoryEntry(sessionId, entry, directory, maxLines = 100
       _inMemoryTrajectoryCache.set(sessionId, cached3);
     }
     const trajectoryPath = getTrajectoryPath(sessionId, directory);
-    await fs49.mkdir(path67.dirname(trajectoryPath), { recursive: true });
+    await fs50.mkdir(path68.dirname(trajectoryPath), { recursive: true });
     const line = `${JSON.stringify(entry)}
 `;
-    await fs49.appendFile(trajectoryPath, line, "utf-8");
+    await fs50.appendFile(trajectoryPath, line, "utf-8");
   } catch (err2) {
     console.warn(`[trajectory-store] Failed to append trajectory entry: ${err2}`);
   }
@@ -73056,7 +73095,7 @@ async function appendTrajectoryEntry(sessionId, entry, directory, maxLines = 100
 async function readTrajectory(sessionId, directory) {
   try {
     const trajectoryPath = getTrajectoryPath(sessionId, directory);
-    const content = await fs49.readFile(trajectoryPath, "utf-8");
+    const content = await fs50.readFile(trajectoryPath, "utf-8");
     const lines = content.split(`
 `).filter((line) => line.trim().length > 0);
     const entries = [];
@@ -73080,15 +73119,15 @@ async function cleanupOldTrajectoryFiles(directory, maxAgeDays = 7) {
   for (const subdir of ["trajectories", "replays"]) {
     try {
       const dirPath = validateSwarmPath(directory, subdir);
-      const entries = await fs49.readdir(dirPath, { withFileTypes: true });
+      const entries = await fs50.readdir(dirPath, { withFileTypes: true });
       for (const entry of entries) {
         if (!entry.isFile())
           continue;
-        const filePath = path67.join(dirPath, entry.name);
+        const filePath = path68.join(dirPath, entry.name);
         try {
-          const stat6 = await fs49.stat(filePath);
+          const stat6 = await fs50.stat(filePath);
           if (now - stat6.mtimeMs > cutoffMs) {
-            await fs49.unlink(filePath);
+            await fs50.unlink(filePath);
           }
         } catch {}
       }
@@ -73138,7 +73177,7 @@ function isSensitiveKey(key) {
 }
 async function truncateTrajectoryFile(filePath, maxLines) {
   try {
-    const content = await fs50.readFile(filePath, "utf-8");
+    const content = await fs51.readFile(filePath, "utf-8");
     const lines = content.split(`
 `).filter((line) => line.trim().length > 0);
     if (lines.length <= maxLines) {
@@ -73146,7 +73185,7 @@ async function truncateTrajectoryFile(filePath, maxLines) {
     }
     const keepCount = Math.floor(maxLines / 2);
     const keptLines = lines.slice(-keepCount);
-    await fs50.writeFile(filePath, `${keptLines.join(`
+    await fs51.writeFile(filePath, `${keptLines.join(`
 `)}
 `, "utf-8");
   } catch {}
@@ -73276,13 +73315,13 @@ function createTrajectoryLoggerHook(config3, _directory) {
         elapsed_ms
       };
       const sanitized = sanitizeTaskId2(taskId);
-      const relativePath = path68.join("evidence", sanitized, "trajectory.jsonl");
+      const relativePath = path69.join("evidence", sanitized, "trajectory.jsonl");
       const trajectoryPath = validateSwarmPath(_directory, relativePath);
       try {
-        await fs50.mkdir(path68.dirname(trajectoryPath), { recursive: true });
+        await fs51.mkdir(path69.dirname(trajectoryPath), { recursive: true });
         const line = `${JSON.stringify(entry)}
 `;
-        await fs50.appendFile(trajectoryPath, line, "utf-8");
+        await fs51.appendFile(trajectoryPath, line, "utf-8");
         await truncateTrajectoryFile(trajectoryPath, maxLines);
       } catch {}
       try {
@@ -73829,17 +73868,17 @@ init_state();
 init_telemetry();
 
 // src/prm/replay.ts
-import { promises as fs51 } from "node:fs";
-import path69 from "node:path";
+import { promises as fs52 } from "node:fs";
+import path70 from "node:path";
 function isPathSafe2(targetPath, basePath) {
-  const resolvedTarget = path69.resolve(targetPath);
-  const resolvedBase = path69.resolve(basePath);
-  const rel = path69.relative(resolvedBase, resolvedTarget);
-  return !rel.startsWith("..") && !path69.isAbsolute(rel);
+  const resolvedTarget = path70.resolve(targetPath);
+  const resolvedBase = path70.resolve(basePath);
+  const rel = path70.relative(resolvedBase, resolvedTarget);
+  return !rel.startsWith("..") && !path70.isAbsolute(rel);
 }
 function isWithinReplaysDir(targetPath) {
-  const resolved = path69.resolve(targetPath);
-  const parts2 = resolved.split(path69.sep);
+  const resolved = path70.resolve(targetPath);
+  const parts2 = resolved.split(path70.sep);
   for (let i2 = 0;i2 < parts2.length - 1; i2++) {
     if (parts2[i2] === ".swarm" && parts2[i2 + 1] === "replays") {
       return true;
@@ -73852,15 +73891,15 @@ function sanitizeFilename(input) {
 }
 async function startReplayRecording(sessionID, directory) {
   try {
-    const replayDir = path69.join(directory, ".swarm", "replays");
+    const replayDir = path70.join(directory, ".swarm", "replays");
     const safeSessionID = sanitizeFilename(sessionID);
     const filename = `${safeSessionID}-${Date.now()}.jsonl`;
-    const filepath = path69.join(replayDir, filename);
+    const filepath = path70.join(replayDir, filename);
     if (!isPathSafe2(filepath, replayDir)) {
       console.warn(`[replay] Invalid path detected - path traversal attempt blocked for session ${sessionID}`);
       return null;
     }
-    await fs51.mkdir(replayDir, { recursive: true });
+    await fs52.mkdir(replayDir, { recursive: true });
     return filepath;
   } catch (err2) {
     console.warn(`[replay] Failed to start recording for session ${sessionID}: ${err2}`);
@@ -73880,7 +73919,7 @@ async function recordReplayEntry(artifactPath, sessionID, entry) {
     };
     const line = `${JSON.stringify(fullEntry)}
 `;
-    await fs51.appendFile(artifactPath, line, "utf-8");
+    await fs52.appendFile(artifactPath, line, "utf-8");
   } catch (err2) {
     console.warn(`[replay] Failed to record entry: ${err2}`);
   }
@@ -74228,8 +74267,8 @@ init_telemetry();
 // src/tools/batch-symbols.ts
 init_dist();
 init_create_tool();
-import * as fs52 from "node:fs";
-import * as path70 from "node:path";
+import * as fs53 from "node:fs";
+import * as path71 from "node:path";
 init_path_security();
 var WINDOWS_RESERVED_NAMES2 = /^(con|prn|aux|nul|com[1-9]|lpt[1-9])(\.|:|$)/i;
 function containsWindowsAttacks2(str) {
@@ -74246,14 +74285,14 @@ function containsWindowsAttacks2(str) {
 }
 function isPathInWorkspace2(filePath, workspace) {
   try {
-    const resolvedPath = path70.resolve(workspace, filePath);
-    if (!fs52.existsSync(resolvedPath)) {
+    const resolvedPath = path71.resolve(workspace, filePath);
+    if (!fs53.existsSync(resolvedPath)) {
       return true;
     }
-    const realWorkspace = fs52.realpathSync(workspace);
-    const realResolvedPath = fs52.realpathSync(resolvedPath);
-    const relativePath = path70.relative(realWorkspace, realResolvedPath);
-    if (relativePath.startsWith("..") || path70.isAbsolute(relativePath)) {
+    const realWorkspace = fs53.realpathSync(workspace);
+    const realResolvedPath = fs53.realpathSync(resolvedPath);
+    const relativePath = path71.relative(realWorkspace, realResolvedPath);
+    if (relativePath.startsWith("..") || path71.isAbsolute(relativePath)) {
       return false;
     }
     return true;
@@ -74262,7 +74301,7 @@ function isPathInWorkspace2(filePath, workspace) {
   }
 }
 function processFile2(file3, cwd, exportedOnly) {
-  const ext = path70.extname(file3);
+  const ext = path71.extname(file3);
   if (containsControlChars(file3)) {
     return {
       file: file3,
@@ -74295,8 +74334,8 @@ function processFile2(file3, cwd, exportedOnly) {
       errorType: "path-outside-workspace"
     };
   }
-  const fullPath = path70.join(cwd, file3);
-  if (!fs52.existsSync(fullPath)) {
+  const fullPath = path71.join(cwd, file3);
+  if (!fs53.existsSync(fullPath)) {
     return {
       file: file3,
       success: false,
@@ -74327,14 +74366,14 @@ function processFile2(file3, cwd, exportedOnly) {
   }
   let isEmptyFile = false;
   try {
-    const stats = fs52.statSync(fullPath);
+    const stats = fs53.statSync(fullPath);
     if (stats.size === 0) {
       isEmptyFile = true;
     }
   } catch {}
   if (syms.length === 0) {
     try {
-      const content = fs52.readFileSync(fullPath, "utf-8");
+      const content = fs53.readFileSync(fullPath, "utf-8");
       if (content.trim().length === 0) {
         isEmptyFile = true;
       }
@@ -74586,25 +74625,25 @@ init_manager2();
 init_task_id();
 init_create_tool();
 init_resolve_working_directory();
-import * as fs53 from "node:fs";
-import * as path71 from "node:path";
+import * as fs54 from "node:fs";
+import * as path72 from "node:path";
 var EVIDENCE_DIR = ".swarm/evidence";
 function isValidTaskId3(taskId) {
   return isStrictTaskId(taskId);
 }
 function isPathWithinSwarm(filePath, workspaceRoot) {
-  const normalizedWorkspace = path71.resolve(workspaceRoot);
-  const swarmPath = path71.join(normalizedWorkspace, ".swarm", "evidence");
-  const normalizedPath = path71.resolve(filePath);
+  const normalizedWorkspace = path72.resolve(workspaceRoot);
+  const swarmPath = path72.join(normalizedWorkspace, ".swarm", "evidence");
+  const normalizedPath = path72.resolve(filePath);
   return normalizedPath.startsWith(swarmPath);
 }
 function readEvidenceFile(evidencePath) {
-  if (!fs53.existsSync(evidencePath)) {
+  if (!fs54.existsSync(evidencePath)) {
     return null;
   }
   let content;
   try {
-    content = fs53.readFileSync(evidencePath, "utf-8");
+    content = fs54.readFileSync(evidencePath, "utf-8");
   } catch {
     return null;
   }
@@ -74676,7 +74715,7 @@ var check_gate_status = createSwarmTool({
       };
       return JSON.stringify(errorResult, null, 2);
     }
-    const evidencePath = path71.join(directory, EVIDENCE_DIR, `${taskIdInput}.json`);
+    const evidencePath = path72.join(directory, EVIDENCE_DIR, `${taskIdInput}.json`);
     if (!isPathWithinSwarm(evidencePath, directory)) {
       const errorResult = {
         taskId: taskIdInput,
@@ -74772,8 +74811,8 @@ init_utils2();
 init_state();
 init_create_tool();
 init_resolve_working_directory();
-import * as fs54 from "node:fs";
-import * as path72 from "node:path";
+import * as fs55 from "node:fs";
+import * as path73 from "node:path";
 function extractMatches(regex, text) {
   return Array.from(text.matchAll(regex));
 }
@@ -74867,7 +74906,7 @@ async function executeCompletionVerify(args2, directory) {
   let plan;
   try {
     const planPath = validateSwarmPath(directory, "plan.json");
-    const planRaw = fs54.readFileSync(planPath, "utf-8");
+    const planRaw = fs55.readFileSync(planPath, "utf-8");
     plan = JSON.parse(planRaw);
   } catch {
     const result2 = {
@@ -74925,10 +74964,10 @@ async function executeCompletionVerify(args2, directory) {
     let hasFileReadFailure = false;
     for (const filePath of fileTargets) {
       const normalizedPath = filePath.replace(/\\/g, "/");
-      const resolvedPath = path72.resolve(directory, normalizedPath);
-      const projectRoot = path72.resolve(directory);
-      const relative16 = path72.relative(projectRoot, resolvedPath);
-      const withinProject = relative16 === "" || !relative16.startsWith("..") && !path72.isAbsolute(relative16);
+      const resolvedPath = path73.resolve(directory, normalizedPath);
+      const projectRoot = path73.resolve(directory);
+      const relative16 = path73.relative(projectRoot, resolvedPath);
+      const withinProject = relative16 === "" || !relative16.startsWith("..") && !path73.isAbsolute(relative16);
       if (!withinProject) {
         blockedTasks.push({
           task_id: task.id,
@@ -74941,7 +74980,7 @@ async function executeCompletionVerify(args2, directory) {
       }
       let fileContent;
       try {
-        fileContent = fs54.readFileSync(resolvedPath, "utf-8");
+        fileContent = fs55.readFileSync(resolvedPath, "utf-8");
       } catch {
         blockedTasks.push({
           task_id: task.id,
@@ -74983,9 +75022,9 @@ async function executeCompletionVerify(args2, directory) {
     blockedTasks
   };
   try {
-    const evidenceDir = path72.join(directory, ".swarm", "evidence", `${phase}`);
-    const evidencePath = path72.join(evidenceDir, "completion-verify.json");
-    fs54.mkdirSync(evidenceDir, { recursive: true });
+    const evidenceDir = path73.join(directory, ".swarm", "evidence", `${phase}`);
+    const evidencePath = path73.join(evidenceDir, "completion-verify.json");
+    fs55.mkdirSync(evidenceDir, { recursive: true });
     const evidenceBundle = {
       schema_version: "1.0.0",
       task_id: "completion-verify",
@@ -75006,7 +75045,7 @@ async function executeCompletionVerify(args2, directory) {
         }
       ]
     };
-    fs54.writeFileSync(evidencePath, JSON.stringify(evidenceBundle, null, 2), "utf-8");
+    fs55.writeFileSync(evidencePath, JSON.stringify(evidenceBundle, null, 2), "utf-8");
   } catch {}
   return JSON.stringify(result, null, 2);
 }
@@ -75060,12 +75099,12 @@ var completion_verify = createSwarmTool({
 });
 // src/tools/complexity-hotspots.ts
 init_zod();
-import * as fs56 from "node:fs";
-import * as path74 from "node:path";
+import * as fs57 from "node:fs";
+import * as path75 from "node:path";
 
 // src/quality/metrics.ts
-import * as fs55 from "node:fs";
-import * as path73 from "node:path";
+import * as fs56 from "node:fs";
+import * as path74 from "node:path";
 var MAX_FILE_SIZE_BYTES4 = 256 * 1024;
 var MIN_DUPLICATION_LINES = 10;
 function estimateCyclomaticComplexity(content) {
@@ -75103,11 +75142,11 @@ function estimateCyclomaticComplexity(content) {
 }
 function getComplexityForFile(filePath) {
   try {
-    const stat6 = fs55.statSync(filePath);
+    const stat6 = fs56.statSync(filePath);
     if (stat6.size > MAX_FILE_SIZE_BYTES4) {
       return null;
     }
-    const content = fs55.readFileSync(filePath, "utf-8");
+    const content = fs56.readFileSync(filePath, "utf-8");
     return estimateCyclomaticComplexity(content);
   } catch {
     return null;
@@ -75117,8 +75156,8 @@ async function computeComplexityDelta(files, workingDir) {
   let totalComplexity = 0;
   const analyzedFiles = [];
   for (const file3 of files) {
-    const fullPath = path73.isAbsolute(file3) ? file3 : path73.join(workingDir, file3);
-    if (!fs55.existsSync(fullPath)) {
+    const fullPath = path74.isAbsolute(file3) ? file3 : path74.join(workingDir, file3);
+    if (!fs56.existsSync(fullPath)) {
       continue;
     }
     const complexity = getComplexityForFile(fullPath);
@@ -75239,8 +75278,8 @@ function countGoExports(content) {
 }
 function getExportCountForFile(filePath) {
   try {
-    const content = fs55.readFileSync(filePath, "utf-8");
-    const ext = path73.extname(filePath).toLowerCase();
+    const content = fs56.readFileSync(filePath, "utf-8");
+    const ext = path74.extname(filePath).toLowerCase();
     switch (ext) {
       case ".ts":
       case ".tsx":
@@ -75266,8 +75305,8 @@ async function computePublicApiDelta(files, workingDir) {
   let totalExports = 0;
   const analyzedFiles = [];
   for (const file3 of files) {
-    const fullPath = path73.isAbsolute(file3) ? file3 : path73.join(workingDir, file3);
-    if (!fs55.existsSync(fullPath)) {
+    const fullPath = path74.isAbsolute(file3) ? file3 : path74.join(workingDir, file3);
+    if (!fs56.existsSync(fullPath)) {
       continue;
     }
     const exports = getExportCountForFile(fullPath);
@@ -75300,16 +75339,16 @@ async function computeDuplicationRatio(files, workingDir) {
   let duplicateLines = 0;
   const analyzedFiles = [];
   for (const file3 of files) {
-    const fullPath = path73.isAbsolute(file3) ? file3 : path73.join(workingDir, file3);
-    if (!fs55.existsSync(fullPath)) {
+    const fullPath = path74.isAbsolute(file3) ? file3 : path74.join(workingDir, file3);
+    if (!fs56.existsSync(fullPath)) {
       continue;
     }
     try {
-      const stat6 = fs55.statSync(fullPath);
+      const stat6 = fs56.statSync(fullPath);
       if (stat6.size > MAX_FILE_SIZE_BYTES4) {
         continue;
       }
-      const content = fs55.readFileSync(fullPath, "utf-8");
+      const content = fs56.readFileSync(fullPath, "utf-8");
       const lines = content.split(`
 `).filter((line) => line.trim().length > 0);
       if (lines.length < MIN_DUPLICATION_LINES) {
@@ -75333,8 +75372,8 @@ function countCodeLines(content) {
   return lines.length;
 }
 function isTestFile(filePath) {
-  const basename11 = path73.basename(filePath);
-  const _ext = path73.extname(filePath).toLowerCase();
+  const basename11 = path74.basename(filePath);
+  const _ext = path74.extname(filePath).toLowerCase();
   const testPatterns = [
     ".test.",
     ".spec.",
@@ -75415,8 +75454,8 @@ function matchGlobSegment(globSegments, pathSegments) {
   }
   return gIndex === globSegments.length && pIndex === pathSegments.length;
 }
-function matchesGlobSegment(path74, glob) {
-  const normalizedPath = path74.replace(/\\/g, "/");
+function matchesGlobSegment(path75, glob) {
+  const normalizedPath = path75.replace(/\\/g, "/");
   const normalizedGlob = glob.replace(/\\/g, "/");
   if (normalizedPath.includes("//")) {
     return false;
@@ -75447,8 +75486,8 @@ function simpleGlobToRegex2(glob) {
 function hasGlobstar(glob) {
   return glob.includes("**");
 }
-function globMatches(path74, glob) {
-  const normalizedPath = path74.replace(/\\/g, "/");
+function globMatches(path75, glob) {
+  const normalizedPath = path75.replace(/\\/g, "/");
   if (!glob || glob === "") {
     if (normalizedPath.includes("//")) {
       return false;
@@ -75484,31 +75523,31 @@ function shouldExcludeFile(filePath, excludeGlobs) {
 async function computeTestToCodeRatio(workingDir, enforceGlobs, excludeGlobs) {
   let testLines = 0;
   let codeLines = 0;
-  const srcDir = path73.join(workingDir, "src");
-  if (fs55.existsSync(srcDir)) {
+  const srcDir = path74.join(workingDir, "src");
+  if (fs56.existsSync(srcDir)) {
     await scanDirectoryForLines(srcDir, enforceGlobs, excludeGlobs, false, (lines) => {
       codeLines += lines;
     });
   }
   const possibleSrcDirs = ["lib", "app", "source", "core"];
   for (const dir of possibleSrcDirs) {
-    const dirPath = path73.join(workingDir, dir);
-    if (fs55.existsSync(dirPath)) {
+    const dirPath = path74.join(workingDir, dir);
+    if (fs56.existsSync(dirPath)) {
       await scanDirectoryForLines(dirPath, enforceGlobs, excludeGlobs, false, (lines) => {
         codeLines += lines;
       });
     }
   }
-  const testsDir = path73.join(workingDir, "tests");
-  if (fs55.existsSync(testsDir)) {
+  const testsDir = path74.join(workingDir, "tests");
+  if (fs56.existsSync(testsDir)) {
     await scanDirectoryForLines(testsDir, ["**"], ["node_modules", "dist"], true, (lines) => {
       testLines += lines;
     });
   }
   const possibleTestDirs = ["test", "__tests__", "specs"];
   for (const dir of possibleTestDirs) {
-    const dirPath = path73.join(workingDir, dir);
-    if (fs55.existsSync(dirPath) && dirPath !== testsDir) {
+    const dirPath = path74.join(workingDir, dir);
+    if (fs56.existsSync(dirPath) && dirPath !== testsDir) {
       await scanDirectoryForLines(dirPath, ["**"], ["node_modules", "dist"], true, (lines) => {
         testLines += lines;
       });
@@ -75520,9 +75559,9 @@ async function computeTestToCodeRatio(workingDir, enforceGlobs, excludeGlobs) {
 }
 async function scanDirectoryForLines(dirPath, includeGlobs, excludeGlobs, isTestScan, callback) {
   try {
-    const entries = fs55.readdirSync(dirPath, { withFileTypes: true });
+    const entries = fs56.readdirSync(dirPath, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = path73.join(dirPath, entry.name);
+      const fullPath = path74.join(dirPath, entry.name);
       if (entry.isDirectory()) {
         if (entry.name === "node_modules" || entry.name === "dist" || entry.name === "build" || entry.name === ".git") {
           continue;
@@ -75530,7 +75569,7 @@ async function scanDirectoryForLines(dirPath, includeGlobs, excludeGlobs, isTest
         await scanDirectoryForLines(fullPath, includeGlobs, excludeGlobs, isTestScan, callback);
       } else if (entry.isFile()) {
         const relativePath = fullPath.replace(`${dirPath}/`, "");
-        const ext = path73.extname(entry.name).toLowerCase();
+        const ext = path74.extname(entry.name).toLowerCase();
         const validExts = [
           ".ts",
           ".tsx",
@@ -75566,7 +75605,7 @@ async function scanDirectoryForLines(dirPath, includeGlobs, excludeGlobs, isTest
             continue;
         }
         try {
-          const content = fs55.readFileSync(fullPath, "utf-8");
+          const content = fs56.readFileSync(fullPath, "utf-8");
           const lines = countCodeLines(content);
           callback(lines);
         } catch {}
@@ -75766,11 +75805,11 @@ async function getGitChurn(days, directory) {
 }
 function getComplexityForFile2(filePath) {
   try {
-    const stat6 = fs56.statSync(filePath);
+    const stat6 = fs57.statSync(filePath);
     if (stat6.size > MAX_FILE_SIZE_BYTES5) {
       return null;
     }
-    const content = fs56.readFileSync(filePath, "utf-8");
+    const content = fs57.readFileSync(filePath, "utf-8");
     return estimateCyclomaticComplexity(content);
   } catch {
     return null;
@@ -75781,7 +75820,7 @@ async function analyzeHotspots(days, topN, extensions, directory) {
   const extSet = new Set(extensions.map((e) => e.startsWith(".") ? e : `.${e}`));
   const filteredChurn = new Map;
   for (const [file3, count] of churnMap) {
-    const ext = path74.extname(file3).toLowerCase();
+    const ext = path75.extname(file3).toLowerCase();
     if (extSet.has(ext)) {
       filteredChurn.set(file3, count);
     }
@@ -75791,8 +75830,8 @@ async function analyzeHotspots(days, topN, extensions, directory) {
   let analyzedFiles = 0;
   for (const [file3, churnCount] of filteredChurn) {
     let fullPath = file3;
-    if (!fs56.existsSync(fullPath)) {
-      fullPath = path74.join(cwd, file3);
+    if (!fs57.existsSync(fullPath)) {
+      fullPath = path75.join(cwd, file3);
     }
     const complexity = getComplexityForFile2(fullPath);
     if (complexity !== null) {
@@ -75961,12 +76000,12 @@ ${body2}`);
 // src/council/council-evidence-writer.ts
 import {
   appendFileSync as appendFileSync6,
-  existsSync as existsSync37,
-  mkdirSync as mkdirSync18,
+  existsSync as existsSync38,
+  mkdirSync as mkdirSync19,
   readFileSync as readFileSync36,
-  writeFileSync as writeFileSync11
+  writeFileSync as writeFileSync12
 } from "node:fs";
-import { join as join68 } from "node:path";
+import { join as join69 } from "node:path";
 var EVIDENCE_DIR2 = ".swarm/evidence";
 var VALID_TASK_ID = /^\d+\.\d+(\.\d+)*$/;
 var COUNCIL_GATE_NAME = "council";
@@ -76000,11 +76039,11 @@ function writeCouncilEvidence(workingDir, synthesis) {
   if (!VALID_TASK_ID.test(synthesis.taskId)) {
     throw new Error(`writeCouncilEvidence: invalid taskId "${synthesis.taskId}" — must match N.M or N.M.P format`);
   }
-  const dir = join68(workingDir, EVIDENCE_DIR2);
-  mkdirSync18(dir, { recursive: true });
-  const filePath = join68(dir, `${synthesis.taskId}.json`);
+  const dir = join69(workingDir, EVIDENCE_DIR2);
+  mkdirSync19(dir, { recursive: true });
+  const filePath = join69(dir, `${synthesis.taskId}.json`);
   const existingRoot = Object.create(null);
-  if (existsSync37(filePath)) {
+  if (existsSync38(filePath)) {
     try {
       const parsed = JSON.parse(readFileSync36(filePath, "utf-8"));
       if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
@@ -76034,17 +76073,17 @@ function writeCouncilEvidence(workingDir, synthesis) {
     updated.taskId = synthesis.taskId;
   if (!Array.isArray(updated.required_gates))
     updated.required_gates = [];
-  writeFileSync11(filePath, JSON.stringify(updated, null, 2));
+  writeFileSync12(filePath, JSON.stringify(updated, null, 2));
   try {
-    const councilDir = join68(workingDir, ".swarm", "council");
-    mkdirSync18(councilDir, { recursive: true });
+    const councilDir = join69(workingDir, ".swarm", "council");
+    mkdirSync19(councilDir, { recursive: true });
     const auditLine = JSON.stringify({
       round: synthesis.roundNumber,
       verdict: synthesis.overallVerdict,
       timestamp: synthesis.timestamp,
       vetoedBy: synthesis.vetoedBy
     });
-    appendFileSync6(join68(councilDir, `${synthesis.taskId}.rounds.jsonl`), `${auditLine}
+    appendFileSync6(join69(councilDir, `${synthesis.taskId}.rounds.jsonl`), `${auditLine}
 `);
   } catch (auditError) {
     console.warn(`writeCouncilEvidence: failed to append round-history audit log: ${auditError instanceof Error ? auditError.message : String(auditError)}`);
@@ -76177,22 +76216,22 @@ function buildUnifiedFeedback(taskId, verdict, vetoedBy, requiredFixes, advisory
 }
 
 // src/council/criteria-store.ts
-import { existsSync as existsSync38, mkdirSync as mkdirSync19, readFileSync as readFileSync37, writeFileSync as writeFileSync12 } from "node:fs";
-import { join as join69 } from "node:path";
+import { existsSync as existsSync39, mkdirSync as mkdirSync20, readFileSync as readFileSync37, writeFileSync as writeFileSync13 } from "node:fs";
+import { join as join70 } from "node:path";
 var COUNCIL_DIR = ".swarm/council";
 function writeCriteria(workingDir, taskId, criteria) {
-  const dir = join69(workingDir, COUNCIL_DIR);
-  mkdirSync19(dir, { recursive: true });
+  const dir = join70(workingDir, COUNCIL_DIR);
+  mkdirSync20(dir, { recursive: true });
   const payload = {
     taskId,
     criteria,
     declaredAt: new Date().toISOString()
   };
-  writeFileSync12(join69(dir, `${safeId(taskId)}.json`), JSON.stringify(payload, null, 2));
+  writeFileSync13(join70(dir, `${safeId(taskId)}.json`), JSON.stringify(payload, null, 2));
 }
 function readCriteria(workingDir, taskId) {
-  const filePath = join69(workingDir, COUNCIL_DIR, `${safeId(taskId)}.json`);
-  if (!existsSync38(filePath))
+  const filePath = join70(workingDir, COUNCIL_DIR, `${safeId(taskId)}.json`);
+  if (!existsSync39(filePath))
     return null;
   try {
     const parsed = JSON.parse(readFileSync37(filePath, "utf-8"));
@@ -76343,8 +76382,8 @@ var submit_council_verdicts = createSwarmTool({
 // src/tools/convene-general-council.ts
 init_zod();
 init_loader();
-import * as fs57 from "node:fs";
-import * as path75 from "node:path";
+import * as fs58 from "node:fs";
+import * as path76 from "node:path";
 
 // src/council/general-council-advisory.ts
 var ADVISORY_HEADER = "[general_council] (advisory; not blocking)";
@@ -76772,13 +76811,13 @@ var convene_general_council = createSwarmTool({
     const round1 = input.round1Responses;
     const round2 = input.round2Responses ?? [];
     const result = synthesizeGeneralCouncil(input.question, input.mode, round1, round2);
-    const evidenceDir = path75.join(workingDir, ".swarm", "council", "general");
+    const evidenceDir = path76.join(workingDir, ".swarm", "council", "general");
     const safeTimestamp = result.timestamp.replace(/[:.]/g, "-");
     const evidenceFile = `${safeTimestamp}-${input.mode}.json`;
-    const evidencePath = path75.join(evidenceDir, evidenceFile);
+    const evidencePath = path76.join(evidenceDir, evidenceFile);
     try {
-      await fs57.promises.mkdir(evidenceDir, { recursive: true });
-      await fs57.promises.writeFile(evidencePath, JSON.stringify(result, null, 2));
+      await fs58.promises.mkdir(evidenceDir, { recursive: true });
+      await fs58.promises.writeFile(evidencePath, JSON.stringify(result, null, 2));
     } catch (err2) {
       const message = err2 instanceof Error ? err2.message : String(err2);
       console.warn(`[convene_general_council] Failed to write evidence to ${evidencePath}: ${message}`);
@@ -77009,8 +77048,8 @@ init_scope_persistence();
 init_state();
 init_task_id();
 init_create_tool();
-import * as fs58 from "node:fs";
-import * as path76 from "node:path";
+import * as fs59 from "node:fs";
+import * as path77 from "node:path";
 function validateTaskIdFormat2(taskId) {
   return validateTaskIdFormat(taskId);
 }
@@ -77084,8 +77123,8 @@ async function executeDeclareScope(args2, fallbackDir) {
         };
       }
     }
-    normalizedDir = path76.normalize(args2.working_directory);
-    const pathParts = normalizedDir.split(path76.sep);
+    normalizedDir = path77.normalize(args2.working_directory);
+    const pathParts = normalizedDir.split(path77.sep);
     if (pathParts.includes("..")) {
       return {
         success: false,
@@ -77095,11 +77134,11 @@ async function executeDeclareScope(args2, fallbackDir) {
         ]
       };
     }
-    const resolvedDir = path76.resolve(normalizedDir);
+    const resolvedDir = path77.resolve(normalizedDir);
     try {
-      const realPath = fs58.realpathSync(resolvedDir);
-      const planPath2 = path76.join(realPath, ".swarm", "plan.json");
-      if (!fs58.existsSync(planPath2)) {
+      const realPath = fs59.realpathSync(resolvedDir);
+      const planPath2 = path77.join(realPath, ".swarm", "plan.json");
+      if (!fs59.existsSync(planPath2)) {
         return {
           success: false,
           message: `Invalid working_directory: plan not found in "${realPath}"`,
@@ -77122,8 +77161,8 @@ async function executeDeclareScope(args2, fallbackDir) {
     console.warn("[declare-scope] fallbackDir is undefined, falling back to process.cwd()");
   }
   const directory = normalizedDir || fallbackDir;
-  const planPath = path76.resolve(directory, ".swarm", "plan.json");
-  if (!fs58.existsSync(planPath)) {
+  const planPath = path77.resolve(directory, ".swarm", "plan.json");
+  if (!fs59.existsSync(planPath)) {
     return {
       success: false,
       message: "No plan found",
@@ -77132,7 +77171,7 @@ async function executeDeclareScope(args2, fallbackDir) {
   }
   let planContent;
   try {
-    planContent = JSON.parse(fs58.readFileSync(planPath, "utf-8"));
+    planContent = JSON.parse(fs59.readFileSync(planPath, "utf-8"));
   } catch {
     return {
       success: false,
@@ -77162,8 +77201,8 @@ async function executeDeclareScope(args2, fallbackDir) {
   const normalizeErrors = [];
   const dir = normalizedDir || fallbackDir || process.cwd();
   const mergedFiles = rawMergedFiles.map((file3) => {
-    if (path76.isAbsolute(file3)) {
-      const relativePath = path76.relative(dir, file3).replace(/\\/g, "/");
+    if (path77.isAbsolute(file3)) {
+      const relativePath = path77.relative(dir, file3).replace(/\\/g, "/");
       if (relativePath.startsWith("..")) {
         normalizeErrors.push(`Path '${file3}' resolves outside the project directory`);
         return file3;
@@ -77223,8 +77262,8 @@ var declare_scope = createSwarmTool({
 // src/tools/diff.ts
 init_zod();
 import * as child_process7 from "node:child_process";
-import * as fs59 from "node:fs";
-import * as path77 from "node:path";
+import * as fs60 from "node:fs";
+import * as path78 from "node:path";
 init_create_tool();
 var MAX_DIFF_LINES = 500;
 var DIFF_TIMEOUT_MS = 30000;
@@ -77253,20 +77292,20 @@ function validateBase(base) {
 function validatePaths(paths) {
   if (!paths)
     return null;
-  for (const path78 of paths) {
-    if (!path78 || path78.length === 0) {
+  for (const path79 of paths) {
+    if (!path79 || path79.length === 0) {
       return "empty path not allowed";
     }
-    if (path78.length > MAX_PATH_LENGTH) {
+    if (path79.length > MAX_PATH_LENGTH) {
       return `path exceeds maximum length of ${MAX_PATH_LENGTH}`;
     }
-    if (SHELL_METACHARACTERS2.test(path78)) {
+    if (SHELL_METACHARACTERS2.test(path79)) {
       return "path contains shell metacharacters";
     }
-    if (path78.startsWith("-")) {
+    if (path79.startsWith("-")) {
       return 'path cannot start with "-" (option-like arguments not allowed)';
     }
-    if (CONTROL_CHAR_PATTERN2.test(path78)) {
+    if (CONTROL_CHAR_PATTERN2.test(path79)) {
       return "path contains control characters";
     }
   }
@@ -77372,8 +77411,8 @@ var diff = createSwarmTool({
         if (parts2.length >= 3) {
           const additions = parseInt(parts2[0], 10) || 0;
           const deletions = parseInt(parts2[1], 10) || 0;
-          const path78 = parts2[2];
-          files.push({ path: path78, additions, deletions });
+          const path79 = parts2[2];
+          files.push({ path: path79, additions, deletions });
         }
       }
       const contractChanges = [];
@@ -77413,7 +77452,7 @@ var diff = createSwarmTool({
           } else if (base === "unstaged") {
             const oldRef = `:${file3.path}`;
             oldContent = fileExistsInRef(oldRef) ? getContentFromRef(oldRef) : "";
-            newContent = fs59.readFileSync(path77.join(directory, file3.path), "utf-8");
+            newContent = fs60.readFileSync(path78.join(directory, file3.path), "utf-8");
           } else {
             const oldRef = `${base}:${file3.path}`;
             oldContent = fileExistsInRef(oldRef) ? getContentFromRef(oldRef) : "";
@@ -77487,8 +77526,8 @@ var diff = createSwarmTool({
 // src/tools/diff-summary.ts
 init_zod();
 import * as child_process8 from "node:child_process";
-import * as fs60 from "node:fs";
-import * as path78 from "node:path";
+import * as fs61 from "node:fs";
+import * as path79 from "node:path";
 init_create_tool();
 var diff_summary = createSwarmTool({
   description: "Generate a filtered semantic diff summary from AST analysis. Returns SemanticDiffSummary with optional filtering by classification or riskLevel.",
@@ -77536,7 +77575,7 @@ var diff_summary = createSwarmTool({
         }
         try {
           let oldContent;
-          const newContent = fs60.readFileSync(path78.join(workingDir, filePath), "utf-8");
+          const newContent = fs61.readFileSync(path79.join(workingDir, filePath), "utf-8");
           if (fileExistsInHead) {
             oldContent = child_process8.execFileSync("git", ["show", `HEAD:${filePath}`], {
               encoding: "utf-8",
@@ -77764,8 +77803,8 @@ Use these as DOMAIN values when delegating to @sme.`;
 init_zod();
 init_create_tool();
 init_path_security();
-import * as fs61 from "node:fs";
-import * as path79 from "node:path";
+import * as fs62 from "node:fs";
+import * as path80 from "node:path";
 var MAX_FILE_SIZE_BYTES6 = 1024 * 1024;
 var MAX_EVIDENCE_FILES = 1000;
 var EVIDENCE_DIR3 = ".swarm/evidence";
@@ -77792,9 +77831,9 @@ function validateRequiredTypes(input) {
   return null;
 }
 function isPathWithinSwarm2(filePath, cwd) {
-  const normalizedCwd = path79.resolve(cwd);
-  const swarmPath = path79.join(normalizedCwd, ".swarm");
-  const normalizedPath = path79.resolve(filePath);
+  const normalizedCwd = path80.resolve(cwd);
+  const swarmPath = path80.join(normalizedCwd, ".swarm");
+  const normalizedPath = path80.resolve(filePath);
   return normalizedPath.startsWith(swarmPath);
 }
 function parseCompletedTasks(planContent) {
@@ -77810,12 +77849,12 @@ function parseCompletedTasks(planContent) {
 }
 function readEvidenceFiles(evidenceDir, _cwd) {
   const evidence = [];
-  if (!fs61.existsSync(evidenceDir) || !fs61.statSync(evidenceDir).isDirectory()) {
+  if (!fs62.existsSync(evidenceDir) || !fs62.statSync(evidenceDir).isDirectory()) {
     return evidence;
   }
   let files;
   try {
-    files = fs61.readdirSync(evidenceDir);
+    files = fs62.readdirSync(evidenceDir);
   } catch {
     return evidence;
   }
@@ -77824,14 +77863,14 @@ function readEvidenceFiles(evidenceDir, _cwd) {
     if (!VALID_EVIDENCE_FILENAME_REGEX.test(filename)) {
       continue;
     }
-    const filePath = path79.join(evidenceDir, filename);
+    const filePath = path80.join(evidenceDir, filename);
     try {
-      const resolvedPath = path79.resolve(filePath);
-      const evidenceDirResolved = path79.resolve(evidenceDir);
+      const resolvedPath = path80.resolve(filePath);
+      const evidenceDirResolved = path80.resolve(evidenceDir);
       if (!resolvedPath.startsWith(evidenceDirResolved)) {
         continue;
       }
-      const stat6 = fs61.lstatSync(filePath);
+      const stat6 = fs62.lstatSync(filePath);
       if (!stat6.isFile()) {
         continue;
       }
@@ -77840,7 +77879,7 @@ function readEvidenceFiles(evidenceDir, _cwd) {
     }
     let fileStat;
     try {
-      fileStat = fs61.statSync(filePath);
+      fileStat = fs62.statSync(filePath);
       if (fileStat.size > MAX_FILE_SIZE_BYTES6) {
         continue;
       }
@@ -77849,7 +77888,7 @@ function readEvidenceFiles(evidenceDir, _cwd) {
     }
     let content;
     try {
-      content = fs61.readFileSync(filePath, "utf-8");
+      content = fs62.readFileSync(filePath, "utf-8");
     } catch {
       continue;
     }
@@ -77945,7 +77984,7 @@ var evidence_check = createSwarmTool({
       return JSON.stringify(errorResult, null, 2);
     }
     const requiredTypes = requiredTypesValue.split(",").map((t) => t.trim()).filter((t) => t.length > 0).map(normalizeEvidenceType);
-    const planPath = path79.join(cwd, PLAN_FILE);
+    const planPath = path80.join(cwd, PLAN_FILE);
     if (!isPathWithinSwarm2(planPath, cwd)) {
       const errorResult = {
         error: "plan file path validation failed",
@@ -77959,7 +77998,7 @@ var evidence_check = createSwarmTool({
     }
     let planContent;
     try {
-      planContent = fs61.readFileSync(planPath, "utf-8");
+      planContent = fs62.readFileSync(planPath, "utf-8");
     } catch {
       const result2 = {
         message: "No completed tasks found in plan.",
@@ -77977,7 +78016,7 @@ var evidence_check = createSwarmTool({
       };
       return JSON.stringify(result2, null, 2);
     }
-    const evidenceDir = path79.join(cwd, EVIDENCE_DIR3);
+    const evidenceDir = path80.join(cwd, EVIDENCE_DIR3);
     const evidence = readEvidenceFiles(evidenceDir, cwd);
     const { tasksWithFullEvidence, gaps } = analyzeGaps(completedTasks, evidence, requiredTypes);
     const completeness = completedTasks.length > 0 ? Math.round(tasksWithFullEvidence.length / completedTasks.length * 100) / 100 : 1;
@@ -77994,8 +78033,8 @@ var evidence_check = createSwarmTool({
 // src/tools/file-extractor.ts
 init_zod();
 init_create_tool();
-import * as fs62 from "node:fs";
-import * as path80 from "node:path";
+import * as fs63 from "node:fs";
+import * as path81 from "node:path";
 var EXT_MAP = {
   python: ".py",
   py: ".py",
@@ -78057,8 +78096,8 @@ var extract_code_blocks = createSwarmTool({
   execute: async (args2, directory) => {
     const { content, output_dir, prefix } = args2;
     const targetDir = output_dir || directory;
-    if (!fs62.existsSync(targetDir)) {
-      fs62.mkdirSync(targetDir, { recursive: true });
+    if (!fs63.existsSync(targetDir)) {
+      fs63.mkdirSync(targetDir, { recursive: true });
     }
     if (!content) {
       return "Error: content is required";
@@ -78076,16 +78115,16 @@ var extract_code_blocks = createSwarmTool({
       if (prefix) {
         filename = `${prefix}_${filename}`;
       }
-      let filepath = path80.join(targetDir, filename);
-      const base = path80.basename(filepath, path80.extname(filepath));
-      const ext = path80.extname(filepath);
+      let filepath = path81.join(targetDir, filename);
+      const base = path81.basename(filepath, path81.extname(filepath));
+      const ext = path81.extname(filepath);
       let counter = 1;
-      while (fs62.existsSync(filepath)) {
-        filepath = path80.join(targetDir, `${base}_${counter}${ext}`);
+      while (fs63.existsSync(filepath)) {
+        filepath = path81.join(targetDir, `${base}_${counter}${ext}`);
         counter++;
       }
       try {
-        fs62.writeFileSync(filepath, code.trim(), "utf-8");
+        fs63.writeFileSync(filepath, code.trim(), "utf-8");
         savedFiles.push(filepath);
       } catch (error93) {
         errors5.push(`Failed to save ${filename}: ${error93 instanceof Error ? error93.message : String(error93)}`);
@@ -78344,8 +78383,8 @@ var gitingest = createSwarmTool({
 init_zod();
 init_create_tool();
 init_path_security();
-import * as fs63 from "node:fs";
-import * as path81 from "node:path";
+import * as fs64 from "node:fs";
+import * as path82 from "node:path";
 var MAX_FILE_PATH_LENGTH2 = 500;
 var MAX_SYMBOL_LENGTH = 256;
 var MAX_FILE_SIZE_BYTES7 = 1024 * 1024;
@@ -78393,7 +78432,7 @@ function validateSymbolInput(symbol3) {
   return null;
 }
 function isBinaryFile2(filePath, buffer) {
-  const ext = path81.extname(filePath).toLowerCase();
+  const ext = path82.extname(filePath).toLowerCase();
   if (ext === ".json" || ext === ".md" || ext === ".txt") {
     return false;
   }
@@ -78417,15 +78456,15 @@ function parseImports(content, targetFile, targetSymbol) {
   const imports = [];
   let _resolvedTarget;
   try {
-    _resolvedTarget = path81.resolve(targetFile);
+    _resolvedTarget = path82.resolve(targetFile);
   } catch {
     _resolvedTarget = targetFile;
   }
-  const targetBasename = path81.basename(targetFile, path81.extname(targetFile));
+  const targetBasename = path82.basename(targetFile, path82.extname(targetFile));
   const targetWithExt = targetFile;
   const targetWithoutExt = targetFile.replace(/\.(ts|tsx|js|jsx|mjs|cjs)$/i, "");
-  const normalizedTargetWithExt = path81.normalize(targetWithExt).replace(/\\/g, "/");
-  const normalizedTargetWithoutExt = path81.normalize(targetWithoutExt).replace(/\\/g, "/");
+  const normalizedTargetWithExt = path82.normalize(targetWithExt).replace(/\\/g, "/");
+  const normalizedTargetWithoutExt = path82.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];
@@ -78448,9 +78487,9 @@ function parseImports(content, targetFile, targetSymbol) {
     }
     const _normalizedModule = modulePath.replace(/^\.\//, "").replace(/^\.\.\\/, "../");
     let isMatch = false;
-    const _targetDir = path81.dirname(targetFile);
-    const targetExt = path81.extname(targetFile);
-    const targetBasenameNoExt = path81.basename(targetFile, targetExt);
+    const _targetDir = path82.dirname(targetFile);
+    const targetExt = path82.extname(targetFile);
+    const targetBasenameNoExt = path82.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, "");
@@ -78507,7 +78546,7 @@ var SKIP_DIRECTORIES4 = new Set([
 function findSourceFiles2(dir, files = [], stats = { skippedDirs: [], skippedFiles: 0, fileErrors: [] }) {
   let entries;
   try {
-    entries = fs63.readdirSync(dir);
+    entries = fs64.readdirSync(dir);
   } catch (e) {
     stats.fileErrors.push({
       path: dir,
@@ -78518,13 +78557,13 @@ 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(path81.join(dir, entry));
+      stats.skippedDirs.push(path82.join(dir, entry));
       continue;
     }
-    const fullPath = path81.join(dir, entry);
+    const fullPath = path82.join(dir, entry);
     let stat6;
     try {
-      stat6 = fs63.statSync(fullPath);
+      stat6 = fs64.statSync(fullPath);
     } catch (e) {
       stats.fileErrors.push({
         path: fullPath,
@@ -78535,7 +78574,7 @@ function findSourceFiles2(dir, files = [], stats = { skippedDirs: [], skippedFil
     if (stat6.isDirectory()) {
       findSourceFiles2(fullPath, files, stats);
     } else if (stat6.isFile()) {
-      const ext = path81.extname(fullPath).toLowerCase();
+      const ext = path82.extname(fullPath).toLowerCase();
       if (SUPPORTED_EXTENSIONS3.includes(ext)) {
         files.push(fullPath);
       }
@@ -78592,8 +78631,8 @@ var imports = createSwarmTool({
       return JSON.stringify(errorResult, null, 2);
     }
     try {
-      const targetFile = path81.resolve(file3);
-      if (!fs63.existsSync(targetFile)) {
+      const targetFile = path82.resolve(file3);
+      if (!fs64.existsSync(targetFile)) {
         const errorResult = {
           error: `target file not found: ${file3}`,
           target: file3,
@@ -78603,7 +78642,7 @@ var imports = createSwarmTool({
         };
         return JSON.stringify(errorResult, null, 2);
       }
-      const targetStat = fs63.statSync(targetFile);
+      const targetStat = fs64.statSync(targetFile);
       if (!targetStat.isFile()) {
         const errorResult = {
           error: "target must be a file, not a directory",
@@ -78614,7 +78653,7 @@ var imports = createSwarmTool({
         };
         return JSON.stringify(errorResult, null, 2);
       }
-      const baseDir = path81.dirname(targetFile);
+      const baseDir = path82.dirname(targetFile);
       const scanStats = {
         skippedDirs: [],
         skippedFiles: 0,
@@ -78629,12 +78668,12 @@ var imports = createSwarmTool({
         if (consumers.length >= MAX_CONSUMERS)
           break;
         try {
-          const stat6 = fs63.statSync(filePath);
+          const stat6 = fs64.statSync(filePath);
           if (stat6.size > MAX_FILE_SIZE_BYTES7) {
             skippedFileCount++;
             continue;
           }
-          const buffer = fs63.readFileSync(filePath);
+          const buffer = fs64.readFileSync(filePath);
           if (isBinaryFile2(filePath, buffer)) {
             skippedFileCount++;
             continue;
@@ -78847,7 +78886,7 @@ init_zod();
 init_config();
 init_knowledge_store();
 init_create_tool();
-import { existsSync as existsSync43 } from "node:fs";
+import { existsSync as existsSync44 } from "node:fs";
 var DEFAULT_LIMIT = 10;
 var MAX_LESSON_LENGTH = 200;
 var VALID_CATEGORIES3 = [
@@ -78917,14 +78956,14 @@ function validateLimit(limit) {
 }
 async function readSwarmKnowledge(directory) {
   const swarmPath = resolveSwarmKnowledgePath(directory);
-  if (!existsSync43(swarmPath)) {
+  if (!existsSync44(swarmPath)) {
     return [];
   }
   return readKnowledge(swarmPath);
 }
 async function readHiveKnowledge() {
   const hivePath = resolveHiveKnowledgePath();
-  if (!existsSync43(hivePath)) {
+  if (!existsSync44(hivePath)) {
     return [];
   }
   return readKnowledge(hivePath);
@@ -79159,8 +79198,8 @@ init_schema();
 init_qa_gate_profile();
 init_manager2();
 init_curator();
-import * as fs65 from "node:fs";
-import * as path83 from "node:path";
+import * as fs66 from "node:fs";
+import * as path84 from "node:path";
 init_knowledge_curator();
 init_knowledge_reader();
 init_knowledge_store();
@@ -79172,20 +79211,20 @@ init_file_locks();
 init_plan_schema();
 init_ledger();
 init_manager();
-import * as fs64 from "node:fs";
-import * as path82 from "node:path";
+import * as fs65 from "node:fs";
+import * as path83 from "node:path";
 async function writeCheckpoint(directory) {
   try {
     const plan = await loadPlan(directory);
     if (!plan)
       return;
-    const swarmDir = path82.join(directory, ".swarm");
-    fs64.mkdirSync(swarmDir, { recursive: true });
-    const jsonPath = path82.join(swarmDir, "SWARM_PLAN.json");
-    const mdPath = path82.join(swarmDir, "SWARM_PLAN.md");
-    fs64.writeFileSync(jsonPath, JSON.stringify(plan, null, 2), "utf8");
+    const swarmDir = path83.join(directory, ".swarm");
+    fs65.mkdirSync(swarmDir, { recursive: true });
+    const jsonPath = path83.join(swarmDir, "SWARM_PLAN.json");
+    const mdPath = path83.join(swarmDir, "SWARM_PLAN.md");
+    fs65.writeFileSync(jsonPath, JSON.stringify(plan, null, 2), "utf8");
     const md = derivePlanMarkdown(plan);
-    fs64.writeFileSync(mdPath, md, "utf8");
+    fs65.writeFileSync(mdPath, md, "utf8");
   } catch (error93) {
     console.warn(`[checkpoint] Failed to write SWARM_PLAN checkpoint: ${error93 instanceof Error ? error93.message : String(error93)}`);
   }
@@ -79417,8 +79456,8 @@ async function executePhaseComplete(args2, workingDirectory, directory) {
     let driftCheckEnabled = true;
     let driftHasSpecMd = false;
     try {
-      const specMdPath = path83.join(dir, ".swarm", "spec.md");
-      driftHasSpecMd = fs65.existsSync(specMdPath);
+      const specMdPath = path84.join(dir, ".swarm", "spec.md");
+      driftHasSpecMd = fs66.existsSync(specMdPath);
       const gatePlan = await loadPlan(dir);
       if (gatePlan) {
         const gatePlanId = `${gatePlan.swarm}-${gatePlan.title}`.replace(/[^a-zA-Z0-9-_]/g, "_");
@@ -79439,9 +79478,9 @@ async function executePhaseComplete(args2, workingDirectory, directory) {
     } else {
       let phaseType;
       try {
-        const planPath = path83.join(dir, ".swarm", "plan.json");
-        if (fs65.existsSync(planPath)) {
-          const planRaw = fs65.readFileSync(planPath, "utf-8");
+        const planPath = path84.join(dir, ".swarm", "plan.json");
+        if (fs66.existsSync(planPath)) {
+          const planRaw = fs66.readFileSync(planPath, "utf-8");
           const plan = JSON.parse(planRaw);
           const targetPhase = plan.phases?.find((p) => p.id === phase);
           phaseType = targetPhase?.type;
@@ -79452,11 +79491,11 @@ async function executePhaseComplete(args2, workingDirectory, directory) {
         warnings.push(`Phase ${phase} is annotated as 'non-code'. Drift verification was skipped per phase type annotation.`);
       } else {
         try {
-          const driftEvidencePath = path83.join(dir, ".swarm", "evidence", String(phase), "drift-verifier.json");
+          const driftEvidencePath = path84.join(dir, ".swarm", "evidence", String(phase), "drift-verifier.json");
           let driftVerdictFound = false;
           let driftVerdictApproved = false;
           try {
-            const driftEvidenceContent = fs65.readFileSync(driftEvidencePath, "utf-8");
+            const driftEvidenceContent = fs66.readFileSync(driftEvidencePath, "utf-8");
             const driftEvidence = JSON.parse(driftEvidenceContent);
             const entries = driftEvidence.entries ?? [];
             for (const entry of entries) {
@@ -79490,9 +79529,9 @@ async function executePhaseComplete(args2, workingDirectory, directory) {
               let incompleteTaskCount = 0;
               let planParseable = false;
               try {
-                const planPath = path83.join(dir, ".swarm", "plan.json");
-                if (fs65.existsSync(planPath)) {
-                  const planRaw = fs65.readFileSync(planPath, "utf-8");
+                const planPath = path84.join(dir, ".swarm", "plan.json");
+                if (fs66.existsSync(planPath)) {
+                  const planRaw = fs66.readFileSync(planPath, "utf-8");
                   const plan = JSON.parse(planRaw);
                   planParseable = true;
                   const planPhase = plan.phases?.find((p) => p.id === phase);
@@ -79557,11 +79596,11 @@ async function executePhaseComplete(args2, workingDirectory, directory) {
           const overrides = session2?.qaGateSessionOverrides ?? {};
           const effective = getEffectiveGates(profile, overrides);
           if (effective.hallucination_guard === true) {
-            const hgPath = path83.join(dir, ".swarm", "evidence", String(phase), "hallucination-guard.json");
+            const hgPath = path84.join(dir, ".swarm", "evidence", String(phase), "hallucination-guard.json");
             let hgVerdictFound = false;
             let hgVerdictApproved = false;
             try {
-              const hgContent = fs65.readFileSync(hgPath, "utf-8");
+              const hgContent = fs66.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") {
@@ -79629,11 +79668,11 @@ async function executePhaseComplete(args2, workingDirectory, directory) {
           const overrides = session2?.qaGateSessionOverrides ?? {};
           const effective = getEffectiveGates(profile, overrides);
           if (effective.mutation_test === true) {
-            const mgPath = path83.join(dir, ".swarm", "evidence", String(phase), "mutation-gate.json");
+            const mgPath = path84.join(dir, ".swarm", "evidence", String(phase), "mutation-gate.json");
             let mgVerdictFound = false;
             let mgVerdict;
             try {
-              const mgContent = fs65.readFileSync(mgPath, "utf-8");
+              const mgContent = fs66.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") {
@@ -79703,14 +79742,14 @@ async function executePhaseComplete(args2, workingDirectory, directory) {
           const effective = getEffectiveGates(profile, overrides);
           if (effective.council_mode === true) {
             councilModeEnabled = true;
-            const pcPath = path83.join(dir, ".swarm", "evidence", String(phase), "phase-council.json");
+            const pcPath = path84.join(dir, ".swarm", "evidence", String(phase), "phase-council.json");
             let pcVerdictFound = false;
             let _pcVerdict;
             let pcQuorumSize;
             let pcTimestamp;
             let pcPhaseNumber;
             try {
-              const pcContent = fs65.readFileSync(pcPath, "utf-8");
+              const pcContent = fs66.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") {
@@ -79905,7 +79944,7 @@ Advisory notes: ${advisoryNotes.join("; ")}` : "";
   }
   if (retroFound && retroEntry?.lessons_learned && retroEntry.lessons_learned.length > 0) {
     try {
-      const projectName = path83.basename(dir);
+      const projectName = path84.basename(dir);
       const curationResult = await curateAndStoreSwarm(retroEntry.lessons_learned, projectName, { phase_number: phase }, dir, knowledgeConfig);
       if (curationResult) {
         const sessionState = swarmState.agentSessions.get(sessionID);
@@ -79985,7 +80024,7 @@ Advisory notes: ${advisoryNotes.join("; ")}` : "";
   let phaseRequiredAgents;
   try {
     const planPath = validateSwarmPath(dir, "plan.json");
-    const planRaw = fs65.readFileSync(planPath, "utf-8");
+    const planRaw = fs66.readFileSync(planPath, "utf-8");
     const plan = JSON.parse(planRaw);
     const phaseObj = plan.phases.find((p) => p.id === phase);
     phaseRequiredAgents = phaseObj?.required_agents;
@@ -80000,7 +80039,7 @@ Advisory notes: ${advisoryNotes.join("; ")}` : "";
   if (agentsMissing.length > 0) {
     try {
       const planPath = validateSwarmPath(dir, "plan.json");
-      const planRaw = fs65.readFileSync(planPath, "utf-8");
+      const planRaw = fs66.readFileSync(planPath, "utf-8");
       const plan = JSON.parse(planRaw);
       const targetPhase = plan.phases.find((p) => p.id === phase);
       if (targetPhase && targetPhase.tasks.length > 0 && targetPhase.tasks.every((t) => t.status === "completed")) {
@@ -80040,7 +80079,7 @@ Advisory notes: ${advisoryNotes.join("; ")}` : "";
   if (phaseCompleteConfig.regression_sweep?.enforce) {
     try {
       const planPath = validateSwarmPath(dir, "plan.json");
-      const planRaw = fs65.readFileSync(planPath, "utf-8");
+      const planRaw = fs66.readFileSync(planPath, "utf-8");
       const plan = JSON.parse(planRaw);
       const targetPhase = plan.phases.find((p) => p.id === phase);
       if (targetPhase) {
@@ -80094,7 +80133,7 @@ Advisory notes: ${advisoryNotes.join("; ")}` : "";
   }
   try {
     const eventsPath = validateSwarmPath(dir, "events.jsonl");
-    fs65.appendFileSync(eventsPath, `${JSON.stringify(event)}
+    fs66.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)}`);
@@ -80169,12 +80208,12 @@ Advisory notes: ${advisoryNotes.join("; ")}` : "";
         warnings.push(`Warning: failed to update plan.json phase status`);
         try {
           const planPath = validateSwarmPath(dir, "plan.json");
-          const planRaw = fs65.readFileSync(planPath, "utf-8");
+          const planRaw = fs66.readFileSync(planPath, "utf-8");
           const plan2 = JSON.parse(planRaw);
           const phaseObj = plan2.phases.find((p) => p.id === phase);
           if (phaseObj) {
             phaseObj.status = "complete";
-            fs65.writeFileSync(planPath, JSON.stringify(plan2, null, 2), "utf-8");
+            fs66.writeFileSync(planPath, JSON.stringify(plan2, null, 2), "utf-8");
           }
         } catch {}
       } else if (plan) {
@@ -80211,12 +80250,12 @@ Advisory notes: ${advisoryNotes.join("; ")}` : "";
       warnings.push(`Warning: failed to update plan.json phase status`);
       try {
         const planPath = validateSwarmPath(dir, "plan.json");
-        const planRaw = fs65.readFileSync(planPath, "utf-8");
+        const planRaw = fs66.readFileSync(planPath, "utf-8");
         const plan = JSON.parse(planRaw);
         const phaseObj = plan.phases.find((p) => p.id === phase);
         if (phaseObj) {
           phaseObj.status = "complete";
-          fs65.writeFileSync(planPath, JSON.stringify(plan, null, 2), "utf-8");
+          fs66.writeFileSync(planPath, JSON.stringify(plan, null, 2), "utf-8");
         }
       } catch {}
     }
@@ -80274,8 +80313,8 @@ init_discovery();
 init_utils();
 init_bun_compat();
 init_create_tool();
-import * as fs66 from "node:fs";
-import * as path84 from "node:path";
+import * as fs67 from "node:fs";
+import * as path85 from "node:path";
 var MAX_OUTPUT_BYTES5 = 52428800;
 var AUDIT_TIMEOUT_MS = 120000;
 function isValidEcosystem(value) {
@@ -80303,31 +80342,31 @@ function validateArgs3(args2) {
 function detectEcosystems(directory) {
   const ecosystems = [];
   const cwd = directory;
-  if (fs66.existsSync(path84.join(cwd, "package.json"))) {
+  if (fs67.existsSync(path85.join(cwd, "package.json"))) {
     ecosystems.push("npm");
   }
-  if (fs66.existsSync(path84.join(cwd, "pyproject.toml")) || fs66.existsSync(path84.join(cwd, "requirements.txt"))) {
+  if (fs67.existsSync(path85.join(cwd, "pyproject.toml")) || fs67.existsSync(path85.join(cwd, "requirements.txt"))) {
     ecosystems.push("pip");
   }
-  if (fs66.existsSync(path84.join(cwd, "Cargo.toml"))) {
+  if (fs67.existsSync(path85.join(cwd, "Cargo.toml"))) {
     ecosystems.push("cargo");
   }
-  if (fs66.existsSync(path84.join(cwd, "go.mod"))) {
+  if (fs67.existsSync(path85.join(cwd, "go.mod"))) {
     ecosystems.push("go");
   }
   try {
-    const files = fs66.readdirSync(cwd);
+    const files = fs67.readdirSync(cwd);
     if (files.some((f) => f.endsWith(".csproj") || f.endsWith(".sln"))) {
       ecosystems.push("dotnet");
     }
   } catch {}
-  if (fs66.existsSync(path84.join(cwd, "Gemfile")) || fs66.existsSync(path84.join(cwd, "Gemfile.lock"))) {
+  if (fs67.existsSync(path85.join(cwd, "Gemfile")) || fs67.existsSync(path85.join(cwd, "Gemfile.lock"))) {
     ecosystems.push("ruby");
   }
-  if (fs66.existsSync(path84.join(cwd, "pubspec.yaml"))) {
+  if (fs67.existsSync(path85.join(cwd, "pubspec.yaml"))) {
     ecosystems.push("dart");
   }
-  if (fs66.existsSync(path84.join(cwd, "composer.lock"))) {
+  if (fs67.existsSync(path85.join(cwd, "composer.lock"))) {
     ecosystems.push("composer");
   }
   return ecosystems;
@@ -81462,8 +81501,8 @@ var pkg_audit = createSwarmTool({
 // src/tools/placeholder-scan.ts
 init_zod();
 init_manager2();
-import * as fs67 from "node:fs";
-import * as path85 from "node:path";
+import * as fs68 from "node:fs";
+import * as path86 from "node:path";
 init_utils();
 init_create_tool();
 var MAX_FILE_SIZE = 1024 * 1024;
@@ -81586,7 +81625,7 @@ function isScaffoldFile(filePath) {
   if (SCAFFOLD_PATH_PATTERNS.some((pattern) => pattern.test(normalizedPath))) {
     return true;
   }
-  const filename = path85.basename(filePath);
+  const filename = path86.basename(filePath);
   if (SCAFFOLD_FILENAME_PATTERNS.some((pattern) => pattern.test(filename))) {
     return true;
   }
@@ -81603,7 +81642,7 @@ function isAllowedByGlobs(filePath, allowGlobs) {
     if (regex.test(normalizedPath)) {
       return true;
     }
-    const filename = path85.basename(filePath);
+    const filename = path86.basename(filePath);
     const filenameRegex = new RegExp(`^${regexPattern}$`, "i");
     if (filenameRegex.test(filename)) {
       return true;
@@ -81612,7 +81651,7 @@ function isAllowedByGlobs(filePath, allowGlobs) {
   return false;
 }
 function isParserSupported(filePath) {
-  const ext = path85.extname(filePath).toLowerCase();
+  const ext = path86.extname(filePath).toLowerCase();
   return SUPPORTED_PARSER_EXTENSIONS.has(ext);
 }
 function isPlanFile(filePath) {
@@ -81859,28 +81898,28 @@ async function placeholderScan(input, directory) {
   let filesScanned = 0;
   const filesWithFindings = new Set;
   for (const filePath of changed_files) {
-    const fullPath = path85.isAbsolute(filePath) ? filePath : path85.resolve(directory, filePath);
-    const resolvedDirectory = path85.resolve(directory);
-    if (!fullPath.startsWith(resolvedDirectory + path85.sep) && fullPath !== resolvedDirectory) {
+    const fullPath = path86.isAbsolute(filePath) ? filePath : path86.resolve(directory, filePath);
+    const resolvedDirectory = path86.resolve(directory);
+    if (!fullPath.startsWith(resolvedDirectory + path86.sep) && fullPath !== resolvedDirectory) {
       continue;
     }
-    if (!fs67.existsSync(fullPath)) {
+    if (!fs68.existsSync(fullPath)) {
       continue;
     }
     if (isAllowedByGlobs(filePath, allow_globs)) {
       continue;
     }
-    const relativeFilePath = path85.relative(directory, fullPath).replace(/\\/g, "/");
+    const relativeFilePath = path86.relative(directory, fullPath).replace(/\\/g, "/");
     if (FILE_ALLOWLIST.some((allowed) => relativeFilePath.endsWith(allowed))) {
       continue;
     }
     let content;
     try {
-      const stat6 = fs67.statSync(fullPath);
+      const stat6 = fs68.statSync(fullPath);
       if (stat6.size > MAX_FILE_SIZE) {
         continue;
       }
-      content = fs67.readFileSync(fullPath, "utf-8");
+      content = fs68.readFileSync(fullPath, "utf-8");
     } catch {
       continue;
     }
@@ -81941,8 +81980,8 @@ var placeholder_scan = createSwarmTool({
   }
 });
 // src/tools/pre-check-batch.ts
-import * as fs70 from "node:fs";
-import * as path88 from "node:path";
+import * as fs71 from "node:fs";
+import * as path89 from "node:path";
 init_zod();
 init_manager2();
 init_utils();
@@ -82079,8 +82118,8 @@ var quality_budget = createSwarmTool({
 init_zod();
 init_manager2();
 init_detector();
-import * as fs69 from "node:fs";
-import * as path87 from "node:path";
+import * as fs70 from "node:fs";
+import * as path88 from "node:path";
 import { extname as extname18 } from "node:path";
 
 // src/sast/rules/c.ts
@@ -82973,25 +83012,25 @@ init_create_tool();
 // src/tools/sast-baseline.ts
 init_utils2();
 import * as crypto8 from "node:crypto";
-import * as fs68 from "node:fs";
-import * as path86 from "node:path";
+import * as fs69 from "node:fs";
+import * as path87 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 = path86.isAbsolute(file3) ? file3 : path86.resolve(directory, file3);
-  const rel = path86.relative(path86.resolve(directory), resolved);
+  const resolved = path87.isAbsolute(file3) ? file3 : path87.resolve(directory, file3);
+  const rel = path87.relative(path87.resolve(directory), resolved);
   return rel.replace(/\\/g, "/");
 }
 function baselineRelPath(phase) {
-  return path86.join("evidence", String(phase), "sast-baseline.json");
+  return path87.join("evidence", String(phase), "sast-baseline.json");
 }
 function tempRelPath(phase) {
-  return path86.join("evidence", String(phase), `sast-baseline.json.tmp.${Date.now()}.${process.pid}`);
+  return path87.join("evidence", String(phase), `sast-baseline.json.tmp.${Date.now()}.${process.pid}`);
 }
 function lockRelPath(phase) {
-  return path86.join("evidence", String(phase), "sast-baseline.json.lock");
+  return path87.join("evidence", String(phase), "sast-baseline.json.lock");
 }
 function getLine(lines, idx) {
   if (idx < 0 || idx >= lines.length)
@@ -83008,7 +83047,7 @@ function fingerprintFinding(finding, directory, occurrenceIndex) {
   }
   const lineNum = finding.location.line;
   try {
-    const content = fs68.readFileSync(finding.location.file, "utf-8");
+    const content = fs69.readFileSync(finding.location.file, "utf-8");
     const lines = content.split(`
 `);
     const idx = lineNum - 1;
@@ -83039,7 +83078,7 @@ function assignOccurrenceIndices(findings, directory) {
     try {
       if (relFile.startsWith(".."))
         throw new Error("escapes workspace");
-      const content = fs68.readFileSync(finding.location.file, "utf-8");
+      const content = fs69.readFileSync(finding.location.file, "utf-8");
       const lines = content.split(`
 `);
       const idx = lineNum - 1;
@@ -83068,11 +83107,11 @@ function assignOccurrenceIndices(findings, directory) {
 async function acquireLock(lockPath) {
   for (let attempt = 0;attempt <= LOCK_RETRY_DELAYS_MS.length; attempt++) {
     try {
-      const fd = fs68.openSync(lockPath, "wx");
-      fs68.closeSync(fd);
+      const fd = fs69.openSync(lockPath, "wx");
+      fs69.closeSync(fd);
       return () => {
         try {
-          fs68.unlinkSync(lockPath);
+          fs69.unlinkSync(lockPath);
         } catch {}
       };
     } catch {
@@ -83112,13 +83151,13 @@ async function captureOrMergeBaseline(directory, phase, findings, engine, scanne
       message: e instanceof Error ? e.message : "Path validation failed"
     };
   }
-  fs68.mkdirSync(path86.dirname(baselinePath), { recursive: true });
-  fs68.mkdirSync(path86.dirname(tempPath), { recursive: true });
+  fs69.mkdirSync(path87.dirname(baselinePath), { recursive: true });
+  fs69.mkdirSync(path87.dirname(tempPath), { recursive: true });
   const releaseLock = await acquireLock(lockPath);
   try {
     let existing = null;
     try {
-      const raw = fs68.readFileSync(baselinePath, "utf-8");
+      const raw = fs69.readFileSync(baselinePath, "utf-8");
       const parsed = JSON.parse(raw);
       if (parsed.schema_version === BASELINE_SCHEMA_VERSION) {
         existing = parsed;
@@ -83178,8 +83217,8 @@ async function captureOrMergeBaseline(directory, phase, findings, engine, scanne
           message: `Baseline would exceed size cap (${json4.length} bytes > ${MAX_BASELINE_BYTES})`
         };
       }
-      fs68.writeFileSync(tempPath, json4, "utf-8");
-      fs68.renameSync(tempPath, baselinePath);
+      fs69.writeFileSync(tempPath, json4, "utf-8");
+      fs69.renameSync(tempPath, baselinePath);
       return {
         status: "merged",
         path: baselinePath,
@@ -83210,8 +83249,8 @@ async function captureOrMergeBaseline(directory, phase, findings, engine, scanne
         message: `Baseline would exceed size cap (${json3.length} bytes > ${MAX_BASELINE_BYTES})`
       };
     }
-    fs68.writeFileSync(tempPath, json3, "utf-8");
-    fs68.renameSync(tempPath, baselinePath);
+    fs69.writeFileSync(tempPath, json3, "utf-8");
+    fs69.renameSync(tempPath, baselinePath);
     return {
       status: "written",
       path: baselinePath,
@@ -83236,7 +83275,7 @@ function loadBaseline(directory, phase) {
     };
   }
   try {
-    const raw = fs68.readFileSync(baselinePath, "utf-8");
+    const raw = fs69.readFileSync(baselinePath, "utf-8");
     const parsed = JSON.parse(raw);
     if (parsed.schema_version !== BASELINE_SCHEMA_VERSION) {
       return {
@@ -83278,17 +83317,17 @@ var SEVERITY_ORDER = {
 };
 function shouldSkipFile(filePath) {
   try {
-    const stats = fs69.statSync(filePath);
+    const stats = fs70.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 = fs69.openSync(filePath, "r");
+    const fd = fs70.openSync(filePath, "r");
     const buffer = Buffer.alloc(8192);
-    const bytesRead = fs69.readSync(fd, buffer, 0, 8192, 0);
-    fs69.closeSync(fd);
+    const bytesRead = fs70.readSync(fd, buffer, 0, 8192, 0);
+    fs70.closeSync(fd);
     if (bytesRead > 0) {
       let nullCount = 0;
       for (let i2 = 0;i2 < bytesRead; i2++) {
@@ -83327,7 +83366,7 @@ function countBySeverity(findings) {
 }
 function scanFileWithTierA(filePath, language) {
   try {
-    const content = fs69.readFileSync(filePath, "utf-8");
+    const content = fs70.readFileSync(filePath, "utf-8");
     const findings = executeRulesSync(filePath, content, language);
     return findings.map((f) => ({
       rule_id: f.rule_id,
@@ -83380,13 +83419,13 @@ async function sastScan(input, directory, config3) {
       _filesSkipped++;
       continue;
     }
-    const resolvedPath = path87.isAbsolute(filePath) ? filePath : path87.resolve(directory, filePath);
-    const resolvedDirectory = path87.resolve(directory);
-    if (!resolvedPath.startsWith(resolvedDirectory + path87.sep) && resolvedPath !== resolvedDirectory) {
+    const resolvedPath = path88.isAbsolute(filePath) ? filePath : path88.resolve(directory, filePath);
+    const resolvedDirectory = path88.resolve(directory);
+    if (!resolvedPath.startsWith(resolvedDirectory + path88.sep) && resolvedPath !== resolvedDirectory) {
       _filesSkipped++;
       continue;
     }
-    if (!fs69.existsSync(resolvedPath)) {
+    if (!fs70.existsSync(resolvedPath)) {
       _filesSkipped++;
       continue;
     }
@@ -83693,18 +83732,18 @@ function validatePath(inputPath, baseDir, workspaceDir) {
   let resolved;
   const isWinAbs = isWindowsAbsolutePath(inputPath);
   if (isWinAbs) {
-    resolved = path88.win32.resolve(inputPath);
-  } else if (path88.isAbsolute(inputPath)) {
-    resolved = path88.resolve(inputPath);
+    resolved = path89.win32.resolve(inputPath);
+  } else if (path89.isAbsolute(inputPath)) {
+    resolved = path89.resolve(inputPath);
   } else {
-    resolved = path88.resolve(baseDir, inputPath);
+    resolved = path89.resolve(baseDir, inputPath);
   }
-  const workspaceResolved = path88.resolve(workspaceDir);
+  const workspaceResolved = path89.resolve(workspaceDir);
   let relative20;
   if (isWinAbs) {
-    relative20 = path88.win32.relative(workspaceResolved, resolved);
+    relative20 = path89.win32.relative(workspaceResolved, resolved);
   } else {
-    relative20 = path88.relative(workspaceResolved, resolved);
+    relative20 = path89.relative(workspaceResolved, resolved);
   }
   if (relative20.startsWith("..")) {
     return "path traversal detected";
@@ -83769,7 +83808,7 @@ async function runLintOnFiles(linter, files, workspaceDir) {
     if (typeof file3 !== "string") {
       continue;
     }
-    const resolvedPath = path88.resolve(file3);
+    const resolvedPath = path89.resolve(file3);
     const validationError = validatePath(resolvedPath, workspaceDir, workspaceDir);
     if (validationError) {
       continue;
@@ -83926,7 +83965,7 @@ async function runSecretscanWithFiles(files, directory) {
         skippedFiles++;
         continue;
       }
-      const resolvedPath = path88.resolve(file3);
+      const resolvedPath = path89.resolve(file3);
       const validationError = validatePath(resolvedPath, directory, directory);
       if (validationError) {
         skippedFiles++;
@@ -83944,14 +83983,14 @@ async function runSecretscanWithFiles(files, directory) {
       };
     }
     for (const file3 of validatedFiles) {
-      const ext = path88.extname(file3).toLowerCase();
+      const ext = path89.extname(file3).toLowerCase();
       if (DEFAULT_EXCLUDE_EXTENSIONS2.has(ext)) {
         skippedFiles++;
         continue;
       }
       let stat6;
       try {
-        stat6 = fs70.statSync(file3);
+        stat6 = fs71.statSync(file3);
       } catch {
         skippedFiles++;
         continue;
@@ -83962,7 +84001,7 @@ async function runSecretscanWithFiles(files, directory) {
       }
       let content;
       try {
-        const buffer = fs70.readFileSync(file3);
+        const buffer = fs71.readFileSync(file3);
         if (buffer.includes(0)) {
           skippedFiles++;
           continue;
@@ -84163,7 +84202,7 @@ function classifySastFindings(findings, changedLineRanges, directory) {
   const preexistingFindings = [];
   for (const finding of findings) {
     const filePath = finding.location.file;
-    const normalised = path88.relative(directory, filePath).replace(/\\/g, "/");
+    const normalised = path89.relative(directory, filePath).replace(/\\/g, "/");
     const changedLines = changedLineRanges.get(normalised);
     if (changedLines?.has(finding.location.line)) {
       newFindings.push(finding);
@@ -84214,7 +84253,7 @@ async function runPreCheckBatch(input, workspaceDir, contextDir) {
       warn(`pre_check_batch: Invalid file path: ${file3}`);
       continue;
     }
-    changedFiles.push(path88.resolve(directory, file3));
+    changedFiles.push(path89.resolve(directory, file3));
   }
   if (changedFiles.length === 0) {
     warn("pre_check_batch: No valid files after validation, skipping all tools (fail-closed)");
@@ -84415,7 +84454,7 @@ var pre_check_batch = createSwarmTool({
       };
       return JSON.stringify(errorResult, null, 2);
     }
-    const resolvedDirectory = path88.resolve(typedArgs.directory);
+    const resolvedDirectory = path89.resolve(typedArgs.directory);
     const workspaceAnchor = resolvedDirectory;
     const dirError = validateDirectory2(resolvedDirectory, workspaceAnchor);
     if (dirError) {
@@ -84456,7 +84495,7 @@ var pre_check_batch = createSwarmTool({
 });
 // src/tools/repo-map.ts
 init_zod();
-import * as path89 from "node:path";
+import * as path90 from "node:path";
 init_path_security();
 init_create_tool();
 var VALID_ACTIONS = [
@@ -84481,7 +84520,7 @@ function validateFile(p) {
     return "file contains control characters";
   if (containsPathTraversal(p))
     return "file contains path traversal";
-  if (path89.isAbsolute(p) || /^[a-zA-Z]:[\\/]/.test(p)) {
+  if (path90.isAbsolute(p) || /^[a-zA-Z]:[\\/]/.test(p)) {
     return "file must be a workspace-relative path, not absolute";
   }
   return null;
@@ -84504,8 +84543,8 @@ function ok(action, payload) {
 }
 function toRelativeGraphPath(input, workspaceRoot) {
   const normalized = input.replace(/\\/g, "/");
-  if (path89.isAbsolute(normalized)) {
-    const rel = path89.relative(workspaceRoot, normalized).replace(/\\/g, "/");
+  if (path90.isAbsolute(normalized)) {
+    const rel = path90.relative(workspaceRoot, normalized).replace(/\\/g, "/");
     return normalizeGraphPath2(rel);
   }
   return normalizeGraphPath2(normalized);
@@ -84649,8 +84688,8 @@ var repo_map = createSwarmTool({
 // src/tools/req-coverage.ts
 init_zod();
 init_create_tool();
-import * as fs71 from "node:fs";
-import * as path90 from "node:path";
+import * as fs72 from "node:fs";
+import * as path91 from "node:path";
 var SPEC_FILE = ".swarm/spec.md";
 var EVIDENCE_DIR4 = ".swarm/evidence";
 var OBLIGATION_KEYWORDS = ["MUST", "SHOULD", "SHALL"];
@@ -84709,19 +84748,19 @@ function extractObligationAndText(id, lineText) {
 var PHASE_TASK_ID_REGEX = /^\d+\.\d+(\.\d+)*$/;
 function readTouchedFiles(evidenceDir, phase, cwd) {
   const touchedFiles = new Set;
-  if (!fs71.existsSync(evidenceDir) || !fs71.statSync(evidenceDir).isDirectory()) {
+  if (!fs72.existsSync(evidenceDir) || !fs72.statSync(evidenceDir).isDirectory()) {
     return [];
   }
   let entries;
   try {
-    entries = fs71.readdirSync(evidenceDir);
+    entries = fs72.readdirSync(evidenceDir);
   } catch {
     return [];
   }
   for (const entry of entries) {
-    const entryPath = path90.join(evidenceDir, entry);
+    const entryPath = path91.join(evidenceDir, entry);
     try {
-      const stat6 = fs71.statSync(entryPath);
+      const stat6 = fs72.statSync(entryPath);
       if (!stat6.isDirectory()) {
         continue;
       }
@@ -84735,14 +84774,14 @@ function readTouchedFiles(evidenceDir, phase, cwd) {
     if (entryPhase !== String(phase)) {
       continue;
     }
-    const evidenceFilePath = path90.join(entryPath, "evidence.json");
+    const evidenceFilePath = path91.join(entryPath, "evidence.json");
     try {
-      const resolvedPath = path90.resolve(evidenceFilePath);
-      const evidenceDirResolved = path90.resolve(evidenceDir);
-      if (!resolvedPath.startsWith(evidenceDirResolved + path90.sep)) {
+      const resolvedPath = path91.resolve(evidenceFilePath);
+      const evidenceDirResolved = path91.resolve(evidenceDir);
+      if (!resolvedPath.startsWith(evidenceDirResolved + path91.sep)) {
         continue;
       }
-      const stat6 = fs71.lstatSync(evidenceFilePath);
+      const stat6 = fs72.lstatSync(evidenceFilePath);
       if (!stat6.isFile()) {
         continue;
       }
@@ -84754,7 +84793,7 @@ function readTouchedFiles(evidenceDir, phase, cwd) {
     }
     let content;
     try {
-      content = fs71.readFileSync(evidenceFilePath, "utf-8");
+      content = fs72.readFileSync(evidenceFilePath, "utf-8");
     } catch {
       continue;
     }
@@ -84773,7 +84812,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(path90.resolve(cwd, file3));
+                  touchedFiles.add(path91.resolve(cwd, file3));
                 }
               }
             }
@@ -84786,12 +84825,12 @@ function readTouchedFiles(evidenceDir, phase, cwd) {
 }
 function searchFileForKeywords(filePath, keywords, cwd) {
   try {
-    const resolvedPath = path90.resolve(filePath);
-    const cwdResolved = path90.resolve(cwd);
+    const resolvedPath = path91.resolve(filePath);
+    const cwdResolved = path91.resolve(cwd);
     if (!resolvedPath.startsWith(cwdResolved)) {
       return false;
     }
-    const content = fs71.readFileSync(resolvedPath, "utf-8");
+    const content = fs72.readFileSync(resolvedPath, "utf-8");
     for (const keyword of keywords) {
       const regex = new RegExp(`\\b${keyword}\\b`, "i");
       if (regex.test(content)) {
@@ -84921,10 +84960,10 @@ var req_coverage = createSwarmTool({
       }, null, 2);
     }
     const cwd = inputDirectory || directory;
-    const specPath = path90.join(cwd, SPEC_FILE);
+    const specPath = path91.join(cwd, SPEC_FILE);
     let specContent;
     try {
-      specContent = fs71.readFileSync(specPath, "utf-8");
+      specContent = fs72.readFileSync(specPath, "utf-8");
     } catch (readError) {
       return JSON.stringify({
         success: false,
@@ -84948,7 +84987,7 @@ var req_coverage = createSwarmTool({
         message: "No FR requirements found in spec.md"
       }, null, 2);
     }
-    const evidenceDir = path90.join(cwd, EVIDENCE_DIR4);
+    const evidenceDir = path91.join(cwd, EVIDENCE_DIR4);
     const touchedFiles = readTouchedFiles(evidenceDir, phase, cwd);
     const analyzedRequirements = [];
     let coveredCount = 0;
@@ -84974,12 +85013,12 @@ var req_coverage = createSwarmTool({
       requirements: analyzedRequirements
     };
     const reportFilename = `req-coverage-phase-${phase}.json`;
-    const reportPath = path90.join(evidenceDir, reportFilename);
+    const reportPath = path91.join(evidenceDir, reportFilename);
     try {
-      if (!fs71.existsSync(evidenceDir)) {
-        fs71.mkdirSync(evidenceDir, { recursive: true });
+      if (!fs72.existsSync(evidenceDir)) {
+        fs72.mkdirSync(evidenceDir, { recursive: true });
       }
-      fs71.writeFileSync(reportPath, JSON.stringify(result, null, 2), "utf-8");
+      fs72.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)}`);
     }
@@ -85061,8 +85100,8 @@ init_plan_schema();
 init_qa_gate_profile();
 init_file_locks();
 import * as crypto9 from "node:crypto";
-import * as fs72 from "node:fs";
-import * as path91 from "node:path";
+import * as fs73 from "node:fs";
+import * as path92 from "node:path";
 init_ledger();
 init_manager();
 init_state();
@@ -85140,17 +85179,17 @@ async function executeSavePlan(args2, fallbackDir) {
     };
   }
   if (args2.working_directory && fallbackDir) {
-    const resolvedTarget = path91.resolve(args2.working_directory);
-    const resolvedRoot = path91.resolve(fallbackDir);
+    const resolvedTarget = path92.resolve(args2.working_directory);
+    const resolvedRoot = path92.resolve(fallbackDir);
     let fallbackExists = false;
     try {
-      fs72.accessSync(resolvedRoot, fs72.constants.F_OK);
+      fs73.accessSync(resolvedRoot, fs73.constants.F_OK);
       fallbackExists = true;
     } catch {
       fallbackExists = false;
     }
     if (fallbackExists) {
-      const isSubdirectory = resolvedTarget.startsWith(resolvedRoot + path91.sep);
+      const isSubdirectory = resolvedTarget.startsWith(resolvedRoot + path92.sep);
       if (isSubdirectory) {
         return {
           success: false,
@@ -85166,11 +85205,11 @@ async function executeSavePlan(args2, fallbackDir) {
   let specMtime;
   let specHash;
   if (process.env.SWARM_SKIP_SPEC_GATE !== "1") {
-    const specPath = path91.join(targetWorkspace, ".swarm", "spec.md");
+    const specPath = path92.join(targetWorkspace, ".swarm", "spec.md");
     try {
-      const stat6 = await fs72.promises.stat(specPath);
+      const stat6 = await fs73.promises.stat(specPath);
       specMtime = stat6.mtime.toISOString();
-      const content = await fs72.promises.readFile(specPath, "utf8");
+      const content = await fs73.promises.readFile(specPath, "utf8");
       specHash = crypto9.createHash("sha256").update(content).digest("hex");
     } catch {
       return {
@@ -85182,10 +85221,10 @@ async function executeSavePlan(args2, fallbackDir) {
     }
   }
   if (process.env.SWARM_SKIP_GATE_SELECTION !== "1") {
-    const contextPath = path91.join(targetWorkspace, ".swarm", "context.md");
+    const contextPath = path92.join(targetWorkspace, ".swarm", "context.md");
     let contextContent = "";
     try {
-      contextContent = await fs72.promises.readFile(contextPath, "utf8");
+      contextContent = await fs73.promises.readFile(contextPath, "utf8");
     } catch {}
     const hasPendingSection = contextContent.includes("## Pending QA Gate Selection");
     if (!hasPendingSection) {
@@ -85332,14 +85371,14 @@ async function executeSavePlan(args2, fallbackDir) {
       }
       await writeCheckpoint(dir).catch(() => {});
       try {
-        const markerPath = path91.join(dir, ".swarm", ".plan-write-marker");
+        const markerPath = path92.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 fs72.promises.writeFile(markerPath, marker, "utf8");
+        await fs73.promises.writeFile(markerPath, marker, "utf8");
       } catch {}
       const warnings = [];
       let criticReviewFound = false;
@@ -85355,7 +85394,7 @@ async function executeSavePlan(args2, fallbackDir) {
       return {
         success: true,
         message: "Plan saved successfully",
-        plan_path: path91.join(dir, ".swarm", "plan.json"),
+        plan_path: path92.join(dir, ".swarm", "plan.json"),
         phases_count: plan.phases.length,
         tasks_count: tasksCount,
         ...resolvedProfile !== undefined ? { execution_profile: resolvedProfile } : {},
@@ -85407,8 +85446,8 @@ var save_plan = createSwarmTool({
 // src/tools/sbom-generate.ts
 init_zod();
 init_manager2();
-import * as fs73 from "node:fs";
-import * as path92 from "node:path";
+import * as fs74 from "node:fs";
+import * as path93 from "node:path";
 
 // src/sbom/detectors/index.ts
 init_utils();
@@ -86256,9 +86295,9 @@ function findManifestFiles(rootDir) {
   const patterns = [...new Set(allDetectors.flatMap((d) => d.patterns))];
   function searchDir(dir) {
     try {
-      const entries = fs73.readdirSync(dir, { withFileTypes: true });
+      const entries = fs74.readdirSync(dir, { withFileTypes: true });
       for (const entry of entries) {
-        const fullPath = path92.join(dir, entry.name);
+        const fullPath = path93.join(dir, entry.name);
         if (entry.name.startsWith(".") || entry.name === "node_modules" || entry.name === "dist" || entry.name === "build" || entry.name === "target") {
           continue;
         }
@@ -86267,7 +86306,7 @@ function findManifestFiles(rootDir) {
         } else if (entry.isFile()) {
           for (const pattern of patterns) {
             if (simpleGlobToRegex(pattern).test(entry.name)) {
-              manifestFiles.push(path92.relative(rootDir, fullPath));
+              manifestFiles.push(path93.relative(rootDir, fullPath));
               break;
             }
           }
@@ -86283,13 +86322,13 @@ function findManifestFilesInDirs(directories, workingDir) {
   const patterns = [...new Set(allDetectors.flatMap((d) => d.patterns))];
   for (const dir of directories) {
     try {
-      const entries = fs73.readdirSync(dir, { withFileTypes: true });
+      const entries = fs74.readdirSync(dir, { withFileTypes: true });
       for (const entry of entries) {
-        const fullPath = path92.join(dir, entry.name);
+        const fullPath = path93.join(dir, entry.name);
         if (entry.isFile()) {
           for (const pattern of patterns) {
             if (simpleGlobToRegex(pattern).test(entry.name)) {
-              found.push(path92.relative(workingDir, fullPath));
+              found.push(path93.relative(workingDir, fullPath));
               break;
             }
           }
@@ -86302,11 +86341,11 @@ function findManifestFilesInDirs(directories, workingDir) {
 function getDirectoriesFromChangedFiles(changedFiles, workingDir) {
   const dirs = new Set;
   for (const file3 of changedFiles) {
-    let currentDir = path92.dirname(file3);
+    let currentDir = path93.dirname(file3);
     while (true) {
-      if (currentDir && currentDir !== "." && currentDir !== path92.sep) {
-        dirs.add(path92.join(workingDir, currentDir));
-        const parent = path92.dirname(currentDir);
+      if (currentDir && currentDir !== "." && currentDir !== path93.sep) {
+        dirs.add(path93.join(workingDir, currentDir));
+        const parent = path93.dirname(currentDir);
         if (parent === currentDir)
           break;
         currentDir = parent;
@@ -86320,7 +86359,7 @@ function getDirectoriesFromChangedFiles(changedFiles, workingDir) {
 }
 function ensureOutputDir(outputDir) {
   try {
-    fs73.mkdirSync(outputDir, { recursive: true });
+    fs74.mkdirSync(outputDir, { recursive: true });
   } catch (error93) {
     if (!error93 || error93.code !== "EEXIST") {
       throw error93;
@@ -86390,7 +86429,7 @@ var sbom_generate = createSwarmTool({
     const changedFiles = obj.changed_files;
     const relativeOutputDir = obj.output_dir || DEFAULT_OUTPUT_DIR;
     const workingDir = directory;
-    const outputDir = path92.isAbsolute(relativeOutputDir) ? relativeOutputDir : path92.join(workingDir, relativeOutputDir);
+    const outputDir = path93.isAbsolute(relativeOutputDir) ? relativeOutputDir : path93.join(workingDir, relativeOutputDir);
     let manifestFiles = [];
     if (scope === "all") {
       manifestFiles = findManifestFiles(workingDir);
@@ -86413,11 +86452,11 @@ var sbom_generate = createSwarmTool({
     const processedFiles = [];
     for (const manifestFile of manifestFiles) {
       try {
-        const fullPath = path92.isAbsolute(manifestFile) ? manifestFile : path92.join(workingDir, manifestFile);
-        if (!fs73.existsSync(fullPath)) {
+        const fullPath = path93.isAbsolute(manifestFile) ? manifestFile : path93.join(workingDir, manifestFile);
+        if (!fs74.existsSync(fullPath)) {
           continue;
         }
-        const content = fs73.readFileSync(fullPath, "utf-8");
+        const content = fs74.readFileSync(fullPath, "utf-8");
         const components = detectComponents(manifestFile, content);
         processedFiles.push(manifestFile);
         if (components.length > 0) {
@@ -86430,8 +86469,8 @@ var sbom_generate = createSwarmTool({
     const bom = generateCycloneDX(allComponents);
     const bomJson = serializeCycloneDX(bom);
     const filename = generateSbomFilename();
-    const outputPath = path92.join(outputDir, filename);
-    fs73.writeFileSync(outputPath, bomJson, "utf-8");
+    const outputPath = path93.join(outputDir, filename);
+    fs74.writeFileSync(outputPath, bomJson, "utf-8");
     const verdict = processedFiles.length > 0 ? "pass" : "pass";
     try {
       const timestamp = new Date().toISOString();
@@ -86473,8 +86512,8 @@ var sbom_generate = createSwarmTool({
 // src/tools/schema-drift.ts
 init_zod();
 init_create_tool();
-import * as fs74 from "node:fs";
-import * as path93 from "node:path";
+import * as fs75 from "node:fs";
+import * as path94 from "node:path";
 var SPEC_CANDIDATES = [
   "openapi.json",
   "openapi.yaml",
@@ -86506,28 +86545,28 @@ function normalizePath3(p) {
 }
 function discoverSpecFile(cwd, specFileArg) {
   if (specFileArg) {
-    const resolvedPath = path93.resolve(cwd, specFileArg);
-    const normalizedCwd = cwd.endsWith(path93.sep) ? cwd : cwd + path93.sep;
+    const resolvedPath = path94.resolve(cwd, specFileArg);
+    const normalizedCwd = cwd.endsWith(path94.sep) ? cwd : cwd + path94.sep;
     if (!resolvedPath.startsWith(normalizedCwd) && resolvedPath !== cwd) {
       throw new Error("Invalid spec_file: path traversal detected");
     }
-    const ext = path93.extname(resolvedPath).toLowerCase();
+    const ext = path94.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 = fs74.statSync(resolvedPath);
+    const stats = fs75.statSync(resolvedPath);
     if (stats.size > MAX_SPEC_SIZE) {
       throw new Error(`Invalid spec_file: file exceeds ${MAX_SPEC_SIZE / 1024 / 1024}MB limit`);
     }
-    if (!fs74.existsSync(resolvedPath)) {
+    if (!fs75.existsSync(resolvedPath)) {
       throw new Error(`Spec file not found: ${resolvedPath}`);
     }
     return resolvedPath;
   }
   for (const candidate of SPEC_CANDIDATES) {
-    const candidatePath = path93.resolve(cwd, candidate);
-    if (fs74.existsSync(candidatePath)) {
-      const stats = fs74.statSync(candidatePath);
+    const candidatePath = path94.resolve(cwd, candidate);
+    if (fs75.existsSync(candidatePath)) {
+      const stats = fs75.statSync(candidatePath);
       if (stats.size <= MAX_SPEC_SIZE) {
         return candidatePath;
       }
@@ -86536,8 +86575,8 @@ function discoverSpecFile(cwd, specFileArg) {
   return null;
 }
 function parseSpec(specFile) {
-  const content = fs74.readFileSync(specFile, "utf-8");
-  const ext = path93.extname(specFile).toLowerCase();
+  const content = fs75.readFileSync(specFile, "utf-8");
+  const ext = path94.extname(specFile).toLowerCase();
   if (ext === ".json") {
     return parseJsonSpec(content);
   }
@@ -86608,12 +86647,12 @@ function extractRoutes(cwd) {
   function walkDir(dir) {
     let entries;
     try {
-      entries = fs74.readdirSync(dir, { withFileTypes: true });
+      entries = fs75.readdirSync(dir, { withFileTypes: true });
     } catch {
       return;
     }
     for (const entry of entries) {
-      const fullPath = path93.join(dir, entry.name);
+      const fullPath = path94.join(dir, entry.name);
       if (entry.isSymbolicLink()) {
         continue;
       }
@@ -86623,7 +86662,7 @@ function extractRoutes(cwd) {
         }
         walkDir(fullPath);
       } else if (entry.isFile()) {
-        const ext = path93.extname(entry.name).toLowerCase();
+        const ext = path94.extname(entry.name).toLowerCase();
         const baseName = entry.name.toLowerCase();
         if (![".ts", ".js", ".mjs"].includes(ext)) {
           continue;
@@ -86641,7 +86680,7 @@ function extractRoutes(cwd) {
 }
 function extractRoutesFromFile(filePath) {
   const routes = [];
-  const content = fs74.readFileSync(filePath, "utf-8");
+  const content = fs75.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;
@@ -86790,8 +86829,8 @@ init_zod();
 init_bun_compat();
 init_path_security();
 init_create_tool();
-import * as fs75 from "node:fs";
-import * as path94 from "node:path";
+import * as fs76 from "node:fs";
+import * as path95 from "node:path";
 var DEFAULT_MAX_RESULTS = 100;
 var DEFAULT_MAX_LINES = 200;
 var REGEX_TIMEOUT_MS = 5000;
@@ -86827,11 +86866,11 @@ function containsWindowsAttacks3(str) {
 }
 function isPathInWorkspace3(filePath, workspace) {
   try {
-    const resolvedPath = path94.resolve(workspace, filePath);
-    const realWorkspace = fs75.realpathSync(workspace);
-    const realResolvedPath = fs75.realpathSync(resolvedPath);
-    const relativePath = path94.relative(realWorkspace, realResolvedPath);
-    if (relativePath.startsWith("..") || path94.isAbsolute(relativePath)) {
+    const resolvedPath = path95.resolve(workspace, filePath);
+    const realWorkspace = fs76.realpathSync(workspace);
+    const realResolvedPath = fs76.realpathSync(resolvedPath);
+    const relativePath = path95.relative(realWorkspace, realResolvedPath);
+    if (relativePath.startsWith("..") || path95.isAbsolute(relativePath)) {
       return false;
     }
     return true;
@@ -86844,12 +86883,12 @@ function validatePathForRead2(filePath, workspace) {
 }
 function findRgInEnvPath() {
   const searchPath = process.env.PATH ?? "";
-  for (const dir of searchPath.split(path94.delimiter)) {
+  for (const dir of searchPath.split(path95.delimiter)) {
     if (!dir)
       continue;
     const isWindows = process.platform === "win32";
-    const candidate = path94.join(dir, isWindows ? "rg.exe" : "rg");
-    if (fs75.existsSync(candidate))
+    const candidate = path95.join(dir, isWindows ? "rg.exe" : "rg");
+    if (fs76.existsSync(candidate))
       return candidate;
   }
   return null;
@@ -86976,10 +87015,10 @@ function collectFiles(dir, workspace, includeGlobs, excludeGlobs) {
     return files;
   }
   try {
-    const entries = fs75.readdirSync(dir, { withFileTypes: true });
+    const entries = fs76.readdirSync(dir, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = path94.join(dir, entry.name);
-      const relativePath = path94.relative(workspace, fullPath);
+      const fullPath = path95.join(dir, entry.name);
+      const relativePath = path95.relative(workspace, fullPath);
       if (!validatePathForRead2(fullPath, workspace)) {
         continue;
       }
@@ -87020,13 +87059,13 @@ async function fallbackSearch(opts) {
   const matches = [];
   let total = 0;
   for (const file3 of files) {
-    const fullPath = path94.join(opts.workspace, file3);
+    const fullPath = path95.join(opts.workspace, file3);
     if (!validatePathForRead2(fullPath, opts.workspace)) {
       continue;
     }
     let stats;
     try {
-      stats = fs75.statSync(fullPath);
+      stats = fs76.statSync(fullPath);
       if (stats.size > MAX_FILE_SIZE_BYTES10) {
         continue;
       }
@@ -87035,7 +87074,7 @@ async function fallbackSearch(opts) {
     }
     let content;
     try {
-      content = fs75.readFileSync(fullPath, "utf-8");
+      content = fs76.readFileSync(fullPath, "utf-8");
     } catch {
       continue;
     }
@@ -87147,7 +87186,7 @@ var search = createSwarmTool({
         message: "Exclude pattern contains invalid Windows-specific sequence"
       }, null, 2);
     }
-    if (!fs75.existsSync(directory)) {
+    if (!fs76.existsSync(directory)) {
       return JSON.stringify({
         error: true,
         type: "unknown",
@@ -87276,8 +87315,8 @@ var set_qa_gates = createSwarmTool({
 init_zod();
 init_path_security();
 init_create_tool();
-import * as fs76 from "node:fs";
-import * as path95 from "node:path";
+import * as fs77 from "node:fs";
+import * as path96 from "node:path";
 var WINDOWS_RESERVED_NAMES4 = /^(con|prn|aux|nul|com[1-9]|lpt[1-9])(\.|:|$)/i;
 function containsWindowsAttacks4(str) {
   if (/:[^\\/]/.test(str))
@@ -87291,14 +87330,14 @@ function containsWindowsAttacks4(str) {
 }
 function isPathInWorkspace4(filePath, workspace) {
   try {
-    const resolvedPath = path95.resolve(workspace, filePath);
-    if (!fs76.existsSync(resolvedPath)) {
+    const resolvedPath = path96.resolve(workspace, filePath);
+    if (!fs77.existsSync(resolvedPath)) {
       return true;
     }
-    const realWorkspace = fs76.realpathSync(workspace);
-    const realResolvedPath = fs76.realpathSync(resolvedPath);
-    const relativePath = path95.relative(realWorkspace, realResolvedPath);
-    if (relativePath.startsWith("..") || path95.isAbsolute(relativePath)) {
+    const realWorkspace = fs77.realpathSync(workspace);
+    const realResolvedPath = fs77.realpathSync(resolvedPath);
+    const relativePath = path96.relative(realWorkspace, realResolvedPath);
+    if (relativePath.startsWith("..") || path96.isAbsolute(relativePath)) {
       return false;
     }
     return true;
@@ -87470,7 +87509,7 @@ var suggestPatch = createSwarmTool({
         message: "changes cannot be empty"
       }, null, 2);
     }
-    if (!fs76.existsSync(directory)) {
+    if (!fs77.existsSync(directory)) {
       return JSON.stringify({
         success: false,
         error: true,
@@ -87506,8 +87545,8 @@ var suggestPatch = createSwarmTool({
         });
         continue;
       }
-      const fullPath = path95.resolve(directory, change.file);
-      if (!fs76.existsSync(fullPath)) {
+      const fullPath = path96.resolve(directory, change.file);
+      if (!fs77.existsSync(fullPath)) {
         errors5.push({
           success: false,
           error: true,
@@ -87521,7 +87560,7 @@ var suggestPatch = createSwarmTool({
       }
       let content;
       try {
-        content = fs76.readFileSync(fullPath, "utf-8");
+        content = fs77.readFileSync(fullPath, "utf-8");
       } catch (err3) {
         errors5.push({
           success: false,
@@ -87768,8 +87807,8 @@ var generate_mutants = createSwarmTool({
 // src/tools/lint-spec.ts
 init_spec_schema();
 init_create_tool();
-import * as fs77 from "node:fs";
-import * as path96 from "node:path";
+import * as fs78 from "node:fs";
+import * as path97 from "node:path";
 var SPEC_FILE_NAME = "spec.md";
 var SWARM_DIR2 = ".swarm";
 var OBLIGATION_KEYWORDS2 = ["MUST", "SHALL", "SHOULD", "MAY"];
@@ -87822,8 +87861,8 @@ var lint_spec = createSwarmTool({
   async execute(_args, directory) {
     const errors5 = [];
     const warnings = [];
-    const specPath = path96.join(directory, SWARM_DIR2, SPEC_FILE_NAME);
-    if (!fs77.existsSync(specPath)) {
+    const specPath = path97.join(directory, SWARM_DIR2, SPEC_FILE_NAME);
+    if (!fs78.existsSync(specPath)) {
       const result2 = {
         valid: false,
         specMtime: null,
@@ -87842,12 +87881,12 @@ var lint_spec = createSwarmTool({
     }
     let specMtime = null;
     try {
-      const stats = fs77.statSync(specPath);
+      const stats = fs78.statSync(specPath);
       specMtime = stats.mtime.toISOString();
     } catch {}
     let content;
     try {
-      content = fs77.readFileSync(specPath, "utf-8");
+      content = fs78.readFileSync(specPath, "utf-8");
     } catch (e) {
       const result2 = {
         valid: false,
@@ -87892,13 +87931,13 @@ var lint_spec = createSwarmTool({
 });
 // src/tools/mutation-test.ts
 init_zod();
-import * as fs78 from "node:fs";
-import * as path98 from "node:path";
+import * as fs79 from "node:fs";
+import * as path99 from "node:path";
 
 // src/mutation/engine.ts
 import { spawnSync as spawnSync3 } from "node:child_process";
-import { unlinkSync as unlinkSync13, writeFileSync as writeFileSync19 } from "node:fs";
-import * as path97 from "node:path";
+import { unlinkSync as unlinkSync13, writeFileSync as writeFileSync20 } from "node:fs";
+import * as path98 from "node:path";
 
 // src/mutation/equivalence.ts
 function isStaticallyEquivalent(originalCode, mutatedCode) {
@@ -88033,9 +88072,9 @@ async function executeMutation(patch, testCommand, _testFiles, workingDir) {
   let patchFile;
   try {
     const safeId2 = patch.id.replace(/[^a-zA-Z0-9_-]/g, "_");
-    patchFile = path97.join(workingDir, `.mutation_patch_${safeId2}.diff`);
+    patchFile = path98.join(workingDir, `.mutation_patch_${safeId2}.diff`);
     try {
-      writeFileSync19(patchFile, patch.patch);
+      writeFileSync20(patchFile, patch.patch);
     } catch (writeErr) {
       error93 = `Failed to write patch file: ${writeErr}`;
       outcome = "error";
@@ -88427,8 +88466,8 @@ var mutation_test = createSwarmTool({
       ];
       for (const filePath of uniquePaths) {
         try {
-          const resolvedPath = path98.resolve(cwd, filePath);
-          sourceFiles.set(filePath, fs78.readFileSync(resolvedPath, "utf-8"));
+          const resolvedPath = path99.resolve(cwd, filePath);
+          sourceFiles.set(filePath, fs79.readFileSync(resolvedPath, "utf-8"));
         } catch {}
       }
       const report = await executeMutationSuite(typedArgs.patches, typedArgs.test_command, typedArgs.files, cwd, undefined, undefined, sourceFiles.size > 0 ? sourceFiles : undefined);
@@ -88446,8 +88485,8 @@ var mutation_test = createSwarmTool({
 init_zod();
 init_manager2();
 init_detector();
-import * as fs79 from "node:fs";
-import * as path99 from "node:path";
+import * as fs80 from "node:fs";
+import * as path100 from "node:path";
 init_create_tool();
 var MAX_FILE_SIZE2 = 2 * 1024 * 1024;
 var BINARY_CHECK_BYTES = 8192;
@@ -88513,7 +88552,7 @@ async function syntaxCheck(input, directory, config3) {
   if (languages?.length) {
     const lowerLangs = languages.map((l) => l.toLowerCase());
     filesToCheck = filesToCheck.filter((file3) => {
-      const ext = path99.extname(file3.path).toLowerCase();
+      const ext = path100.extname(file3.path).toLowerCase();
       const langDef = getLanguageForExtension(ext);
       const fileProfile = getProfileForFile(file3.path);
       const langId = fileProfile?.id || langDef?.id;
@@ -88526,7 +88565,7 @@ async function syntaxCheck(input, directory, config3) {
   let skippedCount = 0;
   for (const fileInfo of filesToCheck) {
     const { path: filePath } = fileInfo;
-    const fullPath = path99.isAbsolute(filePath) ? filePath : path99.join(directory, filePath);
+    const fullPath = path100.isAbsolute(filePath) ? filePath : path100.join(directory, filePath);
     const result = {
       path: filePath,
       language: "",
@@ -88556,7 +88595,7 @@ async function syntaxCheck(input, directory, config3) {
       }
       let content;
       try {
-        content = fs79.readFileSync(fullPath, "utf8");
+        content = fs80.readFileSync(fullPath, "utf8");
       } catch {
         result.skipped_reason = "file_read_error";
         skippedCount++;
@@ -88575,7 +88614,7 @@ async function syntaxCheck(input, directory, config3) {
         results.push(result);
         continue;
       }
-      const ext = path99.extname(filePath).toLowerCase();
+      const ext = path100.extname(filePath).toLowerCase();
       const langDef = getLanguageForExtension(ext);
       result.language = profile?.id || langDef?.id || "unknown";
       const errors5 = extractSyntaxErrors(parser, content);
@@ -88667,8 +88706,8 @@ init_zod();
 init_utils();
 init_create_tool();
 init_path_security();
-import * as fs80 from "node:fs";
-import * as path100 from "node:path";
+import * as fs81 from "node:fs";
+import * as path101 from "node:path";
 var MAX_TEXT_LENGTH = 200;
 var MAX_FILE_SIZE_BYTES11 = 1024 * 1024;
 var SUPPORTED_EXTENSIONS4 = new Set([
@@ -88734,9 +88773,9 @@ function validatePathsInput(paths, cwd) {
     return { error: "paths contains path traversal", resolvedPath: null };
   }
   try {
-    const resolvedPath = path100.resolve(paths);
-    const normalizedCwd = path100.resolve(cwd);
-    const normalizedResolved = path100.resolve(resolvedPath);
+    const resolvedPath = path101.resolve(paths);
+    const normalizedCwd = path101.resolve(cwd);
+    const normalizedResolved = path101.resolve(resolvedPath);
     if (!normalizedResolved.startsWith(normalizedCwd)) {
       return {
         error: "paths must be within the current working directory",
@@ -88752,13 +88791,13 @@ function validatePathsInput(paths, cwd) {
   }
 }
 function isSupportedExtension(filePath) {
-  const ext = path100.extname(filePath).toLowerCase();
+  const ext = path101.extname(filePath).toLowerCase();
   return SUPPORTED_EXTENSIONS4.has(ext);
 }
 function findSourceFiles3(dir, files = []) {
   let entries;
   try {
-    entries = fs80.readdirSync(dir);
+    entries = fs81.readdirSync(dir);
   } catch {
     return files;
   }
@@ -88767,10 +88806,10 @@ function findSourceFiles3(dir, files = []) {
     if (SKIP_DIRECTORIES5.has(entry)) {
       continue;
     }
-    const fullPath = path100.join(dir, entry);
+    const fullPath = path101.join(dir, entry);
     let stat6;
     try {
-      stat6 = fs80.statSync(fullPath);
+      stat6 = fs81.statSync(fullPath);
     } catch {
       continue;
     }
@@ -88863,7 +88902,7 @@ var todo_extract = createSwarmTool({
       return JSON.stringify(errorResult, null, 2);
     }
     const scanPath = resolvedPath;
-    if (!fs80.existsSync(scanPath)) {
+    if (!fs81.existsSync(scanPath)) {
       const errorResult = {
         error: `path not found: ${pathsInput}`,
         total: 0,
@@ -88873,13 +88912,13 @@ var todo_extract = createSwarmTool({
       return JSON.stringify(errorResult, null, 2);
     }
     const filesToScan = [];
-    const stat6 = fs80.statSync(scanPath);
+    const stat6 = fs81.statSync(scanPath);
     if (stat6.isFile()) {
       if (isSupportedExtension(scanPath)) {
         filesToScan.push(scanPath);
       } else {
         const errorResult = {
-          error: `unsupported file extension: ${path100.extname(scanPath)}`,
+          error: `unsupported file extension: ${path101.extname(scanPath)}`,
           total: 0,
           byPriority: { high: 0, medium: 0, low: 0 },
           entries: []
@@ -88892,11 +88931,11 @@ var todo_extract = createSwarmTool({
     const allEntries = [];
     for (const filePath of filesToScan) {
       try {
-        const fileStat = fs80.statSync(filePath);
+        const fileStat = fs81.statSync(filePath);
         if (fileStat.size > MAX_FILE_SIZE_BYTES11) {
           continue;
         }
-        const content = fs80.readFileSync(filePath, "utf-8");
+        const content = fs81.readFileSync(filePath, "utf-8");
         const entries = parseTodoComments(content, filePath, tagsSet);
         allEntries.push(...entries);
       } catch {}
@@ -88927,19 +88966,19 @@ init_loader();
 init_schema();
 init_qa_gate_profile();
 init_gate_evidence();
-import * as fs82 from "node:fs";
-import * as path102 from "node:path";
+import * as fs83 from "node:fs";
+import * as path103 from "node:path";
 
 // src/hooks/diff-scope.ts
 init_bun_compat();
-import * as fs81 from "node:fs";
-import * as path101 from "node:path";
+import * as fs82 from "node:fs";
+import * as path102 from "node:path";
 function getDeclaredScope(taskId, directory) {
   try {
-    const planPath = path101.join(directory, ".swarm", "plan.json");
-    if (!fs81.existsSync(planPath))
+    const planPath = path102.join(directory, ".swarm", "plan.json");
+    if (!fs82.existsSync(planPath))
       return null;
-    const raw = fs81.readFileSync(planPath, "utf-8");
+    const raw = fs82.readFileSync(planPath, "utf-8");
     const plan = JSON.parse(raw);
     for (const phase of plan.phases ?? []) {
       for (const task of phase.tasks ?? []) {
@@ -89055,7 +89094,7 @@ var TIER_3_PATTERNS = [
 ];
 function matchesTier3Pattern(files) {
   for (const file3 of files) {
-    const fileName = path102.basename(file3);
+    const fileName = path103.basename(file3);
     for (const pattern of TIER_3_PATTERNS) {
       if (pattern.test(fileName)) {
         return true;
@@ -89069,8 +89108,8 @@ function checkReviewerGate(taskId, workingDirectory, stageBParallelEnabled = fal
     if (hasActiveTurboMode()) {
       const resolvedDir2 = workingDirectory;
       try {
-        const planPath = path102.join(resolvedDir2, ".swarm", "plan.json");
-        const planRaw = fs82.readFileSync(planPath, "utf-8");
+        const planPath = path103.join(resolvedDir2, ".swarm", "plan.json");
+        const planRaw = fs83.readFileSync(planPath, "utf-8");
         const plan = JSON.parse(planRaw);
         for (const planPhase of plan.phases ?? []) {
           for (const task of planPhase.tasks ?? []) {
@@ -89139,8 +89178,8 @@ function checkReviewerGate(taskId, workingDirectory, stageBParallelEnabled = fal
     }
     try {
       const resolvedDir2 = workingDirectory;
-      const planPath = path102.join(resolvedDir2, ".swarm", "plan.json");
-      const planRaw = fs82.readFileSync(planPath, "utf-8");
+      const planPath = path103.join(resolvedDir2, ".swarm", "plan.json");
+      const planRaw = fs83.readFileSync(planPath, "utf-8");
       const plan = JSON.parse(planRaw);
       for (const planPhase of plan.phases ?? []) {
         for (const task of planPhase.tasks ?? []) {
@@ -89297,8 +89336,8 @@ function checkCouncilGate(workingDirectory, taskId) {
     return { blocked: false, reason: "" };
   }
   try {
-    const planPath = path102.join(workingDirectory, ".swarm", "plan.json");
-    const planRaw = fs82.readFileSync(planPath, "utf-8");
+    const planPath = path103.join(workingDirectory, ".swarm", "plan.json");
+    const planRaw = fs83.readFileSync(planPath, "utf-8");
     const planObj = JSON.parse(planRaw);
     if (planObj.swarm && planObj.title) {
       const planId = `${planObj.swarm}-${planObj.title}`.replace(/[^a-zA-Z0-9-_]/g, "_");
@@ -89388,8 +89427,8 @@ async function executeUpdateTaskStatus(args2, fallbackDir) {
         };
       }
     }
-    normalizedDir = path102.normalize(args2.working_directory);
-    const pathParts = normalizedDir.split(path102.sep);
+    normalizedDir = path103.normalize(args2.working_directory);
+    const pathParts = normalizedDir.split(path103.sep);
     if (pathParts.includes("..")) {
       return {
         success: false,
@@ -89399,11 +89438,11 @@ async function executeUpdateTaskStatus(args2, fallbackDir) {
         ]
       };
     }
-    const resolvedDir = path102.resolve(normalizedDir);
+    const resolvedDir = path103.resolve(normalizedDir);
     try {
-      const realPath = fs82.realpathSync(resolvedDir);
-      const planPath = path102.join(realPath, ".swarm", "plan.json");
-      if (!fs82.existsSync(planPath)) {
+      const realPath = fs83.realpathSync(resolvedDir);
+      const planPath = path103.join(realPath, ".swarm", "plan.json");
+      if (!fs83.existsSync(planPath)) {
         return {
           success: false,
           message: `Invalid working_directory: plan not found in "${realPath}"`,
@@ -89434,22 +89473,22 @@ async function executeUpdateTaskStatus(args2, fallbackDir) {
   }
   if (args2.status === "in_progress") {
     try {
-      const evidencePath = path102.join(directory, ".swarm", "evidence", `${args2.task_id}.json`);
-      fs82.mkdirSync(path102.dirname(evidencePath), { recursive: true });
-      const fd = fs82.openSync(evidencePath, "wx");
+      const evidencePath = path103.join(directory, ".swarm", "evidence", `${args2.task_id}.json`);
+      fs83.mkdirSync(path103.dirname(evidencePath), { recursive: true });
+      const fd = fs83.openSync(evidencePath, "wx");
       let writeOk = false;
       try {
-        fs82.writeSync(fd, JSON.stringify({
+        fs83.writeSync(fd, JSON.stringify({
           taskId: args2.task_id,
           required_gates: ["reviewer", "test_engineer"],
           gates: {}
         }, null, 2));
         writeOk = true;
       } finally {
-        fs82.closeSync(fd);
+        fs83.closeSync(fd);
         if (!writeOk) {
           try {
-            fs82.unlinkSync(evidencePath);
+            fs83.unlinkSync(evidencePath);
           } catch {}
         }
       }
@@ -89459,8 +89498,8 @@ async function executeUpdateTaskStatus(args2, fallbackDir) {
     recoverTaskStateFromDelegations(args2.task_id);
     let phaseRequiresReviewer = true;
     try {
-      const planPath = path102.join(directory, ".swarm", "plan.json");
-      const planRaw = fs82.readFileSync(planPath, "utf-8");
+      const planPath = path103.join(directory, ".swarm", "plan.json");
+      const planRaw = fs83.readFileSync(planPath, "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")) {
@@ -89778,8 +89817,8 @@ init_utils2();
 init_ledger();
 init_manager();
 init_create_tool();
-import fs83 from "node:fs";
-import path103 from "node:path";
+import fs84 from "node:fs";
+import path104 from "node:path";
 function derivePlanId5(plan) {
   return `${plan.swarm}-${plan.title}`.replace(/[^a-zA-Z0-9-_]/g, "_");
 }
@@ -89830,7 +89869,7 @@ async function executeWriteDriftEvidence(args2, directory) {
     entries: [evidenceEntry]
   };
   const filename = "drift-verifier.json";
-  const relativePath = path103.join("evidence", String(phase), filename);
+  const relativePath = path104.join("evidence", String(phase), filename);
   let validatedPath;
   try {
     validatedPath = validateSwarmPath(directory, relativePath);
@@ -89841,12 +89880,12 @@ async function executeWriteDriftEvidence(args2, directory) {
       message: error93 instanceof Error ? error93.message : "Failed to validate path"
     }, null, 2);
   }
-  const evidenceDir = path103.dirname(validatedPath);
+  const evidenceDir = path104.dirname(validatedPath);
   try {
-    await fs83.promises.mkdir(evidenceDir, { recursive: true });
-    const tempPath = path103.join(evidenceDir, `.${filename}.tmp`);
-    await fs83.promises.writeFile(tempPath, JSON.stringify(evidenceContent, null, 2), "utf-8");
-    await fs83.promises.rename(tempPath, validatedPath);
+    await fs84.promises.mkdir(evidenceDir, { recursive: true });
+    const tempPath = path104.join(evidenceDir, `.${filename}.tmp`);
+    await fs84.promises.writeFile(tempPath, JSON.stringify(evidenceContent, null, 2), "utf-8");
+    await fs84.promises.rename(tempPath, validatedPath);
     let snapshotInfo;
     let snapshotError;
     let qaProfileLocked;
@@ -89940,8 +89979,8 @@ var write_drift_evidence = createSwarmTool({
 init_zod();
 init_utils2();
 init_create_tool();
-import fs84 from "node:fs";
-import path104 from "node:path";
+import fs85 from "node:fs";
+import path105 from "node:path";
 function normalizeVerdict2(verdict) {
   switch (verdict) {
     case "APPROVED":
@@ -89989,7 +90028,7 @@ async function executeWriteHallucinationEvidence(args2, directory) {
     entries: [evidenceEntry]
   };
   const filename = "hallucination-guard.json";
-  const relativePath = path104.join("evidence", String(phase), filename);
+  const relativePath = path105.join("evidence", String(phase), filename);
   let validatedPath;
   try {
     validatedPath = validateSwarmPath(directory, relativePath);
@@ -90000,12 +90039,12 @@ async function executeWriteHallucinationEvidence(args2, directory) {
       message: error93 instanceof Error ? error93.message : "Failed to validate path"
     }, null, 2);
   }
-  const evidenceDir = path104.dirname(validatedPath);
+  const evidenceDir = path105.dirname(validatedPath);
   try {
-    await fs84.promises.mkdir(evidenceDir, { recursive: true });
-    const tempPath = path104.join(evidenceDir, `.${filename}.tmp`);
-    await fs84.promises.writeFile(tempPath, JSON.stringify(evidenceContent, null, 2), "utf-8");
-    await fs84.promises.rename(tempPath, validatedPath);
+    await fs85.promises.mkdir(evidenceDir, { recursive: true });
+    const tempPath = path105.join(evidenceDir, `.${filename}.tmp`);
+    await fs85.promises.writeFile(tempPath, JSON.stringify(evidenceContent, null, 2), "utf-8");
+    await fs85.promises.rename(tempPath, validatedPath);
     return JSON.stringify({
       success: true,
       phase,
@@ -90051,8 +90090,8 @@ var write_hallucination_evidence = createSwarmTool({
 init_zod();
 init_utils2();
 init_create_tool();
-import fs85 from "node:fs";
-import path105 from "node:path";
+import fs86 from "node:fs";
+import path106 from "node:path";
 function normalizeVerdict3(verdict) {
   switch (verdict) {
     case "PASS":
@@ -90126,7 +90165,7 @@ async function executeWriteMutationEvidence(args2, directory) {
     entries: [evidenceEntry]
   };
   const filename = "mutation-gate.json";
-  const relativePath = path105.join("evidence", String(phase), filename);
+  const relativePath = path106.join("evidence", String(phase), filename);
   let validatedPath;
   try {
     validatedPath = validateSwarmPath(directory, relativePath);
@@ -90137,12 +90176,12 @@ async function executeWriteMutationEvidence(args2, directory) {
       message: error93 instanceof Error ? error93.message : "Failed to validate path"
     }, null, 2);
   }
-  const evidenceDir = path105.dirname(validatedPath);
+  const evidenceDir = path106.dirname(validatedPath);
   try {
-    await fs85.promises.mkdir(evidenceDir, { recursive: true });
-    const tempPath = path105.join(evidenceDir, `.${filename}.tmp`);
-    await fs85.promises.writeFile(tempPath, JSON.stringify(evidenceContent, null, 2), "utf-8");
-    await fs85.promises.rename(tempPath, validatedPath);
+    await fs86.promises.mkdir(evidenceDir, { recursive: true });
+    const tempPath = path106.join(evidenceDir, `.${filename}.tmp`);
+    await fs86.promises.writeFile(tempPath, JSON.stringify(evidenceContent, null, 2), "utf-8");
+    await fs86.promises.rename(tempPath, validatedPath);
     return JSON.stringify({
       success: true,
       phase,
@@ -90196,20 +90235,20 @@ init_write_retro();
 init_utils();
 
 // src/utils/gitignore-warning.ts
-import * as fs86 from "node:fs";
-import * as path106 from "node:path";
+import * as fs87 from "node:fs";
+import * as path107 from "node:path";
 var _gitignoreWarningEmitted = false;
 function findGitRoot(startDir) {
   let current = startDir;
   while (true) {
     try {
-      const gitPath = path106.join(current, ".git");
-      const stat6 = fs86.statSync(gitPath);
+      const gitPath = path107.join(current, ".git");
+      const stat6 = fs87.statSync(gitPath);
       if (stat6.isDirectory()) {
         return current;
       }
     } catch {}
-    const parent = path106.dirname(current);
+    const parent = path107.dirname(current);
     if (parent === current) {
       return null;
     }
@@ -90229,7 +90268,7 @@ function fileCoversSwarm(content) {
 }
 function readFileSafe(filePath) {
   try {
-    return fs86.readFileSync(filePath, "utf8");
+    return fs87.readFileSync(filePath, "utf8");
   } catch {
     return null;
   }
@@ -90241,12 +90280,12 @@ function warnIfSwarmNotGitignored(directory, quiet = false) {
     const gitRoot = findGitRoot(directory);
     if (!gitRoot)
       return;
-    const gitignoreContent = readFileSafe(path106.join(gitRoot, ".gitignore"));
+    const gitignoreContent = readFileSafe(path107.join(gitRoot, ".gitignore"));
     if (gitignoreContent !== null && fileCoversSwarm(gitignoreContent)) {
       _gitignoreWarningEmitted = true;
       return;
     }
-    const excludeContent = readFileSafe(path106.join(gitRoot, ".git", "info", "exclude"));
+    const excludeContent = readFileSafe(path107.join(gitRoot, ".git", "info", "exclude"));
     if (excludeContent !== null && fileCoversSwarm(excludeContent)) {
       _gitignoreWarningEmitted = true;
       return;
@@ -90292,26 +90331,6 @@ ${footerLines.join(`
 // src/index.ts
 init_warning_buffer();
 var _heartbeatTimers = new Map;
-function writeSwarmConfigExampleIfNew(projectDirectory) {
-  try {
-    const swarmDir = path107.join(projectDirectory, ".swarm");
-    const dest = path107.join(swarmDir, "config.example.json");
-    if (fs87.existsSync(dest))
-      return;
-    const example = {
-      agents: Object.fromEntries(Object.entries(DEFAULT_MODELS).filter(([name2]) => name2 !== "default").map(([name2, model]) => [
-        name2,
-        {
-          model,
-          fallback_models: ["opencode/gpt-5-nano", "opencode/big-pickle"]
-        }
-      ])),
-      max_iterations: 5
-    };
-    fs87.writeFileSync(dest, `${JSON.stringify(example, null, 2)}
-`, "utf-8");
-  } catch {}
-}
 var OpenCodeSwarm = async (ctx) => {
   try {
     return await initializeOpenCodeSwarm(ctx);
@@ -90383,6 +90402,7 @@ async function initializeOpenCodeSwarm(ctx) {
   });
   initTelemetry(ctx.directory);
   writeSwarmConfigExampleIfNew(ctx.directory);
+  writeProjectConfigIfNew(ctx.directory, config3.quiet);
   warnIfSwarmNotGitignored(ctx.directory, config3.quiet);
   if (config3.version_check !== false) {
     scheduleVersionCheck(package_default.version, (msg) => {
@@ -90510,7 +90530,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 = path107.resolve(ctx.directory, ".swarm");
+    const swarmDir = path108.resolve(ctx.directory, ".swarm");
     statusArtifact = new ASA(swarmDir);
     statusArtifact.updateConfig(automationConfig.mode, automationConfig.capabilities);
     if (automationConfig.capabilities?.evidence_auto_summaries === true) {