opencode-swarm 7.0.0 → 7.0.1

package/dist/index.js

@@ -33,7 +33,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "opencode-swarm",
-    version: "7.0.0",
+    version: "7.0.1",
     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",
@@ -16750,7 +16750,7 @@ async function loadPlan(directory) {
                   const rebuilt = await replayFromLedger(directory);
                   if (rebuilt) {
                     await rebuildPlan(directory, rebuilt);
-                    warn("[loadPlan] Rebuilt plan from ledger. Checkpoint available at SWARM_PLAN.md if it exists.");
+                    warn("[loadPlan] Rebuilt plan from ledger. Checkpoint available at .swarm/SWARM_PLAN.md if it exists.");
                     return rebuilt;
                   }
                 } catch (replayError) {
@@ -16771,7 +16771,7 @@ async function loadPlan(directory) {
                       return approved.plan;
                     }
                   } catch {}
-                  warn(`[loadPlan] Ledger replay failed during hash-mismatch rebuild: ${replayError instanceof Error ? replayError.message : String(replayError)}. Returning stale plan.json. To recover: check SWARM_PLAN.md for a checkpoint, or run /swarm reset-session.`);
+                  warn(`[loadPlan] Ledger replay failed during hash-mismatch rebuild: ${replayError instanceof Error ? replayError.message : String(replayError)}. Returning stale plan.json. To recover: check .swarm/SWARM_PLAN.md for a checkpoint, or run /swarm reset-session.`);
                 }
               }
             }
@@ -16817,7 +16817,7 @@ async function loadPlan(directory) {
         }
         return validated;
       } catch (error49) {
-        warn(`[loadPlan] plan.json validation failed: ${error49 instanceof Error ? error49.message : String(error49)}. Attempting rebuild from ledger. If rebuild fails, check SWARM_PLAN.md for a checkpoint.`);
+        warn(`[loadPlan] plan.json validation failed: ${error49 instanceof Error ? error49.message : String(error49)}. Attempting rebuild from ledger. If rebuild fails, check .swarm/SWARM_PLAN.md for a checkpoint.`);
         let rawPlanId = null;
         try {
           const rawParsed = JSON.parse(planJsonContent);
@@ -39463,6 +39463,7 @@ var init_create_tool = __esm(() => {
 // src/tools/checkpoint.ts
 var exports_checkpoint = {};
 __export(exports_checkpoint, {
+  saveCheckpointRecord: () => saveCheckpointRecord,
   checkpoint: () => checkpoint
 });
 import * as child_process from "node:child_process";
@@ -39617,6 +39618,38 @@ function handleSave(label, directory) {
     }, null, 2);
   }
 }
+function saveCheckpointRecord(label, directory) {
+  const labelError = validateLabel(label);
+  if (labelError) {
+    return { success: false, error: labelError };
+  }
+  try {
+    const log2 = readCheckpointLog(directory);
+    if (log2.checkpoints.find((c) => c.label === label)) {
+      return { success: false, error: `duplicate label: "${label}"` };
+    }
+    let sha = "";
+    if (isGitRepo()) {
+      try {
+        sha = getCurrentSha();
+      } catch {
+        sha = "";
+      }
+    }
+    log2.checkpoints.push({
+      label,
+      sha,
+      timestamp: new Date().toISOString()
+    });
+    writeCheckpointLog(log2, directory);
+    return { success: true, sha };
+  } catch (e) {
+    return {
+      success: false,
+      error: e instanceof Error ? e.message : "unknown error"
+    };
+  }
+}
 function handleRestore(label, directory) {
   try {
     const log2 = readCheckpointLog(directory);
@@ -42084,22 +42117,20 @@ async function handleCloseCommand(directory, args2) {
     }
   } catch {}
   let swarmPlanFilesRemoved = 0;
-  const swarmPlanJsonPath = path18.join(directory, "SWARM_PLAN.json");
-  const swarmPlanMdPath = path18.join(directory, "SWARM_PLAN.md");
-  try {
-    await fs12.unlink(swarmPlanJsonPath);
-    swarmPlanFilesRemoved++;
-  } catch (err2) {
-    if (err2?.code !== "ENOENT") {
-      warnings.push(`Failed to remove SWARM_PLAN.json: ${err2 instanceof Error ? err2.message : String(err2)}`);
-    }
-  }
-  try {
-    await fs12.unlink(swarmPlanMdPath);
-    swarmPlanFilesRemoved++;
-  } catch (err2) {
-    if (err2?.code !== "ENOENT") {
-      warnings.push(`Failed to remove SWARM_PLAN.md: ${err2 instanceof Error ? err2.message : String(err2)}`);
+  const candidates = [
+    path18.join(directory, ".swarm", "SWARM_PLAN.json"),
+    path18.join(directory, ".swarm", "SWARM_PLAN.md"),
+    path18.join(directory, "SWARM_PLAN.json"),
+    path18.join(directory, "SWARM_PLAN.md")
+  ];
+  for (const candidate of candidates) {
+    try {
+      await fs12.unlink(candidate);
+      swarmPlanFilesRemoved++;
+    } catch (err2) {
+      if (err2?.code !== "ENOENT") {
+        warnings.push(`Failed to remove ${path18.basename(candidate)}: ${err2 instanceof Error ? err2.message : String(err2)}`);
+      }
     }
   }
   clearAllScopes(directory);
@@ -42174,9 +42205,7 @@ async function handleCloseCommand(directory, args2) {
     "- Reset context.md for next session",
     "- Cleared agent sessions and delegation chains",
     ...configBackupsRemoved > 0 ? [`- Removed ${configBackupsRemoved} stale config backup file(s)`] : [],
-    ...swarmPlanFilesRemoved > 0 ? [
-      `- Removed ${swarmPlanFilesRemoved} root-level SWARM_PLAN checkpoint artifact(s)`
-    ] : [],
+    ...swarmPlanFilesRemoved > 0 ? [`- Removed ${swarmPlanFilesRemoved} SWARM_PLAN checkpoint artifact(s)`] : [],
     ...planExists && !planAlreadyDone ? ["- Set non-completed phases/tasks to closed status"] : [],
     ...curationSucceeded && allLessons.length > 0 ? [`- Committed ${allLessons.length} lesson(s) to knowledge store`] : [],
     "",
@@ -44094,11 +44123,21 @@ function getPluginConfigDir() {
 function getPluginCachePaths() {
   const cacheBase = process.env.XDG_CACHE_HOME || path24.join(os5.homedir(), ".cache");
   const configDir = getPluginConfigDir();
-  return [
+  const paths = [
+    path24.join(cacheBase, "opencode", "node_modules", "opencode-swarm"),
     path24.join(cacheBase, "opencode", "packages", "opencode-swarm@latest"),
-    path24.join(configDir, "node_modules", "opencode-swarm"),
-    path24.join(cacheBase, "opencode", "node_modules", "opencode-swarm")
+    path24.join(configDir, "node_modules", "opencode-swarm")
   ];
+  if (process.platform === "darwin") {
+    const libCaches = path24.join(os5.homedir(), "Library", "Caches");
+    paths.push(path24.join(libCaches, "opencode", "node_modules", "opencode-swarm"), path24.join(libCaches, "opencode", "packages", "opencode-swarm@latest"));
+  }
+  if (process.platform === "win32") {
+    const localAppData = process.env.LOCALAPPDATA || path24.join(os5.homedir(), "AppData", "Local");
+    const appData = process.env.APPDATA || path24.join(os5.homedir(), "AppData", "Roaming");
+    paths.push(path24.join(localAppData, "opencode", "node_modules", "opencode-swarm"), path24.join(localAppData, "opencode", "packages", "opencode-swarm@latest"), path24.join(appData, "opencode", "node_modules", "opencode-swarm"));
+  }
+  return paths;
 }
 var init_cache_paths = () => {};
 
@@ -53940,13 +53979,14 @@ var init_manager3 = __esm(() => {
 
 // src/commands/reset.ts
 import * as fs25 from "node:fs";
+import * as path38 from "node:path";
 async function handleResetCommand(directory, args2) {
   const hasConfirm = args2.includes("--confirm");
   if (!hasConfirm) {
     return [
       "## Swarm Reset",
       "",
-      "⚠️ This will delete plan.md and context.md from .swarm/",
+      "⚠️ This will delete all swarm state from .swarm/ (plan, context, checkpoints, SWARM_PLAN artifacts)",
       "",
       "**Tip**: Run `/swarm export` first to backup your state.",
       "",
@@ -53954,7 +53994,15 @@ async function handleResetCommand(directory, args2) {
     ].join(`
 `);
   }
-  const filesToReset = ["plan.md", "context.md"];
+  const filesToReset = [
+    "plan.md",
+    "plan.json",
+    "context.md",
+    "SWARM_PLAN.md",
+    "SWARM_PLAN.json",
+    "checkpoints.json",
+    "events.jsonl"
+  ];
   const results = [];
   for (const filename of filesToReset) {
     try {
@@ -53969,6 +54017,15 @@ async function handleResetCommand(directory, args2) {
       results.push(`- ❌ Failed to delete ${filename}`);
     }
   }
+  for (const filename of ["SWARM_PLAN.md", "SWARM_PLAN.json"]) {
+    try {
+      const rootPath = path38.join(directory, filename);
+      if (fs25.existsSync(rootPath)) {
+        fs25.unlinkSync(rootPath);
+        results.push(`- ✅ Deleted ${filename} (root)`);
+      }
+    } catch {}
+  }
   try {
     resetAutomationManager();
     results.push("- ✅ Stopped background automation (in-memory queues cleared)");
@@ -54002,7 +54059,7 @@ var init_reset = __esm(() => {
 
 // src/commands/reset-session.ts
 import * as fs26 from "node:fs";
-import * as path38 from "node:path";
+import * as path39 from "node:path";
 async function handleResetSessionCommand(directory, _args) {
   const results = [];
   try {
@@ -54017,13 +54074,13 @@ async function handleResetSessionCommand(directory, _args) {
     results.push("❌ Failed to delete state.json");
   }
   try {
-    const sessionDir = path38.dirname(validateSwarmPath(directory, "session/state.json"));
+    const sessionDir = path39.dirname(validateSwarmPath(directory, "session/state.json"));
     if (fs26.existsSync(sessionDir)) {
       const files = fs26.readdirSync(sessionDir);
       const otherFiles = files.filter((f) => f !== "state.json");
       let deletedCount = 0;
       for (const file3 of otherFiles) {
-        const filePath = path38.join(sessionDir, file3);
+        const filePath = path39.join(sessionDir, file3);
         if (fs26.lstatSync(filePath).isFile()) {
           fs26.unlinkSync(filePath);
           deletedCount++;
@@ -54056,7 +54113,7 @@ var init_reset_session = __esm(() => {
 
 // src/summaries/manager.ts
 import { mkdirSync as mkdirSync13, readdirSync as readdirSync10, renameSync as renameSync10, rmSync as rmSync4, statSync as statSync10 } from "node:fs";
-import * as path39 from "node:path";
+import * as path40 from "node:path";
 function sanitizeSummaryId(id) {
   if (!id || id.length === 0) {
     throw new Error("Invalid summary ID: empty string");
@@ -54090,9 +54147,9 @@ async function storeSummary(directory, id, fullOutput, summaryText, maxStoredByt
   if (serializedSize > maxStoredBytes) {
     throw new Error(`Summary entry size (${serializedSize} bytes) exceeds maximum (${maxStoredBytes} bytes)`);
   }
-  const relativePath = path39.join("summaries", `${sanitizedId}.json`);
+  const relativePath = path40.join("summaries", `${sanitizedId}.json`);
   const summaryPath = validateSwarmPath(directory, relativePath);
-  const summaryDir = path39.dirname(summaryPath);
+  const summaryDir = path40.dirname(summaryPath);
   const entry = {
     id: sanitizedId,
     summaryText,
@@ -54102,7 +54159,7 @@ async function storeSummary(directory, id, fullOutput, summaryText, maxStoredByt
   };
   const entryJson = JSON.stringify(entry);
   mkdirSync13(summaryDir, { recursive: true });
-  const tempPath = path39.join(summaryDir, `${sanitizedId}.json.tmp.${Date.now()}.${process.pid}`);
+  const tempPath = path40.join(summaryDir, `${sanitizedId}.json.tmp.${Date.now()}.${process.pid}`);
   try {
     await Bun.write(tempPath, entryJson);
     renameSync10(tempPath, summaryPath);
@@ -54115,7 +54172,7 @@ async function storeSummary(directory, id, fullOutput, summaryText, maxStoredByt
 }
 async function loadFullOutput(directory, id) {
   const sanitizedId = sanitizeSummaryId(id);
-  const relativePath = path39.join("summaries", `${sanitizedId}.json`);
+  const relativePath = path40.join("summaries", `${sanitizedId}.json`);
   validateSwarmPath(directory, relativePath);
   const content = await readSwarmFileAsync(directory, relativePath);
   if (content === null) {
@@ -54177,7 +54234,7 @@ var init_retrieve = __esm(() => {
 
 // src/commands/rollback.ts
 import * as fs27 from "node:fs";
-import * as path40 from "node:path";
+import * as path41 from "node:path";
 async function handleRollbackCommand(directory, args2) {
   const phaseArg = args2[0];
   if (!phaseArg) {
@@ -54242,8 +54299,8 @@ async function handleRollbackCommand(directory, args2) {
     if (EXCLUDE_FILES.has(file3) || file3.startsWith("plan-ledger.archived-")) {
       continue;
     }
-    const src = path40.join(checkpointDir, file3);
-    const dest = path40.join(swarmDir, file3);
+    const src = path41.join(checkpointDir, file3);
+    const dest = path41.join(swarmDir, file3);
     try {
       fs27.cpSync(src, dest, { recursive: true, force: true });
       successes.push(file3);
@@ -54262,12 +54319,12 @@ async function handleRollbackCommand(directory, args2) {
     ].join(`
 `);
   }
-  const existingLedgerPath = path40.join(swarmDir, "plan-ledger.jsonl");
+  const existingLedgerPath = path41.join(swarmDir, "plan-ledger.jsonl");
   if (fs27.existsSync(existingLedgerPath)) {
     fs27.unlinkSync(existingLedgerPath);
   }
   try {
-    const planJsonPath = path40.join(swarmDir, "plan.json");
+    const planJsonPath = path41.join(swarmDir, "plan.json");
     if (fs27.existsSync(planJsonPath)) {
       const planRaw = fs27.readFileSync(planJsonPath, "utf-8");
       const plan = PlanSchema.parse(JSON.parse(planRaw));
@@ -54345,9 +54402,9 @@ async function handleSimulateCommand(directory, args2) {
   const report = reportLines.filter(Boolean).join(`
 `);
   const fs28 = await import("node:fs/promises");
-  const path41 = await import("node:path");
-  const reportPath = path41.join(directory, ".swarm", "simulate-report.md");
-  await fs28.mkdir(path41.dirname(reportPath), { recursive: true });
+  const path42 = await import("node:path");
+  const reportPath = path42.join(directory, ".swarm", "simulate-report.md");
+  await fs28.mkdir(path42.dirname(reportPath), { recursive: true });
   await fs28.writeFile(reportPath, report, "utf-8");
   return `${darkMatterPairs.length} hidden coupling pairs detected`;
 }
@@ -54366,7 +54423,7 @@ async function handleSpecifyCommand(_directory, args2) {
 
 // src/services/compaction-service.ts
 import * as fs28 from "node:fs";
-import * as path41 from "node:path";
+import * as path42 from "node:path";
 function makeInitialState() {
   return {
     lastObservationAt: 0,
@@ -54388,7 +54445,7 @@ function getSessionState(sessionId) {
 }
 function appendSnapshot(directory, tier, budgetPct, message) {
   try {
-    const snapshotPath = path41.join(directory, ".swarm", "context-snapshot.md");
+    const snapshotPath = path42.join(directory, ".swarm", "context-snapshot.md");
     const timestamp = new Date().toISOString();
     const entry = `
 ## [${tier.toUpperCase()}] ${timestamp} — ${budgetPct.toFixed(1)}% used
@@ -58769,7 +58826,7 @@ COVERAGE REPORTING:
 
 // src/agents/index.ts
 import { mkdir as mkdir6, writeFile as writeFile6 } from "node:fs/promises";
-import * as path42 from "node:path";
+import * as path43 from "node:path";
 function stripSwarmPrefix(agentName, swarmPrefix) {
   if (!swarmPrefix || !agentName)
     return agentName;
@@ -59080,14 +59137,14 @@ function getAgentConfigs(config3, directory, sessionId) {
   }));
   if (directory) {
     const sid = sessionId ?? `init-${Date.now()}`;
-    const evidenceDir = path42.join(directory, ".swarm", "evidence");
+    const evidenceDir = path43.join(directory, ".swarm", "evidence");
     const filename = `agent-tools-${sid}.json`;
     const snapshotData = JSON.stringify({
       sessionId: sid,
       generatedAt: new Date().toISOString(),
       agents: agentToolSnapshot
     }, null, 2);
-    mkdir6(evidenceDir, { recursive: true }).then(() => writeFile6(path42.join(evidenceDir, filename), snapshotData)).catch(() => {});
+    mkdir6(evidenceDir, { recursive: true }).then(() => writeFile6(path43.join(evidenceDir, filename), snapshotData)).catch(() => {});
   }
   return result;
 }
@@ -59113,13 +59170,13 @@ __export(exports_evidence_summary_integration, {
   EvidenceSummaryIntegration: () => EvidenceSummaryIntegration
 });
 import { existsSync as existsSync24, mkdirSync as mkdirSync14, writeFileSync as writeFileSync6 } from "node:fs";
-import * as path43 from "node:path";
+import * as path44 from "node:path";
 function persistSummary(projectDir, artifact, filename) {
-  const swarmPath = path43.join(projectDir, ".swarm");
+  const swarmPath = path44.join(projectDir, ".swarm");
   if (!existsSync24(swarmPath)) {
     mkdirSync14(swarmPath, { recursive: true });
   }
-  const artifactPath = path43.join(swarmPath, filename);
+  const artifactPath = path44.join(swarmPath, filename);
   const content = JSON.stringify(artifact, null, 2);
   writeFileSync6(artifactPath, content, "utf-8");
   log("[EvidenceSummaryIntegration] Summary persisted", {
@@ -59238,7 +59295,7 @@ __export(exports_status_artifact, {
   AutomationStatusArtifact: () => AutomationStatusArtifact
 });
 import * as fs30 from "node:fs";
-import * as path45 from "node:path";
+import * as path46 from "node:path";
 function createEmptySnapshot(mode, capabilities) {
   return {
     timestamp: Date.now(),
@@ -59297,7 +59354,7 @@ class AutomationStatusArtifact {
     });
   }
   getFilePath() {
-    return path45.join(this.swarmDir, this.filename);
+    return path46.join(this.swarmDir, this.filename);
   }
   load() {
     const filePath = this.getFilePath();
@@ -59710,12 +59767,12 @@ __export(exports_review_receipt, {
 });
 import * as crypto5 from "node:crypto";
 import * as fs34 from "node:fs";
-import * as path46 from "node:path";
+import * as path47 from "node:path";
 function resolveReceiptsDir(directory) {
-  return path46.join(directory, ".swarm", "review-receipts");
+  return path47.join(directory, ".swarm", "review-receipts");
 }
 function resolveReceiptIndexPath(directory) {
-  return path46.join(resolveReceiptsDir(directory), "index.json");
+  return path47.join(resolveReceiptsDir(directory), "index.json");
 }
 function buildReceiptFilename(id, date9) {
   const dateStr = date9.toISOString().slice(0, 10);
@@ -59754,7 +59811,7 @@ async function readReceiptIndex(directory) {
 }
 async function writeReceiptIndex(directory, index) {
   const indexPath = resolveReceiptIndexPath(directory);
-  const dir = path46.dirname(indexPath);
+  const dir = path47.dirname(indexPath);
   await fs34.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");
@@ -59765,7 +59822,7 @@ async function persistReviewReceipt(directory, receipt) {
   await fs34.promises.mkdir(receiptsDir, { recursive: true });
   const now = new Date(receipt.reviewed_at);
   const filename = buildReceiptFilename(receipt.id, now);
-  const receiptPath = path46.join(receiptsDir, filename);
+  const receiptPath = path47.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);
@@ -59787,7 +59844,7 @@ async function readReceiptById(directory, receiptId) {
   const entry = index.entries.find((e) => e.id === receiptId);
   if (!entry)
     return null;
-  const receiptPath = path46.join(resolveReceiptsDir(directory), entry.filename);
+  const receiptPath = path47.join(resolveReceiptsDir(directory), entry.filename);
   try {
     const content = await fs34.promises.readFile(receiptPath, "utf-8");
     return JSON.parse(content);
@@ -59800,7 +59857,7 @@ 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 = path46.join(resolveReceiptsDir(directory), entry.filename);
+    const receiptPath = path47.join(resolveReceiptsDir(directory), entry.filename);
     try {
       const content = await fs34.promises.readFile(receiptPath, "utf-8");
       receipts.push(JSON.parse(content));
@@ -59813,7 +59870,7 @@ 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 = path46.join(resolveReceiptsDir(directory), entry.filename);
+    const receiptPath = path47.join(resolveReceiptsDir(directory), entry.filename);
     try {
       const content = await fs34.promises.readFile(receiptPath, "utf-8");
       receipts.push(JSON.parse(content));
@@ -61401,11 +61458,11 @@ ${JSON.stringify(symbolNames, null, 2)}`);
         throw toThrow;
       }, "quit_");
       var scriptDirectory = "";
-      function locateFile(path57) {
+      function locateFile(path58) {
         if (Module["locateFile"]) {
-          return Module["locateFile"](path57, scriptDirectory);
+          return Module["locateFile"](path58, scriptDirectory);
         }
-        return scriptDirectory + path57;
+        return scriptDirectory + path58;
       }
       __name(locateFile, "locateFile");
       var readAsync, readBinary;
@@ -63154,13 +63211,13 @@ __export(exports_runtime, {
   getInitializedLanguages: () => getInitializedLanguages,
   clearParserCache: () => clearParserCache
 });
-import * as path57 from "node:path";
+import * as path58 from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 async function initTreeSitter() {
   if (treeSitterInitialized) {
     return;
   }
-  const thisDir = path57.dirname(fileURLToPath2(import.meta.url));
+  const thisDir = path58.dirname(fileURLToPath2(import.meta.url));
   const isSource = thisDir.replace(/\\/g, "/").endsWith("/src/lang");
   if (isSource) {
     await Parser.init();
@@ -63168,7 +63225,7 @@ async function initTreeSitter() {
     const grammarsDir = getGrammarsDirAbsolute();
     await Parser.init({
       locateFile(scriptName) {
-        return path57.join(grammarsDir, scriptName);
+        return path58.join(grammarsDir, scriptName);
       }
     });
   }
@@ -63189,11 +63246,11 @@ function getWasmFileName(languageId) {
   return `tree-sitter-${sanitized}.wasm`;
 }
 function getGrammarsDirAbsolute() {
-  const thisDir = path57.dirname(fileURLToPath2(import.meta.url));
+  const thisDir = path58.dirname(fileURLToPath2(import.meta.url));
   const normalized = thisDir.replace(/\\/g, "/");
   const isSource = normalized.endsWith("/src/lang");
   const isCliBundle = normalized.endsWith("/cli");
-  return isSource ? path57.join(thisDir, "grammars") : isCliBundle ? path57.join(thisDir, "..", "lang", "grammars") : path57.join(thisDir, "lang", "grammars");
+  return isSource ? path58.join(thisDir, "grammars") : isCliBundle ? path58.join(thisDir, "..", "lang", "grammars") : path58.join(thisDir, "lang", "grammars");
 }
 async function loadGrammar(languageId) {
   if (typeof languageId !== "string" || languageId.length > 100) {
@@ -63209,7 +63266,7 @@ async function loadGrammar(languageId) {
   await initTreeSitter();
   const parser = new Parser;
   const wasmFileName = getWasmFileName(normalizedId);
-  const wasmPath = path57.join(getGrammarsDirAbsolute(), wasmFileName);
+  const wasmPath = path58.join(getGrammarsDirAbsolute(), wasmFileName);
   const { existsSync: existsSync30 } = await import("node:fs");
   if (!existsSync30(wasmPath)) {
     throw new Error(`Grammar file not found for ${languageId}: ${wasmPath}
@@ -63244,7 +63301,7 @@ async function isGrammarAvailable(languageId) {
   }
   try {
     const wasmFileName = getWasmFileName(normalizedId);
-    const wasmPath = path57.join(getGrammarsDirAbsolute(), wasmFileName);
+    const wasmPath = path58.join(getGrammarsDirAbsolute(), wasmFileName);
     const { statSync: statSync18 } = await import("node:fs");
     statSync18(wasmPath);
     return true;
@@ -63303,13 +63360,13 @@ __export(exports_doc_scan, {
 import * as crypto7 from "node:crypto";
 import * as fs43 from "node:fs";
 import { mkdir as mkdir9, readFile as readFile8, writeFile as writeFile8 } from "node:fs/promises";
-import * as path59 from "node:path";
+import * as path60 from "node:path";
 function normalizeSeparators(filePath) {
   return filePath.replace(/\\/g, "/");
 }
 function matchesDocPattern(filePath, patterns) {
   const normalizedPath = normalizeSeparators(filePath);
-  const basename8 = path59.basename(filePath);
+  const basename8 = path60.basename(filePath);
   for (const pattern of patterns) {
     if (!pattern.includes("/") && !pattern.includes("\\")) {
       if (basename8 === pattern) {
@@ -63365,7 +63422,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 = path59.join(directory, ".swarm", "doc-manifest.json");
+  const manifestPath = path60.join(directory, ".swarm", "doc-manifest.json");
   const defaultPatterns = DocsConfigSchema.parse({}).doc_patterns;
   const extraPatterns = [
     "ARCHITECTURE.md",
@@ -63382,7 +63439,7 @@ async function scanDocIndex(directory) {
       let cacheValid = true;
       for (const file3 of existingManifest.files) {
         try {
-          const fullPath = path59.join(directory, file3.path);
+          const fullPath = path60.join(directory, file3.path);
           const stat3 = fs43.statSync(fullPath);
           if (stat3.mtimeMs > file3.mtime) {
             cacheValid = false;
@@ -63412,7 +63469,7 @@ async function scanDocIndex(directory) {
   }
   const entries = rawEntries.filter((e) => typeof e === "string");
   for (const entry of entries) {
-    const fullPath = path59.join(directory, entry);
+    const fullPath = path60.join(directory, entry);
     let stat3;
     try {
       stat3 = fs43.statSync(fullPath);
@@ -63448,7 +63505,7 @@ async function scanDocIndex(directory) {
     } catch {
       continue;
     }
-    const { title, summary } = extractTitleAndSummary(content, path59.basename(entry));
+    const { title, summary } = extractTitleAndSummary(content, path60.basename(entry));
     const lineCount = content.split(`
 `).length;
     discoveredFiles.push({
@@ -63474,7 +63531,7 @@ async function scanDocIndex(directory) {
     files: discoveredFiles
   };
   try {
-    await mkdir9(path59.dirname(manifestPath), { recursive: true });
+    await mkdir9(path60.dirname(manifestPath), { recursive: true });
     await writeFile8(manifestPath, JSON.stringify(manifest, null, 2), "utf-8");
   } catch {}
   return { manifest, cached: false };
@@ -63513,7 +63570,7 @@ function extractConstraintsFromContent(content) {
   return constraints;
 }
 async function extractDocConstraints(directory, taskFiles, taskDescription) {
-  const manifestPath = path59.join(directory, ".swarm", "doc-manifest.json");
+  const manifestPath = path60.join(directory, ".swarm", "doc-manifest.json");
   let manifest;
   try {
     const content = await readFile8(manifestPath, "utf-8");
@@ -63539,7 +63596,7 @@ async function extractDocConstraints(directory, taskFiles, taskDescription) {
     }
     let fullContent;
     try {
-      fullContent = await readFile8(path59.join(directory, docFile.path), "utf-8");
+      fullContent = await readFile8(path60.join(directory, docFile.path), "utf-8");
     } catch {
       skippedCount++;
       continue;
@@ -63562,7 +63619,7 @@ async function extractDocConstraints(directory, taskFiles, taskDescription) {
           tier: "swarm",
           lesson: constraint,
           category: "architecture",
-          tags: ["doc-scan", path59.basename(docFile.path)],
+          tags: ["doc-scan", path60.basename(docFile.path)],
           scope: "global",
           confidence: 0.5,
           status: "candidate",
@@ -63635,7 +63692,7 @@ var init_doc_scan = __esm(() => {
         }
       } catch {}
       if (force) {
-        const manifestPath = path59.join(directory, ".swarm", "doc-manifest.json");
+        const manifestPath = path60.join(directory, ".swarm", "doc-manifest.json");
         try {
           fs43.unlinkSync(manifestPath);
         } catch {}
@@ -63826,9 +63883,9 @@ __export(exports_curator_drift, {
   buildDriftInjectionText: () => buildDriftInjectionText
 });
 import * as fs46 from "node:fs";
-import * as path62 from "node:path";
+import * as path63 from "node:path";
 async function readPriorDriftReports(directory) {
-  const swarmDir = path62.join(directory, ".swarm");
+  const swarmDir = path63.join(directory, ".swarm");
   const entries = await fs46.promises.readdir(swarmDir).catch(() => null);
   if (entries === null)
     return [];
@@ -63855,7 +63912,7 @@ async function readPriorDriftReports(directory) {
 async function writeDriftReport(directory, report) {
   const filename = `${DRIFT_REPORT_PREFIX}${report.phase}.json`;
   const filePath = validateSwarmPath(directory, filename);
-  const swarmDir = path62.dirname(filePath);
+  const swarmDir = path63.dirname(filePath);
   await fs46.promises.mkdir(swarmDir, { recursive: true });
   try {
     await fs46.promises.writeFile(filePath, JSON.stringify(report, null, 2), "utf-8");
@@ -63991,7 +64048,7 @@ var init_curator_drift = __esm(() => {
 init_package();
 init_agents2();
 import * as fs87 from "node:fs";
-import * as path105 from "node:path";
+import * as path106 from "node:path";
 
 // src/background/index.ts
 init_event_bus();
@@ -64002,7 +64059,7 @@ init_manager3();
 init_manager();
 init_utils();
 import * as fs29 from "node:fs";
-import * as path44 from "node:path";
+import * as path45 from "node:path";
 
 class PlanSyncWorker {
   directory;
@@ -64026,10 +64083,10 @@ class PlanSyncWorker {
     this.onSyncComplete = options.onSyncComplete;
   }
   getSwarmDir() {
-    return path44.resolve(this.directory, ".swarm");
+    return path45.resolve(this.directory, ".swarm");
   }
   getPlanJsonPath() {
-    return path44.join(this.getSwarmDir(), "plan.json");
+    return path45.join(this.getSwarmDir(), "plan.json");
   }
   start() {
     if (this.disposed) {
@@ -64248,8 +64305,8 @@ class PlanSyncWorker {
   checkForUnauthorizedWrite() {
     try {
       const swarmDir = this.getSwarmDir();
-      const planJsonPath = path44.join(swarmDir, "plan.json");
-      const markerPath = path44.join(swarmDir, ".plan-write-marker");
+      const planJsonPath = path45.join(swarmDir, "plan.json");
+      const markerPath = path45.join(swarmDir, ".plan-write-marker");
       const planStats = fs29.statSync(planJsonPath);
       const planMtimeMs = Math.floor(planStats.mtimeMs);
       const markerContent = fs29.readFileSync(markerPath, "utf8");
@@ -64486,11 +64543,11 @@ async function doFlush(directory) {
     const activitySection = renderActivitySection();
     const updated = replaceOrAppendSection(existing, "## Agent Activity", activitySection);
     const flushedCount = swarmState.pendingEvents;
-    const path46 = nodePath2.join(directory, ".swarm", "context.md");
-    const tempPath = `${path46}.tmp`;
+    const path47 = nodePath2.join(directory, ".swarm", "context.md");
+    const tempPath = `${path47}.tmp`;
     try {
       await Bun.write(tempPath, updated);
-      renameSync11(tempPath, path46);
+      renameSync11(tempPath, path47);
     } catch (writeError) {
       try {
         unlinkSync8(tempPath);
@@ -64541,7 +64598,7 @@ ${content.substring(endIndex + 1)}`;
 init_manager();
 init_utils2();
 import * as fs31 from "node:fs";
-import { join as join42 } from "node:path";
+import { join as join43 } from "node:path";
 function createCompactionCustomizerHook(config3, directory) {
   const enabled = config3.hooks?.compaction !== false;
   if (!enabled) {
@@ -64586,7 +64643,7 @@ function createCompactionCustomizerHook(config3, directory) {
         }
       }
       try {
-        const summariesDir = join42(directory, ".swarm", "summaries");
+        const summariesDir = join43(directory, ".swarm", "summaries");
         const files = await fs31.promises.readdir(summariesDir);
         if (files.length > 0) {
           const count = files.length;
@@ -65851,7 +65908,7 @@ init_schema();
 init_manager();
 init_curator();
 init_utils2();
-import * as path47 from "node:path";
+import * as path48 from "node:path";
 function createPhaseMonitorHook(directory, preflightManager, curatorRunner, delegateFactory) {
   let lastKnownPhase = null;
   const handler = async (input, _output) => {
@@ -65871,9 +65928,9 @@ function createPhaseMonitorHook(directory, preflightManager, curatorRunner, dele
           const llmDelegate = delegateFactory?.(sessionId);
           const initResult = await runner(directory, curatorConfig, llmDelegate);
           if (initResult.briefing) {
-            const briefingPath = path47.join(directory, ".swarm", "curator-briefing.md");
+            const briefingPath = path48.join(directory, ".swarm", "curator-briefing.md");
             const { mkdir: mkdir7, writeFile: writeFile7 } = await import("node:fs/promises");
-            await mkdir7(path47.dirname(briefingPath), { recursive: true });
+            await mkdir7(path48.dirname(briefingPath), { recursive: true });
             await writeFile7(briefingPath, initResult.briefing, "utf-8");
             const { buildApprovedReceipt: buildApprovedReceipt2, persistReviewReceipt: persistReviewReceipt2 } = await Promise.resolve().then(() => (init_review_receipt(), exports_review_receipt));
             const initReceipt = buildApprovedReceipt2({
@@ -65998,7 +66055,7 @@ ${originalText}`;
 }
 // src/hooks/repo-graph-builder.ts
 init_constants();
-import * as path50 from "node:path";
+import * as path51 from "node:path";
 
 // src/tools/repo-graph.ts
 init_utils2();
@@ -66007,14 +66064,14 @@ init_path_security();
 import * as fsSync2 from "node:fs";
 import { constants as constants3, existsSync as existsSync28, realpathSync as realpathSync6 } from "node:fs";
 import * as fsPromises3 from "node:fs/promises";
-import * as path49 from "node:path";
+import * as path50 from "node:path";
 
 // src/tools/symbols.ts
 init_zod();
 init_create_tool();
 init_path_security();
 import * as fs35 from "node:fs";
-import * as path48 from "node:path";
+import * as path49 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) {
@@ -66031,11 +66088,11 @@ function containsWindowsAttacks(str) {
 }
 function isPathInWorkspace(filePath, workspace) {
   try {
-    const resolvedPath = path48.resolve(workspace, filePath);
+    const resolvedPath = path49.resolve(workspace, filePath);
     const realWorkspace = fs35.realpathSync(workspace);
     const realResolvedPath = fs35.realpathSync(resolvedPath);
-    const relativePath = path48.relative(realWorkspace, realResolvedPath);
-    if (relativePath.startsWith("..") || path48.isAbsolute(relativePath)) {
+    const relativePath = path49.relative(realWorkspace, realResolvedPath);
+    if (relativePath.startsWith("..") || path49.isAbsolute(relativePath)) {
       return false;
     }
     return true;
@@ -66047,7 +66104,7 @@ function validatePathForRead(filePath, workspace) {
   return isPathInWorkspace(filePath, workspace);
 }
 function extractTSSymbols(filePath, cwd) {
-  const fullPath = path48.join(cwd, filePath);
+  const fullPath = path49.join(cwd, filePath);
   if (!validatePathForRead(fullPath, cwd)) {
     return [];
   }
@@ -66199,7 +66256,7 @@ function extractTSSymbols(filePath, cwd) {
   });
 }
 function extractPythonSymbols(filePath, cwd) {
-  const fullPath = path48.join(cwd, filePath);
+  const fullPath = path49.join(cwd, filePath);
   if (!validatePathForRead(fullPath, cwd)) {
     return [];
   }
@@ -66282,7 +66339,7 @@ var symbols = createSwarmTool({
       }, null, 2);
     }
     const cwd = directory;
-    const ext = path48.extname(file3);
+    const ext = path49.extname(file3);
     if (containsControlChars(file3)) {
       return JSON.stringify({
         file: file3,
@@ -66346,7 +66403,7 @@ var symbols = createSwarmTool({
 var WINDOWS_RENAME_MAX_RETRIES = 3;
 var WINDOWS_RENAME_RETRY_DELAY_MS = 50;
 function normalizeGraphPath(filePath) {
-  return path49.normalize(filePath).replace(/\\/g, "/");
+  return path50.normalize(filePath).replace(/\\/g, "/");
 }
 var REPO_GRAPH_FILENAME = "repo-graph.json";
 var GRAPH_SCHEMA_VERSION = "1.0.0";
@@ -66455,8 +66512,8 @@ function resolveModuleSpecifier(workspaceRoot, sourceFile, specifier) {
   }
   try {
     if (specifier.startsWith(".")) {
-      const sourceDir = path49.dirname(sourceFile);
-      let resolved = path49.resolve(sourceDir, specifier);
+      const sourceDir = path50.dirname(sourceFile);
+      let resolved = path50.resolve(sourceDir, specifier);
       let realResolved;
       try {
         realResolved = realpathSync6(resolved);
@@ -66467,7 +66524,7 @@ function resolveModuleSpecifier(workspaceRoot, sourceFile, specifier) {
       try {
         realRoot = realpathSync6(workspaceRoot);
       } catch {
-        realRoot = path49.normalize(workspaceRoot);
+        realRoot = path50.normalize(workspaceRoot);
       }
       if (!existsSync28(resolved)) {
         const EXTENSIONS = [
@@ -66499,9 +66556,9 @@ function resolveModuleSpecifier(workspaceRoot, sourceFile, specifier) {
           return null;
         }
       }
-      const normalizedResolved = path49.normalize(realResolved);
-      const normalizedRoot = path49.normalize(realRoot);
-      if (!normalizedResolved.startsWith(normalizedRoot + path49.sep) && normalizedResolved !== normalizedRoot) {
+      const normalizedResolved = path50.normalize(realResolved);
+      const normalizedRoot = path50.normalize(realRoot);
+      if (!normalizedResolved.startsWith(normalizedRoot + path50.sep) && normalizedResolved !== normalizedRoot) {
         return null;
       }
       return resolved;
@@ -66514,7 +66571,7 @@ function resolveModuleSpecifier(workspaceRoot, sourceFile, specifier) {
 function createEmptyGraph(workspaceRoot) {
   return {
     schema_version: GRAPH_SCHEMA_VERSION,
-    workspaceRoot: path49.normalize(workspaceRoot),
+    workspaceRoot: path50.normalize(workspaceRoot),
     nodes: {},
     edges: [],
     metadata: {
@@ -66548,10 +66605,10 @@ function addEdge(graph, edge) {
   }
 }
 function getCachedGraph(workspace) {
-  return graphCache.get(path49.normalize(workspace));
+  return graphCache.get(path50.normalize(workspace));
 }
 function setCachedGraph(workspace, graph, mtime) {
-  const normalized = path49.normalize(workspace);
+  const normalized = path50.normalize(workspace);
   graphCache.set(normalized, graph);
   dirtyFlags.set(normalized, false);
   if (mtime !== undefined) {
@@ -66559,10 +66616,10 @@ function setCachedGraph(workspace, graph, mtime) {
   }
 }
 function isDirty(workspace) {
-  return dirtyFlags.get(path49.normalize(workspace)) ?? false;
+  return dirtyFlags.get(path50.normalize(workspace)) ?? false;
 }
 function clearCache(workspace) {
-  const normalized = path49.normalize(workspace);
+  const normalized = path50.normalize(workspace);
   graphCache.delete(normalized);
   dirtyFlags.delete(normalized);
   mtimeCache.delete(normalized);
@@ -66575,7 +66632,7 @@ function getGraphPath(workspace) {
 }
 async function loadGraph(workspace) {
   validateWorkspace(workspace);
-  const normalized = path49.normalize(workspace);
+  const normalized = path50.normalize(workspace);
   const cached3 = getCachedGraph(normalized);
   if (cached3 && !isDirty(normalized)) {
     try {
@@ -66669,28 +66726,28 @@ async function saveGraph(workspace, graph, options) {
   if (!Array.isArray(graph.edges)) {
     throw new Error("Graph must have edges array");
   }
-  const normalizedWorkspace = path49.normalize(workspace);
+  const normalizedWorkspace = path50.normalize(workspace);
   let realWorkspace;
   try {
     realWorkspace = realpathSync6(workspace);
   } catch {
     realWorkspace = normalizedWorkspace;
   }
-  const normalizedGraphRoot = path49.normalize(graph.workspaceRoot);
+  const normalizedGraphRoot = path50.normalize(graph.workspaceRoot);
   let realGraphRoot;
   try {
     realGraphRoot = realpathSync6(graph.workspaceRoot);
   } catch {
     realGraphRoot = normalizedGraphRoot;
   }
-  if (path49.normalize(realWorkspace) !== path49.normalize(realGraphRoot)) {
+  if (path50.normalize(realWorkspace) !== path50.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 fsPromises3.mkdir(path49.dirname(tempPath), { recursive: true });
+  await fsPromises3.mkdir(path50.dirname(tempPath), { recursive: true });
   let lastError = null;
   try {
     if (options?.createAtomic) {
@@ -66821,7 +66878,7 @@ function findSourceFiles(dir, stats) {
       stats.skippedDirs++;
       continue;
     }
-    const fullPath = path49.join(dir, entry);
+    const fullPath = path50.join(dir, entry);
     let stat3;
     try {
       stat3 = fsSync2.statSync(fullPath);
@@ -66832,7 +66889,7 @@ function findSourceFiles(dir, stats) {
       const subFiles = findSourceFiles(fullPath, stats);
       files.push(...subFiles);
     } else if (stat3.isFile()) {
-      const ext = path49.extname(fullPath).toLowerCase();
+      const ext = path50.extname(fullPath).toLowerCase();
       if (SUPPORTED_EXTENSIONS.includes(ext)) {
         files.push(fullPath);
       }
@@ -66841,11 +66898,11 @@ function findSourceFiles(dir, stats) {
   return files;
 }
 function toModuleName(filePath, workspaceRoot) {
-  const relative9 = path49.relative(workspaceRoot, filePath);
-  return relative9.split(path49.sep).join("/");
+  const relative9 = path50.relative(workspaceRoot, filePath);
+  return relative9.split(path50.sep).join("/");
 }
 function getLanguage(filePath) {
-  const ext = path49.extname(filePath).toLowerCase();
+  const ext = path50.extname(filePath).toLowerCase();
   return EXTENSION_TO_LANGUAGE[ext] ?? "unknown";
 }
 function isBinaryContent(content) {
@@ -66858,7 +66915,7 @@ function buildWorkspaceGraph(workspaceRoot, options) {
   validateWorkspace(workspaceRoot);
   const maxFileSize = options?.maxFileSizeBytes ?? 1024 * 1024;
   const maxFiles = options?.maxFiles ?? 1e4;
-  const absoluteRoot = path49.resolve(workspaceRoot);
+  const absoluteRoot = path50.resolve(workspaceRoot);
   if (!existsSync28(absoluteRoot)) {
     throw new Error(`Workspace directory does not exist: ${workspaceRoot}`);
   }
@@ -66899,16 +66956,16 @@ function buildWorkspaceGraph(workspaceRoot, options) {
       continue;
     }
     stats.filesScanned++;
-    const ext = path49.extname(filePath).toLowerCase();
+    const ext = path50.extname(filePath).toLowerCase();
     let exports = [];
     let parsedImports = [];
     try {
       if ([".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs"].includes(ext)) {
-        const relativePath = path49.relative(absoluteRoot, filePath);
+        const relativePath = path50.relative(absoluteRoot, filePath);
         const symbols2 = extractTSSymbols(relativePath, absoluteRoot);
         exports = symbols2.filter((s) => s.exported).map((s) => s.name);
       } else if (ext === ".py") {
-        const relativePath = path49.relative(absoluteRoot, filePath);
+        const relativePath = path50.relative(absoluteRoot, filePath);
         const symbols2 = extractPythonSymbols(relativePath, absoluteRoot);
         exports = symbols2.filter((s) => s.exported).map((s) => s.name);
       }
@@ -66965,15 +67022,15 @@ function scanFile(filePath, absoluteRoot, maxFileSize) {
   if (isBinaryContent(content)) {
     return { node: null, edges: [] };
   }
-  const ext = path49.extname(filePath).toLowerCase();
+  const ext = path50.extname(filePath).toLowerCase();
   let exports = [];
   try {
     if ([".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs"].includes(ext)) {
-      const relativePath = path49.relative(absoluteRoot, filePath);
+      const relativePath = path50.relative(absoluteRoot, filePath);
       const symbols2 = extractTSSymbols(relativePath, absoluteRoot);
       exports = symbols2.filter((s) => s.exported).map((s) => s.name);
     } else if (ext === ".py") {
-      const relativePath = path49.relative(absoluteRoot, filePath);
+      const relativePath = path50.relative(absoluteRoot, filePath);
       const symbols2 = extractPythonSymbols(relativePath, absoluteRoot);
       exports = symbols2.filter((s) => s.exported).map((s) => s.name);
     }
@@ -67017,7 +67074,7 @@ async function updateGraphForFiles(workspaceRoot, filePaths, options) {
     return graph2;
   }
   const graph = existingGraph;
-  const absoluteRoot = path49.resolve(workspaceRoot);
+  const absoluteRoot = path50.resolve(workspaceRoot);
   const maxFileSize = 1024 * 1024;
   const updatedPaths = new Set;
   for (const rawFilePath of filePaths) {
@@ -67130,7 +67187,7 @@ function createRepoGraphBuilderHook(workspaceRoot, deps) {
       if (!isSupportedSourceFile(filePath)) {
         return;
       }
-      const absoluteFilePath = path50.isAbsolute(filePath) ? filePath : path50.resolve(workspaceRoot, filePath);
+      const absoluteFilePath = path51.isAbsolute(filePath) ? filePath : path51.resolve(workspaceRoot, filePath);
       const normalizedAbsolute = absoluteFilePath.replace(/\\/g, "/");
       const normalizedWorkspace = workspaceRoot.replace(/\\/g, "/");
       if (!normalizedAbsolute.startsWith(`${normalizedWorkspace}/`) && normalizedAbsolute !== normalizedWorkspace) {
@@ -67138,7 +67195,7 @@ function createRepoGraphBuilderHook(workspaceRoot, deps) {
       }
       try {
         await _updateGraphForFiles(workspaceRoot, [absoluteFilePath]);
-        log(`[repo-graph] Incremental update for ${path50.basename(filePath)}`);
+        log(`[repo-graph] Incremental update for ${path51.basename(filePath)}`);
       } catch (error93) {
         const message = error93 instanceof Error ? error93.message : String(error93);
         error48(`[repo-graph] Incremental update failed: ${message}`);
@@ -67157,14 +67214,14 @@ init_manager2();
 init_detector();
 init_manager();
 import * as fs44 from "node:fs";
-import * as path60 from "node:path";
+import * as path61 from "node:path";
 
 // src/services/decision-drift-analyzer.ts
 init_utils2();
 init_manager();
 init_utils();
 import * as fs36 from "node:fs";
-import * as path51 from "node:path";
+import * as path52 from "node:path";
 var DEFAULT_DRIFT_CONFIG = {
   staleThresholdPhases: 1,
   detectContradictions: true,
@@ -67318,7 +67375,7 @@ async function analyzeDecisionDrift(directory, config3 = {}) {
         currentPhase = legacyPhase;
       }
     }
-    const contextPath = path51.join(directory, ".swarm", "context.md");
+    const contextPath = path52.join(directory, ".swarm", "context.md");
     let contextContent = "";
     try {
       if (fs36.existsSync(contextPath)) {
@@ -67457,7 +67514,7 @@ init_utils();
 init_constants();
 init_schema();
 import * as fs37 from "node:fs/promises";
-import * as path52 from "node:path";
+import * as path53 from "node:path";
 function safeGet(obj, key) {
   if (!obj || !Object.hasOwn(obj, key))
     return;
@@ -67689,23 +67746,18 @@ async function handleDebuggingSpiral(match, taskId, directory) {
   let eventLogged = false;
   let checkpointCreated = false;
   try {
-    const swarmDir = path52.join(directory, ".swarm");
+    const swarmDir = path53.join(directory, ".swarm");
     await fs37.mkdir(swarmDir, { recursive: true });
-    const eventsPath = path52.join(swarmDir, "events.jsonl");
+    const eventsPath = path53.join(swarmDir, "events.jsonl");
     await fs37.appendFile(eventsPath, `${formatDebuggingSpiralEvent(match, taskId)}
 `);
     eventLogged = true;
   } catch {}
   const checkpointLabel = `spiral-${taskId}-${Date.now()}`;
   try {
-    const { checkpoint: checkpoint2 } = await Promise.resolve().then(() => (init_checkpoint(), exports_checkpoint));
-    const result = await checkpoint2.execute({ action: "save", label: checkpointLabel }, { directory });
-    try {
-      const parsed = JSON.parse(result);
-      checkpointCreated = parsed.success === true;
-    } catch {
-      checkpointCreated = false;
-    }
+    const { saveCheckpointRecord: saveCheckpointRecord2 } = await Promise.resolve().then(() => (init_checkpoint(), exports_checkpoint));
+    const result = saveCheckpointRecord2(checkpointLabel, directory);
+    checkpointCreated = result.success === true;
   } catch {
     checkpointCreated = false;
   }
@@ -67831,7 +67883,7 @@ import * as fs41 from "node:fs";
 
 // src/graph/graph-builder.ts
 import * as fs39 from "node:fs";
-import * as path55 from "node:path";
+import * as path56 from "node:path";
 
 // node_modules/yocto-queue/index.js
 class Node {
@@ -67992,7 +68044,7 @@ function validateConcurrency(concurrency) {
 // src/graph/import-extractor.ts
 init_path_security();
 import * as fs38 from "node:fs";
-import * as path53 from "node:path";
+import * as path54 from "node:path";
 var SOURCE_EXTENSIONS2 = [
   ".ts",
   ".tsx",
@@ -68037,14 +68089,14 @@ function getLanguageFromExtension(ext) {
   return null;
 }
 function toRelForwardSlash(absPath, root) {
-  return path53.relative(root, absPath).replace(/\\/g, "/");
+  return path54.relative(root, absPath).replace(/\\/g, "/");
 }
 function tryResolveTSJS(rawModule, sourceFileAbs) {
   if (!rawModule.startsWith(".") && !rawModule.startsWith("/")) {
     return null;
   }
-  const sourceDir = path53.dirname(sourceFileAbs);
-  const baseAbs = path53.resolve(sourceDir, rawModule);
+  const sourceDir = path54.dirname(sourceFileAbs);
+  const baseAbs = path54.resolve(sourceDir, rawModule);
   const probe = (basePath) => {
     for (const ext of RESOLVE_EXTENSION_CANDIDATES) {
       const test = basePath + ext;
@@ -68055,7 +68107,7 @@ function tryResolveTSJS(rawModule, sourceFileAbs) {
       } catch {}
     }
     for (const indexFile of RESOLVE_INDEX_CANDIDATES) {
-      const test = path53.join(basePath, indexFile);
+      const test = path54.join(basePath, indexFile);
       try {
         const stat3 = fs38.statSync(test);
         if (stat3.isFile())
@@ -68085,13 +68137,13 @@ function tryResolvePython(rawModule, sourceFileAbs, workspaceRoot) {
   }
   const remainder = rawModule.slice(leadingDots).replace(/\./g, "/");
   const upDirs = "../".repeat(Math.max(0, leadingDots - 1));
-  const sourceDir = path53.dirname(sourceFileAbs);
-  const baseAbs = path53.resolve(sourceDir, upDirs + remainder);
+  const sourceDir = path54.dirname(sourceFileAbs);
+  const baseAbs = path54.resolve(sourceDir, upDirs + remainder);
   const accept = (test) => {
     try {
       const stat3 = fs38.statSync(test);
       if (stat3.isFile()) {
-        const rel = path53.relative(workspaceRoot, test).replace(/\\/g, "/");
+        const rel = path54.relative(workspaceRoot, test).replace(/\\/g, "/");
         if (rel.startsWith(".."))
           return null;
         return test;
@@ -68105,7 +68157,7 @@ function tryResolvePython(rawModule, sourceFileAbs, workspaceRoot) {
       return hit;
   }
   for (const indexFile of PY_INDEX_CANDIDATES) {
-    const hit = accept(path53.join(baseAbs, indexFile));
+    const hit = accept(path54.join(baseAbs, indexFile));
     if (hit)
       return hit;
   }
@@ -68476,7 +68528,7 @@ function parseRustUses(content) {
 }
 function extractImports2(opts) {
   const { absoluteFilePath, workspaceRoot } = opts;
-  const ext = path53.extname(absoluteFilePath).toLowerCase();
+  const ext = path54.extname(absoluteFilePath).toLowerCase();
   const language = getLanguageFromExtension(ext);
   if (!language)
     return [];
@@ -68527,9 +68579,9 @@ function extractImports2(opts) {
 }
 
 // src/graph/symbol-extractor.ts
-import * as path54 from "node:path";
+import * as path55 from "node:path";
 function extractExportedSymbols(relativeFilePath, workspaceRoot) {
-  const ext = path54.extname(relativeFilePath).toLowerCase();
+  const ext = path55.extname(relativeFilePath).toLowerCase();
   const language = getLanguageFromExtension(ext);
   if (!language)
     return [];
@@ -68618,15 +68670,15 @@ function findSourceFiles2(workspaceRoot, skipDirs = DEFAULT_SKIP_DIRS) {
       if (entry.isDirectory()) {
         if (skipDirs.has(entry.name))
           continue;
-        stack.push(path55.join(dir, entry.name));
+        stack.push(path56.join(dir, entry.name));
         continue;
       }
       if (!entry.isFile())
         continue;
-      const ext = path55.extname(entry.name).toLowerCase();
+      const ext = path56.extname(entry.name).toLowerCase();
       if (!SOURCE_EXT_SET.has(ext))
         continue;
-      out2.push(path55.join(dir, entry.name));
+      out2.push(path56.join(dir, entry.name));
     }
   }
   return out2;
@@ -68654,7 +68706,7 @@ async function buildRepoGraph(workspaceRoot, options = {}) {
   };
 }
 async function processFile(absoluteFilePath, workspaceRoot) {
-  const ext = path55.extname(absoluteFilePath).toLowerCase();
+  const ext = path56.extname(absoluteFilePath).toLowerCase();
   const language = getLanguageFromExtension(ext);
   if (!language)
     return null;
@@ -68674,7 +68726,7 @@ async function processFile(absoluteFilePath, workspaceRoot) {
   } catch {
     return null;
   }
-  const relPath = path55.relative(workspaceRoot, absoluteFilePath).replace(/\\/g, "/");
+  const relPath = path56.relative(workspaceRoot, absoluteFilePath).replace(/\\/g, "/");
   const imports = extractImports2({
     absoluteFilePath,
     workspaceRoot,
@@ -68916,10 +68968,10 @@ function formatSummary(opts) {
 // src/graph/graph-store.ts
 import * as crypto6 from "node:crypto";
 import * as fs40 from "node:fs";
-import * as path56 from "node:path";
+import * as path57 from "node:path";
 var SWARM_DIR = ".swarm";
 function getGraphPath2(workspaceRoot) {
-  return path56.join(workspaceRoot, SWARM_DIR, REPO_GRAPH_FILENAME2);
+  return path57.join(workspaceRoot, SWARM_DIR, REPO_GRAPH_FILENAME2);
 }
 function loadGraph2(workspaceRoot) {
   const file3 = getGraphPath2(workspaceRoot);
@@ -68941,7 +68993,7 @@ function loadGraph2(workspaceRoot) {
 }
 function saveGraph2(workspaceRoot, graph) {
   const file3 = getGraphPath2(workspaceRoot);
-  const dir = path56.dirname(file3);
+  const dir = path57.dirname(file3);
   try {
     const stat3 = fs40.lstatSync(dir);
     if (stat3.isSymbolicLink()) {
@@ -69047,7 +69099,7 @@ 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 path58 from "node:path";
+import * as path59 from "node:path";
 
 // src/diff/ast-diff.ts
 init_tree_sitter();
@@ -69794,17 +69846,17 @@ async function buildSemanticDiffBlock(directory, changedFiles, maxFiles = 10) {
     const fileConsumers = {};
     if (graph) {
       for (const f of filesToProcess) {
-        const relativePath = path58.isAbsolute(f) ? path58.relative(directory, f) : f;
+        const relativePath = path59.isAbsolute(f) ? path59.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 = path58.normalize(filePath);
-      const resolvedPath = path58.resolve(directory, normalizedPath);
-      const relativeToDir = path58.relative(directory, resolvedPath);
-      if (relativeToDir.startsWith("..") || path58.isAbsolute(relativeToDir)) {
+      const normalizedPath = path59.normalize(filePath);
+      const resolvedPath = path59.resolve(directory, normalizedPath);
+      const relativeToDir = path59.relative(directory, resolvedPath);
+      if (relativeToDir.startsWith("..") || path59.isAbsolute(relativeToDir)) {
         continue;
       }
       try {
@@ -69831,7 +69883,7 @@ async function buildSemanticDiffBlock(directory, changedFiles, maxFiles = 10) {
           stdio: "pipe",
           maxBuffer: 5 * 1024 * 1024
         }) : "";
-        const newContent = fs42.readFileSync(path58.join(directory, filePath), "utf-8");
+        const newContent = fs42.readFileSync(path59.join(directory, filePath), "utf-8");
         const astResult = await computeASTDiff(filePath, oldContent, newContent);
         if (astResult && (astResult.changes.length > 0 || astResult.error !== undefined)) {
           astDiffs.push(astResult);
@@ -70173,7 +70225,7 @@ function createSystemEnhancerHook(config3, directory) {
               await fs44.promises.writeFile(darkMatterPath, darkMatterReport, "utf-8");
               warn(`[system-enhancer] Dark matter scan complete: ${darkMatter.length} co-change patterns found`);
               try {
-                const projectName = path60.basename(path60.resolve(directory));
+                const projectName = path61.basename(path61.resolve(directory));
                 const knowledgeEntries = darkMatterToKnowledgeEntries2(darkMatter, projectName);
                 const knowledgePath = resolveSwarmKnowledgePath(directory);
                 const existingEntries = await readKnowledge(knowledgePath);
@@ -70372,7 +70424,7 @@ ${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 = path60.join(directory, ".swarm", "evidence", `${taskId_ccp}.json`);
+                const evidencePath = path61.join(directory, ".swarm", "evidence", `${taskId_ccp}.json`);
                 if (fs44.existsSync(evidencePath)) {
                   const evidenceContent = fs44.readFileSync(evidencePath, "utf-8");
                   const evidenceData = JSON.parse(evidenceContent);
@@ -71518,7 +71570,7 @@ init_hive_promoter();
 
 // src/hooks/incremental-verify.ts
 import * as fs45 from "node:fs";
-import * as path61 from "node:path";
+import * as path62 from "node:path";
 
 // src/hooks/spawn-helper.ts
 import * as child_process6 from "node:child_process";
@@ -71596,18 +71648,18 @@ function spawnAsync(command, cwd, timeoutMs) {
 // src/hooks/incremental-verify.ts
 var emittedSkipAdvisories = new Set;
 function detectPackageManager(projectDir) {
-  if (fs45.existsSync(path61.join(projectDir, "bun.lockb")))
+  if (fs45.existsSync(path62.join(projectDir, "bun.lockb")))
     return "bun";
-  if (fs45.existsSync(path61.join(projectDir, "pnpm-lock.yaml")))
+  if (fs45.existsSync(path62.join(projectDir, "pnpm-lock.yaml")))
     return "pnpm";
-  if (fs45.existsSync(path61.join(projectDir, "yarn.lock")))
+  if (fs45.existsSync(path62.join(projectDir, "yarn.lock")))
     return "yarn";
-  if (fs45.existsSync(path61.join(projectDir, "package-lock.json")))
+  if (fs45.existsSync(path62.join(projectDir, "package-lock.json")))
     return "npm";
   return "bun";
 }
 function detectTypecheckCommand(projectDir) {
-  const pkgPath = path61.join(projectDir, "package.json");
+  const pkgPath = path62.join(projectDir, "package.json");
   if (fs45.existsSync(pkgPath)) {
     try {
       const pkg = JSON.parse(fs45.readFileSync(pkgPath, "utf8"));
@@ -71624,8 +71676,8 @@ function detectTypecheckCommand(projectDir) {
         ...pkg.dependencies,
         ...pkg.devDependencies
       };
-      if (!deps?.typescript && !fs45.existsSync(path61.join(projectDir, "tsconfig.json"))) {}
-      const hasTSMarkers = deps?.typescript || fs45.existsSync(path61.join(projectDir, "tsconfig.json"));
+      if (!deps?.typescript && !fs45.existsSync(path62.join(projectDir, "tsconfig.json"))) {}
+      const hasTSMarkers = deps?.typescript || fs45.existsSync(path62.join(projectDir, "tsconfig.json"));
       if (hasTSMarkers) {
         return { command: ["npx", "tsc", "--noEmit"], language: "typescript" };
       }
@@ -71633,13 +71685,13 @@ function detectTypecheckCommand(projectDir) {
       return null;
     }
   }
-  if (fs45.existsSync(path61.join(projectDir, "go.mod"))) {
+  if (fs45.existsSync(path62.join(projectDir, "go.mod"))) {
     return { command: ["go", "vet", "./..."], language: "go" };
   }
-  if (fs45.existsSync(path61.join(projectDir, "Cargo.toml"))) {
+  if (fs45.existsSync(path62.join(projectDir, "Cargo.toml"))) {
     return { command: ["cargo", "check"], language: "rust" };
   }
-  if (fs45.existsSync(path61.join(projectDir, "pyproject.toml")) || fs45.existsSync(path61.join(projectDir, "requirements.txt")) || fs45.existsSync(path61.join(projectDir, "setup.py"))) {
+  if (fs45.existsSync(path62.join(projectDir, "pyproject.toml")) || fs45.existsSync(path62.join(projectDir, "requirements.txt")) || fs45.existsSync(path62.join(projectDir, "setup.py"))) {
     return { command: null, language: "python" };
   }
   try {
@@ -71989,7 +72041,7 @@ init_scope_persistence();
 init_state();
 init_delegation_gate();
 init_normalize_tool_name();
-import * as path63 from "node:path";
+import * as path64 from "node:path";
 var WRITE_TOOLS = new Set(WRITE_TOOL_NAMES);
 function createScopeGuardHook(config3, directory, injectAdvisory) {
   const enabled = config3.enabled ?? true;
@@ -72047,13 +72099,13 @@ function createScopeGuardHook(config3, directory, injectAdvisory) {
 }
 function isFileInScope(filePath, scopeEntries, directory) {
   const dir = directory ?? process.cwd();
-  const resolvedFile = path63.resolve(dir, filePath);
+  const resolvedFile = path64.resolve(dir, filePath);
   return scopeEntries.some((scope) => {
-    const resolvedScope = path63.resolve(dir, scope);
+    const resolvedScope = path64.resolve(dir, scope);
     if (resolvedFile === resolvedScope)
       return true;
-    const rel = path63.relative(resolvedScope, resolvedFile);
-    return rel.length > 0 && !rel.startsWith("..") && !path63.isAbsolute(rel);
+    const rel = path64.relative(resolvedScope, resolvedFile);
+    return rel.length > 0 && !rel.startsWith("..") && !path64.isAbsolute(rel);
   });
 }
 
@@ -72105,7 +72157,7 @@ function createSelfReviewHook(config3, injectAdvisory) {
 
 // src/hooks/slop-detector.ts
 import * as fs47 from "node:fs";
-import * as path64 from "node:path";
+import * as path65 from "node:path";
 var WRITE_EDIT_TOOLS = new Set([
   "write",
   "edit",
@@ -72155,7 +72207,7 @@ function walkFiles(dir, exts, deadline) {
         break;
       if (entry.isSymbolicLink())
         continue;
-      const full = path64.join(dir, entry.name);
+      const full = path65.join(dir, entry.name);
       if (entry.isDirectory()) {
         if (entry.name === "node_modules" || entry.name === ".git")
           continue;
@@ -72170,7 +72222,7 @@ function walkFiles(dir, exts, deadline) {
   return results;
 }
 function checkDeadExports(content, projectDir, startTime) {
-  const hasPackageJson = fs47.existsSync(path64.join(projectDir, "package.json"));
+  const hasPackageJson = fs47.existsSync(path65.join(projectDir, "package.json"));
   if (!hasPackageJson)
     return null;
   const exportMatches = content.matchAll(/^\+(?:export)\s+(?:function|class|const|type|interface)\s+(\w{3,})/gm);
@@ -72378,14 +72430,14 @@ function createSteeringConsumedHook(directory) {
 // src/hooks/trajectory-logger.ts
 init_manager2();
 import * as fs50 from "node:fs/promises";
-import * as path66 from "node:path";
+import * as path67 from "node:path";
 
 // src/prm/trajectory-store.ts
 init_utils2();
 import * as fs49 from "node:fs/promises";
-import * as path65 from "node:path";
+import * as path66 from "node:path";
 function getTrajectoryPath(sessionId, directory) {
-  const relativePath = path65.join("trajectories", `${sessionId}.jsonl`);
+  const relativePath = path66.join("trajectories", `${sessionId}.jsonl`);
   return validateSwarmPath(directory, relativePath);
 }
 var _inMemoryTrajectoryCache = new Map;
@@ -72404,7 +72456,7 @@ async function appendTrajectoryEntry(sessionId, entry, directory, maxLines = 100
       _inMemoryTrajectoryCache.set(sessionId, cached3);
     }
     const trajectoryPath = getTrajectoryPath(sessionId, directory);
-    await fs49.mkdir(path65.dirname(trajectoryPath), { recursive: true });
+    await fs49.mkdir(path66.dirname(trajectoryPath), { recursive: true });
     const line = `${JSON.stringify(entry)}
 `;
     await fs49.appendFile(trajectoryPath, line, "utf-8");
@@ -72443,7 +72495,7 @@ async function cleanupOldTrajectoryFiles(directory, maxAgeDays = 7) {
       for (const entry of entries) {
         if (!entry.isFile())
           continue;
-        const filePath = path65.join(dirPath, entry.name);
+        const filePath = path66.join(dirPath, entry.name);
         try {
           const stat4 = await fs49.stat(filePath);
           if (now - stat4.mtimeMs > cutoffMs) {
@@ -72635,10 +72687,10 @@ function createTrajectoryLoggerHook(config3, _directory) {
         elapsed_ms
       };
       const sanitized = sanitizeTaskId2(taskId);
-      const relativePath = path66.join("evidence", sanitized, "trajectory.jsonl");
+      const relativePath = path67.join("evidence", sanitized, "trajectory.jsonl");
       const trajectoryPath = validateSwarmPath(_directory, relativePath);
       try {
-        await fs50.mkdir(path66.dirname(trajectoryPath), { recursive: true });
+        await fs50.mkdir(path67.dirname(trajectoryPath), { recursive: true });
         const line = `${JSON.stringify(entry)}
 `;
         await fs50.appendFile(trajectoryPath, line, "utf-8");
@@ -73189,16 +73241,16 @@ init_telemetry();
 
 // src/prm/replay.ts
 import { promises as fs51 } from "node:fs";
-import path67 from "node:path";
+import path68 from "node:path";
 function isPathSafe2(targetPath, basePath) {
-  const resolvedTarget = path67.resolve(targetPath);
-  const resolvedBase = path67.resolve(basePath);
-  const rel = path67.relative(resolvedBase, resolvedTarget);
-  return !rel.startsWith("..") && !path67.isAbsolute(rel);
+  const resolvedTarget = path68.resolve(targetPath);
+  const resolvedBase = path68.resolve(basePath);
+  const rel = path68.relative(resolvedBase, resolvedTarget);
+  return !rel.startsWith("..") && !path68.isAbsolute(rel);
 }
 function isWithinReplaysDir(targetPath) {
-  const resolved = path67.resolve(targetPath);
-  const parts2 = resolved.split(path67.sep);
+  const resolved = path68.resolve(targetPath);
+  const parts2 = resolved.split(path68.sep);
   for (let i2 = 0;i2 < parts2.length - 1; i2++) {
     if (parts2[i2] === ".swarm" && parts2[i2 + 1] === "replays") {
       return true;
@@ -73211,10 +73263,10 @@ function sanitizeFilename(input) {
 }
 async function startReplayRecording(sessionID, directory) {
   try {
-    const replayDir = path67.join(directory, ".swarm", "replays");
+    const replayDir = path68.join(directory, ".swarm", "replays");
     const safeSessionID = sanitizeFilename(sessionID);
     const filename = `${safeSessionID}-${Date.now()}.jsonl`;
-    const filepath = path67.join(replayDir, filename);
+    const filepath = path68.join(replayDir, filename);
     if (!isPathSafe2(filepath, replayDir)) {
       console.warn(`[replay] Invalid path detected - path traversal attempt blocked for session ${sessionID}`);
       return null;
@@ -73587,7 +73639,7 @@ init_telemetry();
 init_dist();
 init_create_tool();
 import * as fs52 from "node:fs";
-import * as path68 from "node:path";
+import * as path69 from "node:path";
 init_path_security();
 var WINDOWS_RESERVED_NAMES2 = /^(con|prn|aux|nul|com[1-9]|lpt[1-9])(\.|:|$)/i;
 function containsWindowsAttacks2(str) {
@@ -73604,14 +73656,14 @@ function containsWindowsAttacks2(str) {
 }
 function isPathInWorkspace2(filePath, workspace) {
   try {
-    const resolvedPath = path68.resolve(workspace, filePath);
+    const resolvedPath = path69.resolve(workspace, filePath);
     if (!fs52.existsSync(resolvedPath)) {
       return true;
     }
     const realWorkspace = fs52.realpathSync(workspace);
     const realResolvedPath = fs52.realpathSync(resolvedPath);
-    const relativePath = path68.relative(realWorkspace, realResolvedPath);
-    if (relativePath.startsWith("..") || path68.isAbsolute(relativePath)) {
+    const relativePath = path69.relative(realWorkspace, realResolvedPath);
+    if (relativePath.startsWith("..") || path69.isAbsolute(relativePath)) {
       return false;
     }
     return true;
@@ -73620,7 +73672,7 @@ function isPathInWorkspace2(filePath, workspace) {
   }
 }
 function processFile2(file3, cwd, exportedOnly) {
-  const ext = path68.extname(file3);
+  const ext = path69.extname(file3);
   if (containsControlChars(file3)) {
     return {
       file: file3,
@@ -73653,7 +73705,7 @@ function processFile2(file3, cwd, exportedOnly) {
       errorType: "path-outside-workspace"
     };
   }
-  const fullPath = path68.join(cwd, file3);
+  const fullPath = path69.join(cwd, file3);
   if (!fs52.existsSync(fullPath)) {
     return {
       file: file3,
@@ -73945,15 +73997,15 @@ init_task_id();
 init_create_tool();
 init_resolve_working_directory();
 import * as fs53 from "node:fs";
-import * as path69 from "node:path";
+import * as path70 from "node:path";
 var EVIDENCE_DIR = ".swarm/evidence";
 function isValidTaskId3(taskId) {
   return isStrictTaskId(taskId);
 }
 function isPathWithinSwarm(filePath, workspaceRoot) {
-  const normalizedWorkspace = path69.resolve(workspaceRoot);
-  const swarmPath = path69.join(normalizedWorkspace, ".swarm", "evidence");
-  const normalizedPath = path69.resolve(filePath);
+  const normalizedWorkspace = path70.resolve(workspaceRoot);
+  const swarmPath = path70.join(normalizedWorkspace, ".swarm", "evidence");
+  const normalizedPath = path70.resolve(filePath);
   return normalizedPath.startsWith(swarmPath);
 }
 function readEvidenceFile(evidencePath) {
@@ -74034,7 +74086,7 @@ var check_gate_status = createSwarmTool({
       };
       return JSON.stringify(errorResult, null, 2);
     }
-    const evidencePath = path69.join(directory, EVIDENCE_DIR, `${taskIdInput}.json`);
+    const evidencePath = path70.join(directory, EVIDENCE_DIR, `${taskIdInput}.json`);
     if (!isPathWithinSwarm(evidencePath, directory)) {
       const errorResult = {
         taskId: taskIdInput,
@@ -74131,7 +74183,7 @@ init_state();
 init_create_tool();
 init_resolve_working_directory();
 import * as fs54 from "node:fs";
-import * as path70 from "node:path";
+import * as path71 from "node:path";
 function extractMatches(regex, text) {
   return Array.from(text.matchAll(regex));
 }
@@ -74283,10 +74335,10 @@ async function executeCompletionVerify(args2, directory) {
     let hasFileReadFailure = false;
     for (const filePath of fileTargets) {
       const normalizedPath = filePath.replace(/\\/g, "/");
-      const resolvedPath = path70.resolve(directory, normalizedPath);
-      const projectRoot = path70.resolve(directory);
-      const relative16 = path70.relative(projectRoot, resolvedPath);
-      const withinProject = relative16 === "" || !relative16.startsWith("..") && !path70.isAbsolute(relative16);
+      const resolvedPath = path71.resolve(directory, normalizedPath);
+      const projectRoot = path71.resolve(directory);
+      const relative16 = path71.relative(projectRoot, resolvedPath);
+      const withinProject = relative16 === "" || !relative16.startsWith("..") && !path71.isAbsolute(relative16);
       if (!withinProject) {
         blockedTasks.push({
           task_id: task.id,
@@ -74341,8 +74393,8 @@ async function executeCompletionVerify(args2, directory) {
     blockedTasks
   };
   try {
-    const evidenceDir = path70.join(directory, ".swarm", "evidence", `${phase}`);
-    const evidencePath = path70.join(evidenceDir, "completion-verify.json");
+    const evidenceDir = path71.join(directory, ".swarm", "evidence", `${phase}`);
+    const evidencePath = path71.join(evidenceDir, "completion-verify.json");
     fs54.mkdirSync(evidenceDir, { recursive: true });
     const evidenceBundle = {
       schema_version: "1.0.0",
@@ -74419,11 +74471,11 @@ var completion_verify = createSwarmTool({
 // src/tools/complexity-hotspots.ts
 init_zod();
 import * as fs56 from "node:fs";
-import * as path72 from "node:path";
+import * as path73 from "node:path";
 
 // src/quality/metrics.ts
 import * as fs55 from "node:fs";
-import * as path71 from "node:path";
+import * as path72 from "node:path";
 var MAX_FILE_SIZE_BYTES4 = 256 * 1024;
 var MIN_DUPLICATION_LINES = 10;
 function estimateCyclomaticComplexity(content) {
@@ -74475,7 +74527,7 @@ async function computeComplexityDelta(files, workingDir) {
   let totalComplexity = 0;
   const analyzedFiles = [];
   for (const file3 of files) {
-    const fullPath = path71.isAbsolute(file3) ? file3 : path71.join(workingDir, file3);
+    const fullPath = path72.isAbsolute(file3) ? file3 : path72.join(workingDir, file3);
     if (!fs55.existsSync(fullPath)) {
       continue;
     }
@@ -74598,7 +74650,7 @@ function countGoExports(content) {
 function getExportCountForFile(filePath) {
   try {
     const content = fs55.readFileSync(filePath, "utf-8");
-    const ext = path71.extname(filePath).toLowerCase();
+    const ext = path72.extname(filePath).toLowerCase();
     switch (ext) {
       case ".ts":
       case ".tsx":
@@ -74624,7 +74676,7 @@ async function computePublicApiDelta(files, workingDir) {
   let totalExports = 0;
   const analyzedFiles = [];
   for (const file3 of files) {
-    const fullPath = path71.isAbsolute(file3) ? file3 : path71.join(workingDir, file3);
+    const fullPath = path72.isAbsolute(file3) ? file3 : path72.join(workingDir, file3);
     if (!fs55.existsSync(fullPath)) {
       continue;
     }
@@ -74658,7 +74710,7 @@ async function computeDuplicationRatio(files, workingDir) {
   let duplicateLines = 0;
   const analyzedFiles = [];
   for (const file3 of files) {
-    const fullPath = path71.isAbsolute(file3) ? file3 : path71.join(workingDir, file3);
+    const fullPath = path72.isAbsolute(file3) ? file3 : path72.join(workingDir, file3);
     if (!fs55.existsSync(fullPath)) {
       continue;
     }
@@ -74691,8 +74743,8 @@ function countCodeLines(content) {
   return lines.length;
 }
 function isTestFile(filePath) {
-  const basename10 = path71.basename(filePath);
-  const _ext = path71.extname(filePath).toLowerCase();
+  const basename10 = path72.basename(filePath);
+  const _ext = path72.extname(filePath).toLowerCase();
   const testPatterns = [
     ".test.",
     ".spec.",
@@ -74773,8 +74825,8 @@ function matchGlobSegment(globSegments, pathSegments) {
   }
   return gIndex === globSegments.length && pIndex === pathSegments.length;
 }
-function matchesGlobSegment(path72, glob) {
-  const normalizedPath = path72.replace(/\\/g, "/");
+function matchesGlobSegment(path73, glob) {
+  const normalizedPath = path73.replace(/\\/g, "/");
   const normalizedGlob = glob.replace(/\\/g, "/");
   if (normalizedPath.includes("//")) {
     return false;
@@ -74805,8 +74857,8 @@ function simpleGlobToRegex2(glob) {
 function hasGlobstar(glob) {
   return glob.includes("**");
 }
-function globMatches(path72, glob) {
-  const normalizedPath = path72.replace(/\\/g, "/");
+function globMatches(path73, glob) {
+  const normalizedPath = path73.replace(/\\/g, "/");
   if (!glob || glob === "") {
     if (normalizedPath.includes("//")) {
       return false;
@@ -74842,7 +74894,7 @@ function shouldExcludeFile(filePath, excludeGlobs) {
 async function computeTestToCodeRatio(workingDir, enforceGlobs, excludeGlobs) {
   let testLines = 0;
   let codeLines = 0;
-  const srcDir = path71.join(workingDir, "src");
+  const srcDir = path72.join(workingDir, "src");
   if (fs55.existsSync(srcDir)) {
     await scanDirectoryForLines(srcDir, enforceGlobs, excludeGlobs, false, (lines) => {
       codeLines += lines;
@@ -74850,14 +74902,14 @@ async function computeTestToCodeRatio(workingDir, enforceGlobs, excludeGlobs) {
   }
   const possibleSrcDirs = ["lib", "app", "source", "core"];
   for (const dir of possibleSrcDirs) {
-    const dirPath = path71.join(workingDir, dir);
+    const dirPath = path72.join(workingDir, dir);
     if (fs55.existsSync(dirPath)) {
       await scanDirectoryForLines(dirPath, enforceGlobs, excludeGlobs, false, (lines) => {
         codeLines += lines;
       });
     }
   }
-  const testsDir = path71.join(workingDir, "tests");
+  const testsDir = path72.join(workingDir, "tests");
   if (fs55.existsSync(testsDir)) {
     await scanDirectoryForLines(testsDir, ["**"], ["node_modules", "dist"], true, (lines) => {
       testLines += lines;
@@ -74865,7 +74917,7 @@ async function computeTestToCodeRatio(workingDir, enforceGlobs, excludeGlobs) {
   }
   const possibleTestDirs = ["test", "__tests__", "specs"];
   for (const dir of possibleTestDirs) {
-    const dirPath = path71.join(workingDir, dir);
+    const dirPath = path72.join(workingDir, dir);
     if (fs55.existsSync(dirPath) && dirPath !== testsDir) {
       await scanDirectoryForLines(dirPath, ["**"], ["node_modules", "dist"], true, (lines) => {
         testLines += lines;
@@ -74880,7 +74932,7 @@ async function scanDirectoryForLines(dirPath, includeGlobs, excludeGlobs, isTest
   try {
     const entries = fs55.readdirSync(dirPath, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = path71.join(dirPath, entry.name);
+      const fullPath = path72.join(dirPath, entry.name);
       if (entry.isDirectory()) {
         if (entry.name === "node_modules" || entry.name === "dist" || entry.name === "build" || entry.name === ".git") {
           continue;
@@ -74888,7 +74940,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 = path71.extname(entry.name).toLowerCase();
+        const ext = path72.extname(entry.name).toLowerCase();
         const validExts = [
           ".ts",
           ".tsx",
@@ -75141,7 +75193,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 = path72.extname(file3).toLowerCase();
+    const ext = path73.extname(file3).toLowerCase();
     if (extSet.has(ext)) {
       filteredChurn.set(file3, count);
     }
@@ -75152,7 +75204,7 @@ async function analyzeHotspots(days, topN, extensions, directory) {
   for (const [file3, churnCount] of filteredChurn) {
     let fullPath = file3;
     if (!fs56.existsSync(fullPath)) {
-      fullPath = path72.join(cwd, file3);
+      fullPath = path73.join(cwd, file3);
     }
     const complexity = getComplexityForFile2(fullPath);
     if (complexity !== null) {
@@ -75326,7 +75378,7 @@ import {
   readFileSync as readFileSync36,
   writeFileSync as writeFileSync11
 } from "node:fs";
-import { join as join66 } from "node:path";
+import { join as join67 } from "node:path";
 var EVIDENCE_DIR2 = ".swarm/evidence";
 var VALID_TASK_ID = /^\d+\.\d+(\.\d+)*$/;
 var COUNCIL_GATE_NAME = "council";
@@ -75360,9 +75412,9 @@ 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 = join66(workingDir, EVIDENCE_DIR2);
+  const dir = join67(workingDir, EVIDENCE_DIR2);
   mkdirSync18(dir, { recursive: true });
-  const filePath = join66(dir, `${synthesis.taskId}.json`);
+  const filePath = join67(dir, `${synthesis.taskId}.json`);
   const existingRoot = Object.create(null);
   if (existsSync37(filePath)) {
     try {
@@ -75396,7 +75448,7 @@ function writeCouncilEvidence(workingDir, synthesis) {
     updated.required_gates = [];
   writeFileSync11(filePath, JSON.stringify(updated, null, 2));
   try {
-    const councilDir = join66(workingDir, ".swarm", "council");
+    const councilDir = join67(workingDir, ".swarm", "council");
     mkdirSync18(councilDir, { recursive: true });
     const auditLine = JSON.stringify({
       round: synthesis.roundNumber,
@@ -75404,7 +75456,7 @@ function writeCouncilEvidence(workingDir, synthesis) {
       timestamp: synthesis.timestamp,
       vetoedBy: synthesis.vetoedBy
     });
-    appendFileSync6(join66(councilDir, `${synthesis.taskId}.rounds.jsonl`), `${auditLine}
+    appendFileSync6(join67(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)}`);
@@ -75538,20 +75590,20 @@ 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 join67 } from "node:path";
+import { join as join68 } from "node:path";
 var COUNCIL_DIR = ".swarm/council";
 function writeCriteria(workingDir, taskId, criteria) {
-  const dir = join67(workingDir, COUNCIL_DIR);
+  const dir = join68(workingDir, COUNCIL_DIR);
   mkdirSync19(dir, { recursive: true });
   const payload = {
     taskId,
     criteria,
     declaredAt: new Date().toISOString()
   };
-  writeFileSync12(join67(dir, `${safeId(taskId)}.json`), JSON.stringify(payload, null, 2));
+  writeFileSync12(join68(dir, `${safeId(taskId)}.json`), JSON.stringify(payload, null, 2));
 }
 function readCriteria(workingDir, taskId) {
-  const filePath = join67(workingDir, COUNCIL_DIR, `${safeId(taskId)}.json`);
+  const filePath = join68(workingDir, COUNCIL_DIR, `${safeId(taskId)}.json`);
   if (!existsSync38(filePath))
     return null;
   try {
@@ -75704,7 +75756,7 @@ var submit_council_verdicts = createSwarmTool({
 init_zod();
 init_loader();
 import * as fs57 from "node:fs";
-import * as path73 from "node:path";
+import * as path74 from "node:path";
 
 // src/council/general-council-advisory.ts
 var ADVISORY_HEADER = "[general_council] (advisory; not blocking)";
@@ -76152,10 +76204,10 @@ var convene_general_council = createSwarmTool({
     const round1 = input.round1Responses;
     const round2 = input.round2Responses ?? [];
     const result = synthesizeGeneralCouncil(input.question, input.mode, round1, round2);
-    const evidenceDir = path73.join(workingDir, ".swarm", "council", "general");
+    const evidenceDir = path74.join(workingDir, ".swarm", "council", "general");
     const safeTimestamp = result.timestamp.replace(/[:.]/g, "-");
     const evidenceFile = `${safeTimestamp}-${input.mode}.json`;
-    const evidencePath = path73.join(evidenceDir, evidenceFile);
+    const evidencePath = path74.join(evidenceDir, evidenceFile);
     try {
       await fs57.promises.mkdir(evidenceDir, { recursive: true });
       await fs57.promises.writeFile(evidencePath, JSON.stringify(result, null, 2));
@@ -76392,7 +76444,7 @@ init_state();
 init_task_id();
 init_create_tool();
 import * as fs58 from "node:fs";
-import * as path74 from "node:path";
+import * as path75 from "node:path";
 function validateTaskIdFormat2(taskId) {
   return validateTaskIdFormat(taskId);
 }
@@ -76466,8 +76518,8 @@ async function executeDeclareScope(args2, fallbackDir) {
         };
       }
     }
-    normalizedDir = path74.normalize(args2.working_directory);
-    const pathParts = normalizedDir.split(path74.sep);
+    normalizedDir = path75.normalize(args2.working_directory);
+    const pathParts = normalizedDir.split(path75.sep);
     if (pathParts.includes("..")) {
       return {
         success: false,
@@ -76477,10 +76529,10 @@ async function executeDeclareScope(args2, fallbackDir) {
         ]
       };
     }
-    const resolvedDir = path74.resolve(normalizedDir);
+    const resolvedDir = path75.resolve(normalizedDir);
     try {
       const realPath = fs58.realpathSync(resolvedDir);
-      const planPath2 = path74.join(realPath, ".swarm", "plan.json");
+      const planPath2 = path75.join(realPath, ".swarm", "plan.json");
       if (!fs58.existsSync(planPath2)) {
         return {
           success: false,
@@ -76504,7 +76556,7 @@ async function executeDeclareScope(args2, fallbackDir) {
     console.warn("[declare-scope] fallbackDir is undefined, falling back to process.cwd()");
   }
   const directory = normalizedDir || fallbackDir;
-  const planPath = path74.resolve(directory, ".swarm", "plan.json");
+  const planPath = path75.resolve(directory, ".swarm", "plan.json");
   if (!fs58.existsSync(planPath)) {
     return {
       success: false,
@@ -76544,8 +76596,8 @@ async function executeDeclareScope(args2, fallbackDir) {
   const normalizeErrors = [];
   const dir = normalizedDir || fallbackDir || process.cwd();
   const mergedFiles = rawMergedFiles.map((file3) => {
-    if (path74.isAbsolute(file3)) {
-      const relativePath = path74.relative(dir, file3).replace(/\\/g, "/");
+    if (path75.isAbsolute(file3)) {
+      const relativePath = path75.relative(dir, file3).replace(/\\/g, "/");
       if (relativePath.startsWith("..")) {
         normalizeErrors.push(`Path '${file3}' resolves outside the project directory`);
         return file3;
@@ -76606,7 +76658,7 @@ var declare_scope = createSwarmTool({
 init_zod();
 import * as child_process7 from "node:child_process";
 import * as fs59 from "node:fs";
-import * as path75 from "node:path";
+import * as path76 from "node:path";
 init_create_tool();
 var MAX_DIFF_LINES = 500;
 var DIFF_TIMEOUT_MS = 30000;
@@ -76635,20 +76687,20 @@ function validateBase(base) {
 function validatePaths(paths) {
   if (!paths)
     return null;
-  for (const path76 of paths) {
-    if (!path76 || path76.length === 0) {
+  for (const path77 of paths) {
+    if (!path77 || path77.length === 0) {
       return "empty path not allowed";
     }
-    if (path76.length > MAX_PATH_LENGTH) {
+    if (path77.length > MAX_PATH_LENGTH) {
       return `path exceeds maximum length of ${MAX_PATH_LENGTH}`;
     }
-    if (SHELL_METACHARACTERS2.test(path76)) {
+    if (SHELL_METACHARACTERS2.test(path77)) {
       return "path contains shell metacharacters";
     }
-    if (path76.startsWith("-")) {
+    if (path77.startsWith("-")) {
       return 'path cannot start with "-" (option-like arguments not allowed)';
     }
-    if (CONTROL_CHAR_PATTERN2.test(path76)) {
+    if (CONTROL_CHAR_PATTERN2.test(path77)) {
       return "path contains control characters";
     }
   }
@@ -76754,8 +76806,8 @@ var diff = createSwarmTool({
         if (parts2.length >= 3) {
           const additions = parseInt(parts2[0], 10) || 0;
           const deletions = parseInt(parts2[1], 10) || 0;
-          const path76 = parts2[2];
-          files.push({ path: path76, additions, deletions });
+          const path77 = parts2[2];
+          files.push({ path: path77, additions, deletions });
         }
       }
       const contractChanges = [];
@@ -76795,7 +76847,7 @@ var diff = createSwarmTool({
           } else if (base === "unstaged") {
             const oldRef = `:${file3.path}`;
             oldContent = fileExistsInRef(oldRef) ? getContentFromRef(oldRef) : "";
-            newContent = fs59.readFileSync(path75.join(directory, file3.path), "utf-8");
+            newContent = fs59.readFileSync(path76.join(directory, file3.path), "utf-8");
           } else {
             const oldRef = `${base}:${file3.path}`;
             oldContent = fileExistsInRef(oldRef) ? getContentFromRef(oldRef) : "";
@@ -76870,7 +76922,7 @@ var diff = createSwarmTool({
 init_zod();
 import * as child_process8 from "node:child_process";
 import * as fs60 from "node:fs";
-import * as path76 from "node:path";
+import * as path77 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.",
@@ -76918,7 +76970,7 @@ var diff_summary = createSwarmTool({
         }
         try {
           let oldContent;
-          const newContent = fs60.readFileSync(path76.join(workingDir, filePath), "utf-8");
+          const newContent = fs60.readFileSync(path77.join(workingDir, filePath), "utf-8");
           if (fileExistsInHead) {
             oldContent = child_process8.execFileSync("git", ["show", `HEAD:${filePath}`], {
               encoding: "utf-8",
@@ -77147,7 +77199,7 @@ init_zod();
 init_create_tool();
 init_path_security();
 import * as fs61 from "node:fs";
-import * as path77 from "node:path";
+import * as path78 from "node:path";
 var MAX_FILE_SIZE_BYTES6 = 1024 * 1024;
 var MAX_EVIDENCE_FILES = 1000;
 var EVIDENCE_DIR3 = ".swarm/evidence";
@@ -77174,9 +77226,9 @@ function validateRequiredTypes(input) {
   return null;
 }
 function isPathWithinSwarm2(filePath, cwd) {
-  const normalizedCwd = path77.resolve(cwd);
-  const swarmPath = path77.join(normalizedCwd, ".swarm");
-  const normalizedPath = path77.resolve(filePath);
+  const normalizedCwd = path78.resolve(cwd);
+  const swarmPath = path78.join(normalizedCwd, ".swarm");
+  const normalizedPath = path78.resolve(filePath);
   return normalizedPath.startsWith(swarmPath);
 }
 function parseCompletedTasks(planContent) {
@@ -77206,10 +77258,10 @@ function readEvidenceFiles(evidenceDir, _cwd) {
     if (!VALID_EVIDENCE_FILENAME_REGEX.test(filename)) {
       continue;
     }
-    const filePath = path77.join(evidenceDir, filename);
+    const filePath = path78.join(evidenceDir, filename);
     try {
-      const resolvedPath = path77.resolve(filePath);
-      const evidenceDirResolved = path77.resolve(evidenceDir);
+      const resolvedPath = path78.resolve(filePath);
+      const evidenceDirResolved = path78.resolve(evidenceDir);
       if (!resolvedPath.startsWith(evidenceDirResolved)) {
         continue;
       }
@@ -77327,7 +77379,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 = path77.join(cwd, PLAN_FILE);
+    const planPath = path78.join(cwd, PLAN_FILE);
     if (!isPathWithinSwarm2(planPath, cwd)) {
       const errorResult = {
         error: "plan file path validation failed",
@@ -77359,7 +77411,7 @@ var evidence_check = createSwarmTool({
       };
       return JSON.stringify(result2, null, 2);
     }
-    const evidenceDir = path77.join(cwd, EVIDENCE_DIR3);
+    const evidenceDir = path78.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;
@@ -77377,7 +77429,7 @@ var evidence_check = createSwarmTool({
 init_zod();
 init_create_tool();
 import * as fs62 from "node:fs";
-import * as path78 from "node:path";
+import * as path79 from "node:path";
 var EXT_MAP = {
   python: ".py",
   py: ".py",
@@ -77458,12 +77510,12 @@ var extract_code_blocks = createSwarmTool({
       if (prefix) {
         filename = `${prefix}_${filename}`;
       }
-      let filepath = path78.join(targetDir, filename);
-      const base = path78.basename(filepath, path78.extname(filepath));
-      const ext = path78.extname(filepath);
+      let filepath = path79.join(targetDir, filename);
+      const base = path79.basename(filepath, path79.extname(filepath));
+      const ext = path79.extname(filepath);
       let counter = 1;
       while (fs62.existsSync(filepath)) {
-        filepath = path78.join(targetDir, `${base}_${counter}${ext}`);
+        filepath = path79.join(targetDir, `${base}_${counter}${ext}`);
         counter++;
       }
       try {
@@ -77727,7 +77779,7 @@ init_zod();
 init_create_tool();
 init_path_security();
 import * as fs63 from "node:fs";
-import * as path79 from "node:path";
+import * as path80 from "node:path";
 var MAX_FILE_PATH_LENGTH2 = 500;
 var MAX_SYMBOL_LENGTH = 256;
 var MAX_FILE_SIZE_BYTES7 = 1024 * 1024;
@@ -77775,7 +77827,7 @@ function validateSymbolInput(symbol3) {
   return null;
 }
 function isBinaryFile2(filePath, buffer) {
-  const ext = path79.extname(filePath).toLowerCase();
+  const ext = path80.extname(filePath).toLowerCase();
   if (ext === ".json" || ext === ".md" || ext === ".txt") {
     return false;
   }
@@ -77799,15 +77851,15 @@ function parseImports(content, targetFile, targetSymbol) {
   const imports = [];
   let _resolvedTarget;
   try {
-    _resolvedTarget = path79.resolve(targetFile);
+    _resolvedTarget = path80.resolve(targetFile);
   } catch {
     _resolvedTarget = targetFile;
   }
-  const targetBasename = path79.basename(targetFile, path79.extname(targetFile));
+  const targetBasename = path80.basename(targetFile, path80.extname(targetFile));
   const targetWithExt = targetFile;
   const targetWithoutExt = targetFile.replace(/\.(ts|tsx|js|jsx|mjs|cjs)$/i, "");
-  const normalizedTargetWithExt = path79.normalize(targetWithExt).replace(/\\/g, "/");
-  const normalizedTargetWithoutExt = path79.normalize(targetWithoutExt).replace(/\\/g, "/");
+  const normalizedTargetWithExt = path80.normalize(targetWithExt).replace(/\\/g, "/");
+  const normalizedTargetWithoutExt = path80.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];
@@ -77830,9 +77882,9 @@ function parseImports(content, targetFile, targetSymbol) {
     }
     const _normalizedModule = modulePath.replace(/^\.\//, "").replace(/^\.\.\\/, "../");
     let isMatch = false;
-    const _targetDir = path79.dirname(targetFile);
-    const targetExt = path79.extname(targetFile);
-    const targetBasenameNoExt = path79.basename(targetFile, targetExt);
+    const _targetDir = path80.dirname(targetFile);
+    const targetExt = path80.extname(targetFile);
+    const targetBasenameNoExt = path80.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, "");
@@ -77900,10 +77952,10 @@ function findSourceFiles3(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(path79.join(dir, entry));
+      stats.skippedDirs.push(path80.join(dir, entry));
       continue;
     }
-    const fullPath = path79.join(dir, entry);
+    const fullPath = path80.join(dir, entry);
     let stat4;
     try {
       stat4 = fs63.statSync(fullPath);
@@ -77917,7 +77969,7 @@ function findSourceFiles3(dir, files = [], stats = { skippedDirs: [], skippedFil
     if (stat4.isDirectory()) {
       findSourceFiles3(fullPath, files, stats);
     } else if (stat4.isFile()) {
-      const ext = path79.extname(fullPath).toLowerCase();
+      const ext = path80.extname(fullPath).toLowerCase();
       if (SUPPORTED_EXTENSIONS3.includes(ext)) {
         files.push(fullPath);
       }
@@ -77974,7 +78026,7 @@ var imports = createSwarmTool({
       return JSON.stringify(errorResult, null, 2);
     }
     try {
-      const targetFile = path79.resolve(file3);
+      const targetFile = path80.resolve(file3);
       if (!fs63.existsSync(targetFile)) {
         const errorResult = {
           error: `target file not found: ${file3}`,
@@ -77996,7 +78048,7 @@ var imports = createSwarmTool({
         };
         return JSON.stringify(errorResult, null, 2);
       }
-      const baseDir = path79.dirname(targetFile);
+      const baseDir = path80.dirname(targetFile);
       const scanStats = {
         skippedDirs: [],
         skippedFiles: 0,
@@ -78542,7 +78594,7 @@ init_qa_gate_profile();
 init_manager2();
 init_curator();
 import * as fs65 from "node:fs";
-import * as path81 from "node:path";
+import * as path82 from "node:path";
 init_knowledge_curator();
 init_knowledge_reader();
 init_knowledge_store();
@@ -78555,14 +78607,16 @@ init_plan_schema();
 init_ledger();
 init_manager();
 import * as fs64 from "node:fs";
-import * as path80 from "node:path";
+import * as path81 from "node:path";
 async function writeCheckpoint(directory) {
   try {
     const plan = await loadPlan(directory);
     if (!plan)
       return;
-    const jsonPath = path80.join(directory, "SWARM_PLAN.json");
-    const mdPath = path80.join(directory, "SWARM_PLAN.md");
+    const swarmDir = path81.join(directory, ".swarm");
+    fs64.mkdirSync(swarmDir, { recursive: true });
+    const jsonPath = path81.join(swarmDir, "SWARM_PLAN.json");
+    const mdPath = path81.join(swarmDir, "SWARM_PLAN.md");
     fs64.writeFileSync(jsonPath, JSON.stringify(plan, null, 2), "utf8");
     const md = derivePlanMarkdown(plan);
     fs64.writeFileSync(mdPath, md, "utf8");
@@ -78797,7 +78851,7 @@ async function executePhaseComplete(args2, workingDirectory, directory) {
     let driftCheckEnabled = true;
     let driftHasSpecMd = false;
     try {
-      const specMdPath = path81.join(dir, ".swarm", "spec.md");
+      const specMdPath = path82.join(dir, ".swarm", "spec.md");
       driftHasSpecMd = fs65.existsSync(specMdPath);
       const gatePlan = await loadPlan(dir);
       if (gatePlan) {
@@ -78819,7 +78873,7 @@ async function executePhaseComplete(args2, workingDirectory, directory) {
     } else {
       let phaseType;
       try {
-        const planPath = path81.join(dir, ".swarm", "plan.json");
+        const planPath = path82.join(dir, ".swarm", "plan.json");
         if (fs65.existsSync(planPath)) {
           const planRaw = fs65.readFileSync(planPath, "utf-8");
           const plan = JSON.parse(planRaw);
@@ -78832,7 +78886,7 @@ 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 = path81.join(dir, ".swarm", "evidence", String(phase), "drift-verifier.json");
+          const driftEvidencePath = path82.join(dir, ".swarm", "evidence", String(phase), "drift-verifier.json");
           let driftVerdictFound = false;
           let driftVerdictApproved = false;
           try {
@@ -78870,7 +78924,7 @@ async function executePhaseComplete(args2, workingDirectory, directory) {
               let incompleteTaskCount = 0;
               let planParseable = false;
               try {
-                const planPath = path81.join(dir, ".swarm", "plan.json");
+                const planPath = path82.join(dir, ".swarm", "plan.json");
                 if (fs65.existsSync(planPath)) {
                   const planRaw = fs65.readFileSync(planPath, "utf-8");
                   const plan = JSON.parse(planRaw);
@@ -78937,7 +78991,7 @@ async function executePhaseComplete(args2, workingDirectory, directory) {
           const overrides = session2?.qaGateSessionOverrides ?? {};
           const effective = getEffectiveGates(profile, overrides);
           if (effective.hallucination_guard === true) {
-            const hgPath = path81.join(dir, ".swarm", "evidence", String(phase), "hallucination-guard.json");
+            const hgPath = path82.join(dir, ".swarm", "evidence", String(phase), "hallucination-guard.json");
             let hgVerdictFound = false;
             let hgVerdictApproved = false;
             try {
@@ -79009,7 +79063,7 @@ async function executePhaseComplete(args2, workingDirectory, directory) {
           const overrides = session2?.qaGateSessionOverrides ?? {};
           const effective = getEffectiveGates(profile, overrides);
           if (effective.mutation_test === true) {
-            const mgPath = path81.join(dir, ".swarm", "evidence", String(phase), "mutation-gate.json");
+            const mgPath = path82.join(dir, ".swarm", "evidence", String(phase), "mutation-gate.json");
             let mgVerdictFound = false;
             let mgVerdict;
             try {
@@ -79083,7 +79137,7 @@ async function executePhaseComplete(args2, workingDirectory, directory) {
           const effective = getEffectiveGates(profile, overrides);
           if (effective.council_mode === true) {
             councilModeEnabled = true;
-            const pcPath = path81.join(dir, ".swarm", "evidence", String(phase), "phase-council.json");
+            const pcPath = path82.join(dir, ".swarm", "evidence", String(phase), "phase-council.json");
             let pcVerdictFound = false;
             let _pcVerdict;
             let pcQuorumSize;
@@ -79285,7 +79339,7 @@ Advisory notes: ${advisoryNotes.join("; ")}` : "";
   }
   if (retroFound && retroEntry?.lessons_learned && retroEntry.lessons_learned.length > 0) {
     try {
-      const projectName = path81.basename(dir);
+      const projectName = path82.basename(dir);
       const curationResult = await curateAndStoreSwarm(retroEntry.lessons_learned, projectName, { phase_number: phase }, dir, knowledgeConfig);
       if (curationResult) {
         const sessionState = swarmState.agentSessions.get(sessionID);
@@ -79654,7 +79708,7 @@ init_discovery();
 init_utils();
 init_create_tool();
 import * as fs66 from "node:fs";
-import * as path82 from "node:path";
+import * as path83 from "node:path";
 var MAX_OUTPUT_BYTES5 = 52428800;
 var AUDIT_TIMEOUT_MS = 120000;
 function isValidEcosystem(value) {
@@ -79682,16 +79736,16 @@ function validateArgs3(args2) {
 function detectEcosystems(directory) {
   const ecosystems = [];
   const cwd = directory;
-  if (fs66.existsSync(path82.join(cwd, "package.json"))) {
+  if (fs66.existsSync(path83.join(cwd, "package.json"))) {
     ecosystems.push("npm");
   }
-  if (fs66.existsSync(path82.join(cwd, "pyproject.toml")) || fs66.existsSync(path82.join(cwd, "requirements.txt"))) {
+  if (fs66.existsSync(path83.join(cwd, "pyproject.toml")) || fs66.existsSync(path83.join(cwd, "requirements.txt"))) {
     ecosystems.push("pip");
   }
-  if (fs66.existsSync(path82.join(cwd, "Cargo.toml"))) {
+  if (fs66.existsSync(path83.join(cwd, "Cargo.toml"))) {
     ecosystems.push("cargo");
   }
-  if (fs66.existsSync(path82.join(cwd, "go.mod"))) {
+  if (fs66.existsSync(path83.join(cwd, "go.mod"))) {
     ecosystems.push("go");
   }
   try {
@@ -79700,13 +79754,13 @@ function detectEcosystems(directory) {
       ecosystems.push("dotnet");
     }
   } catch {}
-  if (fs66.existsSync(path82.join(cwd, "Gemfile")) || fs66.existsSync(path82.join(cwd, "Gemfile.lock"))) {
+  if (fs66.existsSync(path83.join(cwd, "Gemfile")) || fs66.existsSync(path83.join(cwd, "Gemfile.lock"))) {
     ecosystems.push("ruby");
   }
-  if (fs66.existsSync(path82.join(cwd, "pubspec.yaml"))) {
+  if (fs66.existsSync(path83.join(cwd, "pubspec.yaml"))) {
     ecosystems.push("dart");
   }
-  if (fs66.existsSync(path82.join(cwd, "composer.lock"))) {
+  if (fs66.existsSync(path83.join(cwd, "composer.lock"))) {
     ecosystems.push("composer");
   }
   return ecosystems;
@@ -80866,7 +80920,7 @@ var pkg_audit = createSwarmTool({
 init_zod();
 init_manager2();
 import * as fs67 from "node:fs";
-import * as path83 from "node:path";
+import * as path84 from "node:path";
 init_utils();
 init_create_tool();
 var MAX_FILE_SIZE = 1024 * 1024;
@@ -80989,7 +81043,7 @@ function isScaffoldFile(filePath) {
   if (SCAFFOLD_PATH_PATTERNS.some((pattern) => pattern.test(normalizedPath))) {
     return true;
   }
-  const filename = path83.basename(filePath);
+  const filename = path84.basename(filePath);
   if (SCAFFOLD_FILENAME_PATTERNS.some((pattern) => pattern.test(filename))) {
     return true;
   }
@@ -81006,7 +81060,7 @@ function isAllowedByGlobs(filePath, allowGlobs) {
     if (regex.test(normalizedPath)) {
       return true;
     }
-    const filename = path83.basename(filePath);
+    const filename = path84.basename(filePath);
     const filenameRegex = new RegExp(`^${regexPattern}$`, "i");
     if (filenameRegex.test(filename)) {
       return true;
@@ -81015,7 +81069,7 @@ function isAllowedByGlobs(filePath, allowGlobs) {
   return false;
 }
 function isParserSupported(filePath) {
-  const ext = path83.extname(filePath).toLowerCase();
+  const ext = path84.extname(filePath).toLowerCase();
   return SUPPORTED_PARSER_EXTENSIONS.has(ext);
 }
 function isPlanFile(filePath) {
@@ -81262,9 +81316,9 @@ async function placeholderScan(input, directory) {
   let filesScanned = 0;
   const filesWithFindings = new Set;
   for (const filePath of changed_files) {
-    const fullPath = path83.isAbsolute(filePath) ? filePath : path83.resolve(directory, filePath);
-    const resolvedDirectory = path83.resolve(directory);
-    if (!fullPath.startsWith(resolvedDirectory + path83.sep) && fullPath !== resolvedDirectory) {
+    const fullPath = path84.isAbsolute(filePath) ? filePath : path84.resolve(directory, filePath);
+    const resolvedDirectory = path84.resolve(directory);
+    if (!fullPath.startsWith(resolvedDirectory + path84.sep) && fullPath !== resolvedDirectory) {
       continue;
     }
     if (!fs67.existsSync(fullPath)) {
@@ -81273,7 +81327,7 @@ async function placeholderScan(input, directory) {
     if (isAllowedByGlobs(filePath, allow_globs)) {
       continue;
     }
-    const relativeFilePath = path83.relative(directory, fullPath).replace(/\\/g, "/");
+    const relativeFilePath = path84.relative(directory, fullPath).replace(/\\/g, "/");
     if (FILE_ALLOWLIST.some((allowed) => relativeFilePath.endsWith(allowed))) {
       continue;
     }
@@ -81345,7 +81399,7 @@ var placeholder_scan = createSwarmTool({
 });
 // src/tools/pre-check-batch.ts
 import * as fs70 from "node:fs";
-import * as path86 from "node:path";
+import * as path87 from "node:path";
 init_zod();
 init_manager2();
 init_utils();
@@ -81482,7 +81536,7 @@ init_zod();
 init_manager2();
 init_detector();
 import * as fs69 from "node:fs";
-import * as path85 from "node:path";
+import * as path86 from "node:path";
 import { extname as extname18 } from "node:path";
 
 // src/sast/rules/c.ts
@@ -82376,24 +82430,24 @@ init_create_tool();
 init_utils2();
 import * as crypto8 from "node:crypto";
 import * as fs68 from "node:fs";
-import * as path84 from "node:path";
+import * as path85 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 = path84.isAbsolute(file3) ? file3 : path84.resolve(directory, file3);
-  const rel = path84.relative(path84.resolve(directory), resolved);
+  const resolved = path85.isAbsolute(file3) ? file3 : path85.resolve(directory, file3);
+  const rel = path85.relative(path85.resolve(directory), resolved);
   return rel.replace(/\\/g, "/");
 }
 function baselineRelPath(phase) {
-  return path84.join("evidence", String(phase), "sast-baseline.json");
+  return path85.join("evidence", String(phase), "sast-baseline.json");
 }
 function tempRelPath(phase) {
-  return path84.join("evidence", String(phase), `sast-baseline.json.tmp.${Date.now()}.${process.pid}`);
+  return path85.join("evidence", String(phase), `sast-baseline.json.tmp.${Date.now()}.${process.pid}`);
 }
 function lockRelPath(phase) {
-  return path84.join("evidence", String(phase), "sast-baseline.json.lock");
+  return path85.join("evidence", String(phase), "sast-baseline.json.lock");
 }
 function getLine(lines, idx) {
   if (idx < 0 || idx >= lines.length)
@@ -82514,8 +82568,8 @@ async function captureOrMergeBaseline(directory, phase, findings, engine, scanne
       message: e instanceof Error ? e.message : "Path validation failed"
     };
   }
-  fs68.mkdirSync(path84.dirname(baselinePath), { recursive: true });
-  fs68.mkdirSync(path84.dirname(tempPath), { recursive: true });
+  fs68.mkdirSync(path85.dirname(baselinePath), { recursive: true });
+  fs68.mkdirSync(path85.dirname(tempPath), { recursive: true });
   const releaseLock = await acquireLock(lockPath);
   try {
     let existing = null;
@@ -82782,9 +82836,9 @@ async function sastScan(input, directory, config3) {
       _filesSkipped++;
       continue;
     }
-    const resolvedPath = path85.isAbsolute(filePath) ? filePath : path85.resolve(directory, filePath);
-    const resolvedDirectory = path85.resolve(directory);
-    if (!resolvedPath.startsWith(resolvedDirectory + path85.sep) && resolvedPath !== resolvedDirectory) {
+    const resolvedPath = path86.isAbsolute(filePath) ? filePath : path86.resolve(directory, filePath);
+    const resolvedDirectory = path86.resolve(directory);
+    if (!resolvedPath.startsWith(resolvedDirectory + path86.sep) && resolvedPath !== resolvedDirectory) {
       _filesSkipped++;
       continue;
     }
@@ -83095,18 +83149,18 @@ function validatePath(inputPath, baseDir, workspaceDir) {
   let resolved;
   const isWinAbs = isWindowsAbsolutePath(inputPath);
   if (isWinAbs) {
-    resolved = path86.win32.resolve(inputPath);
-  } else if (path86.isAbsolute(inputPath)) {
-    resolved = path86.resolve(inputPath);
+    resolved = path87.win32.resolve(inputPath);
+  } else if (path87.isAbsolute(inputPath)) {
+    resolved = path87.resolve(inputPath);
   } else {
-    resolved = path86.resolve(baseDir, inputPath);
+    resolved = path87.resolve(baseDir, inputPath);
   }
-  const workspaceResolved = path86.resolve(workspaceDir);
+  const workspaceResolved = path87.resolve(workspaceDir);
   let relative20;
   if (isWinAbs) {
-    relative20 = path86.win32.relative(workspaceResolved, resolved);
+    relative20 = path87.win32.relative(workspaceResolved, resolved);
   } else {
-    relative20 = path86.relative(workspaceResolved, resolved);
+    relative20 = path87.relative(workspaceResolved, resolved);
   }
   if (relative20.startsWith("..")) {
     return "path traversal detected";
@@ -83171,7 +83225,7 @@ async function runLintOnFiles(linter, files, workspaceDir) {
     if (typeof file3 !== "string") {
       continue;
     }
-    const resolvedPath = path86.resolve(file3);
+    const resolvedPath = path87.resolve(file3);
     const validationError = validatePath(resolvedPath, workspaceDir, workspaceDir);
     if (validationError) {
       continue;
@@ -83328,7 +83382,7 @@ async function runSecretscanWithFiles(files, directory) {
         skippedFiles++;
         continue;
       }
-      const resolvedPath = path86.resolve(file3);
+      const resolvedPath = path87.resolve(file3);
       const validationError = validatePath(resolvedPath, directory, directory);
       if (validationError) {
         skippedFiles++;
@@ -83346,7 +83400,7 @@ async function runSecretscanWithFiles(files, directory) {
       };
     }
     for (const file3 of validatedFiles) {
-      const ext = path86.extname(file3).toLowerCase();
+      const ext = path87.extname(file3).toLowerCase();
       if (DEFAULT_EXCLUDE_EXTENSIONS2.has(ext)) {
         skippedFiles++;
         continue;
@@ -83565,7 +83619,7 @@ function classifySastFindings(findings, changedLineRanges, directory) {
   const preexistingFindings = [];
   for (const finding of findings) {
     const filePath = finding.location.file;
-    const normalised = path86.relative(directory, filePath).replace(/\\/g, "/");
+    const normalised = path87.relative(directory, filePath).replace(/\\/g, "/");
     const changedLines = changedLineRanges.get(normalised);
     if (changedLines?.has(finding.location.line)) {
       newFindings.push(finding);
@@ -83616,7 +83670,7 @@ async function runPreCheckBatch(input, workspaceDir, contextDir) {
       warn(`pre_check_batch: Invalid file path: ${file3}`);
       continue;
     }
-    changedFiles.push(path86.resolve(directory, file3));
+    changedFiles.push(path87.resolve(directory, file3));
   }
   if (changedFiles.length === 0) {
     warn("pre_check_batch: No valid files after validation, skipping all tools (fail-closed)");
@@ -83817,7 +83871,7 @@ var pre_check_batch = createSwarmTool({
       };
       return JSON.stringify(errorResult, null, 2);
     }
-    const resolvedDirectory = path86.resolve(typedArgs.directory);
+    const resolvedDirectory = path87.resolve(typedArgs.directory);
     const workspaceAnchor = resolvedDirectory;
     const dirError = validateDirectory2(resolvedDirectory, workspaceAnchor);
     if (dirError) {
@@ -83858,7 +83912,7 @@ var pre_check_batch = createSwarmTool({
 });
 // src/tools/repo-map.ts
 init_zod();
-import * as path87 from "node:path";
+import * as path88 from "node:path";
 init_path_security();
 init_create_tool();
 var VALID_ACTIONS = [
@@ -83883,7 +83937,7 @@ function validateFile(p) {
     return "file contains control characters";
   if (containsPathTraversal(p))
     return "file contains path traversal";
-  if (path87.isAbsolute(p) || /^[a-zA-Z]:[\\/]/.test(p)) {
+  if (path88.isAbsolute(p) || /^[a-zA-Z]:[\\/]/.test(p)) {
     return "file must be a workspace-relative path, not absolute";
   }
   return null;
@@ -83906,8 +83960,8 @@ function ok(action, payload) {
 }
 function toRelativeGraphPath(input, workspaceRoot) {
   const normalized = input.replace(/\\/g, "/");
-  if (path87.isAbsolute(normalized)) {
-    const rel = path87.relative(workspaceRoot, normalized).replace(/\\/g, "/");
+  if (path88.isAbsolute(normalized)) {
+    const rel = path88.relative(workspaceRoot, normalized).replace(/\\/g, "/");
     return normalizeGraphPath2(rel);
   }
   return normalizeGraphPath2(normalized);
@@ -84052,7 +84106,7 @@ var repo_map = createSwarmTool({
 init_zod();
 init_create_tool();
 import * as fs71 from "node:fs";
-import * as path88 from "node:path";
+import * as path89 from "node:path";
 var SPEC_FILE = ".swarm/spec.md";
 var EVIDENCE_DIR4 = ".swarm/evidence";
 var OBLIGATION_KEYWORDS = ["MUST", "SHOULD", "SHALL"];
@@ -84121,7 +84175,7 @@ function readTouchedFiles(evidenceDir, phase, cwd) {
     return [];
   }
   for (const entry of entries) {
-    const entryPath = path88.join(evidenceDir, entry);
+    const entryPath = path89.join(evidenceDir, entry);
     try {
       const stat4 = fs71.statSync(entryPath);
       if (!stat4.isDirectory()) {
@@ -84137,11 +84191,11 @@ function readTouchedFiles(evidenceDir, phase, cwd) {
     if (entryPhase !== String(phase)) {
       continue;
     }
-    const evidenceFilePath = path88.join(entryPath, "evidence.json");
+    const evidenceFilePath = path89.join(entryPath, "evidence.json");
     try {
-      const resolvedPath = path88.resolve(evidenceFilePath);
-      const evidenceDirResolved = path88.resolve(evidenceDir);
-      if (!resolvedPath.startsWith(evidenceDirResolved + path88.sep)) {
+      const resolvedPath = path89.resolve(evidenceFilePath);
+      const evidenceDirResolved = path89.resolve(evidenceDir);
+      if (!resolvedPath.startsWith(evidenceDirResolved + path89.sep)) {
         continue;
       }
       const stat4 = fs71.lstatSync(evidenceFilePath);
@@ -84175,7 +84229,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(path88.resolve(cwd, file3));
+                  touchedFiles.add(path89.resolve(cwd, file3));
                 }
               }
             }
@@ -84188,8 +84242,8 @@ function readTouchedFiles(evidenceDir, phase, cwd) {
 }
 function searchFileForKeywords(filePath, keywords, cwd) {
   try {
-    const resolvedPath = path88.resolve(filePath);
-    const cwdResolved = path88.resolve(cwd);
+    const resolvedPath = path89.resolve(filePath);
+    const cwdResolved = path89.resolve(cwd);
     if (!resolvedPath.startsWith(cwdResolved)) {
       return false;
     }
@@ -84323,7 +84377,7 @@ var req_coverage = createSwarmTool({
       }, null, 2);
     }
     const cwd = inputDirectory || directory;
-    const specPath = path88.join(cwd, SPEC_FILE);
+    const specPath = path89.join(cwd, SPEC_FILE);
     let specContent;
     try {
       specContent = fs71.readFileSync(specPath, "utf-8");
@@ -84350,7 +84404,7 @@ var req_coverage = createSwarmTool({
         message: "No FR requirements found in spec.md"
       }, null, 2);
     }
-    const evidenceDir = path88.join(cwd, EVIDENCE_DIR4);
+    const evidenceDir = path89.join(cwd, EVIDENCE_DIR4);
     const touchedFiles = readTouchedFiles(evidenceDir, phase, cwd);
     const analyzedRequirements = [];
     let coveredCount = 0;
@@ -84376,7 +84430,7 @@ var req_coverage = createSwarmTool({
       requirements: analyzedRequirements
     };
     const reportFilename = `req-coverage-phase-${phase}.json`;
-    const reportPath = path88.join(evidenceDir, reportFilename);
+    const reportPath = path89.join(evidenceDir, reportFilename);
     try {
       if (!fs71.existsSync(evidenceDir)) {
         fs71.mkdirSync(evidenceDir, { recursive: true });
@@ -84464,7 +84518,7 @@ init_qa_gate_profile();
 init_file_locks();
 import * as crypto9 from "node:crypto";
 import * as fs72 from "node:fs";
-import * as path89 from "node:path";
+import * as path90 from "node:path";
 init_ledger();
 init_manager();
 init_state();
@@ -84542,8 +84596,8 @@ async function executeSavePlan(args2, fallbackDir) {
     };
   }
   if (args2.working_directory && fallbackDir) {
-    const resolvedTarget = path89.resolve(args2.working_directory);
-    const resolvedRoot = path89.resolve(fallbackDir);
+    const resolvedTarget = path90.resolve(args2.working_directory);
+    const resolvedRoot = path90.resolve(fallbackDir);
     let fallbackExists = false;
     try {
       fs72.accessSync(resolvedRoot, fs72.constants.F_OK);
@@ -84552,7 +84606,7 @@ async function executeSavePlan(args2, fallbackDir) {
       fallbackExists = false;
     }
     if (fallbackExists) {
-      const isSubdirectory = resolvedTarget.startsWith(resolvedRoot + path89.sep);
+      const isSubdirectory = resolvedTarget.startsWith(resolvedRoot + path90.sep);
       if (isSubdirectory) {
         return {
           success: false,
@@ -84568,7 +84622,7 @@ async function executeSavePlan(args2, fallbackDir) {
   let specMtime;
   let specHash;
   if (process.env.SWARM_SKIP_SPEC_GATE !== "1") {
-    const specPath = path89.join(targetWorkspace, ".swarm", "spec.md");
+    const specPath = path90.join(targetWorkspace, ".swarm", "spec.md");
     try {
       const stat4 = await fs72.promises.stat(specPath);
       specMtime = stat4.mtime.toISOString();
@@ -84584,7 +84638,7 @@ async function executeSavePlan(args2, fallbackDir) {
     }
   }
   if (process.env.SWARM_SKIP_GATE_SELECTION !== "1") {
-    const contextPath = path89.join(targetWorkspace, ".swarm", "context.md");
+    const contextPath = path90.join(targetWorkspace, ".swarm", "context.md");
     let contextContent = "";
     try {
       contextContent = await fs72.promises.readFile(contextPath, "utf8");
@@ -84734,7 +84788,7 @@ async function executeSavePlan(args2, fallbackDir) {
       }
       await writeCheckpoint(dir).catch(() => {});
       try {
-        const markerPath = path89.join(dir, ".swarm", ".plan-write-marker");
+        const markerPath = path90.join(dir, ".swarm", ".plan-write-marker");
         const marker = JSON.stringify({
           source: "save_plan",
           timestamp: new Date().toISOString(),
@@ -84757,7 +84811,7 @@ async function executeSavePlan(args2, fallbackDir) {
       return {
         success: true,
         message: "Plan saved successfully",
-        plan_path: path89.join(dir, ".swarm", "plan.json"),
+        plan_path: path90.join(dir, ".swarm", "plan.json"),
         phases_count: plan.phases.length,
         tasks_count: tasksCount,
         ...resolvedProfile !== undefined ? { execution_profile: resolvedProfile } : {},
@@ -84810,7 +84864,7 @@ var save_plan = createSwarmTool({
 init_zod();
 init_manager2();
 import * as fs73 from "node:fs";
-import * as path90 from "node:path";
+import * as path91 from "node:path";
 
 // src/sbom/detectors/index.ts
 init_utils();
@@ -85660,7 +85714,7 @@ function findManifestFiles(rootDir) {
     try {
       const entries = fs73.readdirSync(dir, { withFileTypes: true });
       for (const entry of entries) {
-        const fullPath = path90.join(dir, entry.name);
+        const fullPath = path91.join(dir, entry.name);
         if (entry.name.startsWith(".") || entry.name === "node_modules" || entry.name === "dist" || entry.name === "build" || entry.name === "target") {
           continue;
         }
@@ -85669,7 +85723,7 @@ function findManifestFiles(rootDir) {
         } else if (entry.isFile()) {
           for (const pattern of patterns) {
             if (simpleGlobToRegex(pattern).test(entry.name)) {
-              manifestFiles.push(path90.relative(rootDir, fullPath));
+              manifestFiles.push(path91.relative(rootDir, fullPath));
               break;
             }
           }
@@ -85687,11 +85741,11 @@ function findManifestFilesInDirs(directories, workingDir) {
     try {
       const entries = fs73.readdirSync(dir, { withFileTypes: true });
       for (const entry of entries) {
-        const fullPath = path90.join(dir, entry.name);
+        const fullPath = path91.join(dir, entry.name);
         if (entry.isFile()) {
           for (const pattern of patterns) {
             if (simpleGlobToRegex(pattern).test(entry.name)) {
-              found.push(path90.relative(workingDir, fullPath));
+              found.push(path91.relative(workingDir, fullPath));
               break;
             }
           }
@@ -85704,11 +85758,11 @@ function findManifestFilesInDirs(directories, workingDir) {
 function getDirectoriesFromChangedFiles(changedFiles, workingDir) {
   const dirs = new Set;
   for (const file3 of changedFiles) {
-    let currentDir = path90.dirname(file3);
+    let currentDir = path91.dirname(file3);
     while (true) {
-      if (currentDir && currentDir !== "." && currentDir !== path90.sep) {
-        dirs.add(path90.join(workingDir, currentDir));
-        const parent = path90.dirname(currentDir);
+      if (currentDir && currentDir !== "." && currentDir !== path91.sep) {
+        dirs.add(path91.join(workingDir, currentDir));
+        const parent = path91.dirname(currentDir);
         if (parent === currentDir)
           break;
         currentDir = parent;
@@ -85792,7 +85846,7 @@ var sbom_generate = createSwarmTool({
     const changedFiles = obj.changed_files;
     const relativeOutputDir = obj.output_dir || DEFAULT_OUTPUT_DIR;
     const workingDir = directory;
-    const outputDir = path90.isAbsolute(relativeOutputDir) ? relativeOutputDir : path90.join(workingDir, relativeOutputDir);
+    const outputDir = path91.isAbsolute(relativeOutputDir) ? relativeOutputDir : path91.join(workingDir, relativeOutputDir);
     let manifestFiles = [];
     if (scope === "all") {
       manifestFiles = findManifestFiles(workingDir);
@@ -85815,7 +85869,7 @@ var sbom_generate = createSwarmTool({
     const processedFiles = [];
     for (const manifestFile of manifestFiles) {
       try {
-        const fullPath = path90.isAbsolute(manifestFile) ? manifestFile : path90.join(workingDir, manifestFile);
+        const fullPath = path91.isAbsolute(manifestFile) ? manifestFile : path91.join(workingDir, manifestFile);
         if (!fs73.existsSync(fullPath)) {
           continue;
         }
@@ -85832,7 +85886,7 @@ var sbom_generate = createSwarmTool({
     const bom = generateCycloneDX(allComponents);
     const bomJson = serializeCycloneDX(bom);
     const filename = generateSbomFilename();
-    const outputPath = path90.join(outputDir, filename);
+    const outputPath = path91.join(outputDir, filename);
     fs73.writeFileSync(outputPath, bomJson, "utf-8");
     const verdict = processedFiles.length > 0 ? "pass" : "pass";
     try {
@@ -85876,7 +85930,7 @@ var sbom_generate = createSwarmTool({
 init_zod();
 init_create_tool();
 import * as fs74 from "node:fs";
-import * as path91 from "node:path";
+import * as path92 from "node:path";
 var SPEC_CANDIDATES = [
   "openapi.json",
   "openapi.yaml",
@@ -85908,12 +85962,12 @@ function normalizePath3(p) {
 }
 function discoverSpecFile(cwd, specFileArg) {
   if (specFileArg) {
-    const resolvedPath = path91.resolve(cwd, specFileArg);
-    const normalizedCwd = cwd.endsWith(path91.sep) ? cwd : cwd + path91.sep;
+    const resolvedPath = path92.resolve(cwd, specFileArg);
+    const normalizedCwd = cwd.endsWith(path92.sep) ? cwd : cwd + path92.sep;
     if (!resolvedPath.startsWith(normalizedCwd) && resolvedPath !== cwd) {
       throw new Error("Invalid spec_file: path traversal detected");
     }
-    const ext = path91.extname(resolvedPath).toLowerCase();
+    const ext = path92.extname(resolvedPath).toLowerCase();
     if (!ALLOWED_EXTENSIONS.includes(ext)) {
       throw new Error(`Invalid spec_file: must end in .json, .yaml, or .yml, got ${ext}`);
     }
@@ -85927,7 +85981,7 @@ function discoverSpecFile(cwd, specFileArg) {
     return resolvedPath;
   }
   for (const candidate of SPEC_CANDIDATES) {
-    const candidatePath = path91.resolve(cwd, candidate);
+    const candidatePath = path92.resolve(cwd, candidate);
     if (fs74.existsSync(candidatePath)) {
       const stats = fs74.statSync(candidatePath);
       if (stats.size <= MAX_SPEC_SIZE) {
@@ -85939,7 +85993,7 @@ function discoverSpecFile(cwd, specFileArg) {
 }
 function parseSpec(specFile) {
   const content = fs74.readFileSync(specFile, "utf-8");
-  const ext = path91.extname(specFile).toLowerCase();
+  const ext = path92.extname(specFile).toLowerCase();
   if (ext === ".json") {
     return parseJsonSpec(content);
   }
@@ -86015,7 +86069,7 @@ function extractRoutes(cwd) {
       return;
     }
     for (const entry of entries) {
-      const fullPath = path91.join(dir, entry.name);
+      const fullPath = path92.join(dir, entry.name);
       if (entry.isSymbolicLink()) {
         continue;
       }
@@ -86025,7 +86079,7 @@ function extractRoutes(cwd) {
         }
         walkDir(fullPath);
       } else if (entry.isFile()) {
-        const ext = path91.extname(entry.name).toLowerCase();
+        const ext = path92.extname(entry.name).toLowerCase();
         const baseName = entry.name.toLowerCase();
         if (![".ts", ".js", ".mjs"].includes(ext)) {
           continue;
@@ -86192,7 +86246,7 @@ init_zod();
 init_path_security();
 init_create_tool();
 import * as fs75 from "node:fs";
-import * as path92 from "node:path";
+import * as path93 from "node:path";
 var DEFAULT_MAX_RESULTS = 100;
 var DEFAULT_MAX_LINES = 200;
 var REGEX_TIMEOUT_MS = 5000;
@@ -86228,11 +86282,11 @@ function containsWindowsAttacks3(str) {
 }
 function isPathInWorkspace3(filePath, workspace) {
   try {
-    const resolvedPath = path92.resolve(workspace, filePath);
+    const resolvedPath = path93.resolve(workspace, filePath);
     const realWorkspace = fs75.realpathSync(workspace);
     const realResolvedPath = fs75.realpathSync(resolvedPath);
-    const relativePath = path92.relative(realWorkspace, realResolvedPath);
-    if (relativePath.startsWith("..") || path92.isAbsolute(relativePath)) {
+    const relativePath = path93.relative(realWorkspace, realResolvedPath);
+    if (relativePath.startsWith("..") || path93.isAbsolute(relativePath)) {
       return false;
     }
     return true;
@@ -86245,11 +86299,11 @@ function validatePathForRead2(filePath, workspace) {
 }
 function findRgInEnvPath() {
   const searchPath = process.env.PATH ?? "";
-  for (const dir of searchPath.split(path92.delimiter)) {
+  for (const dir of searchPath.split(path93.delimiter)) {
     if (!dir)
       continue;
     const isWindows = process.platform === "win32";
-    const candidate = path92.join(dir, isWindows ? "rg.exe" : "rg");
+    const candidate = path93.join(dir, isWindows ? "rg.exe" : "rg");
     if (fs75.existsSync(candidate))
       return candidate;
   }
@@ -86379,8 +86433,8 @@ function collectFiles(dir, workspace, includeGlobs, excludeGlobs) {
   try {
     const entries = fs75.readdirSync(dir, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = path92.join(dir, entry.name);
-      const relativePath = path92.relative(workspace, fullPath);
+      const fullPath = path93.join(dir, entry.name);
+      const relativePath = path93.relative(workspace, fullPath);
       if (!validatePathForRead2(fullPath, workspace)) {
         continue;
       }
@@ -86421,7 +86475,7 @@ async function fallbackSearch(opts) {
   const matches = [];
   let total = 0;
   for (const file3 of files) {
-    const fullPath = path92.join(opts.workspace, file3);
+    const fullPath = path93.join(opts.workspace, file3);
     if (!validatePathForRead2(fullPath, opts.workspace)) {
       continue;
     }
@@ -86678,7 +86732,7 @@ init_zod();
 init_path_security();
 init_create_tool();
 import * as fs76 from "node:fs";
-import * as path93 from "node:path";
+import * as path94 from "node:path";
 var WINDOWS_RESERVED_NAMES4 = /^(con|prn|aux|nul|com[1-9]|lpt[1-9])(\.|:|$)/i;
 function containsWindowsAttacks4(str) {
   if (/:[^\\/]/.test(str))
@@ -86692,14 +86746,14 @@ function containsWindowsAttacks4(str) {
 }
 function isPathInWorkspace4(filePath, workspace) {
   try {
-    const resolvedPath = path93.resolve(workspace, filePath);
+    const resolvedPath = path94.resolve(workspace, filePath);
     if (!fs76.existsSync(resolvedPath)) {
       return true;
     }
     const realWorkspace = fs76.realpathSync(workspace);
     const realResolvedPath = fs76.realpathSync(resolvedPath);
-    const relativePath = path93.relative(realWorkspace, realResolvedPath);
-    if (relativePath.startsWith("..") || path93.isAbsolute(relativePath)) {
+    const relativePath = path94.relative(realWorkspace, realResolvedPath);
+    if (relativePath.startsWith("..") || path94.isAbsolute(relativePath)) {
       return false;
     }
     return true;
@@ -86907,7 +86961,7 @@ var suggestPatch = createSwarmTool({
         });
         continue;
       }
-      const fullPath = path93.resolve(directory, change.file);
+      const fullPath = path94.resolve(directory, change.file);
       if (!fs76.existsSync(fullPath)) {
         errors5.push({
           success: false,
@@ -87170,7 +87224,7 @@ var generate_mutants = createSwarmTool({
 init_spec_schema();
 init_create_tool();
 import * as fs77 from "node:fs";
-import * as path94 from "node:path";
+import * as path95 from "node:path";
 var SPEC_FILE_NAME = "spec.md";
 var SWARM_DIR2 = ".swarm";
 var OBLIGATION_KEYWORDS2 = ["MUST", "SHALL", "SHOULD", "MAY"];
@@ -87223,7 +87277,7 @@ var lint_spec = createSwarmTool({
   async execute(_args, directory) {
     const errors5 = [];
     const warnings = [];
-    const specPath = path94.join(directory, SWARM_DIR2, SPEC_FILE_NAME);
+    const specPath = path95.join(directory, SWARM_DIR2, SPEC_FILE_NAME);
     if (!fs77.existsSync(specPath)) {
       const result2 = {
         valid: false,
@@ -87294,12 +87348,12 @@ var lint_spec = createSwarmTool({
 // src/tools/mutation-test.ts
 init_zod();
 import * as fs78 from "node:fs";
-import * as path96 from "node:path";
+import * as path97 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 path95 from "node:path";
+import * as path96 from "node:path";
 
 // src/mutation/equivalence.ts
 function isStaticallyEquivalent(originalCode, mutatedCode) {
@@ -87434,7 +87488,7 @@ async function executeMutation(patch, testCommand, _testFiles, workingDir) {
   let patchFile;
   try {
     const safeId2 = patch.id.replace(/[^a-zA-Z0-9_-]/g, "_");
-    patchFile = path95.join(workingDir, `.mutation_patch_${safeId2}.diff`);
+    patchFile = path96.join(workingDir, `.mutation_patch_${safeId2}.diff`);
     try {
       writeFileSync19(patchFile, patch.patch);
     } catch (writeErr) {
@@ -87828,7 +87882,7 @@ var mutation_test = createSwarmTool({
       ];
       for (const filePath of uniquePaths) {
         try {
-          const resolvedPath = path96.resolve(cwd, filePath);
+          const resolvedPath = path97.resolve(cwd, filePath);
           sourceFiles.set(filePath, fs78.readFileSync(resolvedPath, "utf-8"));
         } catch {}
       }
@@ -87848,7 +87902,7 @@ init_zod();
 init_manager2();
 init_detector();
 import * as fs79 from "node:fs";
-import * as path97 from "node:path";
+import * as path98 from "node:path";
 init_create_tool();
 var MAX_FILE_SIZE2 = 2 * 1024 * 1024;
 var BINARY_CHECK_BYTES = 8192;
@@ -87914,7 +87968,7 @@ async function syntaxCheck(input, directory, config3) {
   if (languages?.length) {
     const lowerLangs = languages.map((l) => l.toLowerCase());
     filesToCheck = filesToCheck.filter((file3) => {
-      const ext = path97.extname(file3.path).toLowerCase();
+      const ext = path98.extname(file3.path).toLowerCase();
       const langDef = getLanguageForExtension(ext);
       const fileProfile = getProfileForFile(file3.path);
       const langId = fileProfile?.id || langDef?.id;
@@ -87927,7 +87981,7 @@ async function syntaxCheck(input, directory, config3) {
   let skippedCount = 0;
   for (const fileInfo of filesToCheck) {
     const { path: filePath } = fileInfo;
-    const fullPath = path97.isAbsolute(filePath) ? filePath : path97.join(directory, filePath);
+    const fullPath = path98.isAbsolute(filePath) ? filePath : path98.join(directory, filePath);
     const result = {
       path: filePath,
       language: "",
@@ -87976,7 +88030,7 @@ async function syntaxCheck(input, directory, config3) {
         results.push(result);
         continue;
       }
-      const ext = path97.extname(filePath).toLowerCase();
+      const ext = path98.extname(filePath).toLowerCase();
       const langDef = getLanguageForExtension(ext);
       result.language = profile?.id || langDef?.id || "unknown";
       const errors5 = extractSyntaxErrors(parser, content);
@@ -88069,7 +88123,7 @@ init_utils();
 init_create_tool();
 init_path_security();
 import * as fs80 from "node:fs";
-import * as path98 from "node:path";
+import * as path99 from "node:path";
 var MAX_TEXT_LENGTH = 200;
 var MAX_FILE_SIZE_BYTES11 = 1024 * 1024;
 var SUPPORTED_EXTENSIONS4 = new Set([
@@ -88135,9 +88189,9 @@ function validatePathsInput(paths, cwd) {
     return { error: "paths contains path traversal", resolvedPath: null };
   }
   try {
-    const resolvedPath = path98.resolve(paths);
-    const normalizedCwd = path98.resolve(cwd);
-    const normalizedResolved = path98.resolve(resolvedPath);
+    const resolvedPath = path99.resolve(paths);
+    const normalizedCwd = path99.resolve(cwd);
+    const normalizedResolved = path99.resolve(resolvedPath);
     if (!normalizedResolved.startsWith(normalizedCwd)) {
       return {
         error: "paths must be within the current working directory",
@@ -88153,7 +88207,7 @@ function validatePathsInput(paths, cwd) {
   }
 }
 function isSupportedExtension(filePath) {
-  const ext = path98.extname(filePath).toLowerCase();
+  const ext = path99.extname(filePath).toLowerCase();
   return SUPPORTED_EXTENSIONS4.has(ext);
 }
 function findSourceFiles4(dir, files = []) {
@@ -88168,7 +88222,7 @@ function findSourceFiles4(dir, files = []) {
     if (SKIP_DIRECTORIES5.has(entry)) {
       continue;
     }
-    const fullPath = path98.join(dir, entry);
+    const fullPath = path99.join(dir, entry);
     let stat4;
     try {
       stat4 = fs80.statSync(fullPath);
@@ -88280,7 +88334,7 @@ var todo_extract = createSwarmTool({
         filesToScan.push(scanPath);
       } else {
         const errorResult = {
-          error: `unsupported file extension: ${path98.extname(scanPath)}`,
+          error: `unsupported file extension: ${path99.extname(scanPath)}`,
           total: 0,
           byPriority: { high: 0, medium: 0, low: 0 },
           entries: []
@@ -88329,14 +88383,14 @@ init_schema();
 init_qa_gate_profile();
 init_gate_evidence();
 import * as fs82 from "node:fs";
-import * as path100 from "node:path";
+import * as path101 from "node:path";
 
 // src/hooks/diff-scope.ts
 import * as fs81 from "node:fs";
-import * as path99 from "node:path";
+import * as path100 from "node:path";
 function getDeclaredScope(taskId, directory) {
   try {
-    const planPath = path99.join(directory, ".swarm", "plan.json");
+    const planPath = path100.join(directory, ".swarm", "plan.json");
     if (!fs81.existsSync(planPath))
       return null;
     const raw = fs81.readFileSync(planPath, "utf-8");
@@ -88455,7 +88509,7 @@ var TIER_3_PATTERNS = [
 ];
 function matchesTier3Pattern(files) {
   for (const file3 of files) {
-    const fileName = path100.basename(file3);
+    const fileName = path101.basename(file3);
     for (const pattern of TIER_3_PATTERNS) {
       if (pattern.test(fileName)) {
         return true;
@@ -88469,7 +88523,7 @@ function checkReviewerGate(taskId, workingDirectory, stageBParallelEnabled = fal
     if (hasActiveTurboMode()) {
       const resolvedDir2 = workingDirectory;
       try {
-        const planPath = path100.join(resolvedDir2, ".swarm", "plan.json");
+        const planPath = path101.join(resolvedDir2, ".swarm", "plan.json");
         const planRaw = fs82.readFileSync(planPath, "utf-8");
         const plan = JSON.parse(planRaw);
         for (const planPhase of plan.phases ?? []) {
@@ -88539,7 +88593,7 @@ function checkReviewerGate(taskId, workingDirectory, stageBParallelEnabled = fal
     }
     try {
       const resolvedDir2 = workingDirectory;
-      const planPath = path100.join(resolvedDir2, ".swarm", "plan.json");
+      const planPath = path101.join(resolvedDir2, ".swarm", "plan.json");
       const planRaw = fs82.readFileSync(planPath, "utf-8");
       const plan = JSON.parse(planRaw);
       for (const planPhase of plan.phases ?? []) {
@@ -88697,7 +88751,7 @@ function checkCouncilGate(workingDirectory, taskId) {
     return { blocked: false, reason: "" };
   }
   try {
-    const planPath = path100.join(workingDirectory, ".swarm", "plan.json");
+    const planPath = path101.join(workingDirectory, ".swarm", "plan.json");
     const planRaw = fs82.readFileSync(planPath, "utf-8");
     const planObj = JSON.parse(planRaw);
     if (planObj.swarm && planObj.title) {
@@ -88788,8 +88842,8 @@ async function executeUpdateTaskStatus(args2, fallbackDir) {
         };
       }
     }
-    normalizedDir = path100.normalize(args2.working_directory);
-    const pathParts = normalizedDir.split(path100.sep);
+    normalizedDir = path101.normalize(args2.working_directory);
+    const pathParts = normalizedDir.split(path101.sep);
     if (pathParts.includes("..")) {
       return {
         success: false,
@@ -88799,10 +88853,10 @@ async function executeUpdateTaskStatus(args2, fallbackDir) {
         ]
       };
     }
-    const resolvedDir = path100.resolve(normalizedDir);
+    const resolvedDir = path101.resolve(normalizedDir);
     try {
       const realPath = fs82.realpathSync(resolvedDir);
-      const planPath = path100.join(realPath, ".swarm", "plan.json");
+      const planPath = path101.join(realPath, ".swarm", "plan.json");
       if (!fs82.existsSync(planPath)) {
         return {
           success: false,
@@ -88834,8 +88888,8 @@ async function executeUpdateTaskStatus(args2, fallbackDir) {
   }
   if (args2.status === "in_progress") {
     try {
-      const evidencePath = path100.join(directory, ".swarm", "evidence", `${args2.task_id}.json`);
-      fs82.mkdirSync(path100.dirname(evidencePath), { recursive: true });
+      const evidencePath = path101.join(directory, ".swarm", "evidence", `${args2.task_id}.json`);
+      fs82.mkdirSync(path101.dirname(evidencePath), { recursive: true });
       const fd = fs82.openSync(evidencePath, "wx");
       let writeOk = false;
       try {
@@ -88859,7 +88913,7 @@ async function executeUpdateTaskStatus(args2, fallbackDir) {
     recoverTaskStateFromDelegations(args2.task_id);
     let phaseRequiresReviewer = true;
     try {
-      const planPath = path100.join(directory, ".swarm", "plan.json");
+      const planPath = path101.join(directory, ".swarm", "plan.json");
       const planRaw = fs82.readFileSync(planPath, "utf-8");
       const plan = JSON.parse(planRaw);
       const taskPhase = plan.phases.find((p) => p.tasks.some((t) => t.id === args2.task_id));
@@ -89179,7 +89233,7 @@ init_ledger();
 init_manager();
 init_create_tool();
 import fs83 from "node:fs";
-import path101 from "node:path";
+import path102 from "node:path";
 function derivePlanId5(plan) {
   return `${plan.swarm}-${plan.title}`.replace(/[^a-zA-Z0-9-_]/g, "_");
 }
@@ -89230,7 +89284,7 @@ async function executeWriteDriftEvidence(args2, directory) {
     entries: [evidenceEntry]
   };
   const filename = "drift-verifier.json";
-  const relativePath = path101.join("evidence", String(phase), filename);
+  const relativePath = path102.join("evidence", String(phase), filename);
   let validatedPath;
   try {
     validatedPath = validateSwarmPath(directory, relativePath);
@@ -89241,10 +89295,10 @@ async function executeWriteDriftEvidence(args2, directory) {
       message: error93 instanceof Error ? error93.message : "Failed to validate path"
     }, null, 2);
   }
-  const evidenceDir = path101.dirname(validatedPath);
+  const evidenceDir = path102.dirname(validatedPath);
   try {
     await fs83.promises.mkdir(evidenceDir, { recursive: true });
-    const tempPath = path101.join(evidenceDir, `.${filename}.tmp`);
+    const tempPath = path102.join(evidenceDir, `.${filename}.tmp`);
     await fs83.promises.writeFile(tempPath, JSON.stringify(evidenceContent, null, 2), "utf-8");
     await fs83.promises.rename(tempPath, validatedPath);
     let snapshotInfo;
@@ -89341,7 +89395,7 @@ init_zod();
 init_utils2();
 init_create_tool();
 import fs84 from "node:fs";
-import path102 from "node:path";
+import path103 from "node:path";
 function normalizeVerdict2(verdict) {
   switch (verdict) {
     case "APPROVED":
@@ -89389,7 +89443,7 @@ async function executeWriteHallucinationEvidence(args2, directory) {
     entries: [evidenceEntry]
   };
   const filename = "hallucination-guard.json";
-  const relativePath = path102.join("evidence", String(phase), filename);
+  const relativePath = path103.join("evidence", String(phase), filename);
   let validatedPath;
   try {
     validatedPath = validateSwarmPath(directory, relativePath);
@@ -89400,10 +89454,10 @@ async function executeWriteHallucinationEvidence(args2, directory) {
       message: error93 instanceof Error ? error93.message : "Failed to validate path"
     }, null, 2);
   }
-  const evidenceDir = path102.dirname(validatedPath);
+  const evidenceDir = path103.dirname(validatedPath);
   try {
     await fs84.promises.mkdir(evidenceDir, { recursive: true });
-    const tempPath = path102.join(evidenceDir, `.${filename}.tmp`);
+    const tempPath = path103.join(evidenceDir, `.${filename}.tmp`);
     await fs84.promises.writeFile(tempPath, JSON.stringify(evidenceContent, null, 2), "utf-8");
     await fs84.promises.rename(tempPath, validatedPath);
     return JSON.stringify({
@@ -89452,7 +89506,7 @@ init_zod();
 init_utils2();
 init_create_tool();
 import fs85 from "node:fs";
-import path103 from "node:path";
+import path104 from "node:path";
 function normalizeVerdict3(verdict) {
   switch (verdict) {
     case "PASS":
@@ -89526,7 +89580,7 @@ async function executeWriteMutationEvidence(args2, directory) {
     entries: [evidenceEntry]
   };
   const filename = "mutation-gate.json";
-  const relativePath = path103.join("evidence", String(phase), filename);
+  const relativePath = path104.join("evidence", String(phase), filename);
   let validatedPath;
   try {
     validatedPath = validateSwarmPath(directory, relativePath);
@@ -89537,10 +89591,10 @@ async function executeWriteMutationEvidence(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 fs85.promises.mkdir(evidenceDir, { recursive: true });
-    const tempPath = path103.join(evidenceDir, `.${filename}.tmp`);
+    const tempPath = path104.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({
@@ -89597,19 +89651,19 @@ init_utils();
 
 // src/utils/gitignore-warning.ts
 import * as fs86 from "node:fs";
-import * as path104 from "node:path";
+import * as path105 from "node:path";
 var _gitignoreWarningEmitted = false;
 function findGitRoot(startDir) {
   let current = startDir;
   while (true) {
     try {
-      const gitPath = path104.join(current, ".git");
+      const gitPath = path105.join(current, ".git");
       const stat4 = fs86.statSync(gitPath);
       if (stat4.isDirectory()) {
         return current;
       }
     } catch {}
-    const parent = path104.dirname(current);
+    const parent = path105.dirname(current);
     if (parent === current) {
       return null;
     }
@@ -89641,12 +89695,12 @@ function warnIfSwarmNotGitignored(directory, quiet = false) {
     const gitRoot = findGitRoot(directory);
     if (!gitRoot)
       return;
-    const gitignoreContent = readFileSafe(path104.join(gitRoot, ".gitignore"));
+    const gitignoreContent = readFileSafe(path105.join(gitRoot, ".gitignore"));
     if (gitignoreContent !== null && fileCoversSwarm(gitignoreContent)) {
       _gitignoreWarningEmitted = true;
       return;
     }
-    const excludeContent = readFileSafe(path104.join(gitRoot, ".git", "info", "exclude"));
+    const excludeContent = readFileSafe(path105.join(gitRoot, ".git", "info", "exclude"));
     if (excludeContent !== null && fileCoversSwarm(excludeContent)) {
       _gitignoreWarningEmitted = true;
       return;
@@ -89694,8 +89748,8 @@ init_warning_buffer();
 var _heartbeatTimers = new Map;
 function writeSwarmConfigExampleIfNew(projectDirectory) {
   try {
-    const swarmDir = path105.join(projectDirectory, ".swarm");
-    const dest = path105.join(swarmDir, "config.example.json");
+    const swarmDir = path106.join(projectDirectory, ".swarm");
+    const dest = path106.join(swarmDir, "config.example.json");
     if (fs87.existsSync(dest))
       return;
     const example = {
@@ -89899,7 +89953,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 = path105.resolve(ctx.directory, ".swarm");
+    const swarmDir = path106.resolve(ctx.directory, ".swarm");
     statusArtifact = new ASA(swarmDir);
     statusArtifact.updateConfig(automationConfig.mode, automationConfig.capabilities);
     if (automationConfig.capabilities?.evidence_auto_summaries === true) {