opencode-swarm 6.86.7 → 6.86.9

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.7",
+  version: "6.86.9",
   description: "Architect-centric agentic swarm plugin for OpenCode - hub-and-spoke orchestration with SME consultation, code generation, and QA review",
   main: "dist/index.js",
   types: "dist/index.d.ts",
@@ -18618,7 +18618,7 @@ var package_default = {
   ],
   scripts: {
     clean: `bun -e "require('fs').rmSync('dist',{recursive:true,force:true})"`,
-    build: "bun run clean && bun run scripts/copy-grammars.ts && bun build src/index.ts --outdir dist --target bun --format esm && bun build src/cli/index.ts --outdir dist/cli --target bun --format esm && bun run scripts/copy-grammars.ts --to-dist && tsc --emitDeclarationOnly",
+    build: "bun run clean && bun run scripts/copy-grammars.ts && bun build src/index.ts --outdir dist --target node --format esm && bun build src/cli/index.ts --outdir dist/cli --target bun --format esm && bun run scripts/copy-grammars.ts --to-dist && tsc --emitDeclarationOnly",
     typecheck: "tsc --noEmit",
     test: "bun test",
     lint: "biome lint .",
@@ -19691,6 +19691,7 @@ var PluginConfigSchema = exports_external.object({
   parallelization: ParallelizationConfigSchema.optional(),
   turbo_mode: exports_external.boolean().default(false).optional(),
   quiet: exports_external.boolean().default(false).optional(),
+  version_check: exports_external.boolean().default(true).optional(),
   full_auto: exports_external.object({
     enabled: exports_external.boolean().default(false),
     critic_model: exports_external.string().optional(),
@@ -19967,9 +19968,17 @@ init_plan_schema();
 import { createHash as createHash3 } from "crypto";
 
 // src/db/project-db.ts
-import { Database } from "bun:sqlite";
 import { existsSync as existsSync5, mkdirSync as mkdirSync4 } from "fs";
+import { createRequire } from "module";
 import { join as join7, resolve as resolve5 } from "path";
+var _DatabaseCtor = null;
+function loadDatabaseCtor() {
+  if (_DatabaseCtor)
+    return _DatabaseCtor;
+  const req = createRequire(import.meta.url);
+  _DatabaseCtor = req("bun:sqlite").Database;
+  return _DatabaseCtor;
+}
 var MIGRATIONS = [
   {
     version: 1,
@@ -20040,7 +20049,8 @@ function getProjectDb(directory) {
     return existing;
   const swarmDir = join7(key, ".swarm");
   mkdirSync4(swarmDir, { recursive: true });
-  const db = new Database(join7(swarmDir, "swarm.db"));
+  const Db = loadDatabaseCtor();
+  const db = new Db(join7(swarmDir, "swarm.db"));
   db.run("PRAGMA journal_mode = WAL;");
   db.run("PRAGMA synchronous = NORMAL;");
   db.run("PRAGMA busy_timeout = 5000;");
@@ -36258,12 +36268,83 @@ async function handleDarkMatterCommand(directory, args) {
 
 // src/services/diagnose-service.ts
 import * as child_process4 from "child_process";
-import { existsSync as existsSync8, readdirSync as readdirSync4, readFileSync as readFileSync5, statSync as statSync5 } from "fs";
-import path17 from "path";
+import { existsSync as existsSync9, readdirSync as readdirSync4, readFileSync as readFileSync6, statSync as statSync5 } from "fs";
+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 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 : join15(homedir5(), ".cache");
+  return join15(base, "opencode-swarm");
+}
+function cacheFile() {
+  return join15(cacheDir(), "version-check.json");
+}
+function readVersionCache() {
+  try {
+    const path18 = cacheFile();
+    if (!existsSync8(path18))
+      return null;
+    const raw = readFileSync5(path18, "utf-8");
+    const parsed = JSON.parse(raw);
+    if (typeof parsed?.checkedAt !== "number")
+      return null;
+    const npmLatest = typeof parsed.npmLatest === "string" ? parsed.npmLatest : null;
+    return { checkedAt: parsed.checkedAt, npmLatest };
+  } catch {
+    return null;
+  }
+}
+function compareVersions(a, b) {
+  const [aBase, aPre] = a.split("-", 2);
+  const [bBase, bPre] = b.split("-", 2);
+  const aParts = aBase.split(".").map((n) => Number.parseInt(n, 10) || 0);
+  const bParts = bBase.split(".").map((n) => Number.parseInt(n, 10) || 0);
+  const len = Math.max(aParts.length, bParts.length);
+  for (let i = 0;i < len; i++) {
+    const av = aParts[i] ?? 0;
+    const bv = bParts[i] ?? 0;
+    if (av > bv)
+      return 1;
+    if (av < bv)
+      return -1;
+  }
+  if (aPre && !bPre)
+    return -1;
+  if (!aPre && bPre)
+    return 1;
+  if (aPre && bPre)
+    return aPre < bPre ? -1 : aPre > bPre ? 1 : 0;
+  return 0;
+}
+
+// src/services/diagnose-service.ts
 var { version: version3 } = package_default;
 function validateTaskDag(plan) {
   const allTaskIds = new Set;
@@ -36496,7 +36577,7 @@ async function checkConfigBackups(directory) {
 }
 async function checkGitRepository(directory) {
   try {
-    if (!existsSync8(directory) || !statSync5(directory).isDirectory()) {
+    if (!existsSync9(directory) || !statSync5(directory).isDirectory()) {
       return {
         name: "Git Repository",
         status: "\u274C",
@@ -36560,8 +36641,8 @@ async function checkSpecStaleness(directory, plan) {
   };
 }
 async function checkConfigParseability(directory) {
-  const configPath = path17.join(directory, ".opencode/opencode-swarm.json");
-  if (!existsSync8(configPath)) {
+  const configPath = path18.join(directory, ".opencode/opencode-swarm.json");
+  if (!existsSync9(configPath)) {
     return {
       name: "Config Parseability",
       status: "\u2705",
@@ -36569,7 +36650,7 @@ async function checkConfigParseability(directory) {
     };
   }
   try {
-    const content = readFileSync5(configPath, "utf-8");
+    const content = readFileSync6(configPath, "utf-8");
     JSON.parse(content);
     return {
       name: "Config Parseability",
@@ -36589,7 +36670,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 = [
@@ -36613,14 +36694,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 (!existsSync8(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 (!existsSync8(path17.join(grammarDir, file3))) {
+    if (!existsSync9(path18.join(grammarDir, file3))) {
       missing.push(file3);
     }
   }
@@ -36638,8 +36719,8 @@ async function checkGrammarWasmFiles() {
   };
 }
 async function checkCheckpointManifest(directory) {
-  const manifestPath = path17.join(directory, ".swarm/checkpoints.json");
-  if (!existsSync8(manifestPath)) {
+  const manifestPath = path18.join(directory, ".swarm/checkpoints.json");
+  if (!existsSync9(manifestPath)) {
     return {
       name: "Checkpoint Manifest",
       status: "\u2705",
@@ -36647,7 +36728,7 @@ async function checkCheckpointManifest(directory) {
     };
   }
   try {
-    const content = readFileSync5(manifestPath, "utf-8");
+    const content = readFileSync6(manifestPath, "utf-8");
     const parsed = JSON.parse(content);
     if (!parsed.checkpoints || !Array.isArray(parsed.checkpoints)) {
       return {
@@ -36690,8 +36771,8 @@ async function checkCheckpointManifest(directory) {
   }
 }
 async function checkEventStreamIntegrity(directory) {
-  const eventsPath = path17.join(directory, ".swarm/events.jsonl");
-  if (!existsSync8(eventsPath)) {
+  const eventsPath = path18.join(directory, ".swarm/events.jsonl");
+  if (!existsSync9(eventsPath)) {
     return {
       name: "Event Stream",
       status: "\u2705",
@@ -36699,7 +36780,7 @@ async function checkEventStreamIntegrity(directory) {
     };
   }
   try {
-    const content = readFileSync5(eventsPath, "utf-8");
+    const content = readFileSync6(eventsPath, "utf-8");
     const lines = content.split(`
 `).filter((line) => line.trim() !== "");
     let malformedCount = 0;
@@ -36731,8 +36812,8 @@ async function checkEventStreamIntegrity(directory) {
   }
 }
 async function checkSteeringDirectives(directory) {
-  const eventsPath = path17.join(directory, ".swarm/events.jsonl");
-  if (!existsSync8(eventsPath)) {
+  const eventsPath = path18.join(directory, ".swarm/events.jsonl");
+  if (!existsSync9(eventsPath)) {
     return {
       name: "Steering Directives",
       status: "\u2705",
@@ -36740,7 +36821,7 @@ async function checkSteeringDirectives(directory) {
     };
   }
   try {
-    const content = readFileSync5(eventsPath, "utf-8");
+    const content = readFileSync6(eventsPath, "utf-8");
     const lines = content.split(`
 `).filter((line) => line.trim() !== "");
     const directivesIssued = [];
@@ -36787,8 +36868,8 @@ async function checkCurator(directory) {
         detail: "Disabled (enable via curator.enabled)"
       };
     }
-    const summaryPath = path17.join(directory, ".swarm/curator-summary.json");
-    if (!existsSync8(summaryPath)) {
+    const summaryPath = path18.join(directory, ".swarm/curator-summary.json");
+    if (!existsSync9(summaryPath)) {
       return {
         name: "Curator",
         status: "\u2705",
@@ -36796,7 +36877,7 @@ async function checkCurator(directory) {
       };
     }
     try {
-      const content = readFileSync5(summaryPath, "utf-8");
+      const content = readFileSync6(summaryPath, "utf-8");
       const parsed = JSON.parse(content);
       if (typeof parsed.schema_version !== "number" || parsed.schema_version !== 1) {
         return {
@@ -36831,10 +36912,23 @@ async function checkCurator(directory) {
 }
 async function getDiagnoseData(directory) {
   const checks5 = [];
+  const versionCache = readVersionCache();
+  let versionDetail = version3;
+  let versionStatus = "\u2705";
+  if (versionCache?.npmLatest) {
+    const ageMs = Date.now() - versionCache.checkedAt;
+    const ageMin = Math.max(0, Math.round(ageMs / 60000));
+    if (compareVersions(versionCache.npmLatest, version3) > 0) {
+      versionStatus = "\u26A0\uFE0F";
+      versionDetail = `${version3} (npm latest: ${versionCache.npmLatest}, checked ${ageMin}m ago) ` + "\u2014 run `bunx opencode-swarm update` to refresh";
+    } else {
+      versionDetail = `${version3} (npm latest: ${versionCache.npmLatest}, checked ${ageMin}m ago)`;
+    }
+  }
   checks5.push({
     name: "Version",
-    status: "\u2705",
-    detail: version3
+    status: versionStatus,
+    detail: versionDetail
   });
   const plan = await loadPlanJsonOnly(directory);
   if (plan) {
@@ -36940,8 +37034,8 @@ async function getDiagnoseData(directory) {
   checks5.push(await checkSteeringDirectives(directory));
   checks5.push(await checkCurator(directory));
   try {
-    const evidenceDir = path17.join(directory, ".swarm", "evidence");
-    const snapshotFiles = existsSync8(evidenceDir) ? readdirSync4(evidenceDir).filter((f) => f.startsWith("agent-tools-") && f.endsWith(".json")) : [];
+    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();
       checks5.push({
@@ -36970,7 +37064,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 {
@@ -37008,15 +37131,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 join15 } from "path";
+import { extname as extname2, join as join17 } from "path";
 
 // src/lang/profiles.ts
 class LanguageRegistry {
@@ -37996,7 +38119,7 @@ async function detectProjectLanguages(projectDir) {
         if (detectFile.includes("*") || detectFile.includes("?"))
           continue;
         try {
-          await access2(join15(dir, detectFile));
+          await access2(join17(dir, detectFile));
           detected.add(profile.id);
           break;
         } catch {}
@@ -38017,7 +38140,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(join15(projectDir, entry.name));
+        await scanDir(join17(projectDir, entry.name));
       }
     }
   } catch {}
@@ -38176,11 +38299,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;
       }
@@ -38189,7 +38312,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 [];
   }
@@ -38230,7 +38353,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);
         }
@@ -38243,7 +38366,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)) {
@@ -38266,7 +38389,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;
         }
@@ -38441,8 +38564,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: [
@@ -39363,14 +39486,14 @@ async function handleHistoryCommand(directory, _args) {
 }
 // src/hooks/knowledge-migrator.ts
 import { randomUUID as randomUUID2 } from "crypto";
-import { existsSync as existsSync12, readFileSync as readFileSync9 } from "fs";
+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 (existsSync12(sentinelPath)) {
+  if (existsSync13(sentinelPath)) {
     return {
       migrated: false,
       entriesMigrated: 0,
@@ -39379,7 +39502,7 @@ async function migrateContextToKnowledge(directory, config3) {
       skippedReason: "sentinel-exists"
     };
   }
-  if (!existsSync12(contextPath)) {
+  if (!existsSync13(contextPath)) {
     return {
       migrated: false,
       entriesMigrated: 0,
@@ -39564,16 +39687,16 @@ function truncateLesson(text) {
   return `${text.slice(0, 277)}...`;
 }
 function inferProjectName(directory) {
-  const packageJsonPath = path21.join(directory, "package.json");
-  if (existsSync12(packageJsonPath)) {
+  const packageJsonPath = path22.join(directory, "package.json");
+  if (existsSync13(packageJsonPath)) {
     try {
-      const pkg = JSON.parse(readFileSync9(packageJsonPath, "utf-8"));
+      const pkg = JSON.parse(readFileSync10(packageJsonPath, "utf-8"));
       if (pkg.name && typeof pkg.name === "string") {
         return pkg.name;
       }
     } catch {}
   }
-  return path21.basename(directory);
+  return path22.basename(directory);
 }
 async function writeSentinel(sentinelPath, migrated, dropped) {
   const sentinel = {
@@ -39585,7 +39708,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");
 }
 
@@ -39822,12 +39945,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
@@ -39873,9 +39996,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") {
@@ -39891,7 +40014,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", "."];
@@ -39925,10 +40048,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]"))
@@ -39938,19 +40061,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 {
@@ -39969,11 +40092,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));
@@ -39987,13 +40110,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))
@@ -40021,10 +40144,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;
@@ -40033,10 +40156,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;
   }
@@ -40049,13 +40172,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);
   }
@@ -40264,7 +40387,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;
@@ -40491,7 +40614,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 [];
@@ -40514,7 +40637,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;
@@ -40535,7 +40658,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;
   }
@@ -40672,9 +40795,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,
@@ -40700,8 +40823,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;
@@ -40736,7 +40859,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 {
@@ -40802,7 +40925,7 @@ var secretscan = createSwarmTool({
       }
     }
     try {
-      const _scanDirRaw = path23.resolve(directory);
+      const _scanDirRaw = path24.resolve(directory);
       const scanDir = (() => {
         try {
           return fs12.realpathSync(_scanDirRaw);
@@ -40962,11 +41085,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;
@@ -40991,8 +41114,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);
     }
@@ -41037,12 +41160,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)));
         }
       }
     }
@@ -41080,7 +41203,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) {
@@ -41102,7 +41225,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");
@@ -41117,10 +41240,10 @@ async function loadImpactMap(cwd) {
   return buildImpactMap(cwd);
 }
 async function saveImpactMap(cwd, impactMap) {
-  const cacheDir = path24.join(cwd, ".swarm", "cache");
-  const cachePath = path24.join(cacheDir, "impact-map.json");
-  if (!fs13.existsSync(cacheDir)) {
-    fs13.mkdirSync(cacheDir, { recursive: true });
+  const cacheDir2 = path25.join(cwd, ".swarm", "cache");
+  const cachePath = path25.join(cacheDir2, "impact-map.json");
+  if (!fs13.existsSync(cacheDir2)) {
+    fs13.mkdirSync(cacheDir2, { recursive: true });
   }
   const data = {
     generatedAt: new Date().toISOString(),
@@ -41144,7 +41267,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) {
@@ -41391,13 +41514,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) {
@@ -41457,7 +41580,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 });
   }
@@ -41531,7 +41654,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 };
@@ -41551,15 +41674,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);
@@ -41575,7 +41698,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);
@@ -41585,7 +41708,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,
@@ -41675,14 +41798,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) {
@@ -41695,30 +41818,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);
@@ -41739,16 +41862,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"))
@@ -41768,7 +41891,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]")) {
@@ -41779,9 +41902,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";
     }
@@ -41824,12 +41947,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)) {
@@ -41866,18 +41989,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)];
 }
@@ -41905,23 +42028,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}`
@@ -41930,7 +42053,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,
@@ -41939,8 +42062,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)) {
@@ -41961,7 +42084,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);
@@ -41969,8 +42092,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",
@@ -41990,12 +42113,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;
@@ -42008,8 +42131,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",
@@ -42026,12 +42149,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;
@@ -42134,8 +42257,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)
@@ -42152,7 +42275,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":
@@ -42780,7 +42903,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));
@@ -42815,7 +42938,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) {
@@ -42842,7 +42965,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) {
@@ -42860,8 +42983,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";
@@ -42954,8 +43077,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) {
@@ -42978,7 +43101,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);
@@ -42989,7 +43112,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);
@@ -43003,7 +43126,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();
@@ -43330,7 +43453,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",
@@ -44453,7 +44576,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 {
@@ -44468,13 +44591,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++;
@@ -44504,7 +44627,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) {
@@ -44528,7 +44651,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) {
@@ -44584,7 +44707,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) {
@@ -44649,8 +44772,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);
@@ -44669,12 +44792,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));
@@ -44747,9 +44870,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`;
 }
@@ -45284,11 +45407,35 @@ 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_PATH = path32.join(process.env.XDG_CACHE_HOME || path32.join(os6.homedir(), ".cache"), "opencode", "packages", "opencode-swarm@latest");
+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 = 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 = 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)) {
     fs21.mkdirSync(dir, { recursive: true });
@@ -45309,8 +45456,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;
     }
@@ -45328,7 +45475,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);
@@ -45359,14 +45506,13 @@ async function install() {
   saveJson(OPENCODE_CONFIG_PATH, opencodeConfig);
   console.log("\u2713 Added opencode-swarm to OpenCode plugins");
   console.log("\u2713 Disabled default OpenCode agents (explore, general)");
-  try {
-    if (fs21.existsSync(OPENCODE_PLUGIN_CACHE_PATH)) {
-      fs21.rmSync(OPENCODE_PLUGIN_CACHE_PATH, { recursive: true, force: true });
-      console.log("\u2713 Cleared opencode plugin cache (next start will fetch latest)");
-    }
-  } catch {
-    console.warn("\u26A0 Could not clear opencode plugin cache \u2014 you may need to delete it manually:");
-    console.warn(`  ${OPENCODE_PLUGIN_CACHE_PATH}`);
+  const evicted = evictPluginCaches();
+  if (evicted.cleared.length > 0) {
+    console.log(`\u2713 Cleared opencode plugin cache (next start will fetch latest): ${evicted.cleared.join(", ")}`);
+  }
+  for (const failed of evicted.failed) {
+    console.warn(`\u26A0 Could not clear opencode plugin cache \u2014 you may need to delete it manually:
+  ${failed}`);
   }
   if (!fs21.existsSync(PLUGIN_CONFIG_PATH)) {
     const defaultConfig = {
@@ -45466,6 +45612,51 @@ Next steps:`);
   console.log("   \u2014 use it as a reference for customizing model assignments.");
   return 0;
 }
+async function update() {
+  console.log(`\uD83D\uDC1D Refreshing OpenCode Swarm plugin cache...
+`);
+  const result = evictPluginCaches();
+  if (result.cleared.length > 0) {
+    for (const cleared of result.cleared) {
+      console.log(`\u2713 Cleared: ${cleared}`);
+    }
+    console.log(`
+Restart OpenCode to fetch the latest version from npm.`);
+  }
+  if (result.cleared.length === 0 && result.failed.length === 0) {
+    console.log("No cached plugin found. Restart OpenCode to fetch the latest version from npm.");
+    console.log("Checked locations:");
+    for (const p of OPENCODE_PLUGIN_CACHE_PATHS) {
+      console.log(`  - ${p}`);
+    }
+  }
+  if (result.failed.length > 0) {
+    for (const failed of result.failed) {
+      console.error(`\u2717 Could not clear: ${failed}`);
+    }
+    return 1;
+  }
+  return 0;
+}
+function evictPluginCaches() {
+  const cleared = [];
+  const failed = [];
+  for (const cachePath of OPENCODE_PLUGIN_CACHE_PATHS) {
+    if (!fs21.existsSync(cachePath))
+      continue;
+    if (!isSafeCachePath(cachePath)) {
+      failed.push(`${cachePath} (refused: failed safety check)`);
+      continue;
+    }
+    try {
+      fs21.rmSync(cachePath, { recursive: true, force: true });
+      cleared.push(cachePath);
+    } catch (err) {
+      failed.push(`${cachePath} (${err instanceof Error ? err.message : String(err)})`);
+    }
+  }
+  return { cleared, failed };
+}
 async function uninstall() {
   try {
     console.log(`\uD83D\uDC1D Uninstalling OpenCode Swarm...
@@ -45536,6 +45727,7 @@ Usage: bunx opencode-swarm [command] [OPTIONS]
 
 Commands:
   install     Install and configure the plugin (default)
+  update      Refresh OpenCode's plugin cache so the next start fetches latest from npm
   uninstall   Remove the plugin from OpenCode config
   run         Run a plugin command directly (for use outside OpenCode)
 
@@ -45560,6 +45752,7 @@ Custom Prompts:
 
 Examples:
   bunx opencode-swarm install
+  bunx opencode-swarm update
   bunx opencode-swarm uninstall
   bunx opencode-swarm uninstall --clean
   bunx opencode-swarm --help
@@ -45585,6 +45778,9 @@ async function main() {
   if (command === "install") {
     const exitCode = await install();
     process.exit(exitCode);
+  } else if (command === "update") {
+    const exitCode = await update();
+    process.exit(exitCode);
   } else if (command === "uninstall") {
     const exitCode = await uninstall();
     process.exit(exitCode);