opencode-swarm 6.86.8 → 6.86.9

package/dist/index.js

@@ -33,7 +33,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "opencode-swarm",
-    version: "6.86.8",
+    version: "6.86.9",
     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",
@@ -43890,24 +43890,41 @@ var init_dark_matter = __esm(() => {
   init_co_change_analyzer();
 });
 
+// src/config/cache-paths.ts
+import * as os5 from "node:os";
+import * as path24 from "node:path";
+function getPluginConfigDir() {
+  return path24.join(process.env.XDG_CONFIG_HOME || path24.join(os5.homedir(), ".config"), "opencode");
+}
+function getPluginCachePaths() {
+  const cacheBase = process.env.XDG_CACHE_HOME || path24.join(os5.homedir(), ".cache");
+  const configDir = getPluginConfigDir();
+  return [
+    path24.join(cacheBase, "opencode", "packages", "opencode-swarm@latest"),
+    path24.join(configDir, "node_modules", "opencode-swarm"),
+    path24.join(cacheBase, "opencode", "node_modules", "opencode-swarm")
+  ];
+}
+var init_cache_paths = () => {};
+
 // src/services/version-check.ts
 import { existsSync as existsSync11, mkdirSync as mkdirSync11, readFileSync as readFileSync6, writeFileSync as writeFileSync4 } from "node:fs";
-import { homedir as homedir4 } from "node:os";
-import { join as join21 } from "node:path";
+import { homedir as homedir5 } from "node:os";
+import { join as join22 } from "node:path";
 function cacheDir() {
   const xdg = process.env.XDG_CACHE_HOME;
-  const base = xdg && xdg.length > 0 ? xdg : join21(homedir4(), ".cache");
-  return join21(base, "opencode-swarm");
+  const base = xdg && xdg.length > 0 ? xdg : join22(homedir5(), ".cache");
+  return join22(base, "opencode-swarm");
 }
 function cacheFile() {
-  return join21(cacheDir(), "version-check.json");
+  return join22(cacheDir(), "version-check.json");
 }
 function readVersionCache() {
   try {
-    const path24 = cacheFile();
-    if (!existsSync11(path24))
+    const path25 = cacheFile();
+    if (!existsSync11(path25))
       return null;
-    const raw = readFileSync6(path24, "utf-8");
+    const raw = readFileSync6(path25, "utf-8");
     const parsed = JSON.parse(raw);
     if (typeof parsed?.checkedAt !== "number")
       return null;
@@ -44005,7 +44022,7 @@ var init_version_check = __esm(() => {
 // src/services/diagnose-service.ts
 import * as child_process4 from "node:child_process";
 import { existsSync as existsSync12, readdirSync as readdirSync4, readFileSync as readFileSync7, statSync as statSync6 } from "node:fs";
-import path24 from "node:path";
+import path25 from "node:path";
 import { fileURLToPath } from "node:url";
 function validateTaskDag(plan) {
   const allTaskIds = new Set;
@@ -44302,7 +44319,7 @@ async function checkSpecStaleness(directory, plan) {
   };
 }
 async function checkConfigParseability(directory) {
-  const configPath = path24.join(directory, ".opencode/opencode-swarm.json");
+  const configPath = path25.join(directory, ".opencode/opencode-swarm.json");
   if (!existsSync12(configPath)) {
     return {
       name: "Config Parseability",
@@ -44331,7 +44348,7 @@ function resolveGrammarDir(thisDir) {
   const normalized = thisDir.replace(/\\/g, "/");
   const isSource = normalized.endsWith("/src/services");
   const isCliBundle = normalized.endsWith("/cli");
-  return isSource || isCliBundle ? path24.join(thisDir, "..", "lang", "grammars") : path24.join(thisDir, "lang", "grammars");
+  return isSource || isCliBundle ? path25.join(thisDir, "..", "lang", "grammars") : path25.join(thisDir, "lang", "grammars");
 }
 async function checkGrammarWasmFiles() {
   const grammarFiles = [
@@ -44355,14 +44372,14 @@ async function checkGrammarWasmFiles() {
     "tree-sitter-ini.wasm",
     "tree-sitter-regex.wasm"
   ];
-  const thisDir = path24.dirname(fileURLToPath(import.meta.url));
+  const thisDir = path25.dirname(fileURLToPath(import.meta.url));
   const grammarDir = resolveGrammarDir(thisDir);
   const missing = [];
-  if (!existsSync12(path24.join(grammarDir, "tree-sitter.wasm"))) {
+  if (!existsSync12(path25.join(grammarDir, "tree-sitter.wasm"))) {
     missing.push("tree-sitter.wasm (core runtime)");
   }
   for (const file3 of grammarFiles) {
-    if (!existsSync12(path24.join(grammarDir, file3))) {
+    if (!existsSync12(path25.join(grammarDir, file3))) {
       missing.push(file3);
     }
   }
@@ -44380,7 +44397,7 @@ async function checkGrammarWasmFiles() {
   };
 }
 async function checkCheckpointManifest(directory) {
-  const manifestPath = path24.join(directory, ".swarm/checkpoints.json");
+  const manifestPath = path25.join(directory, ".swarm/checkpoints.json");
   if (!existsSync12(manifestPath)) {
     return {
       name: "Checkpoint Manifest",
@@ -44432,7 +44449,7 @@ async function checkCheckpointManifest(directory) {
   }
 }
 async function checkEventStreamIntegrity(directory) {
-  const eventsPath = path24.join(directory, ".swarm/events.jsonl");
+  const eventsPath = path25.join(directory, ".swarm/events.jsonl");
   if (!existsSync12(eventsPath)) {
     return {
       name: "Event Stream",
@@ -44473,7 +44490,7 @@ async function checkEventStreamIntegrity(directory) {
   }
 }
 async function checkSteeringDirectives(directory) {
-  const eventsPath = path24.join(directory, ".swarm/events.jsonl");
+  const eventsPath = path25.join(directory, ".swarm/events.jsonl");
   if (!existsSync12(eventsPath)) {
     return {
       name: "Steering Directives",
@@ -44529,7 +44546,7 @@ async function checkCurator(directory) {
         detail: "Disabled (enable via curator.enabled)"
       };
     }
-    const summaryPath = path24.join(directory, ".swarm/curator-summary.json");
+    const summaryPath = path25.join(directory, ".swarm/curator-summary.json");
     if (!existsSync12(summaryPath)) {
       return {
         name: "Curator",
@@ -44695,7 +44712,7 @@ async function getDiagnoseData(directory) {
   checks5.push(await checkSteeringDirectives(directory));
   checks5.push(await checkCurator(directory));
   try {
-    const evidenceDir = path24.join(directory, ".swarm", "evidence");
+    const evidenceDir = path25.join(directory, ".swarm", "evidence");
     const snapshotFiles = existsSync12(evidenceDir) ? readdirSync4(evidenceDir).filter((f) => f.startsWith("agent-tools-") && f.endsWith(".json")) : [];
     if (snapshotFiles.length > 0) {
       const latest = snapshotFiles.sort().pop();
@@ -44725,7 +44742,36 @@ async function getDiagnoseData(directory) {
       detail: `${deferredWarnings.length} warning(s) deferred from init (run with verbose logs for details)`
     });
   }
-  const passCount = checks5.filter((c) => c.status === "✅").length;
+  const cachePaths = getPluginCachePaths();
+  const cacheRows = [];
+  for (const cachePath of cachePaths) {
+    try {
+      if (!existsSync12(cachePath)) {
+        cacheRows.push(`⬜ ${cachePath} — absent`);
+        continue;
+      }
+      const pkgJsonPath = path25.join(cachePath, "package.json");
+      try {
+        const raw = readFileSync7(pkgJsonPath, "utf-8");
+        const parsed = JSON.parse(raw);
+        const installedVersion = typeof parsed.version === "string" ? parsed.version : "?";
+        cacheRows.push(`✅ ${cachePath} — v${installedVersion}`);
+      } catch {
+        cacheRows.push(`⚠️ ${cachePath} — present (package.json unreadable)`);
+      }
+    } catch {
+      cacheRows.push(`⚠️ ${cachePath} — status unknown (read error)`);
+    }
+  }
+  const hasCacheEntry = cacheRows.some((r) => r.startsWith("✅"));
+  const hasCacheWarning = cacheRows.some((r) => r.startsWith("⚠️"));
+  const cacheStatus = hasCacheWarning ? "⚠️" : hasCacheEntry ? "✅" : "⬜";
+  checks5.push({
+    name: "Plugin Caches",
+    status: cacheStatus,
+    detail: cacheRows.join(" | ")
+  });
+  const passCount = checks5.filter((c) => c.status === "✅" || c.status === "⬜").length;
   const totalCount = checks5.length;
   const allPassed = passCount === totalCount;
   return {
@@ -44761,6 +44807,7 @@ async function handleDiagnoseCommand(directory, _args) {
 var version3;
 var init_diagnose_service = __esm(() => {
   init_package();
+  init_cache_paths();
   init_loader();
   init_manager2();
   init_utils2();
@@ -44790,14 +44837,14 @@ __export(exports_config_doctor, {
 });
 import * as crypto3 from "node:crypto";
 import * as fs14 from "node:fs";
-import * as os5 from "node:os";
-import * as path25 from "node:path";
+import * as os6 from "node:os";
+import * as path26 from "node:path";
 function getUserConfigDir3() {
-  return process.env.XDG_CONFIG_HOME || path25.join(os5.homedir(), ".config");
+  return process.env.XDG_CONFIG_HOME || path26.join(os6.homedir(), ".config");
 }
 function getConfigPaths(directory) {
-  const userConfigPath = path25.join(getUserConfigDir3(), "opencode", "opencode-swarm.json");
-  const projectConfigPath = path25.join(directory, ".opencode", "opencode-swarm.json");
+  const userConfigPath = path26.join(getUserConfigDir3(), "opencode", "opencode-swarm.json");
+  const projectConfigPath = path26.join(directory, ".opencode", "opencode-swarm.json");
   return { userConfigPath, projectConfigPath };
 }
 function computeHash(content) {
@@ -44822,9 +44869,9 @@ function isValidConfigPath(configPath, directory) {
   const normalizedUser = userConfigPath.replace(/\\/g, "/");
   const normalizedProject = projectConfigPath.replace(/\\/g, "/");
   try {
-    const resolvedConfig = path25.resolve(configPath);
-    const resolvedUser = path25.resolve(normalizedUser);
-    const resolvedProject = path25.resolve(normalizedProject);
+    const resolvedConfig = path26.resolve(configPath);
+    const resolvedUser = path26.resolve(normalizedUser);
+    const resolvedProject = path26.resolve(normalizedProject);
     return resolvedConfig === resolvedUser || resolvedConfig === resolvedProject;
   } catch {
     return false;
@@ -44864,12 +44911,12 @@ function createConfigBackup(directory) {
   };
 }
 function writeBackupArtifact(directory, backup) {
-  const swarmDir = path25.join(directory, ".swarm");
+  const swarmDir = path26.join(directory, ".swarm");
   if (!fs14.existsSync(swarmDir)) {
     fs14.mkdirSync(swarmDir, { recursive: true });
   }
   const backupFilename = `config-backup-${backup.createdAt}.json`;
-  const backupPath = path25.join(swarmDir, backupFilename);
+  const backupPath = path26.join(swarmDir, backupFilename);
   const artifact = {
     createdAt: backup.createdAt,
     configPath: backup.configPath,
@@ -44899,7 +44946,7 @@ function restoreFromBackup(backupPath, directory) {
       return null;
     }
     const targetPath = artifact.configPath;
-    const targetDir = path25.dirname(targetPath);
+    const targetDir = path26.dirname(targetPath);
     if (!fs14.existsSync(targetDir)) {
       fs14.mkdirSync(targetDir, { recursive: true });
     }
@@ -44930,9 +44977,9 @@ function readConfigFromFile(directory) {
     return null;
   }
 }
-function validateConfigKey(path26, value, _config) {
+function validateConfigKey(path27, value, _config) {
   const findings = [];
-  switch (path26) {
+  switch (path27) {
     case "agents": {
       if (value !== undefined) {
         findings.push({
@@ -45179,27 +45226,27 @@ function validateConfigKey(path26, value, _config) {
   }
   return findings;
 }
-function walkConfigAndValidate(obj, path26, config3, findings) {
+function walkConfigAndValidate(obj, path27, config3, findings) {
   if (obj === null || obj === undefined) {
     return;
   }
-  if (path26 && typeof obj === "object" && !Array.isArray(obj)) {
-    const keyFindings = validateConfigKey(path26, obj, config3);
+  if (path27 && typeof obj === "object" && !Array.isArray(obj)) {
+    const keyFindings = validateConfigKey(path27, obj, config3);
     findings.push(...keyFindings);
   }
   if (typeof obj !== "object") {
-    const keyFindings = validateConfigKey(path26, obj, config3);
+    const keyFindings = validateConfigKey(path27, obj, config3);
     findings.push(...keyFindings);
     return;
   }
   if (Array.isArray(obj)) {
     obj.forEach((item, index) => {
-      walkConfigAndValidate(item, `${path26}[${index}]`, config3, findings);
+      walkConfigAndValidate(item, `${path27}[${index}]`, config3, findings);
     });
     return;
   }
   for (const [key, value] of Object.entries(obj)) {
-    const newPath = path26 ? `${path26}.${key}` : key;
+    const newPath = path27 ? `${path27}.${key}` : key;
     walkConfigAndValidate(value, newPath, config3, findings);
   }
 }
@@ -45319,7 +45366,7 @@ function applySafeAutoFixes(directory, result) {
     }
   }
   if (appliedFixes.length > 0) {
-    const configDir = path25.dirname(configPath);
+    const configDir = path26.dirname(configPath);
     if (!fs14.existsSync(configDir)) {
       fs14.mkdirSync(configDir, { recursive: true });
     }
@@ -45329,12 +45376,12 @@ function applySafeAutoFixes(directory, result) {
   return { appliedFixes, updatedConfigPath };
 }
 function writeDoctorArtifact(directory, result) {
-  const swarmDir = path25.join(directory, ".swarm");
+  const swarmDir = path26.join(directory, ".swarm");
   if (!fs14.existsSync(swarmDir)) {
     fs14.mkdirSync(swarmDir, { recursive: true });
   }
   const artifactFilename = "config-doctor.json";
-  const artifactPath = path25.join(swarmDir, artifactFilename);
+  const artifactPath = path26.join(swarmDir, artifactFilename);
   const guiOutput = {
     timestamp: result.timestamp,
     summary: result.summary,
@@ -46381,7 +46428,7 @@ var init_profiles = __esm(() => {
 
 // src/lang/detector.ts
 import { access as access2, readdir as readdir3 } from "node:fs/promises";
-import { extname as extname2, join as join23 } from "node:path";
+import { extname as extname2, join as join24 } from "node:path";
 function getProfileForFile(filePath) {
   const ext = extname2(filePath);
   if (!ext)
@@ -46403,7 +46450,7 @@ async function detectProjectLanguages(projectDir) {
         if (detectFile.includes("*") || detectFile.includes("?"))
           continue;
         try {
-          await access2(join23(dir, detectFile));
+          await access2(join24(dir, detectFile));
           detected.add(profile.id);
           break;
         } catch {}
@@ -46424,7 +46471,7 @@ async function detectProjectLanguages(projectDir) {
     const topEntries = await readdir3(projectDir, { withFileTypes: true });
     for (const entry of topEntries) {
       if (entry.isDirectory() && !entry.name.startsWith(".") && entry.name !== "node_modules") {
-        await scanDir(join23(projectDir, entry.name));
+        await scanDir(join24(projectDir, entry.name));
       }
     }
   } catch {}
@@ -46443,7 +46490,7 @@ var init_detector = __esm(() => {
 
 // src/build/discovery.ts
 import * as fs15 from "node:fs";
-import * as path26 from "node:path";
+import * as path27 from "node:path";
 function isCommandAvailable(command) {
   if (toolchainCache.has(command)) {
     return toolchainCache.get(command);
@@ -46476,11 +46523,11 @@ function findBuildFiles(workingDir, patterns) {
         const regex = simpleGlobToRegex(pattern);
         const matches = files.filter((f) => regex.test(f));
         if (matches.length > 0) {
-          return path26.join(dir, matches[0]);
+          return path27.join(dir, matches[0]);
         }
       } catch {}
     } else {
-      const filePath = path26.join(workingDir, pattern);
+      const filePath = path27.join(workingDir, pattern);
       if (fs15.existsSync(filePath)) {
         return filePath;
       }
@@ -46489,7 +46536,7 @@ function findBuildFiles(workingDir, patterns) {
   return null;
 }
 function getRepoDefinedScripts(workingDir, scripts) {
-  const packageJsonPath = path26.join(workingDir, "package.json");
+  const packageJsonPath = path27.join(workingDir, "package.json");
   if (!fs15.existsSync(packageJsonPath)) {
     return [];
   }
@@ -46530,7 +46577,7 @@ function findAllBuildFiles(workingDir) {
         const regex = simpleGlobToRegex(pattern);
         findFilesRecursive(workingDir, regex, allBuildFiles);
       } else {
-        const filePath = path26.join(workingDir, pattern);
+        const filePath = path27.join(workingDir, pattern);
         if (fs15.existsSync(filePath)) {
           allBuildFiles.add(filePath);
         }
@@ -46543,7 +46590,7 @@ function findFilesRecursive(dir, regex, results) {
   try {
     const entries = fs15.readdirSync(dir, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = path26.join(dir, entry.name);
+      const fullPath = path27.join(dir, entry.name);
       if (entry.isDirectory() && !["node_modules", ".git", "dist", "build", "target"].includes(entry.name)) {
         findFilesRecursive(fullPath, regex, results);
       } else if (entry.isFile() && regex.test(entry.name)) {
@@ -46566,7 +46613,7 @@ async function discoverBuildCommandsFromProfiles(workingDir) {
     let foundCommand = false;
     for (const cmd of sortedCommands) {
       if (cmd.detectFile) {
-        const detectFilePath = path26.join(workingDir, cmd.detectFile);
+        const detectFilePath = path27.join(workingDir, cmd.detectFile);
         if (!fs15.existsSync(detectFilePath)) {
           continue;
         }
@@ -46797,7 +46844,7 @@ __export(exports_tool_doctor, {
   getBinaryReadinessAdvisory: () => getBinaryReadinessAdvisory
 });
 import * as fs16 from "node:fs";
-import * as path27 from "node:path";
+import * as path28 from "node:path";
 function extractRegisteredToolKeys(indexPath) {
   const registeredKeys = new Set;
   try {
@@ -46864,8 +46911,8 @@ function getBinaryReadinessAdvisory() {
 }
 function runToolDoctor(_directory, pluginRoot) {
   const findings = [];
-  const resolvedPluginRoot = pluginRoot ?? path27.resolve(import.meta.dir, "..", "..");
-  const indexPath = path27.join(resolvedPluginRoot, "src", "index.ts");
+  const resolvedPluginRoot = pluginRoot ?? path28.resolve(import.meta.dir, "..", "..");
+  const indexPath = path28.join(resolvedPluginRoot, "src", "index.ts");
   if (!fs16.existsSync(indexPath)) {
     return {
       findings: [
@@ -48123,10 +48170,10 @@ var init_history = __esm(() => {
 import { randomUUID as randomUUID3 } from "node:crypto";
 import { existsSync as existsSync16, readFileSync as readFileSync11 } from "node:fs";
 import { mkdir as mkdir5, readFile as readFile6, writeFile as writeFile5 } from "node:fs/promises";
-import * as path28 from "node:path";
+import * as path29 from "node:path";
 async function migrateContextToKnowledge(directory, config3) {
-  const sentinelPath = path28.join(directory, ".swarm", ".knowledge-migrated");
-  const contextPath = path28.join(directory, ".swarm", "context.md");
+  const sentinelPath = path29.join(directory, ".swarm", ".knowledge-migrated");
+  const contextPath = path29.join(directory, ".swarm", "context.md");
   const knowledgePath = resolveSwarmKnowledgePath(directory);
   if (existsSync16(sentinelPath)) {
     return {
@@ -48322,7 +48369,7 @@ function truncateLesson(text) {
   return `${text.slice(0, 277)}...`;
 }
 function inferProjectName(directory) {
-  const packageJsonPath = path28.join(directory, "package.json");
+  const packageJsonPath = path29.join(directory, "package.json");
   if (existsSync16(packageJsonPath)) {
     try {
       const pkg = JSON.parse(readFileSync11(packageJsonPath, "utf-8"));
@@ -48331,7 +48378,7 @@ function inferProjectName(directory) {
       }
     } catch {}
   }
-  return path28.basename(directory);
+  return path29.basename(directory);
 }
 async function writeSentinel(sentinelPath, migrated, dropped) {
   const sentinel = {
@@ -48343,7 +48390,7 @@ async function writeSentinel(sentinelPath, migrated, dropped) {
     schema_version: 1,
     migration_tool: "knowledge-migrator.ts"
   };
-  await mkdir5(path28.dirname(sentinelPath), { recursive: true });
+  await mkdir5(path29.dirname(sentinelPath), { recursive: true });
   await writeFile5(sentinelPath, JSON.stringify(sentinel, null, 2), "utf-8");
 }
 var init_knowledge_migrator = __esm(() => {
@@ -48596,7 +48643,7 @@ var init_plan = __esm(() => {
 
 // src/utils/path-security.ts
 import * as fs17 from "node:fs";
-import * as path29 from "node:path";
+import * as path30 from "node:path";
 function containsPathTraversal(str) {
   if (/\.\.[/\\]/.test(str))
     return true;
@@ -48647,17 +48694,17 @@ function validateSymlinkBoundary(targetPath, rootPath) {
   try {
     realTarget = fs17.realpathSync(targetPath);
   } catch {
-    realTarget = path29.normalize(targetPath);
+    realTarget = path30.normalize(targetPath);
   }
   let realRoot;
   try {
     realRoot = fs17.realpathSync(rootPath);
   } catch {
-    realRoot = path29.normalize(rootPath);
+    realRoot = path30.normalize(rootPath);
   }
-  const normalizedTarget = path29.normalize(realTarget);
-  const normalizedRoot = path29.normalize(realRoot);
-  if (!normalizedTarget.startsWith(normalizedRoot + path29.sep) && normalizedTarget !== normalizedRoot) {
+  const normalizedTarget = path30.normalize(realTarget);
+  const normalizedRoot = path30.normalize(realRoot);
+  if (!normalizedTarget.startsWith(normalizedRoot + path30.sep) && normalizedTarget !== normalizedRoot) {
     throw new Error(`Symlink resolution escaped boundary: ${realTarget} is not within ${realRoot}`);
   }
 }
@@ -48665,7 +48712,7 @@ var init_path_security = () => {};
 
 // src/tools/lint.ts
 import * as fs18 from "node:fs";
-import * as path30 from "node:path";
+import * as path31 from "node:path";
 function validateArgs(args2) {
   if (typeof args2 !== "object" || args2 === null)
     return false;
@@ -48676,9 +48723,9 @@ function validateArgs(args2) {
 }
 function getLinterCommand(linter, mode, projectDir) {
   const isWindows = process.platform === "win32";
-  const binDir = path30.join(projectDir, "node_modules", ".bin");
-  const biomeBin = isWindows ? path30.join(binDir, "biome.EXE") : path30.join(binDir, "biome");
-  const eslintBin = isWindows ? path30.join(binDir, "eslint.cmd") : path30.join(binDir, "eslint");
+  const binDir = path31.join(projectDir, "node_modules", ".bin");
+  const biomeBin = isWindows ? path31.join(binDir, "biome.EXE") : path31.join(binDir, "biome");
+  const eslintBin = isWindows ? path31.join(binDir, "eslint.cmd") : path31.join(binDir, "eslint");
   switch (linter) {
     case "biome":
       if (mode === "fix") {
@@ -48694,7 +48741,7 @@ function getLinterCommand(linter, mode, projectDir) {
 }
 function getAdditionalLinterCommand(linter, mode, cwd) {
   const gradlewName = process.platform === "win32" ? "gradlew.bat" : "gradlew";
-  const gradlew = fs18.existsSync(path30.join(cwd, gradlewName)) ? path30.join(cwd, gradlewName) : null;
+  const gradlew = fs18.existsSync(path31.join(cwd, gradlewName)) ? path31.join(cwd, gradlewName) : null;
   switch (linter) {
     case "ruff":
       return mode === "fix" ? ["ruff", "check", "--fix", "."] : ["ruff", "check", "."];
@@ -48728,10 +48775,10 @@ function getAdditionalLinterCommand(linter, mode, cwd) {
   }
 }
 function detectRuff(cwd) {
-  if (fs18.existsSync(path30.join(cwd, "ruff.toml")))
+  if (fs18.existsSync(path31.join(cwd, "ruff.toml")))
     return isCommandAvailable("ruff");
   try {
-    const pyproject = path30.join(cwd, "pyproject.toml");
+    const pyproject = path31.join(cwd, "pyproject.toml");
     if (fs18.existsSync(pyproject)) {
       const content = fs18.readFileSync(pyproject, "utf-8");
       if (content.includes("[tool.ruff]"))
@@ -48741,19 +48788,19 @@ function detectRuff(cwd) {
   return false;
 }
 function detectClippy(cwd) {
-  return fs18.existsSync(path30.join(cwd, "Cargo.toml")) && isCommandAvailable("cargo");
+  return fs18.existsSync(path31.join(cwd, "Cargo.toml")) && isCommandAvailable("cargo");
 }
 function detectGolangciLint(cwd) {
-  return fs18.existsSync(path30.join(cwd, "go.mod")) && isCommandAvailable("golangci-lint");
+  return fs18.existsSync(path31.join(cwd, "go.mod")) && isCommandAvailable("golangci-lint");
 }
 function detectCheckstyle(cwd) {
-  const hasMaven = fs18.existsSync(path30.join(cwd, "pom.xml"));
-  const hasGradle = fs18.existsSync(path30.join(cwd, "build.gradle")) || fs18.existsSync(path30.join(cwd, "build.gradle.kts"));
-  const hasBinary = hasMaven && isCommandAvailable("mvn") || hasGradle && (fs18.existsSync(path30.join(cwd, "gradlew")) || isCommandAvailable("gradle"));
+  const hasMaven = fs18.existsSync(path31.join(cwd, "pom.xml"));
+  const hasGradle = fs18.existsSync(path31.join(cwd, "build.gradle")) || fs18.existsSync(path31.join(cwd, "build.gradle.kts"));
+  const hasBinary = hasMaven && isCommandAvailable("mvn") || hasGradle && (fs18.existsSync(path31.join(cwd, "gradlew")) || isCommandAvailable("gradle"));
   return (hasMaven || hasGradle) && hasBinary;
 }
 function detectKtlint(cwd) {
-  const hasKotlin = fs18.existsSync(path30.join(cwd, "build.gradle.kts")) || fs18.existsSync(path30.join(cwd, "build.gradle")) || (() => {
+  const hasKotlin = fs18.existsSync(path31.join(cwd, "build.gradle.kts")) || fs18.existsSync(path31.join(cwd, "build.gradle")) || (() => {
     try {
       return fs18.readdirSync(cwd).some((f) => f.endsWith(".kt") || f.endsWith(".kts"));
     } catch {
@@ -48772,11 +48819,11 @@ function detectDotnetFormat(cwd) {
   }
 }
 function detectCppcheck(cwd) {
-  if (fs18.existsSync(path30.join(cwd, "CMakeLists.txt"))) {
+  if (fs18.existsSync(path31.join(cwd, "CMakeLists.txt"))) {
     return isCommandAvailable("cppcheck");
   }
   try {
-    const dirsToCheck = [cwd, path30.join(cwd, "src")];
+    const dirsToCheck = [cwd, path31.join(cwd, "src")];
     const hasCpp = dirsToCheck.some((dir) => {
       try {
         return fs18.readdirSync(dir).some((f) => /\.(c|cpp|cc|cxx|h|hpp)$/.test(f));
@@ -48790,13 +48837,13 @@ function detectCppcheck(cwd) {
   }
 }
 function detectSwiftlint(cwd) {
-  return fs18.existsSync(path30.join(cwd, "Package.swift")) && isCommandAvailable("swiftlint");
+  return fs18.existsSync(path31.join(cwd, "Package.swift")) && isCommandAvailable("swiftlint");
 }
 function detectDartAnalyze(cwd) {
-  return fs18.existsSync(path30.join(cwd, "pubspec.yaml")) && (isCommandAvailable("dart") || isCommandAvailable("flutter"));
+  return fs18.existsSync(path31.join(cwd, "pubspec.yaml")) && (isCommandAvailable("dart") || isCommandAvailable("flutter"));
 }
 function detectRubocop(cwd) {
-  return (fs18.existsSync(path30.join(cwd, "Gemfile")) || fs18.existsSync(path30.join(cwd, "gems.rb")) || fs18.existsSync(path30.join(cwd, ".rubocop.yml"))) && (isCommandAvailable("rubocop") || isCommandAvailable("bundle"));
+  return (fs18.existsSync(path31.join(cwd, "Gemfile")) || fs18.existsSync(path31.join(cwd, "gems.rb")) || fs18.existsSync(path31.join(cwd, ".rubocop.yml"))) && (isCommandAvailable("rubocop") || isCommandAvailable("bundle"));
 }
 function detectAdditionalLinter(cwd) {
   if (detectRuff(cwd))
@@ -48824,10 +48871,10 @@ function detectAdditionalLinter(cwd) {
 function resolveLinterBinPath(linter, projectDir) {
   const isWindows = process.platform === "win32";
   const binName = linter === "biome" ? isWindows ? "biome.EXE" : "biome" : isWindows ? "eslint.cmd" : "eslint";
-  const localBin = path30.join(projectDir, "node_modules", ".bin", binName);
+  const localBin = path31.join(projectDir, "node_modules", ".bin", binName);
   if (fs18.existsSync(localBin))
     return localBin;
-  const ancestor = findBinInAncestors(path30.dirname(projectDir), binName);
+  const ancestor = findBinInAncestors(path31.dirname(projectDir), binName);
   if (ancestor)
     return ancestor;
   const fromPath = findBinInEnvPath(binName);
@@ -48838,10 +48885,10 @@ function resolveLinterBinPath(linter, projectDir) {
 function findBinInAncestors(startDir, binName) {
   let dir = startDir;
   while (true) {
-    const candidate = path30.join(dir, "node_modules", ".bin", binName);
+    const candidate = path31.join(dir, "node_modules", ".bin", binName);
     if (fs18.existsSync(candidate))
       return candidate;
-    const parent = path30.dirname(dir);
+    const parent = path31.dirname(dir);
     if (parent === dir)
       break;
     dir = parent;
@@ -48850,10 +48897,10 @@ function findBinInAncestors(startDir, binName) {
 }
 function findBinInEnvPath(binName) {
   const searchPath = process.env.PATH ?? "";
-  for (const dir of searchPath.split(path30.delimiter)) {
+  for (const dir of searchPath.split(path31.delimiter)) {
     if (!dir)
       continue;
-    const candidate = path30.join(dir, binName);
+    const candidate = path31.join(dir, binName);
     if (fs18.existsSync(candidate))
       return candidate;
   }
@@ -48866,13 +48913,13 @@ async function detectAvailableLinter(directory) {
     return null;
   const projectDir = directory;
   const isWindows = process.platform === "win32";
-  const biomeBin = isWindows ? path30.join(projectDir, "node_modules", ".bin", "biome.EXE") : path30.join(projectDir, "node_modules", ".bin", "biome");
-  const eslintBin = isWindows ? path30.join(projectDir, "node_modules", ".bin", "eslint.cmd") : path30.join(projectDir, "node_modules", ".bin", "eslint");
+  const biomeBin = isWindows ? path31.join(projectDir, "node_modules", ".bin", "biome.EXE") : path31.join(projectDir, "node_modules", ".bin", "biome");
+  const eslintBin = isWindows ? path31.join(projectDir, "node_modules", ".bin", "eslint.cmd") : path31.join(projectDir, "node_modules", ".bin", "eslint");
   const localResult = await _detectAvailableLinter(projectDir, biomeBin, eslintBin);
   if (localResult)
     return localResult;
-  const biomeAncestor = findBinInAncestors(path30.dirname(projectDir), isWindows ? "biome.EXE" : "biome");
-  const eslintAncestor = findBinInAncestors(path30.dirname(projectDir), isWindows ? "eslint.cmd" : "eslint");
+  const biomeAncestor = findBinInAncestors(path31.dirname(projectDir), isWindows ? "biome.EXE" : "biome");
+  const eslintAncestor = findBinInAncestors(path31.dirname(projectDir), isWindows ? "eslint.cmd" : "eslint");
   if (biomeAncestor || eslintAncestor) {
     return _detectAvailableLinter(projectDir, biomeAncestor ?? biomeBin, eslintAncestor ?? eslintBin);
   }
@@ -49088,7 +49135,7 @@ For Rust: rustup component add clippy`
 
 // src/tools/secretscan.ts
 import * as fs19 from "node:fs";
-import * as path31 from "node:path";
+import * as path32 from "node:path";
 function calculateShannonEntropy(str) {
   if (str.length === 0)
     return 0;
@@ -49136,7 +49183,7 @@ function isGlobOrPathPattern(pattern) {
   return pattern.includes("/") || pattern.includes("\\") || /[*?[\]{}]/.test(pattern);
 }
 function loadSecretScanIgnore(scanDir) {
-  const ignorePath = path31.join(scanDir, ".secretscanignore");
+  const ignorePath = path32.join(scanDir, ".secretscanignore");
   try {
     if (!fs19.existsSync(ignorePath))
       return [];
@@ -49159,7 +49206,7 @@ function isExcluded(entry, relPath, exactNames, globPatterns) {
   if (exactNames.has(entry))
     return true;
   for (const pattern of globPatterns) {
-    if (path31.matchesGlob(relPath, pattern))
+    if (path32.matchesGlob(relPath, pattern))
       return true;
   }
   return false;
@@ -49180,7 +49227,7 @@ function validateDirectoryInput(dir) {
   return null;
 }
 function isBinaryFile(filePath, buffer) {
-  const ext = path31.extname(filePath).toLowerCase();
+  const ext = path32.extname(filePath).toLowerCase();
   if (DEFAULT_EXCLUDE_EXTENSIONS.has(ext)) {
     return true;
   }
@@ -49316,9 +49363,9 @@ function isSymlinkLoop(realPath, visited) {
   return false;
 }
 function isPathWithinScope(realPath, scanDir) {
-  const resolvedScanDir = path31.resolve(scanDir);
-  const resolvedRealPath = path31.resolve(realPath);
-  return resolvedRealPath === resolvedScanDir || resolvedRealPath.startsWith(resolvedScanDir + path31.sep) || resolvedRealPath.startsWith(`${resolvedScanDir}/`) || resolvedRealPath.startsWith(`${resolvedScanDir}\\`);
+  const resolvedScanDir = path32.resolve(scanDir);
+  const resolvedRealPath = path32.resolve(realPath);
+  return resolvedRealPath === resolvedScanDir || resolvedRealPath.startsWith(resolvedScanDir + path32.sep) || resolvedRealPath.startsWith(`${resolvedScanDir}/`) || resolvedRealPath.startsWith(`${resolvedScanDir}\\`);
 }
 function findScannableFiles(dir, excludeExact, excludeGlobs, scanDir, visited, stats = {
   skippedDirs: 0,
@@ -49344,8 +49391,8 @@ function findScannableFiles(dir, excludeExact, excludeGlobs, scanDir, visited, s
     return a.localeCompare(b);
   });
   for (const entry of entries) {
-    const fullPath = path31.join(dir, entry);
-    const relPath = path31.relative(scanDir, fullPath).replace(/\\/g, "/");
+    const fullPath = path32.join(dir, entry);
+    const relPath = path32.relative(scanDir, fullPath).replace(/\\/g, "/");
     if (isExcluded(entry, relPath, excludeExact, excludeGlobs)) {
       stats.skippedDirs++;
       continue;
@@ -49380,7 +49427,7 @@ function findScannableFiles(dir, excludeExact, excludeGlobs, scanDir, visited, s
       const subFiles = findScannableFiles(fullPath, excludeExact, excludeGlobs, scanDir, visited, stats);
       files.push(...subFiles);
     } else if (lstat.isFile()) {
-      const ext = path31.extname(fullPath).toLowerCase();
+      const ext = path32.extname(fullPath).toLowerCase();
       if (!DEFAULT_EXCLUDE_EXTENSIONS.has(ext)) {
         files.push(fullPath);
       } else {
@@ -49640,7 +49687,7 @@ var init_secretscan = __esm(() => {
         }
       }
       try {
-        const _scanDirRaw = path31.resolve(directory);
+        const _scanDirRaw = path32.resolve(directory);
         const scanDir = (() => {
           try {
             return fs19.realpathSync(_scanDirRaw);
@@ -49783,7 +49830,7 @@ var init_secretscan = __esm(() => {
 
 // src/test-impact/analyzer.ts
 import fs20 from "node:fs";
-import path32 from "node:path";
+import path33 from "node:path";
 function normalizePath(p) {
   return p.replace(/\\/g, "/");
 }
@@ -49804,8 +49851,8 @@ function resolveRelativeImport(fromDir, importPath) {
   if (!importPath.startsWith(".")) {
     return null;
   }
-  const resolved = path32.resolve(fromDir, importPath);
-  if (path32.extname(resolved)) {
+  const resolved = path33.resolve(fromDir, importPath);
+  if (path33.extname(resolved)) {
     if (fs20.existsSync(resolved) && fs20.statSync(resolved).isFile()) {
       return normalizePath(resolved);
     }
@@ -49850,12 +49897,12 @@ function findTestFilesSync(cwd) {
     for (const entry of entries) {
       if (entry.isDirectory()) {
         if (!skipDirs.has(entry.name)) {
-          walk(path32.join(dir, entry.name), visitedInodes);
+          walk(path33.join(dir, entry.name), visitedInodes);
         }
       } else if (entry.isFile()) {
         const name2 = entry.name;
         if (/\.(test|spec)\.(ts|tsx|js|jsx)$/.test(name2) || dir.includes("__tests__") && /\.(ts|tsx|js|jsx)$/.test(name2)) {
-          testFiles.push(normalizePath(path32.join(dir, entry.name)));
+          testFiles.push(normalizePath(path33.join(dir, entry.name)));
         }
       }
     }
@@ -49893,7 +49940,7 @@ async function buildImpactMapInternal(cwd) {
       continue;
     }
     const imports = extractImports(content);
-    const testDir = path32.dirname(testFile);
+    const testDir = path33.dirname(testFile);
     for (const importPath of imports) {
       const resolvedSource = resolveRelativeImport(testDir, importPath);
       if (resolvedSource === null) {
@@ -49915,7 +49962,7 @@ async function buildImpactMap(cwd) {
   return impactMap;
 }
 async function loadImpactMap(cwd) {
-  const cachePath = path32.join(cwd, ".swarm", "cache", "impact-map.json");
+  const cachePath = path33.join(cwd, ".swarm", "cache", "impact-map.json");
   if (fs20.existsSync(cachePath)) {
     try {
       const content = fs20.readFileSync(cachePath, "utf-8");
@@ -49930,8 +49977,8 @@ async function loadImpactMap(cwd) {
   return buildImpactMap(cwd);
 }
 async function saveImpactMap(cwd, impactMap) {
-  const cacheDir2 = path32.join(cwd, ".swarm", "cache");
-  const cachePath = path32.join(cacheDir2, "impact-map.json");
+  const cacheDir2 = path33.join(cwd, ".swarm", "cache");
+  const cachePath = path33.join(cacheDir2, "impact-map.json");
   if (!fs20.existsSync(cacheDir2)) {
     fs20.mkdirSync(cacheDir2, { recursive: true });
   }
@@ -49957,7 +50004,7 @@ async function analyzeImpact(changedFiles, cwd) {
   const impactedTestsSet = new Set;
   const untestedFiles = [];
   for (const changedFile of validFiles) {
-    const normalizedChanged = normalizePath(path32.resolve(changedFile));
+    const normalizedChanged = normalizePath(path33.resolve(changedFile));
     const tests = impactMap[normalizedChanged];
     if (tests && tests.length > 0) {
       for (const test of tests) {
@@ -50209,9 +50256,9 @@ var FLAKY_THRESHOLD = 0.3, MIN_RUNS_FOR_QUARANTINE = 5, MAX_HISTORY_RUNS = 20;
 
 // src/test-impact/history-store.ts
 import fs21 from "node:fs";
-import path33 from "node:path";
+import path34 from "node:path";
 function getHistoryPath(workingDir) {
-  return path33.join(workingDir || process.cwd(), ".swarm", "cache", "test-history.jsonl");
+  return path34.join(workingDir || process.cwd(), ".swarm", "cache", "test-history.jsonl");
 }
 function sanitizeErrorMessage(errorMessage) {
   if (errorMessage === undefined) {
@@ -50266,7 +50313,7 @@ function appendTestRun(record3, workingDir) {
     changedFiles: sanitizeChangedFiles(record3.changedFiles || [])
   };
   const historyPath = getHistoryPath(workingDir);
-  const historyDir = path33.dirname(historyPath);
+  const historyDir = path34.dirname(historyPath);
   if (!fs21.existsSync(historyDir)) {
     fs21.mkdirSync(historyDir, { recursive: true });
   }
@@ -50348,7 +50395,7 @@ var init_history_store = __esm(() => {
 
 // src/tools/resolve-working-directory.ts
 import * as fs22 from "node:fs";
-import * as path34 from "node:path";
+import * as path35 from "node:path";
 function resolveWorkingDirectory(workingDirectory, fallbackDirectory) {
   if (workingDirectory == null || workingDirectory === "") {
     return { success: true, directory: fallbackDirectory };
@@ -50368,15 +50415,15 @@ function resolveWorkingDirectory(workingDirectory, fallbackDirectory) {
       };
     }
   }
-  const normalizedDir = path34.normalize(workingDirectory);
-  const pathParts = normalizedDir.split(path34.sep);
+  const normalizedDir = path35.normalize(workingDirectory);
+  const pathParts = normalizedDir.split(path35.sep);
   if (pathParts.includes("..")) {
     return {
       success: false,
       message: "Invalid working_directory: path traversal sequences (..) are not allowed"
     };
   }
-  const resolvedDir = path34.resolve(normalizedDir);
+  const resolvedDir = path35.resolve(normalizedDir);
   let statResult;
   try {
     statResult = fs22.statSync(resolvedDir);
@@ -50392,7 +50439,7 @@ function resolveWorkingDirectory(workingDirectory, fallbackDirectory) {
       message: `Invalid working_directory: path "${resolvedDir}" is not a directory`
     };
   }
-  const resolvedFallback = path34.resolve(fallbackDirectory);
+  const resolvedFallback = path35.resolve(fallbackDirectory);
   let fallbackExists = false;
   try {
     fs22.statSync(resolvedFallback);
@@ -50402,7 +50449,7 @@ function resolveWorkingDirectory(workingDirectory, fallbackDirectory) {
   }
   if (workingDirectory != null && workingDirectory !== "") {
     if (fallbackExists) {
-      const isSubdirectory = resolvedDir.startsWith(resolvedFallback + path34.sep);
+      const isSubdirectory = resolvedDir.startsWith(resolvedFallback + path35.sep);
       if (isSubdirectory) {
         return {
           success: false,
@@ -50424,7 +50471,7 @@ var init_resolve_working_directory = () => {};
 
 // src/tools/test-runner.ts
 import * as fs23 from "node:fs";
-import * as path35 from "node:path";
+import * as path36 from "node:path";
 function isAbsolutePath(str) {
   if (str.startsWith("/"))
     return true;
@@ -50489,14 +50536,14 @@ function hasDevDependency(devDeps, ...patterns) {
   return hasPackageJsonDependency(devDeps, ...patterns);
 }
 function detectGoTest(cwd) {
-  return fs23.existsSync(path35.join(cwd, "go.mod")) && isCommandAvailable("go");
+  return fs23.existsSync(path36.join(cwd, "go.mod")) && isCommandAvailable("go");
 }
 function detectJavaMaven(cwd) {
-  return fs23.existsSync(path35.join(cwd, "pom.xml")) && isCommandAvailable("mvn");
+  return fs23.existsSync(path36.join(cwd, "pom.xml")) && isCommandAvailable("mvn");
 }
 function detectGradle(cwd) {
-  const hasBuildFile = fs23.existsSync(path35.join(cwd, "build.gradle")) || fs23.existsSync(path35.join(cwd, "build.gradle.kts"));
-  const hasGradlew = fs23.existsSync(path35.join(cwd, "gradlew")) || fs23.existsSync(path35.join(cwd, "gradlew.bat"));
+  const hasBuildFile = fs23.existsSync(path36.join(cwd, "build.gradle")) || fs23.existsSync(path36.join(cwd, "build.gradle.kts"));
+  const hasGradlew = fs23.existsSync(path36.join(cwd, "gradlew")) || fs23.existsSync(path36.join(cwd, "gradlew.bat"));
   return hasBuildFile && (hasGradlew || isCommandAvailable("gradle"));
 }
 function detectDotnetTest(cwd) {
@@ -50509,30 +50556,30 @@ function detectDotnetTest(cwd) {
   }
 }
 function detectCTest(cwd) {
-  const hasSource = fs23.existsSync(path35.join(cwd, "CMakeLists.txt"));
-  const hasBuildCache = fs23.existsSync(path35.join(cwd, "CMakeCache.txt")) || fs23.existsSync(path35.join(cwd, "build", "CMakeCache.txt"));
+  const hasSource = fs23.existsSync(path36.join(cwd, "CMakeLists.txt"));
+  const hasBuildCache = fs23.existsSync(path36.join(cwd, "CMakeCache.txt")) || fs23.existsSync(path36.join(cwd, "build", "CMakeCache.txt"));
   return (hasSource || hasBuildCache) && isCommandAvailable("ctest");
 }
 function detectSwiftTest(cwd) {
-  return fs23.existsSync(path35.join(cwd, "Package.swift")) && isCommandAvailable("swift");
+  return fs23.existsSync(path36.join(cwd, "Package.swift")) && isCommandAvailable("swift");
 }
 function detectDartTest(cwd) {
-  return fs23.existsSync(path35.join(cwd, "pubspec.yaml")) && (isCommandAvailable("dart") || isCommandAvailable("flutter"));
+  return fs23.existsSync(path36.join(cwd, "pubspec.yaml")) && (isCommandAvailable("dart") || isCommandAvailable("flutter"));
 }
 function detectRSpec(cwd) {
-  const hasRSpecFile = fs23.existsSync(path35.join(cwd, ".rspec"));
-  const hasGemfile = fs23.existsSync(path35.join(cwd, "Gemfile"));
-  const hasSpecDir = fs23.existsSync(path35.join(cwd, "spec"));
+  const hasRSpecFile = fs23.existsSync(path36.join(cwd, ".rspec"));
+  const hasGemfile = fs23.existsSync(path36.join(cwd, "Gemfile"));
+  const hasSpecDir = fs23.existsSync(path36.join(cwd, "spec"));
   const hasRSpec = hasRSpecFile || hasGemfile && hasSpecDir;
   return hasRSpec && (isCommandAvailable("bundle") || isCommandAvailable("rspec"));
 }
 function detectMinitest(cwd) {
-  return fs23.existsSync(path35.join(cwd, "test")) && (fs23.existsSync(path35.join(cwd, "Gemfile")) || fs23.existsSync(path35.join(cwd, "Rakefile"))) && isCommandAvailable("ruby");
+  return fs23.existsSync(path36.join(cwd, "test")) && (fs23.existsSync(path36.join(cwd, "Gemfile")) || fs23.existsSync(path36.join(cwd, "Rakefile"))) && isCommandAvailable("ruby");
 }
 async function detectTestFramework(cwd) {
   const baseDir = cwd;
   try {
-    const packageJsonPath = path35.join(baseDir, "package.json");
+    const packageJsonPath = path36.join(baseDir, "package.json");
     if (fs23.existsSync(packageJsonPath)) {
       const content = fs23.readFileSync(packageJsonPath, "utf-8");
       const pkg = JSON.parse(content);
@@ -50553,16 +50600,16 @@ async function detectTestFramework(cwd) {
         return "jest";
       if (hasDevDependency(devDeps, "mocha", "@types/mocha"))
         return "mocha";
-      if (fs23.existsSync(path35.join(baseDir, "bun.lockb")) || fs23.existsSync(path35.join(baseDir, "bun.lock"))) {
+      if (fs23.existsSync(path36.join(baseDir, "bun.lockb")) || fs23.existsSync(path36.join(baseDir, "bun.lock"))) {
         if (scripts.test?.includes("bun"))
           return "bun";
       }
     }
   } catch {}
   try {
-    const pyprojectTomlPath = path35.join(baseDir, "pyproject.toml");
-    const setupCfgPath = path35.join(baseDir, "setup.cfg");
-    const requirementsTxtPath = path35.join(baseDir, "requirements.txt");
+    const pyprojectTomlPath = path36.join(baseDir, "pyproject.toml");
+    const setupCfgPath = path36.join(baseDir, "setup.cfg");
+    const requirementsTxtPath = path36.join(baseDir, "requirements.txt");
     if (fs23.existsSync(pyprojectTomlPath)) {
       const content = fs23.readFileSync(pyprojectTomlPath, "utf-8");
       if (content.includes("[tool.pytest"))
@@ -50582,7 +50629,7 @@ async function detectTestFramework(cwd) {
     }
   } catch {}
   try {
-    const cargoTomlPath = path35.join(baseDir, "Cargo.toml");
+    const cargoTomlPath = path36.join(baseDir, "Cargo.toml");
     if (fs23.existsSync(cargoTomlPath)) {
       const content = fs23.readFileSync(cargoTomlPath, "utf-8");
       if (content.includes("[dev-dependencies]")) {
@@ -50593,9 +50640,9 @@ async function detectTestFramework(cwd) {
     }
   } catch {}
   try {
-    const pesterConfigPath = path35.join(baseDir, "pester.config.ps1");
-    const pesterConfigJsonPath = path35.join(baseDir, "pester.config.ps1.json");
-    const pesterPs1Path = path35.join(baseDir, "tests.ps1");
+    const pesterConfigPath = path36.join(baseDir, "pester.config.ps1");
+    const pesterConfigJsonPath = path36.join(baseDir, "pester.config.ps1.json");
+    const pesterPs1Path = path36.join(baseDir, "tests.ps1");
     if (fs23.existsSync(pesterConfigPath) || fs23.existsSync(pesterConfigJsonPath) || fs23.existsSync(pesterPs1Path)) {
       return "pester";
     }
@@ -50624,12 +50671,12 @@ function isTestDirectoryPath(normalizedPath) {
   return normalizedPath.split("/").some((segment) => TEST_DIRECTORY_NAMES.includes(segment));
 }
 function resolveWorkspacePath(file3, workingDir) {
-  return path35.isAbsolute(file3) ? path35.resolve(file3) : path35.resolve(workingDir, file3);
+  return path36.isAbsolute(file3) ? path36.resolve(file3) : path36.resolve(workingDir, file3);
 }
 function toWorkspaceOutputPath(absolutePath, workingDir, preferRelative) {
   if (!preferRelative)
     return absolutePath;
-  return path35.relative(workingDir, absolutePath);
+  return path36.relative(workingDir, absolutePath);
 }
 function dedupePush(target, value) {
   if (!target.includes(value)) {
@@ -50666,18 +50713,18 @@ function buildLanguageSpecificTestNames(nameWithoutExt, ext) {
   }
 }
 function getRepoLevelCandidateDirectories(workingDir, relativePath, ext) {
-  const relativeDir = path35.dirname(relativePath);
+  const relativeDir = path36.dirname(relativePath);
   const nestedRelativeDir = relativeDir === "." ? "" : relativeDir;
   const directories = TEST_DIRECTORY_NAMES.flatMap((dirName) => {
-    const rootDir = path35.join(workingDir, dirName);
-    return nestedRelativeDir ? [rootDir, path35.join(rootDir, nestedRelativeDir)] : [rootDir];
+    const rootDir = path36.join(workingDir, dirName);
+    return nestedRelativeDir ? [rootDir, path36.join(rootDir, nestedRelativeDir)] : [rootDir];
   });
   const normalizedRelativePath = relativePath.replace(/\\/g, "/");
   if (ext === ".java" && normalizedRelativePath.startsWith("src/main/java/")) {
-    directories.push(path35.join(workingDir, "src/test/java", path35.dirname(normalizedRelativePath.slice("src/main/java/".length))));
+    directories.push(path36.join(workingDir, "src/test/java", path36.dirname(normalizedRelativePath.slice("src/main/java/".length))));
   }
   if ((ext === ".kt" || ext === ".java") && normalizedRelativePath.startsWith("src/main/kotlin/")) {
-    directories.push(path35.join(workingDir, "src/test/kotlin", path35.dirname(normalizedRelativePath.slice("src/main/kotlin/".length))));
+    directories.push(path36.join(workingDir, "src/test/kotlin", path36.dirname(normalizedRelativePath.slice("src/main/kotlin/".length))));
   }
   return [...new Set(directories)];
 }
@@ -50705,23 +50752,23 @@ function isLanguageSpecificTestFile(basename6) {
 }
 function isConventionTestFilePath(filePath) {
   const normalizedPath = filePath.replace(/\\/g, "/");
-  const basename6 = path35.basename(filePath);
+  const basename6 = path36.basename(filePath);
   return hasCompoundTestExtension(basename6) || basename6.includes(".spec.") || basename6.includes(".test.") || isLanguageSpecificTestFile(basename6) || isTestDirectoryPath(normalizedPath);
 }
 function getTestFilesFromConvention(sourceFiles, workingDir = process.cwd()) {
   const testFiles = [];
   for (const file3 of sourceFiles) {
     const absoluteFile = resolveWorkspacePath(file3, workingDir);
-    const relativeFile = path35.relative(workingDir, absoluteFile);
-    const basename6 = path35.basename(absoluteFile);
-    const dirname14 = path35.dirname(absoluteFile);
-    const preferRelativeOutput = !path35.isAbsolute(file3);
+    const relativeFile = path36.relative(workingDir, absoluteFile);
+    const basename6 = path36.basename(absoluteFile);
+    const dirname14 = path36.dirname(absoluteFile);
+    const preferRelativeOutput = !path36.isAbsolute(file3);
     if (isConventionTestFilePath(relativeFile) || isConventionTestFilePath(file3)) {
       dedupePush(testFiles, toWorkspaceOutputPath(absoluteFile, workingDir, preferRelativeOutput));
       continue;
     }
     const nameWithoutExt = basename6.replace(/\.[^.]+$/, "");
-    const ext = path35.extname(basename6);
+    const ext = path36.extname(basename6);
     const genericTestNames = [
       `${nameWithoutExt}.spec${ext}`,
       `${nameWithoutExt}.test${ext}`
@@ -50730,7 +50777,7 @@ function getTestFilesFromConvention(sourceFiles, workingDir = process.cwd()) {
     const colocatedCandidates = [
       ...genericTestNames,
       ...languageSpecificTestNames
-    ].map((candidateName) => path35.join(dirname14, candidateName));
+    ].map((candidateName) => path36.join(dirname14, candidateName));
     const testDirectoryNames = [
       basename6,
       ...genericTestNames,
@@ -50739,8 +50786,8 @@ function getTestFilesFromConvention(sourceFiles, workingDir = process.cwd()) {
     const repoLevelDirectories = getRepoLevelCandidateDirectories(workingDir, relativeFile, ext);
     const possibleTestFiles = [
       ...colocatedCandidates,
-      ...TEST_DIRECTORY_NAMES.flatMap((dirName) => testDirectoryNames.map((candidateName) => path35.join(dirname14, dirName, candidateName))),
-      ...repoLevelDirectories.flatMap((candidateDir) => testDirectoryNames.map((candidateName) => path35.join(candidateDir, candidateName)))
+      ...TEST_DIRECTORY_NAMES.flatMap((dirName) => testDirectoryNames.map((candidateName) => path36.join(dirname14, dirName, candidateName))),
+      ...repoLevelDirectories.flatMap((candidateDir) => testDirectoryNames.map((candidateName) => path36.join(candidateDir, candidateName)))
     ];
     for (const testFile of possibleTestFiles) {
       if (fs23.existsSync(testFile)) {
@@ -50761,7 +50808,7 @@ async function getTestFilesFromGraph(sourceFiles, workingDir) {
     try {
       const absoluteTestFile = resolveWorkspacePath(testFile, workingDir);
       const content = fs23.readFileSync(absoluteTestFile, "utf-8");
-      const testDir = path35.dirname(absoluteTestFile);
+      const testDir = path36.dirname(absoluteTestFile);
       const importRegex = /import\s+.*?\s+from\s+['"]([^'"]+)['"]/g;
       let match;
       match = importRegex.exec(content);
@@ -50769,8 +50816,8 @@ async function getTestFilesFromGraph(sourceFiles, workingDir) {
         const importPath = match[1];
         let resolvedImport;
         if (importPath.startsWith(".")) {
-          resolvedImport = path35.resolve(testDir, importPath);
-          const existingExt = path35.extname(resolvedImport);
+          resolvedImport = path36.resolve(testDir, importPath);
+          const existingExt = path36.extname(resolvedImport);
           if (!existingExt) {
             for (const extToTry of [
               ".ts",
@@ -50790,12 +50837,12 @@ async function getTestFilesFromGraph(sourceFiles, workingDir) {
         } else {
           continue;
         }
-        const importBasename = path35.basename(resolvedImport, path35.extname(resolvedImport));
-        const importDir = path35.dirname(resolvedImport);
+        const importBasename = path36.basename(resolvedImport, path36.extname(resolvedImport));
+        const importDir = path36.dirname(resolvedImport);
         for (const sourceFile of absoluteSourceFiles) {
-          const sourceDir = path35.dirname(sourceFile);
-          const sourceBasename = path35.basename(sourceFile, path35.extname(sourceFile));
-          const isRelatedDir = importDir === sourceDir || importDir === path35.join(sourceDir, "__tests__") || importDir === path35.join(sourceDir, "tests") || importDir === path35.join(sourceDir, "test") || importDir === path35.join(sourceDir, "spec");
+          const sourceDir = path36.dirname(sourceFile);
+          const sourceBasename = path36.basename(sourceFile, path36.extname(sourceFile));
+          const isRelatedDir = importDir === sourceDir || importDir === path36.join(sourceDir, "__tests__") || importDir === path36.join(sourceDir, "tests") || importDir === path36.join(sourceDir, "test") || importDir === path36.join(sourceDir, "spec");
           if (resolvedImport === sourceFile || importBasename === sourceBasename && isRelatedDir) {
             dedupePush(testFiles, testFile);
             break;
@@ -50808,8 +50855,8 @@ async function getTestFilesFromGraph(sourceFiles, workingDir) {
       while (match !== null) {
         const importPath = match[1];
         if (importPath.startsWith(".")) {
-          let resolvedImport = path35.resolve(testDir, importPath);
-          const existingExt = path35.extname(resolvedImport);
+          let resolvedImport = path36.resolve(testDir, importPath);
+          const existingExt = path36.extname(resolvedImport);
           if (!existingExt) {
             for (const extToTry of [
               ".ts",
@@ -50826,12 +50873,12 @@ async function getTestFilesFromGraph(sourceFiles, workingDir) {
               }
             }
           }
-          const importDir = path35.dirname(resolvedImport);
-          const importBasename = path35.basename(resolvedImport, path35.extname(resolvedImport));
+          const importDir = path36.dirname(resolvedImport);
+          const importBasename = path36.basename(resolvedImport, path36.extname(resolvedImport));
           for (const sourceFile of absoluteSourceFiles) {
-            const sourceDir = path35.dirname(sourceFile);
-            const sourceBasename = path35.basename(sourceFile, path35.extname(sourceFile));
-            const isRelatedDir = importDir === sourceDir || importDir === path35.join(sourceDir, "__tests__") || importDir === path35.join(sourceDir, "tests") || importDir === path35.join(sourceDir, "test") || importDir === path35.join(sourceDir, "spec");
+            const sourceDir = path36.dirname(sourceFile);
+            const sourceBasename = path36.basename(sourceFile, path36.extname(sourceFile));
+            const isRelatedDir = importDir === sourceDir || importDir === path36.join(sourceDir, "__tests__") || importDir === path36.join(sourceDir, "tests") || importDir === path36.join(sourceDir, "test") || importDir === path36.join(sourceDir, "spec");
             if (resolvedImport === sourceFile || importBasename === sourceBasename && isRelatedDir) {
               dedupePush(testFiles, testFile);
               break;
@@ -50934,8 +50981,8 @@ function buildTestCommand(framework, scope, files, coverage, baseDir) {
       return ["mvn", "test"];
     case "gradle": {
       const isWindows = process.platform === "win32";
-      const hasGradlewBat = fs23.existsSync(path35.join(baseDir, "gradlew.bat"));
-      const hasGradlew = fs23.existsSync(path35.join(baseDir, "gradlew"));
+      const hasGradlewBat = fs23.existsSync(path36.join(baseDir, "gradlew.bat"));
+      const hasGradlew = fs23.existsSync(path36.join(baseDir, "gradlew"));
       if (hasGradlewBat && isWindows)
         return ["gradlew.bat", "test"];
       if (hasGradlew)
@@ -50952,7 +50999,7 @@ function buildTestCommand(framework, scope, files, coverage, baseDir) {
         "cmake-build-release",
         "out"
       ];
-      const actualBuildDir = buildDirCandidates.find((d) => fs23.existsSync(path35.join(baseDir, d, "CMakeCache.txt"))) ?? "build";
+      const actualBuildDir = buildDirCandidates.find((d) => fs23.existsSync(path36.join(baseDir, d, "CMakeCache.txt"))) ?? "build";
       return ["ctest", "--test-dir", actualBuildDir];
     }
     case "swift-test":
@@ -51604,7 +51651,7 @@ var init_test_runner = __esm(() => {
         const sourceFiles = args2.files.filter((file3) => {
           if (directTestFiles.includes(file3))
             return false;
-          const ext = path35.extname(file3).toLowerCase();
+          const ext = path36.extname(file3).toLowerCase();
           return SOURCE_EXTENSIONS.has(ext);
         });
         const invalidFiles = args2.files.filter((file3) => !directTestFiles.includes(file3) && !sourceFiles.includes(file3));
@@ -51639,7 +51686,7 @@ var init_test_runner = __esm(() => {
           if (isConventionTestFilePath(f)) {
             return false;
           }
-          const ext = path35.extname(f).toLowerCase();
+          const ext = path36.extname(f).toLowerCase();
           return SOURCE_EXTENSIONS.has(ext);
         });
         if (sourceFiles.length === 0) {
@@ -51666,7 +51713,7 @@ var init_test_runner = __esm(() => {
           if (isConventionTestFilePath(f)) {
             return false;
           }
-          const ext = path35.extname(f).toLowerCase();
+          const ext = path36.extname(f).toLowerCase();
           return SOURCE_EXTENSIONS.has(ext);
         });
         if (sourceFiles.length === 0) {
@@ -51684,8 +51731,8 @@ var init_test_runner = __esm(() => {
           const impactResult = await analyzeImpact(sourceFiles, workingDir);
           if (impactResult.impactedTests.length > 0) {
             testFiles = impactResult.impactedTests.map((absPath) => {
-              const relativePath = path35.relative(workingDir, absPath);
-              return path35.isAbsolute(relativePath) ? absPath : relativePath;
+              const relativePath = path36.relative(workingDir, absPath);
+              return path36.isAbsolute(relativePath) ? absPath : relativePath;
             });
           } else {
             graphFallbackReason = "no impacted tests found via impact analysis, falling back to graph";
@@ -51761,7 +51808,7 @@ var init_test_runner = __esm(() => {
 
 // src/services/preflight-service.ts
 import * as fs24 from "node:fs";
-import * as path36 from "node:path";
+import * as path37 from "node:path";
 function validateDirectoryPath(dir) {
   if (!dir || typeof dir !== "string") {
     throw new Error("Directory path is required");
@@ -51769,8 +51816,8 @@ function validateDirectoryPath(dir) {
   if (dir.includes("..")) {
     throw new Error("Directory path must not contain path traversal sequences");
   }
-  const normalized = path36.normalize(dir);
-  const absolutePath = path36.isAbsolute(normalized) ? normalized : path36.resolve(normalized);
+  const normalized = path37.normalize(dir);
+  const absolutePath = path37.isAbsolute(normalized) ? normalized : path37.resolve(normalized);
   return absolutePath;
 }
 function validateTimeout(timeoutMs, defaultValue) {
@@ -51793,7 +51840,7 @@ function validateTimeout(timeoutMs, defaultValue) {
 }
 function getPackageVersion(dir) {
   try {
-    const packagePath = path36.join(dir, "package.json");
+    const packagePath = path37.join(dir, "package.json");
     if (fs24.existsSync(packagePath)) {
       const content = fs24.readFileSync(packagePath, "utf-8");
       const pkg = JSON.parse(content);
@@ -51804,7 +51851,7 @@ function getPackageVersion(dir) {
 }
 function getChangelogVersion(dir) {
   try {
-    const changelogPath = path36.join(dir, "CHANGELOG.md");
+    const changelogPath = path37.join(dir, "CHANGELOG.md");
     if (fs24.existsSync(changelogPath)) {
       const content = fs24.readFileSync(changelogPath, "utf-8");
       const match = content.match(/^##\s*\[?(\d+\.\d+\.\d+)\]?/m);
@@ -51818,7 +51865,7 @@ function getChangelogVersion(dir) {
 function getVersionFileVersion(dir) {
   const possibleFiles = ["VERSION.txt", "version.txt", "VERSION", "version"];
   for (const file3 of possibleFiles) {
-    const filePath = path36.join(dir, file3);
+    const filePath = path37.join(dir, file3);
     if (fs24.existsSync(filePath)) {
       try {
         const content = fs24.readFileSync(filePath, "utf-8").trim();
@@ -52145,7 +52192,7 @@ async function runEvidenceCheck(dir) {
 async function runRequirementCoverageCheck(dir, currentPhase) {
   const startTime = Date.now();
   try {
-    const specPath = path36.join(dir, ".swarm", "spec.md");
+    const specPath = path37.join(dir, ".swarm", "spec.md");
     if (!fs24.existsSync(specPath)) {
       return {
         type: "req_coverage",
@@ -53330,7 +53377,7 @@ var init_reset = __esm(() => {
 
 // src/commands/reset-session.ts
 import * as fs26 from "node:fs";
-import * as path37 from "node:path";
+import * as path38 from "node:path";
 async function handleResetSessionCommand(directory, _args) {
   const results = [];
   try {
@@ -53345,13 +53392,13 @@ async function handleResetSessionCommand(directory, _args) {
     results.push("❌ Failed to delete state.json");
   }
   try {
-    const sessionDir = path37.dirname(validateSwarmPath(directory, "session/state.json"));
+    const sessionDir = path38.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 = path37.join(sessionDir, file3);
+        const filePath = path38.join(sessionDir, file3);
         if (fs26.lstatSync(filePath).isFile()) {
           fs26.unlinkSync(filePath);
           deletedCount++;
@@ -53384,7 +53431,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 path38 from "node:path";
+import * as path39 from "node:path";
 function sanitizeSummaryId(id) {
   if (!id || id.length === 0) {
     throw new Error("Invalid summary ID: empty string");
@@ -53418,9 +53465,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 = path38.join("summaries", `${sanitizedId}.json`);
+  const relativePath = path39.join("summaries", `${sanitizedId}.json`);
   const summaryPath = validateSwarmPath(directory, relativePath);
-  const summaryDir = path38.dirname(summaryPath);
+  const summaryDir = path39.dirname(summaryPath);
   const entry = {
     id: sanitizedId,
     summaryText,
@@ -53430,7 +53477,7 @@ async function storeSummary(directory, id, fullOutput, summaryText, maxStoredByt
   };
   const entryJson = JSON.stringify(entry);
   mkdirSync13(summaryDir, { recursive: true });
-  const tempPath = path38.join(summaryDir, `${sanitizedId}.json.tmp.${Date.now()}.${process.pid}`);
+  const tempPath = path39.join(summaryDir, `${sanitizedId}.json.tmp.${Date.now()}.${process.pid}`);
   try {
     await Bun.write(tempPath, entryJson);
     renameSync10(tempPath, summaryPath);
@@ -53443,7 +53490,7 @@ async function storeSummary(directory, id, fullOutput, summaryText, maxStoredByt
 }
 async function loadFullOutput(directory, id) {
   const sanitizedId = sanitizeSummaryId(id);
-  const relativePath = path38.join("summaries", `${sanitizedId}.json`);
+  const relativePath = path39.join("summaries", `${sanitizedId}.json`);
   validateSwarmPath(directory, relativePath);
   const content = await readSwarmFileAsync(directory, relativePath);
   if (content === null) {
@@ -53505,7 +53552,7 @@ var init_retrieve = __esm(() => {
 
 // src/commands/rollback.ts
 import * as fs27 from "node:fs";
-import * as path39 from "node:path";
+import * as path40 from "node:path";
 async function handleRollbackCommand(directory, args2) {
   const phaseArg = args2[0];
   if (!phaseArg) {
@@ -53570,8 +53617,8 @@ async function handleRollbackCommand(directory, args2) {
     if (EXCLUDE_FILES.has(file3) || file3.startsWith("plan-ledger.archived-")) {
       continue;
     }
-    const src = path39.join(checkpointDir, file3);
-    const dest = path39.join(swarmDir, file3);
+    const src = path40.join(checkpointDir, file3);
+    const dest = path40.join(swarmDir, file3);
     try {
       fs27.cpSync(src, dest, { recursive: true, force: true });
       successes.push(file3);
@@ -53590,12 +53637,12 @@ async function handleRollbackCommand(directory, args2) {
     ].join(`
 `);
   }
-  const existingLedgerPath = path39.join(swarmDir, "plan-ledger.jsonl");
+  const existingLedgerPath = path40.join(swarmDir, "plan-ledger.jsonl");
   if (fs27.existsSync(existingLedgerPath)) {
     fs27.unlinkSync(existingLedgerPath);
   }
   try {
-    const planJsonPath = path39.join(swarmDir, "plan.json");
+    const planJsonPath = path40.join(swarmDir, "plan.json");
     if (fs27.existsSync(planJsonPath)) {
       const planRaw = fs27.readFileSync(planJsonPath, "utf-8");
       const plan = PlanSchema.parse(JSON.parse(planRaw));
@@ -53673,9 +53720,9 @@ async function handleSimulateCommand(directory, args2) {
   const report = reportLines.filter(Boolean).join(`
 `);
   const fs28 = await import("node:fs/promises");
-  const path40 = await import("node:path");
-  const reportPath = path40.join(directory, ".swarm", "simulate-report.md");
-  await fs28.mkdir(path40.dirname(reportPath), { recursive: true });
+  const path41 = await import("node:path");
+  const reportPath = path41.join(directory, ".swarm", "simulate-report.md");
+  await fs28.mkdir(path41.dirname(reportPath), { recursive: true });
   await fs28.writeFile(reportPath, report, "utf-8");
   return `${darkMatterPairs.length} hidden coupling pairs detected`;
 }
@@ -53694,7 +53741,7 @@ async function handleSpecifyCommand(_directory, args2) {
 
 // src/services/compaction-service.ts
 import * as fs28 from "node:fs";
-import * as path40 from "node:path";
+import * as path41 from "node:path";
 function makeInitialState() {
   return {
     lastObservationAt: 0,
@@ -53716,7 +53763,7 @@ function getSessionState(sessionId) {
 }
 function appendSnapshot(directory, tier, budgetPct, message) {
   try {
-    const snapshotPath = path40.join(directory, ".swarm", "context-snapshot.md");
+    const snapshotPath = path41.join(directory, ".swarm", "context-snapshot.md");
     const timestamp = new Date().toISOString();
     const entry = `
 ## [${tier.toUpperCase()}] ${timestamp} — ${budgetPct.toFixed(1)}% used
@@ -58025,7 +58072,7 @@ COVERAGE REPORTING:
 
 // src/agents/index.ts
 import { mkdir as mkdir6, writeFile as writeFile6 } from "node:fs/promises";
-import * as path41 from "node:path";
+import * as path42 from "node:path";
 function stripSwarmPrefix(agentName, swarmPrefix) {
   if (!swarmPrefix || !agentName)
     return agentName;
@@ -58336,14 +58383,14 @@ function getAgentConfigs(config3, directory, sessionId) {
   }));
   if (directory) {
     const sid = sessionId ?? `init-${Date.now()}`;
-    const evidenceDir = path41.join(directory, ".swarm", "evidence");
+    const evidenceDir = path42.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(path41.join(evidenceDir, filename), snapshotData)).catch(() => {});
+    mkdir6(evidenceDir, { recursive: true }).then(() => writeFile6(path42.join(evidenceDir, filename), snapshotData)).catch(() => {});
   }
   return result;
 }
@@ -58369,13 +58416,13 @@ __export(exports_evidence_summary_integration, {
   EvidenceSummaryIntegration: () => EvidenceSummaryIntegration
 });
 import { existsSync as existsSync24, mkdirSync as mkdirSync14, writeFileSync as writeFileSync6 } from "node:fs";
-import * as path42 from "node:path";
+import * as path43 from "node:path";
 function persistSummary(projectDir, artifact, filename) {
-  const swarmPath = path42.join(projectDir, ".swarm");
+  const swarmPath = path43.join(projectDir, ".swarm");
   if (!existsSync24(swarmPath)) {
     mkdirSync14(swarmPath, { recursive: true });
   }
-  const artifactPath = path42.join(swarmPath, filename);
+  const artifactPath = path43.join(swarmPath, filename);
   const content = JSON.stringify(artifact, null, 2);
   writeFileSync6(artifactPath, content, "utf-8");
   log("[EvidenceSummaryIntegration] Summary persisted", {
@@ -58494,7 +58541,7 @@ __export(exports_status_artifact, {
   AutomationStatusArtifact: () => AutomationStatusArtifact
 });
 import * as fs30 from "node:fs";
-import * as path44 from "node:path";
+import * as path45 from "node:path";
 function createEmptySnapshot(mode, capabilities) {
   return {
     timestamp: Date.now(),
@@ -58553,7 +58600,7 @@ class AutomationStatusArtifact {
     });
   }
   getFilePath() {
-    return path44.join(this.swarmDir, this.filename);
+    return path45.join(this.swarmDir, this.filename);
   }
   load() {
     const filePath = this.getFilePath();
@@ -58966,12 +59013,12 @@ __export(exports_review_receipt, {
 });
 import * as crypto5 from "node:crypto";
 import * as fs34 from "node:fs";
-import * as path45 from "node:path";
+import * as path46 from "node:path";
 function resolveReceiptsDir(directory) {
-  return path45.join(directory, ".swarm", "review-receipts");
+  return path46.join(directory, ".swarm", "review-receipts");
 }
 function resolveReceiptIndexPath(directory) {
-  return path45.join(resolveReceiptsDir(directory), "index.json");
+  return path46.join(resolveReceiptsDir(directory), "index.json");
 }
 function buildReceiptFilename(id, date9) {
   const dateStr = date9.toISOString().slice(0, 10);
@@ -59010,7 +59057,7 @@ async function readReceiptIndex(directory) {
 }
 async function writeReceiptIndex(directory, index) {
   const indexPath = resolveReceiptIndexPath(directory);
-  const dir = path45.dirname(indexPath);
+  const dir = path46.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");
@@ -59021,7 +59068,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 = path45.join(receiptsDir, filename);
+  const receiptPath = path46.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);
@@ -59043,7 +59090,7 @@ async function readReceiptById(directory, receiptId) {
   const entry = index.entries.find((e) => e.id === receiptId);
   if (!entry)
     return null;
-  const receiptPath = path45.join(resolveReceiptsDir(directory), entry.filename);
+  const receiptPath = path46.join(resolveReceiptsDir(directory), entry.filename);
   try {
     const content = await fs34.promises.readFile(receiptPath, "utf-8");
     return JSON.parse(content);
@@ -59056,7 +59103,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 = path45.join(resolveReceiptsDir(directory), entry.filename);
+    const receiptPath = path46.join(resolveReceiptsDir(directory), entry.filename);
     try {
       const content = await fs34.promises.readFile(receiptPath, "utf-8");
       receipts.push(JSON.parse(content));
@@ -59069,7 +59116,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 = path45.join(resolveReceiptsDir(directory), entry.filename);
+    const receiptPath = path46.join(resolveReceiptsDir(directory), entry.filename);
     try {
       const content = await fs34.promises.readFile(receiptPath, "utf-8");
       receipts.push(JSON.parse(content));
@@ -60656,11 +60703,11 @@ ${JSON.stringify(symbolNames, null, 2)}`);
         throw toThrow;
       }, "quit_");
       var scriptDirectory = "";
-      function locateFile(path56) {
+      function locateFile(path57) {
         if (Module["locateFile"]) {
-          return Module["locateFile"](path56, scriptDirectory);
+          return Module["locateFile"](path57, scriptDirectory);
         }
-        return scriptDirectory + path56;
+        return scriptDirectory + path57;
       }
       __name(locateFile, "locateFile");
       var readAsync, readBinary;
@@ -62409,13 +62456,13 @@ __export(exports_runtime, {
   getInitializedLanguages: () => getInitializedLanguages,
   clearParserCache: () => clearParserCache
 });
-import * as path56 from "node:path";
+import * as path57 from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 async function initTreeSitter() {
   if (treeSitterInitialized) {
     return;
   }
-  const thisDir = path56.dirname(fileURLToPath2(import.meta.url));
+  const thisDir = path57.dirname(fileURLToPath2(import.meta.url));
   const isSource = thisDir.replace(/\\/g, "/").endsWith("/src/lang");
   if (isSource) {
     await Parser.init();
@@ -62423,7 +62470,7 @@ async function initTreeSitter() {
     const grammarsDir = getGrammarsDirAbsolute();
     await Parser.init({
       locateFile(scriptName) {
-        return path56.join(grammarsDir, scriptName);
+        return path57.join(grammarsDir, scriptName);
       }
     });
   }
@@ -62444,11 +62491,11 @@ function getWasmFileName(languageId) {
   return `tree-sitter-${sanitized}.wasm`;
 }
 function getGrammarsDirAbsolute() {
-  const thisDir = path56.dirname(fileURLToPath2(import.meta.url));
+  const thisDir = path57.dirname(fileURLToPath2(import.meta.url));
   const normalized = thisDir.replace(/\\/g, "/");
   const isSource = normalized.endsWith("/src/lang");
   const isCliBundle = normalized.endsWith("/cli");
-  return isSource ? path56.join(thisDir, "grammars") : isCliBundle ? path56.join(thisDir, "..", "lang", "grammars") : path56.join(thisDir, "lang", "grammars");
+  return isSource ? path57.join(thisDir, "grammars") : isCliBundle ? path57.join(thisDir, "..", "lang", "grammars") : path57.join(thisDir, "lang", "grammars");
 }
 async function loadGrammar(languageId) {
   if (typeof languageId !== "string" || languageId.length > 100) {
@@ -62464,7 +62511,7 @@ async function loadGrammar(languageId) {
   await initTreeSitter();
   const parser = new Parser;
   const wasmFileName = getWasmFileName(normalizedId);
-  const wasmPath = path56.join(getGrammarsDirAbsolute(), wasmFileName);
+  const wasmPath = path57.join(getGrammarsDirAbsolute(), wasmFileName);
   const { existsSync: existsSync30 } = await import("node:fs");
   if (!existsSync30(wasmPath)) {
     throw new Error(`Grammar file not found for ${languageId}: ${wasmPath}
@@ -62499,7 +62546,7 @@ async function isGrammarAvailable(languageId) {
   }
   try {
     const wasmFileName = getWasmFileName(normalizedId);
-    const wasmPath = path56.join(getGrammarsDirAbsolute(), wasmFileName);
+    const wasmPath = path57.join(getGrammarsDirAbsolute(), wasmFileName);
     const { statSync: statSync18 } = await import("node:fs");
     statSync18(wasmPath);
     return true;
@@ -62558,13 +62605,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 path58 from "node:path";
+import * as path59 from "node:path";
 function normalizeSeparators(filePath) {
   return filePath.replace(/\\/g, "/");
 }
 function matchesDocPattern(filePath, patterns) {
   const normalizedPath = normalizeSeparators(filePath);
-  const basename8 = path58.basename(filePath);
+  const basename8 = path59.basename(filePath);
   for (const pattern of patterns) {
     if (!pattern.includes("/") && !pattern.includes("\\")) {
       if (basename8 === pattern) {
@@ -62620,7 +62667,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 = path58.join(directory, ".swarm", "doc-manifest.json");
+  const manifestPath = path59.join(directory, ".swarm", "doc-manifest.json");
   const defaultPatterns = DocsConfigSchema.parse({}).doc_patterns;
   const extraPatterns = [
     "ARCHITECTURE.md",
@@ -62637,7 +62684,7 @@ async function scanDocIndex(directory) {
       let cacheValid = true;
       for (const file3 of existingManifest.files) {
         try {
-          const fullPath = path58.join(directory, file3.path);
+          const fullPath = path59.join(directory, file3.path);
           const stat3 = fs43.statSync(fullPath);
           if (stat3.mtimeMs > file3.mtime) {
             cacheValid = false;
@@ -62667,7 +62714,7 @@ async function scanDocIndex(directory) {
   }
   const entries = rawEntries.filter((e) => typeof e === "string");
   for (const entry of entries) {
-    const fullPath = path58.join(directory, entry);
+    const fullPath = path59.join(directory, entry);
     let stat3;
     try {
       stat3 = fs43.statSync(fullPath);
@@ -62703,7 +62750,7 @@ async function scanDocIndex(directory) {
     } catch {
       continue;
     }
-    const { title, summary } = extractTitleAndSummary(content, path58.basename(entry));
+    const { title, summary } = extractTitleAndSummary(content, path59.basename(entry));
     const lineCount = content.split(`
 `).length;
     discoveredFiles.push({
@@ -62729,7 +62776,7 @@ async function scanDocIndex(directory) {
     files: discoveredFiles
   };
   try {
-    await mkdir9(path58.dirname(manifestPath), { recursive: true });
+    await mkdir9(path59.dirname(manifestPath), { recursive: true });
     await writeFile8(manifestPath, JSON.stringify(manifest, null, 2), "utf-8");
   } catch {}
   return { manifest, cached: false };
@@ -62768,7 +62815,7 @@ function extractConstraintsFromContent(content) {
   return constraints;
 }
 async function extractDocConstraints(directory, taskFiles, taskDescription) {
-  const manifestPath = path58.join(directory, ".swarm", "doc-manifest.json");
+  const manifestPath = path59.join(directory, ".swarm", "doc-manifest.json");
   let manifest;
   try {
     const content = await readFile8(manifestPath, "utf-8");
@@ -62794,7 +62841,7 @@ async function extractDocConstraints(directory, taskFiles, taskDescription) {
     }
     let fullContent;
     try {
-      fullContent = await readFile8(path58.join(directory, docFile.path), "utf-8");
+      fullContent = await readFile8(path59.join(directory, docFile.path), "utf-8");
     } catch {
       skippedCount++;
       continue;
@@ -62817,7 +62864,7 @@ async function extractDocConstraints(directory, taskFiles, taskDescription) {
           tier: "swarm",
           lesson: constraint,
           category: "architecture",
-          tags: ["doc-scan", path58.basename(docFile.path)],
+          tags: ["doc-scan", path59.basename(docFile.path)],
           scope: "global",
           confidence: 0.5,
           status: "candidate",
@@ -62890,7 +62937,7 @@ var init_doc_scan = __esm(() => {
         }
       } catch {}
       if (force) {
-        const manifestPath = path58.join(directory, ".swarm", "doc-manifest.json");
+        const manifestPath = path59.join(directory, ".swarm", "doc-manifest.json");
         try {
           fs43.unlinkSync(manifestPath);
         } catch {}
@@ -63081,9 +63128,9 @@ __export(exports_curator_drift, {
   buildDriftInjectionText: () => buildDriftInjectionText
 });
 import * as fs46 from "node:fs";
-import * as path61 from "node:path";
+import * as path62 from "node:path";
 async function readPriorDriftReports(directory) {
-  const swarmDir = path61.join(directory, ".swarm");
+  const swarmDir = path62.join(directory, ".swarm");
   const entries = await fs46.promises.readdir(swarmDir).catch(() => null);
   if (entries === null)
     return [];
@@ -63110,7 +63157,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 = path61.dirname(filePath);
+  const swarmDir = path62.dirname(filePath);
   await fs46.promises.mkdir(swarmDir, { recursive: true });
   try {
     await fs46.promises.writeFile(filePath, JSON.stringify(report, null, 2), "utf-8");
@@ -63245,7 +63292,7 @@ var init_curator_drift = __esm(() => {
 init_package();
 init_agents2();
 import * as fs87 from "node:fs";
-import * as path104 from "node:path";
+import * as path105 from "node:path";
 
 // src/background/index.ts
 init_event_bus();
@@ -63256,7 +63303,7 @@ init_manager3();
 init_manager();
 init_utils();
 import * as fs29 from "node:fs";
-import * as path43 from "node:path";
+import * as path44 from "node:path";
 
 class PlanSyncWorker {
   directory;
@@ -63280,10 +63327,10 @@ class PlanSyncWorker {
     this.onSyncComplete = options.onSyncComplete;
   }
   getSwarmDir() {
-    return path43.resolve(this.directory, ".swarm");
+    return path44.resolve(this.directory, ".swarm");
   }
   getPlanJsonPath() {
-    return path43.join(this.getSwarmDir(), "plan.json");
+    return path44.join(this.getSwarmDir(), "plan.json");
   }
   start() {
     if (this.disposed) {
@@ -63502,8 +63549,8 @@ class PlanSyncWorker {
   checkForUnauthorizedWrite() {
     try {
       const swarmDir = this.getSwarmDir();
-      const planJsonPath = path43.join(swarmDir, "plan.json");
-      const markerPath = path43.join(swarmDir, ".plan-write-marker");
+      const planJsonPath = path44.join(swarmDir, "plan.json");
+      const markerPath = path44.join(swarmDir, ".plan-write-marker");
       const planStats = fs29.statSync(planJsonPath);
       const planMtimeMs = Math.floor(planStats.mtimeMs);
       const markerContent = fs29.readFileSync(markerPath, "utf8");
@@ -63740,11 +63787,11 @@ async function doFlush(directory) {
     const activitySection = renderActivitySection();
     const updated = replaceOrAppendSection(existing, "## Agent Activity", activitySection);
     const flushedCount = swarmState.pendingEvents;
-    const path45 = nodePath2.join(directory, ".swarm", "context.md");
-    const tempPath = `${path45}.tmp`;
+    const path46 = nodePath2.join(directory, ".swarm", "context.md");
+    const tempPath = `${path46}.tmp`;
     try {
       await Bun.write(tempPath, updated);
-      renameSync11(tempPath, path45);
+      renameSync11(tempPath, path46);
     } catch (writeError) {
       try {
         unlinkSync8(tempPath);
@@ -63795,7 +63842,7 @@ ${content.substring(endIndex + 1)}`;
 init_manager();
 init_utils2();
 import * as fs31 from "node:fs";
-import { join as join40 } from "node:path";
+import { join as join41 } from "node:path";
 function createCompactionCustomizerHook(config3, directory) {
   const enabled = config3.hooks?.compaction !== false;
   if (!enabled) {
@@ -63840,7 +63887,7 @@ function createCompactionCustomizerHook(config3, directory) {
         }
       }
       try {
-        const summariesDir = join40(directory, ".swarm", "summaries");
+        const summariesDir = join41(directory, ".swarm", "summaries");
         const files = await fs31.promises.readdir(summariesDir);
         if (files.length > 0) {
           const count = files.length;
@@ -65104,7 +65151,7 @@ init_schema();
 init_manager();
 init_curator();
 init_utils2();
-import * as path46 from "node:path";
+import * as path47 from "node:path";
 function createPhaseMonitorHook(directory, preflightManager, curatorRunner, delegateFactory) {
   let lastKnownPhase = null;
   const handler = async (input, _output) => {
@@ -65124,9 +65171,9 @@ function createPhaseMonitorHook(directory, preflightManager, curatorRunner, dele
           const llmDelegate = delegateFactory?.(sessionId);
           const initResult = await runner(directory, curatorConfig, llmDelegate);
           if (initResult.briefing) {
-            const briefingPath = path46.join(directory, ".swarm", "curator-briefing.md");
+            const briefingPath = path47.join(directory, ".swarm", "curator-briefing.md");
             const { mkdir: mkdir7, writeFile: writeFile7 } = await import("node:fs/promises");
-            await mkdir7(path46.dirname(briefingPath), { recursive: true });
+            await mkdir7(path47.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({
@@ -65251,7 +65298,7 @@ ${originalText}`;
 }
 // src/hooks/repo-graph-builder.ts
 init_constants();
-import * as path49 from "node:path";
+import * as path50 from "node:path";
 
 // src/tools/repo-graph.ts
 init_utils2();
@@ -65260,14 +65307,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 path48 from "node:path";
+import * as path49 from "node:path";
 
 // src/tools/symbols.ts
 init_zod();
 init_create_tool();
 init_path_security();
 import * as fs35 from "node:fs";
-import * as path47 from "node:path";
+import * as path48 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) {
@@ -65284,11 +65331,11 @@ function containsWindowsAttacks(str) {
 }
 function isPathInWorkspace(filePath, workspace) {
   try {
-    const resolvedPath = path47.resolve(workspace, filePath);
+    const resolvedPath = path48.resolve(workspace, filePath);
     const realWorkspace = fs35.realpathSync(workspace);
     const realResolvedPath = fs35.realpathSync(resolvedPath);
-    const relativePath = path47.relative(realWorkspace, realResolvedPath);
-    if (relativePath.startsWith("..") || path47.isAbsolute(relativePath)) {
+    const relativePath = path48.relative(realWorkspace, realResolvedPath);
+    if (relativePath.startsWith("..") || path48.isAbsolute(relativePath)) {
       return false;
     }
     return true;
@@ -65300,7 +65347,7 @@ function validatePathForRead(filePath, workspace) {
   return isPathInWorkspace(filePath, workspace);
 }
 function extractTSSymbols(filePath, cwd) {
-  const fullPath = path47.join(cwd, filePath);
+  const fullPath = path48.join(cwd, filePath);
   if (!validatePathForRead(fullPath, cwd)) {
     return [];
   }
@@ -65452,7 +65499,7 @@ function extractTSSymbols(filePath, cwd) {
   });
 }
 function extractPythonSymbols(filePath, cwd) {
-  const fullPath = path47.join(cwd, filePath);
+  const fullPath = path48.join(cwd, filePath);
   if (!validatePathForRead(fullPath, cwd)) {
     return [];
   }
@@ -65535,7 +65582,7 @@ var symbols = createSwarmTool({
       }, null, 2);
     }
     const cwd = directory;
-    const ext = path47.extname(file3);
+    const ext = path48.extname(file3);
     if (containsControlChars(file3)) {
       return JSON.stringify({
         file: file3,
@@ -65599,7 +65646,7 @@ var symbols = createSwarmTool({
 var WINDOWS_RENAME_MAX_RETRIES = 3;
 var WINDOWS_RENAME_RETRY_DELAY_MS = 50;
 function normalizeGraphPath(filePath) {
-  return path48.normalize(filePath).replace(/\\/g, "/");
+  return path49.normalize(filePath).replace(/\\/g, "/");
 }
 var REPO_GRAPH_FILENAME = "repo-graph.json";
 var GRAPH_SCHEMA_VERSION = "1.0.0";
@@ -65708,8 +65755,8 @@ function resolveModuleSpecifier(workspaceRoot, sourceFile, specifier) {
   }
   try {
     if (specifier.startsWith(".")) {
-      const sourceDir = path48.dirname(sourceFile);
-      let resolved = path48.resolve(sourceDir, specifier);
+      const sourceDir = path49.dirname(sourceFile);
+      let resolved = path49.resolve(sourceDir, specifier);
       let realResolved;
       try {
         realResolved = realpathSync6(resolved);
@@ -65720,7 +65767,7 @@ function resolveModuleSpecifier(workspaceRoot, sourceFile, specifier) {
       try {
         realRoot = realpathSync6(workspaceRoot);
       } catch {
-        realRoot = path48.normalize(workspaceRoot);
+        realRoot = path49.normalize(workspaceRoot);
       }
       if (!existsSync28(resolved)) {
         const EXTENSIONS = [
@@ -65752,9 +65799,9 @@ function resolveModuleSpecifier(workspaceRoot, sourceFile, specifier) {
           return null;
         }
       }
-      const normalizedResolved = path48.normalize(realResolved);
-      const normalizedRoot = path48.normalize(realRoot);
-      if (!normalizedResolved.startsWith(normalizedRoot + path48.sep) && normalizedResolved !== normalizedRoot) {
+      const normalizedResolved = path49.normalize(realResolved);
+      const normalizedRoot = path49.normalize(realRoot);
+      if (!normalizedResolved.startsWith(normalizedRoot + path49.sep) && normalizedResolved !== normalizedRoot) {
         return null;
       }
       return resolved;
@@ -65767,7 +65814,7 @@ function resolveModuleSpecifier(workspaceRoot, sourceFile, specifier) {
 function createEmptyGraph(workspaceRoot) {
   return {
     schema_version: GRAPH_SCHEMA_VERSION,
-    workspaceRoot: path48.normalize(workspaceRoot),
+    workspaceRoot: path49.normalize(workspaceRoot),
     nodes: {},
     edges: [],
     metadata: {
@@ -65801,10 +65848,10 @@ function addEdge(graph, edge) {
   }
 }
 function getCachedGraph(workspace) {
-  return graphCache.get(path48.normalize(workspace));
+  return graphCache.get(path49.normalize(workspace));
 }
 function setCachedGraph(workspace, graph, mtime) {
-  const normalized = path48.normalize(workspace);
+  const normalized = path49.normalize(workspace);
   graphCache.set(normalized, graph);
   dirtyFlags.set(normalized, false);
   if (mtime !== undefined) {
@@ -65812,10 +65859,10 @@ function setCachedGraph(workspace, graph, mtime) {
   }
 }
 function isDirty(workspace) {
-  return dirtyFlags.get(path48.normalize(workspace)) ?? false;
+  return dirtyFlags.get(path49.normalize(workspace)) ?? false;
 }
 function clearCache(workspace) {
-  const normalized = path48.normalize(workspace);
+  const normalized = path49.normalize(workspace);
   graphCache.delete(normalized);
   dirtyFlags.delete(normalized);
   mtimeCache.delete(normalized);
@@ -65828,7 +65875,7 @@ function getGraphPath(workspace) {
 }
 async function loadGraph(workspace) {
   validateWorkspace(workspace);
-  const normalized = path48.normalize(workspace);
+  const normalized = path49.normalize(workspace);
   const cached3 = getCachedGraph(normalized);
   if (cached3 && !isDirty(normalized)) {
     try {
@@ -65922,28 +65969,28 @@ async function saveGraph(workspace, graph, options) {
   if (!Array.isArray(graph.edges)) {
     throw new Error("Graph must have edges array");
   }
-  const normalizedWorkspace = path48.normalize(workspace);
+  const normalizedWorkspace = path49.normalize(workspace);
   let realWorkspace;
   try {
     realWorkspace = realpathSync6(workspace);
   } catch {
     realWorkspace = normalizedWorkspace;
   }
-  const normalizedGraphRoot = path48.normalize(graph.workspaceRoot);
+  const normalizedGraphRoot = path49.normalize(graph.workspaceRoot);
   let realGraphRoot;
   try {
     realGraphRoot = realpathSync6(graph.workspaceRoot);
   } catch {
     realGraphRoot = normalizedGraphRoot;
   }
-  if (path48.normalize(realWorkspace) !== path48.normalize(realGraphRoot)) {
+  if (path49.normalize(realWorkspace) !== path49.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(path48.dirname(tempPath), { recursive: true });
+  await fsPromises3.mkdir(path49.dirname(tempPath), { recursive: true });
   let lastError = null;
   try {
     if (options?.createAtomic) {
@@ -66074,7 +66121,7 @@ function findSourceFiles(dir, stats) {
       stats.skippedDirs++;
       continue;
     }
-    const fullPath = path48.join(dir, entry);
+    const fullPath = path49.join(dir, entry);
     let stat3;
     try {
       stat3 = fsSync2.statSync(fullPath);
@@ -66085,7 +66132,7 @@ function findSourceFiles(dir, stats) {
       const subFiles = findSourceFiles(fullPath, stats);
       files.push(...subFiles);
     } else if (stat3.isFile()) {
-      const ext = path48.extname(fullPath).toLowerCase();
+      const ext = path49.extname(fullPath).toLowerCase();
       if (SUPPORTED_EXTENSIONS.includes(ext)) {
         files.push(fullPath);
       }
@@ -66094,11 +66141,11 @@ function findSourceFiles(dir, stats) {
   return files;
 }
 function toModuleName(filePath, workspaceRoot) {
-  const relative9 = path48.relative(workspaceRoot, filePath);
-  return relative9.split(path48.sep).join("/");
+  const relative9 = path49.relative(workspaceRoot, filePath);
+  return relative9.split(path49.sep).join("/");
 }
 function getLanguage(filePath) {
-  const ext = path48.extname(filePath).toLowerCase();
+  const ext = path49.extname(filePath).toLowerCase();
   return EXTENSION_TO_LANGUAGE[ext] ?? "unknown";
 }
 function isBinaryContent(content) {
@@ -66111,7 +66158,7 @@ function buildWorkspaceGraph(workspaceRoot, options) {
   validateWorkspace(workspaceRoot);
   const maxFileSize = options?.maxFileSizeBytes ?? 1024 * 1024;
   const maxFiles = options?.maxFiles ?? 1e4;
-  const absoluteRoot = path48.resolve(workspaceRoot);
+  const absoluteRoot = path49.resolve(workspaceRoot);
   if (!existsSync28(absoluteRoot)) {
     throw new Error(`Workspace directory does not exist: ${workspaceRoot}`);
   }
@@ -66152,16 +66199,16 @@ function buildWorkspaceGraph(workspaceRoot, options) {
       continue;
     }
     stats.filesScanned++;
-    const ext = path48.extname(filePath).toLowerCase();
+    const ext = path49.extname(filePath).toLowerCase();
     let exports = [];
     let parsedImports = [];
     try {
       if ([".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs"].includes(ext)) {
-        const relativePath = path48.relative(absoluteRoot, filePath);
+        const relativePath = path49.relative(absoluteRoot, filePath);
         const symbols2 = extractTSSymbols(relativePath, absoluteRoot);
         exports = symbols2.filter((s) => s.exported).map((s) => s.name);
       } else if (ext === ".py") {
-        const relativePath = path48.relative(absoluteRoot, filePath);
+        const relativePath = path49.relative(absoluteRoot, filePath);
         const symbols2 = extractPythonSymbols(relativePath, absoluteRoot);
         exports = symbols2.filter((s) => s.exported).map((s) => s.name);
       }
@@ -66218,15 +66265,15 @@ function scanFile(filePath, absoluteRoot, maxFileSize) {
   if (isBinaryContent(content)) {
     return { node: null, edges: [] };
   }
-  const ext = path48.extname(filePath).toLowerCase();
+  const ext = path49.extname(filePath).toLowerCase();
   let exports = [];
   try {
     if ([".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs"].includes(ext)) {
-      const relativePath = path48.relative(absoluteRoot, filePath);
+      const relativePath = path49.relative(absoluteRoot, filePath);
       const symbols2 = extractTSSymbols(relativePath, absoluteRoot);
       exports = symbols2.filter((s) => s.exported).map((s) => s.name);
     } else if (ext === ".py") {
-      const relativePath = path48.relative(absoluteRoot, filePath);
+      const relativePath = path49.relative(absoluteRoot, filePath);
       const symbols2 = extractPythonSymbols(relativePath, absoluteRoot);
       exports = symbols2.filter((s) => s.exported).map((s) => s.name);
     }
@@ -66270,7 +66317,7 @@ async function updateGraphForFiles(workspaceRoot, filePaths, options) {
     return graph2;
   }
   const graph = existingGraph;
-  const absoluteRoot = path48.resolve(workspaceRoot);
+  const absoluteRoot = path49.resolve(workspaceRoot);
   const maxFileSize = 1024 * 1024;
   const updatedPaths = new Set;
   for (const rawFilePath of filePaths) {
@@ -66383,7 +66430,7 @@ function createRepoGraphBuilderHook(workspaceRoot, deps) {
       if (!isSupportedSourceFile(filePath)) {
         return;
       }
-      const absoluteFilePath = path49.isAbsolute(filePath) ? filePath : path49.resolve(workspaceRoot, filePath);
+      const absoluteFilePath = path50.isAbsolute(filePath) ? filePath : path50.resolve(workspaceRoot, filePath);
       const normalizedAbsolute = absoluteFilePath.replace(/\\/g, "/");
       const normalizedWorkspace = workspaceRoot.replace(/\\/g, "/");
       if (!normalizedAbsolute.startsWith(`${normalizedWorkspace}/`) && normalizedAbsolute !== normalizedWorkspace) {
@@ -66391,7 +66438,7 @@ function createRepoGraphBuilderHook(workspaceRoot, deps) {
       }
       try {
         await _updateGraphForFiles(workspaceRoot, [absoluteFilePath]);
-        log(`[repo-graph] Incremental update for ${path49.basename(filePath)}`);
+        log(`[repo-graph] Incremental update for ${path50.basename(filePath)}`);
       } catch (error93) {
         const message = error93 instanceof Error ? error93.message : String(error93);
         error48(`[repo-graph] Incremental update failed: ${message}`);
@@ -66410,14 +66457,14 @@ init_manager2();
 init_detector();
 init_manager();
 import * as fs44 from "node:fs";
-import * as path59 from "node:path";
+import * as path60 from "node:path";
 
 // src/services/decision-drift-analyzer.ts
 init_utils2();
 init_manager();
 init_utils();
 import * as fs36 from "node:fs";
-import * as path50 from "node:path";
+import * as path51 from "node:path";
 var DEFAULT_DRIFT_CONFIG = {
   staleThresholdPhases: 1,
   detectContradictions: true,
@@ -66571,7 +66618,7 @@ async function analyzeDecisionDrift(directory, config3 = {}) {
         currentPhase = legacyPhase;
       }
     }
-    const contextPath = path50.join(directory, ".swarm", "context.md");
+    const contextPath = path51.join(directory, ".swarm", "context.md");
     let contextContent = "";
     try {
       if (fs36.existsSync(contextPath)) {
@@ -66710,7 +66757,7 @@ init_utils();
 init_constants();
 init_schema();
 import * as fs37 from "node:fs/promises";
-import * as path51 from "node:path";
+import * as path52 from "node:path";
 function safeGet(obj, key) {
   if (!obj || !Object.hasOwn(obj, key))
     return;
@@ -66942,9 +66989,9 @@ async function handleDebuggingSpiral(match, taskId, directory) {
   let eventLogged = false;
   let checkpointCreated = false;
   try {
-    const swarmDir = path51.join(directory, ".swarm");
+    const swarmDir = path52.join(directory, ".swarm");
     await fs37.mkdir(swarmDir, { recursive: true });
-    const eventsPath = path51.join(swarmDir, "events.jsonl");
+    const eventsPath = path52.join(swarmDir, "events.jsonl");
     await fs37.appendFile(eventsPath, `${formatDebuggingSpiralEvent(match, taskId)}
 `);
     eventLogged = true;
@@ -67084,7 +67131,7 @@ import * as fs41 from "node:fs";
 
 // src/graph/graph-builder.ts
 import * as fs39 from "node:fs";
-import * as path54 from "node:path";
+import * as path55 from "node:path";
 
 // node_modules/yocto-queue/index.js
 class Node {
@@ -67245,7 +67292,7 @@ function validateConcurrency(concurrency) {
 // src/graph/import-extractor.ts
 init_path_security();
 import * as fs38 from "node:fs";
-import * as path52 from "node:path";
+import * as path53 from "node:path";
 var SOURCE_EXTENSIONS2 = [
   ".ts",
   ".tsx",
@@ -67290,14 +67337,14 @@ function getLanguageFromExtension(ext) {
   return null;
 }
 function toRelForwardSlash(absPath, root) {
-  return path52.relative(root, absPath).replace(/\\/g, "/");
+  return path53.relative(root, absPath).replace(/\\/g, "/");
 }
 function tryResolveTSJS(rawModule, sourceFileAbs) {
   if (!rawModule.startsWith(".") && !rawModule.startsWith("/")) {
     return null;
   }
-  const sourceDir = path52.dirname(sourceFileAbs);
-  const baseAbs = path52.resolve(sourceDir, rawModule);
+  const sourceDir = path53.dirname(sourceFileAbs);
+  const baseAbs = path53.resolve(sourceDir, rawModule);
   const probe = (basePath) => {
     for (const ext of RESOLVE_EXTENSION_CANDIDATES) {
       const test = basePath + ext;
@@ -67308,7 +67355,7 @@ function tryResolveTSJS(rawModule, sourceFileAbs) {
       } catch {}
     }
     for (const indexFile of RESOLVE_INDEX_CANDIDATES) {
-      const test = path52.join(basePath, indexFile);
+      const test = path53.join(basePath, indexFile);
       try {
         const stat3 = fs38.statSync(test);
         if (stat3.isFile())
@@ -67338,13 +67385,13 @@ function tryResolvePython(rawModule, sourceFileAbs, workspaceRoot) {
   }
   const remainder = rawModule.slice(leadingDots).replace(/\./g, "/");
   const upDirs = "../".repeat(Math.max(0, leadingDots - 1));
-  const sourceDir = path52.dirname(sourceFileAbs);
-  const baseAbs = path52.resolve(sourceDir, upDirs + remainder);
+  const sourceDir = path53.dirname(sourceFileAbs);
+  const baseAbs = path53.resolve(sourceDir, upDirs + remainder);
   const accept = (test) => {
     try {
       const stat3 = fs38.statSync(test);
       if (stat3.isFile()) {
-        const rel = path52.relative(workspaceRoot, test).replace(/\\/g, "/");
+        const rel = path53.relative(workspaceRoot, test).replace(/\\/g, "/");
         if (rel.startsWith(".."))
           return null;
         return test;
@@ -67358,7 +67405,7 @@ function tryResolvePython(rawModule, sourceFileAbs, workspaceRoot) {
       return hit;
   }
   for (const indexFile of PY_INDEX_CANDIDATES) {
-    const hit = accept(path52.join(baseAbs, indexFile));
+    const hit = accept(path53.join(baseAbs, indexFile));
     if (hit)
       return hit;
   }
@@ -67729,7 +67776,7 @@ function parseRustUses(content) {
 }
 function extractImports2(opts) {
   const { absoluteFilePath, workspaceRoot } = opts;
-  const ext = path52.extname(absoluteFilePath).toLowerCase();
+  const ext = path53.extname(absoluteFilePath).toLowerCase();
   const language = getLanguageFromExtension(ext);
   if (!language)
     return [];
@@ -67780,9 +67827,9 @@ function extractImports2(opts) {
 }
 
 // src/graph/symbol-extractor.ts
-import * as path53 from "node:path";
+import * as path54 from "node:path";
 function extractExportedSymbols(relativeFilePath, workspaceRoot) {
-  const ext = path53.extname(relativeFilePath).toLowerCase();
+  const ext = path54.extname(relativeFilePath).toLowerCase();
   const language = getLanguageFromExtension(ext);
   if (!language)
     return [];
@@ -67871,15 +67918,15 @@ function findSourceFiles2(workspaceRoot, skipDirs = DEFAULT_SKIP_DIRS) {
       if (entry.isDirectory()) {
         if (skipDirs.has(entry.name))
           continue;
-        stack.push(path54.join(dir, entry.name));
+        stack.push(path55.join(dir, entry.name));
         continue;
       }
       if (!entry.isFile())
         continue;
-      const ext = path54.extname(entry.name).toLowerCase();
+      const ext = path55.extname(entry.name).toLowerCase();
       if (!SOURCE_EXT_SET.has(ext))
         continue;
-      out2.push(path54.join(dir, entry.name));
+      out2.push(path55.join(dir, entry.name));
     }
   }
   return out2;
@@ -67907,7 +67954,7 @@ async function buildRepoGraph(workspaceRoot, options = {}) {
   };
 }
 async function processFile(absoluteFilePath, workspaceRoot) {
-  const ext = path54.extname(absoluteFilePath).toLowerCase();
+  const ext = path55.extname(absoluteFilePath).toLowerCase();
   const language = getLanguageFromExtension(ext);
   if (!language)
     return null;
@@ -67927,7 +67974,7 @@ async function processFile(absoluteFilePath, workspaceRoot) {
   } catch {
     return null;
   }
-  const relPath = path54.relative(workspaceRoot, absoluteFilePath).replace(/\\/g, "/");
+  const relPath = path55.relative(workspaceRoot, absoluteFilePath).replace(/\\/g, "/");
   const imports = extractImports2({
     absoluteFilePath,
     workspaceRoot,
@@ -68169,10 +68216,10 @@ function formatSummary(opts) {
 // src/graph/graph-store.ts
 import * as crypto6 from "node:crypto";
 import * as fs40 from "node:fs";
-import * as path55 from "node:path";
+import * as path56 from "node:path";
 var SWARM_DIR = ".swarm";
 function getGraphPath2(workspaceRoot) {
-  return path55.join(workspaceRoot, SWARM_DIR, REPO_GRAPH_FILENAME2);
+  return path56.join(workspaceRoot, SWARM_DIR, REPO_GRAPH_FILENAME2);
 }
 function loadGraph2(workspaceRoot) {
   const file3 = getGraphPath2(workspaceRoot);
@@ -68194,7 +68241,7 @@ function loadGraph2(workspaceRoot) {
 }
 function saveGraph2(workspaceRoot, graph) {
   const file3 = getGraphPath2(workspaceRoot);
-  const dir = path55.dirname(file3);
+  const dir = path56.dirname(file3);
   try {
     const stat3 = fs40.lstatSync(dir);
     if (stat3.isSymbolicLink()) {
@@ -68300,7 +68347,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 path57 from "node:path";
+import * as path58 from "node:path";
 
 // src/diff/ast-diff.ts
 init_tree_sitter();
@@ -69047,17 +69094,17 @@ async function buildSemanticDiffBlock(directory, changedFiles, maxFiles = 10) {
     const fileConsumers = {};
     if (graph) {
       for (const f of filesToProcess) {
-        const relativePath = path57.isAbsolute(f) ? path57.relative(directory, f) : f;
+        const relativePath = path58.isAbsolute(f) ? path58.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 = path57.normalize(filePath);
-      const resolvedPath = path57.resolve(directory, normalizedPath);
-      const relativeToDir = path57.relative(directory, resolvedPath);
-      if (relativeToDir.startsWith("..") || path57.isAbsolute(relativeToDir)) {
+      const normalizedPath = path58.normalize(filePath);
+      const resolvedPath = path58.resolve(directory, normalizedPath);
+      const relativeToDir = path58.relative(directory, resolvedPath);
+      if (relativeToDir.startsWith("..") || path58.isAbsolute(relativeToDir)) {
         continue;
       }
       try {
@@ -69084,7 +69131,7 @@ async function buildSemanticDiffBlock(directory, changedFiles, maxFiles = 10) {
           stdio: "pipe",
           maxBuffer: 5 * 1024 * 1024
         }) : "";
-        const newContent = fs42.readFileSync(path57.join(directory, filePath), "utf-8");
+        const newContent = fs42.readFileSync(path58.join(directory, filePath), "utf-8");
         const astResult = await computeASTDiff(filePath, oldContent, newContent);
         if (astResult && (astResult.changes.length > 0 || astResult.error !== undefined)) {
           astDiffs.push(astResult);
@@ -69426,7 +69473,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 = path59.basename(path59.resolve(directory));
+                const projectName = path60.basename(path60.resolve(directory));
                 const knowledgeEntries = darkMatterToKnowledgeEntries2(darkMatter, projectName);
                 const knowledgePath = resolveSwarmKnowledgePath(directory);
                 const existingEntries = await readKnowledge(knowledgePath);
@@ -69625,7 +69672,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 = path59.join(directory, ".swarm", "evidence", `${taskId_ccp}.json`);
+                const evidencePath = path60.join(directory, ".swarm", "evidence", `${taskId_ccp}.json`);
                 if (fs44.existsSync(evidencePath)) {
                   const evidenceContent = fs44.readFileSync(evidencePath, "utf-8");
                   const evidenceData = JSON.parse(evidenceContent);
@@ -70771,7 +70818,7 @@ init_hive_promoter();
 
 // src/hooks/incremental-verify.ts
 import * as fs45 from "node:fs";
-import * as path60 from "node:path";
+import * as path61 from "node:path";
 
 // src/hooks/spawn-helper.ts
 import * as child_process6 from "node:child_process";
@@ -70849,18 +70896,18 @@ function spawnAsync(command, cwd, timeoutMs) {
 // src/hooks/incremental-verify.ts
 var emittedSkipAdvisories = new Set;
 function detectPackageManager(projectDir) {
-  if (fs45.existsSync(path60.join(projectDir, "bun.lockb")))
+  if (fs45.existsSync(path61.join(projectDir, "bun.lockb")))
     return "bun";
-  if (fs45.existsSync(path60.join(projectDir, "pnpm-lock.yaml")))
+  if (fs45.existsSync(path61.join(projectDir, "pnpm-lock.yaml")))
     return "pnpm";
-  if (fs45.existsSync(path60.join(projectDir, "yarn.lock")))
+  if (fs45.existsSync(path61.join(projectDir, "yarn.lock")))
     return "yarn";
-  if (fs45.existsSync(path60.join(projectDir, "package-lock.json")))
+  if (fs45.existsSync(path61.join(projectDir, "package-lock.json")))
     return "npm";
   return "bun";
 }
 function detectTypecheckCommand(projectDir) {
-  const pkgPath = path60.join(projectDir, "package.json");
+  const pkgPath = path61.join(projectDir, "package.json");
   if (fs45.existsSync(pkgPath)) {
     try {
       const pkg = JSON.parse(fs45.readFileSync(pkgPath, "utf8"));
@@ -70877,8 +70924,8 @@ function detectTypecheckCommand(projectDir) {
         ...pkg.dependencies,
         ...pkg.devDependencies
       };
-      if (!deps?.typescript && !fs45.existsSync(path60.join(projectDir, "tsconfig.json"))) {}
-      const hasTSMarkers = deps?.typescript || fs45.existsSync(path60.join(projectDir, "tsconfig.json"));
+      if (!deps?.typescript && !fs45.existsSync(path61.join(projectDir, "tsconfig.json"))) {}
+      const hasTSMarkers = deps?.typescript || fs45.existsSync(path61.join(projectDir, "tsconfig.json"));
       if (hasTSMarkers) {
         return { command: ["npx", "tsc", "--noEmit"], language: "typescript" };
       }
@@ -70886,13 +70933,13 @@ function detectTypecheckCommand(projectDir) {
       return null;
     }
   }
-  if (fs45.existsSync(path60.join(projectDir, "go.mod"))) {
+  if (fs45.existsSync(path61.join(projectDir, "go.mod"))) {
     return { command: ["go", "vet", "./..."], language: "go" };
   }
-  if (fs45.existsSync(path60.join(projectDir, "Cargo.toml"))) {
+  if (fs45.existsSync(path61.join(projectDir, "Cargo.toml"))) {
     return { command: ["cargo", "check"], language: "rust" };
   }
-  if (fs45.existsSync(path60.join(projectDir, "pyproject.toml")) || fs45.existsSync(path60.join(projectDir, "requirements.txt")) || fs45.existsSync(path60.join(projectDir, "setup.py"))) {
+  if (fs45.existsSync(path61.join(projectDir, "pyproject.toml")) || fs45.existsSync(path61.join(projectDir, "requirements.txt")) || fs45.existsSync(path61.join(projectDir, "setup.py"))) {
     return { command: null, language: "python" };
   }
   try {
@@ -71242,7 +71289,7 @@ init_scope_persistence();
 init_state();
 init_delegation_gate();
 init_normalize_tool_name();
-import * as path62 from "node:path";
+import * as path63 from "node:path";
 var WRITE_TOOLS = new Set(WRITE_TOOL_NAMES);
 function createScopeGuardHook(config3, directory, injectAdvisory) {
   const enabled = config3.enabled ?? true;
@@ -71300,13 +71347,13 @@ function createScopeGuardHook(config3, directory, injectAdvisory) {
 }
 function isFileInScope(filePath, scopeEntries, directory) {
   const dir = directory ?? process.cwd();
-  const resolvedFile = path62.resolve(dir, filePath);
+  const resolvedFile = path63.resolve(dir, filePath);
   return scopeEntries.some((scope) => {
-    const resolvedScope = path62.resolve(dir, scope);
+    const resolvedScope = path63.resolve(dir, scope);
     if (resolvedFile === resolvedScope)
       return true;
-    const rel = path62.relative(resolvedScope, resolvedFile);
-    return rel.length > 0 && !rel.startsWith("..") && !path62.isAbsolute(rel);
+    const rel = path63.relative(resolvedScope, resolvedFile);
+    return rel.length > 0 && !rel.startsWith("..") && !path63.isAbsolute(rel);
   });
 }
 
@@ -71358,7 +71405,7 @@ function createSelfReviewHook(config3, injectAdvisory) {
 
 // src/hooks/slop-detector.ts
 import * as fs47 from "node:fs";
-import * as path63 from "node:path";
+import * as path64 from "node:path";
 var WRITE_EDIT_TOOLS = new Set([
   "write",
   "edit",
@@ -71408,7 +71455,7 @@ function walkFiles(dir, exts, deadline) {
         break;
       if (entry.isSymbolicLink())
         continue;
-      const full = path63.join(dir, entry.name);
+      const full = path64.join(dir, entry.name);
       if (entry.isDirectory()) {
         if (entry.name === "node_modules" || entry.name === ".git")
           continue;
@@ -71423,7 +71470,7 @@ function walkFiles(dir, exts, deadline) {
   return results;
 }
 function checkDeadExports(content, projectDir, startTime) {
-  const hasPackageJson = fs47.existsSync(path63.join(projectDir, "package.json"));
+  const hasPackageJson = fs47.existsSync(path64.join(projectDir, "package.json"));
   if (!hasPackageJson)
     return null;
   const exportMatches = content.matchAll(/^\+(?:export)\s+(?:function|class|const|type|interface)\s+(\w{3,})/gm);
@@ -71631,14 +71678,14 @@ function createSteeringConsumedHook(directory) {
 // src/hooks/trajectory-logger.ts
 init_manager2();
 import * as fs50 from "node:fs/promises";
-import * as path65 from "node:path";
+import * as path66 from "node:path";
 
 // src/prm/trajectory-store.ts
 init_utils2();
 import * as fs49 from "node:fs/promises";
-import * as path64 from "node:path";
+import * as path65 from "node:path";
 function getTrajectoryPath(sessionId, directory) {
-  const relativePath = path64.join("trajectories", `${sessionId}.jsonl`);
+  const relativePath = path65.join("trajectories", `${sessionId}.jsonl`);
   return validateSwarmPath(directory, relativePath);
 }
 var _inMemoryTrajectoryCache = new Map;
@@ -71657,7 +71704,7 @@ async function appendTrajectoryEntry(sessionId, entry, directory, maxLines = 100
       _inMemoryTrajectoryCache.set(sessionId, cached3);
     }
     const trajectoryPath = getTrajectoryPath(sessionId, directory);
-    await fs49.mkdir(path64.dirname(trajectoryPath), { recursive: true });
+    await fs49.mkdir(path65.dirname(trajectoryPath), { recursive: true });
     const line = `${JSON.stringify(entry)}
 `;
     await fs49.appendFile(trajectoryPath, line, "utf-8");
@@ -71696,7 +71743,7 @@ async function cleanupOldTrajectoryFiles(directory, maxAgeDays = 7) {
       for (const entry of entries) {
         if (!entry.isFile())
           continue;
-        const filePath = path64.join(dirPath, entry.name);
+        const filePath = path65.join(dirPath, entry.name);
         try {
           const stat4 = await fs49.stat(filePath);
           if (now - stat4.mtimeMs > cutoffMs) {
@@ -71888,10 +71935,10 @@ function createTrajectoryLoggerHook(config3, _directory) {
         elapsed_ms
       };
       const sanitized = sanitizeTaskId2(taskId);
-      const relativePath = path65.join("evidence", sanitized, "trajectory.jsonl");
+      const relativePath = path66.join("evidence", sanitized, "trajectory.jsonl");
       const trajectoryPath = validateSwarmPath(_directory, relativePath);
       try {
-        await fs50.mkdir(path65.dirname(trajectoryPath), { recursive: true });
+        await fs50.mkdir(path66.dirname(trajectoryPath), { recursive: true });
         const line = `${JSON.stringify(entry)}
 `;
         await fs50.appendFile(trajectoryPath, line, "utf-8");
@@ -72442,16 +72489,16 @@ init_telemetry();
 
 // src/prm/replay.ts
 import { promises as fs51 } from "node:fs";
-import path66 from "node:path";
+import path67 from "node:path";
 function isPathSafe2(targetPath, basePath) {
-  const resolvedTarget = path66.resolve(targetPath);
-  const resolvedBase = path66.resolve(basePath);
-  const rel = path66.relative(resolvedBase, resolvedTarget);
-  return !rel.startsWith("..") && !path66.isAbsolute(rel);
+  const resolvedTarget = path67.resolve(targetPath);
+  const resolvedBase = path67.resolve(basePath);
+  const rel = path67.relative(resolvedBase, resolvedTarget);
+  return !rel.startsWith("..") && !path67.isAbsolute(rel);
 }
 function isWithinReplaysDir(targetPath) {
-  const resolved = path66.resolve(targetPath);
-  const parts2 = resolved.split(path66.sep);
+  const resolved = path67.resolve(targetPath);
+  const parts2 = resolved.split(path67.sep);
   for (let i2 = 0;i2 < parts2.length - 1; i2++) {
     if (parts2[i2] === ".swarm" && parts2[i2 + 1] === "replays") {
       return true;
@@ -72464,10 +72511,10 @@ function sanitizeFilename(input) {
 }
 async function startReplayRecording(sessionID, directory) {
   try {
-    const replayDir = path66.join(directory, ".swarm", "replays");
+    const replayDir = path67.join(directory, ".swarm", "replays");
     const safeSessionID = sanitizeFilename(sessionID);
     const filename = `${safeSessionID}-${Date.now()}.jsonl`;
-    const filepath = path66.join(replayDir, filename);
+    const filepath = path67.join(replayDir, filename);
     if (!isPathSafe2(filepath, replayDir)) {
       console.warn(`[replay] Invalid path detected - path traversal attempt blocked for session ${sessionID}`);
       return null;
@@ -72833,7 +72880,7 @@ init_telemetry();
 init_dist();
 init_create_tool();
 import * as fs52 from "node:fs";
-import * as path67 from "node:path";
+import * as path68 from "node:path";
 init_path_security();
 var WINDOWS_RESERVED_NAMES2 = /^(con|prn|aux|nul|com[1-9]|lpt[1-9])(\.|:|$)/i;
 function containsWindowsAttacks2(str) {
@@ -72850,14 +72897,14 @@ function containsWindowsAttacks2(str) {
 }
 function isPathInWorkspace2(filePath, workspace) {
   try {
-    const resolvedPath = path67.resolve(workspace, filePath);
+    const resolvedPath = path68.resolve(workspace, filePath);
     if (!fs52.existsSync(resolvedPath)) {
       return true;
     }
     const realWorkspace = fs52.realpathSync(workspace);
     const realResolvedPath = fs52.realpathSync(resolvedPath);
-    const relativePath = path67.relative(realWorkspace, realResolvedPath);
-    if (relativePath.startsWith("..") || path67.isAbsolute(relativePath)) {
+    const relativePath = path68.relative(realWorkspace, realResolvedPath);
+    if (relativePath.startsWith("..") || path68.isAbsolute(relativePath)) {
       return false;
     }
     return true;
@@ -72866,7 +72913,7 @@ function isPathInWorkspace2(filePath, workspace) {
   }
 }
 function processFile2(file3, cwd, exportedOnly) {
-  const ext = path67.extname(file3);
+  const ext = path68.extname(file3);
   if (containsControlChars(file3)) {
     return {
       file: file3,
@@ -72899,7 +72946,7 @@ function processFile2(file3, cwd, exportedOnly) {
       errorType: "path-outside-workspace"
     };
   }
-  const fullPath = path67.join(cwd, file3);
+  const fullPath = path68.join(cwd, file3);
   if (!fs52.existsSync(fullPath)) {
     return {
       file: file3,
@@ -73191,15 +73238,15 @@ init_task_id();
 init_create_tool();
 init_resolve_working_directory();
 import * as fs53 from "node:fs";
-import * as path68 from "node:path";
+import * as path69 from "node:path";
 var EVIDENCE_DIR = ".swarm/evidence";
 function isValidTaskId3(taskId) {
   return isStrictTaskId(taskId);
 }
 function isPathWithinSwarm(filePath, workspaceRoot) {
-  const normalizedWorkspace = path68.resolve(workspaceRoot);
-  const swarmPath = path68.join(normalizedWorkspace, ".swarm", "evidence");
-  const normalizedPath = path68.resolve(filePath);
+  const normalizedWorkspace = path69.resolve(workspaceRoot);
+  const swarmPath = path69.join(normalizedWorkspace, ".swarm", "evidence");
+  const normalizedPath = path69.resolve(filePath);
   return normalizedPath.startsWith(swarmPath);
 }
 function readEvidenceFile(evidencePath) {
@@ -73280,7 +73327,7 @@ var check_gate_status = createSwarmTool({
       };
       return JSON.stringify(errorResult, null, 2);
     }
-    const evidencePath = path68.join(directory, EVIDENCE_DIR, `${taskIdInput}.json`);
+    const evidencePath = path69.join(directory, EVIDENCE_DIR, `${taskIdInput}.json`);
     if (!isPathWithinSwarm(evidencePath, directory)) {
       const errorResult = {
         taskId: taskIdInput,
@@ -73377,7 +73424,7 @@ init_state();
 init_create_tool();
 init_resolve_working_directory();
 import * as fs54 from "node:fs";
-import * as path69 from "node:path";
+import * as path70 from "node:path";
 function extractMatches(regex, text) {
   return Array.from(text.matchAll(regex));
 }
@@ -73529,10 +73576,10 @@ async function executeCompletionVerify(args2, directory) {
     let hasFileReadFailure = false;
     for (const filePath of fileTargets) {
       const normalizedPath = filePath.replace(/\\/g, "/");
-      const resolvedPath = path69.resolve(directory, normalizedPath);
-      const projectRoot = path69.resolve(directory);
-      const relative16 = path69.relative(projectRoot, resolvedPath);
-      const withinProject = relative16 === "" || !relative16.startsWith("..") && !path69.isAbsolute(relative16);
+      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);
       if (!withinProject) {
         blockedTasks.push({
           task_id: task.id,
@@ -73587,8 +73634,8 @@ async function executeCompletionVerify(args2, directory) {
     blockedTasks
   };
   try {
-    const evidenceDir = path69.join(directory, ".swarm", "evidence", `${phase}`);
-    const evidencePath = path69.join(evidenceDir, "completion-verify.json");
+    const evidenceDir = path70.join(directory, ".swarm", "evidence", `${phase}`);
+    const evidencePath = path70.join(evidenceDir, "completion-verify.json");
     fs54.mkdirSync(evidenceDir, { recursive: true });
     const evidenceBundle = {
       schema_version: "1.0.0",
@@ -73665,11 +73712,11 @@ var completion_verify = createSwarmTool({
 // src/tools/complexity-hotspots.ts
 init_zod();
 import * as fs56 from "node:fs";
-import * as path71 from "node:path";
+import * as path72 from "node:path";
 
 // src/quality/metrics.ts
 import * as fs55 from "node:fs";
-import * as path70 from "node:path";
+import * as path71 from "node:path";
 var MAX_FILE_SIZE_BYTES4 = 256 * 1024;
 var MIN_DUPLICATION_LINES = 10;
 function estimateCyclomaticComplexity(content) {
@@ -73721,7 +73768,7 @@ async function computeComplexityDelta(files, workingDir) {
   let totalComplexity = 0;
   const analyzedFiles = [];
   for (const file3 of files) {
-    const fullPath = path70.isAbsolute(file3) ? file3 : path70.join(workingDir, file3);
+    const fullPath = path71.isAbsolute(file3) ? file3 : path71.join(workingDir, file3);
     if (!fs55.existsSync(fullPath)) {
       continue;
     }
@@ -73844,7 +73891,7 @@ function countGoExports(content) {
 function getExportCountForFile(filePath) {
   try {
     const content = fs55.readFileSync(filePath, "utf-8");
-    const ext = path70.extname(filePath).toLowerCase();
+    const ext = path71.extname(filePath).toLowerCase();
     switch (ext) {
       case ".ts":
       case ".tsx":
@@ -73870,7 +73917,7 @@ async function computePublicApiDelta(files, workingDir) {
   let totalExports = 0;
   const analyzedFiles = [];
   for (const file3 of files) {
-    const fullPath = path70.isAbsolute(file3) ? file3 : path70.join(workingDir, file3);
+    const fullPath = path71.isAbsolute(file3) ? file3 : path71.join(workingDir, file3);
     if (!fs55.existsSync(fullPath)) {
       continue;
     }
@@ -73904,7 +73951,7 @@ async function computeDuplicationRatio(files, workingDir) {
   let duplicateLines = 0;
   const analyzedFiles = [];
   for (const file3 of files) {
-    const fullPath = path70.isAbsolute(file3) ? file3 : path70.join(workingDir, file3);
+    const fullPath = path71.isAbsolute(file3) ? file3 : path71.join(workingDir, file3);
     if (!fs55.existsSync(fullPath)) {
       continue;
     }
@@ -73937,8 +73984,8 @@ function countCodeLines(content) {
   return lines.length;
 }
 function isTestFile(filePath) {
-  const basename10 = path70.basename(filePath);
-  const _ext = path70.extname(filePath).toLowerCase();
+  const basename10 = path71.basename(filePath);
+  const _ext = path71.extname(filePath).toLowerCase();
   const testPatterns = [
     ".test.",
     ".spec.",
@@ -74019,8 +74066,8 @@ function matchGlobSegment(globSegments, pathSegments) {
   }
   return gIndex === globSegments.length && pIndex === pathSegments.length;
 }
-function matchesGlobSegment(path71, glob) {
-  const normalizedPath = path71.replace(/\\/g, "/");
+function matchesGlobSegment(path72, glob) {
+  const normalizedPath = path72.replace(/\\/g, "/");
   const normalizedGlob = glob.replace(/\\/g, "/");
   if (normalizedPath.includes("//")) {
     return false;
@@ -74051,8 +74098,8 @@ function simpleGlobToRegex2(glob) {
 function hasGlobstar(glob) {
   return glob.includes("**");
 }
-function globMatches(path71, glob) {
-  const normalizedPath = path71.replace(/\\/g, "/");
+function globMatches(path72, glob) {
+  const normalizedPath = path72.replace(/\\/g, "/");
   if (!glob || glob === "") {
     if (normalizedPath.includes("//")) {
       return false;
@@ -74088,7 +74135,7 @@ function shouldExcludeFile(filePath, excludeGlobs) {
 async function computeTestToCodeRatio(workingDir, enforceGlobs, excludeGlobs) {
   let testLines = 0;
   let codeLines = 0;
-  const srcDir = path70.join(workingDir, "src");
+  const srcDir = path71.join(workingDir, "src");
   if (fs55.existsSync(srcDir)) {
     await scanDirectoryForLines(srcDir, enforceGlobs, excludeGlobs, false, (lines) => {
       codeLines += lines;
@@ -74096,14 +74143,14 @@ async function computeTestToCodeRatio(workingDir, enforceGlobs, excludeGlobs) {
   }
   const possibleSrcDirs = ["lib", "app", "source", "core"];
   for (const dir of possibleSrcDirs) {
-    const dirPath = path70.join(workingDir, dir);
+    const dirPath = path71.join(workingDir, dir);
     if (fs55.existsSync(dirPath)) {
       await scanDirectoryForLines(dirPath, enforceGlobs, excludeGlobs, false, (lines) => {
         codeLines += lines;
       });
     }
   }
-  const testsDir = path70.join(workingDir, "tests");
+  const testsDir = path71.join(workingDir, "tests");
   if (fs55.existsSync(testsDir)) {
     await scanDirectoryForLines(testsDir, ["**"], ["node_modules", "dist"], true, (lines) => {
       testLines += lines;
@@ -74111,7 +74158,7 @@ async function computeTestToCodeRatio(workingDir, enforceGlobs, excludeGlobs) {
   }
   const possibleTestDirs = ["test", "__tests__", "specs"];
   for (const dir of possibleTestDirs) {
-    const dirPath = path70.join(workingDir, dir);
+    const dirPath = path71.join(workingDir, dir);
     if (fs55.existsSync(dirPath) && dirPath !== testsDir) {
       await scanDirectoryForLines(dirPath, ["**"], ["node_modules", "dist"], true, (lines) => {
         testLines += lines;
@@ -74126,7 +74173,7 @@ async function scanDirectoryForLines(dirPath, includeGlobs, excludeGlobs, isTest
   try {
     const entries = fs55.readdirSync(dirPath, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = path70.join(dirPath, entry.name);
+      const fullPath = path71.join(dirPath, entry.name);
       if (entry.isDirectory()) {
         if (entry.name === "node_modules" || entry.name === "dist" || entry.name === "build" || entry.name === ".git") {
           continue;
@@ -74134,7 +74181,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 = path70.extname(entry.name).toLowerCase();
+        const ext = path71.extname(entry.name).toLowerCase();
         const validExts = [
           ".ts",
           ".tsx",
@@ -74387,7 +74434,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 = path71.extname(file3).toLowerCase();
+    const ext = path72.extname(file3).toLowerCase();
     if (extSet.has(ext)) {
       filteredChurn.set(file3, count);
     }
@@ -74398,7 +74445,7 @@ async function analyzeHotspots(days, topN, extensions, directory) {
   for (const [file3, churnCount] of filteredChurn) {
     let fullPath = file3;
     if (!fs56.existsSync(fullPath)) {
-      fullPath = path71.join(cwd, file3);
+      fullPath = path72.join(cwd, file3);
     }
     const complexity = getComplexityForFile2(fullPath);
     if (complexity !== null) {
@@ -74572,7 +74619,7 @@ import {
   readFileSync as readFileSync36,
   writeFileSync as writeFileSync11
 } from "node:fs";
-import { join as join64 } from "node:path";
+import { join as join65 } from "node:path";
 var EVIDENCE_DIR2 = ".swarm/evidence";
 var VALID_TASK_ID = /^\d+\.\d+(\.\d+)*$/;
 var COUNCIL_GATE_NAME = "council";
@@ -74606,9 +74653,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 = join64(workingDir, EVIDENCE_DIR2);
+  const dir = join65(workingDir, EVIDENCE_DIR2);
   mkdirSync18(dir, { recursive: true });
-  const filePath = join64(dir, `${synthesis.taskId}.json`);
+  const filePath = join65(dir, `${synthesis.taskId}.json`);
   const existingRoot = Object.create(null);
   if (existsSync37(filePath)) {
     try {
@@ -74642,7 +74689,7 @@ function writeCouncilEvidence(workingDir, synthesis) {
     updated.required_gates = [];
   writeFileSync11(filePath, JSON.stringify(updated, null, 2));
   try {
-    const councilDir = join64(workingDir, ".swarm", "council");
+    const councilDir = join65(workingDir, ".swarm", "council");
     mkdirSync18(councilDir, { recursive: true });
     const auditLine = JSON.stringify({
       round: synthesis.roundNumber,
@@ -74650,7 +74697,7 @@ function writeCouncilEvidence(workingDir, synthesis) {
       timestamp: synthesis.timestamp,
       vetoedBy: synthesis.vetoedBy
     });
-    appendFileSync6(join64(councilDir, `${synthesis.taskId}.rounds.jsonl`), `${auditLine}
+    appendFileSync6(join65(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)}`);
@@ -74783,20 +74830,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 join65 } from "node:path";
+import { join as join66 } from "node:path";
 var COUNCIL_DIR = ".swarm/council";
 function writeCriteria(workingDir, taskId, criteria) {
-  const dir = join65(workingDir, COUNCIL_DIR);
+  const dir = join66(workingDir, COUNCIL_DIR);
   mkdirSync19(dir, { recursive: true });
   const payload = {
     taskId,
     criteria,
     declaredAt: new Date().toISOString()
   };
-  writeFileSync12(join65(dir, `${safeId(taskId)}.json`), JSON.stringify(payload, null, 2));
+  writeFileSync12(join66(dir, `${safeId(taskId)}.json`), JSON.stringify(payload, null, 2));
 }
 function readCriteria(workingDir, taskId) {
-  const filePath = join65(workingDir, COUNCIL_DIR, `${safeId(taskId)}.json`);
+  const filePath = join66(workingDir, COUNCIL_DIR, `${safeId(taskId)}.json`);
   if (!existsSync38(filePath))
     return null;
   try {
@@ -74949,7 +74996,7 @@ var submit_council_verdicts = createSwarmTool({
 init_zod();
 init_loader();
 import * as fs57 from "node:fs";
-import * as path72 from "node:path";
+import * as path73 from "node:path";
 
 // src/council/general-council-advisory.ts
 var ADVISORY_HEADER = "[general_council] (advisory; not blocking)";
@@ -75397,10 +75444,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 = path72.join(workingDir, ".swarm", "council", "general");
+    const evidenceDir = path73.join(workingDir, ".swarm", "council", "general");
     const safeTimestamp = result.timestamp.replace(/[:.]/g, "-");
     const evidenceFile = `${safeTimestamp}-${input.mode}.json`;
-    const evidencePath = path72.join(evidenceDir, evidenceFile);
+    const evidencePath = path73.join(evidenceDir, evidenceFile);
     try {
       await fs57.promises.mkdir(evidenceDir, { recursive: true });
       await fs57.promises.writeFile(evidencePath, JSON.stringify(result, null, 2));
@@ -75637,7 +75684,7 @@ init_state();
 init_task_id();
 init_create_tool();
 import * as fs58 from "node:fs";
-import * as path73 from "node:path";
+import * as path74 from "node:path";
 function validateTaskIdFormat2(taskId) {
   return validateTaskIdFormat(taskId);
 }
@@ -75711,8 +75758,8 @@ async function executeDeclareScope(args2, fallbackDir) {
         };
       }
     }
-    normalizedDir = path73.normalize(args2.working_directory);
-    const pathParts = normalizedDir.split(path73.sep);
+    normalizedDir = path74.normalize(args2.working_directory);
+    const pathParts = normalizedDir.split(path74.sep);
     if (pathParts.includes("..")) {
       return {
         success: false,
@@ -75722,10 +75769,10 @@ async function executeDeclareScope(args2, fallbackDir) {
         ]
       };
     }
-    const resolvedDir = path73.resolve(normalizedDir);
+    const resolvedDir = path74.resolve(normalizedDir);
     try {
       const realPath = fs58.realpathSync(resolvedDir);
-      const planPath2 = path73.join(realPath, ".swarm", "plan.json");
+      const planPath2 = path74.join(realPath, ".swarm", "plan.json");
       if (!fs58.existsSync(planPath2)) {
         return {
           success: false,
@@ -75749,7 +75796,7 @@ async function executeDeclareScope(args2, fallbackDir) {
     console.warn("[declare-scope] fallbackDir is undefined, falling back to process.cwd()");
   }
   const directory = normalizedDir || fallbackDir;
-  const planPath = path73.resolve(directory, ".swarm", "plan.json");
+  const planPath = path74.resolve(directory, ".swarm", "plan.json");
   if (!fs58.existsSync(planPath)) {
     return {
       success: false,
@@ -75789,8 +75836,8 @@ async function executeDeclareScope(args2, fallbackDir) {
   const normalizeErrors = [];
   const dir = normalizedDir || fallbackDir || process.cwd();
   const mergedFiles = rawMergedFiles.map((file3) => {
-    if (path73.isAbsolute(file3)) {
-      const relativePath = path73.relative(dir, file3).replace(/\\/g, "/");
+    if (path74.isAbsolute(file3)) {
+      const relativePath = path74.relative(dir, file3).replace(/\\/g, "/");
       if (relativePath.startsWith("..")) {
         normalizeErrors.push(`Path '${file3}' resolves outside the project directory`);
         return file3;
@@ -75851,7 +75898,7 @@ var declare_scope = createSwarmTool({
 init_zod();
 import * as child_process7 from "node:child_process";
 import * as fs59 from "node:fs";
-import * as path74 from "node:path";
+import * as path75 from "node:path";
 init_create_tool();
 var MAX_DIFF_LINES = 500;
 var DIFF_TIMEOUT_MS = 30000;
@@ -75880,20 +75927,20 @@ function validateBase(base) {
 function validatePaths(paths) {
   if (!paths)
     return null;
-  for (const path75 of paths) {
-    if (!path75 || path75.length === 0) {
+  for (const path76 of paths) {
+    if (!path76 || path76.length === 0) {
       return "empty path not allowed";
     }
-    if (path75.length > MAX_PATH_LENGTH) {
+    if (path76.length > MAX_PATH_LENGTH) {
       return `path exceeds maximum length of ${MAX_PATH_LENGTH}`;
     }
-    if (SHELL_METACHARACTERS2.test(path75)) {
+    if (SHELL_METACHARACTERS2.test(path76)) {
       return "path contains shell metacharacters";
     }
-    if (path75.startsWith("-")) {
+    if (path76.startsWith("-")) {
       return 'path cannot start with "-" (option-like arguments not allowed)';
     }
-    if (CONTROL_CHAR_PATTERN2.test(path75)) {
+    if (CONTROL_CHAR_PATTERN2.test(path76)) {
       return "path contains control characters";
     }
   }
@@ -75999,8 +76046,8 @@ var diff = createSwarmTool({
         if (parts2.length >= 3) {
           const additions = parseInt(parts2[0], 10) || 0;
           const deletions = parseInt(parts2[1], 10) || 0;
-          const path75 = parts2[2];
-          files.push({ path: path75, additions, deletions });
+          const path76 = parts2[2];
+          files.push({ path: path76, additions, deletions });
         }
       }
       const contractChanges = [];
@@ -76040,7 +76087,7 @@ var diff = createSwarmTool({
           } else if (base === "unstaged") {
             const oldRef = `:${file3.path}`;
             oldContent = fileExistsInRef(oldRef) ? getContentFromRef(oldRef) : "";
-            newContent = fs59.readFileSync(path74.join(directory, file3.path), "utf-8");
+            newContent = fs59.readFileSync(path75.join(directory, file3.path), "utf-8");
           } else {
             const oldRef = `${base}:${file3.path}`;
             oldContent = fileExistsInRef(oldRef) ? getContentFromRef(oldRef) : "";
@@ -76115,7 +76162,7 @@ var diff = createSwarmTool({
 init_zod();
 import * as child_process8 from "node:child_process";
 import * as fs60 from "node:fs";
-import * as path75 from "node:path";
+import * as path76 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.",
@@ -76163,7 +76210,7 @@ var diff_summary = createSwarmTool({
         }
         try {
           let oldContent;
-          const newContent = fs60.readFileSync(path75.join(workingDir, filePath), "utf-8");
+          const newContent = fs60.readFileSync(path76.join(workingDir, filePath), "utf-8");
           if (fileExistsInHead) {
             oldContent = child_process8.execFileSync("git", ["show", `HEAD:${filePath}`], {
               encoding: "utf-8",
@@ -76392,7 +76439,7 @@ init_zod();
 init_create_tool();
 init_path_security();
 import * as fs61 from "node:fs";
-import * as path76 from "node:path";
+import * as path77 from "node:path";
 var MAX_FILE_SIZE_BYTES6 = 1024 * 1024;
 var MAX_EVIDENCE_FILES = 1000;
 var EVIDENCE_DIR3 = ".swarm/evidence";
@@ -76419,9 +76466,9 @@ function validateRequiredTypes(input) {
   return null;
 }
 function isPathWithinSwarm2(filePath, cwd) {
-  const normalizedCwd = path76.resolve(cwd);
-  const swarmPath = path76.join(normalizedCwd, ".swarm");
-  const normalizedPath = path76.resolve(filePath);
+  const normalizedCwd = path77.resolve(cwd);
+  const swarmPath = path77.join(normalizedCwd, ".swarm");
+  const normalizedPath = path77.resolve(filePath);
   return normalizedPath.startsWith(swarmPath);
 }
 function parseCompletedTasks(planContent) {
@@ -76451,10 +76498,10 @@ function readEvidenceFiles(evidenceDir, _cwd) {
     if (!VALID_EVIDENCE_FILENAME_REGEX.test(filename)) {
       continue;
     }
-    const filePath = path76.join(evidenceDir, filename);
+    const filePath = path77.join(evidenceDir, filename);
     try {
-      const resolvedPath = path76.resolve(filePath);
-      const evidenceDirResolved = path76.resolve(evidenceDir);
+      const resolvedPath = path77.resolve(filePath);
+      const evidenceDirResolved = path77.resolve(evidenceDir);
       if (!resolvedPath.startsWith(evidenceDirResolved)) {
         continue;
       }
@@ -76572,7 +76619,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 = path76.join(cwd, PLAN_FILE);
+    const planPath = path77.join(cwd, PLAN_FILE);
     if (!isPathWithinSwarm2(planPath, cwd)) {
       const errorResult = {
         error: "plan file path validation failed",
@@ -76604,7 +76651,7 @@ var evidence_check = createSwarmTool({
       };
       return JSON.stringify(result2, null, 2);
     }
-    const evidenceDir = path76.join(cwd, EVIDENCE_DIR3);
+    const evidenceDir = path77.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;
@@ -76622,7 +76669,7 @@ var evidence_check = createSwarmTool({
 init_zod();
 init_create_tool();
 import * as fs62 from "node:fs";
-import * as path77 from "node:path";
+import * as path78 from "node:path";
 var EXT_MAP = {
   python: ".py",
   py: ".py",
@@ -76703,12 +76750,12 @@ var extract_code_blocks = createSwarmTool({
       if (prefix) {
         filename = `${prefix}_${filename}`;
       }
-      let filepath = path77.join(targetDir, filename);
-      const base = path77.basename(filepath, path77.extname(filepath));
-      const ext = path77.extname(filepath);
+      let filepath = path78.join(targetDir, filename);
+      const base = path78.basename(filepath, path78.extname(filepath));
+      const ext = path78.extname(filepath);
       let counter = 1;
       while (fs62.existsSync(filepath)) {
-        filepath = path77.join(targetDir, `${base}_${counter}${ext}`);
+        filepath = path78.join(targetDir, `${base}_${counter}${ext}`);
         counter++;
       }
       try {
@@ -76972,7 +77019,7 @@ init_zod();
 init_create_tool();
 init_path_security();
 import * as fs63 from "node:fs";
-import * as path78 from "node:path";
+import * as path79 from "node:path";
 var MAX_FILE_PATH_LENGTH2 = 500;
 var MAX_SYMBOL_LENGTH = 256;
 var MAX_FILE_SIZE_BYTES7 = 1024 * 1024;
@@ -77020,7 +77067,7 @@ function validateSymbolInput(symbol3) {
   return null;
 }
 function isBinaryFile2(filePath, buffer) {
-  const ext = path78.extname(filePath).toLowerCase();
+  const ext = path79.extname(filePath).toLowerCase();
   if (ext === ".json" || ext === ".md" || ext === ".txt") {
     return false;
   }
@@ -77044,15 +77091,15 @@ function parseImports(content, targetFile, targetSymbol) {
   const imports = [];
   let _resolvedTarget;
   try {
-    _resolvedTarget = path78.resolve(targetFile);
+    _resolvedTarget = path79.resolve(targetFile);
   } catch {
     _resolvedTarget = targetFile;
   }
-  const targetBasename = path78.basename(targetFile, path78.extname(targetFile));
+  const targetBasename = path79.basename(targetFile, path79.extname(targetFile));
   const targetWithExt = targetFile;
   const targetWithoutExt = targetFile.replace(/\.(ts|tsx|js|jsx|mjs|cjs)$/i, "");
-  const normalizedTargetWithExt = path78.normalize(targetWithExt).replace(/\\/g, "/");
-  const normalizedTargetWithoutExt = path78.normalize(targetWithoutExt).replace(/\\/g, "/");
+  const normalizedTargetWithExt = path79.normalize(targetWithExt).replace(/\\/g, "/");
+  const normalizedTargetWithoutExt = path79.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];
@@ -77075,9 +77122,9 @@ function parseImports(content, targetFile, targetSymbol) {
     }
     const _normalizedModule = modulePath.replace(/^\.\//, "").replace(/^\.\.\\/, "../");
     let isMatch = false;
-    const _targetDir = path78.dirname(targetFile);
-    const targetExt = path78.extname(targetFile);
-    const targetBasenameNoExt = path78.basename(targetFile, targetExt);
+    const _targetDir = path79.dirname(targetFile);
+    const targetExt = path79.extname(targetFile);
+    const targetBasenameNoExt = path79.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, "");
@@ -77145,10 +77192,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(path78.join(dir, entry));
+      stats.skippedDirs.push(path79.join(dir, entry));
       continue;
     }
-    const fullPath = path78.join(dir, entry);
+    const fullPath = path79.join(dir, entry);
     let stat4;
     try {
       stat4 = fs63.statSync(fullPath);
@@ -77162,7 +77209,7 @@ function findSourceFiles3(dir, files = [], stats = { skippedDirs: [], skippedFil
     if (stat4.isDirectory()) {
       findSourceFiles3(fullPath, files, stats);
     } else if (stat4.isFile()) {
-      const ext = path78.extname(fullPath).toLowerCase();
+      const ext = path79.extname(fullPath).toLowerCase();
       if (SUPPORTED_EXTENSIONS3.includes(ext)) {
         files.push(fullPath);
       }
@@ -77219,7 +77266,7 @@ var imports = createSwarmTool({
       return JSON.stringify(errorResult, null, 2);
     }
     try {
-      const targetFile = path78.resolve(file3);
+      const targetFile = path79.resolve(file3);
       if (!fs63.existsSync(targetFile)) {
         const errorResult = {
           error: `target file not found: ${file3}`,
@@ -77241,7 +77288,7 @@ var imports = createSwarmTool({
         };
         return JSON.stringify(errorResult, null, 2);
       }
-      const baseDir = path78.dirname(targetFile);
+      const baseDir = path79.dirname(targetFile);
       const scanStats = {
         skippedDirs: [],
         skippedFiles: 0,
@@ -77785,7 +77832,7 @@ init_qa_gate_profile();
 init_manager2();
 init_curator();
 import * as fs65 from "node:fs";
-import * as path80 from "node:path";
+import * as path81 from "node:path";
 init_knowledge_curator();
 init_knowledge_reader();
 init_knowledge_store();
@@ -77798,14 +77845,14 @@ init_plan_schema();
 init_ledger();
 init_manager();
 import * as fs64 from "node:fs";
-import * as path79 from "node:path";
+import * as path80 from "node:path";
 async function writeCheckpoint(directory) {
   try {
     const plan = await loadPlan(directory);
     if (!plan)
       return;
-    const jsonPath = path79.join(directory, "SWARM_PLAN.json");
-    const mdPath = path79.join(directory, "SWARM_PLAN.md");
+    const jsonPath = path80.join(directory, "SWARM_PLAN.json");
+    const mdPath = path80.join(directory, "SWARM_PLAN.md");
     fs64.writeFileSync(jsonPath, JSON.stringify(plan, null, 2), "utf8");
     const md = derivePlanMarkdown(plan);
     fs64.writeFileSync(mdPath, md, "utf8");
@@ -78038,7 +78085,7 @@ async function executePhaseComplete(args2, workingDirectory, directory) {
       safeWarn(`[phase_complete] Completion verify error (non-blocking):`, completionError);
     }
     try {
-      const driftEvidencePath = path80.join(dir, ".swarm", "evidence", String(phase), "drift-verifier.json");
+      const driftEvidencePath = path81.join(dir, ".swarm", "evidence", String(phase), "drift-verifier.json");
       let driftVerdictFound = false;
       let driftVerdictApproved = false;
       try {
@@ -78072,7 +78119,7 @@ async function executePhaseComplete(args2, workingDirectory, directory) {
         driftVerdictFound = false;
       }
       if (!driftVerdictFound) {
-        const specPath = path80.join(dir, ".swarm", "spec.md");
+        const specPath = path81.join(dir, ".swarm", "spec.md");
         const specExists = fs65.existsSync(specPath);
         if (!specExists) {
           let incompleteTaskCount = 0;
@@ -78130,7 +78177,7 @@ async function executePhaseComplete(args2, workingDirectory, directory) {
           const overrides = session2?.qaGateSessionOverrides ?? {};
           const effective = getEffectiveGates(profile, overrides);
           if (effective.hallucination_guard === true) {
-            const hgPath = path80.join(dir, ".swarm", "evidence", String(phase), "hallucination-guard.json");
+            const hgPath = path81.join(dir, ".swarm", "evidence", String(phase), "hallucination-guard.json");
             let hgVerdictFound = false;
             let hgVerdictApproved = false;
             try {
@@ -78202,7 +78249,7 @@ async function executePhaseComplete(args2, workingDirectory, directory) {
           const overrides = session2?.qaGateSessionOverrides ?? {};
           const effective = getEffectiveGates(profile, overrides);
           if (effective.mutation_test === true) {
-            const mgPath = path80.join(dir, ".swarm", "evidence", String(phase), "mutation-gate.json");
+            const mgPath = path81.join(dir, ".swarm", "evidence", String(phase), "mutation-gate.json");
             let mgVerdictFound = false;
             let mgVerdict;
             try {
@@ -78274,7 +78321,7 @@ async function executePhaseComplete(args2, workingDirectory, directory) {
   }
   if (retroFound && retroEntry?.lessons_learned && retroEntry.lessons_learned.length > 0) {
     try {
-      const projectName = path80.basename(dir);
+      const projectName = path81.basename(dir);
       const curationResult = await curateAndStoreSwarm(retroEntry.lessons_learned, projectName, { phase_number: phase }, dir, knowledgeConfig);
       if (curationResult) {
         const sessionState = swarmState.agentSessions.get(sessionID);
@@ -78643,7 +78690,7 @@ init_discovery();
 init_utils();
 init_create_tool();
 import * as fs66 from "node:fs";
-import * as path81 from "node:path";
+import * as path82 from "node:path";
 var MAX_OUTPUT_BYTES5 = 52428800;
 var AUDIT_TIMEOUT_MS = 120000;
 function isValidEcosystem(value) {
@@ -78671,16 +78718,16 @@ function validateArgs3(args2) {
 function detectEcosystems(directory) {
   const ecosystems = [];
   const cwd = directory;
-  if (fs66.existsSync(path81.join(cwd, "package.json"))) {
+  if (fs66.existsSync(path82.join(cwd, "package.json"))) {
     ecosystems.push("npm");
   }
-  if (fs66.existsSync(path81.join(cwd, "pyproject.toml")) || fs66.existsSync(path81.join(cwd, "requirements.txt"))) {
+  if (fs66.existsSync(path82.join(cwd, "pyproject.toml")) || fs66.existsSync(path82.join(cwd, "requirements.txt"))) {
     ecosystems.push("pip");
   }
-  if (fs66.existsSync(path81.join(cwd, "Cargo.toml"))) {
+  if (fs66.existsSync(path82.join(cwd, "Cargo.toml"))) {
     ecosystems.push("cargo");
   }
-  if (fs66.existsSync(path81.join(cwd, "go.mod"))) {
+  if (fs66.existsSync(path82.join(cwd, "go.mod"))) {
     ecosystems.push("go");
   }
   try {
@@ -78689,13 +78736,13 @@ function detectEcosystems(directory) {
       ecosystems.push("dotnet");
     }
   } catch {}
-  if (fs66.existsSync(path81.join(cwd, "Gemfile")) || fs66.existsSync(path81.join(cwd, "Gemfile.lock"))) {
+  if (fs66.existsSync(path82.join(cwd, "Gemfile")) || fs66.existsSync(path82.join(cwd, "Gemfile.lock"))) {
     ecosystems.push("ruby");
   }
-  if (fs66.existsSync(path81.join(cwd, "pubspec.yaml"))) {
+  if (fs66.existsSync(path82.join(cwd, "pubspec.yaml"))) {
     ecosystems.push("dart");
   }
-  if (fs66.existsSync(path81.join(cwd, "composer.lock"))) {
+  if (fs66.existsSync(path82.join(cwd, "composer.lock"))) {
     ecosystems.push("composer");
   }
   return ecosystems;
@@ -79855,7 +79902,7 @@ var pkg_audit = createSwarmTool({
 init_zod();
 init_manager2();
 import * as fs67 from "node:fs";
-import * as path82 from "node:path";
+import * as path83 from "node:path";
 init_utils();
 init_create_tool();
 var MAX_FILE_SIZE = 1024 * 1024;
@@ -79978,7 +80025,7 @@ function isScaffoldFile(filePath) {
   if (SCAFFOLD_PATH_PATTERNS.some((pattern) => pattern.test(normalizedPath))) {
     return true;
   }
-  const filename = path82.basename(filePath);
+  const filename = path83.basename(filePath);
   if (SCAFFOLD_FILENAME_PATTERNS.some((pattern) => pattern.test(filename))) {
     return true;
   }
@@ -79995,7 +80042,7 @@ function isAllowedByGlobs(filePath, allowGlobs) {
     if (regex.test(normalizedPath)) {
       return true;
     }
-    const filename = path82.basename(filePath);
+    const filename = path83.basename(filePath);
     const filenameRegex = new RegExp(`^${regexPattern}$`, "i");
     if (filenameRegex.test(filename)) {
       return true;
@@ -80004,7 +80051,7 @@ function isAllowedByGlobs(filePath, allowGlobs) {
   return false;
 }
 function isParserSupported(filePath) {
-  const ext = path82.extname(filePath).toLowerCase();
+  const ext = path83.extname(filePath).toLowerCase();
   return SUPPORTED_PARSER_EXTENSIONS.has(ext);
 }
 function isPlanFile(filePath) {
@@ -80251,9 +80298,9 @@ async function placeholderScan(input, directory) {
   let filesScanned = 0;
   const filesWithFindings = new Set;
   for (const filePath of changed_files) {
-    const fullPath = path82.isAbsolute(filePath) ? filePath : path82.resolve(directory, filePath);
-    const resolvedDirectory = path82.resolve(directory);
-    if (!fullPath.startsWith(resolvedDirectory + path82.sep) && fullPath !== resolvedDirectory) {
+    const fullPath = path83.isAbsolute(filePath) ? filePath : path83.resolve(directory, filePath);
+    const resolvedDirectory = path83.resolve(directory);
+    if (!fullPath.startsWith(resolvedDirectory + path83.sep) && fullPath !== resolvedDirectory) {
       continue;
     }
     if (!fs67.existsSync(fullPath)) {
@@ -80262,7 +80309,7 @@ async function placeholderScan(input, directory) {
     if (isAllowedByGlobs(filePath, allow_globs)) {
       continue;
     }
-    const relativeFilePath = path82.relative(directory, fullPath).replace(/\\/g, "/");
+    const relativeFilePath = path83.relative(directory, fullPath).replace(/\\/g, "/");
     if (FILE_ALLOWLIST.some((allowed) => relativeFilePath.endsWith(allowed))) {
       continue;
     }
@@ -80334,7 +80381,7 @@ var placeholder_scan = createSwarmTool({
 });
 // src/tools/pre-check-batch.ts
 import * as fs70 from "node:fs";
-import * as path85 from "node:path";
+import * as path86 from "node:path";
 init_zod();
 init_manager2();
 init_utils();
@@ -80471,7 +80518,7 @@ init_zod();
 init_manager2();
 init_detector();
 import * as fs69 from "node:fs";
-import * as path84 from "node:path";
+import * as path85 from "node:path";
 import { extname as extname18 } from "node:path";
 
 // src/sast/rules/c.ts
@@ -81365,24 +81412,24 @@ init_create_tool();
 init_utils2();
 import * as crypto8 from "node:crypto";
 import * as fs68 from "node:fs";
-import * as path83 from "node:path";
+import * as path84 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 = path83.isAbsolute(file3) ? file3 : path83.resolve(directory, file3);
-  const rel = path83.relative(path83.resolve(directory), resolved);
+  const resolved = path84.isAbsolute(file3) ? file3 : path84.resolve(directory, file3);
+  const rel = path84.relative(path84.resolve(directory), resolved);
   return rel.replace(/\\/g, "/");
 }
 function baselineRelPath(phase) {
-  return path83.join("evidence", String(phase), "sast-baseline.json");
+  return path84.join("evidence", String(phase), "sast-baseline.json");
 }
 function tempRelPath(phase) {
-  return path83.join("evidence", String(phase), `sast-baseline.json.tmp.${Date.now()}.${process.pid}`);
+  return path84.join("evidence", String(phase), `sast-baseline.json.tmp.${Date.now()}.${process.pid}`);
 }
 function lockRelPath(phase) {
-  return path83.join("evidence", String(phase), "sast-baseline.json.lock");
+  return path84.join("evidence", String(phase), "sast-baseline.json.lock");
 }
 function getLine(lines, idx) {
   if (idx < 0 || idx >= lines.length)
@@ -81503,8 +81550,8 @@ async function captureOrMergeBaseline(directory, phase, findings, engine, scanne
       message: e instanceof Error ? e.message : "Path validation failed"
     };
   }
-  fs68.mkdirSync(path83.dirname(baselinePath), { recursive: true });
-  fs68.mkdirSync(path83.dirname(tempPath), { recursive: true });
+  fs68.mkdirSync(path84.dirname(baselinePath), { recursive: true });
+  fs68.mkdirSync(path84.dirname(tempPath), { recursive: true });
   const releaseLock = await acquireLock(lockPath);
   try {
     let existing = null;
@@ -81771,9 +81818,9 @@ async function sastScan(input, directory, config3) {
       _filesSkipped++;
       continue;
     }
-    const resolvedPath = path84.isAbsolute(filePath) ? filePath : path84.resolve(directory, filePath);
-    const resolvedDirectory = path84.resolve(directory);
-    if (!resolvedPath.startsWith(resolvedDirectory + path84.sep) && resolvedPath !== resolvedDirectory) {
+    const resolvedPath = path85.isAbsolute(filePath) ? filePath : path85.resolve(directory, filePath);
+    const resolvedDirectory = path85.resolve(directory);
+    if (!resolvedPath.startsWith(resolvedDirectory + path85.sep) && resolvedPath !== resolvedDirectory) {
       _filesSkipped++;
       continue;
     }
@@ -82084,18 +82131,18 @@ function validatePath(inputPath, baseDir, workspaceDir) {
   let resolved;
   const isWinAbs = isWindowsAbsolutePath(inputPath);
   if (isWinAbs) {
-    resolved = path85.win32.resolve(inputPath);
-  } else if (path85.isAbsolute(inputPath)) {
-    resolved = path85.resolve(inputPath);
+    resolved = path86.win32.resolve(inputPath);
+  } else if (path86.isAbsolute(inputPath)) {
+    resolved = path86.resolve(inputPath);
   } else {
-    resolved = path85.resolve(baseDir, inputPath);
+    resolved = path86.resolve(baseDir, inputPath);
   }
-  const workspaceResolved = path85.resolve(workspaceDir);
+  const workspaceResolved = path86.resolve(workspaceDir);
   let relative20;
   if (isWinAbs) {
-    relative20 = path85.win32.relative(workspaceResolved, resolved);
+    relative20 = path86.win32.relative(workspaceResolved, resolved);
   } else {
-    relative20 = path85.relative(workspaceResolved, resolved);
+    relative20 = path86.relative(workspaceResolved, resolved);
   }
   if (relative20.startsWith("..")) {
     return "path traversal detected";
@@ -82160,7 +82207,7 @@ async function runLintOnFiles(linter, files, workspaceDir) {
     if (typeof file3 !== "string") {
       continue;
     }
-    const resolvedPath = path85.resolve(file3);
+    const resolvedPath = path86.resolve(file3);
     const validationError = validatePath(resolvedPath, workspaceDir, workspaceDir);
     if (validationError) {
       continue;
@@ -82317,7 +82364,7 @@ async function runSecretscanWithFiles(files, directory) {
         skippedFiles++;
         continue;
       }
-      const resolvedPath = path85.resolve(file3);
+      const resolvedPath = path86.resolve(file3);
       const validationError = validatePath(resolvedPath, directory, directory);
       if (validationError) {
         skippedFiles++;
@@ -82335,7 +82382,7 @@ async function runSecretscanWithFiles(files, directory) {
       };
     }
     for (const file3 of validatedFiles) {
-      const ext = path85.extname(file3).toLowerCase();
+      const ext = path86.extname(file3).toLowerCase();
       if (DEFAULT_EXCLUDE_EXTENSIONS2.has(ext)) {
         skippedFiles++;
         continue;
@@ -82554,7 +82601,7 @@ function classifySastFindings(findings, changedLineRanges, directory) {
   const preexistingFindings = [];
   for (const finding of findings) {
     const filePath = finding.location.file;
-    const normalised = path85.relative(directory, filePath).replace(/\\/g, "/");
+    const normalised = path86.relative(directory, filePath).replace(/\\/g, "/");
     const changedLines = changedLineRanges.get(normalised);
     if (changedLines?.has(finding.location.line)) {
       newFindings.push(finding);
@@ -82605,7 +82652,7 @@ async function runPreCheckBatch(input, workspaceDir, contextDir) {
       warn(`pre_check_batch: Invalid file path: ${file3}`);
       continue;
     }
-    changedFiles.push(path85.resolve(directory, file3));
+    changedFiles.push(path86.resolve(directory, file3));
   }
   if (changedFiles.length === 0) {
     warn("pre_check_batch: No valid files after validation, skipping all tools (fail-closed)");
@@ -82806,7 +82853,7 @@ var pre_check_batch = createSwarmTool({
       };
       return JSON.stringify(errorResult, null, 2);
     }
-    const resolvedDirectory = path85.resolve(typedArgs.directory);
+    const resolvedDirectory = path86.resolve(typedArgs.directory);
     const workspaceAnchor = resolvedDirectory;
     const dirError = validateDirectory2(resolvedDirectory, workspaceAnchor);
     if (dirError) {
@@ -82847,7 +82894,7 @@ var pre_check_batch = createSwarmTool({
 });
 // src/tools/repo-map.ts
 init_zod();
-import * as path86 from "node:path";
+import * as path87 from "node:path";
 init_path_security();
 init_create_tool();
 var VALID_ACTIONS = [
@@ -82872,7 +82919,7 @@ function validateFile(p) {
     return "file contains control characters";
   if (containsPathTraversal(p))
     return "file contains path traversal";
-  if (path86.isAbsolute(p) || /^[a-zA-Z]:[\\/]/.test(p)) {
+  if (path87.isAbsolute(p) || /^[a-zA-Z]:[\\/]/.test(p)) {
     return "file must be a workspace-relative path, not absolute";
   }
   return null;
@@ -82895,8 +82942,8 @@ function ok(action, payload) {
 }
 function toRelativeGraphPath(input, workspaceRoot) {
   const normalized = input.replace(/\\/g, "/");
-  if (path86.isAbsolute(normalized)) {
-    const rel = path86.relative(workspaceRoot, normalized).replace(/\\/g, "/");
+  if (path87.isAbsolute(normalized)) {
+    const rel = path87.relative(workspaceRoot, normalized).replace(/\\/g, "/");
     return normalizeGraphPath2(rel);
   }
   return normalizeGraphPath2(normalized);
@@ -83041,7 +83088,7 @@ var repo_map = createSwarmTool({
 init_zod();
 init_create_tool();
 import * as fs71 from "node:fs";
-import * as path87 from "node:path";
+import * as path88 from "node:path";
 var SPEC_FILE = ".swarm/spec.md";
 var EVIDENCE_DIR4 = ".swarm/evidence";
 var OBLIGATION_KEYWORDS = ["MUST", "SHOULD", "SHALL"];
@@ -83110,7 +83157,7 @@ function readTouchedFiles(evidenceDir, phase, cwd) {
     return [];
   }
   for (const entry of entries) {
-    const entryPath = path87.join(evidenceDir, entry);
+    const entryPath = path88.join(evidenceDir, entry);
     try {
       const stat4 = fs71.statSync(entryPath);
       if (!stat4.isDirectory()) {
@@ -83126,11 +83173,11 @@ function readTouchedFiles(evidenceDir, phase, cwd) {
     if (entryPhase !== String(phase)) {
       continue;
     }
-    const evidenceFilePath = path87.join(entryPath, "evidence.json");
+    const evidenceFilePath = path88.join(entryPath, "evidence.json");
     try {
-      const resolvedPath = path87.resolve(evidenceFilePath);
-      const evidenceDirResolved = path87.resolve(evidenceDir);
-      if (!resolvedPath.startsWith(evidenceDirResolved + path87.sep)) {
+      const resolvedPath = path88.resolve(evidenceFilePath);
+      const evidenceDirResolved = path88.resolve(evidenceDir);
+      if (!resolvedPath.startsWith(evidenceDirResolved + path88.sep)) {
         continue;
       }
       const stat4 = fs71.lstatSync(evidenceFilePath);
@@ -83164,7 +83211,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(path87.resolve(cwd, file3));
+                  touchedFiles.add(path88.resolve(cwd, file3));
                 }
               }
             }
@@ -83177,8 +83224,8 @@ function readTouchedFiles(evidenceDir, phase, cwd) {
 }
 function searchFileForKeywords(filePath, keywords, cwd) {
   try {
-    const resolvedPath = path87.resolve(filePath);
-    const cwdResolved = path87.resolve(cwd);
+    const resolvedPath = path88.resolve(filePath);
+    const cwdResolved = path88.resolve(cwd);
     if (!resolvedPath.startsWith(cwdResolved)) {
       return false;
     }
@@ -83312,7 +83359,7 @@ var req_coverage = createSwarmTool({
       }, null, 2);
     }
     const cwd = inputDirectory || directory;
-    const specPath = path87.join(cwd, SPEC_FILE);
+    const specPath = path88.join(cwd, SPEC_FILE);
     let specContent;
     try {
       specContent = fs71.readFileSync(specPath, "utf-8");
@@ -83339,7 +83386,7 @@ var req_coverage = createSwarmTool({
         message: "No FR requirements found in spec.md"
       }, null, 2);
     }
-    const evidenceDir = path87.join(cwd, EVIDENCE_DIR4);
+    const evidenceDir = path88.join(cwd, EVIDENCE_DIR4);
     const touchedFiles = readTouchedFiles(evidenceDir, phase, cwd);
     const analyzedRequirements = [];
     let coveredCount = 0;
@@ -83365,7 +83412,7 @@ var req_coverage = createSwarmTool({
       requirements: analyzedRequirements
     };
     const reportFilename = `req-coverage-phase-${phase}.json`;
-    const reportPath = path87.join(evidenceDir, reportFilename);
+    const reportPath = path88.join(evidenceDir, reportFilename);
     try {
       if (!fs71.existsSync(evidenceDir)) {
         fs71.mkdirSync(evidenceDir, { recursive: true });
@@ -83453,7 +83500,7 @@ init_qa_gate_profile();
 init_file_locks();
 import * as crypto9 from "node:crypto";
 import * as fs72 from "node:fs";
-import * as path88 from "node:path";
+import * as path89 from "node:path";
 init_ledger();
 init_manager();
 init_state();
@@ -83531,8 +83578,8 @@ async function executeSavePlan(args2, fallbackDir) {
     };
   }
   if (args2.working_directory && fallbackDir) {
-    const resolvedTarget = path88.resolve(args2.working_directory);
-    const resolvedRoot = path88.resolve(fallbackDir);
+    const resolvedTarget = path89.resolve(args2.working_directory);
+    const resolvedRoot = path89.resolve(fallbackDir);
     let fallbackExists = false;
     try {
       fs72.accessSync(resolvedRoot, fs72.constants.F_OK);
@@ -83541,7 +83588,7 @@ async function executeSavePlan(args2, fallbackDir) {
       fallbackExists = false;
     }
     if (fallbackExists) {
-      const isSubdirectory = resolvedTarget.startsWith(resolvedRoot + path88.sep);
+      const isSubdirectory = resolvedTarget.startsWith(resolvedRoot + path89.sep);
       if (isSubdirectory) {
         return {
           success: false,
@@ -83557,7 +83604,7 @@ async function executeSavePlan(args2, fallbackDir) {
   let specMtime;
   let specHash;
   if (process.env.SWARM_SKIP_SPEC_GATE !== "1") {
-    const specPath = path88.join(targetWorkspace, ".swarm", "spec.md");
+    const specPath = path89.join(targetWorkspace, ".swarm", "spec.md");
     try {
       const stat4 = await fs72.promises.stat(specPath);
       specMtime = stat4.mtime.toISOString();
@@ -83573,7 +83620,7 @@ async function executeSavePlan(args2, fallbackDir) {
     }
   }
   if (process.env.SWARM_SKIP_GATE_SELECTION !== "1") {
-    const contextPath = path88.join(targetWorkspace, ".swarm", "context.md");
+    const contextPath = path89.join(targetWorkspace, ".swarm", "context.md");
     let contextContent = "";
     try {
       contextContent = await fs72.promises.readFile(contextPath, "utf8");
@@ -83723,7 +83770,7 @@ async function executeSavePlan(args2, fallbackDir) {
       }
       await writeCheckpoint(dir).catch(() => {});
       try {
-        const markerPath = path88.join(dir, ".swarm", ".plan-write-marker");
+        const markerPath = path89.join(dir, ".swarm", ".plan-write-marker");
         const marker = JSON.stringify({
           source: "save_plan",
           timestamp: new Date().toISOString(),
@@ -83746,7 +83793,7 @@ async function executeSavePlan(args2, fallbackDir) {
       return {
         success: true,
         message: "Plan saved successfully",
-        plan_path: path88.join(dir, ".swarm", "plan.json"),
+        plan_path: path89.join(dir, ".swarm", "plan.json"),
         phases_count: plan.phases.length,
         tasks_count: tasksCount,
         ...resolvedProfile !== undefined ? { execution_profile: resolvedProfile } : {},
@@ -83799,7 +83846,7 @@ var save_plan = createSwarmTool({
 init_zod();
 init_manager2();
 import * as fs73 from "node:fs";
-import * as path89 from "node:path";
+import * as path90 from "node:path";
 
 // src/sbom/detectors/index.ts
 init_utils();
@@ -84649,7 +84696,7 @@ function findManifestFiles(rootDir) {
     try {
       const entries = fs73.readdirSync(dir, { withFileTypes: true });
       for (const entry of entries) {
-        const fullPath = path89.join(dir, entry.name);
+        const fullPath = path90.join(dir, entry.name);
         if (entry.name.startsWith(".") || entry.name === "node_modules" || entry.name === "dist" || entry.name === "build" || entry.name === "target") {
           continue;
         }
@@ -84658,7 +84705,7 @@ function findManifestFiles(rootDir) {
         } else if (entry.isFile()) {
           for (const pattern of patterns) {
             if (simpleGlobToRegex(pattern).test(entry.name)) {
-              manifestFiles.push(path89.relative(rootDir, fullPath));
+              manifestFiles.push(path90.relative(rootDir, fullPath));
               break;
             }
           }
@@ -84676,11 +84723,11 @@ function findManifestFilesInDirs(directories, workingDir) {
     try {
       const entries = fs73.readdirSync(dir, { withFileTypes: true });
       for (const entry of entries) {
-        const fullPath = path89.join(dir, entry.name);
+        const fullPath = path90.join(dir, entry.name);
         if (entry.isFile()) {
           for (const pattern of patterns) {
             if (simpleGlobToRegex(pattern).test(entry.name)) {
-              found.push(path89.relative(workingDir, fullPath));
+              found.push(path90.relative(workingDir, fullPath));
               break;
             }
           }
@@ -84693,11 +84740,11 @@ function findManifestFilesInDirs(directories, workingDir) {
 function getDirectoriesFromChangedFiles(changedFiles, workingDir) {
   const dirs = new Set;
   for (const file3 of changedFiles) {
-    let currentDir = path89.dirname(file3);
+    let currentDir = path90.dirname(file3);
     while (true) {
-      if (currentDir && currentDir !== "." && currentDir !== path89.sep) {
-        dirs.add(path89.join(workingDir, currentDir));
-        const parent = path89.dirname(currentDir);
+      if (currentDir && currentDir !== "." && currentDir !== path90.sep) {
+        dirs.add(path90.join(workingDir, currentDir));
+        const parent = path90.dirname(currentDir);
         if (parent === currentDir)
           break;
         currentDir = parent;
@@ -84781,7 +84828,7 @@ var sbom_generate = createSwarmTool({
     const changedFiles = obj.changed_files;
     const relativeOutputDir = obj.output_dir || DEFAULT_OUTPUT_DIR;
     const workingDir = directory;
-    const outputDir = path89.isAbsolute(relativeOutputDir) ? relativeOutputDir : path89.join(workingDir, relativeOutputDir);
+    const outputDir = path90.isAbsolute(relativeOutputDir) ? relativeOutputDir : path90.join(workingDir, relativeOutputDir);
     let manifestFiles = [];
     if (scope === "all") {
       manifestFiles = findManifestFiles(workingDir);
@@ -84804,7 +84851,7 @@ var sbom_generate = createSwarmTool({
     const processedFiles = [];
     for (const manifestFile of manifestFiles) {
       try {
-        const fullPath = path89.isAbsolute(manifestFile) ? manifestFile : path89.join(workingDir, manifestFile);
+        const fullPath = path90.isAbsolute(manifestFile) ? manifestFile : path90.join(workingDir, manifestFile);
         if (!fs73.existsSync(fullPath)) {
           continue;
         }
@@ -84821,7 +84868,7 @@ var sbom_generate = createSwarmTool({
     const bom = generateCycloneDX(allComponents);
     const bomJson = serializeCycloneDX(bom);
     const filename = generateSbomFilename();
-    const outputPath = path89.join(outputDir, filename);
+    const outputPath = path90.join(outputDir, filename);
     fs73.writeFileSync(outputPath, bomJson, "utf-8");
     const verdict = processedFiles.length > 0 ? "pass" : "pass";
     try {
@@ -84865,7 +84912,7 @@ var sbom_generate = createSwarmTool({
 init_zod();
 init_create_tool();
 import * as fs74 from "node:fs";
-import * as path90 from "node:path";
+import * as path91 from "node:path";
 var SPEC_CANDIDATES = [
   "openapi.json",
   "openapi.yaml",
@@ -84897,12 +84944,12 @@ function normalizePath3(p) {
 }
 function discoverSpecFile(cwd, specFileArg) {
   if (specFileArg) {
-    const resolvedPath = path90.resolve(cwd, specFileArg);
-    const normalizedCwd = cwd.endsWith(path90.sep) ? cwd : cwd + path90.sep;
+    const resolvedPath = path91.resolve(cwd, specFileArg);
+    const normalizedCwd = cwd.endsWith(path91.sep) ? cwd : cwd + path91.sep;
     if (!resolvedPath.startsWith(normalizedCwd) && resolvedPath !== cwd) {
       throw new Error("Invalid spec_file: path traversal detected");
     }
-    const ext = path90.extname(resolvedPath).toLowerCase();
+    const ext = path91.extname(resolvedPath).toLowerCase();
     if (!ALLOWED_EXTENSIONS.includes(ext)) {
       throw new Error(`Invalid spec_file: must end in .json, .yaml, or .yml, got ${ext}`);
     }
@@ -84916,7 +84963,7 @@ function discoverSpecFile(cwd, specFileArg) {
     return resolvedPath;
   }
   for (const candidate of SPEC_CANDIDATES) {
-    const candidatePath = path90.resolve(cwd, candidate);
+    const candidatePath = path91.resolve(cwd, candidate);
     if (fs74.existsSync(candidatePath)) {
       const stats = fs74.statSync(candidatePath);
       if (stats.size <= MAX_SPEC_SIZE) {
@@ -84928,7 +84975,7 @@ function discoverSpecFile(cwd, specFileArg) {
 }
 function parseSpec(specFile) {
   const content = fs74.readFileSync(specFile, "utf-8");
-  const ext = path90.extname(specFile).toLowerCase();
+  const ext = path91.extname(specFile).toLowerCase();
   if (ext === ".json") {
     return parseJsonSpec(content);
   }
@@ -85004,7 +85051,7 @@ function extractRoutes(cwd) {
       return;
     }
     for (const entry of entries) {
-      const fullPath = path90.join(dir, entry.name);
+      const fullPath = path91.join(dir, entry.name);
       if (entry.isSymbolicLink()) {
         continue;
       }
@@ -85014,7 +85061,7 @@ function extractRoutes(cwd) {
         }
         walkDir(fullPath);
       } else if (entry.isFile()) {
-        const ext = path90.extname(entry.name).toLowerCase();
+        const ext = path91.extname(entry.name).toLowerCase();
         const baseName = entry.name.toLowerCase();
         if (![".ts", ".js", ".mjs"].includes(ext)) {
           continue;
@@ -85181,7 +85228,7 @@ init_zod();
 init_path_security();
 init_create_tool();
 import * as fs75 from "node:fs";
-import * as path91 from "node:path";
+import * as path92 from "node:path";
 var DEFAULT_MAX_RESULTS = 100;
 var DEFAULT_MAX_LINES = 200;
 var REGEX_TIMEOUT_MS = 5000;
@@ -85217,11 +85264,11 @@ function containsWindowsAttacks3(str) {
 }
 function isPathInWorkspace3(filePath, workspace) {
   try {
-    const resolvedPath = path91.resolve(workspace, filePath);
+    const resolvedPath = path92.resolve(workspace, filePath);
     const realWorkspace = fs75.realpathSync(workspace);
     const realResolvedPath = fs75.realpathSync(resolvedPath);
-    const relativePath = path91.relative(realWorkspace, realResolvedPath);
-    if (relativePath.startsWith("..") || path91.isAbsolute(relativePath)) {
+    const relativePath = path92.relative(realWorkspace, realResolvedPath);
+    if (relativePath.startsWith("..") || path92.isAbsolute(relativePath)) {
       return false;
     }
     return true;
@@ -85234,11 +85281,11 @@ function validatePathForRead2(filePath, workspace) {
 }
 function findRgInEnvPath() {
   const searchPath = process.env.PATH ?? "";
-  for (const dir of searchPath.split(path91.delimiter)) {
+  for (const dir of searchPath.split(path92.delimiter)) {
     if (!dir)
       continue;
     const isWindows = process.platform === "win32";
-    const candidate = path91.join(dir, isWindows ? "rg.exe" : "rg");
+    const candidate = path92.join(dir, isWindows ? "rg.exe" : "rg");
     if (fs75.existsSync(candidate))
       return candidate;
   }
@@ -85368,8 +85415,8 @@ function collectFiles(dir, workspace, includeGlobs, excludeGlobs) {
   try {
     const entries = fs75.readdirSync(dir, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = path91.join(dir, entry.name);
-      const relativePath = path91.relative(workspace, fullPath);
+      const fullPath = path92.join(dir, entry.name);
+      const relativePath = path92.relative(workspace, fullPath);
       if (!validatePathForRead2(fullPath, workspace)) {
         continue;
       }
@@ -85410,7 +85457,7 @@ async function fallbackSearch(opts) {
   const matches = [];
   let total = 0;
   for (const file3 of files) {
-    const fullPath = path91.join(opts.workspace, file3);
+    const fullPath = path92.join(opts.workspace, file3);
     if (!validatePathForRead2(fullPath, opts.workspace)) {
       continue;
     }
@@ -85665,7 +85712,7 @@ init_zod();
 init_path_security();
 init_create_tool();
 import * as fs76 from "node:fs";
-import * as path92 from "node:path";
+import * as path93 from "node:path";
 var WINDOWS_RESERVED_NAMES4 = /^(con|prn|aux|nul|com[1-9]|lpt[1-9])(\.|:|$)/i;
 function containsWindowsAttacks4(str) {
   if (/:[^\\/]/.test(str))
@@ -85679,14 +85726,14 @@ function containsWindowsAttacks4(str) {
 }
 function isPathInWorkspace4(filePath, workspace) {
   try {
-    const resolvedPath = path92.resolve(workspace, filePath);
+    const resolvedPath = path93.resolve(workspace, filePath);
     if (!fs76.existsSync(resolvedPath)) {
       return true;
     }
     const realWorkspace = fs76.realpathSync(workspace);
     const realResolvedPath = fs76.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;
@@ -85894,7 +85941,7 @@ var suggestPatch = createSwarmTool({
         });
         continue;
       }
-      const fullPath = path92.resolve(directory, change.file);
+      const fullPath = path93.resolve(directory, change.file);
       if (!fs76.existsSync(fullPath)) {
         errors5.push({
           success: false,
@@ -86157,7 +86204,7 @@ var generate_mutants = createSwarmTool({
 init_spec_schema();
 init_create_tool();
 import * as fs77 from "node:fs";
-import * as path93 from "node:path";
+import * as path94 from "node:path";
 var SPEC_FILE_NAME = "spec.md";
 var SWARM_DIR2 = ".swarm";
 var OBLIGATION_KEYWORDS2 = ["MUST", "SHALL", "SHOULD", "MAY"];
@@ -86210,7 +86257,7 @@ var lint_spec = createSwarmTool({
   async execute(_args, directory) {
     const errors5 = [];
     const warnings = [];
-    const specPath = path93.join(directory, SWARM_DIR2, SPEC_FILE_NAME);
+    const specPath = path94.join(directory, SWARM_DIR2, SPEC_FILE_NAME);
     if (!fs77.existsSync(specPath)) {
       const result2 = {
         valid: false,
@@ -86281,12 +86328,12 @@ var lint_spec = createSwarmTool({
 // src/tools/mutation-test.ts
 init_zod();
 import * as fs78 from "node:fs";
-import * as path95 from "node:path";
+import * as path96 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 path94 from "node:path";
+import * as path95 from "node:path";
 
 // src/mutation/equivalence.ts
 function isStaticallyEquivalent(originalCode, mutatedCode) {
@@ -86421,7 +86468,7 @@ async function executeMutation(patch, testCommand, _testFiles, workingDir) {
   let patchFile;
   try {
     const safeId2 = patch.id.replace(/[^a-zA-Z0-9_-]/g, "_");
-    patchFile = path94.join(workingDir, `.mutation_patch_${safeId2}.diff`);
+    patchFile = path95.join(workingDir, `.mutation_patch_${safeId2}.diff`);
     try {
       writeFileSync19(patchFile, patch.patch);
     } catch (writeErr) {
@@ -86815,7 +86862,7 @@ var mutation_test = createSwarmTool({
       ];
       for (const filePath of uniquePaths) {
         try {
-          const resolvedPath = path95.resolve(cwd, filePath);
+          const resolvedPath = path96.resolve(cwd, filePath);
           sourceFiles.set(filePath, fs78.readFileSync(resolvedPath, "utf-8"));
         } catch {}
       }
@@ -86835,7 +86882,7 @@ init_zod();
 init_manager2();
 init_detector();
 import * as fs79 from "node:fs";
-import * as path96 from "node:path";
+import * as path97 from "node:path";
 init_create_tool();
 var MAX_FILE_SIZE2 = 2 * 1024 * 1024;
 var BINARY_CHECK_BYTES = 8192;
@@ -86901,7 +86948,7 @@ async function syntaxCheck(input, directory, config3) {
   if (languages?.length) {
     const lowerLangs = languages.map((l) => l.toLowerCase());
     filesToCheck = filesToCheck.filter((file3) => {
-      const ext = path96.extname(file3.path).toLowerCase();
+      const ext = path97.extname(file3.path).toLowerCase();
       const langDef = getLanguageForExtension(ext);
       const fileProfile = getProfileForFile(file3.path);
       const langId = fileProfile?.id || langDef?.id;
@@ -86914,7 +86961,7 @@ async function syntaxCheck(input, directory, config3) {
   let skippedCount = 0;
   for (const fileInfo of filesToCheck) {
     const { path: filePath } = fileInfo;
-    const fullPath = path96.isAbsolute(filePath) ? filePath : path96.join(directory, filePath);
+    const fullPath = path97.isAbsolute(filePath) ? filePath : path97.join(directory, filePath);
     const result = {
       path: filePath,
       language: "",
@@ -86963,7 +87010,7 @@ async function syntaxCheck(input, directory, config3) {
         results.push(result);
         continue;
       }
-      const ext = path96.extname(filePath).toLowerCase();
+      const ext = path97.extname(filePath).toLowerCase();
       const langDef = getLanguageForExtension(ext);
       result.language = profile?.id || langDef?.id || "unknown";
       const errors5 = extractSyntaxErrors(parser, content);
@@ -87056,7 +87103,7 @@ init_utils();
 init_create_tool();
 init_path_security();
 import * as fs80 from "node:fs";
-import * as path97 from "node:path";
+import * as path98 from "node:path";
 var MAX_TEXT_LENGTH = 200;
 var MAX_FILE_SIZE_BYTES11 = 1024 * 1024;
 var SUPPORTED_EXTENSIONS4 = new Set([
@@ -87122,9 +87169,9 @@ function validatePathsInput(paths, cwd) {
     return { error: "paths contains path traversal", resolvedPath: null };
   }
   try {
-    const resolvedPath = path97.resolve(paths);
-    const normalizedCwd = path97.resolve(cwd);
-    const normalizedResolved = path97.resolve(resolvedPath);
+    const resolvedPath = path98.resolve(paths);
+    const normalizedCwd = path98.resolve(cwd);
+    const normalizedResolved = path98.resolve(resolvedPath);
     if (!normalizedResolved.startsWith(normalizedCwd)) {
       return {
         error: "paths must be within the current working directory",
@@ -87140,7 +87187,7 @@ function validatePathsInput(paths, cwd) {
   }
 }
 function isSupportedExtension(filePath) {
-  const ext = path97.extname(filePath).toLowerCase();
+  const ext = path98.extname(filePath).toLowerCase();
   return SUPPORTED_EXTENSIONS4.has(ext);
 }
 function findSourceFiles4(dir, files = []) {
@@ -87155,7 +87202,7 @@ function findSourceFiles4(dir, files = []) {
     if (SKIP_DIRECTORIES5.has(entry)) {
       continue;
     }
-    const fullPath = path97.join(dir, entry);
+    const fullPath = path98.join(dir, entry);
     let stat4;
     try {
       stat4 = fs80.statSync(fullPath);
@@ -87267,7 +87314,7 @@ var todo_extract = createSwarmTool({
         filesToScan.push(scanPath);
       } else {
         const errorResult = {
-          error: `unsupported file extension: ${path97.extname(scanPath)}`,
+          error: `unsupported file extension: ${path98.extname(scanPath)}`,
           total: 0,
           byPriority: { high: 0, medium: 0, low: 0 },
           entries: []
@@ -87316,14 +87363,14 @@ init_schema();
 init_qa_gate_profile();
 init_gate_evidence();
 import * as fs82 from "node:fs";
-import * as path99 from "node:path";
+import * as path100 from "node:path";
 
 // src/hooks/diff-scope.ts
 import * as fs81 from "node:fs";
-import * as path98 from "node:path";
+import * as path99 from "node:path";
 function getDeclaredScope(taskId, directory) {
   try {
-    const planPath = path98.join(directory, ".swarm", "plan.json");
+    const planPath = path99.join(directory, ".swarm", "plan.json");
     if (!fs81.existsSync(planPath))
       return null;
     const raw = fs81.readFileSync(planPath, "utf-8");
@@ -87442,7 +87489,7 @@ var TIER_3_PATTERNS = [
 ];
 function matchesTier3Pattern(files) {
   for (const file3 of files) {
-    const fileName = path99.basename(file3);
+    const fileName = path100.basename(file3);
     for (const pattern of TIER_3_PATTERNS) {
       if (pattern.test(fileName)) {
         return true;
@@ -87456,7 +87503,7 @@ function checkReviewerGate(taskId, workingDirectory, stageBParallelEnabled = fal
     if (hasActiveTurboMode()) {
       const resolvedDir2 = workingDirectory;
       try {
-        const planPath = path99.join(resolvedDir2, ".swarm", "plan.json");
+        const planPath = path100.join(resolvedDir2, ".swarm", "plan.json");
         const planRaw = fs82.readFileSync(planPath, "utf-8");
         const plan = JSON.parse(planRaw);
         for (const planPhase of plan.phases ?? []) {
@@ -87526,7 +87573,7 @@ function checkReviewerGate(taskId, workingDirectory, stageBParallelEnabled = fal
     }
     try {
       const resolvedDir2 = workingDirectory;
-      const planPath = path99.join(resolvedDir2, ".swarm", "plan.json");
+      const planPath = path100.join(resolvedDir2, ".swarm", "plan.json");
       const planRaw = fs82.readFileSync(planPath, "utf-8");
       const plan = JSON.parse(planRaw);
       for (const planPhase of plan.phases ?? []) {
@@ -87684,7 +87731,7 @@ function checkCouncilGate(workingDirectory, taskId) {
     return { blocked: false, reason: "" };
   }
   try {
-    const planPath = path99.join(workingDirectory, ".swarm", "plan.json");
+    const planPath = path100.join(workingDirectory, ".swarm", "plan.json");
     const planRaw = fs82.readFileSync(planPath, "utf-8");
     const planObj = JSON.parse(planRaw);
     if (planObj.swarm && planObj.title) {
@@ -87775,8 +87822,8 @@ async function executeUpdateTaskStatus(args2, fallbackDir) {
         };
       }
     }
-    normalizedDir = path99.normalize(args2.working_directory);
-    const pathParts = normalizedDir.split(path99.sep);
+    normalizedDir = path100.normalize(args2.working_directory);
+    const pathParts = normalizedDir.split(path100.sep);
     if (pathParts.includes("..")) {
       return {
         success: false,
@@ -87786,10 +87833,10 @@ async function executeUpdateTaskStatus(args2, fallbackDir) {
         ]
       };
     }
-    const resolvedDir = path99.resolve(normalizedDir);
+    const resolvedDir = path100.resolve(normalizedDir);
     try {
       const realPath = fs82.realpathSync(resolvedDir);
-      const planPath = path99.join(realPath, ".swarm", "plan.json");
+      const planPath = path100.join(realPath, ".swarm", "plan.json");
       if (!fs82.existsSync(planPath)) {
         return {
           success: false,
@@ -87821,8 +87868,8 @@ async function executeUpdateTaskStatus(args2, fallbackDir) {
   }
   if (args2.status === "in_progress") {
     try {
-      const evidencePath = path99.join(directory, ".swarm", "evidence", `${args2.task_id}.json`);
-      fs82.mkdirSync(path99.dirname(evidencePath), { recursive: true });
+      const evidencePath = path100.join(directory, ".swarm", "evidence", `${args2.task_id}.json`);
+      fs82.mkdirSync(path100.dirname(evidencePath), { recursive: true });
       const fd = fs82.openSync(evidencePath, "wx");
       let writeOk = false;
       try {
@@ -87846,7 +87893,7 @@ async function executeUpdateTaskStatus(args2, fallbackDir) {
     recoverTaskStateFromDelegations(args2.task_id);
     let phaseRequiresReviewer = true;
     try {
-      const planPath = path99.join(directory, ".swarm", "plan.json");
+      const planPath = path100.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));
@@ -88166,7 +88213,7 @@ init_ledger();
 init_manager();
 init_create_tool();
 import fs83 from "node:fs";
-import path100 from "node:path";
+import path101 from "node:path";
 function derivePlanId5(plan) {
   return `${plan.swarm}-${plan.title}`.replace(/[^a-zA-Z0-9-_]/g, "_");
 }
@@ -88217,7 +88264,7 @@ async function executeWriteDriftEvidence(args2, directory) {
     entries: [evidenceEntry]
   };
   const filename = "drift-verifier.json";
-  const relativePath = path100.join("evidence", String(phase), filename);
+  const relativePath = path101.join("evidence", String(phase), filename);
   let validatedPath;
   try {
     validatedPath = validateSwarmPath(directory, relativePath);
@@ -88228,10 +88275,10 @@ async function executeWriteDriftEvidence(args2, directory) {
       message: error93 instanceof Error ? error93.message : "Failed to validate path"
     }, null, 2);
   }
-  const evidenceDir = path100.dirname(validatedPath);
+  const evidenceDir = path101.dirname(validatedPath);
   try {
     await fs83.promises.mkdir(evidenceDir, { recursive: true });
-    const tempPath = path100.join(evidenceDir, `.${filename}.tmp`);
+    const tempPath = path101.join(evidenceDir, `.${filename}.tmp`);
     await fs83.promises.writeFile(tempPath, JSON.stringify(evidenceContent, null, 2), "utf-8");
     await fs83.promises.rename(tempPath, validatedPath);
     let snapshotInfo;
@@ -88328,7 +88375,7 @@ init_zod();
 init_utils2();
 init_create_tool();
 import fs84 from "node:fs";
-import path101 from "node:path";
+import path102 from "node:path";
 function normalizeVerdict2(verdict) {
   switch (verdict) {
     case "APPROVED":
@@ -88376,7 +88423,7 @@ async function executeWriteHallucinationEvidence(args2, directory) {
     entries: [evidenceEntry]
   };
   const filename = "hallucination-guard.json";
-  const relativePath = path101.join("evidence", String(phase), filename);
+  const relativePath = path102.join("evidence", String(phase), filename);
   let validatedPath;
   try {
     validatedPath = validateSwarmPath(directory, relativePath);
@@ -88387,10 +88434,10 @@ async function executeWriteHallucinationEvidence(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 fs84.promises.mkdir(evidenceDir, { recursive: true });
-    const tempPath = path101.join(evidenceDir, `.${filename}.tmp`);
+    const tempPath = path102.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({
@@ -88439,7 +88486,7 @@ init_zod();
 init_utils2();
 init_create_tool();
 import fs85 from "node:fs";
-import path102 from "node:path";
+import path103 from "node:path";
 function normalizeVerdict3(verdict) {
   switch (verdict) {
     case "PASS":
@@ -88513,7 +88560,7 @@ async function executeWriteMutationEvidence(args2, directory) {
     entries: [evidenceEntry]
   };
   const filename = "mutation-gate.json";
-  const relativePath = path102.join("evidence", String(phase), filename);
+  const relativePath = path103.join("evidence", String(phase), filename);
   let validatedPath;
   try {
     validatedPath = validateSwarmPath(directory, relativePath);
@@ -88524,10 +88571,10 @@ async function executeWriteMutationEvidence(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 fs85.promises.mkdir(evidenceDir, { recursive: true });
-    const tempPath = path102.join(evidenceDir, `.${filename}.tmp`);
+    const tempPath = path103.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({
@@ -88584,19 +88631,19 @@ init_utils();
 
 // src/utils/gitignore-warning.ts
 import * as fs86 from "node:fs";
-import * as path103 from "node:path";
+import * as path104 from "node:path";
 var _gitignoreWarningEmitted = false;
 function findGitRoot(startDir) {
   let current = startDir;
   while (true) {
     try {
-      const gitPath = path103.join(current, ".git");
+      const gitPath = path104.join(current, ".git");
       const stat4 = fs86.statSync(gitPath);
       if (stat4.isDirectory()) {
         return current;
       }
     } catch {}
-    const parent = path103.dirname(current);
+    const parent = path104.dirname(current);
     if (parent === current) {
       return null;
     }
@@ -88628,12 +88675,12 @@ function warnIfSwarmNotGitignored(directory) {
     const gitRoot = findGitRoot(directory);
     if (!gitRoot)
       return;
-    const gitignoreContent = readFileSafe(path103.join(gitRoot, ".gitignore"));
+    const gitignoreContent = readFileSafe(path104.join(gitRoot, ".gitignore"));
     if (gitignoreContent !== null && fileCoversSwarm(gitignoreContent)) {
       _gitignoreWarningEmitted = true;
       return;
     }
-    const excludeContent = readFileSafe(path103.join(gitRoot, ".git", "info", "exclude"));
+    const excludeContent = readFileSafe(path104.join(gitRoot, ".git", "info", "exclude"));
     if (excludeContent !== null && fileCoversSwarm(excludeContent)) {
       _gitignoreWarningEmitted = true;
       return;
@@ -88679,8 +88726,8 @@ init_warning_buffer();
 var _heartbeatTimers = new Map;
 function writeSwarmConfigExampleIfNew(projectDirectory) {
   try {
-    const swarmDir = path104.join(projectDirectory, ".swarm");
-    const dest = path104.join(swarmDir, "config.example.json");
+    const swarmDir = path105.join(projectDirectory, ".swarm");
+    const dest = path105.join(swarmDir, "config.example.json");
     if (fs87.existsSync(dest))
       return;
     const example = {
@@ -88856,7 +88903,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 = path104.resolve(ctx.directory, ".swarm");
+    const swarmDir = path105.resolve(ctx.directory, ".swarm");
     statusArtifact = new ASA(swarmDir);
     statusArtifact.updateConfig(automationConfig.mode, automationConfig.capabilities);
     if (automationConfig.capabilities?.evidence_auto_summaries === true) {
@@ -89449,9 +89496,10 @@ async function initializeOpenCodeSwarm(ctx) {
     automation: automationManager
   };
 }
-var src_default = OpenCodeSwarm;
+var src_default = {
+  id: "opencode-swarm",
+  server: OpenCodeSwarm
+};
 export {
-  deferredWarnings,
-  src_default as default,
-  addDeferredWarning
+  src_default as default
 };