opencode-swarm 6.86.8 → 6.86.10

package/dist/cli/index.js

@@ -17669,14 +17669,14 @@ __export(exports_config_doctor, {
 });
 import * as crypto3 from "crypto";
 import * as fs8 from "fs";
-import * as os5 from "os";
-import * as path18 from "path";
+import * as os6 from "os";
+import * as path19 from "path";
 function getUserConfigDir3() {
-  return process.env.XDG_CONFIG_HOME || path18.join(os5.homedir(), ".config");
+  return process.env.XDG_CONFIG_HOME || path19.join(os6.homedir(), ".config");
 }
 function getConfigPaths(directory) {
-  const userConfigPath = path18.join(getUserConfigDir3(), "opencode", "opencode-swarm.json");
-  const projectConfigPath = path18.join(directory, ".opencode", "opencode-swarm.json");
+  const userConfigPath = path19.join(getUserConfigDir3(), "opencode", "opencode-swarm.json");
+  const projectConfigPath = path19.join(directory, ".opencode", "opencode-swarm.json");
   return { userConfigPath, projectConfigPath };
 }
 function computeHash(content) {
@@ -17701,9 +17701,9 @@ function isValidConfigPath(configPath, directory) {
   const normalizedUser = userConfigPath.replace(/\\/g, "/");
   const normalizedProject = projectConfigPath.replace(/\\/g, "/");
   try {
-    const resolvedConfig = path18.resolve(configPath);
-    const resolvedUser = path18.resolve(normalizedUser);
-    const resolvedProject = path18.resolve(normalizedProject);
+    const resolvedConfig = path19.resolve(configPath);
+    const resolvedUser = path19.resolve(normalizedUser);
+    const resolvedProject = path19.resolve(normalizedProject);
     return resolvedConfig === resolvedUser || resolvedConfig === resolvedProject;
   } catch {
     return false;
@@ -17743,12 +17743,12 @@ function createConfigBackup(directory) {
   };
 }
 function writeBackupArtifact(directory, backup) {
-  const swarmDir = path18.join(directory, ".swarm");
+  const swarmDir = path19.join(directory, ".swarm");
   if (!fs8.existsSync(swarmDir)) {
     fs8.mkdirSync(swarmDir, { recursive: true });
   }
   const backupFilename = `config-backup-${backup.createdAt}.json`;
-  const backupPath = path18.join(swarmDir, backupFilename);
+  const backupPath = path19.join(swarmDir, backupFilename);
   const artifact = {
     createdAt: backup.createdAt,
     configPath: backup.configPath,
@@ -17778,7 +17778,7 @@ function restoreFromBackup(backupPath, directory) {
       return null;
     }
     const targetPath = artifact.configPath;
-    const targetDir = path18.dirname(targetPath);
+    const targetDir = path19.dirname(targetPath);
     if (!fs8.existsSync(targetDir)) {
       fs8.mkdirSync(targetDir, { recursive: true });
     }
@@ -17809,9 +17809,9 @@ function readConfigFromFile(directory) {
     return null;
   }
 }
-function validateConfigKey(path19, value, _config) {
+function validateConfigKey(path20, value, _config) {
   const findings = [];
-  switch (path19) {
+  switch (path20) {
     case "agents": {
       if (value !== undefined) {
         findings.push({
@@ -18058,27 +18058,27 @@ function validateConfigKey(path19, value, _config) {
   }
   return findings;
 }
-function walkConfigAndValidate(obj, path19, config3, findings) {
+function walkConfigAndValidate(obj, path20, config3, findings) {
   if (obj === null || obj === undefined) {
     return;
   }
-  if (path19 && typeof obj === "object" && !Array.isArray(obj)) {
-    const keyFindings = validateConfigKey(path19, obj, config3);
+  if (path20 && typeof obj === "object" && !Array.isArray(obj)) {
+    const keyFindings = validateConfigKey(path20, obj, config3);
     findings.push(...keyFindings);
   }
   if (typeof obj !== "object") {
-    const keyFindings = validateConfigKey(path19, obj, config3);
+    const keyFindings = validateConfigKey(path20, obj, config3);
     findings.push(...keyFindings);
     return;
   }
   if (Array.isArray(obj)) {
     obj.forEach((item, index) => {
-      walkConfigAndValidate(item, `${path19}[${index}]`, config3, findings);
+      walkConfigAndValidate(item, `${path20}[${index}]`, config3, findings);
     });
     return;
   }
   for (const [key, value] of Object.entries(obj)) {
-    const newPath = path19 ? `${path19}.${key}` : key;
+    const newPath = path20 ? `${path20}.${key}` : key;
     walkConfigAndValidate(value, newPath, config3, findings);
   }
 }
@@ -18198,7 +18198,7 @@ function applySafeAutoFixes(directory, result) {
     }
   }
   if (appliedFixes.length > 0) {
-    const configDir = path18.dirname(configPath);
+    const configDir = path19.dirname(configPath);
     if (!fs8.existsSync(configDir)) {
       fs8.mkdirSync(configDir, { recursive: true });
     }
@@ -18208,12 +18208,12 @@ function applySafeAutoFixes(directory, result) {
   return { appliedFixes, updatedConfigPath };
 }
 function writeDoctorArtifact(directory, result) {
-  const swarmDir = path18.join(directory, ".swarm");
+  const swarmDir = path19.join(directory, ".swarm");
   if (!fs8.existsSync(swarmDir)) {
     fs8.mkdirSync(swarmDir, { recursive: true });
   }
   const artifactFilename = "config-doctor.json";
-  const artifactPath = path18.join(swarmDir, artifactFilename);
+  const artifactPath = path19.join(swarmDir, artifactFilename);
   const guiOutput = {
     timestamp: result.timestamp,
     summary: result.summary,
@@ -18575,12 +18575,12 @@ var init_evidence_summary_service = __esm(() => {
 
 // src/cli/index.ts
 import * as fs21 from "fs";
-import * as os6 from "os";
-import * as path32 from "path";
+import * as os7 from "os";
+import * as path33 from "path";
 // package.json
 var package_default = {
   name: "opencode-swarm",
-  version: "6.86.8",
+  version: "6.86.10",
   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",
@@ -20170,6 +20170,7 @@ function getEffectiveGates(profile, sessionOverrides) {
 
 // src/hooks/delegation-gate.ts
 init_telemetry();
+init_logger();
 
 // node_modules/quick-lru/index.js
 class QuickLRU extends Map {
@@ -20533,6 +20534,7 @@ function clearAllScopes(directory) {
 // src/hooks/guardrails.ts
 init_telemetry();
 init_utils();
+init_logger();
 
 // src/hooks/conflict-resolution.ts
 init_telemetry();
@@ -35625,6 +35627,7 @@ function getGlobalEventBus() {
 
 // src/hooks/curator.ts
 init_manager();
+init_logger();
 init_utils2();
 
 // src/hooks/hive-promoter.ts
@@ -36269,31 +36272,49 @@ async function handleDarkMatterCommand(directory, args) {
 // src/services/diagnose-service.ts
 import * as child_process4 from "child_process";
 import { existsSync as existsSync9, readdirSync as readdirSync4, readFileSync as readFileSync6, statSync as statSync5 } from "fs";
-import path17 from "path";
+import path18 from "path";
 import { fileURLToPath } from "url";
+
+// src/config/cache-paths.ts
+import * as os5 from "os";
+import * as path17 from "path";
+function getPluginConfigDir() {
+  return path17.join(process.env.XDG_CONFIG_HOME || path17.join(os5.homedir(), ".config"), "opencode");
+}
+function getPluginCachePaths() {
+  const cacheBase = process.env.XDG_CACHE_HOME || path17.join(os5.homedir(), ".cache");
+  const configDir = getPluginConfigDir();
+  return [
+    path17.join(cacheBase, "opencode", "packages", "opencode-swarm@latest"),
+    path17.join(configDir, "node_modules", "opencode-swarm"),
+    path17.join(cacheBase, "opencode", "node_modules", "opencode-swarm")
+  ];
+}
+
+// src/services/diagnose-service.ts
 init_manager2();
 init_utils2();
 init_manager();
 
 // src/services/version-check.ts
 import { existsSync as existsSync8, mkdirSync as mkdirSync8, readFileSync as readFileSync5, writeFileSync as writeFileSync4 } from "fs";
-import { homedir as homedir4 } from "os";
-import { join as join14 } from "path";
+import { homedir as homedir5 } from "os";
+import { join as join15 } from "path";
 var CHECK_INTERVAL_MS = 24 * 60 * 60 * 1000;
 function cacheDir() {
   const xdg = process.env.XDG_CACHE_HOME;
-  const base = xdg && xdg.length > 0 ? xdg : join14(homedir4(), ".cache");
-  return join14(base, "opencode-swarm");
+  const base = xdg && xdg.length > 0 ? xdg : join15(homedir5(), ".cache");
+  return join15(base, "opencode-swarm");
 }
 function cacheFile() {
-  return join14(cacheDir(), "version-check.json");
+  return join15(cacheDir(), "version-check.json");
 }
 function readVersionCache() {
   try {
-    const path17 = cacheFile();
-    if (!existsSync8(path17))
+    const path18 = cacheFile();
+    if (!existsSync8(path18))
       return null;
-    const raw = readFileSync5(path17, "utf-8");
+    const raw = readFileSync5(path18, "utf-8");
     const parsed = JSON.parse(raw);
     if (typeof parsed?.checkedAt !== "number")
       return null;
@@ -36623,7 +36644,7 @@ async function checkSpecStaleness(directory, plan) {
   };
 }
 async function checkConfigParseability(directory) {
-  const configPath = path17.join(directory, ".opencode/opencode-swarm.json");
+  const configPath = path18.join(directory, ".opencode/opencode-swarm.json");
   if (!existsSync9(configPath)) {
     return {
       name: "Config Parseability",
@@ -36652,7 +36673,7 @@ function resolveGrammarDir(thisDir) {
   const normalized = thisDir.replace(/\\/g, "/");
   const isSource = normalized.endsWith("/src/services");
   const isCliBundle = normalized.endsWith("/cli");
-  return isSource || isCliBundle ? path17.join(thisDir, "..", "lang", "grammars") : path17.join(thisDir, "lang", "grammars");
+  return isSource || isCliBundle ? path18.join(thisDir, "..", "lang", "grammars") : path18.join(thisDir, "lang", "grammars");
 }
 async function checkGrammarWasmFiles() {
   const grammarFiles = [
@@ -36676,14 +36697,14 @@ async function checkGrammarWasmFiles() {
     "tree-sitter-ini.wasm",
     "tree-sitter-regex.wasm"
   ];
-  const thisDir = path17.dirname(fileURLToPath(import.meta.url));
+  const thisDir = path18.dirname(fileURLToPath(import.meta.url));
   const grammarDir = resolveGrammarDir(thisDir);
   const missing = [];
-  if (!existsSync9(path17.join(grammarDir, "tree-sitter.wasm"))) {
+  if (!existsSync9(path18.join(grammarDir, "tree-sitter.wasm"))) {
     missing.push("tree-sitter.wasm (core runtime)");
   }
   for (const file3 of grammarFiles) {
-    if (!existsSync9(path17.join(grammarDir, file3))) {
+    if (!existsSync9(path18.join(grammarDir, file3))) {
       missing.push(file3);
     }
   }
@@ -36701,7 +36722,7 @@ async function checkGrammarWasmFiles() {
   };
 }
 async function checkCheckpointManifest(directory) {
-  const manifestPath = path17.join(directory, ".swarm/checkpoints.json");
+  const manifestPath = path18.join(directory, ".swarm/checkpoints.json");
   if (!existsSync9(manifestPath)) {
     return {
       name: "Checkpoint Manifest",
@@ -36753,7 +36774,7 @@ async function checkCheckpointManifest(directory) {
   }
 }
 async function checkEventStreamIntegrity(directory) {
-  const eventsPath = path17.join(directory, ".swarm/events.jsonl");
+  const eventsPath = path18.join(directory, ".swarm/events.jsonl");
   if (!existsSync9(eventsPath)) {
     return {
       name: "Event Stream",
@@ -36794,7 +36815,7 @@ async function checkEventStreamIntegrity(directory) {
   }
 }
 async function checkSteeringDirectives(directory) {
-  const eventsPath = path17.join(directory, ".swarm/events.jsonl");
+  const eventsPath = path18.join(directory, ".swarm/events.jsonl");
   if (!existsSync9(eventsPath)) {
     return {
       name: "Steering Directives",
@@ -36850,7 +36871,7 @@ async function checkCurator(directory) {
         detail: "Disabled (enable via curator.enabled)"
       };
     }
-    const summaryPath = path17.join(directory, ".swarm/curator-summary.json");
+    const summaryPath = path18.join(directory, ".swarm/curator-summary.json");
     if (!existsSync9(summaryPath)) {
       return {
         name: "Curator",
@@ -37016,7 +37037,7 @@ async function getDiagnoseData(directory) {
   checks5.push(await checkSteeringDirectives(directory));
   checks5.push(await checkCurator(directory));
   try {
-    const evidenceDir = path17.join(directory, ".swarm", "evidence");
+    const evidenceDir = path18.join(directory, ".swarm", "evidence");
     const snapshotFiles = existsSync9(evidenceDir) ? readdirSync4(evidenceDir).filter((f) => f.startsWith("agent-tools-") && f.endsWith(".json")) : [];
     if (snapshotFiles.length > 0) {
       const latest = snapshotFiles.sort().pop();
@@ -37046,7 +37067,36 @@ async function getDiagnoseData(directory) {
       detail: `${deferredWarnings.length} warning(s) deferred from init (run with verbose logs for details)`
     });
   }
-  const passCount = checks5.filter((c) => c.status === "\u2705").length;
+  const cachePaths = getPluginCachePaths();
+  const cacheRows = [];
+  for (const cachePath of cachePaths) {
+    try {
+      if (!existsSync9(cachePath)) {
+        cacheRows.push(`\u2B1C ${cachePath} \u2014 absent`);
+        continue;
+      }
+      const pkgJsonPath = path18.join(cachePath, "package.json");
+      try {
+        const raw = readFileSync6(pkgJsonPath, "utf-8");
+        const parsed = JSON.parse(raw);
+        const installedVersion = typeof parsed.version === "string" ? parsed.version : "?";
+        cacheRows.push(`\u2705 ${cachePath} \u2014 v${installedVersion}`);
+      } catch {
+        cacheRows.push(`\u26A0\uFE0F ${cachePath} \u2014 present (package.json unreadable)`);
+      }
+    } catch {
+      cacheRows.push(`\u26A0\uFE0F ${cachePath} \u2014 status unknown (read error)`);
+    }
+  }
+  const hasCacheEntry = cacheRows.some((r) => r.startsWith("\u2705"));
+  const hasCacheWarning = cacheRows.some((r) => r.startsWith("\u26A0\uFE0F"));
+  const cacheStatus = hasCacheWarning ? "\u26A0\uFE0F" : hasCacheEntry ? "\u2705" : "\u2B1C";
+  checks5.push({
+    name: "Plugin Caches",
+    status: cacheStatus,
+    detail: cacheRows.join(" | ")
+  });
+  const passCount = checks5.filter((c) => c.status === "\u2705" || c.status === "\u2B1C").length;
   const totalCount = checks5.length;
   const allPassed = passCount === totalCount;
   return {
@@ -37084,15 +37134,15 @@ init_config_doctor();
 
 // src/services/tool-doctor.ts
 import * as fs10 from "fs";
-import * as path20 from "path";
+import * as path21 from "path";
 
 // src/build/discovery.ts
 import * as fs9 from "fs";
-import * as path19 from "path";
+import * as path20 from "path";
 
 // src/lang/detector.ts
 import { access as access2, readdir as readdir2 } from "fs/promises";
-import { extname as extname2, join as join16 } from "path";
+import { extname as extname2, join as join17 } from "path";
 
 // src/lang/profiles.ts
 class LanguageRegistry {
@@ -38072,7 +38122,7 @@ async function detectProjectLanguages(projectDir) {
         if (detectFile.includes("*") || detectFile.includes("?"))
           continue;
         try {
-          await access2(join16(dir, detectFile));
+          await access2(join17(dir, detectFile));
           detected.add(profile.id);
           break;
         } catch {}
@@ -38093,7 +38143,7 @@ async function detectProjectLanguages(projectDir) {
     const topEntries = await readdir2(projectDir, { withFileTypes: true });
     for (const entry of topEntries) {
       if (entry.isDirectory() && !entry.name.startsWith(".") && entry.name !== "node_modules") {
-        await scanDir(join16(projectDir, entry.name));
+        await scanDir(join17(projectDir, entry.name));
       }
     }
   } catch {}
@@ -38252,11 +38302,11 @@ function findBuildFiles(workingDir, patterns) {
         const regex = simpleGlobToRegex(pattern);
         const matches = files.filter((f) => regex.test(f));
         if (matches.length > 0) {
-          return path19.join(dir, matches[0]);
+          return path20.join(dir, matches[0]);
         }
       } catch {}
     } else {
-      const filePath = path19.join(workingDir, pattern);
+      const filePath = path20.join(workingDir, pattern);
       if (fs9.existsSync(filePath)) {
         return filePath;
       }
@@ -38265,7 +38315,7 @@ function findBuildFiles(workingDir, patterns) {
   return null;
 }
 function getRepoDefinedScripts(workingDir, scripts) {
-  const packageJsonPath = path19.join(workingDir, "package.json");
+  const packageJsonPath = path20.join(workingDir, "package.json");
   if (!fs9.existsSync(packageJsonPath)) {
     return [];
   }
@@ -38306,7 +38356,7 @@ function findAllBuildFiles(workingDir) {
         const regex = simpleGlobToRegex(pattern);
         findFilesRecursive(workingDir, regex, allBuildFiles);
       } else {
-        const filePath = path19.join(workingDir, pattern);
+        const filePath = path20.join(workingDir, pattern);
         if (fs9.existsSync(filePath)) {
           allBuildFiles.add(filePath);
         }
@@ -38319,7 +38369,7 @@ function findFilesRecursive(dir, regex, results) {
   try {
     const entries = fs9.readdirSync(dir, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = path19.join(dir, entry.name);
+      const fullPath = path20.join(dir, entry.name);
       if (entry.isDirectory() && !["node_modules", ".git", "dist", "build", "target"].includes(entry.name)) {
         findFilesRecursive(fullPath, regex, results);
       } else if (entry.isFile() && regex.test(entry.name)) {
@@ -38342,7 +38392,7 @@ async function discoverBuildCommandsFromProfiles(workingDir) {
     let foundCommand = false;
     for (const cmd of sortedCommands) {
       if (cmd.detectFile) {
-        const detectFilePath = path19.join(workingDir, cmd.detectFile);
+        const detectFilePath = path20.join(workingDir, cmd.detectFile);
         if (!fs9.existsSync(detectFilePath)) {
           continue;
         }
@@ -38517,8 +38567,8 @@ function checkBinaryReadiness() {
 }
 function runToolDoctor(_directory, pluginRoot) {
   const findings = [];
-  const resolvedPluginRoot = pluginRoot ?? path20.resolve(import.meta.dir, "..", "..");
-  const indexPath = path20.join(resolvedPluginRoot, "src", "index.ts");
+  const resolvedPluginRoot = pluginRoot ?? path21.resolve(import.meta.dir, "..", "..");
+  const indexPath = path21.join(resolvedPluginRoot, "src", "index.ts");
   if (!fs10.existsSync(indexPath)) {
     return {
       findings: [
@@ -39438,13 +39488,14 @@ async function handleHistoryCommand(directory, _args) {
   return formatHistoryMarkdown(historyData);
 }
 // src/hooks/knowledge-migrator.ts
+init_logger();
 import { randomUUID as randomUUID2 } from "crypto";
 import { existsSync as existsSync13, readFileSync as readFileSync10 } from "fs";
 import { mkdir as mkdir3, readFile as readFile4, writeFile as writeFile4 } from "fs/promises";
-import * as path21 from "path";
+import * as path22 from "path";
 async function migrateContextToKnowledge(directory, config3) {
-  const sentinelPath = path21.join(directory, ".swarm", ".knowledge-migrated");
-  const contextPath = path21.join(directory, ".swarm", "context.md");
+  const sentinelPath = path22.join(directory, ".swarm", ".knowledge-migrated");
+  const contextPath = path22.join(directory, ".swarm", "context.md");
   const knowledgePath = resolveSwarmKnowledgePath(directory);
   if (existsSync13(sentinelPath)) {
     return {
@@ -39535,7 +39586,7 @@ async function migrateContextToKnowledge(directory, config3) {
     await rewriteKnowledge(knowledgePath, existing);
   }
   await writeSentinel(sentinelPath, migrated, dropped);
-  console.log(`[knowledge-migrator] Migrated ${migrated} entries, dropped ${dropped}`);
+  log(`[knowledge-migrator] Migrated ${migrated} entries, dropped ${dropped}`);
   return {
     migrated: true,
     entriesMigrated: migrated,
@@ -39640,7 +39691,7 @@ function truncateLesson(text) {
   return `${text.slice(0, 277)}...`;
 }
 function inferProjectName(directory) {
-  const packageJsonPath = path21.join(directory, "package.json");
+  const packageJsonPath = path22.join(directory, "package.json");
   if (existsSync13(packageJsonPath)) {
     try {
       const pkg = JSON.parse(readFileSync10(packageJsonPath, "utf-8"));
@@ -39649,7 +39700,7 @@ function inferProjectName(directory) {
       }
     } catch {}
   }
-  return path21.basename(directory);
+  return path22.basename(directory);
 }
 async function writeSentinel(sentinelPath, migrated, dropped) {
   const sentinel = {
@@ -39661,7 +39712,7 @@ async function writeSentinel(sentinelPath, migrated, dropped) {
     schema_version: 1,
     migration_tool: "knowledge-migrator.ts"
   };
-  await mkdir3(path21.dirname(sentinelPath), { recursive: true });
+  await mkdir3(path22.dirname(sentinelPath), { recursive: true });
   await writeFile4(sentinelPath, JSON.stringify(sentinel, null, 2), "utf-8");
 }
 
@@ -39898,12 +39949,12 @@ async function handlePlanCommand(directory, args) {
 init_manager2();
 init_manager();
 import * as fs17 from "fs";
-import * as path28 from "path";
+import * as path29 from "path";
 
 // src/tools/lint.ts
 init_zod();
 import * as fs11 from "fs";
-import * as path22 from "path";
+import * as path23 from "path";
 init_utils();
 
 // src/utils/path-security.ts
@@ -39949,9 +40000,9 @@ function validateArgs(args) {
 }
 function getLinterCommand(linter, mode, projectDir) {
   const isWindows = process.platform === "win32";
-  const binDir = path22.join(projectDir, "node_modules", ".bin");
-  const biomeBin = isWindows ? path22.join(binDir, "biome.EXE") : path22.join(binDir, "biome");
-  const eslintBin = isWindows ? path22.join(binDir, "eslint.cmd") : path22.join(binDir, "eslint");
+  const binDir = path23.join(projectDir, "node_modules", ".bin");
+  const biomeBin = isWindows ? path23.join(binDir, "biome.EXE") : path23.join(binDir, "biome");
+  const eslintBin = isWindows ? path23.join(binDir, "eslint.cmd") : path23.join(binDir, "eslint");
   switch (linter) {
     case "biome":
       if (mode === "fix") {
@@ -39967,7 +40018,7 @@ function getLinterCommand(linter, mode, projectDir) {
 }
 function getAdditionalLinterCommand(linter, mode, cwd) {
   const gradlewName = process.platform === "win32" ? "gradlew.bat" : "gradlew";
-  const gradlew = fs11.existsSync(path22.join(cwd, gradlewName)) ? path22.join(cwd, gradlewName) : null;
+  const gradlew = fs11.existsSync(path23.join(cwd, gradlewName)) ? path23.join(cwd, gradlewName) : null;
   switch (linter) {
     case "ruff":
       return mode === "fix" ? ["ruff", "check", "--fix", "."] : ["ruff", "check", "."];
@@ -40001,10 +40052,10 @@ function getAdditionalLinterCommand(linter, mode, cwd) {
   }
 }
 function detectRuff(cwd) {
-  if (fs11.existsSync(path22.join(cwd, "ruff.toml")))
+  if (fs11.existsSync(path23.join(cwd, "ruff.toml")))
     return isCommandAvailable("ruff");
   try {
-    const pyproject = path22.join(cwd, "pyproject.toml");
+    const pyproject = path23.join(cwd, "pyproject.toml");
     if (fs11.existsSync(pyproject)) {
       const content = fs11.readFileSync(pyproject, "utf-8");
       if (content.includes("[tool.ruff]"))
@@ -40014,19 +40065,19 @@ function detectRuff(cwd) {
   return false;
 }
 function detectClippy(cwd) {
-  return fs11.existsSync(path22.join(cwd, "Cargo.toml")) && isCommandAvailable("cargo");
+  return fs11.existsSync(path23.join(cwd, "Cargo.toml")) && isCommandAvailable("cargo");
 }
 function detectGolangciLint(cwd) {
-  return fs11.existsSync(path22.join(cwd, "go.mod")) && isCommandAvailable("golangci-lint");
+  return fs11.existsSync(path23.join(cwd, "go.mod")) && isCommandAvailable("golangci-lint");
 }
 function detectCheckstyle(cwd) {
-  const hasMaven = fs11.existsSync(path22.join(cwd, "pom.xml"));
-  const hasGradle = fs11.existsSync(path22.join(cwd, "build.gradle")) || fs11.existsSync(path22.join(cwd, "build.gradle.kts"));
-  const hasBinary = hasMaven && isCommandAvailable("mvn") || hasGradle && (fs11.existsSync(path22.join(cwd, "gradlew")) || isCommandAvailable("gradle"));
+  const hasMaven = fs11.existsSync(path23.join(cwd, "pom.xml"));
+  const hasGradle = fs11.existsSync(path23.join(cwd, "build.gradle")) || fs11.existsSync(path23.join(cwd, "build.gradle.kts"));
+  const hasBinary = hasMaven && isCommandAvailable("mvn") || hasGradle && (fs11.existsSync(path23.join(cwd, "gradlew")) || isCommandAvailable("gradle"));
   return (hasMaven || hasGradle) && hasBinary;
 }
 function detectKtlint(cwd) {
-  const hasKotlin = fs11.existsSync(path22.join(cwd, "build.gradle.kts")) || fs11.existsSync(path22.join(cwd, "build.gradle")) || (() => {
+  const hasKotlin = fs11.existsSync(path23.join(cwd, "build.gradle.kts")) || fs11.existsSync(path23.join(cwd, "build.gradle")) || (() => {
     try {
       return fs11.readdirSync(cwd).some((f) => f.endsWith(".kt") || f.endsWith(".kts"));
     } catch {
@@ -40045,11 +40096,11 @@ function detectDotnetFormat(cwd) {
   }
 }
 function detectCppcheck(cwd) {
-  if (fs11.existsSync(path22.join(cwd, "CMakeLists.txt"))) {
+  if (fs11.existsSync(path23.join(cwd, "CMakeLists.txt"))) {
     return isCommandAvailable("cppcheck");
   }
   try {
-    const dirsToCheck = [cwd, path22.join(cwd, "src")];
+    const dirsToCheck = [cwd, path23.join(cwd, "src")];
     const hasCpp = dirsToCheck.some((dir) => {
       try {
         return fs11.readdirSync(dir).some((f) => /\.(c|cpp|cc|cxx|h|hpp)$/.test(f));
@@ -40063,13 +40114,13 @@ function detectCppcheck(cwd) {
   }
 }
 function detectSwiftlint(cwd) {
-  return fs11.existsSync(path22.join(cwd, "Package.swift")) && isCommandAvailable("swiftlint");
+  return fs11.existsSync(path23.join(cwd, "Package.swift")) && isCommandAvailable("swiftlint");
 }
 function detectDartAnalyze(cwd) {
-  return fs11.existsSync(path22.join(cwd, "pubspec.yaml")) && (isCommandAvailable("dart") || isCommandAvailable("flutter"));
+  return fs11.existsSync(path23.join(cwd, "pubspec.yaml")) && (isCommandAvailable("dart") || isCommandAvailable("flutter"));
 }
 function detectRubocop(cwd) {
-  return (fs11.existsSync(path22.join(cwd, "Gemfile")) || fs11.existsSync(path22.join(cwd, "gems.rb")) || fs11.existsSync(path22.join(cwd, ".rubocop.yml"))) && (isCommandAvailable("rubocop") || isCommandAvailable("bundle"));
+  return (fs11.existsSync(path23.join(cwd, "Gemfile")) || fs11.existsSync(path23.join(cwd, "gems.rb")) || fs11.existsSync(path23.join(cwd, ".rubocop.yml"))) && (isCommandAvailable("rubocop") || isCommandAvailable("bundle"));
 }
 function detectAdditionalLinter(cwd) {
   if (detectRuff(cwd))
@@ -40097,10 +40148,10 @@ function detectAdditionalLinter(cwd) {
 function findBinInAncestors(startDir, binName) {
   let dir = startDir;
   while (true) {
-    const candidate = path22.join(dir, "node_modules", ".bin", binName);
+    const candidate = path23.join(dir, "node_modules", ".bin", binName);
     if (fs11.existsSync(candidate))
       return candidate;
-    const parent = path22.dirname(dir);
+    const parent = path23.dirname(dir);
     if (parent === dir)
       break;
     dir = parent;
@@ -40109,10 +40160,10 @@ function findBinInAncestors(startDir, binName) {
 }
 function findBinInEnvPath(binName) {
   const searchPath = process.env.PATH ?? "";
-  for (const dir of searchPath.split(path22.delimiter)) {
+  for (const dir of searchPath.split(path23.delimiter)) {
     if (!dir)
       continue;
-    const candidate = path22.join(dir, binName);
+    const candidate = path23.join(dir, binName);
     if (fs11.existsSync(candidate))
       return candidate;
   }
@@ -40125,13 +40176,13 @@ async function detectAvailableLinter(directory) {
     return null;
   const projectDir = directory;
   const isWindows = process.platform === "win32";
-  const biomeBin = isWindows ? path22.join(projectDir, "node_modules", ".bin", "biome.EXE") : path22.join(projectDir, "node_modules", ".bin", "biome");
-  const eslintBin = isWindows ? path22.join(projectDir, "node_modules", ".bin", "eslint.cmd") : path22.join(projectDir, "node_modules", ".bin", "eslint");
+  const biomeBin = isWindows ? path23.join(projectDir, "node_modules", ".bin", "biome.EXE") : path23.join(projectDir, "node_modules", ".bin", "biome");
+  const eslintBin = isWindows ? path23.join(projectDir, "node_modules", ".bin", "eslint.cmd") : path23.join(projectDir, "node_modules", ".bin", "eslint");
   const localResult = await _detectAvailableLinter(projectDir, biomeBin, eslintBin);
   if (localResult)
     return localResult;
-  const biomeAncestor = findBinInAncestors(path22.dirname(projectDir), isWindows ? "biome.EXE" : "biome");
-  const eslintAncestor = findBinInAncestors(path22.dirname(projectDir), isWindows ? "eslint.cmd" : "eslint");
+  const biomeAncestor = findBinInAncestors(path23.dirname(projectDir), isWindows ? "biome.EXE" : "biome");
+  const eslintAncestor = findBinInAncestors(path23.dirname(projectDir), isWindows ? "eslint.cmd" : "eslint");
   if (biomeAncestor || eslintAncestor) {
     return _detectAvailableLinter(projectDir, biomeAncestor ?? biomeBin, eslintAncestor ?? eslintBin);
   }
@@ -40340,7 +40391,7 @@ For Rust: rustup component add clippy`
 // src/tools/secretscan.ts
 init_zod();
 import * as fs12 from "fs";
-import * as path23 from "path";
+import * as path24 from "path";
 var MAX_FILE_PATH_LENGTH = 500;
 var MAX_FILE_SIZE_BYTES = 512 * 1024;
 var MAX_FILES_SCANNED = 1000;
@@ -40567,7 +40618,7 @@ function isGlobOrPathPattern(pattern) {
   return pattern.includes("/") || pattern.includes("\\") || /[*?[\]{}]/.test(pattern);
 }
 function loadSecretScanIgnore(scanDir) {
-  const ignorePath = path23.join(scanDir, ".secretscanignore");
+  const ignorePath = path24.join(scanDir, ".secretscanignore");
   try {
     if (!fs12.existsSync(ignorePath))
       return [];
@@ -40590,7 +40641,7 @@ function isExcluded(entry, relPath, exactNames, globPatterns) {
   if (exactNames.has(entry))
     return true;
   for (const pattern of globPatterns) {
-    if (path23.matchesGlob(relPath, pattern))
+    if (path24.matchesGlob(relPath, pattern))
       return true;
   }
   return false;
@@ -40611,7 +40662,7 @@ function validateDirectoryInput(dir) {
   return null;
 }
 function isBinaryFile(filePath, buffer) {
-  const ext = path23.extname(filePath).toLowerCase();
+  const ext = path24.extname(filePath).toLowerCase();
   if (DEFAULT_EXCLUDE_EXTENSIONS.has(ext)) {
     return true;
   }
@@ -40748,9 +40799,9 @@ function isSymlinkLoop(realPath, visited) {
   return false;
 }
 function isPathWithinScope(realPath, scanDir) {
-  const resolvedScanDir = path23.resolve(scanDir);
-  const resolvedRealPath = path23.resolve(realPath);
-  return resolvedRealPath === resolvedScanDir || resolvedRealPath.startsWith(resolvedScanDir + path23.sep) || resolvedRealPath.startsWith(`${resolvedScanDir}/`) || resolvedRealPath.startsWith(`${resolvedScanDir}\\`);
+  const resolvedScanDir = path24.resolve(scanDir);
+  const resolvedRealPath = path24.resolve(realPath);
+  return resolvedRealPath === resolvedScanDir || resolvedRealPath.startsWith(resolvedScanDir + path24.sep) || resolvedRealPath.startsWith(`${resolvedScanDir}/`) || resolvedRealPath.startsWith(`${resolvedScanDir}\\`);
 }
 function findScannableFiles(dir, excludeExact, excludeGlobs, scanDir, visited, stats = {
   skippedDirs: 0,
@@ -40776,8 +40827,8 @@ function findScannableFiles(dir, excludeExact, excludeGlobs, scanDir, visited, s
     return a.localeCompare(b);
   });
   for (const entry of entries) {
-    const fullPath = path23.join(dir, entry);
-    const relPath = path23.relative(scanDir, fullPath).replace(/\\/g, "/");
+    const fullPath = path24.join(dir, entry);
+    const relPath = path24.relative(scanDir, fullPath).replace(/\\/g, "/");
     if (isExcluded(entry, relPath, excludeExact, excludeGlobs)) {
       stats.skippedDirs++;
       continue;
@@ -40812,7 +40863,7 @@ function findScannableFiles(dir, excludeExact, excludeGlobs, scanDir, visited, s
       const subFiles = findScannableFiles(fullPath, excludeExact, excludeGlobs, scanDir, visited, stats);
       files.push(...subFiles);
     } else if (lstat.isFile()) {
-      const ext = path23.extname(fullPath).toLowerCase();
+      const ext = path24.extname(fullPath).toLowerCase();
       if (!DEFAULT_EXCLUDE_EXTENSIONS.has(ext)) {
         files.push(fullPath);
       } else {
@@ -40878,7 +40929,7 @@ var secretscan = createSwarmTool({
       }
     }
     try {
-      const _scanDirRaw = path23.resolve(directory);
+      const _scanDirRaw = path24.resolve(directory);
       const scanDir = (() => {
         try {
           return fs12.realpathSync(_scanDirRaw);
@@ -41038,11 +41089,11 @@ async function runSecretscan(directory) {
 // src/tools/test-runner.ts
 init_zod();
 import * as fs16 from "fs";
-import * as path27 from "path";
+import * as path28 from "path";
 
 // src/test-impact/analyzer.ts
 import fs13 from "fs";
-import path24 from "path";
+import path25 from "path";
 var IMPORT_REGEX_ES = /import\s+.*?\s+from\s+['"]([^'"]+)['"]/g;
 var IMPORT_REGEX_REQUIRE = /require\s*\(\s*['"]([^'"]+)['"]\s*\)/g;
 var IMPORT_REGEX_REEXPORT = /export\s+(?:\{[^}]*\}|\*)\s+from\s+['"]([^'"]+)['"]/g;
@@ -41067,8 +41118,8 @@ function resolveRelativeImport(fromDir, importPath) {
   if (!importPath.startsWith(".")) {
     return null;
   }
-  const resolved = path24.resolve(fromDir, importPath);
-  if (path24.extname(resolved)) {
+  const resolved = path25.resolve(fromDir, importPath);
+  if (path25.extname(resolved)) {
     if (fs13.existsSync(resolved) && fs13.statSync(resolved).isFile()) {
       return normalizePath(resolved);
     }
@@ -41113,12 +41164,12 @@ function findTestFilesSync(cwd) {
     for (const entry of entries) {
       if (entry.isDirectory()) {
         if (!skipDirs.has(entry.name)) {
-          walk(path24.join(dir, entry.name), visitedInodes);
+          walk(path25.join(dir, entry.name), visitedInodes);
         }
       } else if (entry.isFile()) {
         const name = entry.name;
         if (/\.(test|spec)\.(ts|tsx|js|jsx)$/.test(name) || dir.includes("__tests__") && /\.(ts|tsx|js|jsx)$/.test(name)) {
-          testFiles.push(normalizePath(path24.join(dir, entry.name)));
+          testFiles.push(normalizePath(path25.join(dir, entry.name)));
         }
       }
     }
@@ -41156,7 +41207,7 @@ async function buildImpactMapInternal(cwd) {
       continue;
     }
     const imports = extractImports(content);
-    const testDir = path24.dirname(testFile);
+    const testDir = path25.dirname(testFile);
     for (const importPath of imports) {
       const resolvedSource = resolveRelativeImport(testDir, importPath);
       if (resolvedSource === null) {
@@ -41178,7 +41229,7 @@ async function buildImpactMap(cwd) {
   return impactMap;
 }
 async function loadImpactMap(cwd) {
-  const cachePath = path24.join(cwd, ".swarm", "cache", "impact-map.json");
+  const cachePath = path25.join(cwd, ".swarm", "cache", "impact-map.json");
   if (fs13.existsSync(cachePath)) {
     try {
       const content = fs13.readFileSync(cachePath, "utf-8");
@@ -41193,8 +41244,8 @@ async function loadImpactMap(cwd) {
   return buildImpactMap(cwd);
 }
 async function saveImpactMap(cwd, impactMap) {
-  const cacheDir2 = path24.join(cwd, ".swarm", "cache");
-  const cachePath = path24.join(cacheDir2, "impact-map.json");
+  const cacheDir2 = path25.join(cwd, ".swarm", "cache");
+  const cachePath = path25.join(cacheDir2, "impact-map.json");
   if (!fs13.existsSync(cacheDir2)) {
     fs13.mkdirSync(cacheDir2, { recursive: true });
   }
@@ -41220,7 +41271,7 @@ async function analyzeImpact(changedFiles, cwd) {
   const impactedTestsSet = new Set;
   const untestedFiles = [];
   for (const changedFile of validFiles) {
-    const normalizedChanged = normalizePath(path24.resolve(changedFile));
+    const normalizedChanged = normalizePath(path25.resolve(changedFile));
     const tests = impactMap[normalizedChanged];
     if (tests && tests.length > 0) {
       for (const test of tests) {
@@ -41467,13 +41518,13 @@ function detectFlakyTests(allHistory) {
 
 // src/test-impact/history-store.ts
 import fs14 from "fs";
-import path25 from "path";
+import path26 from "path";
 var MAX_HISTORY_PER_TEST = 20;
 var MAX_ERROR_LENGTH = 500;
 var MAX_STACK_LENGTH = 200;
 var MAX_CHANGED_FILES = 50;
 function getHistoryPath(workingDir) {
-  return path25.join(workingDir || process.cwd(), ".swarm", "cache", "test-history.jsonl");
+  return path26.join(workingDir || process.cwd(), ".swarm", "cache", "test-history.jsonl");
 }
 function sanitizeErrorMessage(errorMessage) {
   if (errorMessage === undefined) {
@@ -41533,7 +41584,7 @@ function appendTestRun(record3, workingDir) {
     changedFiles: sanitizeChangedFiles(record3.changedFiles || [])
   };
   const historyPath = getHistoryPath(workingDir);
-  const historyDir = path25.dirname(historyPath);
+  const historyDir = path26.dirname(historyPath);
   if (!fs14.existsSync(historyDir)) {
     fs14.mkdirSync(historyDir, { recursive: true });
   }
@@ -41607,7 +41658,7 @@ function getAllHistory(workingDir) {
 
 // src/tools/resolve-working-directory.ts
 import * as fs15 from "fs";
-import * as path26 from "path";
+import * as path27 from "path";
 function resolveWorkingDirectory(workingDirectory, fallbackDirectory) {
   if (workingDirectory == null || workingDirectory === "") {
     return { success: true, directory: fallbackDirectory };
@@ -41627,15 +41678,15 @@ function resolveWorkingDirectory(workingDirectory, fallbackDirectory) {
       };
     }
   }
-  const normalizedDir = path26.normalize(workingDirectory);
-  const pathParts = normalizedDir.split(path26.sep);
+  const normalizedDir = path27.normalize(workingDirectory);
+  const pathParts = normalizedDir.split(path27.sep);
   if (pathParts.includes("..")) {
     return {
       success: false,
       message: "Invalid working_directory: path traversal sequences (..) are not allowed"
     };
   }
-  const resolvedDir = path26.resolve(normalizedDir);
+  const resolvedDir = path27.resolve(normalizedDir);
   let statResult;
   try {
     statResult = fs15.statSync(resolvedDir);
@@ -41651,7 +41702,7 @@ function resolveWorkingDirectory(workingDirectory, fallbackDirectory) {
       message: `Invalid working_directory: path "${resolvedDir}" is not a directory`
     };
   }
-  const resolvedFallback = path26.resolve(fallbackDirectory);
+  const resolvedFallback = path27.resolve(fallbackDirectory);
   let fallbackExists = false;
   try {
     fs15.statSync(resolvedFallback);
@@ -41661,7 +41712,7 @@ function resolveWorkingDirectory(workingDirectory, fallbackDirectory) {
   }
   if (workingDirectory != null && workingDirectory !== "") {
     if (fallbackExists) {
-      const isSubdirectory = resolvedDir.startsWith(resolvedFallback + path26.sep);
+      const isSubdirectory = resolvedDir.startsWith(resolvedFallback + path27.sep);
       if (isSubdirectory) {
         return {
           success: false,
@@ -41751,14 +41802,14 @@ function hasDevDependency(devDeps, ...patterns) {
   return hasPackageJsonDependency(devDeps, ...patterns);
 }
 function detectGoTest(cwd) {
-  return fs16.existsSync(path27.join(cwd, "go.mod")) && isCommandAvailable("go");
+  return fs16.existsSync(path28.join(cwd, "go.mod")) && isCommandAvailable("go");
 }
 function detectJavaMaven(cwd) {
-  return fs16.existsSync(path27.join(cwd, "pom.xml")) && isCommandAvailable("mvn");
+  return fs16.existsSync(path28.join(cwd, "pom.xml")) && isCommandAvailable("mvn");
 }
 function detectGradle(cwd) {
-  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"));
+  const hasBuildFile = fs16.existsSync(path28.join(cwd, "build.gradle")) || fs16.existsSync(path28.join(cwd, "build.gradle.kts"));
+  const hasGradlew = fs16.existsSync(path28.join(cwd, "gradlew")) || fs16.existsSync(path28.join(cwd, "gradlew.bat"));
   return hasBuildFile && (hasGradlew || isCommandAvailable("gradle"));
 }
 function detectDotnetTest(cwd) {
@@ -41771,30 +41822,30 @@ function detectDotnetTest(cwd) {
   }
 }
 function detectCTest(cwd) {
-  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"));
+  const hasSource = fs16.existsSync(path28.join(cwd, "CMakeLists.txt"));
+  const hasBuildCache = fs16.existsSync(path28.join(cwd, "CMakeCache.txt")) || fs16.existsSync(path28.join(cwd, "build", "CMakeCache.txt"));
   return (hasSource || hasBuildCache) && isCommandAvailable("ctest");
 }
 function detectSwiftTest(cwd) {
-  return fs16.existsSync(path27.join(cwd, "Package.swift")) && isCommandAvailable("swift");
+  return fs16.existsSync(path28.join(cwd, "Package.swift")) && isCommandAvailable("swift");
 }
 function detectDartTest(cwd) {
-  return fs16.existsSync(path27.join(cwd, "pubspec.yaml")) && (isCommandAvailable("dart") || isCommandAvailable("flutter"));
+  return fs16.existsSync(path28.join(cwd, "pubspec.yaml")) && (isCommandAvailable("dart") || isCommandAvailable("flutter"));
 }
 function detectRSpec(cwd) {
-  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 hasRSpecFile = fs16.existsSync(path28.join(cwd, ".rspec"));
+  const hasGemfile = fs16.existsSync(path28.join(cwd, "Gemfile"));
+  const hasSpecDir = fs16.existsSync(path28.join(cwd, "spec"));
   const hasRSpec = hasRSpecFile || hasGemfile && hasSpecDir;
   return hasRSpec && (isCommandAvailable("bundle") || isCommandAvailable("rspec"));
 }
 function detectMinitest(cwd) {
-  return fs16.existsSync(path27.join(cwd, "test")) && (fs16.existsSync(path27.join(cwd, "Gemfile")) || fs16.existsSync(path27.join(cwd, "Rakefile"))) && isCommandAvailable("ruby");
+  return fs16.existsSync(path28.join(cwd, "test")) && (fs16.existsSync(path28.join(cwd, "Gemfile")) || fs16.existsSync(path28.join(cwd, "Rakefile"))) && isCommandAvailable("ruby");
 }
 async function detectTestFramework(cwd) {
   const baseDir = cwd;
   try {
-    const packageJsonPath = path27.join(baseDir, "package.json");
+    const packageJsonPath = path28.join(baseDir, "package.json");
     if (fs16.existsSync(packageJsonPath)) {
       const content = fs16.readFileSync(packageJsonPath, "utf-8");
       const pkg = JSON.parse(content);
@@ -41815,16 +41866,16 @@ async function detectTestFramework(cwd) {
         return "jest";
       if (hasDevDependency(devDeps, "mocha", "@types/mocha"))
         return "mocha";
-      if (fs16.existsSync(path27.join(baseDir, "bun.lockb")) || fs16.existsSync(path27.join(baseDir, "bun.lock"))) {
+      if (fs16.existsSync(path28.join(baseDir, "bun.lockb")) || fs16.existsSync(path28.join(baseDir, "bun.lock"))) {
         if (scripts.test?.includes("bun"))
           return "bun";
       }
     }
   } catch {}
   try {
-    const pyprojectTomlPath = path27.join(baseDir, "pyproject.toml");
-    const setupCfgPath = path27.join(baseDir, "setup.cfg");
-    const requirementsTxtPath = path27.join(baseDir, "requirements.txt");
+    const pyprojectTomlPath = path28.join(baseDir, "pyproject.toml");
+    const setupCfgPath = path28.join(baseDir, "setup.cfg");
+    const requirementsTxtPath = path28.join(baseDir, "requirements.txt");
     if (fs16.existsSync(pyprojectTomlPath)) {
       const content = fs16.readFileSync(pyprojectTomlPath, "utf-8");
       if (content.includes("[tool.pytest"))
@@ -41844,7 +41895,7 @@ async function detectTestFramework(cwd) {
     }
   } catch {}
   try {
-    const cargoTomlPath = path27.join(baseDir, "Cargo.toml");
+    const cargoTomlPath = path28.join(baseDir, "Cargo.toml");
     if (fs16.existsSync(cargoTomlPath)) {
       const content = fs16.readFileSync(cargoTomlPath, "utf-8");
       if (content.includes("[dev-dependencies]")) {
@@ -41855,9 +41906,9 @@ async function detectTestFramework(cwd) {
     }
   } catch {}
   try {
-    const pesterConfigPath = path27.join(baseDir, "pester.config.ps1");
-    const pesterConfigJsonPath = path27.join(baseDir, "pester.config.ps1.json");
-    const pesterPs1Path = path27.join(baseDir, "tests.ps1");
+    const pesterConfigPath = path28.join(baseDir, "pester.config.ps1");
+    const pesterConfigJsonPath = path28.join(baseDir, "pester.config.ps1.json");
+    const pesterPs1Path = path28.join(baseDir, "tests.ps1");
     if (fs16.existsSync(pesterConfigPath) || fs16.existsSync(pesterConfigJsonPath) || fs16.existsSync(pesterPs1Path)) {
       return "pester";
     }
@@ -41900,12 +41951,12 @@ function isTestDirectoryPath(normalizedPath) {
   return normalizedPath.split("/").some((segment) => TEST_DIRECTORY_NAMES.includes(segment));
 }
 function resolveWorkspacePath(file3, workingDir) {
-  return path27.isAbsolute(file3) ? path27.resolve(file3) : path27.resolve(workingDir, file3);
+  return path28.isAbsolute(file3) ? path28.resolve(file3) : path28.resolve(workingDir, file3);
 }
 function toWorkspaceOutputPath(absolutePath, workingDir, preferRelative) {
   if (!preferRelative)
     return absolutePath;
-  return path27.relative(workingDir, absolutePath);
+  return path28.relative(workingDir, absolutePath);
 }
 function dedupePush(target, value) {
   if (!target.includes(value)) {
@@ -41942,18 +41993,18 @@ function buildLanguageSpecificTestNames(nameWithoutExt, ext) {
   }
 }
 function getRepoLevelCandidateDirectories(workingDir, relativePath, ext) {
-  const relativeDir = path27.dirname(relativePath);
+  const relativeDir = path28.dirname(relativePath);
   const nestedRelativeDir = relativeDir === "." ? "" : relativeDir;
   const directories = TEST_DIRECTORY_NAMES.flatMap((dirName) => {
-    const rootDir = path27.join(workingDir, dirName);
-    return nestedRelativeDir ? [rootDir, path27.join(rootDir, nestedRelativeDir)] : [rootDir];
+    const rootDir = path28.join(workingDir, dirName);
+    return nestedRelativeDir ? [rootDir, path28.join(rootDir, nestedRelativeDir)] : [rootDir];
   });
   const normalizedRelativePath = relativePath.replace(/\\/g, "/");
   if (ext === ".java" && normalizedRelativePath.startsWith("src/main/java/")) {
-    directories.push(path27.join(workingDir, "src/test/java", path27.dirname(normalizedRelativePath.slice("src/main/java/".length))));
+    directories.push(path28.join(workingDir, "src/test/java", path28.dirname(normalizedRelativePath.slice("src/main/java/".length))));
   }
   if ((ext === ".kt" || ext === ".java") && normalizedRelativePath.startsWith("src/main/kotlin/")) {
-    directories.push(path27.join(workingDir, "src/test/kotlin", path27.dirname(normalizedRelativePath.slice("src/main/kotlin/".length))));
+    directories.push(path28.join(workingDir, "src/test/kotlin", path28.dirname(normalizedRelativePath.slice("src/main/kotlin/".length))));
   }
   return [...new Set(directories)];
 }
@@ -41981,23 +42032,23 @@ function isLanguageSpecificTestFile(basename4) {
 }
 function isConventionTestFilePath(filePath) {
   const normalizedPath = filePath.replace(/\\/g, "/");
-  const basename4 = path27.basename(filePath);
+  const basename4 = path28.basename(filePath);
   return hasCompoundTestExtension(basename4) || basename4.includes(".spec.") || basename4.includes(".test.") || isLanguageSpecificTestFile(basename4) || isTestDirectoryPath(normalizedPath);
 }
 function getTestFilesFromConvention(sourceFiles, workingDir = process.cwd()) {
   const testFiles = [];
   for (const file3 of sourceFiles) {
     const absoluteFile = resolveWorkspacePath(file3, workingDir);
-    const relativeFile = path27.relative(workingDir, absoluteFile);
-    const basename4 = path27.basename(absoluteFile);
-    const dirname11 = path27.dirname(absoluteFile);
-    const preferRelativeOutput = !path27.isAbsolute(file3);
+    const relativeFile = path28.relative(workingDir, absoluteFile);
+    const basename4 = path28.basename(absoluteFile);
+    const dirname11 = path28.dirname(absoluteFile);
+    const preferRelativeOutput = !path28.isAbsolute(file3);
     if (isConventionTestFilePath(relativeFile) || isConventionTestFilePath(file3)) {
       dedupePush(testFiles, toWorkspaceOutputPath(absoluteFile, workingDir, preferRelativeOutput));
       continue;
     }
     const nameWithoutExt = basename4.replace(/\.[^.]+$/, "");
-    const ext = path27.extname(basename4);
+    const ext = path28.extname(basename4);
     const genericTestNames = [
       `${nameWithoutExt}.spec${ext}`,
       `${nameWithoutExt}.test${ext}`
@@ -42006,7 +42057,7 @@ function getTestFilesFromConvention(sourceFiles, workingDir = process.cwd()) {
     const colocatedCandidates = [
       ...genericTestNames,
       ...languageSpecificTestNames
-    ].map((candidateName) => path27.join(dirname11, candidateName));
+    ].map((candidateName) => path28.join(dirname11, candidateName));
     const testDirectoryNames = [
       basename4,
       ...genericTestNames,
@@ -42015,8 +42066,8 @@ function getTestFilesFromConvention(sourceFiles, workingDir = process.cwd()) {
     const repoLevelDirectories = getRepoLevelCandidateDirectories(workingDir, relativeFile, ext);
     const possibleTestFiles = [
       ...colocatedCandidates,
-      ...TEST_DIRECTORY_NAMES.flatMap((dirName) => testDirectoryNames.map((candidateName) => path27.join(dirname11, dirName, candidateName))),
-      ...repoLevelDirectories.flatMap((candidateDir) => testDirectoryNames.map((candidateName) => path27.join(candidateDir, candidateName)))
+      ...TEST_DIRECTORY_NAMES.flatMap((dirName) => testDirectoryNames.map((candidateName) => path28.join(dirname11, dirName, candidateName))),
+      ...repoLevelDirectories.flatMap((candidateDir) => testDirectoryNames.map((candidateName) => path28.join(candidateDir, candidateName)))
     ];
     for (const testFile of possibleTestFiles) {
       if (fs16.existsSync(testFile)) {
@@ -42037,7 +42088,7 @@ async function getTestFilesFromGraph(sourceFiles, workingDir) {
     try {
       const absoluteTestFile = resolveWorkspacePath(testFile, workingDir);
       const content = fs16.readFileSync(absoluteTestFile, "utf-8");
-      const testDir = path27.dirname(absoluteTestFile);
+      const testDir = path28.dirname(absoluteTestFile);
       const importRegex = /import\s+.*?\s+from\s+['"]([^'"]+)['"]/g;
       let match;
       match = importRegex.exec(content);
@@ -42045,8 +42096,8 @@ async function getTestFilesFromGraph(sourceFiles, workingDir) {
         const importPath = match[1];
         let resolvedImport;
         if (importPath.startsWith(".")) {
-          resolvedImport = path27.resolve(testDir, importPath);
-          const existingExt = path27.extname(resolvedImport);
+          resolvedImport = path28.resolve(testDir, importPath);
+          const existingExt = path28.extname(resolvedImport);
           if (!existingExt) {
             for (const extToTry of [
               ".ts",
@@ -42066,12 +42117,12 @@ async function getTestFilesFromGraph(sourceFiles, workingDir) {
         } else {
           continue;
         }
-        const importBasename = path27.basename(resolvedImport, path27.extname(resolvedImport));
-        const importDir = path27.dirname(resolvedImport);
+        const importBasename = path28.basename(resolvedImport, path28.extname(resolvedImport));
+        const importDir = path28.dirname(resolvedImport);
         for (const sourceFile of absoluteSourceFiles) {
-          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") || importDir === path27.join(sourceDir, "spec");
+          const sourceDir = path28.dirname(sourceFile);
+          const sourceBasename = path28.basename(sourceFile, path28.extname(sourceFile));
+          const isRelatedDir = importDir === sourceDir || importDir === path28.join(sourceDir, "__tests__") || importDir === path28.join(sourceDir, "tests") || importDir === path28.join(sourceDir, "test") || importDir === path28.join(sourceDir, "spec");
           if (resolvedImport === sourceFile || importBasename === sourceBasename && isRelatedDir) {
             dedupePush(testFiles, testFile);
             break;
@@ -42084,8 +42135,8 @@ async function getTestFilesFromGraph(sourceFiles, workingDir) {
       while (match !== null) {
         const importPath = match[1];
         if (importPath.startsWith(".")) {
-          let resolvedImport = path27.resolve(testDir, importPath);
-          const existingExt = path27.extname(resolvedImport);
+          let resolvedImport = path28.resolve(testDir, importPath);
+          const existingExt = path28.extname(resolvedImport);
           if (!existingExt) {
             for (const extToTry of [
               ".ts",
@@ -42102,12 +42153,12 @@ async function getTestFilesFromGraph(sourceFiles, workingDir) {
               }
             }
           }
-          const importDir = path27.dirname(resolvedImport);
-          const importBasename = path27.basename(resolvedImport, path27.extname(resolvedImport));
+          const importDir = path28.dirname(resolvedImport);
+          const importBasename = path28.basename(resolvedImport, path28.extname(resolvedImport));
           for (const sourceFile of absoluteSourceFiles) {
-            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") || importDir === path27.join(sourceDir, "spec");
+            const sourceDir = path28.dirname(sourceFile);
+            const sourceBasename = path28.basename(sourceFile, path28.extname(sourceFile));
+            const isRelatedDir = importDir === sourceDir || importDir === path28.join(sourceDir, "__tests__") || importDir === path28.join(sourceDir, "tests") || importDir === path28.join(sourceDir, "test") || importDir === path28.join(sourceDir, "spec");
             if (resolvedImport === sourceFile || importBasename === sourceBasename && isRelatedDir) {
               dedupePush(testFiles, testFile);
               break;
@@ -42210,8 +42261,8 @@ function buildTestCommand(framework, scope, files, coverage, baseDir) {
       return ["mvn", "test"];
     case "gradle": {
       const isWindows = process.platform === "win32";
-      const hasGradlewBat = fs16.existsSync(path27.join(baseDir, "gradlew.bat"));
-      const hasGradlew = fs16.existsSync(path27.join(baseDir, "gradlew"));
+      const hasGradlewBat = fs16.existsSync(path28.join(baseDir, "gradlew.bat"));
+      const hasGradlew = fs16.existsSync(path28.join(baseDir, "gradlew"));
       if (hasGradlewBat && isWindows)
         return ["gradlew.bat", "test"];
       if (hasGradlew)
@@ -42228,7 +42279,7 @@ function buildTestCommand(framework, scope, files, coverage, baseDir) {
         "cmake-build-release",
         "out"
       ];
-      const actualBuildDir = buildDirCandidates.find((d) => fs16.existsSync(path27.join(baseDir, d, "CMakeCache.txt"))) ?? "build";
+      const actualBuildDir = buildDirCandidates.find((d) => fs16.existsSync(path28.join(baseDir, d, "CMakeCache.txt"))) ?? "build";
       return ["ctest", "--test-dir", actualBuildDir];
     }
     case "swift-test":
@@ -42856,7 +42907,7 @@ var test_runner = createSwarmTool({
       const sourceFiles = args.files.filter((file3) => {
         if (directTestFiles.includes(file3))
           return false;
-        const ext = path27.extname(file3).toLowerCase();
+        const ext = path28.extname(file3).toLowerCase();
         return SOURCE_EXTENSIONS.has(ext);
       });
       const invalidFiles = args.files.filter((file3) => !directTestFiles.includes(file3) && !sourceFiles.includes(file3));
@@ -42891,7 +42942,7 @@ var test_runner = createSwarmTool({
         if (isConventionTestFilePath(f)) {
           return false;
         }
-        const ext = path27.extname(f).toLowerCase();
+        const ext = path28.extname(f).toLowerCase();
         return SOURCE_EXTENSIONS.has(ext);
       });
       if (sourceFiles.length === 0) {
@@ -42918,7 +42969,7 @@ var test_runner = createSwarmTool({
         if (isConventionTestFilePath(f)) {
           return false;
         }
-        const ext = path27.extname(f).toLowerCase();
+        const ext = path28.extname(f).toLowerCase();
         return SOURCE_EXTENSIONS.has(ext);
       });
       if (sourceFiles.length === 0) {
@@ -42936,8 +42987,8 @@ var test_runner = createSwarmTool({
         const impactResult = await analyzeImpact(sourceFiles, workingDir);
         if (impactResult.impactedTests.length > 0) {
           testFiles = impactResult.impactedTests.map((absPath) => {
-            const relativePath = path27.relative(workingDir, absPath);
-            return path27.isAbsolute(relativePath) ? absPath : relativePath;
+            const relativePath = path28.relative(workingDir, absPath);
+            return path28.isAbsolute(relativePath) ? absPath : relativePath;
           });
         } else {
           graphFallbackReason = "no impacted tests found via impact analysis, falling back to graph";
@@ -43030,8 +43081,8 @@ function validateDirectoryPath(dir) {
   if (dir.includes("..")) {
     throw new Error("Directory path must not contain path traversal sequences");
   }
-  const normalized = path28.normalize(dir);
-  const absolutePath = path28.isAbsolute(normalized) ? normalized : path28.resolve(normalized);
+  const normalized = path29.normalize(dir);
+  const absolutePath = path29.isAbsolute(normalized) ? normalized : path29.resolve(normalized);
   return absolutePath;
 }
 function validateTimeout(timeoutMs, defaultValue) {
@@ -43054,7 +43105,7 @@ function validateTimeout(timeoutMs, defaultValue) {
 }
 function getPackageVersion(dir) {
   try {
-    const packagePath = path28.join(dir, "package.json");
+    const packagePath = path29.join(dir, "package.json");
     if (fs17.existsSync(packagePath)) {
       const content = fs17.readFileSync(packagePath, "utf-8");
       const pkg = JSON.parse(content);
@@ -43065,7 +43116,7 @@ function getPackageVersion(dir) {
 }
 function getChangelogVersion(dir) {
   try {
-    const changelogPath = path28.join(dir, "CHANGELOG.md");
+    const changelogPath = path29.join(dir, "CHANGELOG.md");
     if (fs17.existsSync(changelogPath)) {
       const content = fs17.readFileSync(changelogPath, "utf-8");
       const match = content.match(/^##\s*\[?(\d+\.\d+\.\d+)\]?/m);
@@ -43079,7 +43130,7 @@ function getChangelogVersion(dir) {
 function getVersionFileVersion(dir) {
   const possibleFiles = ["VERSION.txt", "version.txt", "VERSION", "version"];
   for (const file3 of possibleFiles) {
-    const filePath = path28.join(dir, file3);
+    const filePath = path29.join(dir, file3);
     if (fs17.existsSync(filePath)) {
       try {
         const content = fs17.readFileSync(filePath, "utf-8").trim();
@@ -43406,7 +43457,7 @@ async function runEvidenceCheck(dir) {
 async function runRequirementCoverageCheck(dir, currentPhase) {
   const startTime = Date.now();
   try {
-    const specPath = path28.join(dir, ".swarm", "spec.md");
+    const specPath = path29.join(dir, ".swarm", "spec.md");
     if (!fs17.existsSync(specPath)) {
       return {
         type: "req_coverage",
@@ -44529,7 +44580,7 @@ async function handleResetCommand(directory, args) {
 // src/commands/reset-session.ts
 init_utils2();
 import * as fs19 from "fs";
-import * as path29 from "path";
+import * as path30 from "path";
 async function handleResetSessionCommand(directory, _args) {
   const results = [];
   try {
@@ -44544,13 +44595,13 @@ async function handleResetSessionCommand(directory, _args) {
     results.push("\u274C Failed to delete state.json");
   }
   try {
-    const sessionDir = path29.dirname(validateSwarmPath(directory, "session/state.json"));
+    const sessionDir = path30.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 = path29.join(sessionDir, file3);
+        const filePath = path30.join(sessionDir, file3);
         if (fs19.lstatSync(filePath).isFile()) {
           fs19.unlinkSync(filePath);
           deletedCount++;
@@ -44580,7 +44631,7 @@ async function handleResetSessionCommand(directory, _args) {
 // src/summaries/manager.ts
 init_utils2();
 init_utils();
-import * as path30 from "path";
+import * as path31 from "path";
 var SUMMARY_ID_REGEX = /^S\d+$/;
 function sanitizeSummaryId(id) {
   if (!id || id.length === 0) {
@@ -44604,7 +44655,7 @@ function sanitizeSummaryId(id) {
 }
 async function loadFullOutput(directory, id) {
   const sanitizedId = sanitizeSummaryId(id);
-  const relativePath = path30.join("summaries", `${sanitizedId}.json`);
+  const relativePath = path31.join("summaries", `${sanitizedId}.json`);
   validateSwarmPath(directory, relativePath);
   const content = await readSwarmFileAsync(directory, relativePath);
   if (content === null) {
@@ -44660,7 +44711,7 @@ init_plan_schema();
 init_utils2();
 init_ledger();
 import * as fs20 from "fs";
-import * as path31 from "path";
+import * as path32 from "path";
 async function handleRollbackCommand(directory, args) {
   const phaseArg = args[0];
   if (!phaseArg) {
@@ -44725,8 +44776,8 @@ async function handleRollbackCommand(directory, args) {
     if (EXCLUDE_FILES.has(file3) || file3.startsWith("plan-ledger.archived-")) {
       continue;
     }
-    const src = path31.join(checkpointDir, file3);
-    const dest = path31.join(swarmDir, file3);
+    const src = path32.join(checkpointDir, file3);
+    const dest = path32.join(swarmDir, file3);
     try {
       fs20.cpSync(src, dest, { recursive: true, force: true });
       successes.push(file3);
@@ -44745,12 +44796,12 @@ async function handleRollbackCommand(directory, args) {
     ].join(`
 `);
   }
-  const existingLedgerPath = path31.join(swarmDir, "plan-ledger.jsonl");
+  const existingLedgerPath = path32.join(swarmDir, "plan-ledger.jsonl");
   if (fs20.existsSync(existingLedgerPath)) {
     fs20.unlinkSync(existingLedgerPath);
   }
   try {
-    const planJsonPath = path31.join(swarmDir, "plan.json");
+    const planJsonPath = path32.join(swarmDir, "plan.json");
     if (fs20.existsSync(planJsonPath)) {
       const planRaw = fs20.readFileSync(planJsonPath, "utf-8");
       const plan = PlanSchema.parse(JSON.parse(planRaw));
@@ -44823,9 +44874,9 @@ async function handleSimulateCommand(directory, args) {
   const report = reportLines.filter(Boolean).join(`
 `);
   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 });
+  const path33 = await import("path");
+  const reportPath = path33.join(directory, ".swarm", "simulate-report.md");
+  await fs21.mkdir(path33.dirname(reportPath), { recursive: true });
   await fs21.writeFile(reportPath, report, "utf-8");
   return `${darkMatterPairs.length} hidden coupling pairs detected`;
 }
@@ -45360,21 +45411,34 @@ function resolveCommand(tokens) {
 
 // src/cli/index.ts
 var { version: version4 } = package_default;
-var CONFIG_DIR = path32.join(process.env.XDG_CONFIG_HOME || path32.join(os6.homedir(), ".config"), "opencode");
-var OPENCODE_CONFIG_PATH = path32.join(CONFIG_DIR, "opencode.json");
-var PLUGIN_CONFIG_PATH = path32.join(CONFIG_DIR, "opencode-swarm.json");
-var PROMPTS_DIR = path32.join(CONFIG_DIR, "opencode-swarm");
-var OPENCODE_PLUGIN_CACHE_PATHS = [
-  path32.join(process.env.XDG_CACHE_HOME || path32.join(os6.homedir(), ".cache"), "opencode", "packages", "opencode-swarm@latest"),
-  path32.join(CONFIG_DIR, "node_modules", "opencode-swarm")
-];
+var CONFIG_DIR = getPluginConfigDir();
+var OPENCODE_CONFIG_PATH = path33.join(CONFIG_DIR, "opencode.json");
+var PLUGIN_CONFIG_PATH = path33.join(CONFIG_DIR, "opencode-swarm.json");
+var PROMPTS_DIR = path33.join(CONFIG_DIR, "opencode-swarm");
+var OPENCODE_PLUGIN_CACHE_PATHS = getPluginCachePaths();
 function isSafeCachePath(p) {
-  const resolved = path32.resolve(p);
-  const home = path32.resolve(os6.homedir());
-  if (resolved === "/" || resolved === home || resolved.length <= home.length)
+  const resolved = path33.resolve(p);
+  const home = path33.resolve(os7.homedir());
+  if (resolved === "/" || resolved === home || resolved.length <= home.length) {
+    return false;
+  }
+  const segments = resolved.split(path33.sep).filter((s) => s.length > 0);
+  if (segments.length < 4) {
     return false;
-  const leaf = path32.basename(resolved);
-  return leaf === "opencode-swarm@latest" || leaf === "opencode-swarm";
+  }
+  const leaf = path33.basename(resolved);
+  if (leaf !== "opencode-swarm@latest" && leaf !== "opencode-swarm") {
+    return false;
+  }
+  const parent = path33.basename(path33.dirname(resolved));
+  if (parent !== "packages" && parent !== "node_modules") {
+    return false;
+  }
+  const grandparent = path33.basename(path33.dirname(path33.dirname(resolved)));
+  if (grandparent !== "opencode") {
+    return false;
+  }
+  return true;
 }
 function ensureDir(dir) {
   if (!fs21.existsSync(dir)) {
@@ -45396,8 +45460,8 @@ function saveJson(filepath, data) {
 }
 function writeProjectConfigIfMissing(cwd) {
   try {
-    const opencodeDir = path32.join(cwd, ".opencode");
-    const projectConfigPath = path32.join(opencodeDir, "opencode-swarm.json");
+    const opencodeDir = path33.join(cwd, ".opencode");
+    const projectConfigPath = path33.join(opencodeDir, "opencode-swarm.json");
     if (fs21.existsSync(projectConfigPath)) {
       return;
     }
@@ -45415,7 +45479,7 @@ async function install() {
 `);
   ensureDir(CONFIG_DIR);
   ensureDir(PROMPTS_DIR);
-  const LEGACY_CONFIG_PATH = path32.join(CONFIG_DIR, "config.json");
+  const LEGACY_CONFIG_PATH = path33.join(CONFIG_DIR, "config.json");
   let opencodeConfig = loadJson(OPENCODE_CONFIG_PATH);
   if (!opencodeConfig) {
     const legacyConfig = loadJson(LEGACY_CONFIG_PATH);