npm - opencode-swarm - Versions diffs - 7.1.1 → 7.2.0 - Mend

opencode-swarm 7.1.1 → 7.2.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (4) hide show

package/dist/cli/index.js +1 -1
package/dist/config/project-init.d.ts +15 -0
package/dist/index.js +800 -762
package/package.json +1 -1

package/dist/index.js CHANGED Viewed

@@ -33,7 +33,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "opencode-swarm",
-    version: "7.1.1",
+    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",
@@ -60207,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);
@@ -60236,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: [] };
@@ -60252,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,
@@ -60285,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;
@@ -60298,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 {}
   }
@@ -60311,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 {}
   }
@@ -61898,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;
@@ -63651,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();
@@ -63665,7 +63665,7 @@ async function initTreeSitter() {
     const grammarsDir = getGrammarsDirAbsolute();
     await Parser.init({
       locateFile(scriptName) {
-        return path59.join(grammarsDir, scriptName);
+        return path60.join(grammarsDir, scriptName);
       }
     });
   }
@@ -63686,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) {
@@ -63706,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/`);
   }
@@ -63741,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;
@@ -63798,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) {
@@ -63862,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",
@@ -63879,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;
@@ -63898,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,
@@ -63909,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;
     }
@@ -63941,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({
@@ -63971,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 };
@@ -64010,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");
@@ -64036,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;
@@ -64059,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",
@@ -64132,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);
@@ -64322,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();
@@ -64352,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)}`);
   }
@@ -64486,8 +64486,7 @@ var init_curator_drift = __esm(() => {
 // 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();
@@ -64906,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
@@ -64983,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);
@@ -65037,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) {
@@ -65083,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.`);
@@ -65570,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,
@@ -65641,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 {}
         }
@@ -65708,7 +65765,7 @@ init_file_locks();
 init_state();
 init_telemetry();
 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,
@@ -65902,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)}`);
@@ -66214,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;
@@ -66253,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));
@@ -66347,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) => {
@@ -66367,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({
@@ -66494,16 +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_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) {
@@ -66534,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) {
@@ -66552,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;
@@ -66568,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 [];
   }
@@ -66720,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 [];
   }
@@ -66803,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,
@@ -66867,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";
@@ -66976,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);
@@ -66988,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",
@@ -67004,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;
           }
@@ -67020,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;
@@ -67035,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: {
@@ -67069,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) {
@@ -67080,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);
@@ -67096,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) {
@@ -67118,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);
@@ -67190,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) {
@@ -67295,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());
@@ -67419,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;
@@ -67427,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);
         }
@@ -67444,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) {
@@ -67463,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)) {
@@ -67533,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);
     }
@@ -67585,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);
@@ -67705,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) {
@@ -67713,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}`);
@@ -67731,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,
@@ -67893,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", {
@@ -68031,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;
@@ -68264,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 {}
@@ -68397,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 {
@@ -68561,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",
@@ -68607,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 {}
@@ -68655,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;
@@ -68675,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;
   }
@@ -69046,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 [];
     }
@@ -69097,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 [];
@@ -69173,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;
     }
@@ -69188,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;
@@ -69224,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;
   }
@@ -69240,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,
@@ -69485,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;
   }
@@ -69511,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`);
     }
@@ -69521,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;
   }
@@ -69552,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;
@@ -69616,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();
@@ -70364,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 {
@@ -70401,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);
@@ -70728,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,
@@ -70740,10 +70797,10 @@ 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);
@@ -70807,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:
@@ -70942,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) {
@@ -71208,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:
@@ -72089,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";
@@ -72168,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);
@@ -72196,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" };
       }
@@ -72205,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"],
@@ -72561,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;
@@ -72619,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);
   });
 }
@@ -72676,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",
@@ -72722,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;
@@ -72742,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);
@@ -72765,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;
@@ -72856,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)) {
@@ -72949,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");
@@ -72958,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 {}
 }
@@ -73000,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;
@@ -73027,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}`);
   }
@@ -73038,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 = [];
@@ -73062,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 {}
       }
@@ -73120,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) {
@@ -73128,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 {}
@@ -73258,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 {
@@ -73811,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;
@@ -73834,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}`);
@@ -73862,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}`);
   }
@@ -74210,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) {
@@ -74228,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;
@@ -74244,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,
@@ -74277,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,
@@ -74309,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;
       }
@@ -74568,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;
   }
@@ -74658,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,
@@ -74754,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));
 }
@@ -74849,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 = {
@@ -74907,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,
@@ -74923,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,
@@ -74965,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",
@@ -74988,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);
 }
@@ -75042,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) {
@@ -75085,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;
@@ -75099,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);
@@ -75221,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":
@@ -75248,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);
@@ -75282,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) {
@@ -75315,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.",
@@ -75397,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;
@@ -75429,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;
@@ -75466,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;
       });
@@ -75502,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;
@@ -75512,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",
@@ -75548,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 {}
@@ -75748,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;
@@ -75763,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);
     }
@@ -75773,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) {
@@ -75943,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";
@@ -75982,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)) {
@@ -76016,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)}`);
@@ -76159,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"));
@@ -76325,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)";
@@ -76754,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}`);
@@ -76991,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);
 }
@@ -77066,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,
@@ -77077,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}"`,
@@ -77104,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",
@@ -77114,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,
@@ -77144,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;
@@ -77205,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;
@@ -77235,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";
     }
   }
@@ -77354,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 = [];
@@ -77395,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) : "";
@@ -77469,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.",
@@ -77518,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",
@@ -77746,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";
@@ -77774,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) {
@@ -77792,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;
   }
@@ -77806,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;
       }
@@ -77822,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;
       }
@@ -77831,7 +77888,7 @@ function readEvidenceFiles(evidenceDir, _cwd) {
     }
     let content;
     try {
-      content = fs61.readFileSync(filePath, "utf-8");
+      content = fs62.readFileSync(filePath, "utf-8");
     } catch {
       continue;
     }
@@ -77927,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",
@@ -77941,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.",
@@ -77959,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;
@@ -77976,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",
@@ -78039,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";
@@ -78058,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)}`);
@@ -78326,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;
@@ -78375,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;
   }
@@ -78399,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];
@@ -78430,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, "");
@@ -78489,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,
@@ -78500,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,
@@ -78517,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);
       }
@@ -78574,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,
@@ -78585,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",
@@ -78596,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,
@@ -78611,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;
@@ -78829,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 = [
@@ -78899,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);
@@ -79141,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();
@@ -79154,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)}`);
   }
@@ -79399,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, "_");
@@ -79421,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;
@@ -79434,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) {
@@ -79472,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);
@@ -79539,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") {
@@ -79611,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") {
@@ -79685,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") {
@@ -79887,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);
@@ -79967,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;
@@ -79982,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")) {
@@ -80022,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) {
@@ -80076,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)}`);
@@ -80151,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) {
@@ -80193,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 {}
     }
@@ -80256,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) {
@@ -80285,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;
@@ -81444,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;
@@ -81568,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;
   }
@@ -81585,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;
@@ -81594,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) {
@@ -81841,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;
     }
@@ -81923,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();
@@ -82061,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
@@ -82955,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)
@@ -82990,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;
@@ -83021,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;
@@ -83050,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 {
@@ -83094,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;
@@ -83160,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,
@@ -83192,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,
@@ -83218,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 {
@@ -83260,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++) {
@@ -83309,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,
@@ -83362,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;
     }
@@ -83675,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";
@@ -83751,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;
@@ -83908,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++;
@@ -83926,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;
@@ -83944,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;
@@ -84145,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);
@@ -84196,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)");
@@ -84397,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) {
@@ -84438,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 = [
@@ -84463,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;
@@ -84486,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);
@@ -84631,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"];
@@ -84691,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;
       }
@@ -84717,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;
       }
@@ -84736,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;
     }
@@ -84755,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));
                 }
               }
             }
@@ -84768,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)) {
@@ -84903,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,
@@ -84930,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;
@@ -84956,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)}`);
     }
@@ -85043,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();
@@ -85122,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,
@@ -85148,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 {
@@ -85164,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) {
@@ -85314,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;
@@ -85337,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 } : {},
@@ -85389,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();
@@ -86238,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;
         }
@@ -86249,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;
             }
           }
@@ -86265,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;
             }
           }
@@ -86284,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;
@@ -86302,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;
@@ -86372,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);
@@ -86395,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) {
@@ -86412,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();
@@ -86455,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",
@@ -86488,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;
       }
@@ -86518,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);
   }
@@ -86590,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;
       }
@@ -86605,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;
@@ -86623,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;
@@ -86772,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;
@@ -86809,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;
@@ -86826,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;
@@ -86958,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;
       }
@@ -87002,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;
       }
@@ -87017,7 +87074,7 @@ async function fallbackSearch(opts) {
     }
     let content;
     try {
-      content = fs75.readFileSync(fullPath, "utf-8");
+      content = fs76.readFileSync(fullPath, "utf-8");
     } catch {
       continue;
     }
@@ -87129,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",
@@ -87258,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))
@@ -87273,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;
@@ -87452,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,
@@ -87488,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,
@@ -87503,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,
@@ -87750,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"];
@@ -87804,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,
@@ -87824,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,
@@ -87874,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) {
@@ -88015,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";
@@ -88409,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);
@@ -88428,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;
@@ -88495,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;
@@ -88508,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: "",
@@ -88538,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++;
@@ -88557,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);
@@ -88649,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([
@@ -88716,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",
@@ -88734,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;
   }
@@ -88749,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;
     }
@@ -88845,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,
@@ -88855,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: []
@@ -88874,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 {}
@@ -88909,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 ?? []) {
@@ -89037,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;
@@ -89051,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 ?? []) {
@@ -89121,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 ?? []) {
@@ -89279,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, "_");
@@ -89370,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,
@@ -89381,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}"`,
@@ -89416,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 {}
         }
       }
@@ -89441,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")) {
@@ -89760,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, "_");
 }
@@ -89812,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);
@@ -89823,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;
@@ -89922,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":
@@ -89971,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);
@@ -89982,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,
@@ -90033,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":
@@ -90108,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);
@@ -90119,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,
@@ -90178,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;
     }
@@ -90211,7 +90268,7 @@ function fileCoversSwarm(content) {
 }
 function readFileSafe(filePath) {
   try {
-    return fs86.readFileSync(filePath, "utf8");
+    return fs87.readFileSync(filePath, "utf8");
   } catch {
     return null;
   }
@@ -90223,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;
@@ -90274,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);
@@ -90365,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) => {
@@ -90492,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) {