opencode-swarm 7.56.0 → 7.56.1

package/dist/cli/index.js

@@ -52,7 +52,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "opencode-swarm",
-    version: "7.56.0",
+    version: "7.56.1",
     description: "Architect-centric agentic swarm plugin for OpenCode - hub-and-spoke orchestration with SME consultation, code generation, and QA review",
     main: "dist/index.js",
     types: "dist/index.d.ts",
@@ -42920,7 +42920,7 @@ var init_profiles = __esm(() => {
       detectFiles: ["Cargo.toml"],
       frameworks: [
         {
-          name: "cargo test",
+          name: "cargo",
           detect: "Cargo.toml",
           cmd: "cargo test",
           priority: 10
@@ -42992,7 +42992,7 @@ var init_profiles = __esm(() => {
     test: {
       detectFiles: ["go.mod"],
       frameworks: [
-        { name: "go test", detect: "go.mod", cmd: "go test ./...", priority: 10 }
+        { name: "go-test", detect: "go.mod", cmd: "go test ./...", priority: 10 }
       ]
     },
     lint: {
@@ -43067,13 +43067,13 @@ var init_profiles = __esm(() => {
       detectFiles: ["pom.xml", "build.gradle", "build.gradle.kts"],
       frameworks: [
         {
-          name: "maven-test",
+          name: "maven",
           detect: "pom.xml",
           cmd: "mvn test -q",
           priority: 10
         },
         {
-          name: "gradle-test",
+          name: "gradle",
           detect: "build.gradle",
           cmd: "gradle test -q",
           priority: 9
@@ -43151,13 +43151,13 @@ var init_profiles = __esm(() => {
       detectFiles: ["build.gradle.kts", "build.gradle"],
       frameworks: [
         {
-          name: "gradle-test",
+          name: "gradle",
           detect: "build.gradle.kts",
           cmd: "gradle test -q",
           priority: 10
         },
         {
-          name: "gradle-test-groovy",
+          name: "gradle",
           detect: "build.gradle",
           cmd: "gradle test -q",
           priority: 9
@@ -43165,11 +43165,11 @@ var init_profiles = __esm(() => {
       ]
     },
     lint: {
-      detectFiles: [".editorconfig", "build.gradle.kts"],
+      detectFiles: ["build.gradle.kts", "build.gradle"],
       linters: [
         {
           name: "ktlint",
-          detect: ".editorconfig",
+          detect: "build.gradle.kts",
           cmd: "ktlint --format",
           priority: 10
         }
@@ -43229,7 +43229,7 @@ var init_profiles = __esm(() => {
       detectFiles: ["*.csproj", "*.sln"],
       frameworks: [
         {
-          name: "dotnet test",
+          name: "dotnet-test",
           detect: "*.csproj",
           cmd: "dotnet test",
           priority: 10
@@ -43380,7 +43380,7 @@ var init_profiles = __esm(() => {
       detectFiles: ["Package.swift", "*.xcodeproj"],
       frameworks: [
         {
-          name: "swift test",
+          name: "swift-test",
           detect: "Package.swift",
           cmd: "swift test",
           priority: 10
@@ -43707,8 +43707,14 @@ async function detectProjectLanguages(projectDir) {
     }
     for (const profile of LANGUAGE_REGISTRY.getAll()) {
       for (const detectFile of profile.build.detectFiles) {
-        if (detectFile.includes("*") || detectFile.includes("?"))
+        if (detectFile.includes("*") || detectFile.includes("?")) {
+          const regex = new RegExp(`^${detectFile.replace(/\./g, "\\.").replace(/\*/g, ".*").replace(/\?/g, ".")}$`);
+          if (entries.some((name) => regex.test(name))) {
+            detected.add(profile.id);
+            break;
+          }
           continue;
+        }
         try {
           await access3(join24(dir, detectFile));
           detected.add(profile.id);
@@ -53161,12 +53167,85 @@ var init_registry_backend = __esm(() => {
   LANGUAGE_BACKEND_REGISTRY = new LanguageBackendRegistry;
 });
 
-// src/lang/backends/typescript.ts
+// src/lang/framework-detector.ts
 import * as fs21 from "fs";
 import * as path43 from "path";
+function detectLaravelProject(directory) {
+  const signals = getLaravelSignals(directory);
+  const signalCount = [
+    signals.hasArtisanFile,
+    signals.hasLaravelFrameworkDep,
+    signals.hasConfigApp
+  ].filter(Boolean).length;
+  return signalCount >= 2;
+}
+function getLaravelSignals(directory) {
+  const hasArtisanFile = checkArtisanFile(directory);
+  const hasLaravelFrameworkDep = checkLaravelFrameworkDep(directory);
+  const hasConfigApp = checkConfigApp(directory);
+  return { hasArtisanFile, hasLaravelFrameworkDep, hasConfigApp };
+}
+function checkArtisanFile(directory) {
+  const artisanPath = path43.join(directory, "artisan");
+  if (!fs21.existsSync(artisanPath))
+    return false;
+  try {
+    return fs21.statSync(artisanPath).isFile();
+  } catch {
+    return false;
+  }
+}
+function checkLaravelFrameworkDep(directory) {
+  const composerPath = path43.join(directory, "composer.json");
+  if (!fs21.existsSync(composerPath))
+    return false;
+  try {
+    const content = fs21.readFileSync(composerPath, "utf-8");
+    const parsed = JSON.parse(content);
+    const require2 = parsed?.require ?? {};
+    return typeof require2["laravel/framework"] === "string";
+  } catch {
+    return false;
+  }
+}
+function checkConfigApp(directory) {
+  return fs21.existsSync(path43.join(directory, "config", "app.php"));
+}
+var init_framework_detector = () => {};
+
+// src/lang/backends/php.ts
+async function selectFramework3(dir) {
+  if (detectLaravelProject(dir)) {
+    return {
+      name: "laravel",
+      detectedVia: "Laravel signals (artisan / composer.json / config/app.php)"
+    };
+  }
+  return null;
+}
+function buildPhpBackend() {
+  const profile = LANGUAGE_REGISTRY.get(PROFILE_ID3);
+  if (!profile) {
+    throw new Error("buildPhpBackend: php profile not in LANGUAGE_REGISTRY. " + "profiles.ts must be imported before this backend.");
+  }
+  return {
+    ...defaultBackendFor(profile),
+    selectFramework: selectFramework3
+  };
+}
+var PROFILE_ID3 = "php";
+var init_php = __esm(() => {
+  init_default_backend();
+  init_framework_detector();
+  init_profiles();
+});
+
+// src/lang/backends/typescript.ts
+import * as fs22 from "fs";
+import * as path44 from "path";
 function readPackageJsonRaw(dir) {
   try {
-    const content = fs21.readFileSync(path43.join(dir, "package.json"), "utf-8");
+    const content = fs22.readFileSync(path44.join(dir, "package.json"), "utf-8");
     return JSON.parse(content);
   } catch {
     return null;
@@ -53216,7 +53295,7 @@ function selectionFromFramework(profile, fwName, dir, detectedVia) {
   };
 }
 async function selectTestFramework(dir) {
-  const profile = LANGUAGE_REGISTRY.get(PROFILE_ID3);
+  const profile = LANGUAGE_REGISTRY.get(PROFILE_ID4);
   if (!profile)
     return null;
   const pkg = readPackageJson(dir);
@@ -53238,7 +53317,7 @@ async function selectTestFramework(dir) {
   return defaultSelectTestFramework(profile, dir);
 }
 function buildTestCommand(framework, files, dir, opts) {
-  const profile = LANGUAGE_REGISTRY.get(PROFILE_ID3);
+  const profile = LANGUAGE_REGISTRY.get(PROFILE_ID4);
   if (!profile)
     return null;
   return defaultBuildTestCommand(profile, framework, files, dir, opts);
@@ -53246,7 +53325,7 @@ function buildTestCommand(framework, files, dir, opts) {
 function parseTestOutput(framework, stdout, stderr, exitCode) {
   return defaultParseTestOutput(framework, stdout, stderr, exitCode);
 }
-async function selectFramework3(dir) {
+async function selectFramework4(dir) {
   const pkg = readPackageJson(dir);
   if (!pkg)
     return null;
@@ -53315,19 +53394,19 @@ function extractImports4(_sourceFile, source) {
   return [...out];
 }
 async function selectBuildCommand(dir) {
-  const profile = LANGUAGE_REGISTRY.get(PROFILE_ID3);
+  const profile = LANGUAGE_REGISTRY.get(PROFILE_ID4);
   if (!profile)
     return null;
   return defaultSelectBuildCommand(profile, dir);
 }
 async function testFilesFor(sourceFile, dir) {
-  const profile = LANGUAGE_REGISTRY.get(PROFILE_ID3);
+  const profile = LANGUAGE_REGISTRY.get(PROFILE_ID4);
   if (!profile)
     return [];
   return defaultTestFilesFor(profile, sourceFile, dir);
 }
 function buildTypescriptBackend() {
-  const profile = LANGUAGE_REGISTRY.get(PROFILE_ID3);
+  const profile = LANGUAGE_REGISTRY.get(PROFILE_ID4);
   if (!profile) {
     throw new Error("buildTypescriptBackend: typescript profile not in LANGUAGE_REGISTRY. " + "profiles.ts must be imported before this backend.");
   }
@@ -53339,11 +53418,11 @@ function buildTypescriptBackend() {
     extractImports: extractImports4,
     selectBuildCommand,
     testFilesFor,
-    selectFramework: selectFramework3,
+    selectFramework: selectFramework4,
     selectEntryPoints: selectEntryPoints3
   };
 }
-var PROFILE_ID3 = "typescript", IMPORT_REGEX_ES2, IMPORT_REGEX_BARE, IMPORT_REGEX_REQUIRE2, IMPORT_REGEX_DYNAMIC, IMPORT_REGEX_REEXPORT2, _internals28;
+var PROFILE_ID4 = "typescript", IMPORT_REGEX_ES2, IMPORT_REGEX_BARE, IMPORT_REGEX_REQUIRE2, IMPORT_REGEX_DYNAMIC, IMPORT_REGEX_REEXPORT2, _internals28;
 var init_typescript = __esm(() => {
   init_default_backend();
   init_profiles();
@@ -53366,12 +53445,14 @@ function registerAllBackends() {
   LANGUAGE_BACKEND_REGISTRY.register(buildTypescriptBackend());
   LANGUAGE_BACKEND_REGISTRY.register(buildPythonBackend());
   LANGUAGE_BACKEND_REGISTRY.register(buildGoBackend());
+  LANGUAGE_BACKEND_REGISTRY.register(buildPhpBackend());
   registered = true;
 }
 var registered = false;
 var init_backends = __esm(() => {
   init_registry_backend();
   init_go();
+  init_php();
   init_python();
   init_typescript();
   registerAllBackends();
@@ -53385,11 +53466,11 @@ __export(exports_dispatch, {
   clearDispatchCache: () => clearDispatchCache,
   _internals: () => _internals29
 });
-import * as fs22 from "fs";
-import * as path44 from "path";
+import * as fs23 from "fs";
+import * as path45 from "path";
 function safeReaddirSet(dir) {
   try {
-    return new Set(fs22.readdirSync(dir));
+    return new Set(fs23.readdirSync(dir));
   } catch {
     return new Set;
   }
@@ -53403,14 +53484,14 @@ function manifestHash(dir) {
     if (!entries.has(name))
       continue;
     try {
-      const stat4 = fs22.statSync(path44.join(dir, name));
+      const stat4 = fs23.statSync(path45.join(dir, name));
       parts.push(`${name}:${stat4.size}:${stat4.mtimeMs}:${stat4.ino}`);
     } catch {}
   }
   return parts.join("|");
 }
 function findManifestRoot(start) {
-  const resolved = path44.resolve(start);
+  const resolved = path45.resolve(start);
   const cached3 = manifestRootCache.get(resolved);
   if (cached3 !== undefined)
     return cached3;
@@ -53429,7 +53510,7 @@ function findManifestRoot(start) {
         return cur;
       }
     }
-    const parent = path44.dirname(cur);
+    const parent = path45.dirname(cur);
     if (parent === cur)
       break;
     cur = parent;
@@ -53538,14 +53619,14 @@ var init_dispatch = __esm(() => {
 });
 
 // src/tools/test-runner.ts
-import * as fs23 from "fs";
-import * as path45 from "path";
+import * as fs24 from "fs";
+import * as path46 from "path";
 async function estimateFanOut(sourceFiles, cwd) {
   try {
     const impactMap = await loadImpactMap(cwd, { skipRebuild: true });
     const uniqueTestFiles = new Set;
     for (const sourceFile of sourceFiles) {
-      const resolvedPath = path45.resolve(cwd, sourceFile);
+      const resolvedPath = path46.resolve(cwd, sourceFile);
       const normalizedPath = resolvedPath.replace(/\\/g, "/");
       const testFiles = impactMap[normalizedPath];
       if (testFiles) {
@@ -53627,19 +53708,19 @@ function hasDevDependency(devDeps, ...patterns) {
   return hasPackageJsonDependency(devDeps, ...patterns);
 }
 function detectGoTest(cwd) {
-  return fs23.existsSync(path45.join(cwd, "go.mod")) && isCommandAvailable("go");
+  return fs24.existsSync(path46.join(cwd, "go.mod")) && isCommandAvailable("go");
 }
 function detectJavaMaven(cwd) {
-  return fs23.existsSync(path45.join(cwd, "pom.xml")) && isCommandAvailable("mvn");
+  return fs24.existsSync(path46.join(cwd, "pom.xml")) && isCommandAvailable("mvn");
 }
 function detectGradle(cwd) {
-  const hasBuildFile = fs23.existsSync(path45.join(cwd, "build.gradle")) || fs23.existsSync(path45.join(cwd, "build.gradle.kts"));
-  const hasGradlew = fs23.existsSync(path45.join(cwd, "gradlew")) || fs23.existsSync(path45.join(cwd, "gradlew.bat"));
+  const hasBuildFile = fs24.existsSync(path46.join(cwd, "build.gradle")) || fs24.existsSync(path46.join(cwd, "build.gradle.kts"));
+  const hasGradlew = fs24.existsSync(path46.join(cwd, "gradlew")) || fs24.existsSync(path46.join(cwd, "gradlew.bat"));
   return hasBuildFile && (hasGradlew || isCommandAvailable("gradle"));
 }
 function detectDotnetTest(cwd) {
   try {
-    const files = fs23.readdirSync(cwd);
+    const files = fs24.readdirSync(cwd);
     const hasCsproj = files.some((f) => f.endsWith(".csproj"));
     return hasCsproj && isCommandAvailable("dotnet");
   } catch {
@@ -53647,25 +53728,25 @@ function detectDotnetTest(cwd) {
   }
 }
 function detectCTest(cwd) {
-  const hasSource = fs23.existsSync(path45.join(cwd, "CMakeLists.txt"));
-  const hasBuildCache = fs23.existsSync(path45.join(cwd, "CMakeCache.txt")) || fs23.existsSync(path45.join(cwd, "build", "CMakeCache.txt"));
+  const hasSource = fs24.existsSync(path46.join(cwd, "CMakeLists.txt"));
+  const hasBuildCache = fs24.existsSync(path46.join(cwd, "CMakeCache.txt")) || fs24.existsSync(path46.join(cwd, "build", "CMakeCache.txt"));
   return (hasSource || hasBuildCache) && isCommandAvailable("ctest");
 }
 function detectSwiftTest(cwd) {
-  return fs23.existsSync(path45.join(cwd, "Package.swift")) && isCommandAvailable("swift");
+  return fs24.existsSync(path46.join(cwd, "Package.swift")) && isCommandAvailable("swift");
 }
 function detectDartTest(cwd) {
-  return fs23.existsSync(path45.join(cwd, "pubspec.yaml")) && (isCommandAvailable("dart") || isCommandAvailable("flutter"));
+  return fs24.existsSync(path46.join(cwd, "pubspec.yaml")) && (isCommandAvailable("dart") || isCommandAvailable("flutter"));
 }
 function detectRSpec(cwd) {
-  const hasRSpecFile = fs23.existsSync(path45.join(cwd, ".rspec"));
-  const hasGemfile = fs23.existsSync(path45.join(cwd, "Gemfile"));
-  const hasSpecDir = fs23.existsSync(path45.join(cwd, "spec"));
+  const hasRSpecFile = fs24.existsSync(path46.join(cwd, ".rspec"));
+  const hasGemfile = fs24.existsSync(path46.join(cwd, "Gemfile"));
+  const hasSpecDir = fs24.existsSync(path46.join(cwd, "spec"));
   const hasRSpec = hasRSpecFile || hasGemfile && hasSpecDir;
   return hasRSpec && (isCommandAvailable("bundle") || isCommandAvailable("rspec"));
 }
 function detectMinitest(cwd) {
-  return fs23.existsSync(path45.join(cwd, "test")) && (fs23.existsSync(path45.join(cwd, "Gemfile")) || fs23.existsSync(path45.join(cwd, "Rakefile"))) && isCommandAvailable("ruby");
+  return fs24.existsSync(path46.join(cwd, "test")) && (fs24.existsSync(path46.join(cwd, "Gemfile")) || fs24.existsSync(path46.join(cwd, "Rakefile"))) && isCommandAvailable("ruby");
 }
 async function detectTestFrameworkViaDispatch(cwd) {
   try {
@@ -53728,9 +53809,9 @@ async function parseTestOutputViaDispatch(framework, output, baseDir) {
 async function detectTestFramework(cwd) {
   const baseDir = cwd;
   try {
-    const packageJsonPath = path45.join(baseDir, "package.json");
-    if (fs23.existsSync(packageJsonPath)) {
-      const content = fs23.readFileSync(packageJsonPath, "utf-8");
+    const packageJsonPath = path46.join(baseDir, "package.json");
+    if (fs24.existsSync(packageJsonPath)) {
+      const content = fs24.readFileSync(packageJsonPath, "utf-8");
       const pkg = JSON.parse(content);
       const _deps = pkg.dependencies || {};
       const devDeps = pkg.devDependencies || {};
@@ -53749,38 +53830,38 @@ async function detectTestFramework(cwd) {
         return "jest";
       if (hasDevDependency(devDeps, "mocha", "@types/mocha"))
         return "mocha";
-      if (fs23.existsSync(path45.join(baseDir, "bun.lockb")) || fs23.existsSync(path45.join(baseDir, "bun.lock"))) {
+      if (fs24.existsSync(path46.join(baseDir, "bun.lockb")) || fs24.existsSync(path46.join(baseDir, "bun.lock"))) {
         if (scripts.test?.includes("bun"))
           return "bun";
       }
     }
   } catch {}
   try {
-    const pyprojectTomlPath = path45.join(baseDir, "pyproject.toml");
-    const setupCfgPath = path45.join(baseDir, "setup.cfg");
-    const requirementsTxtPath = path45.join(baseDir, "requirements.txt");
-    if (fs23.existsSync(pyprojectTomlPath)) {
-      const content = fs23.readFileSync(pyprojectTomlPath, "utf-8");
+    const pyprojectTomlPath = path46.join(baseDir, "pyproject.toml");
+    const setupCfgPath = path46.join(baseDir, "setup.cfg");
+    const requirementsTxtPath = path46.join(baseDir, "requirements.txt");
+    if (fs24.existsSync(pyprojectTomlPath)) {
+      const content = fs24.readFileSync(pyprojectTomlPath, "utf-8");
       if (content.includes("[tool.pytest"))
         return "pytest";
       if (content.includes("pytest"))
         return "pytest";
     }
-    if (fs23.existsSync(setupCfgPath)) {
-      const content = fs23.readFileSync(setupCfgPath, "utf-8");
+    if (fs24.existsSync(setupCfgPath)) {
+      const content = fs24.readFileSync(setupCfgPath, "utf-8");
       if (content.includes("[pytest]"))
         return "pytest";
     }
-    if (fs23.existsSync(requirementsTxtPath)) {
-      const content = fs23.readFileSync(requirementsTxtPath, "utf-8");
+    if (fs24.existsSync(requirementsTxtPath)) {
+      const content = fs24.readFileSync(requirementsTxtPath, "utf-8");
       if (content.includes("pytest"))
         return "pytest";
     }
   } catch {}
   try {
-    const cargoTomlPath = path45.join(baseDir, "Cargo.toml");
-    if (fs23.existsSync(cargoTomlPath)) {
-      const content = fs23.readFileSync(cargoTomlPath, "utf-8");
+    const cargoTomlPath = path46.join(baseDir, "Cargo.toml");
+    if (fs24.existsSync(cargoTomlPath)) {
+      const content = fs24.readFileSync(cargoTomlPath, "utf-8");
       if (content.includes("[dev-dependencies]")) {
         if (content.includes("tokio") || content.includes("mockall") || content.includes("pretty_assertions")) {
           return "cargo";
@@ -53789,10 +53870,10 @@ async function detectTestFramework(cwd) {
     }
   } catch {}
   try {
-    const pesterConfigPath = path45.join(baseDir, "pester.config.ps1");
-    const pesterConfigJsonPath = path45.join(baseDir, "pester.config.ps1.json");
-    const pesterPs1Path = path45.join(baseDir, "tests.ps1");
-    if (fs23.existsSync(pesterConfigPath) || fs23.existsSync(pesterConfigJsonPath) || fs23.existsSync(pesterPs1Path)) {
+    const pesterConfigPath = path46.join(baseDir, "pester.config.ps1");
+    const pesterConfigJsonPath = path46.join(baseDir, "pester.config.ps1.json");
+    const pesterPs1Path = path46.join(baseDir, "tests.ps1");
+    if (fs24.existsSync(pesterConfigPath) || fs24.existsSync(pesterConfigJsonPath) || fs24.existsSync(pesterPs1Path)) {
       return "pester";
     }
   } catch {}
@@ -53820,12 +53901,12 @@ function isTestDirectoryPath(normalizedPath) {
   return normalizedPath.split("/").some((segment) => TEST_DIRECTORY_NAMES.includes(segment));
 }
 function resolveWorkspacePath(file3, workingDir) {
-  return path45.isAbsolute(file3) ? path45.resolve(file3) : path45.resolve(workingDir, file3);
+  return path46.isAbsolute(file3) ? path46.resolve(file3) : path46.resolve(workingDir, file3);
 }
 function toWorkspaceOutputPath(absolutePath, workingDir, preferRelative) {
   if (!preferRelative)
     return absolutePath;
-  return path45.relative(workingDir, absolutePath);
+  return path46.relative(workingDir, absolutePath);
 }
 function dedupePush(target, value) {
   if (!target.includes(value)) {
@@ -53862,18 +53943,18 @@ function buildLanguageSpecificTestNames(nameWithoutExt, ext) {
   }
 }
 function getRepoLevelCandidateDirectories(workingDir, relativePath, ext) {
-  const relativeDir = path45.dirname(relativePath);
+  const relativeDir = path46.dirname(relativePath);
   const nestedRelativeDir = relativeDir === "." ? "" : relativeDir;
   const directories = TEST_DIRECTORY_NAMES.flatMap((dirName) => {
-    const rootDir = path45.join(workingDir, dirName);
-    return nestedRelativeDir ? [rootDir, path45.join(rootDir, nestedRelativeDir)] : [rootDir];
+    const rootDir = path46.join(workingDir, dirName);
+    return nestedRelativeDir ? [rootDir, path46.join(rootDir, nestedRelativeDir)] : [rootDir];
   });
   const normalizedRelativePath = relativePath.replace(/\\/g, "/");
   if (ext === ".java" && normalizedRelativePath.startsWith("src/main/java/")) {
-    directories.push(path45.join(workingDir, "src/test/java", path45.dirname(normalizedRelativePath.slice("src/main/java/".length))));
+    directories.push(path46.join(workingDir, "src/test/java", path46.dirname(normalizedRelativePath.slice("src/main/java/".length))));
   }
   if ((ext === ".kt" || ext === ".java") && normalizedRelativePath.startsWith("src/main/kotlin/")) {
-    directories.push(path45.join(workingDir, "src/test/kotlin", path45.dirname(normalizedRelativePath.slice("src/main/kotlin/".length))));
+    directories.push(path46.join(workingDir, "src/test/kotlin", path46.dirname(normalizedRelativePath.slice("src/main/kotlin/".length))));
   }
   return [...new Set(directories)];
 }
@@ -53901,23 +53982,23 @@ function isLanguageSpecificTestFile(basename7) {
 }
 function isConventionTestFilePath(filePath) {
   const normalizedPath = filePath.replace(/\\/g, "/");
-  const basename7 = path45.basename(filePath);
+  const basename7 = path46.basename(filePath);
   return hasCompoundTestExtension(basename7) || basename7.includes(".spec.") || basename7.includes(".test.") || isLanguageSpecificTestFile(basename7) || isTestDirectoryPath(normalizedPath);
 }
 function getTestFilesFromConvention(sourceFiles, workingDir = process.cwd()) {
   const testFiles = [];
   for (const file3 of sourceFiles) {
     const absoluteFile = resolveWorkspacePath(file3, workingDir);
-    const relativeFile = path45.relative(workingDir, absoluteFile);
-    const basename7 = path45.basename(absoluteFile);
-    const dirname23 = path45.dirname(absoluteFile);
-    const preferRelativeOutput = !path45.isAbsolute(file3);
+    const relativeFile = path46.relative(workingDir, absoluteFile);
+    const basename7 = path46.basename(absoluteFile);
+    const dirname23 = path46.dirname(absoluteFile);
+    const preferRelativeOutput = !path46.isAbsolute(file3);
     if (isConventionTestFilePath(relativeFile) || isConventionTestFilePath(file3)) {
       dedupePush(testFiles, toWorkspaceOutputPath(absoluteFile, workingDir, preferRelativeOutput));
       continue;
     }
     const nameWithoutExt = basename7.replace(/\.[^.]+$/, "");
-    const ext = path45.extname(basename7);
+    const ext = path46.extname(basename7);
     const genericTestNames = [
       `${nameWithoutExt}.spec${ext}`,
       `${nameWithoutExt}.test${ext}`
@@ -53926,7 +54007,7 @@ function getTestFilesFromConvention(sourceFiles, workingDir = process.cwd()) {
     const colocatedCandidates = [
       ...genericTestNames,
       ...languageSpecificTestNames
-    ].map((candidateName) => path45.join(dirname23, candidateName));
+    ].map((candidateName) => path46.join(dirname23, candidateName));
     const testDirectoryNames = [
       basename7,
       ...genericTestNames,
@@ -53935,11 +54016,11 @@ function getTestFilesFromConvention(sourceFiles, workingDir = process.cwd()) {
     const repoLevelDirectories = getRepoLevelCandidateDirectories(workingDir, relativeFile, ext);
     const possibleTestFiles = [
       ...colocatedCandidates,
-      ...TEST_DIRECTORY_NAMES.flatMap((dirName) => testDirectoryNames.map((candidateName) => path45.join(dirname23, dirName, candidateName))),
-      ...repoLevelDirectories.flatMap((candidateDir) => testDirectoryNames.map((candidateName) => path45.join(candidateDir, candidateName)))
+      ...TEST_DIRECTORY_NAMES.flatMap((dirName) => testDirectoryNames.map((candidateName) => path46.join(dirname23, dirName, candidateName))),
+      ...repoLevelDirectories.flatMap((candidateDir) => testDirectoryNames.map((candidateName) => path46.join(candidateDir, candidateName)))
     ];
     for (const testFile of possibleTestFiles) {
-      if (fs23.existsSync(testFile)) {
+      if (fs24.existsSync(testFile)) {
         dedupePush(testFiles, toWorkspaceOutputPath(testFile, workingDir, preferRelativeOutput));
       }
     }
@@ -53956,8 +54037,8 @@ async function getTestFilesFromGraph(sourceFiles, workingDir) {
   for (const testFile of candidateTestFiles) {
     try {
       const absoluteTestFile = resolveWorkspacePath(testFile, workingDir);
-      const content = fs23.readFileSync(absoluteTestFile, "utf-8");
-      const testDir = path45.dirname(absoluteTestFile);
+      const content = fs24.readFileSync(absoluteTestFile, "utf-8");
+      const testDir = path46.dirname(absoluteTestFile);
       const importRegex = /import\s+.*?\s+from\s+['"]([^'"]+)['"]/g;
       let match;
       match = importRegex.exec(content);
@@ -53965,8 +54046,8 @@ async function getTestFilesFromGraph(sourceFiles, workingDir) {
         const importPath = match[1];
         let resolvedImport;
         if (importPath.startsWith(".")) {
-          resolvedImport = path45.resolve(testDir, importPath);
-          const existingExt = path45.extname(resolvedImport);
+          resolvedImport = path46.resolve(testDir, importPath);
+          const existingExt = path46.extname(resolvedImport);
           if (!existingExt) {
             for (const extToTry of [
               ".ts",
@@ -53977,7 +54058,7 @@ async function getTestFilesFromGraph(sourceFiles, workingDir) {
               ".cjs"
             ]) {
               const withExt = resolvedImport + extToTry;
-              if (absoluteSourceFiles.includes(withExt) || fs23.existsSync(withExt)) {
+              if (absoluteSourceFiles.includes(withExt) || fs24.existsSync(withExt)) {
                 resolvedImport = withExt;
                 break;
               }
@@ -53986,12 +54067,12 @@ async function getTestFilesFromGraph(sourceFiles, workingDir) {
         } else {
           continue;
         }
-        const importBasename = path45.basename(resolvedImport, path45.extname(resolvedImport));
-        const importDir = path45.dirname(resolvedImport);
+        const importBasename = path46.basename(resolvedImport, path46.extname(resolvedImport));
+        const importDir = path46.dirname(resolvedImport);
         for (const sourceFile of absoluteSourceFiles) {
-          const sourceDir = path45.dirname(sourceFile);
-          const sourceBasename = path45.basename(sourceFile, path45.extname(sourceFile));
-          const isRelatedDir = importDir === sourceDir || importDir === path45.join(sourceDir, "__tests__") || importDir === path45.join(sourceDir, "tests") || importDir === path45.join(sourceDir, "test") || importDir === path45.join(sourceDir, "spec");
+          const sourceDir = path46.dirname(sourceFile);
+          const sourceBasename = path46.basename(sourceFile, path46.extname(sourceFile));
+          const isRelatedDir = importDir === sourceDir || importDir === path46.join(sourceDir, "__tests__") || importDir === path46.join(sourceDir, "tests") || importDir === path46.join(sourceDir, "test") || importDir === path46.join(sourceDir, "spec");
           if (resolvedImport === sourceFile || importBasename === sourceBasename && isRelatedDir) {
             dedupePush(testFiles, testFile);
             break;
@@ -54004,8 +54085,8 @@ async function getTestFilesFromGraph(sourceFiles, workingDir) {
       while (match !== null) {
         const importPath = match[1];
         if (importPath.startsWith(".")) {
-          let resolvedImport = path45.resolve(testDir, importPath);
-          const existingExt = path45.extname(resolvedImport);
+          let resolvedImport = path46.resolve(testDir, importPath);
+          const existingExt = path46.extname(resolvedImport);
           if (!existingExt) {
             for (const extToTry of [
               ".ts",
@@ -54016,18 +54097,18 @@ async function getTestFilesFromGraph(sourceFiles, workingDir) {
               ".cjs"
             ]) {
               const withExt = resolvedImport + extToTry;
-              if (absoluteSourceFiles.includes(withExt) || fs23.existsSync(withExt)) {
+              if (absoluteSourceFiles.includes(withExt) || fs24.existsSync(withExt)) {
                 resolvedImport = withExt;
                 break;
               }
             }
           }
-          const importDir = path45.dirname(resolvedImport);
-          const importBasename = path45.basename(resolvedImport, path45.extname(resolvedImport));
+          const importDir = path46.dirname(resolvedImport);
+          const importBasename = path46.basename(resolvedImport, path46.extname(resolvedImport));
           for (const sourceFile of absoluteSourceFiles) {
-            const sourceDir = path45.dirname(sourceFile);
-            const sourceBasename = path45.basename(sourceFile, path45.extname(sourceFile));
-            const isRelatedDir = importDir === sourceDir || importDir === path45.join(sourceDir, "__tests__") || importDir === path45.join(sourceDir, "tests") || importDir === path45.join(sourceDir, "test") || importDir === path45.join(sourceDir, "spec");
+            const sourceDir = path46.dirname(sourceFile);
+            const sourceBasename = path46.basename(sourceFile, path46.extname(sourceFile));
+            const isRelatedDir = importDir === sourceDir || importDir === path46.join(sourceDir, "__tests__") || importDir === path46.join(sourceDir, "tests") || importDir === path46.join(sourceDir, "test") || importDir === path46.join(sourceDir, "spec");
             if (resolvedImport === sourceFile || importBasename === sourceBasename && isRelatedDir) {
               dedupePush(testFiles, testFile);
               break;
@@ -54147,8 +54228,8 @@ function buildTestCommand2(framework, scope, files, coverage, baseDir, bail) {
       return ["mvn", "test"];
     case "gradle": {
       const isWindows = process.platform === "win32";
-      const hasGradlewBat = fs23.existsSync(path45.join(baseDir, "gradlew.bat"));
-      const hasGradlew = fs23.existsSync(path45.join(baseDir, "gradlew"));
+      const hasGradlewBat = fs24.existsSync(path46.join(baseDir, "gradlew.bat"));
+      const hasGradlew = fs24.existsSync(path46.join(baseDir, "gradlew"));
       if (hasGradlewBat && isWindows)
         return ["gradlew.bat", "test"];
       if (hasGradlew)
@@ -54165,7 +54246,7 @@ function buildTestCommand2(framework, scope, files, coverage, baseDir, bail) {
         "cmake-build-release",
         "out"
       ];
-      const actualBuildDir = buildDirCandidates.find((d) => fs23.existsSync(path45.join(baseDir, d, "CMakeCache.txt"))) ?? "build";
+      const actualBuildDir = buildDirCandidates.find((d) => fs24.existsSync(path46.join(baseDir, d, "CMakeCache.txt"))) ?? "build";
       return ["ctest", "--test-dir", actualBuildDir];
     }
     case "swift-test":
@@ -54599,13 +54680,13 @@ async function runTests(framework, scope, files, coverage, timeout_ms, cwd, bail
     };
   }
   const startTime = Date.now();
-  const vitestJsonOutputPath = framework === "vitest" ? path45.join(cwd, ".swarm", "cache", "test-runner-vitest.json") : undefined;
+  const vitestJsonOutputPath = framework === "vitest" ? path46.join(cwd, ".swarm", "cache", "test-runner-vitest.json") : undefined;
   try {
     if (vitestJsonOutputPath) {
       try {
-        fs23.mkdirSync(path45.dirname(vitestJsonOutputPath), { recursive: true });
-        if (fs23.existsSync(vitestJsonOutputPath)) {
-          fs23.unlinkSync(vitestJsonOutputPath);
+        fs24.mkdirSync(path46.dirname(vitestJsonOutputPath), { recursive: true });
+        if (fs24.existsSync(vitestJsonOutputPath)) {
+          fs24.unlinkSync(vitestJsonOutputPath);
         }
       } catch {}
     }
@@ -54631,8 +54712,8 @@ async function runTests(framework, scope, files, coverage, timeout_ms, cwd, bail
     }
     if (vitestJsonOutputPath) {
       try {
-        if (fs23.existsSync(vitestJsonOutputPath)) {
-          const vitestJsonOutput = fs23.readFileSync(vitestJsonOutputPath, "utf-8");
+        if (fs24.existsSync(vitestJsonOutputPath)) {
+          const vitestJsonOutput = fs24.readFileSync(vitestJsonOutputPath, "utf-8");
           if (vitestJsonOutput.trim().length > 0) {
             output += (output ? `
 ` : "") + vitestJsonOutput;
@@ -54719,10 +54800,10 @@ async function runTests(framework, scope, files, coverage, timeout_ms, cwd, bail
 }
 function normalizeHistoryTestFile(testFile, workingDir) {
   const normalized = testFile.replace(/\\/g, "/");
-  if (!path45.isAbsolute(testFile))
+  if (!path46.isAbsolute(testFile))
     return normalized;
-  const relative9 = path45.relative(workingDir, testFile);
-  if (relative9.startsWith("..") || path45.isAbsolute(relative9)) {
+  const relative9 = path46.relative(workingDir, testFile);
+  if (relative9.startsWith("..") || path46.isAbsolute(relative9)) {
     return normalized;
   }
   return relative9.replace(/\\/g, "/");
@@ -54829,28 +54910,26 @@ var init_test_runner = __esm(() => {
   init_resolve_working_directory();
   POWERSHELL_METACHARACTERS = /[|;&`$(){}[\]<>"'#*?\x00-\x1f]/;
   DISPATCH_FRAMEWORK_MAP = {
-    "bun:test": "bun",
     bun: "bun",
     vitest: "vitest",
     jest: "jest",
     mocha: "mocha",
     pytest: "pytest",
-    "cargo test": "cargo",
     cargo: "cargo",
     pester: "pester",
-    "go test": "go-test",
-    "maven-test": "maven",
-    "gradle-test": "gradle",
-    "gradle-test-groovy": "gradle",
-    "gradle-kts": "gradle",
-    "dotnet test": "dotnet-test",
+    "go-test": "go-test",
+    maven: "maven",
+    gradle: "gradle",
+    "dotnet-test": "dotnet-test",
     ctest: "ctest",
-    "swift test": "swift-test",
+    "swift-test": "swift-test",
+    "dart-test": "dart-test",
+    rspec: "rspec",
+    minitest: "minitest",
+    "bun:test": "bun",
     "xcodebuild-test": "swift-test",
     "flutter test": "dart-test",
-    "dart test": "dart-test",
-    rspec: "rspec",
-    minitest: "minitest"
+    "dart test": "dart-test"
   };
   COMPOUND_TEST_EXTENSIONS = [
     ".test.ts",
@@ -55062,7 +55141,7 @@ var init_test_runner = __esm(() => {
         const sourceFiles = args.files.filter((file3) => {
           if (directTestFiles.includes(file3))
             return false;
-          const ext = path45.extname(file3).toLowerCase();
+          const ext = path46.extname(file3).toLowerCase();
           return SOURCE_EXTENSIONS.has(ext);
         });
         const invalidFiles = args.files.filter((file3) => !directTestFiles.includes(file3) && !sourceFiles.includes(file3));
@@ -55108,7 +55187,7 @@ var init_test_runner = __esm(() => {
           if (isConventionTestFilePath(f)) {
             return false;
           }
-          const ext = path45.extname(f).toLowerCase();
+          const ext = path46.extname(f).toLowerCase();
           return SOURCE_EXTENSIONS.has(ext);
         });
         if (sourceFiles.length === 0) {
@@ -55158,7 +55237,7 @@ var init_test_runner = __esm(() => {
           if (isConventionTestFilePath(f)) {
             return false;
           }
-          const ext = path45.extname(f).toLowerCase();
+          const ext = path46.extname(f).toLowerCase();
           return SOURCE_EXTENSIONS.has(ext);
         });
         if (sourceFiles.length === 0) {
@@ -55210,8 +55289,8 @@ var init_test_runner = __esm(() => {
           }
           if (impactResult.impactedTests.length > 0) {
             testFiles = impactResult.impactedTests.map((absPath) => {
-              const relativePath = path45.relative(workingDir, absPath);
-              return path45.isAbsolute(relativePath) ? absPath : relativePath;
+              const relativePath = path46.relative(workingDir, absPath);
+              return path46.isAbsolute(relativePath) ? absPath : relativePath;
             });
           } else {
             graphFallbackReason = "no impacted tests found via impact analysis, falling back to graph";
@@ -55289,8 +55368,8 @@ var init_test_runner = __esm(() => {
 });
 
 // src/services/preflight-service.ts
-import * as fs24 from "fs";
-import * as path46 from "path";
+import * as fs25 from "fs";
+import * as path47 from "path";
 function validateDirectoryPath(dir) {
   if (!dir || typeof dir !== "string") {
     throw new Error("Directory path is required");
@@ -55298,8 +55377,8 @@ function validateDirectoryPath(dir) {
   if (dir.includes("..")) {
     throw new Error("Directory path must not contain path traversal sequences");
   }
-  const normalized = path46.normalize(dir);
-  const absolutePath = path46.isAbsolute(normalized) ? normalized : path46.resolve(normalized);
+  const normalized = path47.normalize(dir);
+  const absolutePath = path47.isAbsolute(normalized) ? normalized : path47.resolve(normalized);
   return absolutePath;
 }
 function validateTimeout(timeoutMs, defaultValue) {
@@ -55322,9 +55401,9 @@ function validateTimeout(timeoutMs, defaultValue) {
 }
 function getPackageVersion(dir) {
   try {
-    const packagePath = path46.join(dir, "package.json");
-    if (fs24.existsSync(packagePath)) {
-      const content = fs24.readFileSync(packagePath, "utf-8");
+    const packagePath = path47.join(dir, "package.json");
+    if (fs25.existsSync(packagePath)) {
+      const content = fs25.readFileSync(packagePath, "utf-8");
       const pkg = JSON.parse(content);
       return pkg.version ?? null;
     }
@@ -55333,9 +55412,9 @@ function getPackageVersion(dir) {
 }
 function getChangelogVersion(dir) {
   try {
-    const changelogPath = path46.join(dir, "CHANGELOG.md");
-    if (fs24.existsSync(changelogPath)) {
-      const content = fs24.readFileSync(changelogPath, "utf-8");
+    const changelogPath = path47.join(dir, "CHANGELOG.md");
+    if (fs25.existsSync(changelogPath)) {
+      const content = fs25.readFileSync(changelogPath, "utf-8");
       const match = content.match(/^##\s*\[?(\d+\.\d+\.\d+)\]?/m);
       if (match) {
         return match[1];
@@ -55347,10 +55426,10 @@ function getChangelogVersion(dir) {
 function getVersionFileVersion(dir) {
   const possibleFiles = ["VERSION.txt", "version.txt", "VERSION", "version"];
   for (const file3 of possibleFiles) {
-    const filePath = path46.join(dir, file3);
-    if (fs24.existsSync(filePath)) {
+    const filePath = path47.join(dir, file3);
+    if (fs25.existsSync(filePath)) {
       try {
-        const content = fs24.readFileSync(filePath, "utf-8").trim();
+        const content = fs25.readFileSync(filePath, "utf-8").trim();
         const match = content.match(/(\d+\.\d+\.\d+)/);
         if (match) {
           return match[1];
@@ -55689,8 +55768,8 @@ async function runEvidenceCheck(dir) {
 async function runRequirementCoverageCheck(dir, currentPhase) {
   const startTime = Date.now();
   try {
-    const specPath = path46.join(dir, ".swarm", "spec.md");
-    if (!fs24.existsSync(specPath)) {
+    const specPath = path47.join(dir, ".swarm", "spec.md");
+    if (!fs25.existsSync(specPath)) {
       return {
         type: "req_coverage",
         status: "skip",
@@ -56806,8 +56885,8 @@ var init_manager3 = __esm(() => {
 });
 
 // src/commands/reset.ts
-import * as fs25 from "fs";
-import * as path47 from "path";
+import * as fs26 from "fs";
+import * as path48 from "path";
 async function handleResetCommand(directory, args) {
   const hasConfirm = args.includes("--confirm");
   if (!hasConfirm) {
@@ -56835,8 +56914,8 @@ async function handleResetCommand(directory, args) {
   for (const filename of filesToReset) {
     try {
       const resolvedPath = validateSwarmPath(directory, filename);
-      if (fs25.existsSync(resolvedPath)) {
-        fs25.unlinkSync(resolvedPath);
+      if (fs26.existsSync(resolvedPath)) {
+        fs26.unlinkSync(resolvedPath);
         results.push(`- \u2705 Deleted ${filename}`);
       } else {
         results.push(`- \u23ED\uFE0F ${filename} not found (skipped)`);
@@ -56847,9 +56926,9 @@ async function handleResetCommand(directory, args) {
   }
   for (const filename of ["SWARM_PLAN.md", "SWARM_PLAN.json"]) {
     try {
-      const rootPath = path47.join(directory, filename);
-      if (fs25.existsSync(rootPath)) {
-        fs25.unlinkSync(rootPath);
+      const rootPath = path48.join(directory, filename);
+      if (fs26.existsSync(rootPath)) {
+        fs26.unlinkSync(rootPath);
         results.push(`- \u2705 Deleted ${filename} (root)`);
       }
     } catch {}
@@ -56862,8 +56941,8 @@ async function handleResetCommand(directory, args) {
   }
   try {
     const summariesPath = validateSwarmPath(directory, "summaries");
-    if (fs25.existsSync(summariesPath)) {
-      fs25.rmSync(summariesPath, { recursive: true, force: true });
+    if (fs26.existsSync(summariesPath)) {
+      fs26.rmSync(summariesPath, { recursive: true, force: true });
       results.push("- \u2705 Deleted summaries/ directory");
     } else {
       results.push("- \u23ED\uFE0F summaries/ not found (skipped)");
@@ -56886,14 +56965,14 @@ var init_reset = __esm(() => {
 });
 
 // src/commands/reset-session.ts
-import * as fs26 from "fs";
-import * as path48 from "path";
+import * as fs27 from "fs";
+import * as path49 from "path";
 async function handleResetSessionCommand(directory, _args) {
   const results = [];
   try {
     const statePath = validateSwarmPath(directory, "session/state.json");
-    if (fs26.existsSync(statePath)) {
-      fs26.unlinkSync(statePath);
+    if (fs27.existsSync(statePath)) {
+      fs27.unlinkSync(statePath);
       results.push("\u2705 Deleted .swarm/session/state.json");
     } else {
       results.push("\u23ED\uFE0F state.json not found (already clean)");
@@ -56902,15 +56981,15 @@ async function handleResetSessionCommand(directory, _args) {
     results.push("\u274C Failed to delete state.json");
   }
   try {
-    const sessionDir = path48.dirname(validateSwarmPath(directory, "session/state.json"));
-    if (fs26.existsSync(sessionDir)) {
-      const files = fs26.readdirSync(sessionDir);
+    const sessionDir = path49.dirname(validateSwarmPath(directory, "session/state.json"));
+    if (fs27.existsSync(sessionDir)) {
+      const files = fs27.readdirSync(sessionDir);
       const otherFiles = files.filter((f) => f !== "state.json");
       let deletedCount = 0;
       for (const file3 of otherFiles) {
-        const filePath = path48.join(sessionDir, file3);
-        if (fs26.lstatSync(filePath).isFile()) {
-          fs26.unlinkSync(filePath);
+        const filePath = path49.join(sessionDir, file3);
+        if (fs27.lstatSync(filePath).isFile()) {
+          fs27.unlinkSync(filePath);
           deletedCount++;
         }
       }
@@ -56940,7 +57019,7 @@ var init_reset_session = __esm(() => {
 });
 
 // src/summaries/manager.ts
-import * as path49 from "path";
+import * as path50 from "path";
 function sanitizeSummaryId(id) {
   if (!id || id.length === 0) {
     throw new Error("Invalid summary ID: empty string");
@@ -56963,7 +57042,7 @@ function sanitizeSummaryId(id) {
 }
 async function loadFullOutput(directory, id) {
   const sanitizedId = sanitizeSummaryId(id);
-  const relativePath = path49.join("summaries", `${sanitizedId}.json`);
+  const relativePath = path50.join("summaries", `${sanitizedId}.json`);
   validateSwarmPath(directory, relativePath);
   const content = await readSwarmFileAsync(directory, relativePath);
   if (content === null) {
@@ -57025,18 +57104,18 @@ var init_retrieve = __esm(() => {
 });
 
 // src/commands/rollback.ts
-import * as fs27 from "fs";
-import * as path50 from "path";
+import * as fs28 from "fs";
+import * as path51 from "path";
 async function handleRollbackCommand(directory, args) {
   const phaseArg = args[0];
   if (!phaseArg) {
     const manifestPath2 = validateSwarmPath(directory, "checkpoints/manifest.json");
-    if (!fs27.existsSync(manifestPath2)) {
+    if (!fs28.existsSync(manifestPath2)) {
       return "No checkpoints found. Use `/swarm checkpoint` to create checkpoints.";
     }
     let manifest2;
     try {
-      manifest2 = JSON.parse(fs27.readFileSync(manifestPath2, "utf-8"));
+      manifest2 = JSON.parse(fs28.readFileSync(manifestPath2, "utf-8"));
     } catch {
       return "Error: Checkpoint manifest is corrupted. Delete .swarm/checkpoints/manifest.json and re-checkpoint.";
     }
@@ -57058,12 +57137,12 @@ async function handleRollbackCommand(directory, args) {
     return "Error: Phase number must be a positive integer.";
   }
   const manifestPath = validateSwarmPath(directory, "checkpoints/manifest.json");
-  if (!fs27.existsSync(manifestPath)) {
+  if (!fs28.existsSync(manifestPath)) {
     return `Error: No checkpoints found. Cannot rollback to phase ${targetPhase}.`;
   }
   let manifest;
   try {
-    manifest = JSON.parse(fs27.readFileSync(manifestPath, "utf-8"));
+    manifest = JSON.parse(fs28.readFileSync(manifestPath, "utf-8"));
   } catch {
     return `Error: Checkpoint manifest is corrupted. Delete .swarm/checkpoints/manifest.json and re-checkpoint.`;
   }
@@ -57073,10 +57152,10 @@ async function handleRollbackCommand(directory, args) {
     return `Error: Checkpoint for phase ${targetPhase} not found. Available phases: ${available}`;
   }
   const checkpointDir = validateSwarmPath(directory, `checkpoints/phase-${targetPhase}`);
-  if (!fs27.existsSync(checkpointDir)) {
+  if (!fs28.existsSync(checkpointDir)) {
     return `Error: Checkpoint directory for phase ${targetPhase} does not exist.`;
   }
-  const checkpointFiles = fs27.readdirSync(checkpointDir);
+  const checkpointFiles = fs28.readdirSync(checkpointDir);
   if (checkpointFiles.length === 0) {
     return `Error: Checkpoint for phase ${targetPhase} is empty. Cannot rollback.`;
   }
@@ -57091,10 +57170,10 @@ async function handleRollbackCommand(directory, args) {
     if (EXCLUDE_FILES.has(file3) || file3.startsWith("plan-ledger.archived-")) {
       continue;
     }
-    const src = path50.join(checkpointDir, file3);
-    const dest = path50.join(swarmDir, file3);
+    const src = path51.join(checkpointDir, file3);
+    const dest = path51.join(swarmDir, file3);
     try {
-      fs27.cpSync(src, dest, { recursive: true, force: true });
+      fs28.cpSync(src, dest, { recursive: true, force: true });
       successes.push(file3);
     } catch (error93) {
       failures.push({ file: file3, error: error93.message });
@@ -57111,14 +57190,14 @@ async function handleRollbackCommand(directory, args) {
     ].join(`
 `);
   }
-  const existingLedgerPath = path50.join(swarmDir, "plan-ledger.jsonl");
-  if (fs27.existsSync(existingLedgerPath)) {
-    fs27.unlinkSync(existingLedgerPath);
+  const existingLedgerPath = path51.join(swarmDir, "plan-ledger.jsonl");
+  if (fs28.existsSync(existingLedgerPath)) {
+    fs28.unlinkSync(existingLedgerPath);
   }
   try {
-    const planJsonPath = path50.join(swarmDir, "plan.json");
-    if (fs27.existsSync(planJsonPath)) {
-      const planRaw = fs27.readFileSync(planJsonPath, "utf-8");
+    const planJsonPath = path51.join(swarmDir, "plan.json");
+    if (fs28.existsSync(planJsonPath)) {
+      const planRaw = fs28.readFileSync(planJsonPath, "utf-8");
       const plan = PlanSchema.parse(JSON.parse(planRaw));
       const planId = derivePlanId(plan);
       const planHash = computePlanHash(plan);
@@ -57145,7 +57224,7 @@ async function handleRollbackCommand(directory, args) {
     timestamp: new Date().toISOString()
   };
   try {
-    fs27.appendFileSync(eventsPath, `${JSON.stringify(rollbackEvent)}
+    fs28.appendFileSync(eventsPath, `${JSON.stringify(rollbackEvent)}
 `);
   } catch (error93) {
     console.error("Failed to write rollback event:", error93 instanceof Error ? error93.message : String(error93));
@@ -57206,11 +57285,11 @@ Ensure this is a git repository with commit history.`;
   const report = reportLines.filter(Boolean).join(`
 `);
   try {
-    const fs28 = await import("fs/promises");
-    const path51 = await import("path");
-    const reportPath = path51.join(directory, ".swarm", "simulate-report.md");
-    await fs28.mkdir(path51.dirname(reportPath), { recursive: true });
-    await fs28.writeFile(reportPath, report, "utf-8");
+    const fs29 = await import("fs/promises");
+    const path52 = await import("path");
+    const reportPath = path52.join(directory, ".swarm", "simulate-report.md");
+    await fs29.mkdir(path52.dirname(reportPath), { recursive: true });
+    await fs29.writeFile(reportPath, report, "utf-8");
   } catch (err) {
     const writeErr = err instanceof Error ? err.message : String(err);
     warn(`simulate: failed to write report to ${directory}/.swarm/simulate-report.md`, writeErr);
@@ -57232,15 +57311,15 @@ async function handleSpecifyCommand(_directory, args) {
 }
 
 // src/turbo/lean/state.ts
-import * as fs28 from "fs";
-import * as path51 from "path";
+import * as fs29 from "fs";
+import * as path52 from "path";
 function nowISO2() {
   return new Date().toISOString();
 }
 function ensureSwarmDir2(directory) {
-  const swarmDir = path51.resolve(directory, ".swarm");
-  if (!fs28.existsSync(swarmDir)) {
-    fs28.mkdirSync(swarmDir, { recursive: true });
+  const swarmDir = path52.resolve(directory, ".swarm");
+  if (!fs29.existsSync(swarmDir)) {
+    fs29.mkdirSync(swarmDir, { recursive: true });
   }
   return swarmDir;
 }
@@ -57282,17 +57361,17 @@ function markStateUnreadable2(directory, reason) {
 }
 function readPersisted2(directory) {
   try {
-    const filePath = path51.join(directory, ".swarm", STATE_FILE2);
-    if (!fs28.existsSync(filePath)) {
+    const filePath = path52.join(directory, ".swarm", STATE_FILE2);
+    if (!fs29.existsSync(filePath)) {
       const seed = emptyPersisted2();
       try {
         ensureSwarmDir2(directory);
-        fs28.writeFileSync(filePath, `${JSON.stringify(seed, null, 2)}
+        fs29.writeFileSync(filePath, `${JSON.stringify(seed, null, 2)}
 `, "utf-8");
       } catch {}
       return seed;
     }
-    const raw = fs28.readFileSync(filePath, "utf-8");
+    const raw = fs29.readFileSync(filePath, "utf-8");
     const parsed = JSON.parse(raw);
     if (!parsed || typeof parsed !== "object" || Array.isArray(parsed) || parsed.version !== 1 || !parsed.sessions || typeof parsed.sessions !== "object" || Array.isArray(parsed.sessions)) {
       markStateUnreadable2(directory, `malformed shape (version=${parsed?.version}, sessions type=${Array.isArray(parsed?.sessions) ? "array" : typeof parsed?.sessions})`);
@@ -57318,7 +57397,7 @@ function writePersisted2(directory, persisted) {
   let payload;
   try {
     ensureSwarmDir2(directory);
-    filePath = path51.join(directory, ".swarm", STATE_FILE2);
+    filePath = path52.join(directory, ".swarm", STATE_FILE2);
     tmpPath = `${filePath}.tmp.${Date.now()}`;
     persisted.updatedAt = nowISO2();
     payload = `${JSON.stringify(persisted, null, 2)}
@@ -57329,14 +57408,14 @@ function writePersisted2(directory, persisted) {
     throw new Error(`Lean Turbo state persistence prepare failed: ${msg}`);
   }
   try {
-    fs28.writeFileSync(tmpPath, payload, "utf-8");
-    fs28.renameSync(tmpPath, filePath);
+    fs29.writeFileSync(tmpPath, payload, "utf-8");
+    fs29.renameSync(tmpPath, filePath);
   } catch (error93) {
     const msg = error93 instanceof Error ? error93.message : String(error93);
     error(`[turbo/lean/state] Failed to persist ${STATE_FILE2} atomically: ${msg}`);
     try {
-      if (fs28.existsSync(tmpPath)) {
-        fs28.unlinkSync(tmpPath);
+      if (fs29.existsSync(tmpPath)) {
+        fs29.unlinkSync(tmpPath);
       }
     } catch {}
     throw new Error(`Lean Turbo state persistence failed: ${msg}`);
@@ -57445,10 +57524,10 @@ var init_context_budget_service = __esm(() => {
 
 // src/services/status-service.ts
 import * as fsSync2 from "fs";
-import * as path52 from "path";
+import * as path53 from "path";
 function readSpecStalenessSnapshot(directory) {
   try {
-    const p = path52.join(directory, ".swarm", "spec-staleness.json");
+    const p = path53.join(directory, ".swarm", "spec-staleness.json");
     if (!fsSync2.existsSync(p))
       return { stale: false };
     const raw = fsSync2.readFileSync(p, "utf-8");
@@ -57973,8 +58052,8 @@ var init_write_retro2 = __esm(() => {
 });
 
 // src/commands/command-dispatch.ts
-import fs29 from "fs";
-import path53 from "path";
+import fs30 from "fs";
+import path54 from "path";
 function normalizeSwarmCommandInput(command, argumentText) {
   if (command !== "swarm" && !command.startsWith("swarm-")) {
     return { isSwarmCommand: false, tokens: [] };
@@ -58010,11 +58089,11 @@ ${similar.map((cmd) => `  - /swarm ${cmd}`).join(`
 `);
 }
 function maybeMarkFirstRun(directory) {
-  const sentinelPath = path53.join(directory, ".swarm", ".first-run-complete");
+  const sentinelPath = path54.join(directory, ".swarm", ".first-run-complete");
   try {
-    const swarmDir = path53.join(directory, ".swarm");
-    fs29.mkdirSync(swarmDir, { recursive: true });
-    fs29.writeFileSync(sentinelPath, `first-run-complete: ${new Date().toISOString()}
+    const swarmDir = path54.join(directory, ".swarm");
+    fs30.mkdirSync(swarmDir, { recursive: true });
+    fs30.writeFileSync(sentinelPath, `first-run-complete: ${new Date().toISOString()}
 `, { flag: "wx" });
     return true;
   } catch {
@@ -58762,24 +58841,24 @@ function validateAliases() {
       }
       aliasTargets.get(target).push(name);
       const visited = new Set;
-      const path54 = [];
+      const path55 = [];
       let current = target;
       while (current) {
         const currentEntry = COMMAND_REGISTRY[current];
         if (!currentEntry)
           break;
         if (visited.has(current)) {
-          const cycleStart = path54.indexOf(current);
+          const cycleStart = path55.indexOf(current);
           const fullChain = [
             name,
-            ...path54.slice(0, cycleStart > 0 ? cycleStart : path54.length),
+            ...path55.slice(0, cycleStart > 0 ? cycleStart : path55.length),
             current
           ].join(" \u2192 ");
           errors5.push(`Circular alias detected: ${fullChain}`);
           break;
         }
         visited.add(current);
-        path54.push(current);
+        path55.push(current);
         current = currentEntry.aliasOf || "";
       }
     }
@@ -59398,68 +59477,68 @@ init_package();
 init_registry();
 init_cache_paths();
 init_constants();
-import * as fs30 from "fs";
+import * as fs31 from "fs";
 import * as os8 from "os";
-import * as path54 from "path";
+import * as path55 from "path";
 var { version: version5 } = package_default;
 var CONFIG_DIR = getPluginConfigDir();
-var OPENCODE_CONFIG_PATH = path54.join(CONFIG_DIR, "opencode.json");
-var PLUGIN_CONFIG_PATH = path54.join(CONFIG_DIR, "opencode-swarm.json");
-var PROMPTS_DIR = path54.join(CONFIG_DIR, "opencode-swarm");
+var OPENCODE_CONFIG_PATH = path55.join(CONFIG_DIR, "opencode.json");
+var PLUGIN_CONFIG_PATH = path55.join(CONFIG_DIR, "opencode-swarm.json");
+var PROMPTS_DIR = path55.join(CONFIG_DIR, "opencode-swarm");
 var OPENCODE_PLUGIN_CACHE_PATHS = getPluginCachePaths();
 var OPENCODE_PLUGIN_LOCK_FILE_PATHS = getPluginLockFilePaths();
 function isSafeCachePath(p) {
-  const resolved = path54.resolve(p);
-  const home = path54.resolve(os8.homedir());
+  const resolved = path55.resolve(p);
+  const home = path55.resolve(os8.homedir());
   if (resolved === "/" || resolved === home || resolved.length <= home.length) {
     return false;
   }
-  const segments = resolved.split(path54.sep).filter((s) => s.length > 0);
+  const segments = resolved.split(path55.sep).filter((s) => s.length > 0);
   if (segments.length < 4) {
     return false;
   }
-  const leaf = path54.basename(resolved);
+  const leaf = path55.basename(resolved);
   if (leaf !== "opencode-swarm@latest" && leaf !== "opencode-swarm") {
     return false;
   }
-  const parent = path54.basename(path54.dirname(resolved));
+  const parent = path55.basename(path55.dirname(resolved));
   if (parent !== "packages" && parent !== "node_modules") {
     return false;
   }
-  const grandparent = path54.basename(path54.dirname(path54.dirname(resolved)));
+  const grandparent = path55.basename(path55.dirname(path55.dirname(resolved)));
   if (grandparent !== "opencode") {
     return false;
   }
   return true;
 }
 function isSafeLockFilePath(p) {
-  const resolved = path54.resolve(p);
-  const home = path54.resolve(os8.homedir());
+  const resolved = path55.resolve(p);
+  const home = path55.resolve(os8.homedir());
   if (resolved === "/" || resolved === home || resolved.length <= home.length) {
     return false;
   }
-  const segments = resolved.split(path54.sep).filter((s) => s.length > 0);
+  const segments = resolved.split(path55.sep).filter((s) => s.length > 0);
   if (segments.length < 4) {
     return false;
   }
-  const leaf = path54.basename(resolved);
+  const leaf = path55.basename(resolved);
   if (leaf !== "bun.lock" && leaf !== "bun.lockb" && leaf !== "package-lock.json") {
     return false;
   }
-  const parent = path54.basename(path54.dirname(resolved));
+  const parent = path55.basename(path55.dirname(resolved));
   if (parent !== "opencode") {
     return false;
   }
   return true;
 }
 function ensureDir(dir) {
-  if (!fs30.existsSync(dir)) {
-    fs30.mkdirSync(dir, { recursive: true });
+  if (!fs31.existsSync(dir)) {
+    fs31.mkdirSync(dir, { recursive: true });
   }
 }
 function loadJson(filepath) {
   try {
-    const content = fs30.readFileSync(filepath, "utf-8");
+    const content = fs31.readFileSync(filepath, "utf-8");
     const stripped = content.replace(/\\"|"(?:\\"|[^"])*"|(\/\/.*|\/\*[\s\S]*?\*\/)/g, (match, comment) => comment ? "" : match).replace(/,(\s*[}\]])/g, "$1");
     return JSON.parse(stripped);
   } catch {
@@ -59467,14 +59546,14 @@ function loadJson(filepath) {
   }
 }
 function saveJson(filepath, data) {
-  fs30.writeFileSync(filepath, `${JSON.stringify(data, null, 2)}
+  fs31.writeFileSync(filepath, `${JSON.stringify(data, null, 2)}
 `, "utf-8");
 }
 function writeProjectConfigIfMissing(cwd) {
   try {
-    const opencodeDir = path54.join(cwd, ".opencode");
-    const projectConfigPath = path54.join(opencodeDir, "opencode-swarm.json");
-    if (fs30.existsSync(projectConfigPath)) {
+    const opencodeDir = path55.join(cwd, ".opencode");
+    const projectConfigPath = path55.join(opencodeDir, "opencode-swarm.json");
+    if (fs31.existsSync(projectConfigPath)) {
       return;
     }
     ensureDir(opencodeDir);
@@ -59490,7 +59569,7 @@ async function install() {
 `);
   ensureDir(CONFIG_DIR);
   ensureDir(PROMPTS_DIR);
-  const LEGACY_CONFIG_PATH = path54.join(CONFIG_DIR, "config.json");
+  const LEGACY_CONFIG_PATH = path55.join(CONFIG_DIR, "config.json");
   let opencodeConfig = loadJson(OPENCODE_CONFIG_PATH);
   if (!opencodeConfig) {
     const legacyConfig = loadJson(LEGACY_CONFIG_PATH);
@@ -59537,7 +59616,7 @@ async function install() {
     console.warn(`\u26A0 Could not clear opencode lock file \u2014 you may need to delete it manually:
   ${failed}`);
   }
-  if (!fs30.existsSync(PLUGIN_CONFIG_PATH)) {
+  if (!fs31.existsSync(PLUGIN_CONFIG_PATH)) {
     const defaultConfig = {
       agents: { ...DEFAULT_AGENT_CONFIGS },
       max_iterations: 5
@@ -59616,14 +59695,14 @@ function evictPluginCaches() {
   const cleared = [];
   const failed = [];
   for (const cachePath of OPENCODE_PLUGIN_CACHE_PATHS) {
-    if (!fs30.existsSync(cachePath))
+    if (!fs31.existsSync(cachePath))
       continue;
     if (!isSafeCachePath(cachePath)) {
       failed.push(`${cachePath} (refused: failed safety check)`);
       continue;
     }
     try {
-      fs30.rmSync(cachePath, { recursive: true, force: true });
+      fs31.rmSync(cachePath, { recursive: true, force: true });
       cleared.push(cachePath);
     } catch (err) {
       failed.push(`${cachePath} (${err instanceof Error ? err.message : String(err)})`);
@@ -59635,14 +59714,14 @@ function evictLockFiles() {
   const cleared = [];
   const failed = [];
   for (const lockPath of OPENCODE_PLUGIN_LOCK_FILE_PATHS) {
-    if (!fs30.existsSync(lockPath))
+    if (!fs31.existsSync(lockPath))
       continue;
     if (!isSafeLockFilePath(lockPath)) {
       failed.push(`${lockPath} (refused: failed safety check)`);
       continue;
     }
     try {
-      fs30.unlinkSync(lockPath);
+      fs31.unlinkSync(lockPath);
       cleared.push(lockPath);
     } catch (err) {
       const code = err?.code;
@@ -59661,7 +59740,7 @@ async function uninstall() {
 `);
     const opencodeConfig = loadJson(OPENCODE_CONFIG_PATH);
     if (!opencodeConfig) {
-      if (fs30.existsSync(OPENCODE_CONFIG_PATH)) {
+      if (fs31.existsSync(OPENCODE_CONFIG_PATH)) {
         console.log(`\u2717 Could not parse opencode config at: ${OPENCODE_CONFIG_PATH}`);
         return 1;
       } else {
@@ -59693,13 +59772,13 @@ async function uninstall() {
     console.log("\u2713 Re-enabled default OpenCode agents (explore, general)");
     if (process.argv.includes("--clean")) {
       let cleaned = false;
-      if (fs30.existsSync(PLUGIN_CONFIG_PATH)) {
-        fs30.unlinkSync(PLUGIN_CONFIG_PATH);
+      if (fs31.existsSync(PLUGIN_CONFIG_PATH)) {
+        fs31.unlinkSync(PLUGIN_CONFIG_PATH);
         console.log(`\u2713 Removed plugin config: ${PLUGIN_CONFIG_PATH}`);
         cleaned = true;
       }
-      if (fs30.existsSync(PROMPTS_DIR)) {
-        fs30.rmSync(PROMPTS_DIR, { recursive: true });
+      if (fs31.existsSync(PROMPTS_DIR)) {
+        fs31.rmSync(PROMPTS_DIR, { recursive: true });
         console.log(`\u2713 Removed custom prompts: ${PROMPTS_DIR}`);
         cleaned = true;
       }