opencode-swarm 6.41.2 → 6.41.4

package/dist/index.js

@@ -32342,7 +32342,7 @@ function darkMatterToKnowledgeEntries(pairs, projectName) {
       lesson,
       category: "architecture",
       tags: ["hidden-coupling", "co-change", "dark-matter"],
-      scope: "project",
+      scope: "global",
       confidence,
       status: "candidate",
       confirmed_by: [],
@@ -35466,9 +35466,52 @@ var init_secretscan = __esm(() => {
   });
 });
 
-// src/tools/test-runner.ts
+// src/tools/resolve-working-directory.ts
 import * as fs15 from "fs";
 import * as path26 from "path";
+function resolveWorkingDirectory(workingDirectory, fallbackDirectory) {
+  if (workingDirectory == null || workingDirectory === "") {
+    return { success: true, directory: fallbackDirectory };
+  }
+  if (workingDirectory.includes("\x00")) {
+    return {
+      success: false,
+      message: "Invalid working_directory: null bytes are not allowed"
+    };
+  }
+  if (process.platform === "win32") {
+    const devicePathPattern = /^\\\\|^(NUL|CON|AUX|COM[1-9]|LPT[1-9])(\..*)?$/i;
+    if (devicePathPattern.test(workingDirectory)) {
+      return {
+        success: false,
+        message: "Invalid working_directory: Windows device paths are not allowed"
+      };
+    }
+  }
+  const normalizedDir = path26.normalize(workingDirectory);
+  const pathParts = normalizedDir.split(path26.sep);
+  if (pathParts.includes("..")) {
+    return {
+      success: false,
+      message: "Invalid working_directory: path traversal sequences (..) are not allowed"
+    };
+  }
+  const resolvedDir = path26.resolve(normalizedDir);
+  try {
+    const realPath = fs15.realpathSync(resolvedDir);
+    return { success: true, directory: realPath };
+  } catch {
+    return {
+      success: false,
+      message: `Invalid working_directory: path "${resolvedDir}" does not exist or is inaccessible`
+    };
+  }
+}
+var init_resolve_working_directory = () => {};
+
+// src/tools/test-runner.ts
+import * as fs16 from "fs";
+import * as path27 from "path";
 function isAbsolutePath(str) {
   if (str.startsWith("/"))
     return true;
@@ -35533,19 +35576,19 @@ function hasDevDependency(devDeps, ...patterns) {
   return hasPackageJsonDependency(devDeps, ...patterns);
 }
 function detectGoTest(cwd) {
-  return fs15.existsSync(path26.join(cwd, "go.mod")) && isCommandAvailable("go");
+  return fs16.existsSync(path27.join(cwd, "go.mod")) && isCommandAvailable("go");
 }
 function detectJavaMaven(cwd) {
-  return fs15.existsSync(path26.join(cwd, "pom.xml")) && isCommandAvailable("mvn");
+  return fs16.existsSync(path27.join(cwd, "pom.xml")) && isCommandAvailable("mvn");
 }
 function detectGradle(cwd) {
-  const hasBuildFile = fs15.existsSync(path26.join(cwd, "build.gradle")) || fs15.existsSync(path26.join(cwd, "build.gradle.kts"));
-  const hasGradlew = fs15.existsSync(path26.join(cwd, "gradlew")) || fs15.existsSync(path26.join(cwd, "gradlew.bat"));
+  const hasBuildFile = fs16.existsSync(path27.join(cwd, "build.gradle")) || fs16.existsSync(path27.join(cwd, "build.gradle.kts"));
+  const hasGradlew = fs16.existsSync(path27.join(cwd, "gradlew")) || fs16.existsSync(path27.join(cwd, "gradlew.bat"));
   return hasBuildFile && (hasGradlew || isCommandAvailable("gradle"));
 }
 function detectDotnetTest(cwd) {
   try {
-    const files = fs15.readdirSync(cwd);
+    const files = fs16.readdirSync(cwd);
     const hasCsproj = files.some((f) => f.endsWith(".csproj"));
     return hasCsproj && isCommandAvailable("dotnet");
   } catch {
@@ -35553,32 +35596,32 @@ function detectDotnetTest(cwd) {
   }
 }
 function detectCTest(cwd) {
-  const hasSource = fs15.existsSync(path26.join(cwd, "CMakeLists.txt"));
-  const hasBuildCache = fs15.existsSync(path26.join(cwd, "CMakeCache.txt")) || fs15.existsSync(path26.join(cwd, "build", "CMakeCache.txt"));
+  const hasSource = fs16.existsSync(path27.join(cwd, "CMakeLists.txt"));
+  const hasBuildCache = fs16.existsSync(path27.join(cwd, "CMakeCache.txt")) || fs16.existsSync(path27.join(cwd, "build", "CMakeCache.txt"));
   return (hasSource || hasBuildCache) && isCommandAvailable("ctest");
 }
 function detectSwiftTest(cwd) {
-  return fs15.existsSync(path26.join(cwd, "Package.swift")) && isCommandAvailable("swift");
+  return fs16.existsSync(path27.join(cwd, "Package.swift")) && isCommandAvailable("swift");
 }
 function detectDartTest(cwd) {
-  return fs15.existsSync(path26.join(cwd, "pubspec.yaml")) && (isCommandAvailable("dart") || isCommandAvailable("flutter"));
+  return fs16.existsSync(path27.join(cwd, "pubspec.yaml")) && (isCommandAvailable("dart") || isCommandAvailable("flutter"));
 }
 function detectRSpec(cwd) {
-  const hasRSpecFile = fs15.existsSync(path26.join(cwd, ".rspec"));
-  const hasGemfile = fs15.existsSync(path26.join(cwd, "Gemfile"));
-  const hasSpecDir = fs15.existsSync(path26.join(cwd, "spec"));
+  const hasRSpecFile = fs16.existsSync(path27.join(cwd, ".rspec"));
+  const hasGemfile = fs16.existsSync(path27.join(cwd, "Gemfile"));
+  const hasSpecDir = fs16.existsSync(path27.join(cwd, "spec"));
   const hasRSpec = hasRSpecFile || hasGemfile && hasSpecDir;
   return hasRSpec && (isCommandAvailable("bundle") || isCommandAvailable("rspec"));
 }
 function detectMinitest(cwd) {
-  return fs15.existsSync(path26.join(cwd, "test")) && (fs15.existsSync(path26.join(cwd, "Gemfile")) || fs15.existsSync(path26.join(cwd, "Rakefile"))) && isCommandAvailable("ruby");
+  return fs16.existsSync(path27.join(cwd, "test")) && (fs16.existsSync(path27.join(cwd, "Gemfile")) || fs16.existsSync(path27.join(cwd, "Rakefile"))) && isCommandAvailable("ruby");
 }
 async function detectTestFramework(cwd) {
   const baseDir = cwd;
   try {
-    const packageJsonPath = path26.join(baseDir, "package.json");
-    if (fs15.existsSync(packageJsonPath)) {
-      const content = fs15.readFileSync(packageJsonPath, "utf-8");
+    const packageJsonPath = path27.join(baseDir, "package.json");
+    if (fs16.existsSync(packageJsonPath)) {
+      const content = fs16.readFileSync(packageJsonPath, "utf-8");
       const pkg = JSON.parse(content);
       const _deps = pkg.dependencies || {};
       const devDeps = pkg.devDependencies || {};
@@ -35597,38 +35640,38 @@ async function detectTestFramework(cwd) {
         return "jest";
       if (hasDevDependency(devDeps, "mocha", "@types/mocha"))
         return "mocha";
-      if (fs15.existsSync(path26.join(baseDir, "bun.lockb")) || fs15.existsSync(path26.join(baseDir, "bun.lock"))) {
+      if (fs16.existsSync(path27.join(baseDir, "bun.lockb")) || fs16.existsSync(path27.join(baseDir, "bun.lock"))) {
         if (scripts.test?.includes("bun"))
           return "bun";
       }
     }
   } catch {}
   try {
-    const pyprojectTomlPath = path26.join(baseDir, "pyproject.toml");
-    const setupCfgPath = path26.join(baseDir, "setup.cfg");
-    const requirementsTxtPath = path26.join(baseDir, "requirements.txt");
-    if (fs15.existsSync(pyprojectTomlPath)) {
-      const content = fs15.readFileSync(pyprojectTomlPath, "utf-8");
+    const pyprojectTomlPath = path27.join(baseDir, "pyproject.toml");
+    const setupCfgPath = path27.join(baseDir, "setup.cfg");
+    const requirementsTxtPath = path27.join(baseDir, "requirements.txt");
+    if (fs16.existsSync(pyprojectTomlPath)) {
+      const content = fs16.readFileSync(pyprojectTomlPath, "utf-8");
       if (content.includes("[tool.pytest"))
         return "pytest";
       if (content.includes("pytest"))
         return "pytest";
     }
-    if (fs15.existsSync(setupCfgPath)) {
-      const content = fs15.readFileSync(setupCfgPath, "utf-8");
+    if (fs16.existsSync(setupCfgPath)) {
+      const content = fs16.readFileSync(setupCfgPath, "utf-8");
       if (content.includes("[pytest]"))
         return "pytest";
     }
-    if (fs15.existsSync(requirementsTxtPath)) {
-      const content = fs15.readFileSync(requirementsTxtPath, "utf-8");
+    if (fs16.existsSync(requirementsTxtPath)) {
+      const content = fs16.readFileSync(requirementsTxtPath, "utf-8");
       if (content.includes("pytest"))
         return "pytest";
     }
   } catch {}
   try {
-    const cargoTomlPath = path26.join(baseDir, "Cargo.toml");
-    if (fs15.existsSync(cargoTomlPath)) {
-      const content = fs15.readFileSync(cargoTomlPath, "utf-8");
+    const cargoTomlPath = path27.join(baseDir, "Cargo.toml");
+    if (fs16.existsSync(cargoTomlPath)) {
+      const content = fs16.readFileSync(cargoTomlPath, "utf-8");
       if (content.includes("[dev-dependencies]")) {
         if (content.includes("tokio") || content.includes("mockall") || content.includes("pretty_assertions")) {
           return "cargo";
@@ -35637,10 +35680,10 @@ async function detectTestFramework(cwd) {
     }
   } catch {}
   try {
-    const pesterConfigPath = path26.join(baseDir, "pester.config.ps1");
-    const pesterConfigJsonPath = path26.join(baseDir, "pester.config.ps1.json");
-    const pesterPs1Path = path26.join(baseDir, "tests.ps1");
-    if (fs15.existsSync(pesterConfigPath) || fs15.existsSync(pesterConfigJsonPath) || fs15.existsSync(pesterPs1Path)) {
+    const pesterConfigPath = path27.join(baseDir, "pester.config.ps1");
+    const pesterConfigJsonPath = path27.join(baseDir, "pester.config.ps1.json");
+    const pesterPs1Path = path27.join(baseDir, "tests.ps1");
+    if (fs16.existsSync(pesterConfigPath) || fs16.existsSync(pesterConfigJsonPath) || fs16.existsSync(pesterPs1Path)) {
       return "pester";
     }
   } catch {}
@@ -35672,8 +35715,8 @@ function getTestFilesFromConvention(sourceFiles) {
   const testFiles = [];
   for (const file3 of sourceFiles) {
     const normalizedPath = file3.replace(/\\/g, "/");
-    const basename4 = path26.basename(file3);
-    const dirname11 = path26.dirname(file3);
+    const basename4 = path27.basename(file3);
+    const dirname11 = path27.dirname(file3);
     if (hasCompoundTestExtension(basename4) || basename4.includes(".spec.") || basename4.includes(".test.") || normalizedPath.includes("/__tests__/") || normalizedPath.includes("/tests/") || normalizedPath.includes("/test/")) {
       if (!testFiles.includes(file3)) {
         testFiles.push(file3);
@@ -35682,16 +35725,16 @@ function getTestFilesFromConvention(sourceFiles) {
     }
     for (const _pattern of TEST_PATTERNS) {
       const nameWithoutExt = basename4.replace(/\.[^.]+$/, "");
-      const ext = path26.extname(basename4);
+      const ext = path27.extname(basename4);
       const possibleTestFiles = [
-        path26.join(dirname11, `${nameWithoutExt}.spec${ext}`),
-        path26.join(dirname11, `${nameWithoutExt}.test${ext}`),
-        path26.join(dirname11, "__tests__", `${nameWithoutExt}${ext}`),
-        path26.join(dirname11, "tests", `${nameWithoutExt}${ext}`),
-        path26.join(dirname11, "test", `${nameWithoutExt}${ext}`)
+        path27.join(dirname11, `${nameWithoutExt}.spec${ext}`),
+        path27.join(dirname11, `${nameWithoutExt}.test${ext}`),
+        path27.join(dirname11, "__tests__", `${nameWithoutExt}${ext}`),
+        path27.join(dirname11, "tests", `${nameWithoutExt}${ext}`),
+        path27.join(dirname11, "test", `${nameWithoutExt}${ext}`)
       ];
       for (const testFile of possibleTestFiles) {
-        if (fs15.existsSync(testFile) && !testFiles.includes(testFile)) {
+        if (fs16.existsSync(testFile) && !testFiles.includes(testFile)) {
           testFiles.push(testFile);
         }
       }
@@ -35707,8 +35750,8 @@ async function getTestFilesFromGraph(sourceFiles) {
   }
   for (const testFile of candidateTestFiles) {
     try {
-      const content = fs15.readFileSync(testFile, "utf-8");
-      const testDir = path26.dirname(testFile);
+      const content = fs16.readFileSync(testFile, "utf-8");
+      const testDir = path27.dirname(testFile);
       const importRegex = /import\s+.*?\s+from\s+['"]([^'"]+)['"]/g;
       let match;
       match = importRegex.exec(content);
@@ -35716,8 +35759,8 @@ async function getTestFilesFromGraph(sourceFiles) {
         const importPath = match[1];
         let resolvedImport;
         if (importPath.startsWith(".")) {
-          resolvedImport = path26.resolve(testDir, importPath);
-          const existingExt = path26.extname(resolvedImport);
+          resolvedImport = path27.resolve(testDir, importPath);
+          const existingExt = path27.extname(resolvedImport);
           if (!existingExt) {
             for (const extToTry of [
               ".ts",
@@ -35728,7 +35771,7 @@ async function getTestFilesFromGraph(sourceFiles) {
               ".cjs"
             ]) {
               const withExt = resolvedImport + extToTry;
-              if (sourceFiles.includes(withExt) || fs15.existsSync(withExt)) {
+              if (sourceFiles.includes(withExt) || fs16.existsSync(withExt)) {
                 resolvedImport = withExt;
                 break;
               }
@@ -35737,12 +35780,12 @@ async function getTestFilesFromGraph(sourceFiles) {
         } else {
           continue;
         }
-        const importBasename = path26.basename(resolvedImport, path26.extname(resolvedImport));
-        const importDir = path26.dirname(resolvedImport);
+        const importBasename = path27.basename(resolvedImport, path27.extname(resolvedImport));
+        const importDir = path27.dirname(resolvedImport);
         for (const sourceFile of sourceFiles) {
-          const sourceDir = path26.dirname(sourceFile);
-          const sourceBasename = path26.basename(sourceFile, path26.extname(sourceFile));
-          const isRelatedDir = importDir === sourceDir || importDir === path26.join(sourceDir, "__tests__") || importDir === path26.join(sourceDir, "tests") || importDir === path26.join(sourceDir, "test");
+          const sourceDir = path27.dirname(sourceFile);
+          const sourceBasename = path27.basename(sourceFile, path27.extname(sourceFile));
+          const isRelatedDir = importDir === sourceDir || importDir === path27.join(sourceDir, "__tests__") || importDir === path27.join(sourceDir, "tests") || importDir === path27.join(sourceDir, "test");
           if (resolvedImport === sourceFile || importBasename === sourceBasename && isRelatedDir) {
             if (!testFiles.includes(testFile)) {
               testFiles.push(testFile);
@@ -35757,8 +35800,8 @@ async function getTestFilesFromGraph(sourceFiles) {
       while (match !== null) {
         const importPath = match[1];
         if (importPath.startsWith(".")) {
-          let resolvedImport = path26.resolve(testDir, importPath);
-          const existingExt = path26.extname(resolvedImport);
+          let resolvedImport = path27.resolve(testDir, importPath);
+          const existingExt = path27.extname(resolvedImport);
           if (!existingExt) {
             for (const extToTry of [
               ".ts",
@@ -35769,18 +35812,18 @@ async function getTestFilesFromGraph(sourceFiles) {
               ".cjs"
             ]) {
               const withExt = resolvedImport + extToTry;
-              if (sourceFiles.includes(withExt) || fs15.existsSync(withExt)) {
+              if (sourceFiles.includes(withExt) || fs16.existsSync(withExt)) {
                 resolvedImport = withExt;
                 break;
               }
             }
           }
-          const importDir = path26.dirname(resolvedImport);
-          const importBasename = path26.basename(resolvedImport, path26.extname(resolvedImport));
+          const importDir = path27.dirname(resolvedImport);
+          const importBasename = path27.basename(resolvedImport, path27.extname(resolvedImport));
           for (const sourceFile of sourceFiles) {
-            const sourceDir = path26.dirname(sourceFile);
-            const sourceBasename = path26.basename(sourceFile, path26.extname(sourceFile));
-            const isRelatedDir = importDir === sourceDir || importDir === path26.join(sourceDir, "__tests__") || importDir === path26.join(sourceDir, "tests") || importDir === path26.join(sourceDir, "test");
+            const sourceDir = path27.dirname(sourceFile);
+            const sourceBasename = path27.basename(sourceFile, path27.extname(sourceFile));
+            const isRelatedDir = importDir === sourceDir || importDir === path27.join(sourceDir, "__tests__") || importDir === path27.join(sourceDir, "tests") || importDir === path27.join(sourceDir, "test");
             if (resolvedImport === sourceFile || importBasename === sourceBasename && isRelatedDir) {
               if (!testFiles.includes(testFile)) {
                 testFiles.push(testFile);
@@ -35865,8 +35908,8 @@ function buildTestCommand(framework, scope, files, coverage, baseDir) {
       return ["mvn", "test"];
     case "gradle": {
       const isWindows = process.platform === "win32";
-      const hasGradlewBat = fs15.existsSync(path26.join(baseDir, "gradlew.bat"));
-      const hasGradlew = fs15.existsSync(path26.join(baseDir, "gradlew"));
+      const hasGradlewBat = fs16.existsSync(path27.join(baseDir, "gradlew.bat"));
+      const hasGradlew = fs16.existsSync(path27.join(baseDir, "gradlew"));
       if (hasGradlewBat && isWindows)
         return ["gradlew.bat", "test"];
       if (hasGradlew)
@@ -35883,7 +35926,7 @@ function buildTestCommand(framework, scope, files, coverage, baseDir) {
         "cmake-build-release",
         "out"
       ];
-      const actualBuildDir = buildDirCandidates.find((d) => fs15.existsSync(path26.join(baseDir, d, "CMakeCache.txt"))) ?? "build";
+      const actualBuildDir = buildDirCandidates.find((d) => fs16.existsSync(path27.join(baseDir, d, "CMakeCache.txt"))) ?? "build";
       return ["ctest", "--test-dir", actualBuildDir];
     }
     case "swift-test":
@@ -36115,6 +36158,43 @@ function parseTestOutput(framework, output) {
   }
   return { totals, coveragePercent };
 }
+async function readBoundedStream(stream, maxBytes) {
+  const reader = stream.getReader();
+  const chunks = [];
+  let totalBytes = 0;
+  let truncated = false;
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done)
+        break;
+      if (totalBytes + value.length > maxBytes) {
+        const remaining = maxBytes - totalBytes;
+        if (remaining > 0) {
+          chunks.push(value.slice(0, remaining));
+        }
+        totalBytes = maxBytes;
+        truncated = true;
+        reader.cancel().catch(() => {});
+        break;
+      }
+      chunks.push(value);
+      totalBytes += value.length;
+    }
+  } catch {} finally {
+    try {
+      reader.releaseLock();
+    } catch {}
+  }
+  const decoder = new TextDecoder("utf-8", { fatal: false });
+  const combined = new Uint8Array(totalBytes);
+  let offset = 0;
+  for (const chunk of chunks) {
+    combined.set(chunk, offset);
+    offset += chunk.length;
+  }
+  return { text: decoder.decode(combined), truncated };
+}
 async function runTests(framework, scope, files, coverage, timeout_ms, cwd) {
   const command = buildTestCommand(framework, scope, files, coverage, cwd);
   if (!command) {
@@ -36143,34 +36223,24 @@ async function runTests(framework, scope, files, coverage, timeout_ms, cwd) {
       stderr: "pipe",
       cwd
     });
-    const exitPromise = proc.exited;
-    const timeoutPromise = new Promise((resolve8) => setTimeout(() => {
+    const timeoutPromise = new Promise((resolve9) => setTimeout(() => {
       proc.kill();
-      resolve8(-1);
+      resolve9(-1);
     }, timeout_ms));
-    const exitCode = await Promise.race([exitPromise, timeoutPromise]);
-    const duration_ms = Date.now() - startTime;
-    const [stdout, stderr] = await Promise.all([
-      new Response(proc.stdout).text(),
-      new Response(proc.stderr).text()
+    const [exitCode, stdoutResult, stderrResult] = await Promise.all([
+      Promise.race([proc.exited, timeoutPromise]),
+      readBoundedStream(proc.stdout, MAX_OUTPUT_BYTES3),
+      readBoundedStream(proc.stderr, MAX_OUTPUT_BYTES3)
     ]);
-    let output = stdout;
-    if (stderr) {
+    const duration_ms = Date.now() - startTime;
+    let output = stdoutResult.text;
+    if (stderrResult.text) {
       output += (output ? `
-` : "") + stderr;
+` : "") + stderrResult.text;
     }
-    const outputBytes = Buffer.byteLength(output, "utf-8");
-    if (outputBytes > MAX_OUTPUT_BYTES3) {
-      let truncIndex = MAX_OUTPUT_BYTES3;
-      while (truncIndex > 0) {
-        const truncated = output.slice(0, truncIndex);
-        if (Buffer.byteLength(truncated, "utf-8") <= MAX_OUTPUT_BYTES3) {
-          break;
-        }
-        truncIndex--;
-      }
-      output = `${output.slice(0, truncIndex)}
-... (output truncated)`;
+    if (stdoutResult.truncated || stderrResult.truncated) {
+      output += `
+... (output truncated at stream read limit)`;
     }
     const { totals, coveragePercent } = parseTestOutput(framework, output);
     const isTimeout = exitCode === -1;
@@ -36230,6 +36300,7 @@ var init_test_runner = __esm(() => {
   init_dist();
   init_discovery();
   init_create_tool();
+  init_resolve_working_directory();
   POWERSHELL_METACHARACTERS = /[|;&`$(){}[\]<>"'#*?\x00-\x1f]/;
   TEST_PATTERNS = [
     { test: ".spec.", source: "." },
@@ -36309,10 +36380,26 @@ var init_test_runner = __esm(() => {
       files: tool.schema.array(tool.schema.string()).optional().describe("Specific files to test (used with convention or graph scope)"),
       coverage: tool.schema.boolean().optional().describe("Enable coverage reporting if supported"),
       timeout_ms: tool.schema.number().optional().describe("Timeout in milliseconds (default 60000, max 300000)"),
-      allow_full_suite: tool.schema.boolean().optional().describe('Explicit opt-in for scope "all". Required because full-suite output can destabilize SSE streaming.')
+      allow_full_suite: tool.schema.boolean().optional().describe('Explicit opt-in for scope "all". Required because full-suite output can destabilize SSE streaming.'),
+      working_directory: tool.schema.string().optional().describe("Explicit project root directory. When provided, tests run relative to this path instead of the plugin context directory. Use this when CWD differs from the actual project root.")
     },
     async execute(args2, directory) {
-      const workingDir = directory.trim() || directory;
+      let workingDirInput;
+      if (args2 && typeof args2 === "object") {
+        const obj = args2;
+        workingDirInput = typeof obj.working_directory === "string" ? obj.working_directory : undefined;
+      }
+      const dirResult = resolveWorkingDirectory(workingDirInput, directory);
+      if (!dirResult.success) {
+        const errorResult = {
+          success: false,
+          framework: "none",
+          scope: "all",
+          error: dirResult.message
+        };
+        return JSON.stringify(errorResult, null, 2);
+      }
+      const workingDir = dirResult.directory;
       if (workingDir.length > 4096) {
         const errorResult = {
           success: false,
@@ -36366,8 +36453,8 @@ var init_test_runner = __esm(() => {
             success: false,
             framework: "none",
             scope: "all",
-            error: 'Full-suite test execution (scope: "all") requires allow_full_suite: true',
-            message: 'Set allow_full_suite: true to confirm intentional full-suite execution. Use scope "convention" or "graph" for targeted tests. Full-suite output is large and may destabilize SSE streaming on some opencode versions.'
+            error: 'scope "all" is not allowed without explicit files. Use scope "convention" or "graph" with a files array to run targeted tests.',
+            message: 'Running the full test suite without file targeting is blocked. Provide scope "convention" or "graph" with specific source files in the files array. Example: { scope: "convention", files: ["src/tools/test-runner.ts"] }'
           };
           return JSON.stringify(errorResult, null, 2);
         }
@@ -36407,7 +36494,7 @@ var init_test_runner = __esm(() => {
       let effectiveScope = scope;
       if (scope === "all") {} else if (scope === "convention") {
         const sourceFiles = args2.files.filter((f) => {
-          const ext = path26.extname(f).toLowerCase();
+          const ext = path27.extname(f).toLowerCase();
           return SOURCE_EXTENSIONS.has(ext);
         });
         if (sourceFiles.length === 0) {
@@ -36423,7 +36510,7 @@ var init_test_runner = __esm(() => {
         testFiles = getTestFilesFromConvention(sourceFiles);
       } else if (scope === "graph") {
         const sourceFiles = args2.files.filter((f) => {
-          const ext = path26.extname(f).toLowerCase();
+          const ext = path27.extname(f).toLowerCase();
           return SOURCE_EXTENSIONS.has(ext);
         });
         if (sourceFiles.length === 0) {
@@ -36476,8 +36563,8 @@ var init_test_runner = __esm(() => {
 });
 
 // src/services/preflight-service.ts
-import * as fs16 from "fs";
-import * as path27 from "path";
+import * as fs17 from "fs";
+import * as path28 from "path";
 function validateDirectoryPath(dir) {
   if (!dir || typeof dir !== "string") {
     throw new Error("Directory path is required");
@@ -36485,8 +36572,8 @@ function validateDirectoryPath(dir) {
   if (dir.includes("..")) {
     throw new Error("Directory path must not contain path traversal sequences");
   }
-  const normalized = path27.normalize(dir);
-  const absolutePath = path27.isAbsolute(normalized) ? normalized : path27.resolve(normalized);
+  const normalized = path28.normalize(dir);
+  const absolutePath = path28.isAbsolute(normalized) ? normalized : path28.resolve(normalized);
   return absolutePath;
 }
 function validateTimeout(timeoutMs, defaultValue) {
@@ -36509,9 +36596,9 @@ function validateTimeout(timeoutMs, defaultValue) {
 }
 function getPackageVersion(dir) {
   try {
-    const packagePath = path27.join(dir, "package.json");
-    if (fs16.existsSync(packagePath)) {
-      const content = fs16.readFileSync(packagePath, "utf-8");
+    const packagePath = path28.join(dir, "package.json");
+    if (fs17.existsSync(packagePath)) {
+      const content = fs17.readFileSync(packagePath, "utf-8");
       const pkg = JSON.parse(content);
       return pkg.version ?? null;
     }
@@ -36520,9 +36607,9 @@ function getPackageVersion(dir) {
 }
 function getChangelogVersion(dir) {
   try {
-    const changelogPath = path27.join(dir, "CHANGELOG.md");
-    if (fs16.existsSync(changelogPath)) {
-      const content = fs16.readFileSync(changelogPath, "utf-8");
+    const changelogPath = path28.join(dir, "CHANGELOG.md");
+    if (fs17.existsSync(changelogPath)) {
+      const content = fs17.readFileSync(changelogPath, "utf-8");
       const match = content.match(/^##\s*\[?(\d+\.\d+\.\d+)\]?/m);
       if (match) {
         return match[1];
@@ -36534,10 +36621,10 @@ function getChangelogVersion(dir) {
 function getVersionFileVersion(dir) {
   const possibleFiles = ["VERSION.txt", "version.txt", "VERSION", "version"];
   for (const file3 of possibleFiles) {
-    const filePath = path27.join(dir, file3);
-    if (fs16.existsSync(filePath)) {
+    const filePath = path28.join(dir, file3);
+    if (fs17.existsSync(filePath)) {
       try {
-        const content = fs16.readFileSync(filePath, "utf-8").trim();
+        const content = fs17.readFileSync(filePath, "utf-8").trim();
         const match = content.match(/(\d+\.\d+\.\d+)/);
         if (match) {
           return match[1];
@@ -37062,7 +37149,7 @@ __export(exports_gate_evidence, {
   DEFAULT_REQUIRED_GATES: () => DEFAULT_REQUIRED_GATES
 });
 import { mkdirSync as mkdirSync10, readFileSync as readFileSync14, renameSync as renameSync9, unlinkSync as unlinkSync5 } from "fs";
-import * as path33 from "path";
+import * as path34 from "path";
 function isValidTaskId2(taskId) {
   if (!taskId)
     return false;
@@ -37109,10 +37196,10 @@ function expandRequiredGates(existingGates, newAgentType) {
   return combined.sort();
 }
 function getEvidenceDir(directory) {
-  return path33.join(directory, ".swarm", "evidence");
+  return path34.join(directory, ".swarm", "evidence");
 }
 function getEvidencePath(directory, taskId) {
-  return path33.join(getEvidenceDir(directory), `${taskId}.json`);
+  return path34.join(getEvidenceDir(directory), `${taskId}.json`);
 }
 function readExisting(evidencePath) {
   try {
@@ -37282,15 +37369,15 @@ __export(exports_doc_scan, {
   doc_extract: () => doc_extract
 });
 import * as crypto4 from "crypto";
-import * as fs26 from "fs";
+import * as fs27 from "fs";
 import { mkdir as mkdir6, readFile as readFile6, writeFile as writeFile5 } from "fs/promises";
-import * as path38 from "path";
+import * as path39 from "path";
 function normalizeSeparators(filePath) {
   return filePath.replace(/\\/g, "/");
 }
 function matchesDocPattern(filePath, patterns) {
   const normalizedPath = normalizeSeparators(filePath);
-  const basename5 = path38.basename(filePath);
+  const basename5 = path39.basename(filePath);
   for (const pattern of patterns) {
     if (!pattern.includes("/") && !pattern.includes("\\")) {
       if (basename5 === pattern) {
@@ -37346,7 +37433,7 @@ function stripMarkdown(text) {
   return text.replace(/\[([^\]]+)\]\([^)]+\)/g, "$1").replace(/\*\*([^*]+)\*\*/g, "$1").replace(/`([^`]+)`/g, "$1").replace(/^\s*[-*\u2022]\s+/gm, "").replace(/^\s*\d+\.\s+/gm, "").trim();
 }
 async function scanDocIndex(directory) {
-  const manifestPath = path38.join(directory, ".swarm", "doc-manifest.json");
+  const manifestPath = path39.join(directory, ".swarm", "doc-manifest.json");
   const defaultPatterns = DocsConfigSchema.parse({}).doc_patterns;
   const extraPatterns = [
     "ARCHITECTURE.md",
@@ -37363,8 +37450,8 @@ async function scanDocIndex(directory) {
       let cacheValid = true;
       for (const file3 of existingManifest.files) {
         try {
-          const fullPath = path38.join(directory, file3.path);
-          const stat2 = fs26.statSync(fullPath);
+          const fullPath = path39.join(directory, file3.path);
+          const stat2 = fs27.statSync(fullPath);
           if (stat2.mtimeMs > new Date(existingManifest.scanned_at).getTime()) {
             cacheValid = false;
             break;
@@ -37382,7 +37469,7 @@ async function scanDocIndex(directory) {
   const discoveredFiles = [];
   let rawEntries;
   try {
-    rawEntries = fs26.readdirSync(directory, { recursive: true });
+    rawEntries = fs27.readdirSync(directory, { recursive: true });
   } catch {
     const manifest2 = {
       schema_version: 1,
@@ -37393,10 +37480,10 @@ async function scanDocIndex(directory) {
   }
   const entries = rawEntries.filter((e) => typeof e === "string");
   for (const entry of entries) {
-    const fullPath = path38.join(directory, entry);
+    const fullPath = path39.join(directory, entry);
     let stat2;
     try {
-      stat2 = fs26.statSync(fullPath);
+      stat2 = fs27.statSync(fullPath);
     } catch {
       continue;
     }
@@ -37425,11 +37512,11 @@ async function scanDocIndex(directory) {
     }
     let content;
     try {
-      content = fs26.readFileSync(fullPath, "utf-8");
+      content = fs27.readFileSync(fullPath, "utf-8");
     } catch {
       continue;
     }
-    const { title, summary } = extractTitleAndSummary(content, path38.basename(entry));
+    const { title, summary } = extractTitleAndSummary(content, path39.basename(entry));
     const lineCount = content.split(`
 `).length;
     discoveredFiles.push({
@@ -37455,7 +37542,7 @@ async function scanDocIndex(directory) {
     files: discoveredFiles
   };
   try {
-    await mkdir6(path38.dirname(manifestPath), { recursive: true });
+    await mkdir6(path39.dirname(manifestPath), { recursive: true });
     await writeFile5(manifestPath, JSON.stringify(manifest, null, 2), "utf-8");
   } catch {}
   return { manifest, cached: false };
@@ -37494,7 +37581,7 @@ function extractConstraintsFromContent(content) {
   return constraints;
 }
 async function extractDocConstraints(directory, taskFiles, taskDescription) {
-  const manifestPath = path38.join(directory, ".swarm", "doc-manifest.json");
+  const manifestPath = path39.join(directory, ".swarm", "doc-manifest.json");
   let manifest;
   try {
     const content = await readFile6(manifestPath, "utf-8");
@@ -37520,7 +37607,7 @@ async function extractDocConstraints(directory, taskFiles, taskDescription) {
     }
     let fullContent;
     try {
-      fullContent = await readFile6(path38.join(directory, docFile.path), "utf-8");
+      fullContent = await readFile6(path39.join(directory, docFile.path), "utf-8");
     } catch {
       skippedCount++;
       continue;
@@ -37543,7 +37630,7 @@ async function extractDocConstraints(directory, taskFiles, taskDescription) {
           tier: "swarm",
           lesson: constraint,
           category: "architecture",
-          tags: ["doc-scan", path38.basename(docFile.path)],
+          tags: ["doc-scan", path39.basename(docFile.path)],
           scope: "global",
           confidence: 0.5,
           status: "candidate",
@@ -37616,9 +37703,9 @@ var init_doc_scan = __esm(() => {
         }
       } catch {}
       if (force) {
-        const manifestPath = path38.join(directory, ".swarm", "doc-manifest.json");
+        const manifestPath = path39.join(directory, ".swarm", "doc-manifest.json");
         try {
-          fs26.unlinkSync(manifestPath);
+          fs27.unlinkSync(manifestPath);
         } catch {}
       }
       const { manifest, cached: cached3 } = await scanDocIndex(directory);
@@ -37670,11 +37757,11 @@ __export(exports_curator_drift, {
   readPriorDriftReports: () => readPriorDriftReports,
   buildDriftInjectionText: () => buildDriftInjectionText
 });
-import * as fs29 from "fs";
-import * as path41 from "path";
+import * as fs30 from "fs";
+import * as path42 from "path";
 async function readPriorDriftReports(directory) {
-  const swarmDir = path41.join(directory, ".swarm");
-  const entries = await fs29.promises.readdir(swarmDir).catch(() => null);
+  const swarmDir = path42.join(directory, ".swarm");
+  const entries = await fs30.promises.readdir(swarmDir).catch(() => null);
   if (entries === null)
     return [];
   const reportFiles = entries.filter((name2) => name2.startsWith(DRIFT_REPORT_PREFIX) && name2.endsWith(".json")).sort();
@@ -37700,10 +37787,10 @@ async function readPriorDriftReports(directory) {
 async function writeDriftReport(directory, report) {
   const filename = `${DRIFT_REPORT_PREFIX}${report.phase}.json`;
   const filePath = validateSwarmPath(directory, filename);
-  const swarmDir = path41.dirname(filePath);
-  await fs29.promises.mkdir(swarmDir, { recursive: true });
+  const swarmDir = path42.dirname(filePath);
+  await fs30.promises.mkdir(swarmDir, { recursive: true });
   try {
-    await fs29.promises.writeFile(filePath, JSON.stringify(report, null, 2), "utf-8");
+    await fs30.promises.writeFile(filePath, JSON.stringify(report, null, 2), "utf-8");
   } catch (err2) {
     throw new Error(`[curator-drift] Failed to write drift report to ${filePath}: ${String(err2)}`);
   }
@@ -39270,8 +39357,8 @@ ${JSON.stringify(symbolNames, null, 2)}`);
       var moduleRtn;
       var Module = moduleArg;
       var readyPromiseResolve, readyPromiseReject;
-      var readyPromise = new Promise((resolve16, reject) => {
-        readyPromiseResolve = resolve16;
+      var readyPromise = new Promise((resolve17, reject) => {
+        readyPromiseResolve = resolve17;
         readyPromiseReject = reject;
       });
       var ENVIRONMENT_IS_WEB = typeof window == "object";
@@ -39293,11 +39380,11 @@ ${JSON.stringify(symbolNames, null, 2)}`);
         throw toThrow;
       }, "quit_");
       var scriptDirectory = "";
-      function locateFile(path49) {
+      function locateFile(path50) {
         if (Module["locateFile"]) {
-          return Module["locateFile"](path49, scriptDirectory);
+          return Module["locateFile"](path50, scriptDirectory);
         }
-        return scriptDirectory + path49;
+        return scriptDirectory + path50;
       }
       __name(locateFile, "locateFile");
       var readAsync, readBinary;
@@ -39351,13 +39438,13 @@ ${JSON.stringify(symbolNames, null, 2)}`);
           }
           readAsync = /* @__PURE__ */ __name(async (url3) => {
             if (isFileURI(url3)) {
-              return new Promise((resolve16, reject) => {
+              return new Promise((resolve17, reject) => {
                 var xhr = new XMLHttpRequest;
                 xhr.open("GET", url3, true);
                 xhr.responseType = "arraybuffer";
                 xhr.onload = () => {
                   if (xhr.status == 200 || xhr.status == 0 && xhr.response) {
-                    resolve16(xhr.response);
+                    resolve17(xhr.response);
                     return;
                   }
                   reject(xhr.status);
@@ -39577,10 +39664,10 @@ ${JSON.stringify(symbolNames, null, 2)}`);
         __name(receiveInstantiationResult, "receiveInstantiationResult");
         var info2 = getWasmImports();
         if (Module["instantiateWasm"]) {
-          return new Promise((resolve16, reject) => {
+          return new Promise((resolve17, reject) => {
             Module["instantiateWasm"](info2, (mod, inst) => {
               receiveInstance(mod, inst);
-              resolve16(mod.exports);
+              resolve17(mod.exports);
             });
           });
         }
@@ -41037,13 +41124,13 @@ ${JSON.stringify(symbolNames, null, 2)}`);
 });
 
 // src/lang/runtime.ts
-import * as path49 from "path";
+import * as path50 from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 async function initTreeSitter() {
   if (treeSitterInitialized) {
     return;
   }
-  const thisDir = path49.dirname(fileURLToPath2(import.meta.url));
+  const thisDir = path50.dirname(fileURLToPath2(import.meta.url));
   const isSource = thisDir.replace(/\\/g, "/").endsWith("/src/lang");
   if (isSource) {
     await Parser.init();
@@ -41051,7 +41138,7 @@ async function initTreeSitter() {
     const grammarsDir = getGrammarsDirAbsolute();
     await Parser.init({
       locateFile(scriptName) {
-        return path49.join(grammarsDir, scriptName);
+        return path50.join(grammarsDir, scriptName);
       }
     });
   }
@@ -41072,9 +41159,9 @@ function getWasmFileName(languageId) {
   return `tree-sitter-${sanitized}.wasm`;
 }
 function getGrammarsDirAbsolute() {
-  const thisDir = path49.dirname(fileURLToPath2(import.meta.url));
+  const thisDir = path50.dirname(fileURLToPath2(import.meta.url));
   const isSource = thisDir.replace(/\\/g, "/").endsWith("/src/lang");
-  return isSource ? path49.join(thisDir, "grammars") : path49.join(thisDir, "lang", "grammars");
+  return isSource ? path50.join(thisDir, "grammars") : path50.join(thisDir, "lang", "grammars");
 }
 async function loadGrammar(languageId) {
   if (typeof languageId !== "string" || languageId.length > 100) {
@@ -41090,7 +41177,7 @@ async function loadGrammar(languageId) {
   await initTreeSitter();
   const parser = new Parser;
   const wasmFileName = getWasmFileName(normalizedId);
-  const wasmPath = path49.join(getGrammarsDirAbsolute(), wasmFileName);
+  const wasmPath = path50.join(getGrammarsDirAbsolute(), wasmFileName);
   const { existsSync: existsSync29 } = await import("fs");
   if (!existsSync29(wasmPath)) {
     throw new Error(`Grammar file not found for ${languageId}: ${wasmPath}
@@ -41137,7 +41224,7 @@ var init_runtime = __esm(() => {
 });
 
 // src/index.ts
-import * as path66 from "path";
+import * as path67 from "path";
 
 // src/agents/index.ts
 init_config();
@@ -50040,7 +50127,7 @@ async function handlePromoteCommand(directory, args2) {
 }
 
 // src/commands/reset.ts
-import * as fs17 from "fs";
+import * as fs18 from "fs";
 init_utils2();
 async function handleResetCommand(directory, args2) {
   const hasConfirm = args2.includes("--confirm");
@@ -50061,8 +50148,8 @@ async function handleResetCommand(directory, args2) {
   for (const filename of filesToReset) {
     try {
       const resolvedPath = validateSwarmPath(directory, filename);
-      if (fs17.existsSync(resolvedPath)) {
-        fs17.unlinkSync(resolvedPath);
+      if (fs18.existsSync(resolvedPath)) {
+        fs18.unlinkSync(resolvedPath);
         results.push(`- \u2705 Deleted ${filename}`);
       } else {
         results.push(`- \u23ED\uFE0F ${filename} not found (skipped)`);
@@ -50079,8 +50166,8 @@ async function handleResetCommand(directory, args2) {
   }
   try {
     const summariesPath = validateSwarmPath(directory, "summaries");
-    if (fs17.existsSync(summariesPath)) {
-      fs17.rmSync(summariesPath, { recursive: true, force: true });
+    if (fs18.existsSync(summariesPath)) {
+      fs18.rmSync(summariesPath, { recursive: true, force: true });
       results.push("- \u2705 Deleted summaries/ directory");
     } else {
       results.push("- \u23ED\uFE0F summaries/ not found (skipped)");
@@ -50100,14 +50187,14 @@ async function handleResetCommand(directory, args2) {
 
 // src/commands/reset-session.ts
 init_utils2();
-import * as fs18 from "fs";
-import * as path28 from "path";
+import * as fs19 from "fs";
+import * as path29 from "path";
 async function handleResetSessionCommand(directory, _args) {
   const results = [];
   try {
     const statePath = validateSwarmPath(directory, "session/state.json");
-    if (fs18.existsSync(statePath)) {
-      fs18.unlinkSync(statePath);
+    if (fs19.existsSync(statePath)) {
+      fs19.unlinkSync(statePath);
       results.push("\u2705 Deleted .swarm/session/state.json");
     } else {
       results.push("\u23ED\uFE0F state.json not found (already clean)");
@@ -50116,15 +50203,15 @@ async function handleResetSessionCommand(directory, _args) {
     results.push("\u274C Failed to delete state.json");
   }
   try {
-    const sessionDir = path28.dirname(validateSwarmPath(directory, "session/state.json"));
-    if (fs18.existsSync(sessionDir)) {
-      const files = fs18.readdirSync(sessionDir);
+    const sessionDir = path29.dirname(validateSwarmPath(directory, "session/state.json"));
+    if (fs19.existsSync(sessionDir)) {
+      const files = fs19.readdirSync(sessionDir);
       const otherFiles = files.filter((f) => f !== "state.json");
       let deletedCount = 0;
       for (const file3 of otherFiles) {
-        const filePath = path28.join(sessionDir, file3);
-        if (fs18.lstatSync(filePath).isFile()) {
-          fs18.unlinkSync(filePath);
+        const filePath = path29.join(sessionDir, file3);
+        if (fs19.lstatSync(filePath).isFile()) {
+          fs19.unlinkSync(filePath);
           deletedCount++;
         }
       }
@@ -50153,7 +50240,7 @@ async function handleResetSessionCommand(directory, _args) {
 init_utils2();
 init_utils();
 import { mkdirSync as mkdirSync9, readdirSync as readdirSync8, renameSync as renameSync7, rmSync as rmSync3, statSync as statSync8 } from "fs";
-import * as path29 from "path";
+import * as path30 from "path";
 var SUMMARY_ID_REGEX = /^S\d+$/;
 function sanitizeSummaryId(id) {
   if (!id || id.length === 0) {
@@ -50188,9 +50275,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 = path29.join("summaries", `${sanitizedId}.json`);
+  const relativePath = path30.join("summaries", `${sanitizedId}.json`);
   const summaryPath = validateSwarmPath(directory, relativePath);
-  const summaryDir = path29.dirname(summaryPath);
+  const summaryDir = path30.dirname(summaryPath);
   const entry = {
     id: sanitizedId,
     summaryText,
@@ -50200,7 +50287,7 @@ async function storeSummary(directory, id, fullOutput, summaryText, maxStoredByt
   };
   const entryJson = JSON.stringify(entry);
   mkdirSync9(summaryDir, { recursive: true });
-  const tempPath = path29.join(summaryDir, `${sanitizedId}.json.tmp.${Date.now()}.${process.pid}`);
+  const tempPath = path30.join(summaryDir, `${sanitizedId}.json.tmp.${Date.now()}.${process.pid}`);
   try {
     await Bun.write(tempPath, entryJson);
     renameSync7(tempPath, summaryPath);
@@ -50213,7 +50300,7 @@ async function storeSummary(directory, id, fullOutput, summaryText, maxStoredByt
 }
 async function loadFullOutput(directory, id) {
   const sanitizedId = sanitizeSummaryId(id);
-  const relativePath = path29.join("summaries", `${sanitizedId}.json`);
+  const relativePath = path30.join("summaries", `${sanitizedId}.json`);
   validateSwarmPath(directory, relativePath);
   const content = await readSwarmFileAsync(directory, relativePath);
   if (content === null) {
@@ -50266,18 +50353,18 @@ ${error93 instanceof Error ? error93.message : String(error93)}`;
 
 // src/commands/rollback.ts
 init_utils2();
-import * as fs19 from "fs";
-import * as path30 from "path";
+import * as fs20 from "fs";
+import * as path31 from "path";
 async function handleRollbackCommand(directory, args2) {
   const phaseArg = args2[0];
   if (!phaseArg) {
     const manifestPath2 = validateSwarmPath(directory, "checkpoints/manifest.json");
-    if (!fs19.existsSync(manifestPath2)) {
+    if (!fs20.existsSync(manifestPath2)) {
       return "No checkpoints found. Use `/swarm checkpoint` to create checkpoints.";
     }
     let manifest2;
     try {
-      manifest2 = JSON.parse(fs19.readFileSync(manifestPath2, "utf-8"));
+      manifest2 = JSON.parse(fs20.readFileSync(manifestPath2, "utf-8"));
     } catch {
       return "Error: Checkpoint manifest is corrupted. Delete .swarm/checkpoints/manifest.json and re-checkpoint.";
     }
@@ -50299,12 +50386,12 @@ async function handleRollbackCommand(directory, args2) {
     return "Error: Phase number must be a positive integer.";
   }
   const manifestPath = validateSwarmPath(directory, "checkpoints/manifest.json");
-  if (!fs19.existsSync(manifestPath)) {
+  if (!fs20.existsSync(manifestPath)) {
     return `Error: No checkpoints found. Cannot rollback to phase ${targetPhase}.`;
   }
   let manifest;
   try {
-    manifest = JSON.parse(fs19.readFileSync(manifestPath, "utf-8"));
+    manifest = JSON.parse(fs20.readFileSync(manifestPath, "utf-8"));
   } catch {
     return `Error: Checkpoint manifest is corrupted. Delete .swarm/checkpoints/manifest.json and re-checkpoint.`;
   }
@@ -50314,10 +50401,10 @@ async function handleRollbackCommand(directory, args2) {
     return `Error: Checkpoint for phase ${targetPhase} not found. Available phases: ${available}`;
   }
   const checkpointDir = validateSwarmPath(directory, `checkpoints/phase-${targetPhase}`);
-  if (!fs19.existsSync(checkpointDir)) {
+  if (!fs20.existsSync(checkpointDir)) {
     return `Error: Checkpoint directory for phase ${targetPhase} does not exist.`;
   }
-  const checkpointFiles = fs19.readdirSync(checkpointDir);
+  const checkpointFiles = fs20.readdirSync(checkpointDir);
   if (checkpointFiles.length === 0) {
     return `Error: Checkpoint for phase ${targetPhase} is empty. Cannot rollback.`;
   }
@@ -50325,10 +50412,10 @@ async function handleRollbackCommand(directory, args2) {
   const successes = [];
   const failures = [];
   for (const file3 of checkpointFiles) {
-    const src = path30.join(checkpointDir, file3);
-    const dest = path30.join(swarmDir, file3);
+    const src = path31.join(checkpointDir, file3);
+    const dest = path31.join(swarmDir, file3);
     try {
-      fs19.cpSync(src, dest, { recursive: true, force: true });
+      fs20.cpSync(src, dest, { recursive: true, force: true });
       successes.push(file3);
     } catch (error93) {
       failures.push({ file: file3, error: error93.message });
@@ -50345,7 +50432,7 @@ async function handleRollbackCommand(directory, args2) {
     timestamp: new Date().toISOString()
   };
   try {
-    fs19.appendFileSync(eventsPath, `${JSON.stringify(rollbackEvent)}
+    fs20.appendFileSync(eventsPath, `${JSON.stringify(rollbackEvent)}
 `);
   } catch (error93) {
     console.error("Failed to write rollback event:", error93 instanceof Error ? error93.message : String(error93));
@@ -50389,11 +50476,11 @@ async function handleSimulateCommand(directory, args2) {
   ];
   const report = reportLines.filter(Boolean).join(`
 `);
-  const fs20 = await import("fs/promises");
-  const path31 = await import("path");
-  const reportPath = path31.join(directory, ".swarm", "simulate-report.md");
-  await fs20.mkdir(path31.dirname(reportPath), { recursive: true });
-  await fs20.writeFile(reportPath, report, "utf-8");
+  const fs21 = await import("fs/promises");
+  const path32 = await import("path");
+  const reportPath = path32.join(directory, ".swarm", "simulate-report.md");
+  await fs21.mkdir(path32.dirname(reportPath), { recursive: true });
+  await fs21.writeFile(reportPath, report, "utf-8");
   return `${darkMatterPairs.length} hidden coupling pairs detected`;
 }
 
@@ -50750,8 +50837,8 @@ init_utils2();
 init_manager2();
 
 // src/services/compaction-service.ts
-import * as fs20 from "fs";
-import * as path31 from "path";
+import * as fs21 from "fs";
+import * as path32 from "path";
 function makeInitialState() {
   return {
     lastObservationAt: 0,
@@ -50774,13 +50861,13 @@ function getSessionState(sessionId) {
 }
 function appendSnapshot(directory, tier, budgetPct, message) {
   try {
-    const snapshotPath = path31.join(directory, ".swarm", "context-snapshot.md");
+    const snapshotPath = path32.join(directory, ".swarm", "context-snapshot.md");
     const timestamp = new Date().toISOString();
     const entry = `
 ## [${tier.toUpperCase()}] ${timestamp} \u2014 ${budgetPct.toFixed(1)}% used
 ${message}
 `;
-    fs20.appendFileSync(snapshotPath, entry, "utf-8");
+    fs21.appendFileSync(snapshotPath, entry, "utf-8");
   } catch {}
 }
 function buildObservationMessage(budgetPct) {
@@ -51505,11 +51592,11 @@ async function doFlush(directory) {
     const activitySection = renderActivitySection();
     const updated = replaceOrAppendSection(existing, "## Agent Activity", activitySection);
     const flushedCount = swarmState.pendingEvents;
-    const path32 = nodePath2.join(directory, ".swarm", "context.md");
-    const tempPath = `${path32}.tmp`;
+    const path33 = nodePath2.join(directory, ".swarm", "context.md");
+    const tempPath = `${path33}.tmp`;
     try {
       await Bun.write(tempPath, updated);
-      renameSync8(tempPath, path32);
+      renameSync8(tempPath, path33);
     } catch (writeError) {
       try {
         unlinkSync4(tempPath);
@@ -51558,7 +51645,7 @@ ${content.substring(endIndex + 1)}`;
 }
 // src/hooks/compaction-customizer.ts
 init_manager2();
-import * as fs21 from "fs";
+import * as fs22 from "fs";
 import { join as join29 } from "path";
 init_utils2();
 function createCompactionCustomizerHook(config3, directory) {
@@ -51606,7 +51693,7 @@ function createCompactionCustomizerHook(config3, directory) {
       }
       try {
         const summariesDir = join29(directory, ".swarm", "summaries");
-        const files = await fs21.promises.readdir(summariesDir);
+        const files = await fs22.promises.readdir(summariesDir);
         if (files.length > 0) {
           const count = files.length;
           output.context.push(`[CONTEXT OPTIMIZATION] Tool outputs from earlier in this session have been stored to disk. When compacting, replace any large tool output blocks (bash, test_runner, lint, diff results) with a one-line reference: "[Output stored \u2014 use /swarm retrieve to access full content]". Preserve the tool name, exit status, and any error messages. Discard raw output lines.`);
@@ -52091,8 +52178,8 @@ function maskToolOutput(msg, _threshold) {
 }
 // src/hooks/delegation-gate.ts
 init_schema();
-import * as fs22 from "fs";
-import * as path34 from "path";
+import * as fs23 from "fs";
+import * as path35 from "path";
 
 // src/parallel/review-router.ts
 async function computeComplexity(directory, changedFiles) {
@@ -52104,13 +52191,13 @@ async function computeComplexity(directory, changedFiles) {
       continue;
     }
     try {
-      const fs22 = await import("fs");
-      const path32 = await import("path");
-      const filePath = path32.join(directory, file3);
-      if (!fs22.existsSync(filePath)) {
+      const fs23 = await import("fs");
+      const path33 = await import("path");
+      const filePath = path33.join(directory, file3);
+      if (!fs23.existsSync(filePath)) {
         continue;
       }
-      const content = fs22.readFileSync(filePath, "utf-8");
+      const content = fs23.readFileSync(filePath, "utf-8");
       const functionMatches = content.match(/\b(function|def|func|fn)\s+\w+/g);
       const fileFunctionCount = functionMatches?.length || 0;
       functionCount += fileFunctionCount;
@@ -52158,7 +52245,7 @@ function shouldParallelizeReview(routing) {
 init_telemetry();
 
 // src/hooks/guardrails.ts
-import * as path32 from "path";
+import * as path33 from "path";
 init_constants();
 init_schema();
 
@@ -52320,10 +52407,10 @@ function isArchitect(sessionId) {
 function isOutsideSwarmDir(filePath, directory) {
   if (!filePath)
     return false;
-  const swarmDir = path32.resolve(directory, ".swarm");
-  const resolved = path32.resolve(directory, filePath);
-  const relative4 = path32.relative(swarmDir, resolved);
-  return relative4.startsWith("..") || path32.isAbsolute(relative4);
+  const swarmDir = path33.resolve(directory, ".swarm");
+  const resolved = path33.resolve(directory, filePath);
+  const relative4 = path33.relative(swarmDir, resolved);
+  return relative4.startsWith("..") || path33.isAbsolute(relative4);
 }
 function isSourceCodePath(filePath) {
   if (!filePath)
@@ -52391,13 +52478,13 @@ function getCurrentTaskId(sessionId) {
 }
 function isInDeclaredScope(filePath, scopeEntries, cwd) {
   const dir = cwd ?? process.cwd();
-  const resolvedFile = path32.resolve(dir, filePath);
+  const resolvedFile = path33.resolve(dir, filePath);
   return scopeEntries.some((scope) => {
-    const resolvedScope = path32.resolve(dir, scope);
+    const resolvedScope = path33.resolve(dir, scope);
     if (resolvedFile === resolvedScope)
       return true;
-    const rel = path32.relative(resolvedScope, resolvedFile);
-    return rel.length > 0 && !rel.startsWith("..") && !path32.isAbsolute(rel);
+    const rel = path33.relative(resolvedScope, resolvedFile);
+    return rel.length > 0 && !rel.startsWith("..") && !path33.isAbsolute(rel);
   });
 }
 function createGuardrailsHooks(directory, directoryOrConfig, config3) {
@@ -52593,9 +52680,9 @@ function createGuardrailsHooks(directory, directoryOrConfig, config3) {
     const toolArgs = args2;
     const targetPath = toolArgs?.filePath ?? toolArgs?.path ?? toolArgs?.file ?? toolArgs?.target;
     if (typeof targetPath === "string" && targetPath.length > 0) {
-      const resolvedTarget = path32.resolve(effectiveDirectory, targetPath).toLowerCase();
-      const planMdPath = path32.resolve(effectiveDirectory, ".swarm", "plan.md").toLowerCase();
-      const planJsonPath = path32.resolve(effectiveDirectory, ".swarm", "plan.json").toLowerCase();
+      const resolvedTarget = path33.resolve(effectiveDirectory, targetPath).toLowerCase();
+      const planMdPath = path33.resolve(effectiveDirectory, ".swarm", "plan.md").toLowerCase();
+      const planJsonPath = path33.resolve(effectiveDirectory, ".swarm", "plan.json").toLowerCase();
       if (resolvedTarget === planMdPath || resolvedTarget === planJsonPath) {
         throw new Error("PLAN STATE VIOLATION: Direct writes to .swarm/plan.md and .swarm/plan.json are blocked. " + "plan.md is auto-regenerated from plan.json by PlanSyncWorker. " + "Use update_task_status() to mark tasks complete, " + "phase_complete() for phase transitions, or " + "save_plan to create/restructure plans.");
       }
@@ -52644,9 +52731,9 @@ function createGuardrailsHooks(directory, directoryOrConfig, config3) {
           }
         }
         for (const p of paths) {
-          const resolvedP = path32.resolve(effectiveDirectory, p);
-          const planMdPath = path32.resolve(effectiveDirectory, ".swarm", "plan.md").toLowerCase();
-          const planJsonPath = path32.resolve(effectiveDirectory, ".swarm", "plan.json").toLowerCase();
+          const resolvedP = path33.resolve(effectiveDirectory, p);
+          const planMdPath = path33.resolve(effectiveDirectory, ".swarm", "plan.md").toLowerCase();
+          const planJsonPath = path33.resolve(effectiveDirectory, ".swarm", "plan.json").toLowerCase();
           if (resolvedP.toLowerCase() === planMdPath || resolvedP.toLowerCase() === planJsonPath) {
             throw new Error("PLAN STATE VIOLATION: Direct writes to .swarm/plan.md and .swarm/plan.json are blocked. " + "plan.md is auto-regenerated from plan.json by PlanSyncWorker. " + "Use update_task_status() to mark tasks complete, " + "phase_complete() for phase transitions, or " + "save_plan to create/restructure plans.");
           }
@@ -52666,7 +52753,7 @@ function createGuardrailsHooks(directory, directoryOrConfig, config3) {
         }
       }
     }
-    if (typeof targetPath === "string" && targetPath.length > 0 && isOutsideSwarmDir(targetPath, effectiveDirectory) && isSourceCodePath(path32.relative(effectiveDirectory, path32.resolve(effectiveDirectory, targetPath)))) {
+    if (typeof targetPath === "string" && targetPath.length > 0 && isOutsideSwarmDir(targetPath, effectiveDirectory) && isSourceCodePath(path33.relative(effectiveDirectory, path33.resolve(effectiveDirectory, targetPath)))) {
       const session = swarmState.agentSessions.get(sessionID);
       if (session) {
         session.architectWriteCount++;
@@ -53297,8 +53384,8 @@ var AGENT_AUTHORITY_RULES = {
 function checkFileAuthority(agentName, filePath, cwd) {
   const normalizedAgent = agentName.toLowerCase();
   const dir = cwd || process.cwd();
-  const resolved = path32.resolve(dir, filePath);
-  const normalizedPath = path32.relative(dir, resolved).replace(/\\/g, "/");
+  const resolved = path33.resolve(dir, filePath);
+  const normalizedPath = path33.relative(dir, resolved).replace(/\\/g, "/");
   const rules = AGENT_AUTHORITY_RULES[normalizedAgent];
   if (!rules) {
     return { allowed: false, reason: `Unknown agent: ${agentName}` };
@@ -53380,13 +53467,13 @@ async function getEvidenceTaskId(session, directory) {
     if (typeof directory !== "string" || directory.length === 0) {
       return null;
     }
-    const resolvedDirectory = path34.resolve(directory);
-    const planPath = path34.join(resolvedDirectory, ".swarm", "plan.json");
-    const resolvedPlanPath = path34.resolve(planPath);
-    if (!resolvedPlanPath.startsWith(resolvedDirectory + path34.sep) && resolvedPlanPath !== resolvedDirectory) {
+    const resolvedDirectory = path35.resolve(directory);
+    const planPath = path35.join(resolvedDirectory, ".swarm", "plan.json");
+    const resolvedPlanPath = path35.resolve(planPath);
+    if (!resolvedPlanPath.startsWith(resolvedDirectory + path35.sep) && resolvedPlanPath !== resolvedDirectory) {
       return null;
     }
-    const planContent = await fs22.promises.readFile(resolvedPlanPath, "utf-8");
+    const planContent = await fs23.promises.readFile(resolvedPlanPath, "utf-8");
     const plan = JSON.parse(planContent);
     if (!plan || !Array.isArray(plan.phases)) {
       return null;
@@ -53915,7 +54002,7 @@ ${warningLines.join(`
 }
 // src/hooks/delegation-sanitizer.ts
 init_utils2();
-import * as fs23 from "fs";
+import * as fs24 from "fs";
 var SANITIZATION_PATTERNS = [
   /\b\d+(st|nd|rd|th)\s+(attempt|try|time)\b/gi,
   /\b(5th|fifth|final|last)\s+attempt\b/gi,
@@ -53986,7 +54073,7 @@ function createDelegationSanitizerHook(directory) {
               stripped_patterns: result.stripped,
               timestamp: new Date().toISOString()
             };
-            fs23.appendFileSync(eventsPath, `${JSON.stringify(event)}
+            fs24.appendFileSync(eventsPath, `${JSON.stringify(event)}
 `, "utf-8");
           } catch {}
         }
@@ -54111,7 +54198,7 @@ function consolidateSystemMessages(messages) {
 // src/hooks/phase-monitor.ts
 init_schema();
 init_manager2();
-import * as path35 from "path";
+import * as path36 from "path";
 init_utils2();
 function createPhaseMonitorHook(directory, preflightManager, curatorRunner = runCuratorInit) {
   let lastKnownPhase = null;
@@ -54129,9 +54216,9 @@ function createPhaseMonitorHook(directory, preflightManager, curatorRunner = run
         if (curatorConfig.enabled && curatorConfig.init_enabled) {
           const initResult = await curatorRunner(directory, curatorConfig);
           if (initResult.briefing) {
-            const briefingPath = path35.join(directory, ".swarm", "curator-briefing.md");
+            const briefingPath = path36.join(directory, ".swarm", "curator-briefing.md");
             const { mkdir: mkdir5, writeFile: writeFile5 } = await import("fs/promises");
-            await mkdir5(path35.dirname(briefingPath), { recursive: true });
+            await mkdir5(path36.dirname(briefingPath), { recursive: true });
             await writeFile5(briefingPath, initResult.briefing, "utf-8");
           }
         }
@@ -54243,15 +54330,15 @@ init_schema();
 init_manager();
 init_detector();
 init_manager2();
-import * as fs27 from "fs";
-import * as path39 from "path";
+import * as fs28 from "fs";
+import * as path40 from "path";
 
 // src/services/decision-drift-analyzer.ts
 init_utils2();
 init_manager2();
 init_utils();
-import * as fs24 from "fs";
-import * as path36 from "path";
+import * as fs25 from "fs";
+import * as path37 from "path";
 var DEFAULT_DRIFT_CONFIG = {
   staleThresholdPhases: 1,
   detectContradictions: true,
@@ -54405,11 +54492,11 @@ async function analyzeDecisionDrift(directory, config3 = {}) {
         currentPhase = legacyPhase;
       }
     }
-    const contextPath = path36.join(directory, ".swarm", "context.md");
+    const contextPath = path37.join(directory, ".swarm", "context.md");
     let contextContent = "";
     try {
-      if (fs24.existsSync(contextPath)) {
-        contextContent = fs24.readFileSync(contextPath, "utf-8");
+      if (fs25.existsSync(contextPath)) {
+        contextContent = fs25.readFileSync(contextPath, "utf-8");
       }
     } catch (error93) {
       log("[DecisionDriftAnalyzer] context file read failed", {
@@ -54534,8 +54621,8 @@ init_utils();
 // src/hooks/adversarial-detector.ts
 init_constants();
 init_schema();
-import * as fs25 from "fs/promises";
-import * as path37 from "path";
+import * as fs26 from "fs/promises";
+import * as path38 from "path";
 function safeGet(obj, key) {
   if (!obj || !Object.hasOwn(obj, key))
     return;
@@ -54749,10 +54836,10 @@ async function handleDebuggingSpiral(match, taskId, directory) {
   let eventLogged = false;
   let checkpointCreated = false;
   try {
-    const swarmDir = path37.join(directory, ".swarm");
-    await fs25.mkdir(swarmDir, { recursive: true });
-    const eventsPath = path37.join(swarmDir, "events.jsonl");
-    await fs25.appendFile(eventsPath, `${formatDebuggingSpiralEvent(match, taskId)}
+    const swarmDir = path38.join(directory, ".swarm");
+    await fs26.mkdir(swarmDir, { recursive: true });
+    const eventsPath = path38.join(swarmDir, "events.jsonl");
+    await fs26.appendFile(eventsPath, `${formatDebuggingSpiralEvent(match, taskId)}
 `);
     eventLogged = true;
   } catch {}
@@ -55133,7 +55220,7 @@ function createSystemEnhancerHook(config3, directory) {
         } catch {}
         try {
           const darkMatterPath = validateSwarmPath(directory, "dark-matter.md");
-          if (!fs27.existsSync(darkMatterPath)) {
+          if (!fs28.existsSync(darkMatterPath)) {
             const {
               detectDarkMatter: detectDarkMatter2,
               formatDarkMatterOutput: formatDarkMatterOutput2,
@@ -55141,15 +55228,14 @@ function createSystemEnhancerHook(config3, directory) {
             } = await Promise.resolve().then(() => (init_co_change_analyzer(), exports_co_change_analyzer));
             const darkMatter = await detectDarkMatter2(directory, {
               minCommits: 20,
-              minCoChanges: 3,
-              npmiThreshold: 0.3
+              minCoChanges: 3
             });
             if (darkMatter && darkMatter.length > 0) {
               const darkMatterReport = formatDarkMatterOutput2(darkMatter);
-              await fs27.promises.writeFile(darkMatterPath, darkMatterReport, "utf-8");
+              await fs28.promises.writeFile(darkMatterPath, darkMatterReport, "utf-8");
               warn(`[system-enhancer] Dark matter scan complete: ${darkMatter.length} co-change patterns found`);
               try {
-                const projectName = path39.basename(path39.resolve(directory));
+                const projectName = path40.basename(path40.resolve(directory));
                 const knowledgeEntries = darkMatterToKnowledgeEntries2(darkMatter, projectName);
                 const knowledgePath = resolveSwarmKnowledgePath(directory);
                 const existingEntries = await readKnowledge(knowledgePath);
@@ -55168,6 +55254,19 @@ function createSystemEnhancerHook(config3, directory) {
               }
             }
           }
+          try {
+            const knowledgePath = resolveSwarmKnowledgePath(directory);
+            const allEntries = await readKnowledge(knowledgePath);
+            const stale = allEntries.filter((e) => e.scope === "project" && e.auto_generated === true && Array.isArray(e.tags) && e.tags.includes("dark-matter"));
+            if (stale.length > 0) {
+              for (const e of stale) {
+                e.scope = "global";
+                e.updated_at = new Date().toISOString();
+              }
+              await rewriteKnowledge(knowledgePath, allEntries);
+              warn(`[system-enhancer] Repaired ${stale.length} dark matter knowledge entries (scope: 'project' \u2192 'global')`);
+            }
+          } catch {}
         } catch {}
         const scoringEnabled = config3.context_budget?.scoring?.enabled === true;
         if (!scoringEnabled) {
@@ -55200,11 +55299,11 @@ function createSystemEnhancerHook(config3, directory) {
               if (handoffContent) {
                 const handoffPath = validateSwarmPath(directory, "handoff.md");
                 const consumedPath = validateSwarmPath(directory, "handoff-consumed.md");
-                if (fs27.existsSync(consumedPath)) {
+                if (fs28.existsSync(consumedPath)) {
                   warn("Duplicate handoff detected: handoff-consumed.md already exists");
-                  fs27.unlinkSync(consumedPath);
+                  fs28.unlinkSync(consumedPath);
                 }
-                fs27.renameSync(handoffPath, consumedPath);
+                fs28.renameSync(handoffPath, consumedPath);
                 const handoffBlock = `## HANDOFF \u2014 Resuming from model switch
 The previous model's session ended. Here is your starting context:
 
@@ -55485,11 +55584,11 @@ ${budgetWarning}`);
             if (handoffContent) {
               const handoffPath = validateSwarmPath(directory, "handoff.md");
               const consumedPath = validateSwarmPath(directory, "handoff-consumed.md");
-              if (fs27.existsSync(consumedPath)) {
+              if (fs28.existsSync(consumedPath)) {
                 warn("Duplicate handoff detected: handoff-consumed.md already exists");
-                fs27.unlinkSync(consumedPath);
+                fs28.unlinkSync(consumedPath);
               }
-              fs27.renameSync(handoffPath, consumedPath);
+              fs28.renameSync(handoffPath, consumedPath);
               const handoffBlock = `## HANDOFF \u2014 Resuming from model switch
 The previous model's session ended. Here is your starting context:
 
@@ -56259,14 +56358,14 @@ function isReadTool(toolName) {
 }
 
 // src/hooks/incremental-verify.ts
-import * as fs28 from "fs";
-import * as path40 from "path";
+import * as fs29 from "fs";
+import * as path41 from "path";
 
 // src/hooks/spawn-helper.ts
 import { spawn } from "child_process";
 var WIN32_CMD_BINARIES = new Set(["npm", "npx", "pnpm", "yarn"]);
 function spawnAsync(command, cwd, timeoutMs) {
-  return new Promise((resolve12) => {
+  return new Promise((resolve13) => {
     try {
       const [rawCmd, ...args2] = command;
       const cmd = process.platform === "win32" && WIN32_CMD_BINARIES.has(rawCmd) && !rawCmd.includes(".") ? `${rawCmd}.cmd` : rawCmd;
@@ -56310,24 +56409,24 @@ function spawnAsync(command, cwd, timeoutMs) {
         try {
           proc.kill();
         } catch {}
-        resolve12(null);
+        resolve13(null);
       }, timeoutMs);
       proc.on("close", (code) => {
         if (done)
           return;
         done = true;
         clearTimeout(timer);
-        resolve12({ exitCode: code ?? 1, stdout, stderr });
+        resolve13({ exitCode: code ?? 1, stdout, stderr });
       });
       proc.on("error", () => {
         if (done)
           return;
         done = true;
         clearTimeout(timer);
-        resolve12(null);
+        resolve13(null);
       });
     } catch {
-      resolve12(null);
+      resolve13(null);
     }
   });
 }
@@ -56335,21 +56434,21 @@ function spawnAsync(command, cwd, timeoutMs) {
 // src/hooks/incremental-verify.ts
 var emittedSkipAdvisories = new Set;
 function detectPackageManager(projectDir) {
-  if (fs28.existsSync(path40.join(projectDir, "bun.lockb")))
+  if (fs29.existsSync(path41.join(projectDir, "bun.lockb")))
     return "bun";
-  if (fs28.existsSync(path40.join(projectDir, "pnpm-lock.yaml")))
+  if (fs29.existsSync(path41.join(projectDir, "pnpm-lock.yaml")))
     return "pnpm";
-  if (fs28.existsSync(path40.join(projectDir, "yarn.lock")))
+  if (fs29.existsSync(path41.join(projectDir, "yarn.lock")))
     return "yarn";
-  if (fs28.existsSync(path40.join(projectDir, "package-lock.json")))
+  if (fs29.existsSync(path41.join(projectDir, "package-lock.json")))
     return "npm";
   return "bun";
 }
 function detectTypecheckCommand(projectDir) {
-  const pkgPath = path40.join(projectDir, "package.json");
-  if (fs28.existsSync(pkgPath)) {
+  const pkgPath = path41.join(projectDir, "package.json");
+  if (fs29.existsSync(pkgPath)) {
     try {
-      const pkg = JSON.parse(fs28.readFileSync(pkgPath, "utf8"));
+      const pkg = JSON.parse(fs29.readFileSync(pkgPath, "utf8"));
       const scripts = pkg.scripts;
       if (scripts?.typecheck) {
         const pm = detectPackageManager(projectDir);
@@ -56363,8 +56462,8 @@ function detectTypecheckCommand(projectDir) {
         ...pkg.dependencies,
         ...pkg.devDependencies
       };
-      if (!deps?.typescript && !fs28.existsSync(path40.join(projectDir, "tsconfig.json"))) {}
-      const hasTSMarkers = deps?.typescript || fs28.existsSync(path40.join(projectDir, "tsconfig.json"));
+      if (!deps?.typescript && !fs29.existsSync(path41.join(projectDir, "tsconfig.json"))) {}
+      const hasTSMarkers = deps?.typescript || fs29.existsSync(path41.join(projectDir, "tsconfig.json"));
       if (hasTSMarkers) {
         return { command: ["npx", "tsc", "--noEmit"], language: "typescript" };
       }
@@ -56372,17 +56471,17 @@ function detectTypecheckCommand(projectDir) {
       return null;
     }
   }
-  if (fs28.existsSync(path40.join(projectDir, "go.mod"))) {
+  if (fs29.existsSync(path41.join(projectDir, "go.mod"))) {
     return { command: ["go", "vet", "./..."], language: "go" };
   }
-  if (fs28.existsSync(path40.join(projectDir, "Cargo.toml"))) {
+  if (fs29.existsSync(path41.join(projectDir, "Cargo.toml"))) {
     return { command: ["cargo", "check"], language: "rust" };
   }
-  if (fs28.existsSync(path40.join(projectDir, "pyproject.toml")) || fs28.existsSync(path40.join(projectDir, "requirements.txt")) || fs28.existsSync(path40.join(projectDir, "setup.py"))) {
+  if (fs29.existsSync(path41.join(projectDir, "pyproject.toml")) || fs29.existsSync(path41.join(projectDir, "requirements.txt")) || fs29.existsSync(path41.join(projectDir, "setup.py"))) {
     return { command: null, language: "python" };
   }
   try {
-    const entries = fs28.readdirSync(projectDir);
+    const entries = fs29.readdirSync(projectDir);
     if (entries.some((f) => f.endsWith(".csproj") || f.endsWith(".sln"))) {
       return {
         command: ["dotnet", "build", "--no-restore"],
@@ -56691,7 +56790,7 @@ ${injectionText}`;
 // src/hooks/scope-guard.ts
 init_constants();
 init_schema();
-import * as path42 from "path";
+import * as path43 from "path";
 var WRITE_TOOLS = new Set([
   "write",
   "edit",
@@ -56753,13 +56852,13 @@ function createScopeGuardHook(config3, directory, injectAdvisory) {
 }
 function isFileInScope(filePath, scopeEntries, directory) {
   const dir = directory ?? process.cwd();
-  const resolvedFile = path42.resolve(dir, filePath);
+  const resolvedFile = path43.resolve(dir, filePath);
   return scopeEntries.some((scope) => {
-    const resolvedScope = path42.resolve(dir, scope);
+    const resolvedScope = path43.resolve(dir, scope);
     if (resolvedFile === resolvedScope)
       return true;
-    const rel = path42.relative(resolvedScope, resolvedFile);
-    return rel.length > 0 && !rel.startsWith("..") && !path42.isAbsolute(rel);
+    const rel = path43.relative(resolvedScope, resolvedFile);
+    return rel.length > 0 && !rel.startsWith("..") && !path43.isAbsolute(rel);
   });
 }
 
@@ -56808,8 +56907,8 @@ function createSelfReviewHook(config3, injectAdvisory) {
 }
 
 // src/hooks/slop-detector.ts
-import * as fs30 from "fs";
-import * as path43 from "path";
+import * as fs31 from "fs";
+import * as path44 from "path";
 var WRITE_EDIT_TOOLS = new Set([
   "write",
   "edit",
@@ -56854,12 +56953,12 @@ function checkBoilerplateExplosion(content, taskDescription, threshold) {
 function walkFiles(dir, exts, deadline) {
   const results = [];
   try {
-    for (const entry of fs30.readdirSync(dir, { withFileTypes: true })) {
+    for (const entry of fs31.readdirSync(dir, { withFileTypes: true })) {
       if (deadline !== undefined && Date.now() > deadline)
         break;
       if (entry.isSymbolicLink())
         continue;
-      const full = path43.join(dir, entry.name);
+      const full = path44.join(dir, entry.name);
       if (entry.isDirectory()) {
         if (entry.name === "node_modules" || entry.name === ".git")
           continue;
@@ -56874,7 +56973,7 @@ function walkFiles(dir, exts, deadline) {
   return results;
 }
 function checkDeadExports(content, projectDir, startTime) {
-  const hasPackageJson = fs30.existsSync(path43.join(projectDir, "package.json"));
+  const hasPackageJson = fs31.existsSync(path44.join(projectDir, "package.json"));
   if (!hasPackageJson)
     return null;
   const exportMatches = content.matchAll(/^\+(?:export)\s+(?:function|class|const|type|interface)\s+(\w{3,})/gm);
@@ -56897,7 +56996,7 @@ function checkDeadExports(content, projectDir, startTime) {
         if (found || Date.now() - startTime > 480)
           break;
         try {
-          const text = fs30.readFileSync(file3, "utf-8");
+          const text = fs31.readFileSync(file3, "utf-8");
           if (importPattern.test(text))
             found = true;
           importPattern.lastIndex = 0;
@@ -57030,7 +57129,7 @@ Review before proceeding.`;
 
 // src/hooks/steering-consumed.ts
 init_utils2();
-import * as fs31 from "fs";
+import * as fs32 from "fs";
 function recordSteeringConsumed(directory, directiveId) {
   try {
     const eventsPath = validateSwarmPath(directory, "events.jsonl");
@@ -57039,7 +57138,7 @@ function recordSteeringConsumed(directory, directiveId) {
       directiveId,
       timestamp: new Date().toISOString()
     };
-    fs31.appendFileSync(eventsPath, `${JSON.stringify(event)}
+    fs32.appendFileSync(eventsPath, `${JSON.stringify(event)}
 `, "utf-8");
   } catch {}
 }
@@ -57329,21 +57428,24 @@ async function executeCommand(command) {
     cmd = ["/bin/sh"];
     args2 = ["-c", command.command];
   }
-  const result = await Bun.spawn({
+  const result = Bun.spawn({
     cmd: [...cmd, ...args2],
     cwd: command.cwd,
     stdout: "pipe",
     stderr: "pipe",
     timeout: DEFAULT_TIMEOUT_MS2
   });
+  const [exitCode, stdout, stderr] = await Promise.all([
+    result.exited,
+    new Response(result.stdout).text(),
+    new Response(result.stderr).text()
+  ]);
   const duration_ms = Date.now() - startTime;
-  const stdout = await new Response(result.stdout).text();
-  const stderr = await new Response(result.stderr).text();
   return {
     kind,
     command: command.command,
     cwd: command.cwd,
-    exit_code: result.exitCode ?? -1,
+    exit_code: exitCode ?? -1,
     duration_ms,
     stdout_tail: truncateOutput(stdout),
     stderr_tail: truncateOutput(stderr)
@@ -57448,8 +57550,9 @@ var build_check = createSwarmTool({
 init_dist();
 init_manager();
 init_create_tool();
-import * as fs32 from "fs";
-import * as path44 from "path";
+init_resolve_working_directory();
+import * as fs33 from "fs";
+import * as path45 from "path";
 var EVIDENCE_DIR = ".swarm/evidence";
 var TASK_ID_PATTERN2 = /^\d+\.\d+(\.\d+)*$/;
 function isValidTaskId3(taskId) {
@@ -57466,18 +57569,18 @@ function isValidTaskId3(taskId) {
   return TASK_ID_PATTERN2.test(taskId);
 }
 function isPathWithinSwarm(filePath, workspaceRoot) {
-  const normalizedWorkspace = path44.resolve(workspaceRoot);
-  const swarmPath = path44.join(normalizedWorkspace, ".swarm", "evidence");
-  const normalizedPath = path44.resolve(filePath);
+  const normalizedWorkspace = path45.resolve(workspaceRoot);
+  const swarmPath = path45.join(normalizedWorkspace, ".swarm", "evidence");
+  const normalizedPath = path45.resolve(filePath);
   return normalizedPath.startsWith(swarmPath);
 }
 function readEvidenceFile(evidencePath) {
-  if (!fs32.existsSync(evidencePath)) {
+  if (!fs33.existsSync(evidencePath)) {
     return null;
   }
   let content;
   try {
-    content = fs32.readFileSync(evidencePath, "utf-8");
+    content = fs33.readFileSync(evidencePath, "utf-8");
   } catch {
     return null;
   }
@@ -57495,16 +57598,34 @@ function readEvidenceFile(evidencePath) {
 var check_gate_status = createSwarmTool({
   description: "Read-only tool to check the gate status of a specific task. Reads .swarm/evidence/{taskId}.json and returns structured JSON describing required, passed, and missing gates.",
   args: {
-    task_id: tool.schema.string().min(1).regex(/^\d+\.\d+(\.\d+)*$/, 'Task ID must be in N.M or N.M.P format (e.g., "1.1", "1.2.3", "1.2.3.4")').describe('The task ID to check gate status for (e.g., "1.1", "2.3.1")')
+    task_id: tool.schema.string().min(1).regex(/^\d+\.\d+(\.\d+)*$/, 'Task ID must be in N.M or N.M.P format (e.g., "1.1", "1.2.3", "1.2.3.4")').describe('The task ID to check gate status for (e.g., "1.1", "2.3.1")'),
+    working_directory: tool.schema.string().optional().describe("Explicit project root directory. When provided, .swarm/evidence/ is resolved relative to this path instead of the plugin context directory. Use this when CWD differs from the actual project root.")
   },
   async execute(args2, directory) {
     let taskIdInput;
+    let workingDirInput;
     try {
       if (args2 && typeof args2 === "object") {
         const obj = args2;
         taskIdInput = typeof obj.task_id === "string" ? obj.task_id : undefined;
+        workingDirInput = typeof obj.working_directory === "string" ? obj.working_directory : undefined;
       }
     } catch {}
+    const dirResult = resolveWorkingDirectory(workingDirInput, directory);
+    if (!dirResult.success) {
+      const errorResult = {
+        taskId: taskIdInput ?? "",
+        status: "no_evidence",
+        required_gates: [],
+        passed_gates: [],
+        missing_gates: [],
+        gates: {},
+        message: dirResult.message,
+        todo_scan: null
+      };
+      return JSON.stringify(errorResult, null, 2);
+    }
+    directory = dirResult.directory;
     if (!taskIdInput) {
       const errorResult = {
         taskId: "",
@@ -57531,7 +57652,7 @@ var check_gate_status = createSwarmTool({
       };
       return JSON.stringify(errorResult, null, 2);
     }
-    const evidencePath = path44.join(directory, EVIDENCE_DIR, `${taskIdInput}.json`);
+    const evidencePath = path45.join(directory, EVIDENCE_DIR, `${taskIdInput}.json`);
     if (!isPathWithinSwarm(evidencePath, directory)) {
       const errorResult = {
         taskId: taskIdInput,
@@ -57624,9 +57745,10 @@ init_co_change_analyzer();
 // src/tools/completion-verify.ts
 init_dist();
 init_utils2();
-import * as fs33 from "fs";
-import * as path45 from "path";
+import * as fs34 from "fs";
+import * as path46 from "path";
 init_create_tool();
+init_resolve_working_directory();
 function extractMatches(regex, text) {
   return Array.from(text.matchAll(regex));
 }
@@ -57720,7 +57842,7 @@ async function executeCompletionVerify(args2, directory) {
   let plan;
   try {
     const planPath = validateSwarmPath(directory, "plan.json");
-    const planRaw = fs33.readFileSync(planPath, "utf-8");
+    const planRaw = fs34.readFileSync(planPath, "utf-8");
     plan = JSON.parse(planRaw);
   } catch {
     const result2 = {
@@ -57778,10 +57900,10 @@ async function executeCompletionVerify(args2, directory) {
     let hasFileReadFailure = false;
     for (const filePath of fileTargets) {
       const normalizedPath = filePath.replace(/\\/g, "/");
-      const resolvedPath = path45.resolve(directory, normalizedPath);
-      const projectRoot = path45.resolve(directory);
-      const relative6 = path45.relative(projectRoot, resolvedPath);
-      const withinProject = relative6 === "" || !relative6.startsWith("..") && !path45.isAbsolute(relative6);
+      const resolvedPath = path46.resolve(directory, normalizedPath);
+      const projectRoot = path46.resolve(directory);
+      const relative6 = path46.relative(projectRoot, resolvedPath);
+      const withinProject = relative6 === "" || !relative6.startsWith("..") && !path46.isAbsolute(relative6);
       if (!withinProject) {
         blockedTasks.push({
           task_id: task.id,
@@ -57794,7 +57916,7 @@ async function executeCompletionVerify(args2, directory) {
       }
       let fileContent;
       try {
-        fileContent = fs33.readFileSync(resolvedPath, "utf-8");
+        fileContent = fs34.readFileSync(resolvedPath, "utf-8");
       } catch {
         blockedTasks.push({
           task_id: task.id,
@@ -57836,9 +57958,9 @@ async function executeCompletionVerify(args2, directory) {
     blockedTasks
   };
   try {
-    const evidenceDir = path45.join(directory, ".swarm", "evidence", `${phase}`);
-    const evidencePath = path45.join(evidenceDir, "completion-verify.json");
-    fs33.mkdirSync(evidenceDir, { recursive: true });
+    const evidenceDir = path46.join(directory, ".swarm", "evidence", `${phase}`);
+    const evidencePath = path46.join(evidenceDir, "completion-verify.json");
+    fs34.mkdirSync(evidenceDir, { recursive: true });
     const evidenceBundle = {
       schema_version: "1.0.0",
       task_id: "completion-verify",
@@ -57859,7 +57981,7 @@ async function executeCompletionVerify(args2, directory) {
         }
       ]
     };
-    fs33.writeFileSync(evidencePath, JSON.stringify(evidenceBundle, null, 2), "utf-8");
+    fs34.writeFileSync(evidencePath, JSON.stringify(evidenceBundle, null, 2), "utf-8");
   } catch {}
   return JSON.stringify(result, null, 2);
 }
@@ -57867,7 +57989,8 @@ var completion_verify = createSwarmTool({
   description: "Deterministic pre-check verifying that plan task identifiers exist in their target source files before phase completion. Blocks if obviously incomplete.",
   args: {
     phase: tool.schema.number().describe("The phase number to check"),
-    sessionID: tool.schema.string().optional().describe("Session ID for tracking state (auto-provided by plugin context)")
+    sessionID: tool.schema.string().optional().describe("Session ID for tracking state (auto-provided by plugin context)"),
+    working_directory: tool.schema.string().optional().describe("Explicit project root directory. When provided, .swarm/ is resolved relative to this path instead of the plugin context directory. Use this when CWD differs from the actual project root.")
   },
   execute: async (args2, directory) => {
     let parsedArgs;
@@ -57876,7 +57999,8 @@ var completion_verify = createSwarmTool({
         const obj = args2;
         parsedArgs = {
           phase: typeof obj.phase === "number" ? obj.phase : typeof obj.phase === "string" ? Number(obj.phase) : 0,
-          sessionID: typeof obj.sessionID === "string" ? obj.sessionID : undefined
+          sessionID: typeof obj.sessionID === "string" ? obj.sessionID : undefined,
+          working_directory: typeof obj.working_directory === "string" ? obj.working_directory : undefined
         };
       } else {
         parsedArgs = { phase: 0 };
@@ -57893,17 +58017,30 @@ var completion_verify = createSwarmTool({
         blockedTasks: []
       }, null, 2);
     }
-    return executeCompletionVerify(parsedArgs, directory);
+    const dirResult = resolveWorkingDirectory(parsedArgs.working_directory, directory);
+    if (!dirResult.success) {
+      return JSON.stringify({
+        success: false,
+        phase: parsedArgs.phase,
+        status: "blocked",
+        reason: dirResult.message,
+        tasksChecked: 0,
+        tasksSkipped: 0,
+        tasksBlocked: 0,
+        blockedTasks: []
+      }, null, 2);
+    }
+    return executeCompletionVerify(parsedArgs, dirResult.directory);
   }
 });
 // src/tools/complexity-hotspots.ts
 init_dist();
-import * as fs35 from "fs";
-import * as path47 from "path";
+import * as fs36 from "fs";
+import * as path48 from "path";
 
 // src/quality/metrics.ts
-import * as fs34 from "fs";
-import * as path46 from "path";
+import * as fs35 from "fs";
+import * as path47 from "path";
 var MAX_FILE_SIZE_BYTES2 = 256 * 1024;
 var MIN_DUPLICATION_LINES = 10;
 function estimateCyclomaticComplexity(content) {
@@ -57941,11 +58078,11 @@ function estimateCyclomaticComplexity(content) {
 }
 function getComplexityForFile(filePath) {
   try {
-    const stat2 = fs34.statSync(filePath);
+    const stat2 = fs35.statSync(filePath);
     if (stat2.size > MAX_FILE_SIZE_BYTES2) {
       return null;
     }
-    const content = fs34.readFileSync(filePath, "utf-8");
+    const content = fs35.readFileSync(filePath, "utf-8");
     return estimateCyclomaticComplexity(content);
   } catch {
     return null;
@@ -57955,8 +58092,8 @@ async function computeComplexityDelta(files, workingDir) {
   let totalComplexity = 0;
   const analyzedFiles = [];
   for (const file3 of files) {
-    const fullPath = path46.isAbsolute(file3) ? file3 : path46.join(workingDir, file3);
-    if (!fs34.existsSync(fullPath)) {
+    const fullPath = path47.isAbsolute(file3) ? file3 : path47.join(workingDir, file3);
+    if (!fs35.existsSync(fullPath)) {
       continue;
     }
     const complexity = getComplexityForFile(fullPath);
@@ -58077,8 +58214,8 @@ function countGoExports(content) {
 }
 function getExportCountForFile(filePath) {
   try {
-    const content = fs34.readFileSync(filePath, "utf-8");
-    const ext = path46.extname(filePath).toLowerCase();
+    const content = fs35.readFileSync(filePath, "utf-8");
+    const ext = path47.extname(filePath).toLowerCase();
     switch (ext) {
       case ".ts":
       case ".tsx":
@@ -58104,8 +58241,8 @@ async function computePublicApiDelta(files, workingDir) {
   let totalExports = 0;
   const analyzedFiles = [];
   for (const file3 of files) {
-    const fullPath = path46.isAbsolute(file3) ? file3 : path46.join(workingDir, file3);
-    if (!fs34.existsSync(fullPath)) {
+    const fullPath = path47.isAbsolute(file3) ? file3 : path47.join(workingDir, file3);
+    if (!fs35.existsSync(fullPath)) {
       continue;
     }
     const exports = getExportCountForFile(fullPath);
@@ -58138,16 +58275,16 @@ async function computeDuplicationRatio(files, workingDir) {
   let duplicateLines = 0;
   const analyzedFiles = [];
   for (const file3 of files) {
-    const fullPath = path46.isAbsolute(file3) ? file3 : path46.join(workingDir, file3);
-    if (!fs34.existsSync(fullPath)) {
+    const fullPath = path47.isAbsolute(file3) ? file3 : path47.join(workingDir, file3);
+    if (!fs35.existsSync(fullPath)) {
       continue;
     }
     try {
-      const stat2 = fs34.statSync(fullPath);
+      const stat2 = fs35.statSync(fullPath);
       if (stat2.size > MAX_FILE_SIZE_BYTES2) {
         continue;
       }
-      const content = fs34.readFileSync(fullPath, "utf-8");
+      const content = fs35.readFileSync(fullPath, "utf-8");
       const lines = content.split(`
 `).filter((line) => line.trim().length > 0);
       if (lines.length < MIN_DUPLICATION_LINES) {
@@ -58171,8 +58308,8 @@ function countCodeLines(content) {
   return lines.length;
 }
 function isTestFile(filePath) {
-  const basename7 = path46.basename(filePath);
-  const _ext = path46.extname(filePath).toLowerCase();
+  const basename7 = path47.basename(filePath);
+  const _ext = path47.extname(filePath).toLowerCase();
   const testPatterns = [
     ".test.",
     ".spec.",
@@ -58253,8 +58390,8 @@ function matchGlobSegment(globSegments, pathSegments) {
   }
   return gIndex === globSegments.length && pIndex === pathSegments.length;
 }
-function matchesGlobSegment(path47, glob) {
-  const normalizedPath = path47.replace(/\\/g, "/");
+function matchesGlobSegment(path48, glob) {
+  const normalizedPath = path48.replace(/\\/g, "/");
   const normalizedGlob = glob.replace(/\\/g, "/");
   if (normalizedPath.includes("//")) {
     return false;
@@ -58285,8 +58422,8 @@ function simpleGlobToRegex2(glob) {
 function hasGlobstar(glob) {
   return glob.includes("**");
 }
-function globMatches(path47, glob) {
-  const normalizedPath = path47.replace(/\\/g, "/");
+function globMatches(path48, glob) {
+  const normalizedPath = path48.replace(/\\/g, "/");
   if (!glob || glob === "") {
     if (normalizedPath.includes("//")) {
       return false;
@@ -58322,31 +58459,31 @@ function shouldExcludeFile(filePath, excludeGlobs) {
 async function computeTestToCodeRatio(workingDir, enforceGlobs, excludeGlobs) {
   let testLines = 0;
   let codeLines = 0;
-  const srcDir = path46.join(workingDir, "src");
-  if (fs34.existsSync(srcDir)) {
+  const srcDir = path47.join(workingDir, "src");
+  if (fs35.existsSync(srcDir)) {
     await scanDirectoryForLines(srcDir, enforceGlobs, excludeGlobs, false, (lines) => {
       codeLines += lines;
     });
   }
   const possibleSrcDirs = ["lib", "app", "source", "core"];
   for (const dir of possibleSrcDirs) {
-    const dirPath = path46.join(workingDir, dir);
-    if (fs34.existsSync(dirPath)) {
+    const dirPath = path47.join(workingDir, dir);
+    if (fs35.existsSync(dirPath)) {
       await scanDirectoryForLines(dirPath, enforceGlobs, excludeGlobs, false, (lines) => {
         codeLines += lines;
       });
     }
   }
-  const testsDir = path46.join(workingDir, "tests");
-  if (fs34.existsSync(testsDir)) {
+  const testsDir = path47.join(workingDir, "tests");
+  if (fs35.existsSync(testsDir)) {
     await scanDirectoryForLines(testsDir, ["**"], ["node_modules", "dist"], true, (lines) => {
       testLines += lines;
     });
   }
   const possibleTestDirs = ["test", "__tests__", "specs"];
   for (const dir of possibleTestDirs) {
-    const dirPath = path46.join(workingDir, dir);
-    if (fs34.existsSync(dirPath) && dirPath !== testsDir) {
+    const dirPath = path47.join(workingDir, dir);
+    if (fs35.existsSync(dirPath) && dirPath !== testsDir) {
       await scanDirectoryForLines(dirPath, ["**"], ["node_modules", "dist"], true, (lines) => {
         testLines += lines;
       });
@@ -58358,9 +58495,9 @@ async function computeTestToCodeRatio(workingDir, enforceGlobs, excludeGlobs) {
 }
 async function scanDirectoryForLines(dirPath, includeGlobs, excludeGlobs, isTestScan, callback) {
   try {
-    const entries = fs34.readdirSync(dirPath, { withFileTypes: true });
+    const entries = fs35.readdirSync(dirPath, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = path46.join(dirPath, entry.name);
+      const fullPath = path47.join(dirPath, entry.name);
       if (entry.isDirectory()) {
         if (entry.name === "node_modules" || entry.name === "dist" || entry.name === "build" || entry.name === ".git") {
           continue;
@@ -58368,7 +58505,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 = path46.extname(entry.name).toLowerCase();
+        const ext = path47.extname(entry.name).toLowerCase();
         const validExts = [
           ".ts",
           ".tsx",
@@ -58404,7 +58541,7 @@ async function scanDirectoryForLines(dirPath, includeGlobs, excludeGlobs, isTest
             continue;
         }
         try {
-          const content = fs34.readFileSync(fullPath, "utf-8");
+          const content = fs35.readFileSync(fullPath, "utf-8");
           const lines = countCodeLines(content);
           callback(lines);
         } catch {}
@@ -58583,8 +58720,10 @@ async function getGitChurn(days, directory) {
     stderr: "pipe",
     cwd: directory
   });
-  const stdout = await new Response(proc.stdout).text();
-  await proc.exited;
+  const [stdout] = await Promise.all([
+    new Response(proc.stdout).text(),
+    proc.exited
+  ]);
   const lines = stdout.split(/\r?\n/);
   for (const line of lines) {
     const normalizedPath = line.replace(/\\/g, "/");
@@ -58603,11 +58742,11 @@ async function getGitChurn(days, directory) {
 }
 function getComplexityForFile2(filePath) {
   try {
-    const stat2 = fs35.statSync(filePath);
+    const stat2 = fs36.statSync(filePath);
     if (stat2.size > MAX_FILE_SIZE_BYTES3) {
       return null;
     }
-    const content = fs35.readFileSync(filePath, "utf-8");
+    const content = fs36.readFileSync(filePath, "utf-8");
     return estimateCyclomaticComplexity(content);
   } catch {
     return null;
@@ -58618,7 +58757,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 = path47.extname(file3).toLowerCase();
+    const ext = path48.extname(file3).toLowerCase();
     if (extSet.has(ext)) {
       filteredChurn.set(file3, count);
     }
@@ -58628,8 +58767,8 @@ async function analyzeHotspots(days, topN, extensions, directory) {
   let analyzedFiles = 0;
   for (const [file3, churnCount] of filteredChurn) {
     let fullPath = file3;
-    if (!fs35.existsSync(fullPath)) {
-      fullPath = path47.join(cwd, file3);
+    if (!fs36.existsSync(fullPath)) {
+      fullPath = path48.join(cwd, file3);
     }
     const complexity = getComplexityForFile2(fullPath);
     if (complexity !== null) {
@@ -58837,8 +58976,8 @@ var curator_analyze = createSwarmTool({
 });
 // src/tools/declare-scope.ts
 init_tool();
-import * as fs36 from "fs";
-import * as path48 from "path";
+import * as fs37 from "fs";
+import * as path49 from "path";
 init_create_tool();
 function validateTaskIdFormat(taskId) {
   const taskIdPattern = /^\d+\.\d+(\.\d+)*$/;
@@ -58917,8 +59056,8 @@ async function executeDeclareScope(args2, fallbackDir) {
         };
       }
     }
-    normalizedDir = path48.normalize(args2.working_directory);
-    const pathParts = normalizedDir.split(path48.sep);
+    normalizedDir = path49.normalize(args2.working_directory);
+    const pathParts = normalizedDir.split(path49.sep);
     if (pathParts.includes("..")) {
       return {
         success: false,
@@ -58928,11 +59067,11 @@ async function executeDeclareScope(args2, fallbackDir) {
         ]
       };
     }
-    const resolvedDir = path48.resolve(normalizedDir);
+    const resolvedDir = path49.resolve(normalizedDir);
     try {
-      const realPath = fs36.realpathSync(resolvedDir);
-      const planPath2 = path48.join(realPath, ".swarm", "plan.json");
-      if (!fs36.existsSync(planPath2)) {
+      const realPath = fs37.realpathSync(resolvedDir);
+      const planPath2 = path49.join(realPath, ".swarm", "plan.json");
+      if (!fs37.existsSync(planPath2)) {
         return {
           success: false,
           message: `Invalid working_directory: plan not found in "${realPath}"`,
@@ -58955,8 +59094,8 @@ async function executeDeclareScope(args2, fallbackDir) {
     console.warn("[declare-scope] fallbackDir is undefined, falling back to process.cwd()");
   }
   const directory = normalizedDir || fallbackDir;
-  const planPath = path48.resolve(directory, ".swarm", "plan.json");
-  if (!fs36.existsSync(planPath)) {
+  const planPath = path49.resolve(directory, ".swarm", "plan.json");
+  if (!fs37.existsSync(planPath)) {
     return {
       success: false,
       message: "No plan found",
@@ -58965,7 +59104,7 @@ async function executeDeclareScope(args2, fallbackDir) {
   }
   let planContent;
   try {
-    planContent = JSON.parse(fs36.readFileSync(planPath, "utf-8"));
+    planContent = JSON.parse(fs37.readFileSync(planPath, "utf-8"));
   } catch {
     return {
       success: false,
@@ -58997,8 +59136,8 @@ async function executeDeclareScope(args2, fallbackDir) {
   const normalizeErrors = [];
   const dir = normalizedDir || fallbackDir || process.cwd();
   const mergedFiles = rawMergedFiles.map((file3) => {
-    if (path48.isAbsolute(file3)) {
-      const relativePath = path48.relative(dir, file3).replace(/\\/g, "/");
+    if (path49.isAbsolute(file3)) {
+      const relativePath = path49.relative(dir, file3).replace(/\\/g, "/");
       if (relativePath.startsWith("..")) {
         normalizeErrors.push(`Path '${file3}' resolves outside the project directory`);
         return file3;
@@ -59324,20 +59463,20 @@ function validateBase(base) {
 function validatePaths(paths) {
   if (!paths)
     return null;
-  for (const path50 of paths) {
-    if (!path50 || path50.length === 0) {
+  for (const path51 of paths) {
+    if (!path51 || path51.length === 0) {
       return "empty path not allowed";
     }
-    if (path50.length > MAX_PATH_LENGTH) {
+    if (path51.length > MAX_PATH_LENGTH) {
       return `path exceeds maximum length of ${MAX_PATH_LENGTH}`;
     }
-    if (SHELL_METACHARACTERS2.test(path50)) {
+    if (SHELL_METACHARACTERS2.test(path51)) {
       return "path contains shell metacharacters";
     }
-    if (path50.startsWith("-")) {
+    if (path51.startsWith("-")) {
       return 'path cannot start with "-" (option-like arguments not allowed)';
     }
-    if (CONTROL_CHAR_PATTERN2.test(path50)) {
+    if (CONTROL_CHAR_PATTERN2.test(path51)) {
       return "path contains control characters";
     }
   }
@@ -59418,8 +59557,8 @@ var diff = createSwarmTool({
         if (parts2.length >= 3) {
           const additions = parseInt(parts2[0], 10) || 0;
           const deletions = parseInt(parts2[1], 10) || 0;
-          const path50 = parts2[2];
-          files.push({ path: path50, additions, deletions });
+          const path51 = parts2[2];
+          files.push({ path: path51, additions, deletions });
         }
       }
       const contractChanges = [];
@@ -59701,8 +59840,8 @@ Use these as DOMAIN values when delegating to @sme.`;
 // src/tools/evidence-check.ts
 init_dist();
 init_create_tool();
-import * as fs37 from "fs";
-import * as path50 from "path";
+import * as fs38 from "fs";
+import * as path51 from "path";
 var MAX_FILE_SIZE_BYTES4 = 1024 * 1024;
 var MAX_EVIDENCE_FILES = 1000;
 var EVIDENCE_DIR2 = ".swarm/evidence";
@@ -59729,9 +59868,9 @@ function validateRequiredTypes(input) {
   return null;
 }
 function isPathWithinSwarm2(filePath, cwd) {
-  const normalizedCwd = path50.resolve(cwd);
-  const swarmPath = path50.join(normalizedCwd, ".swarm");
-  const normalizedPath = path50.resolve(filePath);
+  const normalizedCwd = path51.resolve(cwd);
+  const swarmPath = path51.join(normalizedCwd, ".swarm");
+  const normalizedPath = path51.resolve(filePath);
   return normalizedPath.startsWith(swarmPath);
 }
 function parseCompletedTasks(planContent) {
@@ -59747,12 +59886,12 @@ function parseCompletedTasks(planContent) {
 }
 function readEvidenceFiles(evidenceDir, _cwd) {
   const evidence = [];
-  if (!fs37.existsSync(evidenceDir) || !fs37.statSync(evidenceDir).isDirectory()) {
+  if (!fs38.existsSync(evidenceDir) || !fs38.statSync(evidenceDir).isDirectory()) {
     return evidence;
   }
   let files;
   try {
-    files = fs37.readdirSync(evidenceDir);
+    files = fs38.readdirSync(evidenceDir);
   } catch {
     return evidence;
   }
@@ -59761,14 +59900,14 @@ function readEvidenceFiles(evidenceDir, _cwd) {
     if (!VALID_EVIDENCE_FILENAME_REGEX.test(filename)) {
       continue;
     }
-    const filePath = path50.join(evidenceDir, filename);
+    const filePath = path51.join(evidenceDir, filename);
     try {
-      const resolvedPath = path50.resolve(filePath);
-      const evidenceDirResolved = path50.resolve(evidenceDir);
+      const resolvedPath = path51.resolve(filePath);
+      const evidenceDirResolved = path51.resolve(evidenceDir);
       if (!resolvedPath.startsWith(evidenceDirResolved)) {
         continue;
       }
-      const stat2 = fs37.lstatSync(filePath);
+      const stat2 = fs38.lstatSync(filePath);
       if (!stat2.isFile()) {
         continue;
       }
@@ -59777,7 +59916,7 @@ function readEvidenceFiles(evidenceDir, _cwd) {
     }
     let fileStat;
     try {
-      fileStat = fs37.statSync(filePath);
+      fileStat = fs38.statSync(filePath);
       if (fileStat.size > MAX_FILE_SIZE_BYTES4) {
         continue;
       }
@@ -59786,7 +59925,7 @@ function readEvidenceFiles(evidenceDir, _cwd) {
     }
     let content;
     try {
-      content = fs37.readFileSync(filePath, "utf-8");
+      content = fs38.readFileSync(filePath, "utf-8");
     } catch {
       continue;
     }
@@ -59882,7 +60021,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 = path50.join(cwd, PLAN_FILE);
+    const planPath = path51.join(cwd, PLAN_FILE);
     if (!isPathWithinSwarm2(planPath, cwd)) {
       const errorResult = {
         error: "plan file path validation failed",
@@ -59896,7 +60035,7 @@ var evidence_check = createSwarmTool({
     }
     let planContent;
     try {
-      planContent = fs37.readFileSync(planPath, "utf-8");
+      planContent = fs38.readFileSync(planPath, "utf-8");
     } catch {
       const result2 = {
         message: "No completed tasks found in plan.",
@@ -59914,7 +60053,7 @@ var evidence_check = createSwarmTool({
       };
       return JSON.stringify(result2, null, 2);
     }
-    const evidenceDir = path50.join(cwd, EVIDENCE_DIR2);
+    const evidenceDir = path51.join(cwd, EVIDENCE_DIR2);
     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;
@@ -59931,8 +60070,8 @@ var evidence_check = createSwarmTool({
 // src/tools/file-extractor.ts
 init_tool();
 init_create_tool();
-import * as fs38 from "fs";
-import * as path51 from "path";
+import * as fs39 from "fs";
+import * as path52 from "path";
 var EXT_MAP = {
   python: ".py",
   py: ".py",
@@ -59994,8 +60133,8 @@ var extract_code_blocks = createSwarmTool({
   execute: async (args2, directory) => {
     const { content, output_dir, prefix } = args2;
     const targetDir = output_dir || directory;
-    if (!fs38.existsSync(targetDir)) {
-      fs38.mkdirSync(targetDir, { recursive: true });
+    if (!fs39.existsSync(targetDir)) {
+      fs39.mkdirSync(targetDir, { recursive: true });
     }
     if (!content) {
       return "Error: content is required";
@@ -60013,16 +60152,16 @@ var extract_code_blocks = createSwarmTool({
       if (prefix) {
         filename = `${prefix}_${filename}`;
       }
-      let filepath = path51.join(targetDir, filename);
-      const base = path51.basename(filepath, path51.extname(filepath));
-      const ext = path51.extname(filepath);
+      let filepath = path52.join(targetDir, filename);
+      const base = path52.basename(filepath, path52.extname(filepath));
+      const ext = path52.extname(filepath);
       let counter = 1;
-      while (fs38.existsSync(filepath)) {
-        filepath = path51.join(targetDir, `${base}_${counter}${ext}`);
+      while (fs39.existsSync(filepath)) {
+        filepath = path52.join(targetDir, `${base}_${counter}${ext}`);
         counter++;
       }
       try {
-        fs38.writeFileSync(filepath, code.trim(), "utf-8");
+        fs39.writeFileSync(filepath, code.trim(), "utf-8");
         savedFiles.push(filepath);
       } catch (error93) {
         errors5.push(`Failed to save ${filename}: ${error93 instanceof Error ? error93.message : String(error93)}`);
@@ -60052,7 +60191,7 @@ init_create_tool();
 var GITINGEST_TIMEOUT_MS = 1e4;
 var GITINGEST_MAX_RESPONSE_BYTES = 5242880;
 var GITINGEST_MAX_RETRIES = 2;
-var delay = (ms) => new Promise((resolve17) => setTimeout(resolve17, ms));
+var delay = (ms) => new Promise((resolve18) => setTimeout(resolve18, ms));
 async function fetchGitingest(args2) {
   for (let attempt = 0;attempt <= GITINGEST_MAX_RETRIES; attempt++) {
     try {
@@ -60138,8 +60277,8 @@ var gitingest = createSwarmTool({
 // src/tools/imports.ts
 init_dist();
 init_create_tool();
-import * as fs39 from "fs";
-import * as path52 from "path";
+import * as fs40 from "fs";
+import * as path53 from "path";
 var MAX_FILE_PATH_LENGTH2 = 500;
 var MAX_SYMBOL_LENGTH = 256;
 var MAX_FILE_SIZE_BYTES5 = 1024 * 1024;
@@ -60187,7 +60326,7 @@ function validateSymbolInput(symbol3) {
   return null;
 }
 function isBinaryFile2(filePath, buffer) {
-  const ext = path52.extname(filePath).toLowerCase();
+  const ext = path53.extname(filePath).toLowerCase();
   if (ext === ".json" || ext === ".md" || ext === ".txt") {
     return false;
   }
@@ -60211,15 +60350,15 @@ function parseImports(content, targetFile, targetSymbol) {
   const imports = [];
   let _resolvedTarget;
   try {
-    _resolvedTarget = path52.resolve(targetFile);
+    _resolvedTarget = path53.resolve(targetFile);
   } catch {
     _resolvedTarget = targetFile;
   }
-  const targetBasename = path52.basename(targetFile, path52.extname(targetFile));
+  const targetBasename = path53.basename(targetFile, path53.extname(targetFile));
   const targetWithExt = targetFile;
   const targetWithoutExt = targetFile.replace(/\.(ts|tsx|js|jsx|mjs|cjs)$/i, "");
-  const normalizedTargetWithExt = path52.normalize(targetWithExt).replace(/\\/g, "/");
-  const normalizedTargetWithoutExt = path52.normalize(targetWithoutExt).replace(/\\/g, "/");
+  const normalizedTargetWithExt = path53.normalize(targetWithExt).replace(/\\/g, "/");
+  const normalizedTargetWithoutExt = path53.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];
@@ -60242,9 +60381,9 @@ function parseImports(content, targetFile, targetSymbol) {
     }
     const _normalizedModule = modulePath.replace(/^\.\//, "").replace(/^\.\.\\/, "../");
     let isMatch = false;
-    const _targetDir = path52.dirname(targetFile);
-    const targetExt = path52.extname(targetFile);
-    const targetBasenameNoExt = path52.basename(targetFile, targetExt);
+    const _targetDir = path53.dirname(targetFile);
+    const targetExt = path53.extname(targetFile);
+    const targetBasenameNoExt = path53.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, "");
@@ -60301,7 +60440,7 @@ var SKIP_DIRECTORIES3 = new Set([
 function findSourceFiles(dir, files = [], stats = { skippedDirs: [], skippedFiles: 0, fileErrors: [] }) {
   let entries;
   try {
-    entries = fs39.readdirSync(dir);
+    entries = fs40.readdirSync(dir);
   } catch (e) {
     stats.fileErrors.push({
       path: dir,
@@ -60312,13 +60451,13 @@ function findSourceFiles(dir, files = [], stats = { skippedDirs: [], skippedFile
   entries.sort((a, b) => a.toLowerCase().localeCompare(b.toLowerCase()));
   for (const entry of entries) {
     if (SKIP_DIRECTORIES3.has(entry)) {
-      stats.skippedDirs.push(path52.join(dir, entry));
+      stats.skippedDirs.push(path53.join(dir, entry));
       continue;
     }
-    const fullPath = path52.join(dir, entry);
+    const fullPath = path53.join(dir, entry);
     let stat2;
     try {
-      stat2 = fs39.statSync(fullPath);
+      stat2 = fs40.statSync(fullPath);
     } catch (e) {
       stats.fileErrors.push({
         path: fullPath,
@@ -60329,7 +60468,7 @@ function findSourceFiles(dir, files = [], stats = { skippedDirs: [], skippedFile
     if (stat2.isDirectory()) {
       findSourceFiles(fullPath, files, stats);
     } else if (stat2.isFile()) {
-      const ext = path52.extname(fullPath).toLowerCase();
+      const ext = path53.extname(fullPath).toLowerCase();
       if (SUPPORTED_EXTENSIONS.includes(ext)) {
         files.push(fullPath);
       }
@@ -60386,8 +60525,8 @@ var imports = createSwarmTool({
       return JSON.stringify(errorResult, null, 2);
     }
     try {
-      const targetFile = path52.resolve(file3);
-      if (!fs39.existsSync(targetFile)) {
+      const targetFile = path53.resolve(file3);
+      if (!fs40.existsSync(targetFile)) {
         const errorResult = {
           error: `target file not found: ${file3}`,
           target: file3,
@@ -60397,7 +60536,7 @@ var imports = createSwarmTool({
         };
         return JSON.stringify(errorResult, null, 2);
       }
-      const targetStat = fs39.statSync(targetFile);
+      const targetStat = fs40.statSync(targetFile);
       if (!targetStat.isFile()) {
         const errorResult = {
           error: "target must be a file, not a directory",
@@ -60408,7 +60547,7 @@ var imports = createSwarmTool({
         };
         return JSON.stringify(errorResult, null, 2);
       }
-      const baseDir = path52.dirname(targetFile);
+      const baseDir = path53.dirname(targetFile);
       const scanStats = {
         skippedDirs: [],
         skippedFiles: 0,
@@ -60423,12 +60562,12 @@ var imports = createSwarmTool({
         if (consumers.length >= MAX_CONSUMERS)
           break;
         try {
-          const stat2 = fs39.statSync(filePath);
+          const stat2 = fs40.statSync(filePath);
           if (stat2.size > MAX_FILE_SIZE_BYTES5) {
             skippedFileCount++;
             continue;
           }
-          const buffer = fs39.readFileSync(filePath);
+          const buffer = fs40.readFileSync(filePath);
           if (isBinaryFile2(filePath, buffer)) {
             skippedFileCount++;
             continue;
@@ -61017,11 +61156,12 @@ init_dist();
 init_config();
 init_schema();
 init_manager();
-import * as fs40 from "fs";
-import * as path53 from "path";
+import * as fs41 from "fs";
+import * as path54 from "path";
 init_utils2();
 init_telemetry();
 init_create_tool();
+init_resolve_working_directory();
 function safeWarn(message, error93) {
   try {
     console.warn(message, error93 instanceof Error ? error93.message : String(error93));
@@ -61238,11 +61378,11 @@ async function executePhaseComplete(args2, workingDirectory, directory) {
       safeWarn(`[phase_complete] Completion verify error (non-blocking):`, completionError);
     }
     try {
-      const driftEvidencePath = path53.join(dir, ".swarm", "evidence", String(phase), "drift-verifier.json");
+      const driftEvidencePath = path54.join(dir, ".swarm", "evidence", String(phase), "drift-verifier.json");
       let driftVerdictFound = false;
       let driftVerdictApproved = false;
       try {
-        const driftEvidenceContent = fs40.readFileSync(driftEvidencePath, "utf-8");
+        const driftEvidenceContent = fs41.readFileSync(driftEvidencePath, "utf-8");
         const driftEvidence = JSON.parse(driftEvidenceContent);
         const entries = driftEvidence.entries ?? [];
         for (const entry of entries) {
@@ -61272,14 +61412,14 @@ async function executePhaseComplete(args2, workingDirectory, directory) {
         driftVerdictFound = false;
       }
       if (!driftVerdictFound) {
-        const specPath = path53.join(dir, ".swarm", "spec.md");
-        const specExists = fs40.existsSync(specPath);
+        const specPath = path54.join(dir, ".swarm", "spec.md");
+        const specExists = fs41.existsSync(specPath);
         if (!specExists) {
           let incompleteTaskCount = 0;
           let planPhaseFound = false;
           try {
             const planPath = validateSwarmPath(dir, "plan.json");
-            const planRaw = fs40.readFileSync(planPath, "utf-8");
+            const planRaw = fs41.readFileSync(planPath, "utf-8");
             const plan = JSON.parse(planRaw);
             const targetPhase = plan.phases.find((p) => p.id === phase);
             if (targetPhase) {
@@ -61346,7 +61486,7 @@ async function executePhaseComplete(args2, workingDirectory, directory) {
   };
   if (retroFound && retroEntry?.lessons_learned && retroEntry.lessons_learned.length > 0) {
     try {
-      const projectName = path53.basename(dir);
+      const projectName = path54.basename(dir);
       const curationResult = await curateAndStoreSwarm(retroEntry.lessons_learned, projectName, { phase_number: phase }, dir, knowledgeConfig);
       if (curationResult) {
         const sessionState = swarmState.agentSessions.get(sessionID);
@@ -61391,7 +61531,7 @@ async function executePhaseComplete(args2, workingDirectory, directory) {
   let phaseRequiredAgents;
   try {
     const planPath = validateSwarmPath(dir, "plan.json");
-    const planRaw = fs40.readFileSync(planPath, "utf-8");
+    const planRaw = fs41.readFileSync(planPath, "utf-8");
     const plan = JSON.parse(planRaw);
     const phaseObj = plan.phases.find((p) => p.id === phase);
     phaseRequiredAgents = phaseObj?.required_agents;
@@ -61406,7 +61546,7 @@ async function executePhaseComplete(args2, workingDirectory, directory) {
   if (agentsMissing.length > 0) {
     try {
       const planPath = validateSwarmPath(dir, "plan.json");
-      const planRaw = fs40.readFileSync(planPath, "utf-8");
+      const planRaw = fs41.readFileSync(planPath, "utf-8");
       const plan = JSON.parse(planRaw);
       const targetPhase = plan.phases.find((p) => p.id === phase);
       if (targetPhase && targetPhase.tasks.length > 0 && targetPhase.tasks.every((t) => t.status === "completed")) {
@@ -61437,7 +61577,7 @@ async function executePhaseComplete(args2, workingDirectory, directory) {
   if (phaseCompleteConfig.regression_sweep?.enforce) {
     try {
       const planPath = validateSwarmPath(dir, "plan.json");
-      const planRaw = fs40.readFileSync(planPath, "utf-8");
+      const planRaw = fs41.readFileSync(planPath, "utf-8");
       const plan = JSON.parse(planRaw);
       const targetPhase = plan.phases.find((p) => p.id === phase);
       if (targetPhase) {
@@ -61475,7 +61615,7 @@ async function executePhaseComplete(args2, workingDirectory, directory) {
   };
   try {
     const eventsPath = validateSwarmPath(dir, "events.jsonl");
-    fs40.appendFileSync(eventsPath, `${JSON.stringify(event)}
+    fs41.appendFileSync(eventsPath, `${JSON.stringify(event)}
 `, "utf-8");
   } catch (writeError) {
     warnings.push(`Warning: failed to write phase complete event: ${writeError instanceof Error ? writeError.message : String(writeError)}`);
@@ -61499,12 +61639,12 @@ async function executePhaseComplete(args2, workingDirectory, directory) {
     }
     try {
       const planPath = validateSwarmPath(dir, "plan.json");
-      const planJson = fs40.readFileSync(planPath, "utf-8");
+      const planJson = fs41.readFileSync(planPath, "utf-8");
       const plan = JSON.parse(planJson);
       const phaseObj = plan.phases.find((p) => p.id === phase);
       if (phaseObj) {
         phaseObj.status = "completed";
-        fs40.writeFileSync(planPath, `${JSON.stringify(plan, null, 2)}
+        fs41.writeFileSync(planPath, `${JSON.stringify(plan, null, 2)}
 `, "utf-8");
       }
     } catch (error93) {
@@ -61531,16 +61671,19 @@ var phase_complete = createSwarmTool({
   args: {
     phase: tool.schema.number().int().min(1).describe("The phase number being completed \u2014 a positive integer (e.g., 1, 2, 3)"),
     summary: tool.schema.string().optional().describe("Optional summary of what was accomplished in this phase"),
-    sessionID: tool.schema.string().optional().describe("Session ID for tracking state (auto-provided by plugin context)")
+    sessionID: tool.schema.string().optional().describe("Session ID for tracking state (auto-provided by plugin context)"),
+    working_directory: tool.schema.string().optional().describe("Explicit project root directory. When provided, .swarm/ is resolved relative to this path instead of the plugin context directory. Use this when CWD differs from the actual project root.")
   },
   execute: async (args2, directory, ctx) => {
     let phaseCompleteArgs;
+    let workingDirInput;
     try {
       phaseCompleteArgs = {
         phase: Number(args2.phase),
         summary: args2.summary !== undefined ? String(args2.summary) : undefined,
         sessionID: ctx?.sessionID ?? (args2.sessionID !== undefined ? String(args2.sessionID) : undefined)
       };
+      workingDirInput = args2.working_directory !== undefined ? String(args2.working_directory) : undefined;
     } catch {
       return JSON.stringify({
         success: false,
@@ -61550,7 +61693,17 @@ var phase_complete = createSwarmTool({
         warnings: ["Failed to parse arguments"]
       }, null, 2);
     }
-    return executePhaseComplete(phaseCompleteArgs, undefined, directory);
+    const dirResult = resolveWorkingDirectory(workingDirInput, directory);
+    if (!dirResult.success) {
+      return JSON.stringify({
+        success: false,
+        phase: phaseCompleteArgs.phase,
+        message: dirResult.message,
+        agentsDispatched: [],
+        warnings: [dirResult.message]
+      }, null, 2);
+    }
+    return executePhaseComplete(phaseCompleteArgs, dirResult.directory, dirResult.directory);
   }
 });
 // src/tools/pkg-audit.ts
@@ -61558,8 +61711,8 @@ init_dist();
 init_discovery();
 init_utils();
 init_create_tool();
-import * as fs41 from "fs";
-import * as path54 from "path";
+import * as fs42 from "fs";
+import * as path55 from "path";
 var MAX_OUTPUT_BYTES5 = 52428800;
 var AUDIT_TIMEOUT_MS = 120000;
 function isValidEcosystem(value) {
@@ -61577,28 +61730,28 @@ function validateArgs3(args2) {
 function detectEcosystems(directory) {
   const ecosystems = [];
   const cwd = directory;
-  if (fs41.existsSync(path54.join(cwd, "package.json"))) {
+  if (fs42.existsSync(path55.join(cwd, "package.json"))) {
     ecosystems.push("npm");
   }
-  if (fs41.existsSync(path54.join(cwd, "pyproject.toml")) || fs41.existsSync(path54.join(cwd, "requirements.txt"))) {
+  if (fs42.existsSync(path55.join(cwd, "pyproject.toml")) || fs42.existsSync(path55.join(cwd, "requirements.txt"))) {
     ecosystems.push("pip");
   }
-  if (fs41.existsSync(path54.join(cwd, "Cargo.toml"))) {
+  if (fs42.existsSync(path55.join(cwd, "Cargo.toml"))) {
     ecosystems.push("cargo");
   }
-  if (fs41.existsSync(path54.join(cwd, "go.mod"))) {
+  if (fs42.existsSync(path55.join(cwd, "go.mod"))) {
     ecosystems.push("go");
   }
   try {
-    const files = fs41.readdirSync(cwd);
+    const files = fs42.readdirSync(cwd);
     if (files.some((f) => f.endsWith(".csproj") || f.endsWith(".sln"))) {
       ecosystems.push("dotnet");
     }
   } catch {}
-  if (fs41.existsSync(path54.join(cwd, "Gemfile")) || fs41.existsSync(path54.join(cwd, "Gemfile.lock"))) {
+  if (fs42.existsSync(path55.join(cwd, "Gemfile")) || fs42.existsSync(path55.join(cwd, "Gemfile.lock"))) {
     ecosystems.push("ruby");
   }
-  if (fs41.existsSync(path54.join(cwd, "pubspec.yaml"))) {
+  if (fs42.existsSync(path55.join(cwd, "pubspec.yaml"))) {
     ecosystems.push("dart");
   }
   return ecosystems;
@@ -61611,7 +61764,7 @@ async function runNpmAudit(directory) {
       stderr: "pipe",
       cwd: directory
     });
-    const timeoutPromise = new Promise((resolve18) => setTimeout(() => resolve18("timeout"), AUDIT_TIMEOUT_MS));
+    const timeoutPromise = new Promise((resolve19) => setTimeout(() => resolve19("timeout"), AUDIT_TIMEOUT_MS));
     const result = await Promise.race([
       Promise.all([
         new Response(proc.stdout).text(),
@@ -61734,7 +61887,7 @@ async function runPipAudit(directory) {
       stderr: "pipe",
       cwd: directory
     });
-    const timeoutPromise = new Promise((resolve18) => setTimeout(() => resolve18("timeout"), AUDIT_TIMEOUT_MS));
+    const timeoutPromise = new Promise((resolve19) => setTimeout(() => resolve19("timeout"), AUDIT_TIMEOUT_MS));
     const result = await Promise.race([
       Promise.all([
         new Response(proc.stdout).text(),
@@ -61865,7 +62018,7 @@ async function runCargoAudit(directory) {
       stderr: "pipe",
       cwd: directory
     });
-    const timeoutPromise = new Promise((resolve18) => setTimeout(() => resolve18("timeout"), AUDIT_TIMEOUT_MS));
+    const timeoutPromise = new Promise((resolve19) => setTimeout(() => resolve19("timeout"), AUDIT_TIMEOUT_MS));
     const result = await Promise.race([
       Promise.all([
         new Response(proc.stdout).text(),
@@ -61992,7 +62145,7 @@ async function runGoAudit(directory) {
       stderr: "pipe",
       cwd: directory
     });
-    const timeoutPromise = new Promise((resolve18) => setTimeout(() => resolve18("timeout"), AUDIT_TIMEOUT_MS));
+    const timeoutPromise = new Promise((resolve19) => setTimeout(() => resolve19("timeout"), AUDIT_TIMEOUT_MS));
     const result = await Promise.race([
       Promise.all([
         new Response(proc.stdout).text(),
@@ -62128,7 +62281,7 @@ async function runDotnetAudit(directory) {
       stderr: "pipe",
       cwd: directory
     });
-    const timeoutPromise = new Promise((resolve18) => setTimeout(() => resolve18("timeout"), AUDIT_TIMEOUT_MS));
+    const timeoutPromise = new Promise((resolve19) => setTimeout(() => resolve19("timeout"), AUDIT_TIMEOUT_MS));
     const result = await Promise.race([
       Promise.all([
         new Response(proc.stdout).text(),
@@ -62247,7 +62400,7 @@ async function runBundleAudit(directory) {
       stderr: "pipe",
       cwd: directory
     });
-    const timeoutPromise = new Promise((resolve18) => setTimeout(() => resolve18("timeout"), AUDIT_TIMEOUT_MS));
+    const timeoutPromise = new Promise((resolve19) => setTimeout(() => resolve19("timeout"), AUDIT_TIMEOUT_MS));
     const result = await Promise.race([
       Promise.all([
         new Response(proc.stdout).text(),
@@ -62394,7 +62547,7 @@ async function runDartAudit(directory) {
       stderr: "pipe",
       cwd: directory
     });
-    const timeoutPromise = new Promise((resolve18) => setTimeout(() => resolve18("timeout"), AUDIT_TIMEOUT_MS));
+    const timeoutPromise = new Promise((resolve19) => setTimeout(() => resolve19("timeout"), AUDIT_TIMEOUT_MS));
     const result = await Promise.race([
       Promise.all([
         new Response(proc.stdout).text(),
@@ -62619,8 +62772,8 @@ var SUPPORTED_PARSER_EXTENSIONS = new Set([
 ]);
 // src/tools/pre-check-batch.ts
 init_dist();
-import * as fs43 from "fs";
-import * as path56 from "path";
+import * as fs44 from "fs";
+import * as path57 from "path";
 
 // node_modules/yocto-queue/index.js
 class Node2 {
@@ -62711,26 +62864,26 @@ function pLimit(concurrency) {
     activeCount--;
     resumeNext();
   };
-  const run2 = async (function_, resolve18, arguments_2) => {
+  const run2 = async (function_, resolve19, arguments_2) => {
     const result = (async () => function_(...arguments_2))();
-    resolve18(result);
+    resolve19(result);
     try {
       await result;
     } catch {}
     next();
   };
-  const enqueue = (function_, resolve18, reject, arguments_2) => {
+  const enqueue = (function_, resolve19, reject, arguments_2) => {
     const queueItem = { reject };
     new Promise((internalResolve) => {
       queueItem.run = internalResolve;
       queue.enqueue(queueItem);
-    }).then(run2.bind(undefined, function_, resolve18, arguments_2));
+    }).then(run2.bind(undefined, function_, resolve19, arguments_2));
     if (activeCount < concurrency) {
       resumeNext();
     }
   };
-  const generator = (function_, ...arguments_2) => new Promise((resolve18, reject) => {
-    enqueue(function_, resolve18, reject, arguments_2);
+  const generator = (function_, ...arguments_2) => new Promise((resolve19, reject) => {
+    enqueue(function_, resolve19, reject, arguments_2);
   });
   Object.defineProperties(generator, {
     activeCount: {
@@ -62894,8 +63047,8 @@ async function qualityBudget(input, directory) {
 init_dist();
 init_manager();
 init_detector();
-import * as fs42 from "fs";
-import * as path55 from "path";
+import * as fs43 from "fs";
+import * as path56 from "path";
 import { extname as extname10 } from "path";
 
 // src/sast/rules/c.ts
@@ -63646,7 +63799,7 @@ function mapSemgrepSeverity(severity) {
   }
 }
 async function executeWithTimeout(command, args2, options) {
-  return new Promise((resolve18) => {
+  return new Promise((resolve19) => {
     const child = spawn2(command, args2, {
       shell: false,
       cwd: options.cwd
@@ -63655,7 +63808,7 @@ async function executeWithTimeout(command, args2, options) {
     let stderr = "";
     const timeout = setTimeout(() => {
       child.kill("SIGTERM");
-      resolve18({
+      resolve19({
         stdout,
         stderr: "Process timed out",
         exitCode: 124
@@ -63669,7 +63822,7 @@ async function executeWithTimeout(command, args2, options) {
     });
     child.on("close", (code) => {
       clearTimeout(timeout);
-      resolve18({
+      resolve19({
         stdout,
         stderr,
         exitCode: code ?? 0
@@ -63677,7 +63830,7 @@ async function executeWithTimeout(command, args2, options) {
     });
     child.on("error", (err2) => {
       clearTimeout(timeout);
-      resolve18({
+      resolve19({
         stdout,
         stderr: err2.message,
         exitCode: 1
@@ -63765,17 +63918,17 @@ var SEVERITY_ORDER = {
 };
 function shouldSkipFile(filePath) {
   try {
-    const stats = fs42.statSync(filePath);
+    const stats = fs43.statSync(filePath);
     if (stats.size > MAX_FILE_SIZE_BYTES6) {
       return { skip: true, reason: "file too large" };
     }
     if (stats.size === 0) {
       return { skip: true, reason: "empty file" };
     }
-    const fd = fs42.openSync(filePath, "r");
+    const fd = fs43.openSync(filePath, "r");
     const buffer = Buffer.alloc(8192);
-    const bytesRead = fs42.readSync(fd, buffer, 0, 8192, 0);
-    fs42.closeSync(fd);
+    const bytesRead = fs43.readSync(fd, buffer, 0, 8192, 0);
+    fs43.closeSync(fd);
     if (bytesRead > 0) {
       let nullCount = 0;
       for (let i2 = 0;i2 < bytesRead; i2++) {
@@ -63814,7 +63967,7 @@ function countBySeverity(findings) {
 }
 function scanFileWithTierA(filePath, language) {
   try {
-    const content = fs42.readFileSync(filePath, "utf-8");
+    const content = fs43.readFileSync(filePath, "utf-8");
     const findings = executeRulesSync(filePath, content, language);
     return findings.map((f) => ({
       rule_id: f.rule_id,
@@ -63861,8 +64014,8 @@ async function sastScan(input, directory, config3) {
       _filesSkipped++;
       continue;
     }
-    const resolvedPath = path55.isAbsolute(filePath) ? filePath : path55.resolve(directory, filePath);
-    if (!fs42.existsSync(resolvedPath)) {
+    const resolvedPath = path56.isAbsolute(filePath) ? filePath : path56.resolve(directory, filePath);
+    if (!fs43.existsSync(resolvedPath)) {
       _filesSkipped++;
       continue;
     }
@@ -64060,18 +64213,18 @@ function validatePath(inputPath, baseDir, workspaceDir) {
   let resolved;
   const isWinAbs = isWindowsAbsolutePath(inputPath);
   if (isWinAbs) {
-    resolved = path56.win32.resolve(inputPath);
-  } else if (path56.isAbsolute(inputPath)) {
-    resolved = path56.resolve(inputPath);
+    resolved = path57.win32.resolve(inputPath);
+  } else if (path57.isAbsolute(inputPath)) {
+    resolved = path57.resolve(inputPath);
   } else {
-    resolved = path56.resolve(baseDir, inputPath);
+    resolved = path57.resolve(baseDir, inputPath);
   }
-  const workspaceResolved = path56.resolve(workspaceDir);
+  const workspaceResolved = path57.resolve(workspaceDir);
   let relative8;
   if (isWinAbs) {
-    relative8 = path56.win32.relative(workspaceResolved, resolved);
+    relative8 = path57.win32.relative(workspaceResolved, resolved);
   } else {
-    relative8 = path56.relative(workspaceResolved, resolved);
+    relative8 = path57.relative(workspaceResolved, resolved);
   }
   if (relative8.startsWith("..")) {
     return "path traversal detected";
@@ -64132,13 +64285,13 @@ async function runLintWrapped(files, directory, _config) {
 }
 async function runLintOnFiles(linter, files, workspaceDir) {
   const isWindows = process.platform === "win32";
-  const binDir = path56.join(workspaceDir, "node_modules", ".bin");
+  const binDir = path57.join(workspaceDir, "node_modules", ".bin");
   const validatedFiles = [];
   for (const file3 of files) {
     if (typeof file3 !== "string") {
       continue;
     }
-    const resolvedPath = path56.resolve(file3);
+    const resolvedPath = path57.resolve(file3);
     const validationError = validatePath(resolvedPath, workspaceDir, workspaceDir);
     if (validationError) {
       continue;
@@ -64156,10 +64309,10 @@ async function runLintOnFiles(linter, files, workspaceDir) {
   }
   let command;
   if (linter === "biome") {
-    const biomeBin = isWindows ? path56.join(binDir, "biome.EXE") : path56.join(binDir, "biome");
+    const biomeBin = isWindows ? path57.join(binDir, "biome.EXE") : path57.join(binDir, "biome");
     command = [biomeBin, "check", ...validatedFiles];
   } else {
-    const eslintBin = isWindows ? path56.join(binDir, "eslint.cmd") : path56.join(binDir, "eslint");
+    const eslintBin = isWindows ? path57.join(binDir, "eslint.cmd") : path57.join(binDir, "eslint");
     command = [eslintBin, ...validatedFiles];
   }
   try {
@@ -64296,7 +64449,7 @@ async function runSecretscanWithFiles(files, directory) {
         skippedFiles++;
         continue;
       }
-      const resolvedPath = path56.resolve(file3);
+      const resolvedPath = path57.resolve(file3);
       const validationError = validatePath(resolvedPath, directory, directory);
       if (validationError) {
         skippedFiles++;
@@ -64314,14 +64467,14 @@ async function runSecretscanWithFiles(files, directory) {
       };
     }
     for (const file3 of validatedFiles) {
-      const ext = path56.extname(file3).toLowerCase();
+      const ext = path57.extname(file3).toLowerCase();
       if (DEFAULT_EXCLUDE_EXTENSIONS2.has(ext)) {
         skippedFiles++;
         continue;
       }
       let stat2;
       try {
-        stat2 = fs43.statSync(file3);
+        stat2 = fs44.statSync(file3);
       } catch {
         skippedFiles++;
         continue;
@@ -64332,7 +64485,7 @@ async function runSecretscanWithFiles(files, directory) {
       }
       let content;
       try {
-        const buffer = fs43.readFileSync(file3);
+        const buffer = fs44.readFileSync(file3);
         if (buffer.includes(0)) {
           skippedFiles++;
           continue;
@@ -64520,7 +64673,7 @@ function classifySastFindings(findings, changedLineRanges, directory) {
   const preexistingFindings = [];
   for (const finding of findings) {
     const filePath = finding.location.file;
-    const normalised = path56.relative(directory, filePath).replace(/\\/g, "/");
+    const normalised = path57.relative(directory, filePath).replace(/\\/g, "/");
     const changedLines = changedLineRanges.get(normalised);
     if (changedLines && changedLines.has(finding.location.line)) {
       newFindings.push(finding);
@@ -64571,7 +64724,7 @@ async function runPreCheckBatch(input, workspaceDir, contextDir) {
       warn(`pre_check_batch: Invalid file path: ${file3}`);
       continue;
     }
-    changedFiles.push(path56.resolve(directory, file3));
+    changedFiles.push(path57.resolve(directory, file3));
   }
   if (changedFiles.length === 0) {
     warn("pre_check_batch: No valid files after validation, skipping all tools (fail-closed)");
@@ -64759,7 +64912,7 @@ var pre_check_batch = createSwarmTool({
       };
       return JSON.stringify(errorResult, null, 2);
     }
-    const resolvedDirectory = path56.resolve(typedArgs.directory);
+    const resolvedDirectory = path57.resolve(typedArgs.directory);
     const workspaceAnchor = resolvedDirectory;
     const dirError = validateDirectory2(resolvedDirectory, workspaceAnchor);
     if (dirError) {
@@ -64865,38 +65018,38 @@ ${paginatedContent}`;
 });
 // src/tools/save-plan.ts
 init_tool();
-import * as fs45 from "fs";
-import * as path58 from "path";
+import * as fs46 from "fs";
+import * as path59 from "path";
 
 // src/parallel/file-locks.ts
-import * as fs44 from "fs";
-import * as path57 from "path";
+import * as fs45 from "fs";
+import * as path58 from "path";
 var LOCKS_DIR = ".swarm/locks";
 var LOCK_TIMEOUT_MS = 5 * 60 * 1000;
 function getLockFilePath(directory, filePath) {
-  const normalized = path57.resolve(directory, filePath);
-  if (!normalized.startsWith(path57.resolve(directory))) {
+  const normalized = path58.resolve(directory, filePath);
+  if (!normalized.startsWith(path58.resolve(directory))) {
     throw new Error("Invalid file path: path traversal not allowed");
   }
   const hash3 = Buffer.from(normalized).toString("base64").replace(/[/+=]/g, "_");
-  return path57.join(directory, LOCKS_DIR, `${hash3}.lock`);
+  return path58.join(directory, LOCKS_DIR, `${hash3}.lock`);
 }
 function tryAcquireLock(directory, filePath, agent, taskId) {
   const lockPath = getLockFilePath(directory, filePath);
-  const locksDir = path57.dirname(lockPath);
-  if (!fs44.existsSync(locksDir)) {
-    fs44.mkdirSync(locksDir, { recursive: true });
+  const locksDir = path58.dirname(lockPath);
+  if (!fs45.existsSync(locksDir)) {
+    fs45.mkdirSync(locksDir, { recursive: true });
   }
-  if (fs44.existsSync(lockPath)) {
+  if (fs45.existsSync(lockPath)) {
     try {
-      const existingLock = JSON.parse(fs44.readFileSync(lockPath, "utf-8"));
+      const existingLock = JSON.parse(fs45.readFileSync(lockPath, "utf-8"));
       if (Date.now() > existingLock.expiresAt) {
-        fs44.unlinkSync(lockPath);
+        fs45.unlinkSync(lockPath);
       } else {
         return { acquired: false, existing: existingLock };
       }
     } catch {
-      fs44.unlinkSync(lockPath);
+      fs45.unlinkSync(lockPath);
     }
   }
   const lock = {
@@ -64907,24 +65060,24 @@ function tryAcquireLock(directory, filePath, agent, taskId) {
     expiresAt: Date.now() + LOCK_TIMEOUT_MS
   };
   const tempPath = `${lockPath}.tmp`;
-  fs44.writeFileSync(tempPath, JSON.stringify(lock, null, 2), "utf-8");
-  fs44.renameSync(tempPath, lockPath);
+  fs45.writeFileSync(tempPath, JSON.stringify(lock, null, 2), "utf-8");
+  fs45.renameSync(tempPath, lockPath);
   return { acquired: true, lock };
 }
 function releaseLock(directory, filePath, taskId) {
   const lockPath = getLockFilePath(directory, filePath);
-  if (!fs44.existsSync(lockPath)) {
+  if (!fs45.existsSync(lockPath)) {
     return true;
   }
   try {
-    const lock = JSON.parse(fs44.readFileSync(lockPath, "utf-8"));
+    const lock = JSON.parse(fs45.readFileSync(lockPath, "utf-8"));
     if (lock.taskId === taskId) {
-      fs44.unlinkSync(lockPath);
+      fs45.unlinkSync(lockPath);
       return true;
     }
     return false;
   } catch {
-    fs44.unlinkSync(lockPath);
+    fs45.unlinkSync(lockPath);
     return true;
   }
 }
@@ -65049,14 +65202,14 @@ async function executeSavePlan(args2, fallbackDir) {
     try {
       await savePlan(dir, plan);
       try {
-        const markerPath = path58.join(dir, ".swarm", ".plan-write-marker");
+        const markerPath = path59.join(dir, ".swarm", ".plan-write-marker");
         const marker = JSON.stringify({
           source: "save_plan",
           timestamp: new Date().toISOString(),
           phases_count: plan.phases.length,
           tasks_count: tasksCount
         });
-        await fs45.promises.writeFile(markerPath, marker, "utf8");
+        await fs46.promises.writeFile(markerPath, marker, "utf8");
       } catch {}
       const warnings = [];
       let criticReviewFound = false;
@@ -65072,7 +65225,7 @@ async function executeSavePlan(args2, fallbackDir) {
       return {
         success: true,
         message: "Plan saved successfully",
-        plan_path: path58.join(dir, ".swarm", "plan.json"),
+        plan_path: path59.join(dir, ".swarm", "plan.json"),
         phases_count: plan.phases.length,
         tasks_count: tasksCount,
         ...warnings.length > 0 ? { warnings } : {}
@@ -65114,8 +65267,8 @@ var save_plan = createSwarmTool({
 // src/tools/sbom-generate.ts
 init_dist();
 init_manager();
-import * as fs46 from "fs";
-import * as path59 from "path";
+import * as fs47 from "fs";
+import * as path60 from "path";
 
 // src/sbom/detectors/index.ts
 init_utils();
@@ -65963,9 +66116,9 @@ function findManifestFiles(rootDir) {
   const patterns = [...new Set(allDetectors.flatMap((d) => d.patterns))];
   function searchDir(dir) {
     try {
-      const entries = fs46.readdirSync(dir, { withFileTypes: true });
+      const entries = fs47.readdirSync(dir, { withFileTypes: true });
       for (const entry of entries) {
-        const fullPath = path59.join(dir, entry.name);
+        const fullPath = path60.join(dir, entry.name);
         if (entry.name.startsWith(".") || entry.name === "node_modules" || entry.name === "dist" || entry.name === "build" || entry.name === "target") {
           continue;
         }
@@ -65974,7 +66127,7 @@ function findManifestFiles(rootDir) {
         } else if (entry.isFile()) {
           for (const pattern of patterns) {
             if (simpleGlobToRegex(pattern).test(entry.name)) {
-              manifestFiles.push(path59.relative(rootDir, fullPath));
+              manifestFiles.push(path60.relative(rootDir, fullPath));
               break;
             }
           }
@@ -65990,13 +66143,13 @@ function findManifestFilesInDirs(directories, workingDir) {
   const patterns = [...new Set(allDetectors.flatMap((d) => d.patterns))];
   for (const dir of directories) {
     try {
-      const entries = fs46.readdirSync(dir, { withFileTypes: true });
+      const entries = fs47.readdirSync(dir, { withFileTypes: true });
       for (const entry of entries) {
-        const fullPath = path59.join(dir, entry.name);
+        const fullPath = path60.join(dir, entry.name);
         if (entry.isFile()) {
           for (const pattern of patterns) {
             if (simpleGlobToRegex(pattern).test(entry.name)) {
-              found.push(path59.relative(workingDir, fullPath));
+              found.push(path60.relative(workingDir, fullPath));
               break;
             }
           }
@@ -66009,11 +66162,11 @@ function findManifestFilesInDirs(directories, workingDir) {
 function getDirectoriesFromChangedFiles(changedFiles, workingDir) {
   const dirs = new Set;
   for (const file3 of changedFiles) {
-    let currentDir = path59.dirname(file3);
+    let currentDir = path60.dirname(file3);
     while (true) {
-      if (currentDir && currentDir !== "." && currentDir !== path59.sep) {
-        dirs.add(path59.join(workingDir, currentDir));
-        const parent = path59.dirname(currentDir);
+      if (currentDir && currentDir !== "." && currentDir !== path60.sep) {
+        dirs.add(path60.join(workingDir, currentDir));
+        const parent = path60.dirname(currentDir);
         if (parent === currentDir)
           break;
         currentDir = parent;
@@ -66027,7 +66180,7 @@ function getDirectoriesFromChangedFiles(changedFiles, workingDir) {
 }
 function ensureOutputDir(outputDir) {
   try {
-    fs46.mkdirSync(outputDir, { recursive: true });
+    fs47.mkdirSync(outputDir, { recursive: true });
   } catch (error93) {
     if (!error93 || error93.code !== "EEXIST") {
       throw error93;
@@ -66097,7 +66250,7 @@ var sbom_generate = createSwarmTool({
     const changedFiles = obj.changed_files;
     const relativeOutputDir = obj.output_dir || DEFAULT_OUTPUT_DIR;
     const workingDir = directory;
-    const outputDir = path59.isAbsolute(relativeOutputDir) ? relativeOutputDir : path59.join(workingDir, relativeOutputDir);
+    const outputDir = path60.isAbsolute(relativeOutputDir) ? relativeOutputDir : path60.join(workingDir, relativeOutputDir);
     let manifestFiles = [];
     if (scope === "all") {
       manifestFiles = findManifestFiles(workingDir);
@@ -66120,11 +66273,11 @@ var sbom_generate = createSwarmTool({
     const processedFiles = [];
     for (const manifestFile of manifestFiles) {
       try {
-        const fullPath = path59.isAbsolute(manifestFile) ? manifestFile : path59.join(workingDir, manifestFile);
-        if (!fs46.existsSync(fullPath)) {
+        const fullPath = path60.isAbsolute(manifestFile) ? manifestFile : path60.join(workingDir, manifestFile);
+        if (!fs47.existsSync(fullPath)) {
           continue;
         }
-        const content = fs46.readFileSync(fullPath, "utf-8");
+        const content = fs47.readFileSync(fullPath, "utf-8");
         const components = detectComponents(manifestFile, content);
         processedFiles.push(manifestFile);
         if (components.length > 0) {
@@ -66137,8 +66290,8 @@ var sbom_generate = createSwarmTool({
     const bom = generateCycloneDX(allComponents);
     const bomJson = serializeCycloneDX(bom);
     const filename = generateSbomFilename();
-    const outputPath = path59.join(outputDir, filename);
-    fs46.writeFileSync(outputPath, bomJson, "utf-8");
+    const outputPath = path60.join(outputDir, filename);
+    fs47.writeFileSync(outputPath, bomJson, "utf-8");
     const verdict = processedFiles.length > 0 ? "pass" : "pass";
     try {
       const timestamp = new Date().toISOString();
@@ -66180,8 +66333,8 @@ var sbom_generate = createSwarmTool({
 // src/tools/schema-drift.ts
 init_dist();
 init_create_tool();
-import * as fs47 from "fs";
-import * as path60 from "path";
+import * as fs48 from "fs";
+import * as path61 from "path";
 var SPEC_CANDIDATES = [
   "openapi.json",
   "openapi.yaml",
@@ -66213,28 +66366,28 @@ function normalizePath2(p) {
 }
 function discoverSpecFile(cwd, specFileArg) {
   if (specFileArg) {
-    const resolvedPath = path60.resolve(cwd, specFileArg);
-    const normalizedCwd = cwd.endsWith(path60.sep) ? cwd : cwd + path60.sep;
+    const resolvedPath = path61.resolve(cwd, specFileArg);
+    const normalizedCwd = cwd.endsWith(path61.sep) ? cwd : cwd + path61.sep;
     if (!resolvedPath.startsWith(normalizedCwd) && resolvedPath !== cwd) {
       throw new Error("Invalid spec_file: path traversal detected");
     }
-    const ext = path60.extname(resolvedPath).toLowerCase();
+    const ext = path61.extname(resolvedPath).toLowerCase();
     if (!ALLOWED_EXTENSIONS.includes(ext)) {
       throw new Error(`Invalid spec_file: must end in .json, .yaml, or .yml, got ${ext}`);
     }
-    const stats = fs47.statSync(resolvedPath);
+    const stats = fs48.statSync(resolvedPath);
     if (stats.size > MAX_SPEC_SIZE) {
       throw new Error(`Invalid spec_file: file exceeds ${MAX_SPEC_SIZE / 1024 / 1024}MB limit`);
     }
-    if (!fs47.existsSync(resolvedPath)) {
+    if (!fs48.existsSync(resolvedPath)) {
       throw new Error(`Spec file not found: ${resolvedPath}`);
     }
     return resolvedPath;
   }
   for (const candidate of SPEC_CANDIDATES) {
-    const candidatePath = path60.resolve(cwd, candidate);
-    if (fs47.existsSync(candidatePath)) {
-      const stats = fs47.statSync(candidatePath);
+    const candidatePath = path61.resolve(cwd, candidate);
+    if (fs48.existsSync(candidatePath)) {
+      const stats = fs48.statSync(candidatePath);
       if (stats.size <= MAX_SPEC_SIZE) {
         return candidatePath;
       }
@@ -66243,8 +66396,8 @@ function discoverSpecFile(cwd, specFileArg) {
   return null;
 }
 function parseSpec(specFile) {
-  const content = fs47.readFileSync(specFile, "utf-8");
-  const ext = path60.extname(specFile).toLowerCase();
+  const content = fs48.readFileSync(specFile, "utf-8");
+  const ext = path61.extname(specFile).toLowerCase();
   if (ext === ".json") {
     return parseJsonSpec(content);
   }
@@ -66315,12 +66468,12 @@ function extractRoutes(cwd) {
   function walkDir(dir) {
     let entries;
     try {
-      entries = fs47.readdirSync(dir, { withFileTypes: true });
+      entries = fs48.readdirSync(dir, { withFileTypes: true });
     } catch {
       return;
     }
     for (const entry of entries) {
-      const fullPath = path60.join(dir, entry.name);
+      const fullPath = path61.join(dir, entry.name);
       if (entry.isSymbolicLink()) {
         continue;
       }
@@ -66330,7 +66483,7 @@ function extractRoutes(cwd) {
         }
         walkDir(fullPath);
       } else if (entry.isFile()) {
-        const ext = path60.extname(entry.name).toLowerCase();
+        const ext = path61.extname(entry.name).toLowerCase();
         const baseName = entry.name.toLowerCase();
         if (![".ts", ".js", ".mjs"].includes(ext)) {
           continue;
@@ -66348,7 +66501,7 @@ function extractRoutes(cwd) {
 }
 function extractRoutesFromFile(filePath) {
   const routes = [];
-  const content = fs47.readFileSync(filePath, "utf-8");
+  const content = fs48.readFileSync(filePath, "utf-8");
   const lines = content.split(/\r?\n/);
   const expressRegex = /(?:app|router|server|express)\.(get|post|put|patch|delete|options|head)\s*\(\s*['"`]([^'"`]+)['"`]/g;
   const flaskRegex = /@(?:app|blueprint|bp)\.route\s*\(\s*['"]([^'"]+)['"]/g;
@@ -66499,8 +66652,8 @@ init_secretscan();
 // src/tools/symbols.ts
 init_tool();
 init_create_tool();
-import * as fs48 from "fs";
-import * as path61 from "path";
+import * as fs49 from "fs";
+import * as path62 from "path";
 var MAX_FILE_SIZE_BYTES7 = 1024 * 1024;
 var WINDOWS_RESERVED_NAMES = /^(con|prn|aux|nul|com[1-9]|lpt[1-9])(\.|:|$)/i;
 function containsWindowsAttacks(str) {
@@ -66517,11 +66670,11 @@ function containsWindowsAttacks(str) {
 }
 function isPathInWorkspace(filePath, workspace) {
   try {
-    const resolvedPath = path61.resolve(workspace, filePath);
-    const realWorkspace = fs48.realpathSync(workspace);
-    const realResolvedPath = fs48.realpathSync(resolvedPath);
-    const relativePath = path61.relative(realWorkspace, realResolvedPath);
-    if (relativePath.startsWith("..") || path61.isAbsolute(relativePath)) {
+    const resolvedPath = path62.resolve(workspace, filePath);
+    const realWorkspace = fs49.realpathSync(workspace);
+    const realResolvedPath = fs49.realpathSync(resolvedPath);
+    const relativePath = path62.relative(realWorkspace, realResolvedPath);
+    if (relativePath.startsWith("..") || path62.isAbsolute(relativePath)) {
       return false;
     }
     return true;
@@ -66533,17 +66686,17 @@ function validatePathForRead(filePath, workspace) {
   return isPathInWorkspace(filePath, workspace);
 }
 function extractTSSymbols(filePath, cwd) {
-  const fullPath = path61.join(cwd, filePath);
+  const fullPath = path62.join(cwd, filePath);
   if (!validatePathForRead(fullPath, cwd)) {
     return [];
   }
   let content;
   try {
-    const stats = fs48.statSync(fullPath);
+    const stats = fs49.statSync(fullPath);
     if (stats.size > MAX_FILE_SIZE_BYTES7) {
       throw new Error(`File too large: ${stats.size} bytes (max: ${MAX_FILE_SIZE_BYTES7})`);
     }
-    content = fs48.readFileSync(fullPath, "utf-8");
+    content = fs49.readFileSync(fullPath, "utf-8");
   } catch {
     return [];
   }
@@ -66685,17 +66838,17 @@ function extractTSSymbols(filePath, cwd) {
   });
 }
 function extractPythonSymbols(filePath, cwd) {
-  const fullPath = path61.join(cwd, filePath);
+  const fullPath = path62.join(cwd, filePath);
   if (!validatePathForRead(fullPath, cwd)) {
     return [];
   }
   let content;
   try {
-    const stats = fs48.statSync(fullPath);
+    const stats = fs49.statSync(fullPath);
     if (stats.size > MAX_FILE_SIZE_BYTES7) {
       throw new Error(`File too large: ${stats.size} bytes (max: ${MAX_FILE_SIZE_BYTES7})`);
     }
-    content = fs48.readFileSync(fullPath, "utf-8");
+    content = fs49.readFileSync(fullPath, "utf-8");
   } catch {
     return [];
   }
@@ -66768,7 +66921,7 @@ var symbols = createSwarmTool({
       }, null, 2);
     }
     const cwd = directory;
-    const ext = path61.extname(file3);
+    const ext = path62.extname(file3);
     if (containsControlChars(file3)) {
       return JSON.stringify({
         file: file3,
@@ -66839,8 +66992,8 @@ init_test_runner();
 init_dist();
 init_utils();
 init_create_tool();
-import * as fs49 from "fs";
-import * as path62 from "path";
+import * as fs50 from "fs";
+import * as path63 from "path";
 var MAX_TEXT_LENGTH = 200;
 var MAX_FILE_SIZE_BYTES8 = 1024 * 1024;
 var SUPPORTED_EXTENSIONS2 = new Set([
@@ -66905,9 +67058,9 @@ function validatePathsInput(paths, cwd) {
     return { error: "paths contains path traversal", resolvedPath: null };
   }
   try {
-    const resolvedPath = path62.resolve(paths);
-    const normalizedCwd = path62.resolve(cwd);
-    const normalizedResolved = path62.resolve(resolvedPath);
+    const resolvedPath = path63.resolve(paths);
+    const normalizedCwd = path63.resolve(cwd);
+    const normalizedResolved = path63.resolve(resolvedPath);
     if (!normalizedResolved.startsWith(normalizedCwd)) {
       return {
         error: "paths must be within the current working directory",
@@ -66923,13 +67076,13 @@ function validatePathsInput(paths, cwd) {
   }
 }
 function isSupportedExtension(filePath) {
-  const ext = path62.extname(filePath).toLowerCase();
+  const ext = path63.extname(filePath).toLowerCase();
   return SUPPORTED_EXTENSIONS2.has(ext);
 }
 function findSourceFiles2(dir, files = []) {
   let entries;
   try {
-    entries = fs49.readdirSync(dir);
+    entries = fs50.readdirSync(dir);
   } catch {
     return files;
   }
@@ -66938,10 +67091,10 @@ function findSourceFiles2(dir, files = []) {
     if (SKIP_DIRECTORIES4.has(entry)) {
       continue;
     }
-    const fullPath = path62.join(dir, entry);
+    const fullPath = path63.join(dir, entry);
     let stat2;
     try {
-      stat2 = fs49.statSync(fullPath);
+      stat2 = fs50.statSync(fullPath);
     } catch {
       continue;
     }
@@ -67034,7 +67187,7 @@ var todo_extract = createSwarmTool({
       return JSON.stringify(errorResult, null, 2);
     }
     const scanPath = resolvedPath;
-    if (!fs49.existsSync(scanPath)) {
+    if (!fs50.existsSync(scanPath)) {
       const errorResult = {
         error: `path not found: ${pathsInput}`,
         total: 0,
@@ -67044,13 +67197,13 @@ var todo_extract = createSwarmTool({
       return JSON.stringify(errorResult, null, 2);
     }
     const filesToScan = [];
-    const stat2 = fs49.statSync(scanPath);
+    const stat2 = fs50.statSync(scanPath);
     if (stat2.isFile()) {
       if (isSupportedExtension(scanPath)) {
         filesToScan.push(scanPath);
       } else {
         const errorResult = {
-          error: `unsupported file extension: ${path62.extname(scanPath)}`,
+          error: `unsupported file extension: ${path63.extname(scanPath)}`,
           total: 0,
           byPriority: { high: 0, medium: 0, low: 0 },
           entries: []
@@ -67063,11 +67216,11 @@ var todo_extract = createSwarmTool({
     const allEntries = [];
     for (const filePath of filesToScan) {
       try {
-        const fileStat = fs49.statSync(filePath);
+        const fileStat = fs50.statSync(filePath);
         if (fileStat.size > MAX_FILE_SIZE_BYTES8) {
           continue;
         }
-        const content = fs49.readFileSync(filePath, "utf-8");
+        const content = fs50.readFileSync(filePath, "utf-8");
         const entries = parseTodoComments(content, filePath, tagsSet);
         allEntries.push(...entries);
       } catch {}
@@ -67096,18 +67249,18 @@ var todo_extract = createSwarmTool({
 init_tool();
 init_schema();
 init_gate_evidence();
-import * as fs51 from "fs";
-import * as path64 from "path";
+import * as fs52 from "fs";
+import * as path65 from "path";
 
 // src/hooks/diff-scope.ts
-import * as fs50 from "fs";
-import * as path63 from "path";
+import * as fs51 from "fs";
+import * as path64 from "path";
 function getDeclaredScope(taskId, directory) {
   try {
-    const planPath = path63.join(directory, ".swarm", "plan.json");
-    if (!fs50.existsSync(planPath))
+    const planPath = path64.join(directory, ".swarm", "plan.json");
+    if (!fs51.existsSync(planPath))
       return null;
-    const raw = fs50.readFileSync(planPath, "utf-8");
+    const raw = fs51.readFileSync(planPath, "utf-8");
     const plan = JSON.parse(raw);
     for (const phase of plan.phases ?? []) {
       for (const task of phase.tasks ?? []) {
@@ -67220,7 +67373,7 @@ var TIER_3_PATTERNS = [
 ];
 function matchesTier3Pattern(files) {
   for (const file3 of files) {
-    const fileName = path64.basename(file3);
+    const fileName = path65.basename(file3);
     for (const pattern of TIER_3_PATTERNS) {
       if (pattern.test(fileName)) {
         return true;
@@ -67234,8 +67387,8 @@ function checkReviewerGate(taskId, workingDirectory) {
     if (hasActiveTurboMode()) {
       const resolvedDir2 = workingDirectory;
       try {
-        const planPath = path64.join(resolvedDir2, ".swarm", "plan.json");
-        const planRaw = fs51.readFileSync(planPath, "utf-8");
+        const planPath = path65.join(resolvedDir2, ".swarm", "plan.json");
+        const planRaw = fs52.readFileSync(planPath, "utf-8");
         const plan = JSON.parse(planRaw);
         for (const planPhase of plan.phases ?? []) {
           for (const task of planPhase.tasks ?? []) {
@@ -67301,8 +67454,8 @@ function checkReviewerGate(taskId, workingDirectory) {
     }
     try {
       const resolvedDir2 = workingDirectory;
-      const planPath = path64.join(resolvedDir2, ".swarm", "plan.json");
-      const planRaw = fs51.readFileSync(planPath, "utf-8");
+      const planPath = path65.join(resolvedDir2, ".swarm", "plan.json");
+      const planRaw = fs52.readFileSync(planPath, "utf-8");
       const plan = JSON.parse(planRaw);
       for (const planPhase of plan.phases ?? []) {
         for (const task of planPhase.tasks ?? []) {
@@ -67484,8 +67637,8 @@ async function executeUpdateTaskStatus(args2, fallbackDir) {
         };
       }
     }
-    normalizedDir = path64.normalize(args2.working_directory);
-    const pathParts = normalizedDir.split(path64.sep);
+    normalizedDir = path65.normalize(args2.working_directory);
+    const pathParts = normalizedDir.split(path65.sep);
     if (pathParts.includes("..")) {
       return {
         success: false,
@@ -67495,11 +67648,11 @@ async function executeUpdateTaskStatus(args2, fallbackDir) {
         ]
       };
     }
-    const resolvedDir = path64.resolve(normalizedDir);
+    const resolvedDir = path65.resolve(normalizedDir);
     try {
-      const realPath = fs51.realpathSync(resolvedDir);
-      const planPath = path64.join(realPath, ".swarm", "plan.json");
-      if (!fs51.existsSync(planPath)) {
+      const realPath = fs52.realpathSync(resolvedDir);
+      const planPath = path65.join(realPath, ".swarm", "plan.json");
+      if (!fs52.existsSync(planPath)) {
         return {
           success: false,
           message: `Invalid working_directory: plan not found in "${realPath}"`,
@@ -67532,8 +67685,8 @@ async function executeUpdateTaskStatus(args2, fallbackDir) {
     recoverTaskStateFromDelegations(args2.task_id);
     let phaseRequiresReviewer = true;
     try {
-      const planPath = path64.join(directory, ".swarm", "plan.json");
-      const planRaw = fs51.readFileSync(planPath, "utf-8");
+      const planPath = path65.join(directory, ".swarm", "plan.json");
+      const planRaw = fs52.readFileSync(planPath, "utf-8");
       const plan = JSON.parse(planRaw);
       const taskPhase = plan.phases.find((p) => p.tasks.some((t) => t.id === args2.task_id));
       if (taskPhase?.required_agents && !taskPhase.required_agents.includes("reviewer")) {
@@ -67596,8 +67749,8 @@ var update_task_status = createSwarmTool({
 init_tool();
 init_utils2();
 init_create_tool();
-import fs52 from "fs";
-import path65 from "path";
+import fs53 from "fs";
+import path66 from "path";
 function normalizeVerdict(verdict) {
   switch (verdict) {
     case "APPROVED":
@@ -67644,7 +67797,7 @@ async function executeWriteDriftEvidence(args2, directory) {
     entries: [evidenceEntry]
   };
   const filename = "drift-verifier.json";
-  const relativePath = path65.join("evidence", String(phase), filename);
+  const relativePath = path66.join("evidence", String(phase), filename);
   let validatedPath;
   try {
     validatedPath = validateSwarmPath(directory, relativePath);
@@ -67655,12 +67808,12 @@ async function executeWriteDriftEvidence(args2, directory) {
       message: error93 instanceof Error ? error93.message : "Failed to validate path"
     }, null, 2);
   }
-  const evidenceDir = path65.dirname(validatedPath);
+  const evidenceDir = path66.dirname(validatedPath);
   try {
-    await fs52.promises.mkdir(evidenceDir, { recursive: true });
-    const tempPath = path65.join(evidenceDir, `.${filename}.tmp`);
-    await fs52.promises.writeFile(tempPath, JSON.stringify(evidenceContent, null, 2), "utf-8");
-    await fs52.promises.rename(tempPath, validatedPath);
+    await fs53.promises.mkdir(evidenceDir, { recursive: true });
+    const tempPath = path66.join(evidenceDir, `.${filename}.tmp`);
+    await fs53.promises.writeFile(tempPath, JSON.stringify(evidenceContent, null, 2), "utf-8");
+    await fs53.promises.rename(tempPath, validatedPath);
     return JSON.stringify({
       success: true,
       phase,
@@ -67848,7 +68001,7 @@ var OpenCodeSwarm = async (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 = path66.resolve(ctx.directory, ".swarm");
+    const swarmDir = path67.resolve(ctx.directory, ".swarm");
     statusArtifact = new ASA(swarmDir);
     statusArtifact.updateConfig(automationConfig.mode, automationConfig.capabilities);
     if (automationConfig.capabilities?.evidence_auto_summaries === true) {