opencode-swarm 7.78.4 → 7.78.6

package/dist/cli/index.js

@@ -52,7 +52,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "opencode-swarm",
-    version: "7.78.4",
+    version: "7.78.6",
     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",
@@ -37399,26 +37399,90 @@ async function handleClarifyCommand(_directory, args) {
   return "[MODE: CLARIFY-SPEC] Please enter MODE: CLARIFY-SPEC and clarify the existing spec.";
 }
 
+// src/utils/git-binary-missing-error.ts
+function isGitBinaryMissing(err) {
+  return typeof err === "object" && err !== null && "code" in err && err.code === "ENOENT";
+}
+var GitBinaryMissingError;
+var init_git_binary_missing_error = __esm(() => {
+  GitBinaryMissingError = class GitBinaryMissingError extends Error {
+    name = "GitBinaryMissingError";
+    constructor(message = "git binary is not available", options) {
+      super(message, options);
+    }
+  };
+});
+
 // src/git/branch.ts
 import * as child_process2 from "child_process";
+import path13 from "path";
+function unique(values) {
+  return [...new Set(values.filter(Boolean))];
+}
+function windowsGitCandidates() {
+  if (process.platform !== "win32")
+    return ["git"];
+  const roots = unique([
+    process.env.ProgramFiles ?? "",
+    process.env["ProgramFiles(x86)"] ?? "",
+    process.env.LOCALAPPDATA ? path13.join(process.env.LOCALAPPDATA, "Programs") : ""
+  ]);
+  const installed = roots.flatMap((root) => [
+    path13.join(root, "Git", "cmd", "git.exe"),
+    path13.join(root, "Git", "bin", "git.exe")
+  ]);
+  return unique(["git", ...installed]);
+}
+function errorMessage(err) {
+  return err instanceof Error ? err.message : String(err);
+}
+function isNotGitRepositoryMessage(message) {
+  const lower = message.toLowerCase();
+  return lower.includes("not a git repository") || lower.includes("not a git repo");
+}
 function gitExec2(args, cwd) {
-  const result = child_process2.spawnSync("git", args, {
-    cwd,
-    encoding: "utf-8",
-    timeout: GIT_TIMEOUT_MS2,
-    stdio: ["pipe", "pipe", "pipe"]
-  });
-  if (result.status !== 0) {
-    throw new Error(result.stderr || `git exited with ${result.status}`);
+  let missingGitError;
+  for (const command of windowsGitCandidates()) {
+    const result = child_process2.spawnSync(command, args, {
+      cwd,
+      encoding: "utf-8",
+      timeout: GIT_TIMEOUT_MS2,
+      windowsHide: true,
+      maxBuffer: GIT_MAX_BUFFER_BYTES,
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    if (result.error) {
+      if (isGitBinaryMissing(result.error)) {
+        missingGitError ??= result.error;
+        continue;
+      }
+      throw new Error(errorMessage(result.error));
+    }
+    if (result.status !== 0) {
+      throw new Error(result.stderr || result.stdout || `git exited with ${result.status}`);
+    }
+    return result.stdout;
   }
-  return result.stdout;
+  throw new GitBinaryMissingError(process.platform === "win32" ? "git executable is not available on PATH or common Windows install locations" : "git executable is not available on PATH", { cause: missingGitError });
 }
-function isGitRepo2(cwd) {
+function getGitRepositoryStatus(cwd) {
   try {
     gitExec2(["rev-parse", "--git-dir"], cwd);
-    return true;
-  } catch {
-    return false;
+    return { isRepo: true };
+  } catch (err) {
+    if (err instanceof GitBinaryMissingError) {
+      return {
+        isRepo: false,
+        reason: "git_unavailable",
+        message: err.message
+      };
+    }
+    const message = errorMessage(err);
+    return {
+      isRepo: false,
+      reason: isNotGitRepositoryMessage(message) ? "not_git_repo" : "git_error",
+      message
+    };
   }
 }
 function getCurrentBranch(cwd) {
@@ -37851,13 +37915,16 @@ function resetToMainAfterMerge(cwd, options) {
     };
   }
 }
-var GIT_TIMEOUT_MS2 = 30000, _internals14;
+var GIT_TIMEOUT_MS2 = 30000, GIT_MAX_BUFFER_BYTES, _internals14;
 var init_branch = __esm(() => {
+  init_git_binary_missing_error();
   init_logger();
+  GIT_MAX_BUFFER_BYTES = 5 * 1024 * 1024;
   _internals14 = {
     gitExec: gitExec2,
     detectDefaultRemoteBranch,
     getDefaultBaseBranch,
+    getGitRepositoryStatus,
     resetToRemoteBranch,
     resetToMainAfterMerge
   };
@@ -38062,12 +38129,12 @@ var init_event_bus = __esm(() => {
 
 // src/evidence/task-file.ts
 import { renameSync as renameSync6, unlinkSync as unlinkSync4 } from "fs";
-import * as path13 from "path";
+import * as path14 from "path";
 function taskEvidenceRelPath(taskId) {
-  return path13.join("evidence", `${taskId}.json`);
+  return path14.join("evidence", `${taskId}.json`);
 }
 function taskEvidencePath(directory, taskId) {
-  return path13.join(directory, ".swarm", taskEvidenceRelPath(taskId));
+  return path14.join(directory, ".swarm", taskEvidenceRelPath(taskId));
 }
 async function atomicWriteFile(targetPath, content) {
   const tempPath = `${targetPath}.tmp.${Date.now()}.${Math.floor(Math.random() * 1e9)}`;
@@ -38093,15 +38160,15 @@ var init_task_file = __esm(() => {
 // src/hooks/knowledge-events.ts
 import { existsSync as existsSync8 } from "fs";
 import { appendFile as appendFile2, mkdir as mkdir3, readFile as readFile2, stat as stat4 } from "fs/promises";
-import * as path14 from "path";
+import * as path15 from "path";
 function resolveKnowledgeEventsPath(directory) {
-  return path14.join(directory, ".swarm", "knowledge-events.jsonl");
+  return path15.join(directory, ".swarm", "knowledge-events.jsonl");
 }
 function resolveKnowledgeCounterBaselinePath(directory) {
-  return path14.join(directory, ".swarm", "knowledge-counter-baseline.json");
+  return path15.join(directory, ".swarm", "knowledge-counter-baseline.json");
 }
 function resolveLegacyApplicationLogPath(directory) {
-  return path14.join(directory, ".swarm", "knowledge-application.jsonl");
+  return path15.join(directory, ".swarm", "knowledge-application.jsonl");
 }
 async function readKnowledgeEvents(directory) {
   const filePath = resolveKnowledgeEventsPath(directory);
@@ -38382,35 +38449,35 @@ var init_knowledge_events = __esm(() => {
 import { existsSync as existsSync9 } from "fs";
 import { appendFile as appendFile3, mkdir as mkdir4, readFile as readFile3 } from "fs/promises";
 import * as os4 from "os";
-import * as path15 from "path";
+import * as path16 from "path";
 function resolveSwarmKnowledgePath(directory) {
-  return path15.join(directory, ".swarm", "knowledge.jsonl");
+  return path16.join(directory, ".swarm", "knowledge.jsonl");
 }
 function resolveSwarmRejectedPath(directory) {
-  return path15.join(directory, ".swarm", "knowledge-rejected.jsonl");
+  return path16.join(directory, ".swarm", "knowledge-rejected.jsonl");
 }
 function resolveSwarmRetractionsPath(directory) {
-  return path15.join(directory, ".swarm", "knowledge-retractions.jsonl");
+  return path16.join(directory, ".swarm", "knowledge-retractions.jsonl");
 }
 function resolveHiveKnowledgePath() {
   const platform = process.platform;
   const home = process.env.HOME || os4.homedir();
   let dataDir;
   if (platform === "win32") {
-    dataDir = path15.join(process.env.LOCALAPPDATA || path15.join(home, "AppData", "Local"), "opencode-swarm", "Data");
+    dataDir = path16.join(process.env.LOCALAPPDATA || path16.join(home, "AppData", "Local"), "opencode-swarm", "Data");
   } else if (platform === "darwin") {
-    dataDir = path15.join(home, "Library", "Application Support", "opencode-swarm");
+    dataDir = path16.join(home, "Library", "Application Support", "opencode-swarm");
   } else {
-    dataDir = path15.join(process.env.XDG_DATA_HOME || path15.join(home, ".local", "share"), "opencode-swarm");
+    dataDir = path16.join(process.env.XDG_DATA_HOME || path16.join(home, ".local", "share"), "opencode-swarm");
   }
-  return path15.join(dataDir, "shared-learnings.jsonl");
+  return path16.join(dataDir, "shared-learnings.jsonl");
 }
 function resolveHiveRejectedPath() {
   const hivePath = resolveHiveKnowledgePath();
-  return path15.join(path15.dirname(hivePath), "shared-learnings-rejected.jsonl");
+  return path16.join(path16.dirname(hivePath), "shared-learnings-rejected.jsonl");
 }
 async function readKnowledge(filePath) {
-  const resolvedPath = path15.resolve(filePath);
+  const resolvedPath = path16.resolve(filePath);
   const entries = await readCachedParsedFile(resolvedPath, KNOWLEDGE_JSONL_CACHE_NAMESPACE, async () => {
     if (!existsSync9(resolvedPath))
       return null;
@@ -38509,7 +38576,7 @@ async function appendRetractionRecord(directory, record3) {
   await appendKnowledge(resolveSwarmRetractionsPath(directory), record3);
 }
 async function appendKnowledge(filePath, entry) {
-  const dir = path15.dirname(filePath);
+  const dir = path16.dirname(filePath);
   await mkdir4(dir, { recursive: true });
   let release = null;
   try {
@@ -38528,7 +38595,7 @@ async function appendKnowledge(filePath, entry) {
   }
 }
 async function rewriteKnowledge(filePath, entries) {
-  const dir = path15.dirname(filePath);
+  const dir = path16.dirname(filePath);
   await mkdir4(dir, { recursive: true });
   let release = null;
   try {
@@ -38549,7 +38616,7 @@ async function rewriteKnowledge(filePath, entries) {
   }
 }
 async function transactFile(filePath, read, write, mutate) {
-  const dir = path15.dirname(filePath);
+  const dir = path16.dirname(filePath);
   try {
     await mkdir4(dir, { recursive: true });
   } catch {
@@ -38741,7 +38808,7 @@ async function applyConfidenceDeltas(filePath, deltas) {
   }
   let release = null;
   try {
-    const dir = path15.dirname(filePath);
+    const dir = path16.dirname(filePath);
     await mkdir4(dir, { recursive: true });
     release = await import_proper_lockfile4.default.lock(dir, {
       retries: { retries: 5, minTimeout: 100, maxTimeout: 500 },
@@ -39202,7 +39269,7 @@ var init_learning_metrics = __esm(() => {
 
 // src/hooks/knowledge-validator.ts
 import { appendFile as appendFile4, mkdir as mkdir5 } from "fs/promises";
-import * as path16 from "path";
+import * as path17 from "path";
 function normalizeText(text) {
   return text.normalize("NFKC").toLowerCase().replace(/[^\w\s]/g, " ").replace(/\s+/g, " ").trim();
 }
@@ -39365,7 +39432,7 @@ function validateSkillPath(p) {
     return false;
   if (p.includes("\x00"))
     return false;
-  if (path16.isAbsolute(p))
+  if (path17.isAbsolute(p))
     return false;
   if (p.includes(".."))
     return false;
@@ -39467,11 +39534,11 @@ function validateActionability(entry) {
   return { actionable: false, reason };
 }
 function resolveUnactionablePath(directory) {
-  return path16.join(directory, ".swarm", "knowledge-unactionable.jsonl");
+  return path17.join(directory, ".swarm", "knowledge-unactionable.jsonl");
 }
 async function appendUnactionable(directory, entry, reason) {
   const filePath = resolveUnactionablePath(directory);
-  const dirPath = path16.dirname(filePath);
+  const dirPath = path17.dirname(filePath);
   await mkdir5(dirPath, { recursive: true });
   await transactKnowledge(filePath, (existing) => {
     const record3 = {
@@ -39505,10 +39572,10 @@ async function quarantineEntry(directory, entryId, reason, reportedBy) {
     return;
   }
   const sanitizedReason = reason.slice(0, 500).replace(/[\x00-\x08\x0b-\x0c\x0e-\x1f\x7f\x0d]/g, "");
-  const knowledgePath = path16.join(directory, ".swarm", "knowledge.jsonl");
-  const quarantinePath = path16.join(directory, ".swarm", "knowledge-quarantined.jsonl");
-  const rejectedPath = path16.join(directory, ".swarm", "knowledge-rejected.jsonl");
-  const swarmDir = path16.join(directory, ".swarm");
+  const knowledgePath = path17.join(directory, ".swarm", "knowledge.jsonl");
+  const quarantinePath = path17.join(directory, ".swarm", "knowledge-quarantined.jsonl");
+  const rejectedPath = path17.join(directory, ".swarm", "knowledge-rejected.jsonl");
+  const swarmDir = path17.join(directory, ".swarm");
   await mkdir5(swarmDir, { recursive: true });
   let release;
   try {
@@ -39569,10 +39636,10 @@ async function restoreEntry(directory, entryId) {
     warn("[knowledge-validator] restoreEntry: invalid entryId rejected");
     return;
   }
-  const knowledgePath = path16.join(directory, ".swarm", "knowledge.jsonl");
-  const quarantinePath = path16.join(directory, ".swarm", "knowledge-quarantined.jsonl");
-  const rejectedPath = path16.join(directory, ".swarm", "knowledge-rejected.jsonl");
-  const swarmDir = path16.join(directory, ".swarm");
+  const knowledgePath = path17.join(directory, ".swarm", "knowledge.jsonl");
+  const quarantinePath = path17.join(directory, ".swarm", "knowledge-quarantined.jsonl");
+  const rejectedPath = path17.join(directory, ".swarm", "knowledge-rejected.jsonl");
+  const swarmDir = path17.join(directory, ".swarm");
   await mkdir5(swarmDir, { recursive: true });
   let release;
   try {
@@ -39752,16 +39819,16 @@ var init_knowledge_validator = __esm(() => {
 
 // src/services/skill-changelog.ts
 import { appendFile as appendFile5, mkdir as mkdir6, readFile as readFile4, writeFile as writeFile3 } from "fs/promises";
-import * as path17 from "path";
+import * as path18 from "path";
 function resolveSkillChangelogPath(directory, slug) {
   if (slug.includes("..") || slug.includes("/") || slug.includes("\\")) {
     throw new Error(`Invalid skill slug: ${slug} \u2014 must not contain "..", "/" or "\\"`);
   }
-  return path17.join(directory, ".swarm", "skill-changelogs", `${slug}.jsonl`);
+  return path18.join(directory, ".swarm", "skill-changelogs", `${slug}.jsonl`);
 }
 async function appendSkillChangelog(directory, slug, entry) {
   const filePath = resolveSkillChangelogPath(directory, slug);
-  const dirPath = path17.dirname(filePath);
+  const dirPath = path18.dirname(filePath);
   await mkdir6(dirPath, { recursive: true });
   await appendFile5(filePath, `${JSON.stringify(entry)}
 `, "utf-8");
@@ -39797,7 +39864,7 @@ import {
   stat as stat5,
   writeFile as writeFile4
 } from "fs/promises";
-import * as path18 from "path";
+import * as path19 from "path";
 function isValidSlug(slug) {
   return SLUG_PATTERN.test(slug);
 }
@@ -39855,15 +39922,15 @@ function casesFromParsedJson(parsed, fileLabel) {
   return cases;
 }
 function evalRoot(directory, slug) {
-  return path18.join(directory, ".swarm", "skills", "evals", slug);
+  return path19.join(directory, ".swarm", "skills", "evals", slug);
 }
 function isInsidePath(root, target) {
-  const resolvedRoot = path18.resolve(root);
-  const resolvedTarget = path18.resolve(target);
-  return resolvedTarget === resolvedRoot || resolvedTarget.startsWith(resolvedRoot + path18.sep);
+  const resolvedRoot = path19.resolve(root);
+  const resolvedTarget = path19.resolve(target);
+  return resolvedTarget === resolvedRoot || resolvedTarget.startsWith(resolvedRoot + path19.sep);
 }
 function rejectedEditsPath(directory) {
-  return path18.join(directory, ".swarm", "skills", "rejected-edits.jsonl");
+  return path19.join(directory, ".swarm", "skills", "rejected-edits.jsonl");
 }
 async function loadEvalSet(directory, slug) {
   if (!isValidSlug(slug)) {
@@ -39916,9 +39983,9 @@ async function loadEvalSet(directory, slug) {
   const cases = [];
   const fileLabels = [];
   for (const file3 of files) {
-    const fullPath = path18.join(root, file3);
-    const resolved = path18.resolve(fullPath);
-    const resolvedRoot = path18.resolve(root);
+    const fullPath = path19.join(root, file3);
+    const resolved = path19.resolve(fullPath);
+    const resolvedRoot = path19.resolve(root);
     if (!isInsidePath(resolvedRoot, resolved)) {
       return {
         status: "invalid",
@@ -39977,7 +40044,7 @@ async function loadEvalSet(directory, slug) {
         reason: `eval file invalid JSON: ${file3}: ${err instanceof Error ? err.message : String(err)}`
       };
     }
-    fileLabels.push(path18.relative(directory, fullPath).replace(/\\/g, "/"));
+    fileLabels.push(path19.relative(directory, fullPath).replace(/\\/g, "/"));
     cases.push(...casesFromParsedJson(parsed, file3));
     if (cases.length >= MAX_EVAL_CASES)
       break;
@@ -40095,7 +40162,7 @@ async function evaluateSkillChange(req) {
   };
 }
 async function atomicWrite(filePath, content) {
-  await mkdir7(path18.dirname(filePath), { recursive: true });
+  await mkdir7(path19.dirname(filePath), { recursive: true });
   const tmp = `${filePath}.tmp-${process.pid}-${Date.now()}`;
   await writeFile4(tmp, content, "utf-8");
   await rename3(tmp, filePath);
@@ -40168,7 +40235,7 @@ var init_skill_evaluator = __esm(() => {
 // src/services/skill-generator.ts
 import { existsSync as existsSync11, unlinkSync as unlinkSync5 } from "fs";
 import { mkdir as mkdir8, readFile as readFile6, rename as rename4, writeFile as writeFile5 } from "fs/promises";
-import * as path19 from "path";
+import * as path20 from "path";
 function sanitizeSlug(input) {
   const lc = input.toLowerCase().trim();
   const mapped = lc.replace(/[^a-z0-9-]+/g, "-").replace(/-+/g, "-");
@@ -40179,10 +40246,10 @@ function isValidSlug2(slug) {
   return SLUG_PATTERN2.test(slug);
 }
 function proposalPath(directory, slug) {
-  return path19.join(directory, ".swarm", "skills", "proposals", `${slug}.md`);
+  return path20.join(directory, ".swarm", "skills", "proposals", `${slug}.md`);
 }
 function activePath(directory, slug) {
-  return path19.join(directory, ".opencode", "skills", "generated", slug, "SKILL.md");
+  return path20.join(directory, ".opencode", "skills", "generated", slug, "SKILL.md");
 }
 function activeRepoRelativePath(slug) {
   return `.opencode/skills/generated/${slug}/SKILL.md`;
@@ -40397,7 +40464,7 @@ function escapeMarkdown(s) {
   return s.replace(/[\r\n]+/g, " ").slice(0, 280);
 }
 async function atomicWrite2(p, content) {
-  await mkdir8(path19.dirname(p), { recursive: true });
+  await mkdir8(path20.dirname(p), { recursive: true });
   const tmp = `${p}.tmp-${process.pid}-${Date.now()}`;
   await writeFile5(tmp, content, "utf-8");
   await rename4(tmp, p);
@@ -40442,7 +40509,7 @@ async function generateSkills(req) {
       continue;
     }
     const targetPath = req.mode === "active" ? activePath(req.directory, cluster.slug) : proposalPath(req.directory, cluster.slug);
-    const repoRel = path19.relative(req.directory, targetPath).replace(/\\/g, "/");
+    const repoRel = path20.relative(req.directory, targetPath).replace(/\\/g, "/");
     if (!validateSkillPath(repoRel)) {
       result.skipped.push({
         slug: cluster.slug,
@@ -40777,8 +40844,8 @@ async function listSkills(directory) {
     proposals: [],
     active: []
   };
-  const proposalsDir = path19.join(directory, ".swarm", "skills", "proposals");
-  const activeDir = path19.join(directory, ".opencode", "skills", "generated");
+  const proposalsDir = path20.join(directory, ".swarm", "skills", "proposals");
+  const activeDir = path20.join(directory, ".opencode", "skills", "generated");
   const fs10 = await import("fs/promises");
   if (existsSync11(proposalsDir)) {
     const entries = await fs10.readdir(proposalsDir);
@@ -40788,7 +40855,7 @@ async function listSkills(directory) {
       const slug = f.replace(/\.md$/, "");
       result.proposals.push({
         slug,
-        path: path19.join(proposalsDir, f)
+        path: path20.join(proposalsDir, f)
       });
     }
   }
@@ -40797,10 +40864,10 @@ async function listSkills(directory) {
     for (const e of entries) {
       if (!e.isDirectory())
         continue;
-      const retiredMarker = path19.join(activeDir, e.name, "retired.marker");
+      const retiredMarker = path20.join(activeDir, e.name, "retired.marker");
       if (existsSync11(retiredMarker))
         continue;
-      const skillPath = path19.join(activeDir, e.name, "SKILL.md");
+      const skillPath = path20.join(activeDir, e.name, "SKILL.md");
       if (existsSync11(skillPath)) {
         result.active.push({
           slug: e.name,
@@ -40896,7 +40963,7 @@ async function retireSkill(directory, slug, reason) {
     return {
       retired: false,
       path: activePath(directory, cleanSlug),
-      markerPath: path19.join(directory, ".opencode", "skills", "generated", cleanSlug, "retired.marker"),
+      markerPath: path20.join(directory, ".opencode", "skills", "generated", cleanSlug, "retired.marker"),
       reason: "invalid slug"
     };
   }
@@ -40905,12 +40972,12 @@ async function retireSkill(directory, slug, reason) {
     return {
       retired: false,
       path: skillPath,
-      markerPath: path19.join(directory, ".opencode", "skills", "generated", cleanSlug, "retired.marker"),
+      markerPath: path20.join(directory, ".opencode", "skills", "generated", cleanSlug, "retired.marker"),
       reason: "active skill not found"
     };
   }
-  const markerDir = path19.join(directory, ".opencode", "skills", "generated", cleanSlug);
-  const markerPath = path19.join(markerDir, "retired.marker");
+  const markerDir = path20.join(directory, ".opencode", "skills", "generated", cleanSlug);
+  const markerPath = path20.join(markerDir, "retired.marker");
   const markerContent = JSON.stringify({
     retiredAt: new Date().toISOString(),
     reason: reason ?? "manual_retire"
@@ -41139,7 +41206,7 @@ var init_skill_generator = __esm(() => {
 // src/services/skill-improver-quota.ts
 import { existsSync as existsSync12 } from "fs";
 import { mkdir as mkdir9, readFile as readFile7, rename as rename5, writeFile as writeFile6 } from "fs/promises";
-import * as path20 from "path";
+import * as path21 from "path";
 async function acquireLock(dir) {
   const acquire = import_proper_lockfile6.default.lock(dir, LOCK_RETRY_OPTS);
   let timer;
@@ -41158,7 +41225,7 @@ async function acquireLock(dir) {
 }
 function resolveQuotaPath(directory, scope = "skill-improver") {
   const fileName = scope === "knowledge-enrichment" ? "knowledge-enrichment-quota.json" : "skill-improver-quota.json";
-  return path20.join(directory, ".swarm", fileName);
+  return path21.join(directory, ".swarm", fileName);
 }
 function todayKey(window, now = new Date) {
   if (window === "utc") {
@@ -41184,7 +41251,7 @@ async function readState(filePath) {
   }
 }
 async function writeState(filePath, state) {
-  await mkdir9(path20.dirname(filePath), { recursive: true });
+  await mkdir9(path21.dirname(filePath), { recursive: true });
   const tmp = `${filePath}.tmp-${process.pid}`;
   await writeFile6(tmp, JSON.stringify(state, null, 2), "utf-8");
   await rename5(tmp, filePath);
@@ -41207,10 +41274,10 @@ async function getQuotaState(directory, opts) {
 }
 async function reserveQuota(directory, opts) {
   const filePath = resolveQuotaPath(directory, opts.scope);
-  await mkdir9(path20.dirname(filePath), { recursive: true });
+  await mkdir9(path21.dirname(filePath), { recursive: true });
   let release = null;
   try {
-    release = await acquireLock(path20.dirname(filePath));
+    release = await acquireLock(path21.dirname(filePath));
     const state = await getQuotaState(directory, opts);
     if (state.calls_used + opts.nCalls > opts.maxCalls) {
       return {
@@ -41237,10 +41304,10 @@ async function reserveQuota(directory, opts) {
 }
 async function releaseQuota(directory, opts) {
   const filePath = resolveQuotaPath(directory, opts.scope);
-  await mkdir9(path20.dirname(filePath), { recursive: true });
+  await mkdir9(path21.dirname(filePath), { recursive: true });
   let release = null;
   try {
-    release = await acquireLock(path20.dirname(filePath));
+    release = await acquireLock(path21.dirname(filePath));
     const state = await getQuotaState(directory, opts);
     const next = {
       ...state,
@@ -41282,7 +41349,7 @@ var init_skill_reviser = __esm(() => {
 // src/hooks/skill-usage-log.ts
 import * as crypto3 from "crypto";
 import * as fs10 from "fs";
-import * as path21 from "path";
+import * as path22 from "path";
 function resolveLogPath(directory) {
   return validateSwarmPath(directory, "skill-usage.jsonl");
 }
@@ -41360,7 +41427,7 @@ function appendFeedbackAppliedMarker(directory, processedEntryIds) {
   if (processedEntryIds.length === 0)
     return;
   const resolved = resolveLogPath(directory);
-  const dir = path21.dirname(resolved);
+  const dir = path22.dirname(resolved);
   if (!_internals17.existsSync(dir)) {
     _internals17.mkdirSync(dir, { recursive: true });
   }
@@ -41405,7 +41472,7 @@ function appendSkillUsageEntry(directory, entry) {
     throw new Error("sessionID is required and must be a non-empty string");
   }
   const resolved = validateSwarmPath(directory, "skill-usage.jsonl");
-  const dir = path21.dirname(resolved);
+  const dir = path22.dirname(resolved);
   if (!_internals17.existsSync(dir)) {
     _internals17.mkdirSync(dir, { recursive: true });
   }
@@ -41580,8 +41647,8 @@ function pruneSkillUsageLog(directory, maxEntriesPerSkill = 500) {
   if (pruned === 0) {
     return { pruned: 0, remaining: allEntries.length };
   }
-  const dir = path21.dirname(resolved);
-  const tmpPath = path21.join(dir, `skill-usage-${Date.now()}.tmp`);
+  const dir = path22.dirname(resolved);
+  const tmpPath = path22.join(dir, `skill-usage-${Date.now()}.tmp`);
   const content = surviving.map((e) => JSON.stringify(e)).join(`
 `).concat(`
 `);
@@ -41608,9 +41675,9 @@ async function resolveSourceKnowledgeIds(directory, skillPath) {
     if (/\.\.[/\\]/.test(cleanPath)) {
       return [];
     }
-    const absolute = path21.normalize(path21.isAbsolute(cleanPath) ? cleanPath : path21.resolve(directory, cleanPath));
-    const baseDir = path21.normalize(path21.resolve(directory));
-    const isContained = process.platform === "win32" ? absolute.toLowerCase().startsWith((baseDir + path21.sep).toLowerCase()) : absolute.startsWith(baseDir + path21.sep);
+    const absolute = path22.normalize(path22.isAbsolute(cleanPath) ? cleanPath : path22.resolve(directory, cleanPath));
+    const baseDir = path22.normalize(path22.resolve(directory));
+    const isContained = process.platform === "win32" ? absolute.toLowerCase().startsWith((baseDir + path22.sep).toLowerCase()) : absolute.startsWith(baseDir + path22.sep);
     if (!isContained) {
       return [];
     }
@@ -41765,7 +41832,7 @@ var init_curator = __esm(() => {
 });
 
 // src/hooks/hive-promoter.ts
-import path22 from "path";
+import path23 from "path";
 function carryActionableFields(source) {
   const out = {};
   if (source.triggers?.length)
@@ -41967,7 +42034,7 @@ async function promoteToHive(directory, lesson, category) {
     schema_version: 1,
     created_at: new Date().toISOString(),
     updated_at: new Date().toISOString(),
-    source_project: path22.basename(directory) || "unknown",
+    source_project: path23.basename(directory) || "unknown",
     encounter_score: 1
   };
   await appendKnowledge(resolveHiveKnowledgePath(), newHiveEntry);
@@ -42032,7 +42099,7 @@ import {
   unlink as unlink2,
   writeFile as writeFile7
 } from "fs/promises";
-import * as path23 from "path";
+import * as path24 from "path";
 function emptySynonymMap() {
   return { version: 1, cursor: 0, pairs: {} };
 }
@@ -42181,7 +42248,7 @@ async function readSynonymMap(directory, maxPairs = DEFAULT_MAX_PAIRS) {
   }
 }
 async function writeSynonymMapAtomic(filePath, map3) {
-  await mkdir10(path23.dirname(filePath), { recursive: true });
+  await mkdir10(path24.dirname(filePath), { recursive: true });
   const tmp = `${filePath}.tmp.${Date.now()}.${Math.floor(Math.random() * 1e9)}`;
   try {
     await writeFile7(tmp, JSON.stringify(map3, null, 2), "utf-8");
@@ -42194,7 +42261,7 @@ async function writeSynonymMapAtomic(filePath, map3) {
 }
 async function rebuildSynonymMap(directory, entries, maxPairs = DEFAULT_MAX_PAIRS) {
   const filePath = resolveSynonymMapPath(directory);
-  const dir = path23.dirname(filePath);
+  const dir = path24.dirname(filePath);
   await mkdir10(dir, { recursive: true });
   let release = null;
   try {
@@ -42266,12 +42333,12 @@ var init_knowledge_reinforcement = __esm(() => {
 
 // src/hooks/skill-scoring.ts
 import * as fs11 from "fs";
-import * as path24 from "path";
+import * as path25 from "path";
 function extractSkillName(skillPath) {
-  const base = path24.basename(skillPath, path24.extname(skillPath));
+  const base = path25.basename(skillPath, path25.extname(skillPath));
   if (base !== "SKILL")
     return base;
-  const parent = path24.basename(path24.dirname(skillPath));
+  const parent = path25.basename(path25.dirname(skillPath));
   return parent;
 }
 function stripQuotes(value) {
@@ -42426,12 +42493,12 @@ function readSkillMetadata(skillPath, directory) {
   const normalizedPath = skillPath.replace(/^file:/, "").replace(/\\/g, "/");
   const fallback = parseSkillFrontmatter("", normalizedPath);
   try {
-    if (path24.isAbsolute(normalizedPath) || normalizedPath.split("/").includes("..")) {
+    if (path25.isAbsolute(normalizedPath) || normalizedPath.split("/").includes("..")) {
       return fallback;
     }
-    const root = path24.resolve(directory);
-    const absolutePath = path24.resolve(directory, normalizedPath);
-    if (absolutePath !== root && !absolutePath.startsWith(root + path24.sep)) {
+    const root = path25.resolve(directory);
+    const absolutePath = path25.resolve(directory, normalizedPath);
+    if (absolutePath !== root && !absolutePath.startsWith(root + path25.sep)) {
       return fallback;
     }
     const content = readFilePrefix(absolutePath);
@@ -42564,7 +42631,7 @@ function getSkillStats(skillPath, directory) {
   };
 }
 function formatSkillIndexWithContext(skills, directory) {
-  const usageLogPath = path24.join(directory, ".swarm", "skill-usage.jsonl");
+  const usageLogPath = path25.join(directory, ".swarm", "skill-usage.jsonl");
   let hasHistory = false;
   try {
     const stat7 = fs11.statSync(usageLogPath);
@@ -42619,7 +42686,7 @@ var init_skill_scoring = __esm(() => {
 
 // src/hooks/skill-propagation-gate.ts
 import * as fs12 from "fs";
-import * as path25 from "path";
+import * as path26 from "path";
 function parseSimpleYaml(content) {
   const lines = content.split(`
 `);
@@ -42718,7 +42785,7 @@ function parseYamlValue(value) {
   return trimmed;
 }
 function loadRoutingSkills(directory, targetAgent) {
-  const routingPath = path25.join(directory, ".opencode", "skill-routing.yaml");
+  const routingPath = path26.join(directory, ".opencode", "skill-routing.yaml");
   if (!_internals19.existsSync(routingPath))
     return [];
   try {
@@ -42738,7 +42805,7 @@ function loadRoutingSkills(directory, targetAgent) {
 function discoverAvailableSkills(directory) {
   const results = [];
   for (const root of SKILL_SEARCH_ROOTS) {
-    const rootPath = path25.join(directory, root);
+    const rootPath = path26.join(directory, root);
     if (!_internals19.existsSync(rootPath))
       continue;
     let entries;
@@ -42750,13 +42817,13 @@ function discoverAvailableSkills(directory) {
     for (const entry of entries) {
       if (entry.startsWith("."))
         continue;
-      const skillDir = path25.join(rootPath, entry);
-      if (_internals19.existsSync(path25.join(skillDir, "retired.marker")))
+      const skillDir = path26.join(rootPath, entry);
+      if (_internals19.existsSync(path26.join(skillDir, "retired.marker")))
         continue;
-      const skillFile = path25.join(skillDir, "SKILL.md");
+      const skillFile = path26.join(skillDir, "SKILL.md");
       try {
         if (_internals19.statSync(skillDir).isDirectory() && _internals19.existsSync(skillFile)) {
-          results.push(path25.join(root, entry, "SKILL.md").replace(/\\/g, "/"));
+          results.push(path26.join(root, entry, "SKILL.md").replace(/\\/g, "/"));
         }
       } catch (err) {
         warn(`[skill-propagation-gate] failed to stat skill directory ${entry}: ${err instanceof Error ? err.message : String(err)}`);
@@ -42825,9 +42892,9 @@ function extractSkillsFieldFromPrompt(prompt) {
   return "";
 }
 function writeWarnEvent(directory, record3) {
-  const filePath = path25.join(directory, ".swarm", "events.jsonl");
+  const filePath = path26.join(directory, ".swarm", "events.jsonl");
   try {
-    const dir = path25.dirname(filePath);
+    const dir = path26.dirname(filePath);
     if (!_internals19.existsSync(dir)) {
       _internals19.mkdirSync(dir, { recursive: true });
     }
@@ -42956,8 +43023,8 @@ async function skillPropagationGateBefore(directory, input, config3) {
     if (routingPaths.length > 0) {
       const existingPaths = new Set(scored.map((s) => s.skillPath));
       for (const routingPath of routingPaths) {
-        const routedSkillDir = path25.dirname(path25.join(directory, routingPath));
-        if (_internals19.existsSync(path25.join(routedSkillDir, "retired.marker")))
+        const routedSkillDir = path26.dirname(path26.join(directory, routingPath));
+        if (_internals19.existsSync(path26.join(routedSkillDir, "retired.marker")))
           continue;
         if (!existingPaths.has(routingPath)) {
           scored.push({
@@ -42976,8 +43043,8 @@ async function skillPropagationGateBefore(directory, input, config3) {
       let skillsForIndex = availableSkills;
       if (scoringSkipped) {
         skillsForIndex = [...availableSkills].sort((a, b) => {
-          const nameA = path25.basename(path25.dirname(a));
-          const nameB = path25.basename(path25.dirname(b));
+          const nameA = path26.basename(path26.dirname(a));
+          const nameB = path26.basename(path26.dirname(b));
           return nameA.localeCompare(nameB);
         });
       } else if (typeof scored !== "undefined" && scored.length > 0) {
@@ -42985,7 +43052,7 @@ async function skillPropagationGateBefore(directory, input, config3) {
       }
       const formattedIndex = _internals19.formatSkillIndexWithContext(skillsForIndex, directory);
       if (formattedIndex.length > 0) {
-        const contextPath = path25.join(directory, ".swarm", "context.md");
+        const contextPath = path26.join(directory, ".swarm", "context.md");
         let existingContent = "";
         if (_internals19.existsSync(contextPath)) {
           existingContent = _internals19.readFileSync(contextPath, "utf-8");
@@ -43007,7 +43074,7 @@ ${newSection}`;
             updatedContent = existingContent + newSection;
           }
         }
-        const swarmDir = path25.dirname(contextPath);
+        const swarmDir = path26.dirname(contextPath);
         if (!_internals19.existsSync(swarmDir)) {
           _internals19.mkdirSync(swarmDir, { recursive: true });
         }
@@ -43270,13 +43337,13 @@ var init_skill_propagation_gate = __esm(() => {
 // src/hooks/micro-reflector.ts
 import { existsSync as existsSync15 } from "fs";
 import { readFile as readFile9, writeFile as writeFile8 } from "fs/promises";
-import * as path26 from "path";
+import * as path27 from "path";
 function resolveInsightCandidatesPath(directory) {
   return validateSwarmPath(directory, "insight-candidates.jsonl");
 }
 async function readTaskTrajectory(directory, taskId) {
   try {
-    const rel = path26.join("evidence", sanitizeTaskId2(taskId), "trajectory.jsonl");
+    const rel = path27.join("evidence", sanitizeTaskId2(taskId), "trajectory.jsonl");
     const filePath = validateSwarmPath(directory, rel);
     if (!existsSync15(filePath))
       return [];
@@ -43317,7 +43384,7 @@ var init_micro_reflector = __esm(() => {
 // src/hooks/knowledge-curator.ts
 import { existsSync as existsSync16 } from "fs";
 import { appendFile as appendFile6, mkdir as mkdir11, readFile as readFile10, writeFile as writeFile9 } from "fs/promises";
-import * as path27 from "path";
+import * as path28 from "path";
 function pruneSeenRetroSections() {
   const cutoff = Date.now() - 86400000;
   for (const [key, entry] of seenRetroSections) {
@@ -43577,8 +43644,8 @@ RETRY: your last output was missing ${result.missing.join("; ")}; produce valid
 }
 async function appendCuratorSkippedEvent(directory, record3) {
   try {
-    const filePath = path27.join(directory, ".swarm", "events.jsonl");
-    await mkdir11(path27.dirname(filePath), { recursive: true });
+    const filePath = path28.join(directory, ".swarm", "events.jsonl");
+    await mkdir11(path28.dirname(filePath), { recursive: true });
     await appendFile6(filePath, `${JSON.stringify({
       timestamp: new Date().toISOString(),
       event: "curator_skipped",
@@ -44136,7 +44203,7 @@ var init_skill_improver_llm_factory = __esm(() => {
 
 // src/services/trajectory-cluster.ts
 import { mkdir as mkdir12, writeFile as writeFile10 } from "fs/promises";
-import * as path28 from "path";
+import * as path29 from "path";
 function failureKind(e) {
   const tool3 = (e.tool ?? "").toLowerCase();
   const ctx = `${e.action ?? ""} ${e.verdict ?? ""}`.toLowerCase();
@@ -44265,11 +44332,11 @@ async function writeMotifProposals(directory, opts = {}) {
     if (motifs.length === 0)
       return result;
     const max = opts.maxProposals ?? 10;
-    const proposalsDir = validateSwarmPath(directory, path28.join("skills", "proposals"));
+    const proposalsDir = validateSwarmPath(directory, path29.join("skills", "proposals"));
     await mkdir12(proposalsDir, { recursive: true });
     for (const motif of motifs.slice(0, max)) {
       const slug = `motif-${slugify2(motif.signature)}`;
-      const filePath = path28.join(proposalsDir, `${slug}.md`);
+      const filePath = path29.join(proposalsDir, `${slug}.md`);
       await writeFile10(filePath, buildMotifProposal(motif), "utf-8");
       result.proposalsWritten.push(filePath);
     }
@@ -44409,11 +44476,11 @@ async function writeSuccessMotifProposals(directory, opts = {}) {
     if (motifs.length === 0)
       return result;
     const max = opts.maxProposals ?? 10;
-    const proposalsDir = validateSwarmPath(directory, path28.join("skills", "proposals"));
+    const proposalsDir = validateSwarmPath(directory, path29.join("skills", "proposals"));
     await mkdir12(proposalsDir, { recursive: true });
     for (const motif of motifs.slice(0, max)) {
       const slug = workflowSlug(motif.signature);
-      const filePath = path28.join(proposalsDir, `${slug}.md`);
+      const filePath = path29.join(proposalsDir, `${slug}.md`);
       await writeFile10(filePath, buildWorkflowProposal(motif), "utf-8");
       result.proposalsWritten.push(filePath);
     }
@@ -44546,12 +44613,12 @@ var init_unactionable_hardening = __esm(() => {
 // src/services/skill-improver.ts
 import { existsSync as existsSync18 } from "fs";
 import { mkdir as mkdir13, readFile as readFile11, rename as rename7, writeFile as writeFile11 } from "fs/promises";
-import * as path29 from "path";
+import * as path30 from "path";
 function timestampSlug(d) {
   return d.toISOString().replace(/[:.]/g, "-");
 }
 async function atomicWrite3(p, content) {
-  await mkdir13(path29.dirname(p), { recursive: true });
+  await mkdir13(path30.dirname(p), { recursive: true });
   const tmp = `${p}.tmp-${process.pid}-${Date.now()}`;
   await writeFile11(tmp, content, "utf-8");
   await rename7(tmp, p);
@@ -44894,8 +44961,8 @@ async function runSkillImprover(req) {
     }
     throw err;
   }
-  const proposalDir = path29.join(req.directory, ".swarm", "skill-improver", "proposals");
-  const proposalFile = path29.join(proposalDir, `${timestampSlug(now)}.md`);
+  const proposalDir = path30.join(req.directory, ".swarm", "skill-improver", "proposals");
+  const proposalFile = path30.join(proposalDir, `${timestampSlug(now)}.md`);
   const finalBody = source === "llm" ? buildLLMProposalFrame({
     body,
     targets,
@@ -45327,7 +45394,7 @@ __export(exports_curator_postmortem, {
   _internals: () => _internals22
 });
 import { existsSync as existsSync19, readdirSync as readdirSync6, readFileSync as readFileSync9 } from "fs";
-import * as path30 from "path";
+import * as path31 from "path";
 async function collectKnowledgeSummary(directory) {
   const entries = await readKnowledge(resolveSwarmKnowledgePath(directory));
   const events = await readKnowledgeEvents(directory);
@@ -45385,13 +45452,13 @@ function readJsonlFile(filePath) {
 }
 function collectRetrospectives(directory) {
   const results = [];
-  const evidenceDir = path30.join(directory, ".swarm", "evidence");
+  const evidenceDir = path31.join(directory, ".swarm", "evidence");
   try {
     if (!existsSync19(evidenceDir))
       return results;
     for (const entry of readdirSync6(evidenceDir, { withFileTypes: true })) {
       if (entry.isDirectory() && entry.name.startsWith("retro-")) {
-        const retroPath = path30.join(evidenceDir, entry.name, "evidence.json");
+        const retroPath = path31.join(evidenceDir, entry.name, "evidence.json");
         if (existsSync19(retroPath)) {
           try {
             results.push(readFileSync9(retroPath, "utf-8"));
@@ -45404,14 +45471,14 @@ function collectRetrospectives(directory) {
 }
 function collectDriftReports(directory) {
   const results = [];
-  const swarmDir = path30.join(directory, ".swarm");
+  const swarmDir = path31.join(directory, ".swarm");
   try {
     if (!existsSync19(swarmDir))
       return results;
     for (const entry of readdirSync6(swarmDir)) {
       if (entry.startsWith("drift-report-phase-") && entry.endsWith(".json")) {
         try {
-          results.push(readFileSync9(path30.join(swarmDir, entry), "utf-8"));
+          results.push(readFileSync9(path31.join(swarmDir, entry), "utf-8"));
         } catch {}
       }
     }
@@ -45420,7 +45487,7 @@ function collectDriftReports(directory) {
 }
 function collectPendingProposals(directory) {
   const results = [];
-  const insightPath = path30.join(directory, ".swarm", "insight-candidates.jsonl");
+  const insightPath = path31.join(directory, ".swarm", "insight-candidates.jsonl");
   if (existsSync19(insightPath)) {
     try {
       results.push({
@@ -45429,7 +45496,7 @@ function collectPendingProposals(directory) {
       });
     } catch {}
   }
-  const proposalsDir = path30.join(directory, ".swarm", "skills", "proposals");
+  const proposalsDir = path31.join(directory, ".swarm", "skills", "proposals");
   try {
     if (existsSync19(proposalsDir)) {
       for (const entry of readdirSync6(proposalsDir)) {
@@ -45437,7 +45504,7 @@ function collectPendingProposals(directory) {
           try {
             results.push({
               source: `proposals/${entry}`,
-              content: readFileSync9(path30.join(proposalsDir, entry), "utf-8")
+              content: readFileSync9(path31.join(proposalsDir, entry), "utf-8")
             });
           } catch {}
         }
@@ -45612,7 +45679,7 @@ async function runCuratorPostMortem(directory, options = {}) {
     warnings.push("Failed to read curator digest.");
   }
   const proposals = collectPendingProposals(directory);
-  const unactionablePath = path30.join(directory, ".swarm", "knowledge-unactionable.jsonl");
+  const unactionablePath = path31.join(directory, ".swarm", "knowledge-unactionable.jsonl");
   const unactionable = readJsonlFile(unactionablePath);
   const retrospectives = collectRetrospectives(directory);
   const driftReports = collectDriftReports(directory);
@@ -45650,7 +45717,7 @@ ${llmOutput}`;
   }
   try {
     const { mkdirSync: mkdirSync10, writeFileSync: writeFileSync7 } = await import("fs");
-    mkdirSync10(path30.dirname(reportPath), { recursive: true });
+    mkdirSync10(path31.dirname(reportPath), { recursive: true });
     writeFileSync7(reportPath, reportContent, "utf-8");
   } catch (err) {
     const msg = err instanceof Error ? err.message : String(err);
@@ -45698,7 +45765,7 @@ var init_curator_postmortem = __esm(() => {
 // src/commands/close.ts
 import * as fsSync2 from "fs";
 import { promises as fs13 } from "fs";
-import path31 from "path";
+import path32 from "path";
 async function runAbortableSkillReview(req, timeoutMs) {
   const controller = new AbortController;
   let timeout;
@@ -45737,8 +45804,8 @@ async function copyDirRecursive(src, dest) {
   const entries = await fs13.readdir(src);
   await fs13.mkdir(dest, { recursive: true });
   for (const entry of entries) {
-    const srcEntry = path31.join(src, entry);
-    const destEntry = path31.join(dest, entry);
+    const srcEntry = path32.join(src, entry);
+    const destEntry = path32.join(dest, entry);
     try {
       const stat7 = await fs13.stat(srcEntry);
       if (stat7.isDirectory()) {
@@ -45775,7 +45842,7 @@ function guaranteeAllPlansComplete(planData) {
   return { closedPhaseIds, closedTaskIds };
 }
 async function handleCloseCommand(directory, args, options = {}) {
-  const swarmDir = path31.join(directory, ".swarm");
+  const swarmDir = path32.join(directory, ".swarm");
   try {
     const stat7 = fsSync2.lstatSync(swarmDir);
     if (stat7.isSymbolicLink()) {
@@ -45789,7 +45856,7 @@ async function handleCloseCommand(directory, args, options = {}) {
   const planPath = validateSwarmPath(directory, "plan.json");
   let planExists = false;
   let planData = {
-    title: path31.basename(directory) || "Ad-hoc session",
+    title: path32.basename(directory) || "Ad-hoc session",
     phases: []
   };
   try {
@@ -45898,7 +45965,7 @@ async function handleCloseCommand(directory, args, options = {}) {
       warnings.push(`Session retrospective write threw: ${retroError instanceof Error ? retroError.message : String(retroError)}`);
     }
   }
-  const lessonsFilePath = path31.join(swarmDir, "close-lessons.md");
+  const lessonsFilePath = path32.join(swarmDir, "close-lessons.md");
   let explicitLessons = [];
   try {
     const lessonsText = await fs13.readFile(lessonsFilePath, "utf-8");
@@ -45907,11 +45974,11 @@ async function handleCloseCommand(directory, args, options = {}) {
   } catch {}
   const retroLessons = [];
   try {
-    const evidenceDir = path31.join(swarmDir, "evidence");
+    const evidenceDir = path32.join(swarmDir, "evidence");
     const evidenceEntries = await fs13.readdir(evidenceDir);
     const retroDirs = evidenceEntries.filter((e) => e.startsWith("retro-")).sort((a, b) => a.localeCompare(b, undefined, { numeric: true }));
     for (const retroDir of retroDirs) {
-      const evidencePath = path31.join(evidenceDir, retroDir, "evidence.json");
+      const evidencePath = path32.join(evidenceDir, retroDir, "evidence.json");
       try {
         const content = await fs13.readFile(evidencePath, "utf-8");
         const parsed = JSON.parse(content);
@@ -46074,7 +46141,7 @@ async function handleCloseCommand(directory, args, options = {}) {
   } catch {}
   const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
   const suffix = Math.random().toString(36).slice(2, 8);
-  const archiveDir = path31.join(swarmDir, "archive", `swarm-${timestamp}-${suffix}`);
+  const archiveDir = path32.join(swarmDir, "archive", `swarm-${timestamp}-${suffix}`);
   let archiveResult = "";
   let archivedFileCount = 0;
   const archivedActiveStateFiles = new Set;
@@ -46082,8 +46149,8 @@ async function handleCloseCommand(directory, args, options = {}) {
   try {
     await fs13.mkdir(archiveDir, { recursive: true });
     for (const artifact of ARCHIVE_ARTIFACTS) {
-      const srcPath = path31.join(swarmDir, artifact);
-      const destPath = path31.join(archiveDir, artifact);
+      const srcPath = path32.join(swarmDir, artifact);
+      const destPath = path32.join(archiveDir, artifact);
       try {
         await fs13.copyFile(srcPath, destPath);
         archivedFileCount++;
@@ -46093,8 +46160,8 @@ async function handleCloseCommand(directory, args, options = {}) {
       } catch {}
     }
     for (const dirName of ACTIVE_STATE_DIRS_TO_CLEAN) {
-      const srcDir = path31.join(swarmDir, dirName);
-      const destDir = path31.join(archiveDir, dirName);
+      const srcDir = path32.join(swarmDir, dirName);
+      const destDir = path32.join(archiveDir, dirName);
       try {
         const copied = await copyDirRecursive(srcDir, destDir);
         archivedFileCount += copied;
@@ -46121,7 +46188,7 @@ async function handleCloseCommand(directory, args, options = {}) {
         warnings.push(`Preserved ${artifact} because it was not successfully archived.`);
         continue;
       }
-      const filePath = path31.join(swarmDir, artifact);
+      const filePath = path32.join(swarmDir, artifact);
       try {
         await fs13.unlink(filePath);
         cleanedFiles.push(artifact);
@@ -46134,7 +46201,7 @@ async function handleCloseCommand(directory, args, options = {}) {
     if (!archivedActiveStateDirs.has(dirName)) {
       continue;
     }
-    const dirPath = path31.join(swarmDir, dirName);
+    const dirPath = path32.join(swarmDir, dirName);
     try {
       await fs13.rm(dirPath, { recursive: true, force: true });
       cleanedFiles.push(`${dirName}/`);
@@ -46145,23 +46212,23 @@ async function handleCloseCommand(directory, args, options = {}) {
     const configBackups = swarmFiles.filter((f) => f.startsWith("config-backup-") && f.endsWith(".json"));
     for (const backup of configBackups) {
       try {
-        await fs13.unlink(path31.join(swarmDir, backup));
+        await fs13.unlink(path32.join(swarmDir, backup));
         configBackupsRemoved++;
       } catch {}
     }
     const ledgerSiblings = swarmFiles.filter((f) => (f.startsWith("plan-ledger.archived-") || f.startsWith("plan-ledger.backup-")) && f.endsWith(".jsonl"));
     for (const sibling of ledgerSiblings) {
       try {
-        await fs13.unlink(path31.join(swarmDir, sibling));
+        await fs13.unlink(path32.join(swarmDir, sibling));
       } catch {}
     }
   } catch {}
   let swarmPlanFilesRemoved = 0;
   const candidates = [
-    path31.join(directory, ".swarm", "SWARM_PLAN.json"),
-    path31.join(directory, ".swarm", "SWARM_PLAN.md"),
-    path31.join(directory, "SWARM_PLAN.json"),
-    path31.join(directory, "SWARM_PLAN.md")
+    path32.join(directory, ".swarm", "SWARM_PLAN.json"),
+    path32.join(directory, ".swarm", "SWARM_PLAN.md"),
+    path32.join(directory, "SWARM_PLAN.json"),
+    path32.join(directory, "SWARM_PLAN.md")
   ];
   for (const candidate of candidates) {
     try {
@@ -46179,7 +46246,7 @@ async function handleCloseCommand(directory, args, options = {}) {
     const tmpFiles = swarmFiles.filter((f) => f.startsWith(".tmp."));
     for (const tmp of tmpFiles) {
       try {
-        await fs13.unlink(path31.join(swarmDir, tmp));
+        await fs13.unlink(path32.join(swarmDir, tmp));
         tmpFilesRemoved++;
       } catch {}
     }
@@ -46188,7 +46255,7 @@ async function handleCloseCommand(directory, args, options = {}) {
     cleanedFiles.push(`${tmpFilesRemoved} .tmp.* file(s)`);
   }
   clearAllScopes(directory);
-  const contextPath = path31.join(swarmDir, "context.md");
+  const contextPath = path32.join(swarmDir, "context.md");
   const contextContent = [
     "# Context",
     "",
@@ -46210,9 +46277,9 @@ async function handleCloseCommand(directory, args, options = {}) {
   const pruneBranches = args.includes("--prune-branches");
   let gitAlignResult = "";
   const prunedBranches = [];
-  const isGit = isGitRepo2(directory);
-  if (isGit) {
-    const aggressiveResult = resetToMainAfterMerge(directory, {
+  const gitStatus = _internals23.getGitRepositoryStatus(directory);
+  if (gitStatus.isRepo) {
+    const aggressiveResult = _internals23.resetToMainAfterMerge(directory, {
       pruneBranches
     });
     if (aggressiveResult.success) {
@@ -46224,7 +46291,9 @@ async function handleCloseCommand(directory, args, options = {}) {
         warnings.push("Uncommitted changes were discarded during git alignment");
       }
     } else {
-      const alignResult = resetToRemoteBranch(directory, { pruneBranches });
+      const alignResult = _internals23.resetToRemoteBranch(directory, {
+        pruneBranches
+      });
       gitAlignResult = alignResult.message;
       prunedBranches.push(...alignResult.prunedBranches);
       if (!alignResult.success) {
@@ -46237,6 +46306,12 @@ async function handleCloseCommand(directory, args, options = {}) {
         warnings.push(w);
       }
     }
+  } else if (gitStatus.reason === "git_unavailable") {
+    gitAlignResult = `Git executable unavailable \u2014 skipped git alignment: ${gitStatus.message}`;
+    warnings.push(gitAlignResult);
+  } else if (gitStatus.reason === "git_error") {
+    gitAlignResult = `Git repository check failed \u2014 skipped git alignment: ${gitStatus.message}`;
+    warnings.push(gitAlignResult);
   } else {
     gitAlignResult = "Not a git repository \u2014 skipped git alignment";
   }
@@ -46334,7 +46409,7 @@ ${otherWarnings.map((w) => `- ${w}`).join(`
 **Archive:** ${archiveResult}
 **Git:** ${gitAlignResult}${lessonSummary}${knowledgeHintSummary}${skillReviewOutput}${postMortemOutput}${warningMsg}`;
 }
-var CLOSE_SKILL_REVIEW_TIMEOUT_MS = 120000, ARCHIVE_ARTIFACTS, ACTIVE_STATE_TO_CLEAN, ACTIVE_STATE_DIRS_TO_CLEAN;
+var CLOSE_SKILL_REVIEW_TIMEOUT_MS = 120000, ARCHIVE_ARTIFACTS, ACTIVE_STATE_TO_CLEAN, ACTIVE_STATE_DIRS_TO_CLEAN, _internals23;
 var init_close = __esm(() => {
   init_config();
   init_schema();
@@ -46398,6 +46473,15 @@ var init_close = __esm(() => {
     "locks",
     "spec-archive"
   ];
+  _internals23 = {
+    countSessionKnowledgeEntries,
+    CLOSE_SKILL_REVIEW_TIMEOUT_MS,
+    guaranteeAllPlansComplete,
+    getGitRepositoryStatus,
+    resetToMainAfterMerge,
+    resetToRemoteBranch,
+    copyDirRecursive
+  };
 });
 
 // src/commands/codebase-review.ts
@@ -46630,14 +46714,14 @@ var init_concurrency = __esm(() => {
 
 // src/commands/config.ts
 import * as os5 from "os";
-import * as path32 from "path";
+import * as path33 from "path";
 function getUserConfigDir2() {
-  return process.env.XDG_CONFIG_HOME || path32.join(os5.homedir(), ".config");
+  return process.env.XDG_CONFIG_HOME || path33.join(os5.homedir(), ".config");
 }
 async function handleConfigCommand(directory, _args) {
   const config3 = loadPluginConfig(directory);
-  const userConfigPath = path32.join(getUserConfigDir2(), "opencode", "opencode-swarm.json");
-  const projectConfigPath = path32.join(directory, ".opencode", "opencode-swarm.json");
+  const userConfigPath = path33.join(getUserConfigDir2(), "opencode", "opencode-swarm.json");
+  const projectConfigPath = path33.join(directory, ".opencode", "opencode-swarm.json");
   const lines = [
     "## Swarm Configuration",
     "",
@@ -46677,9 +46761,9 @@ async function withTimeout(promise3, ms, timeoutError) {
 // src/services/skill-consolidation.ts
 import { existsSync as existsSync20 } from "fs";
 import { mkdir as mkdir14, readFile as readFile12, rename as rename8, writeFile as writeFile12 } from "fs/promises";
-import * as path33 from "path";
+import * as path34 from "path";
 function consolidationStatePath(directory) {
-  return path33.join(directory, ".swarm", "skill-improver", "consolidation-state.json");
+  return path34.join(directory, ".swarm", "skill-improver", "consolidation-state.json");
 }
 async function readState2(directory) {
   const filePath = consolidationStatePath(directory);
@@ -46695,7 +46779,7 @@ async function readState2(directory) {
   }
 }
 async function atomicWrite4(filePath, content) {
-  await mkdir14(path33.dirname(filePath), { recursive: true });
+  await mkdir14(path34.dirname(filePath), { recursive: true });
   const tmp = `${filePath}.tmp-${process.pid}-${Date.now()}`;
   await writeFile12(tmp, content, "utf-8");
   await rename8(tmp, filePath);
@@ -46775,7 +46859,7 @@ async function runSkillConsolidationInner(req) {
   };
 }
 async function runSkillConsolidation(req) {
-  const key = path33.resolve(req.directory);
+  const key = path34.resolve(req.directory);
   const existing = runningByDirectory.get(key);
   if (existing) {
     return {
@@ -46975,7 +47059,7 @@ var init_curate = __esm(() => {
 import * as child_process3 from "child_process";
 import { randomUUID as randomUUID2 } from "crypto";
 import { readdir as readdir3, readFile as readFile13, stat as stat7 } from "fs/promises";
-import * as path34 from "path";
+import * as path35 from "path";
 import { promisify } from "util";
 function getExecFileAsync() {
   return promisify(child_process3.execFile);
@@ -47079,7 +47163,7 @@ async function scanSourceFiles(dir) {
   try {
     const entries = await readdir3(dir, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = path34.join(dir, entry.name);
+      const fullPath = path35.join(dir, entry.name);
       if (entry.isDirectory()) {
         if (skipDirs.has(entry.name)) {
           continue;
@@ -47087,7 +47171,7 @@ async function scanSourceFiles(dir) {
         const subFiles = await scanSourceFiles(fullPath);
         results.push(...subFiles);
       } else if (entry.isFile()) {
-        const ext = path34.extname(entry.name);
+        const ext = path35.extname(entry.name);
         if ([".ts", ".tsx", ".js", ".jsx", ".mjs"].includes(ext)) {
           results.push(fullPath);
         }
@@ -47109,8 +47193,8 @@ async function getStaticEdges(directory) {
           continue;
         }
         try {
-          const sourceDir = path34.dirname(sourceFile);
-          const resolvedPath = path34.resolve(sourceDir, importPath);
+          const sourceDir = path35.dirname(sourceFile);
+          const resolvedPath = path35.resolve(sourceDir, importPath);
           const extensions = [
             "",
             ".ts",
@@ -47135,8 +47219,8 @@ async function getStaticEdges(directory) {
           if (!targetFile) {
             continue;
           }
-          const relSource = path34.relative(directory, sourceFile).replace(/\\/g, "/");
-          const relTarget = path34.relative(directory, targetFile).replace(/\\/g, "/");
+          const relSource = path35.relative(directory, sourceFile).replace(/\\/g, "/");
+          const relTarget = path35.relative(directory, targetFile).replace(/\\/g, "/");
           const [key] = relSource < relTarget ? [`${relSource}::${relTarget}`, relSource, relTarget] : [`${relTarget}::${relSource}`, relTarget, relSource];
           edges.add(key);
         } catch {}
@@ -47148,7 +47232,7 @@ async function getStaticEdges(directory) {
 function isTestImplementationPair(fileA, fileB) {
   const testPatterns = [".test.ts", ".test.js", ".spec.ts", ".spec.js"];
   const getBaseName = (filePath) => {
-    const base = path34.basename(filePath);
+    const base = path35.basename(filePath);
     for (const pattern of testPatterns) {
       if (base.endsWith(pattern)) {
         return base.slice(0, -pattern.length);
@@ -47158,16 +47242,16 @@ function isTestImplementationPair(fileA, fileB) {
   };
   const baseA = getBaseName(fileA);
   const baseB = getBaseName(fileB);
-  return baseA === baseB && baseA !== path34.basename(fileA) && baseA !== path34.basename(fileB);
+  return baseA === baseB && baseA !== path35.basename(fileA) && baseA !== path35.basename(fileB);
 }
 function hasSharedPrefix(fileA, fileB) {
-  const dirA = path34.dirname(fileA);
-  const dirB = path34.dirname(fileB);
+  const dirA = path35.dirname(fileA);
+  const dirB = path35.dirname(fileB);
   if (dirA !== dirB) {
     return false;
   }
-  const baseA = path34.basename(fileA).replace(/\.(ts|js|tsx|jsx|mjs)$/, "");
-  const baseB = path34.basename(fileB).replace(/\.(ts|js|tsx|jsx|mjs)$/, "");
+  const baseA = path35.basename(fileA).replace(/\.(ts|js|tsx|jsx|mjs)$/, "");
+  const baseB = path35.basename(fileB).replace(/\.(ts|js|tsx|jsx|mjs)$/, "");
   if (baseA.startsWith(baseB) || baseB.startsWith(baseA)) {
     return true;
   }
@@ -47196,9 +47280,9 @@ async function detectDarkMatter(directory, options) {
   } catch {
     return [];
   }
-  const commitMap = await _internals23.parseGitLog(directory, maxCommitsToAnalyze);
-  const matrix = _internals23.buildCoChangeMatrix(commitMap, maxFilesPerCommit);
-  const staticEdges = await _internals23.getStaticEdges(directory);
+  const commitMap = await _internals24.parseGitLog(directory, maxCommitsToAnalyze);
+  const matrix = _internals24.buildCoChangeMatrix(commitMap, maxFilesPerCommit);
+  const staticEdges = await _internals24.getStaticEdges(directory);
   const results = [];
   for (const entry of matrix.values()) {
     const key = `${entry.fileA}::${entry.fileB}`;
@@ -47222,8 +47306,8 @@ function darkMatterToKnowledgeEntries(pairs, projectName) {
   const entries = [];
   const now = new Date().toISOString();
   for (const pair of pairs.slice(0, 10)) {
-    const baseA = path34.basename(pair.fileA);
-    const baseB = path34.basename(pair.fileB);
+    const baseA = path35.basename(pair.fileA);
+    const baseB = path35.basename(pair.fileB);
     let lesson = `Files ${pair.fileA} and ${pair.fileB} co-change with NPMI=${pair.npmi.toFixed(3)} but have no import relationship. This hidden coupling suggests a shared architectural concern \u2014 changes to one likely require changes to the other.`;
     if (lesson.length > 280) {
       lesson = `Files ${baseA} and ${baseB} co-change with NPMI=${pair.npmi.toFixed(3)} but have no import relationship. This hidden coupling suggests a shared architectural concern \u2014 changes to one likely require changes to the other.`;
@@ -47286,7 +47370,7 @@ ${rows}
 These pairs likely share an architectural concern invisible to static analysis.
 Consider adding explicit documentation or extracting the shared concern.`;
 }
-var co_change_analyzer, _internals23;
+var co_change_analyzer, _internals24;
 var init_co_change_analyzer = __esm(() => {
   init_zod();
   init_create_tool();
@@ -47318,11 +47402,11 @@ var init_co_change_analyzer = __esm(() => {
         npmiThreshold,
         maxCommitsToAnalyze
       };
-      const pairs = await _internals23.detectDarkMatter(directory, options);
-      return _internals23.formatDarkMatterOutput(pairs);
+      const pairs = await _internals24.detectDarkMatter(directory, options);
+      return _internals24.formatDarkMatterOutput(pairs);
     }
   });
-  _internals23 = {
+  _internals24 = {
     parseGitLog,
     buildCoChangeMatrix,
     getStaticEdges,
@@ -47333,7 +47417,7 @@ var init_co_change_analyzer = __esm(() => {
 });
 
 // src/commands/dark-matter.ts
-import path35 from "path";
+import path36 from "path";
 async function handleDarkMatterCommand(directory, args) {
   const options = {};
   for (let i = 0;i < args.length; i++) {
@@ -47353,7 +47437,7 @@ async function handleDarkMatterCommand(directory, args) {
   }
   let pairs;
   try {
-    pairs = await _internals23.detectDarkMatter(directory, options);
+    pairs = await _internals24.detectDarkMatter(directory, options);
   } catch (err) {
     const errMsg = err instanceof Error ? err.message : String(err);
     return `## Dark Matter Analysis Failed
@@ -47365,7 +47449,7 @@ Ensure this is a git repository with commit history.`;
   const output = formatDarkMatterOutput(pairs);
   if (pairs.length > 0) {
     try {
-      const projectName = path35.basename(path35.resolve(directory));
+      const projectName = path36.basename(path36.resolve(directory));
       const entries = darkMatterToKnowledgeEntries(pairs, projectName);
       if (entries.length > 0) {
         const knowledgePath = resolveSwarmKnowledgePath(directory);
@@ -47731,44 +47815,44 @@ var init_design_docs = __esm(() => {
 
 // src/config/cache-paths.ts
 import * as os6 from "os";
-import * as path36 from "path";
+import * as path37 from "path";
 function getPluginConfigDir() {
-  return path36.join(process.env.XDG_CONFIG_HOME || path36.join(os6.homedir(), ".config"), "opencode");
+  return path37.join(process.env.XDG_CONFIG_HOME || path37.join(os6.homedir(), ".config"), "opencode");
 }
 function getPluginCachePaths() {
-  const cacheBase = process.env.XDG_CACHE_HOME || path36.join(os6.homedir(), ".cache");
+  const cacheBase = process.env.XDG_CACHE_HOME || path37.join(os6.homedir(), ".cache");
   const configDir = getPluginConfigDir();
   const paths = [
-    path36.join(cacheBase, "opencode", "node_modules", "opencode-swarm"),
-    path36.join(cacheBase, "opencode", "packages", "opencode-swarm@latest"),
-    path36.join(configDir, "node_modules", "opencode-swarm")
+    path37.join(cacheBase, "opencode", "node_modules", "opencode-swarm"),
+    path37.join(cacheBase, "opencode", "packages", "opencode-swarm@latest"),
+    path37.join(configDir, "node_modules", "opencode-swarm")
   ];
   if (process.platform === "darwin") {
-    const libCaches = path36.join(os6.homedir(), "Library", "Caches");
-    paths.push(path36.join(libCaches, "opencode", "node_modules", "opencode-swarm"), path36.join(libCaches, "opencode", "packages", "opencode-swarm@latest"));
+    const libCaches = path37.join(os6.homedir(), "Library", "Caches");
+    paths.push(path37.join(libCaches, "opencode", "node_modules", "opencode-swarm"), path37.join(libCaches, "opencode", "packages", "opencode-swarm@latest"));
   }
   if (process.platform === "win32") {
-    const localAppData = process.env.LOCALAPPDATA || path36.join(os6.homedir(), "AppData", "Local");
-    const appData = process.env.APPDATA || path36.join(os6.homedir(), "AppData", "Roaming");
-    paths.push(path36.join(localAppData, "opencode", "node_modules", "opencode-swarm"), path36.join(localAppData, "opencode", "packages", "opencode-swarm@latest"), path36.join(appData, "opencode", "node_modules", "opencode-swarm"));
+    const localAppData = process.env.LOCALAPPDATA || path37.join(os6.homedir(), "AppData", "Local");
+    const appData = process.env.APPDATA || path37.join(os6.homedir(), "AppData", "Roaming");
+    paths.push(path37.join(localAppData, "opencode", "node_modules", "opencode-swarm"), path37.join(localAppData, "opencode", "packages", "opencode-swarm@latest"), path37.join(appData, "opencode", "node_modules", "opencode-swarm"));
   }
   return paths;
 }
 function getPluginLockFilePaths() {
-  const cacheBase = process.env.XDG_CACHE_HOME || path36.join(os6.homedir(), ".cache");
+  const cacheBase = process.env.XDG_CACHE_HOME || path37.join(os6.homedir(), ".cache");
   const configDir = getPluginConfigDir();
   const paths = [
-    path36.join(cacheBase, "opencode", "bun.lock"),
-    path36.join(cacheBase, "opencode", "bun.lockb"),
-    path36.join(configDir, "package-lock.json")
+    path37.join(cacheBase, "opencode", "bun.lock"),
+    path37.join(cacheBase, "opencode", "bun.lockb"),
+    path37.join(configDir, "package-lock.json")
   ];
   if (process.platform === "darwin") {
-    const libCaches = path36.join(os6.homedir(), "Library", "Caches");
-    paths.push(path36.join(libCaches, "opencode", "bun.lock"), path36.join(libCaches, "opencode", "bun.lockb"));
+    const libCaches = path37.join(os6.homedir(), "Library", "Caches");
+    paths.push(path37.join(libCaches, "opencode", "bun.lock"), path37.join(libCaches, "opencode", "bun.lockb"));
   }
   if (process.platform === "win32") {
-    const localAppData = process.env.LOCALAPPDATA || path36.join(os6.homedir(), "AppData", "Local");
-    paths.push(path36.join(localAppData, "opencode", "bun.lock"), path36.join(localAppData, "opencode", "bun.lockb"));
+    const localAppData = process.env.LOCALAPPDATA || path37.join(os6.homedir(), "AppData", "Local");
+    paths.push(path37.join(localAppData, "opencode", "bun.lock"), path37.join(localAppData, "opencode", "bun.lockb"));
   }
   return paths;
 }
@@ -47964,10 +48048,10 @@ function cacheFile() {
 }
 function readVersionCache() {
   try {
-    const path37 = cacheFile();
-    if (!existsSync21(path37))
+    const path38 = cacheFile();
+    if (!existsSync21(path38))
       return null;
-    const raw = readFileSync11(path37, "utf-8");
+    const raw = readFileSync11(path38, "utf-8");
     const parsed = JSON.parse(raw);
     if (typeof parsed?.checkedAt !== "number")
       return null;
@@ -48217,7 +48301,7 @@ var init_knowledge_diagnostics = __esm(() => {
 // src/services/diagnose-service.ts
 import * as child_process4 from "child_process";
 import { existsSync as existsSync23, readdirSync as readdirSync7, readFileSync as readFileSync12, statSync as statSync9 } from "fs";
-import path37 from "path";
+import path38 from "path";
 import { fileURLToPath } from "url";
 function validateTaskDag(plan) {
   const allTaskIds = new Set;
@@ -48528,7 +48612,7 @@ async function checkSpecStaleness(directory, plan) {
   };
 }
 async function checkConfigParseability(directory) {
-  const configPath = path37.join(directory, ".opencode/opencode-swarm.json");
+  const configPath = path38.join(directory, ".opencode/opencode-swarm.json");
   if (!existsSync23(configPath)) {
     return {
       name: "Config Parseability",
@@ -48557,7 +48641,7 @@ function resolveGrammarDir(thisDir) {
   const normalized = thisDir.replace(/\\/g, "/");
   const isSource = normalized.endsWith("/src/services");
   const isCliBundle = normalized.endsWith("/cli");
-  return isSource || isCliBundle ? path37.join(thisDir, "..", "lang", "grammars") : path37.join(thisDir, "lang", "grammars");
+  return isSource || isCliBundle ? path38.join(thisDir, "..", "lang", "grammars") : path38.join(thisDir, "lang", "grammars");
 }
 async function checkGrammarWasmFiles() {
   const grammarFiles = [
@@ -48581,14 +48665,14 @@ async function checkGrammarWasmFiles() {
     "tree-sitter-ini.wasm",
     "tree-sitter-regex.wasm"
   ];
-  const thisDir = path37.dirname(fileURLToPath(import.meta.url));
+  const thisDir = path38.dirname(fileURLToPath(import.meta.url));
   const grammarDir = resolveGrammarDir(thisDir);
   const missing = [];
-  if (!existsSync23(path37.join(grammarDir, "tree-sitter.wasm"))) {
+  if (!existsSync23(path38.join(grammarDir, "tree-sitter.wasm"))) {
     missing.push("tree-sitter.wasm (core runtime)");
   }
   for (const file3 of grammarFiles) {
-    if (!existsSync23(path37.join(grammarDir, file3))) {
+    if (!existsSync23(path38.join(grammarDir, file3))) {
       missing.push(file3);
     }
   }
@@ -48606,7 +48690,7 @@ async function checkGrammarWasmFiles() {
   };
 }
 async function checkCheckpointManifest(directory) {
-  const manifestPath = path37.join(directory, ".swarm/checkpoints.json");
+  const manifestPath = path38.join(directory, ".swarm/checkpoints.json");
   if (!existsSync23(manifestPath)) {
     return {
       name: "Checkpoint Manifest",
@@ -48658,7 +48742,7 @@ async function checkCheckpointManifest(directory) {
   }
 }
 async function checkEventStreamIntegrity(directory) {
-  const eventsPath = path37.join(directory, ".swarm/events.jsonl");
+  const eventsPath = path38.join(directory, ".swarm/events.jsonl");
   if (!existsSync23(eventsPath)) {
     return {
       name: "Event Stream",
@@ -48699,7 +48783,7 @@ async function checkEventStreamIntegrity(directory) {
   }
 }
 async function checkSteeringDirectives(directory) {
-  const eventsPath = path37.join(directory, ".swarm/events.jsonl");
+  const eventsPath = path38.join(directory, ".swarm/events.jsonl");
   if (!existsSync23(eventsPath)) {
     return {
       name: "Steering Directives",
@@ -48755,7 +48839,7 @@ async function checkCurator(directory) {
         detail: "Disabled (enable via curator.enabled)"
       };
     }
-    const summaryPath = path37.join(directory, ".swarm/curator-summary.json");
+    const summaryPath = path38.join(directory, ".swarm/curator-summary.json");
     if (!existsSync23(summaryPath)) {
       return {
         name: "Curator",
@@ -48922,7 +49006,7 @@ async function getDiagnoseData(directory) {
   checks5.push(await checkCurator(directory));
   checks5.push(await checkKnowledgeHealth(directory));
   try {
-    const evidenceDir = path37.join(directory, ".swarm", "evidence");
+    const evidenceDir = path38.join(directory, ".swarm", "evidence");
     const snapshotFiles = existsSync23(evidenceDir) ? readdirSync7(evidenceDir).filter((f) => f.startsWith("agent-tools-") && f.endsWith(".json")) : [];
     if (snapshotFiles.length > 0) {
       const latest = snapshotFiles.sort().pop();
@@ -48960,7 +49044,7 @@ async function getDiagnoseData(directory) {
         cacheRows.push(`\u2B1C ${cachePath} \u2014 absent`);
         continue;
       }
-      const pkgJsonPath = path37.join(cachePath, "package.json");
+      const pkgJsonPath = path38.join(cachePath, "package.json");
       try {
         const raw = readFileSync12(pkgJsonPath, "utf-8");
         const parsed = JSON.parse(raw);
@@ -49055,7 +49139,7 @@ __export(exports_config_doctor, {
 import * as crypto4 from "crypto";
 import * as fs14 from "fs";
 import * as os7 from "os";
-import * as path38 from "path";
+import * as path39 from "path";
 function levenshteinDistance(a, b) {
   const al = a.length;
   const bl = b.length;
@@ -49088,11 +49172,11 @@ function emitObjectTypeMismatch(key, value, findings) {
   }
 }
 function getUserConfigDir3() {
-  return process.env.XDG_CONFIG_HOME || path38.join(os7.homedir(), ".config");
+  return process.env.XDG_CONFIG_HOME || path39.join(os7.homedir(), ".config");
 }
 function getConfigPaths(directory) {
-  const userConfigPath = path38.join(getUserConfigDir3(), "opencode", "opencode-swarm.json");
-  const projectConfigPath = path38.join(directory, ".opencode", "opencode-swarm.json");
+  const userConfigPath = path39.join(getUserConfigDir3(), "opencode", "opencode-swarm.json");
+  const projectConfigPath = path39.join(directory, ".opencode", "opencode-swarm.json");
   return { userConfigPath, projectConfigPath };
 }
 function computeHash(content) {
@@ -49110,9 +49194,9 @@ function isValidConfigPath(configPath, directory) {
   }
   const { userConfigPath, projectConfigPath } = getConfigPaths(directory);
   try {
-    const resolvedConfig = path38.resolve(configPath);
-    const resolvedUser = path38.resolve(userConfigPath);
-    const resolvedProject = path38.resolve(projectConfigPath);
+    const resolvedConfig = path39.resolve(configPath);
+    const resolvedUser = path39.resolve(userConfigPath);
+    const resolvedProject = path39.resolve(projectConfigPath);
     if (resolvedConfig !== resolvedUser && resolvedConfig !== resolvedProject) {
       return false;
     }
@@ -49175,12 +49259,12 @@ function createConfigBackup(directory) {
   };
 }
 function writeBackupArtifact(directory, backup) {
-  const swarmDir = path38.join(directory, ".swarm");
+  const swarmDir = path39.join(directory, ".swarm");
   if (!fs14.existsSync(swarmDir)) {
     fs14.mkdirSync(swarmDir, { recursive: true });
   }
   const backupFilename = `config-backup-${backup.createdAt}.json`;
-  const backupPath = path38.join(swarmDir, backupFilename);
+  const backupPath = path39.join(swarmDir, backupFilename);
   const artifact = {
     createdAt: backup.createdAt,
     configPath: backup.configPath,
@@ -49195,9 +49279,9 @@ function restoreFromBackup(backupPath, directory) {
   if (!fs14.existsSync(backupPath)) {
     return null;
   }
-  const swarmDir = path38.resolve(path38.join(directory, ".swarm"));
-  const resolvedBackup = path38.resolve(backupPath);
-  if (!resolvedBackup.startsWith(swarmDir + path38.sep) && resolvedBackup !== swarmDir) {
+  const swarmDir = path39.resolve(path39.join(directory, ".swarm"));
+  const resolvedBackup = path39.resolve(backupPath);
+  if (!resolvedBackup.startsWith(swarmDir + path39.sep) && resolvedBackup !== swarmDir) {
     return null;
   }
   try {
@@ -49216,7 +49300,7 @@ function restoreFromBackup(backupPath, directory) {
     }
     log("[ConfigDoctor] Warning: restoring from backup with legacy numeric hash (pre-SHA-256). Consider re-backing up.", {});
     const targetPath = artifact.configPath;
-    const targetDir = path38.dirname(targetPath);
+    const targetDir = path39.dirname(targetPath);
     if (!fs14.existsSync(targetDir)) {
       fs14.mkdirSync(targetDir, { recursive: true });
     }
@@ -49250,10 +49334,10 @@ function readConfigFromFile(directory) {
     return null;
   }
 }
-function validateConfigKey(path39, value) {
+function validateConfigKey(path40, value) {
   const findings = [];
   for (const [depPath, depInfo] of DEPRECATED_FIELDS) {
-    if (path39 === depPath && !depInfo.isDefaultValue(value)) {
+    if (path40 === depPath && !depInfo.isDefaultValue(value)) {
       findings.push({
         id: "deprecated-field",
         title: `Deprecated config field: ${depPath}`,
@@ -49265,7 +49349,7 @@ function validateConfigKey(path39, value) {
       });
     }
   }
-  switch (path39) {
+  switch (path40) {
     case "agents": {
       if (value !== undefined) {
         findings.push({
@@ -49818,7 +49902,7 @@ function validateConfigKey(path39, value) {
       break;
     }
     default: {
-      const topLevel = path39.split(".")[0];
+      const topLevel = path40.split(".")[0];
       if (KNOWN_TOP_LEVEL_KEYS.has(topLevel)) {
         break;
       }
@@ -49840,9 +49924,9 @@ function validateConfigKey(path39, value) {
         findings.push({
           id: "unknown-config-key",
           title: `Unknown config key: ${topLevel}`,
-          description: `Unknown config key "${path39}" is not in the schema. Did you mean "${suggestion}"?`,
+          description: `Unknown config key "${path40}" is not in the schema. Did you mean "${suggestion}"?`,
           severity: "warn",
-          path: path39,
+          path: path40,
           currentValue: value,
           autoFixable: false
         });
@@ -49850,9 +49934,9 @@ function validateConfigKey(path39, value) {
         findings.push({
           id: "unknown-config-key",
           title: `Unknown config key: ${topLevel}`,
-          description: `Unknown config key "${path39}" is not in the schema.`,
+          description: `Unknown config key "${path40}" is not in the schema.`,
           severity: "warn",
-          path: path39,
+          path: path40,
           currentValue: value,
           autoFixable: false
         });
@@ -49862,26 +49946,26 @@ function validateConfigKey(path39, value) {
   }
   return findings;
 }
-function walkConfigAndValidate(obj, path39, findings, visited = new WeakSet) {
+function walkConfigAndValidate(obj, path40, findings, visited = new WeakSet) {
   if (obj === null || obj === undefined) {
     return;
   }
-  if (path39 && typeof obj === "object" && !Array.isArray(obj)) {
-    const keyFindings = validateConfigKey(path39, obj);
+  if (path40 && typeof obj === "object" && !Array.isArray(obj)) {
+    const keyFindings = validateConfigKey(path40, obj);
     findings.push(...keyFindings);
   }
   if (typeof obj !== "object") {
-    const keyFindings = validateConfigKey(path39, obj);
+    const keyFindings = validateConfigKey(path40, obj);
     findings.push(...keyFindings);
     return;
   }
   if (visited.has(obj)) {
     findings.push({
       id: "circular-reference",
-      title: `Circular reference detected at ${path39}`,
-      description: `Config value at "${path39}" contains a circular reference. Validation stopped at this path to prevent stack overflow.`,
+      title: `Circular reference detected at ${path40}`,
+      description: `Config value at "${path40}" contains a circular reference. Validation stopped at this path to prevent stack overflow.`,
       severity: "error",
-      path: path39,
+      path: path40,
       currentValue: "[circular]",
       autoFixable: false
     });
@@ -49889,15 +49973,15 @@ function walkConfigAndValidate(obj, path39, findings, visited = new WeakSet) {
   }
   visited.add(obj);
   if (Array.isArray(obj)) {
-    const arrayFindings = validateConfigKey(path39, obj);
+    const arrayFindings = validateConfigKey(path40, obj);
     findings.push(...arrayFindings);
     obj.forEach((item, index) => {
-      walkConfigAndValidate(item, `${path39}[${index}]`, findings, visited);
+      walkConfigAndValidate(item, `${path40}[${index}]`, findings, visited);
     });
     return;
   }
   for (const [key, value] of Object.entries(obj)) {
-    const newPath = path39 ? `${path39}.${key}` : key;
+    const newPath = path40 ? `${path40}.${key}` : key;
     walkConfigAndValidate(value, newPath, findings, visited);
   }
 }
@@ -50017,7 +50101,7 @@ function applySafeAutoFixes(directory, result) {
     }
   }
   if (appliedFixes.length > 0) {
-    const configDir = path38.dirname(configPath);
+    const configDir = path39.dirname(configPath);
     if (!fs14.existsSync(configDir)) {
       fs14.mkdirSync(configDir, { recursive: true });
     }
@@ -50028,7 +50112,7 @@ function applySafeAutoFixes(directory, result) {
 }
 function readDoctorArtifact(directory) {
   try {
-    const artifactPath = path38.join(directory, ".swarm", "config-doctor.json");
+    const artifactPath = path39.join(directory, ".swarm", "config-doctor.json");
     if (!fs14.existsSync(artifactPath)) {
       return null;
     }
@@ -50061,12 +50145,12 @@ function readDoctorArtifact(directory) {
   }
 }
 function writeDoctorArtifact(directory, result) {
-  const swarmDir = path38.join(directory, ".swarm");
+  const swarmDir = path39.join(directory, ".swarm");
   if (!fs14.existsSync(swarmDir)) {
     fs14.mkdirSync(swarmDir, { recursive: true });
   }
   const artifactFilename = "config-doctor.json";
-  const artifactPath = path38.join(swarmDir, artifactFilename);
+  const artifactPath = path39.join(swarmDir, artifactFilename);
   const guiOutput = {
     timestamp: result.timestamp,
     summary: result.summary,
@@ -50162,17 +50246,17 @@ function detectStraySwarmDirs(projectRoot) {
       if (!entry.isDirectory())
         continue;
       const name = entry.name;
-      const fullPath = path38.join(dir, name);
+      const fullPath = path39.join(dir, name);
       if (SKIP_DIRS.has(name))
         continue;
-      const gitPath = path38.join(fullPath, ".git");
+      const gitPath = path39.join(fullPath, ".git");
       try {
         const gitStat = fs14.statSync(gitPath);
         if (gitStat.isFile() || gitStat.isDirectory())
           continue;
       } catch {}
       if (name === ".swarm") {
-        const parentDir = path38.dirname(fullPath);
+        const parentDir = path39.dirname(fullPath);
         if (parentDir === projectRoot)
           continue;
         let contents = [];
@@ -50182,7 +50266,7 @@ function detectStraySwarmDirs(projectRoot) {
           contents = ["<unreadable>"];
         }
         findings.push({
-          path: path38.relative(projectRoot, fullPath).replace(/\\/g, "/"),
+          path: path39.relative(projectRoot, fullPath).replace(/\\/g, "/"),
           absolutePath: fullPath,
           contents: contents.slice(0, MAX_CONTENTS_ENTRIES),
           totalEntries: contents.length
@@ -50200,21 +50284,21 @@ function removeStraySwarmDir(projectRoot, strayPath) {
   let canonicalStray;
   try {
     canonicalRoot = fs14.realpathSync(projectRoot);
-    canonicalStray = fs14.realpathSync(path38.isAbsolute(strayPath) ? strayPath : path38.resolve(projectRoot, strayPath));
+    canonicalStray = fs14.realpathSync(path39.isAbsolute(strayPath) ? strayPath : path39.resolve(projectRoot, strayPath));
   } catch (err) {
     return {
       success: false,
       message: `Failed to resolve paths: ${err instanceof Error ? err.message : String(err)}`
     };
   }
-  const rootSwarm = path38.join(canonicalRoot, ".swarm");
+  const rootSwarm = path39.join(canonicalRoot, ".swarm");
   if (canonicalStray === rootSwarm || canonicalStray === canonicalRoot) {
     return {
       success: false,
       message: "Refusing to remove root .swarm/ directory"
     };
   }
-  if (!canonicalStray.startsWith(canonicalRoot + path38.sep)) {
+  if (!canonicalStray.startsWith(canonicalRoot + path39.sep)) {
     return {
       success: false,
       message: "Path is outside project root \u2014 refusing to remove"
@@ -51397,7 +51481,7 @@ var init_detector = __esm(() => {
 
 // src/build/discovery.ts
 import * as fs15 from "fs";
-import * as path39 from "path";
+import * as path40 from "path";
 function isCommandAvailable(command) {
   if (toolchainCache.has(command)) {
     return toolchainCache.get(command);
@@ -51405,7 +51489,7 @@ function isCommandAvailable(command) {
   const isWindows = process.platform === "win32";
   const cmd = isWindows ? `${command}.exe` : command;
   try {
-    const result = _internals24.spawnSyncImpl(isWindows ? ["where", cmd] : ["which", cmd], {
+    const result = _internals25.spawnSyncImpl(isWindows ? ["where", cmd] : ["which", cmd], {
       cwd: process.cwd(),
       stdin: "ignore",
       stdout: "ignore",
@@ -51432,11 +51516,11 @@ function findBuildFiles(workingDir, patterns) {
         const regex = simpleGlobToRegex(pattern);
         const matches = files.filter((f) => regex.test(f));
         if (matches.length > 0) {
-          return path39.join(dir, matches[0]);
+          return path40.join(dir, matches[0]);
         }
       } catch {}
     } else {
-      const filePath = path39.join(workingDir, pattern);
+      const filePath = path40.join(workingDir, pattern);
       if (fs15.existsSync(filePath)) {
         return filePath;
       }
@@ -51445,7 +51529,7 @@ function findBuildFiles(workingDir, patterns) {
   return null;
 }
 function getRepoDefinedScripts(workingDir, scripts) {
-  const packageJsonPath = path39.join(workingDir, "package.json");
+  const packageJsonPath = path40.join(workingDir, "package.json");
   if (!fs15.existsSync(packageJsonPath)) {
     return [];
   }
@@ -51486,7 +51570,7 @@ function findAllBuildFiles(workingDir) {
         const regex = simpleGlobToRegex(pattern);
         findFilesRecursive(workingDir, regex, allBuildFiles);
       } else {
-        const filePath = path39.join(workingDir, pattern);
+        const filePath = path40.join(workingDir, pattern);
         if (fs15.existsSync(filePath)) {
           allBuildFiles.add(filePath);
         }
@@ -51499,7 +51583,7 @@ function findFilesRecursive(dir, regex, results) {
   try {
     const entries = fs15.readdirSync(dir, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = path39.join(dir, entry.name);
+      const fullPath = path40.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)) {
@@ -51522,7 +51606,7 @@ async function discoverBuildCommandsFromProfiles(workingDir) {
     let foundCommand = false;
     for (const cmd of sortedCommands) {
       if (cmd.detectFile) {
-        const detectFilePath = path39.join(workingDir, cmd.detectFile);
+        const detectFilePath = path40.join(workingDir, cmd.detectFile);
         if (!fs15.existsSync(detectFilePath)) {
           continue;
         }
@@ -51555,7 +51639,7 @@ async function discoverBuildCommands(workingDir, options) {
   const scope = options?.scope ?? "all";
   const changedFiles = options?.changedFiles ?? [];
   const _filesToCheck = filterByScope(workingDir, scope, changedFiles);
-  const profileResult = await _internals24.discoverBuildCommandsFromProfiles(workingDir);
+  const profileResult = await _internals25.discoverBuildCommandsFromProfiles(workingDir);
   const profileCommands = profileResult.commands;
   const profileSkipped = profileResult.skipped;
   const coveredEcosystems = new Set;
@@ -51618,7 +51702,7 @@ function clearToolchainCache() {
 function getEcosystems() {
   return ECOSYSTEMS.map((e) => e.ecosystem);
 }
-var ECOSYSTEMS, PROFILE_TO_ECOSYSTEM_NAMES, toolchainCache, IS_COMMAND_AVAILABLE_TIMEOUT_MS = 3000, _internals24, build_discovery;
+var ECOSYSTEMS, PROFILE_TO_ECOSYSTEM_NAMES, toolchainCache, IS_COMMAND_AVAILABLE_TIMEOUT_MS = 3000, _internals25, build_discovery;
 var init_discovery = __esm(() => {
   init_dist();
   init_detector();
@@ -51736,7 +51820,7 @@ var init_discovery = __esm(() => {
     php: ["php-composer"]
   };
   toolchainCache = new Map;
-  _internals24 = {
+  _internals25 = {
     isCommandAvailable,
     discoverBuildCommandsFromProfiles,
     discoverBuildCommands,
@@ -52015,7 +52099,7 @@ var exports_evidence_summary_service = {};
 __export(exports_evidence_summary_service, {
   isAutoSummaryEnabled: () => isAutoSummaryEnabled,
   buildEvidenceSummary: () => buildEvidenceSummary,
-  _internals: () => _internals25,
+  _internals: () => _internals26,
   REQUIRED_EVIDENCE_TYPES: () => REQUIRED_EVIDENCE_TYPES,
   EVIDENCE_SUMMARY_VERSION: () => EVIDENCE_SUMMARY_VERSION
 });
@@ -52053,7 +52137,7 @@ function getTaskStatus(task, bundle) {
   if (task?.status) {
     return task.status;
   }
-  const entries = _internals25.normalizeBundleEntries(bundle);
+  const entries = _internals26.normalizeBundleEntries(bundle);
   if (entries.length > 0) {
     return "completed";
   }
@@ -52079,7 +52163,7 @@ function evidenceCompleteFromEntries(entries) {
   };
 }
 function isEvidenceComplete(bundle) {
-  return evidenceCompleteFromEntries(_internals25.normalizeBundleEntries(bundle));
+  return evidenceCompleteFromEntries(_internals26.normalizeBundleEntries(bundle));
 }
 function getTaskBlockers(task, summary, status) {
   const blockers = [];
@@ -52099,9 +52183,9 @@ async function buildTaskSummary(directory, task, taskId) {
   const bundle = result.status === "found" ? result.bundle : null;
   const gateEvidence = await readDurableGateEvidence(directory, taskId);
   const phase = task?.phase ?? 0;
-  const status = _internals25.getTaskStatus(task, bundle);
-  const entries = mergeDurableGateEntriesFromEvidence(taskId, _internals25.normalizeBundleEntries(bundle), gateEvidence);
-  let evidenceCheck = _internals25.evidenceCompleteFromEntries(entries);
+  const status = _internals26.getTaskStatus(task, bundle);
+  const entries = mergeDurableGateEntriesFromEvidence(taskId, _internals26.normalizeBundleEntries(bundle), gateEvidence);
+  let evidenceCheck = _internals26.evidenceCompleteFromEntries(entries);
   if (gateEvidence) {
     const gateStatus = getDurableGateEvidenceStatus(gateEvidence);
     evidenceCheck = gateStatus.isComplete ? { isComplete: true, missingEvidence: [] } : {
@@ -52109,7 +52193,7 @@ async function buildTaskSummary(directory, task, taskId) {
       missingEvidence: gateStatus.missingGates.map((gate) => `gate:${gate}`)
     };
   }
-  const blockers = _internals25.getTaskBlockers(task, evidenceCheck, status);
+  const blockers = _internals26.getTaskBlockers(task, evidenceCheck, status);
   const hasReview = entries.some((e) => e.type === "review");
   const hasTest = entries.some((e) => e.type === "test");
   const hasApproval = entries.some((e) => e.type === "approval");
@@ -52138,12 +52222,12 @@ async function buildPhaseSummary(directory, phase) {
   const taskSummaries = [];
   const _taskMap = new Map(phase.tasks.map((t) => [t.id, t]));
   for (const task of phase.tasks) {
-    const summary = await _internals25.buildTaskSummary(directory, task, task.id);
+    const summary = await _internals26.buildTaskSummary(directory, task, task.id);
     taskSummaries.push(summary);
   }
   const extraTaskIds = taskIds.filter((id) => !phaseTaskIds.has(id));
   for (const taskId of extraTaskIds) {
-    const summary = await _internals25.buildTaskSummary(directory, undefined, taskId);
+    const summary = await _internals26.buildTaskSummary(directory, undefined, taskId);
     if (summary.phase === phase.id) {
       taskSummaries.push(summary);
     }
@@ -52244,7 +52328,7 @@ async function buildEvidenceSummary(directory, currentPhase) {
   let totalTasks = 0;
   let completedTasks = 0;
   for (const phase of phasesToProcess) {
-    const summary = await _internals25.buildPhaseSummary(directory, phase);
+    const summary = await _internals26.buildPhaseSummary(directory, phase);
     phaseSummaries.push(summary);
     totalTasks += summary.totalTasks;
     completedTasks += summary.completedTasks;
@@ -52266,7 +52350,7 @@ async function buildEvidenceSummary(directory, currentPhase) {
     overallBlockers,
     summaryText: ""
   };
-  artifact.summaryText = _internals25.generateSummaryText(artifact);
+  artifact.summaryText = _internals26.generateSummaryText(artifact);
   log("[EvidenceSummary] Summary built", {
     phases: phaseSummaries.length,
     totalTasks,
@@ -52285,7 +52369,7 @@ function isAutoSummaryEnabled(automationConfig) {
   }
   return automationConfig.capabilities?.evidence_auto_summaries === true;
 }
-var VALID_EVIDENCE_TYPES2, REQUIRED_EVIDENCE_TYPES, EVIDENCE_SUMMARY_VERSION = "1.0.0", _internals25;
+var VALID_EVIDENCE_TYPES2, REQUIRED_EVIDENCE_TYPES, EVIDENCE_SUMMARY_VERSION = "1.0.0", _internals26;
 var init_evidence_summary_service = __esm(() => {
   init_gate_bridge();
   init_manager2();
@@ -52300,7 +52384,7 @@ var init_evidence_summary_service = __esm(() => {
     "retrospective"
   ]);
   REQUIRED_EVIDENCE_TYPES = ["review", "test"];
-  _internals25 = {
+  _internals26 = {
     buildEvidenceSummary,
     isAutoSummaryEnabled,
     normalizeBundleEntries,
@@ -52356,7 +52440,7 @@ function getVerdictEmoji(verdict) {
   return getVerdictIcon(verdict);
 }
 async function getTaskEvidenceData(directory, taskId) {
-  const result = await _internals26.loadEvidence(directory, taskId);
+  const result = await _internals27.loadEvidence(directory, taskId);
   if (result.status !== "found") {
     return {
       hasEvidence: false,
@@ -52379,13 +52463,13 @@ async function getTaskEvidenceData(directory, taskId) {
   };
 }
 async function getEvidenceListData(directory) {
-  const taskIds = await _internals26.listEvidenceTaskIds(directory);
+  const taskIds = await _internals27.listEvidenceTaskIds(directory);
   if (taskIds.length === 0) {
     return { hasEvidence: false, tasks: [] };
   }
   const tasks = [];
   for (const taskId of taskIds) {
-    const result = await _internals26.loadEvidence(directory, taskId);
+    const result = await _internals27.loadEvidence(directory, taskId);
     if (result.status === "found") {
       tasks.push({
         taskId,
@@ -52499,10 +52583,10 @@ async function handleEvidenceSummaryCommand(directory) {
   return lines.join(`
 `);
 }
-var _internals26;
+var _internals27;
 var init_evidence_service = __esm(() => {
   init_manager2();
-  _internals26 = {
+  _internals27 = {
     loadEvidence,
     listEvidenceTaskIds
   };
@@ -52553,12 +52637,12 @@ var init_export = __esm(() => {
 
 // src/full-auto/state.ts
 import * as fs16 from "fs";
-import * as path40 from "path";
+import * as path41 from "path";
 function nowISO() {
   return new Date().toISOString();
 }
 function ensureSwarmDir(directory) {
-  const swarmDir = path40.resolve(directory, ".swarm");
+  const swarmDir = path41.resolve(directory, ".swarm");
   if (!fs16.existsSync(swarmDir)) {
     fs16.mkdirSync(swarmDir, { recursive: true });
   }
@@ -53030,7 +53114,7 @@ function extractCurrentPhaseFromPlan2(plan) {
   if (!plan) {
     return { currentPhase: null, currentTask: null, incompleteTasks: [] };
   }
-  if (!_internals27.validatePlanPhases(plan)) {
+  if (!_internals28.validatePlanPhases(plan)) {
     return { currentPhase: null, currentTask: null, incompleteTasks: [] };
   }
   let currentPhase = null;
@@ -53172,9 +53256,9 @@ function extractPhaseMetrics(content) {
 async function getHandoffData(directory) {
   const now = new Date().toISOString();
   const sessionContent = await readSwarmFileAsync(directory, "session/state.json");
-  const sessionState = _internals27.parseSessionState(sessionContent);
+  const sessionState = _internals28.parseSessionState(sessionContent);
   const plan = await loadPlanJsonOnly(directory);
-  const planInfo = _internals27.extractCurrentPhaseFromPlan(plan);
+  const planInfo = _internals28.extractCurrentPhaseFromPlan(plan);
   if (!plan) {
     const planMdContent = await readSwarmFileAsync(directory, "plan.md");
     if (planMdContent) {
@@ -53193,8 +53277,8 @@ async function getHandoffData(directory) {
     }
   }
   const contextContent = await readSwarmFileAsync(directory, "context.md");
-  const recentDecisions = _internals27.extractDecisions(contextContent);
-  const rawPhaseMetrics = _internals27.extractPhaseMetrics(contextContent);
+  const recentDecisions = _internals28.extractDecisions(contextContent);
+  const rawPhaseMetrics = _internals28.extractPhaseMetrics(contextContent);
   const phaseMetrics = sanitizeString(rawPhaseMetrics, 1000);
   let delegationState = null;
   if (sessionState?.delegationState) {
@@ -53358,13 +53442,13 @@ ${lines.join(`
 `)}
 \`\`\``;
 }
-var RTL_OVERRIDE_PATTERN, MAX_TASK_ID_LENGTH = 100, MAX_DECISION_LENGTH = 500, MAX_INCOMPLETE_TASKS = 20, _internals27;
+var RTL_OVERRIDE_PATTERN, MAX_TASK_ID_LENGTH = 100, MAX_DECISION_LENGTH = 500, MAX_INCOMPLETE_TASKS = 20, _internals28;
 var init_handoff_service = __esm(() => {
   init_utils2();
   init_manager();
   init_utils();
   RTL_OVERRIDE_PATTERN = /[\u202e\u202d\u202c\u200f]/g;
-  _internals27 = {
+  _internals28 = {
     getHandoffData,
     formatHandoffMarkdown,
     formatContinuationPrompt,
@@ -53380,7 +53464,7 @@ var init_handoff_service = __esm(() => {
 
 // src/session/snapshot-writer.ts
 import { closeSync as closeSync5, fsyncSync as fsyncSync2, mkdirSync as mkdirSync14, openSync as openSync5, renameSync as renameSync10 } from "fs";
-import * as path41 from "path";
+import * as path42 from "path";
 function serializeAgentSession(s) {
   const gateLog = {};
   const rawGateLog = s.gateLog ?? new Map;
@@ -53486,7 +53570,7 @@ async function writeSnapshot(directory, state) {
     }
     const content = JSON.stringify(snapshot, null, 2);
     const resolvedPath = validateSwarmPath(directory, "session/state.json");
-    const dir = path41.dirname(resolvedPath);
+    const dir = path42.dirname(resolvedPath);
     mkdirSync14(dir, { recursive: true });
     const tempPath = `${resolvedPath}.tmp.${Date.now()}.${Math.random().toString(36).slice(2)}`;
     await bunWrite(tempPath, content);
@@ -53507,22 +53591,22 @@ async function writeSnapshot(directory, state) {
 }
 function createSnapshotWriterHook(directory) {
   return (_input, _output) => {
-    _writeInFlight = _writeInFlight.then(() => _internals28.writeSnapshot(directory, swarmState), () => _internals28.writeSnapshot(directory, swarmState));
+    _writeInFlight = _writeInFlight.then(() => _internals29.writeSnapshot(directory, swarmState), () => _internals29.writeSnapshot(directory, swarmState));
     return _writeInFlight;
   };
 }
 async function flushPendingSnapshot(directory) {
-  _writeInFlight = _writeInFlight.then(() => _internals28.writeSnapshot(directory, swarmState), () => _internals28.writeSnapshot(directory, swarmState));
+  _writeInFlight = _writeInFlight.then(() => _internals29.writeSnapshot(directory, swarmState), () => _internals29.writeSnapshot(directory, swarmState));
   await _writeInFlight;
 }
-var _writeInFlight, _internals28;
+var _writeInFlight, _internals29;
 var init_snapshot_writer = __esm(() => {
   init_utils2();
   init_state();
   init_utils();
   init_bun_compat();
   _writeInFlight = Promise.resolve();
-  _internals28 = {
+  _internals29 = {
     writeSnapshot,
     createSnapshotWriterHook,
     flushPendingSnapshot
@@ -53842,7 +53926,7 @@ function validateAndSanitizeGithubUrl(rawUrl, resource) {
 }
 function detectGitRemote(cwd) {
   try {
-    const result = _internals29.spawnSync("git", ["remote", "get-url", "origin"], {
+    const result = _internals30.spawnSync("git", ["remote", "get-url", "origin"], {
       encoding: "utf-8",
       stdio: ["ignore", "pipe", "pipe"],
       timeout: 5000,
@@ -53887,7 +53971,7 @@ function parseGitRemoteUrl(remoteUrl) {
   }
   return null;
 }
-var MAX_URL_LEN = 2048, IPV4_PRIVATE, IPV4_LOOPBACK, IPV4_LINK_LOCAL, IPV4_PRIVATE_172, IPV4_PRIVATE_192, IPV4_ZERO_NETWORK, IPV6_LINK_LOCAL, IPV6_UNIQUE_LOCAL, _internals29;
+var MAX_URL_LEN = 2048, IPV4_PRIVATE, IPV4_LOOPBACK, IPV4_LINK_LOCAL, IPV4_PRIVATE_172, IPV4_PRIVATE_192, IPV4_ZERO_NETWORK, IPV6_LINK_LOCAL, IPV6_UNIQUE_LOCAL, _internals30;
 var init_url_security = __esm(() => {
   IPV4_PRIVATE = /^10\./;
   IPV4_LOOPBACK = /^127\./;
@@ -53897,7 +53981,7 @@ var init_url_security = __esm(() => {
   IPV4_ZERO_NETWORK = /^0\./;
   IPV6_LINK_LOCAL = /^fe80:/i;
   IPV6_UNIQUE_LOCAL = /^f[cd][0-9a-f]{2}:/i;
-  _internals29 = { spawnSync: spawnSync3 };
+  _internals30 = { spawnSync: spawnSync3 };
 });
 
 // src/commands/issue.ts
@@ -54029,7 +54113,7 @@ import { randomUUID as randomUUID3 } from "crypto";
 import { existsSync as existsSync27, readFileSync as readFileSync16 } from "fs";
 import { mkdir as mkdir15, readFile as readFile15, writeFile as writeFile13 } from "fs/promises";
 import * as os8 from "os";
-import * as path42 from "path";
+import * as path43 from "path";
 async function migrateKnowledgeToExternal(_directory, _config) {
   return {
     migrated: false,
@@ -54040,8 +54124,8 @@ async function migrateKnowledgeToExternal(_directory, _config) {
   };
 }
 async function migrateContextToKnowledge(directory, config3) {
-  const sentinelPath = path42.join(directory, ".swarm", ".knowledge-migrated");
-  const contextPath = path42.join(directory, ".swarm", "context.md");
+  const sentinelPath = path43.join(directory, ".swarm", ".knowledge-migrated");
+  const contextPath = path43.join(directory, ".swarm", "context.md");
   const knowledgePath = resolveSwarmKnowledgePath(directory);
   if (existsSync27(sentinelPath)) {
     return {
@@ -54071,9 +54155,9 @@ async function migrateContextToKnowledge(directory, config3) {
       skippedReason: "empty-context"
     };
   }
-  const rawEntries = _internals30.parseContextMd(contextContent);
+  const rawEntries = _internals31.parseContextMd(contextContent);
   if (rawEntries.length === 0) {
-    await _internals30.writeSentinel(sentinelPath, 0, 0);
+    await _internals31.writeSentinel(sentinelPath, 0, 0);
     return {
       migrated: true,
       entriesMigrated: 0,
@@ -54084,10 +54168,10 @@ async function migrateContextToKnowledge(directory, config3) {
   const existing = await readKnowledge(knowledgePath);
   let migrated = 0;
   let dropped = 0;
-  const projectName = _internals30.inferProjectName(directory);
+  const projectName = _internals31.inferProjectName(directory);
   for (const raw of rawEntries) {
     if (config3.validation_enabled !== false) {
-      const category = raw.categoryHint ?? _internals30.inferCategoryFromText(raw.text);
+      const category = raw.categoryHint ?? _internals31.inferCategoryFromText(raw.text);
       const result = validateLesson(raw.text, existing.map((e) => e.lesson), {
         category,
         scope: "global",
@@ -54107,8 +54191,8 @@ async function migrateContextToKnowledge(directory, config3) {
     const entry = {
       id: randomUUID3(),
       tier: "swarm",
-      lesson: _internals30.truncateLesson(raw.text),
-      category: raw.categoryHint ?? _internals30.inferCategoryFromText(raw.text),
+      lesson: _internals31.truncateLesson(raw.text),
+      category: raw.categoryHint ?? _internals31.inferCategoryFromText(raw.text),
       tags: [...inferredTags, `migration:${raw.sourceSection}`],
       scope: "global",
       confidence: 0.3,
@@ -54131,7 +54215,7 @@ async function migrateContextToKnowledge(directory, config3) {
   if (migrated > 0) {
     await rewriteKnowledge(knowledgePath, existing);
   }
-  await _internals30.writeSentinel(sentinelPath, migrated, dropped);
+  await _internals31.writeSentinel(sentinelPath, migrated, dropped);
   log(`[knowledge-migrator] Migrated ${migrated} entries, dropped ${dropped}`);
   return {
     migrated: true,
@@ -54141,9 +54225,9 @@ async function migrateContextToKnowledge(directory, config3) {
   };
 }
 async function migrateHiveKnowledgeLegacy(config3) {
-  const legacyHivePath = _internals30.resolveLegacyHiveKnowledgePath();
+  const legacyHivePath = _internals31.resolveLegacyHiveKnowledgePath();
   const canonicalHivePath = resolveHiveKnowledgePath();
-  const sentinelPath = path42.join(path42.dirname(canonicalHivePath), ".hive-knowledge-migrated");
+  const sentinelPath = path43.join(path43.dirname(canonicalHivePath), ".hive-knowledge-migrated");
   if (existsSync27(sentinelPath)) {
     return {
       migrated: false,
@@ -54164,7 +54248,7 @@ async function migrateHiveKnowledgeLegacy(config3) {
   }
   const legacyEntries = await readKnowledge(legacyHivePath);
   if (legacyEntries.length === 0) {
-    await _internals30.writeSentinel(sentinelPath, 0, 0);
+    await _internals31.writeSentinel(sentinelPath, 0, 0);
     return {
       migrated: true,
       entriesMigrated: 0,
@@ -54212,7 +54296,7 @@ async function migrateHiveKnowledgeLegacy(config3) {
       const newHiveEntry = {
         id: resolvedId,
         tier: "hive",
-        lesson: _internals30.truncateLesson(lesson),
+        lesson: _internals31.truncateLesson(lesson),
         category,
         tags: ["migration:legacy-hive"],
         scope: scopeTag,
@@ -54231,7 +54315,7 @@ async function migrateHiveKnowledgeLegacy(config3) {
         encounter_score: 1
       };
       try {
-        await _internals30.appendKnowledge(canonicalHivePath, newHiveEntry);
+        await _internals31.appendKnowledge(canonicalHivePath, newHiveEntry);
         existingHiveEntries.push(newHiveEntry);
         migrated++;
       } catch (appendError) {
@@ -54247,7 +54331,7 @@ async function migrateHiveKnowledgeLegacy(config3) {
       dropped++;
     }
   }
-  await _internals30.writeSentinel(sentinelPath, migrated, dropped);
+  await _internals31.writeSentinel(sentinelPath, migrated, dropped);
   log(`[knowledge-migrator] Migrated ${migrated} legacy hive entries, dropped ${dropped}`);
   return {
     migrated: true,
@@ -54258,7 +54342,7 @@ async function migrateHiveKnowledgeLegacy(config3) {
   };
 }
 function parseContextMd(content) {
-  const sections = _internals30.splitIntoSections(content);
+  const sections = _internals31.splitIntoSections(content);
   const entries = [];
   const seen = new Set;
   const sectionPatterns = [
@@ -54274,7 +54358,7 @@ function parseContextMd(content) {
     const match = sectionPatterns.find((sp) => sp.pattern.test(section.heading));
     if (!match)
       continue;
-    const bullets = _internals30.extractBullets(section.body);
+    const bullets = _internals31.extractBullets(section.body);
     for (const bullet of bullets) {
       if (bullet.length < 15)
         continue;
@@ -54283,9 +54367,9 @@ function parseContextMd(content) {
         continue;
       seen.add(normalized);
       entries.push({
-        text: _internals30.truncateLesson(bullet),
+        text: _internals31.truncateLesson(bullet),
         sourceSection: match.sourceSection,
-        categoryHint: _internals30.inferCategoryFromText(bullet)
+        categoryHint: _internals31.inferCategoryFromText(bullet)
       });
     }
   }
@@ -54354,7 +54438,7 @@ function truncateLesson2(text) {
   return `${text.slice(0, 277)}...`;
 }
 function inferProjectName(directory) {
-  const packageJsonPath = path42.join(directory, "package.json");
+  const packageJsonPath = path43.join(directory, "package.json");
   if (existsSync27(packageJsonPath)) {
     try {
       const pkg = JSON.parse(readFileSync16(packageJsonPath, "utf-8"));
@@ -54363,7 +54447,7 @@ function inferProjectName(directory) {
       }
     } catch {}
   }
-  return path42.basename(directory);
+  return path43.basename(directory);
 }
 async function writeSentinel(sentinelPath, migrated, dropped) {
   const sentinel = {
@@ -54375,7 +54459,7 @@ async function writeSentinel(sentinelPath, migrated, dropped) {
     schema_version: 1,
     migration_tool: "knowledge-migrator.ts"
   };
-  await mkdir15(path42.dirname(sentinelPath), { recursive: true });
+  await mkdir15(path43.dirname(sentinelPath), { recursive: true });
   await writeFile13(sentinelPath, JSON.stringify(sentinel, null, 2), "utf-8");
 }
 function resolveLegacyHiveKnowledgePath() {
@@ -54383,20 +54467,20 @@ function resolveLegacyHiveKnowledgePath() {
   const home = process.env.HOME || os8.homedir();
   let dataDir;
   if (platform === "win32") {
-    dataDir = path42.join(process.env.LOCALAPPDATA || path42.join(home, "AppData", "Local"), "opencode-swarm", "Data");
+    dataDir = path43.join(process.env.LOCALAPPDATA || path43.join(home, "AppData", "Local"), "opencode-swarm", "Data");
   } else if (platform === "darwin") {
-    dataDir = path42.join(home, "Library", "Application Support", "opencode-swarm");
+    dataDir = path43.join(home, "Library", "Application Support", "opencode-swarm");
   } else {
-    dataDir = path42.join(process.env.XDG_DATA_HOME || path42.join(home, ".local", "share"), "opencode-swarm");
+    dataDir = path43.join(process.env.XDG_DATA_HOME || path43.join(home, ".local", "share"), "opencode-swarm");
   }
-  return path42.join(dataDir, "hive-knowledge.jsonl");
+  return path43.join(dataDir, "hive-knowledge.jsonl");
 }
-var _internals30;
+var _internals31;
 var init_knowledge_migrator = __esm(() => {
   init_logger();
   init_knowledge_store();
   init_knowledge_validator();
-  _internals30 = {
+  _internals31 = {
     appendKnowledge,
     migrateContextToKnowledge,
     migrateKnowledgeToExternal,
@@ -55571,7 +55655,7 @@ import {
   rename as rename9,
   writeFile as writeFile14
 } from "fs/promises";
-import * as path43 from "path";
+import * as path44 from "path";
 
 class LocalJsonlMemoryProvider {
   name = "local-jsonl";
@@ -55587,7 +55671,7 @@ class LocalJsonlMemoryProvider {
   pathFor(file3) {
     const storageDir = this.config.storageDir.replace(/^\.swarm[/\\]?/, "");
     const filename = file3 === "memories" ? "memories.jsonl" : file3 === "proposals" ? "proposals.jsonl" : "audit.jsonl";
-    return validateSwarmPath(this.rootDirectory, path43.join(storageDir, filename));
+    return validateSwarmPath(this.rootDirectory, path44.join(storageDir, filename));
   }
   async initialize() {
     if (this.initialized)
@@ -55970,12 +56054,12 @@ function parseRecallUsageEvent(event) {
   }
 }
 async function appendJsonl(filePath, value) {
-  await mkdir16(path43.dirname(filePath), { recursive: true });
+  await mkdir16(path44.dirname(filePath), { recursive: true });
   await appendFile7(filePath, `${JSON.stringify(value)}
 `, "utf-8");
 }
 async function writeJsonlAtomic(filePath, values) {
-  await mkdir16(path43.dirname(filePath), { recursive: true });
+  await mkdir16(path44.dirname(filePath), { recursive: true });
   const tmp = `${filePath}.tmp.${randomUUID4()}`;
   const content = values.map((value) => JSON.stringify(value)).join(`
 `) + (values.length > 0 ? `
@@ -56002,7 +56086,7 @@ var init_prompt_block = __esm(() => {
 // src/memory/jsonl-migration.ts
 import { existsSync as existsSync29 } from "fs";
 import { copyFile as copyFile2, mkdir as mkdir17, readFile as readFile17, stat as stat8, writeFile as writeFile15 } from "fs/promises";
-import * as path44 from "path";
+import * as path45 from "path";
 function resolveMemoryStorageDir(rootDirectory, config3 = {}) {
   const resolved = resolveConfig(config3);
   const storageDir = resolved.storageDir.replace(/^\.swarm[/\\]?/, "");
@@ -56016,8 +56100,8 @@ function resolveSqliteDatabasePath(rootDirectory, config3 = {}) {
 async function readLegacyJsonl(rootDirectory, config3 = {}) {
   const resolved = resolveConfig(config3);
   const storageDir = resolveMemoryStorageDir(rootDirectory, resolved);
-  const memoryLoad = await readMemoryJsonl(path44.join(storageDir, "memories.jsonl"), resolved);
-  const proposalLoad = await readProposalJsonl(path44.join(storageDir, "proposals.jsonl"), resolved);
+  const memoryLoad = await readMemoryJsonl(path45.join(storageDir, "memories.jsonl"), resolved);
+  const proposalLoad = await readProposalJsonl(path45.join(storageDir, "proposals.jsonl"), resolved);
   return {
     memories: memoryLoad.records,
     proposals: proposalLoad.records,
@@ -56027,14 +56111,14 @@ async function readLegacyJsonl(rootDirectory, config3 = {}) {
 }
 async function backupLegacyJsonl(rootDirectory, config3 = {}) {
   const storageDir = resolveMemoryStorageDir(rootDirectory, config3);
-  const backupDir = path44.join(storageDir, "backups");
+  const backupDir = path45.join(storageDir, "backups");
   await mkdir17(backupDir, { recursive: true });
   const results = [];
   for (const filename of ["memories.jsonl", "proposals.jsonl"]) {
-    const source = path44.join(storageDir, filename);
+    const source = path45.join(storageDir, filename);
     if (!existsSync29(source))
       continue;
-    const backup = path44.join(backupDir, `${filename}.pre-sqlite-migration`);
+    const backup = path45.join(backupDir, `${filename}.pre-sqlite-migration`);
     if (existsSync29(backup)) {
       results.push({ source, backup, created: false });
       continue;
@@ -56045,23 +56129,23 @@ async function backupLegacyJsonl(rootDirectory, config3 = {}) {
   return results;
 }
 async function writeJsonlExport(rootDirectory, config3, memories, proposals) {
-  const exportDir = path44.join(resolveMemoryStorageDir(rootDirectory, config3), "export");
+  const exportDir = path45.join(resolveMemoryStorageDir(rootDirectory, config3), "export");
   await mkdir17(exportDir, { recursive: true });
-  const memoriesPath = path44.join(exportDir, "memories.jsonl");
-  const proposalsPath = path44.join(exportDir, "proposals.jsonl");
+  const memoriesPath = path45.join(exportDir, "memories.jsonl");
+  const proposalsPath = path45.join(exportDir, "proposals.jsonl");
   await writeFile15(memoriesPath, toJsonl(memories), "utf-8");
   await writeFile15(proposalsPath, toJsonl(proposals), "utf-8");
   return { directory: exportDir, memoriesPath, proposalsPath };
 }
 async function writeMigrationReport(rootDirectory, report, config3 = {}) {
-  const reportPath = path44.join(resolveMemoryStorageDir(rootDirectory, config3), "migration-report.json");
-  await mkdir17(path44.dirname(reportPath), { recursive: true });
+  const reportPath = path45.join(resolveMemoryStorageDir(rootDirectory, config3), "migration-report.json");
+  await mkdir17(path45.dirname(reportPath), { recursive: true });
   await writeFile15(reportPath, `${JSON.stringify(report, null, 2)}
 `, "utf-8");
   return reportPath;
 }
 async function readMigrationReport(rootDirectory, config3 = {}) {
-  const reportPath = path44.join(resolveMemoryStorageDir(rootDirectory, config3), "migration-report.json");
+  const reportPath = path45.join(resolveMemoryStorageDir(rootDirectory, config3), "migration-report.json");
   if (!existsSync29(reportPath))
     return null;
   try {
@@ -56074,7 +56158,7 @@ async function getLegacyJsonlFileStatus(rootDirectory, config3 = {}) {
   const storageDir = resolveMemoryStorageDir(rootDirectory, config3);
   const statuses = [];
   for (const file3 of ["memories.jsonl", "proposals.jsonl"]) {
-    const filePath = path44.join(storageDir, file3);
+    const filePath = path45.join(storageDir, file3);
     let sizeBytes = 0;
     if (existsSync29(filePath)) {
       sizeBytes = (await stat8(filePath)).size;
@@ -56203,7 +56287,7 @@ var init_jsonl_migration = __esm(() => {
 import { randomUUID as randomUUID5 } from "crypto";
 import { mkdirSync as mkdirSync15 } from "fs";
 import { createRequire as createRequire2 } from "module";
-import * as path45 from "path";
+import * as path46 from "path";
 function loadDatabaseCtor2() {
   if (_DatabaseCtor2)
     return _DatabaseCtor2;
@@ -56261,7 +56345,7 @@ class SQLiteMemoryProvider {
     if (this.initialized)
       return;
     const dbPath = this.databasePath();
-    mkdirSync15(path45.dirname(dbPath), { recursive: true });
+    mkdirSync15(path46.dirname(dbPath), { recursive: true });
     const Db = loadDatabaseCtor2();
     this.db = new Db(dbPath);
     this.db.run("PRAGMA journal_mode = WAL;");
@@ -57147,9 +57231,9 @@ var init_gateway = __esm(() => {
 // src/memory/evaluation.ts
 import * as fs17 from "fs/promises";
 import * as os9 from "os";
-import * as path46 from "path";
+import * as path47 from "path";
 async function evaluateMemoryRecallFixtures(options) {
-  const fixtureDirectory = path46.resolve(options.fixtureDirectory);
+  const fixtureDirectory = path47.resolve(options.fixtureDirectory);
   const providers = options.providers ?? DEFAULT_PROVIDERS;
   const modes = options.modes ?? DEFAULT_MODES;
   const generatedAt = new Date().toISOString();
@@ -57158,7 +57242,7 @@ async function evaluateMemoryRecallFixtures(options) {
   for (const fixture of fixtures) {
     const materialized = materializeFixture(fixture);
     for (const providerName of providers) {
-      const tempRoot = await fs17.realpath(await fs17.mkdtemp(path46.join(os9.tmpdir(), "swarm-memory-eval-")));
+      const tempRoot = await fs17.realpath(await fs17.mkdtemp(path47.join(os9.tmpdir(), "swarm-memory-eval-")));
       const provider = createEvaluationProvider(providerName, tempRoot);
       try {
         await provider.initialize?.();
@@ -57202,7 +57286,7 @@ async function loadRecallEvaluationFixtures(fixtureDirectory) {
   const files = entries.filter((entry) => entry.isFile() && entry.name.endsWith(".json")).map((entry) => entry.name).sort((a, b) => a.localeCompare(b));
   const fixtures = [];
   for (const file3 of files) {
-    const raw = await fs17.readFile(path46.join(fixtureDirectory, file3), "utf-8");
+    const raw = await fs17.readFile(path47.join(fixtureDirectory, file3), "utf-8");
     fixtures.push(validateFixture(JSON.parse(raw), file3));
   }
   return fixtures;
@@ -57541,7 +57625,7 @@ var init_memory = __esm(() => {
 
 // src/commands/memory.ts
 import { existsSync as existsSync30 } from "fs";
-import * as path47 from "path";
+import * as path48 from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 async function handleMemoryCommand(_directory, _args) {
   return [
@@ -57811,7 +57895,7 @@ function resolveCommandMemoryConfig(directory) {
 }
 function parseEvaluateArgs(directory, args) {
   let json3 = false;
-  let fixtureDirectory = path47.join(PACKAGE_ROOT, "tests", "fixtures", "memory-recall");
+  let fixtureDirectory = path48.join(PACKAGE_ROOT, "tests", "fixtures", "memory-recall");
   for (let i = 0;i < args.length; i++) {
     const arg = args[i];
     if (arg === "--json") {
@@ -57825,7 +57909,7 @@ function parseEvaluateArgs(directory, args) {
           error: "Usage: /swarm memory evaluate [--json] [--fixtures <directory>]"
         };
       }
-      fixtureDirectory = path47.resolve(directory, next);
+      fixtureDirectory = path48.resolve(directory, next);
       i++;
       continue;
     }
@@ -57858,15 +57942,15 @@ function parseMaintenanceArgs(args, options) {
   return { limit, confirm };
 }
 function resolvePackageRootFromModule(modulePath) {
-  const moduleDir = path47.dirname(modulePath);
-  const leaf = path47.basename(moduleDir);
+  const moduleDir = path48.dirname(modulePath);
+  const leaf = path48.basename(moduleDir);
   if (leaf === "commands" || leaf === "cli") {
-    return path47.resolve(moduleDir, "..", "..");
+    return path48.resolve(moduleDir, "..", "..");
   }
   if (leaf === "dist") {
-    return path47.resolve(moduleDir, "..");
+    return path48.resolve(moduleDir, "..");
   }
-  return path47.resolve(moduleDir, "..");
+  return path48.resolve(moduleDir, "..");
 }
 function formatMigrationResult(label, report) {
   if (!report) {
@@ -57985,14 +58069,14 @@ var PACKAGE_ROOT;
 var init_memory2 = __esm(() => {
   init_loader();
   init_memory();
-  PACKAGE_ROOT = path47.resolve(resolvePackageRootFromModule(fileURLToPath2(import.meta.url)));
+  PACKAGE_ROOT = path48.resolve(resolvePackageRootFromModule(fileURLToPath2(import.meta.url)));
 });
 
 // src/services/plan-service.ts
 async function getPlanData(directory, phaseArg) {
-  const plan = await _internals31.loadPlanJsonOnly(directory);
+  const plan = await _internals32.loadPlanJsonOnly(directory);
   if (plan) {
-    const fullMarkdown = _internals31.derivePlanMarkdown(plan);
+    const fullMarkdown = _internals32.derivePlanMarkdown(plan);
     if (phaseArg === undefined || phaseArg === null || phaseArg === "") {
       return {
         hasPlan: true,
@@ -58035,7 +58119,7 @@ async function getPlanData(directory, phaseArg) {
       isLegacy: false
     };
   }
-  const planContent = await _internals31.readSwarmFileAsync(directory, "plan.md");
+  const planContent = await _internals32.readSwarmFileAsync(directory, "plan.md");
   if (!planContent) {
     return {
       hasPlan: false,
@@ -58131,11 +58215,11 @@ async function handlePlanCommand(directory, args) {
   const planData = await getPlanData(directory, phaseArg);
   return formatPlanMarkdown(planData);
 }
-var _internals31;
+var _internals32;
 var init_plan_service = __esm(() => {
   init_utils2();
   init_manager();
-  _internals31 = {
+  _internals32 = {
     loadPlanJsonOnly,
     derivePlanMarkdown,
     readSwarmFileAsync
@@ -58307,12 +58391,12 @@ var init_pr_feedback = __esm(() => {
 
 // src/background/pr-subscriptions.ts
 import * as fs18 from "fs";
-import * as path48 from "path";
+import * as path49 from "path";
 function storePath(directory) {
   return validateSwarmPath(directory, PR_SUBSCRIPTIONS_FILE);
 }
 function ensureSwarmDir2(directory) {
-  fs18.mkdirSync(path48.resolve(directory, ".swarm", "pr-monitor"), {
+  fs18.mkdirSync(path49.resolve(directory, ".swarm", "pr-monitor"), {
     recursive: true
   });
 }
@@ -58478,7 +58562,7 @@ function formatRelativeTime(epochMs) {
   return `${diffDays} day${diffDays === 1 ? "" : "s"} ago`;
 }
 async function handlePrMonitorStatusCommand(directory, _args, sessionID) {
-  const allActive = await _internals32.listActive(directory);
+  const allActive = await _internals33.listActive(directory);
   const sessionSubs = allActive.filter((record3) => record3.sessionID === sessionID);
   if (sessionSubs.length === 0) {
     return "No active PR subscriptions for this session.";
@@ -58507,10 +58591,10 @@ async function handlePrMonitorStatusCommand(directory, _args, sessionID) {
   return lines.join(`
 `);
 }
-var _internals32;
+var _internals33;
 var init_pr_monitor_status = __esm(() => {
   init_pr_subscriptions();
-  _internals32 = {
+  _internals33 = {
     formatRelativeTime,
     listActive
   };
@@ -58615,7 +58699,7 @@ async function handlePrSubscribeCommand(directory, args, sessionID) {
   const repoFullName = `${prInfo.owner}/${prInfo.repo}`;
   const prUrl = `https://github.com/${prInfo.owner}/${prInfo.repo}/pull/${prInfo.number}`;
   try {
-    const config3 = _internals33.loadPluginConfig(directory);
+    const config3 = _internals34.loadPluginConfig(directory);
     const prMonitorConfig = config3.pr_monitor;
     if (!prMonitorConfig?.enabled) {
       return [
@@ -58625,7 +58709,7 @@ async function handlePrSubscribeCommand(directory, args, sessionID) {
       ].join(`
 `);
     }
-    await _internals33.subscribe(directory, {
+    await _internals34.subscribe(directory, {
       sessionID,
       prNumber: prInfo.number,
       repoFullName,
@@ -58649,12 +58733,12 @@ async function handlePrSubscribeCommand(directory, args, sessionID) {
 `);
   }
 }
-var _internals33;
+var _internals34;
 var init_pr_subscribe = __esm(() => {
   init_pr_subscriptions();
   init_loader();
   init_pr_ref();
-  _internals33 = {
+  _internals34 = {
     loadPluginConfig,
     subscribe
   };
@@ -58678,9 +58762,9 @@ async function handlePrUnsubscribeCommand(directory, args, sessionID) {
 `);
   }
   const refToken = rest[0];
-  const prInfo = _internals34.parsePrRef(refToken, directory);
+  const prInfo = _internals35.parsePrRef(refToken, directory);
   if (!prInfo) {
-    if (_internals34.looksLikePrRef(refToken)) {
+    if (_internals35.looksLikePrRef(refToken)) {
       return [
         `Error: Could not resolve PR reference from "${refToken}".`,
         "",
@@ -58701,8 +58785,8 @@ async function handlePrUnsubscribeCommand(directory, args, sessionID) {
   const repoFullName = `${prInfo.owner}/${prInfo.repo}`;
   const prUrl = `https://github.com/${prInfo.owner}/${prInfo.repo}/pull/${prInfo.number}`;
   try {
-    const correlationId = _internals34.buildCorrelationId(sessionID, repoFullName, prInfo.number);
-    const result = await _internals34.unsubscribe(directory, correlationId);
+    const correlationId = _internals35.buildCorrelationId(sessionID, repoFullName, prInfo.number);
+    const result = await _internals35.unsubscribe(directory, correlationId);
     if (!result) {
       return [
         `Not subscribed to ${prUrl}`,
@@ -58729,11 +58813,11 @@ async function handlePrUnsubscribeCommand(directory, args, sessionID) {
 `);
   }
 }
-var _internals34;
+var _internals35;
 var init_pr_unsubscribe = __esm(() => {
   init_pr_subscriptions();
   init_pr_ref();
-  _internals34 = {
+  _internals35 = {
     unsubscribe,
     buildCorrelationId,
     parsePrRef,
@@ -58785,7 +58869,7 @@ var init_path_security = () => {};
 
 // src/tools/lint.ts
 import * as fs19 from "fs";
-import * as path49 from "path";
+import * as path50 from "path";
 function validateArgs(args) {
   if (typeof args !== "object" || args === null)
     return false;
@@ -58796,9 +58880,9 @@ function validateArgs(args) {
 }
 function getLinterCommand(linter, mode, projectDir) {
   const isWindows = process.platform === "win32";
-  const binDir = path49.join(projectDir, "node_modules", ".bin");
-  const biomeBin = isWindows ? path49.join(binDir, "biome.EXE") : path49.join(binDir, "biome");
-  const eslintBin = isWindows ? path49.join(binDir, "eslint.cmd") : path49.join(binDir, "eslint");
+  const binDir = path50.join(projectDir, "node_modules", ".bin");
+  const biomeBin = isWindows ? path50.join(binDir, "biome.EXE") : path50.join(binDir, "biome");
+  const eslintBin = isWindows ? path50.join(binDir, "eslint.cmd") : path50.join(binDir, "eslint");
   switch (linter) {
     case "biome":
       if (mode === "fix") {
@@ -58814,7 +58898,7 @@ function getLinterCommand(linter, mode, projectDir) {
 }
 function getAdditionalLinterCommand(linter, mode, cwd) {
   const gradlewName = process.platform === "win32" ? "gradlew.bat" : "gradlew";
-  const gradlew = fs19.existsSync(path49.join(cwd, gradlewName)) ? path49.join(cwd, gradlewName) : null;
+  const gradlew = fs19.existsSync(path50.join(cwd, gradlewName)) ? path50.join(cwd, gradlewName) : null;
   switch (linter) {
     case "ruff":
       return mode === "fix" ? ["ruff", "check", "--fix", "."] : ["ruff", "check", "."];
@@ -58848,10 +58932,10 @@ function getAdditionalLinterCommand(linter, mode, cwd) {
   }
 }
 function detectRuff(cwd) {
-  if (fs19.existsSync(path49.join(cwd, "ruff.toml")))
+  if (fs19.existsSync(path50.join(cwd, "ruff.toml")))
     return isCommandAvailable("ruff");
   try {
-    const pyproject = path49.join(cwd, "pyproject.toml");
+    const pyproject = path50.join(cwd, "pyproject.toml");
     if (fs19.existsSync(pyproject)) {
       const content = fs19.readFileSync(pyproject, "utf-8");
       if (content.includes("[tool.ruff]"))
@@ -58861,19 +58945,19 @@ function detectRuff(cwd) {
   return false;
 }
 function detectClippy(cwd) {
-  return fs19.existsSync(path49.join(cwd, "Cargo.toml")) && isCommandAvailable("cargo");
+  return fs19.existsSync(path50.join(cwd, "Cargo.toml")) && isCommandAvailable("cargo");
 }
 function detectGolangciLint(cwd) {
-  return fs19.existsSync(path49.join(cwd, "go.mod")) && isCommandAvailable("golangci-lint");
+  return fs19.existsSync(path50.join(cwd, "go.mod")) && isCommandAvailable("golangci-lint");
 }
 function detectCheckstyle(cwd) {
-  const hasMaven = fs19.existsSync(path49.join(cwd, "pom.xml"));
-  const hasGradle = fs19.existsSync(path49.join(cwd, "build.gradle")) || fs19.existsSync(path49.join(cwd, "build.gradle.kts"));
-  const hasBinary = hasMaven && isCommandAvailable("mvn") || hasGradle && (fs19.existsSync(path49.join(cwd, "gradlew")) || isCommandAvailable("gradle"));
+  const hasMaven = fs19.existsSync(path50.join(cwd, "pom.xml"));
+  const hasGradle = fs19.existsSync(path50.join(cwd, "build.gradle")) || fs19.existsSync(path50.join(cwd, "build.gradle.kts"));
+  const hasBinary = hasMaven && isCommandAvailable("mvn") || hasGradle && (fs19.existsSync(path50.join(cwd, "gradlew")) || isCommandAvailable("gradle"));
   return (hasMaven || hasGradle) && hasBinary;
 }
 function detectKtlint(cwd) {
-  const hasKotlin = fs19.existsSync(path49.join(cwd, "build.gradle.kts")) || fs19.existsSync(path49.join(cwd, "build.gradle")) || (() => {
+  const hasKotlin = fs19.existsSync(path50.join(cwd, "build.gradle.kts")) || fs19.existsSync(path50.join(cwd, "build.gradle")) || (() => {
     try {
       return fs19.readdirSync(cwd).some((f) => f.endsWith(".kt") || f.endsWith(".kts"));
     } catch {
@@ -58892,11 +58976,11 @@ function detectDotnetFormat(cwd) {
   }
 }
 function detectCppcheck(cwd) {
-  if (fs19.existsSync(path49.join(cwd, "CMakeLists.txt"))) {
+  if (fs19.existsSync(path50.join(cwd, "CMakeLists.txt"))) {
     return isCommandAvailable("cppcheck");
   }
   try {
-    const dirsToCheck = [cwd, path49.join(cwd, "src")];
+    const dirsToCheck = [cwd, path50.join(cwd, "src")];
     const hasCpp = dirsToCheck.some((dir) => {
       try {
         return fs19.readdirSync(dir).some((f) => /\.(c|cpp|cc|cxx|h|hpp)$/.test(f));
@@ -58910,13 +58994,13 @@ function detectCppcheck(cwd) {
   }
 }
 function detectSwiftlint(cwd) {
-  return fs19.existsSync(path49.join(cwd, "Package.swift")) && isCommandAvailable("swiftlint");
+  return fs19.existsSync(path50.join(cwd, "Package.swift")) && isCommandAvailable("swiftlint");
 }
 function detectDartAnalyze(cwd) {
-  return fs19.existsSync(path49.join(cwd, "pubspec.yaml")) && (isCommandAvailable("dart") || isCommandAvailable("flutter"));
+  return fs19.existsSync(path50.join(cwd, "pubspec.yaml")) && (isCommandAvailable("dart") || isCommandAvailable("flutter"));
 }
 function detectRubocop(cwd) {
-  return (fs19.existsSync(path49.join(cwd, "Gemfile")) || fs19.existsSync(path49.join(cwd, "gems.rb")) || fs19.existsSync(path49.join(cwd, ".rubocop.yml"))) && (isCommandAvailable("rubocop") || isCommandAvailable("bundle"));
+  return (fs19.existsSync(path50.join(cwd, "Gemfile")) || fs19.existsSync(path50.join(cwd, "gems.rb")) || fs19.existsSync(path50.join(cwd, ".rubocop.yml"))) && (isCommandAvailable("rubocop") || isCommandAvailable("bundle"));
 }
 function detectAdditionalLinter(cwd) {
   if (detectRuff(cwd))
@@ -58944,10 +59028,10 @@ function detectAdditionalLinter(cwd) {
 function findBinInAncestors(startDir, binName) {
   let dir = startDir;
   while (true) {
-    const candidate = path49.join(dir, "node_modules", ".bin", binName);
+    const candidate = path50.join(dir, "node_modules", ".bin", binName);
     if (fs19.existsSync(candidate))
       return candidate;
-    const parent = path49.dirname(dir);
+    const parent = path50.dirname(dir);
     if (parent === dir)
       break;
     dir = parent;
@@ -58956,10 +59040,10 @@ function findBinInAncestors(startDir, binName) {
 }
 function findBinInEnvPath(binName) {
   const searchPath = process.env.PATH ?? "";
-  for (const dir of searchPath.split(path49.delimiter)) {
+  for (const dir of searchPath.split(path50.delimiter)) {
     if (!dir)
       continue;
-    const candidate = path49.join(dir, binName);
+    const candidate = path50.join(dir, binName);
     if (fs19.existsSync(candidate))
       return candidate;
   }
@@ -58972,13 +59056,13 @@ async function detectAvailableLinter(directory) {
     return null;
   const projectDir = directory;
   const isWindows = process.platform === "win32";
-  const biomeBin = isWindows ? path49.join(projectDir, "node_modules", ".bin", "biome.EXE") : path49.join(projectDir, "node_modules", ".bin", "biome");
-  const eslintBin = isWindows ? path49.join(projectDir, "node_modules", ".bin", "eslint.cmd") : path49.join(projectDir, "node_modules", ".bin", "eslint");
+  const biomeBin = isWindows ? path50.join(projectDir, "node_modules", ".bin", "biome.EXE") : path50.join(projectDir, "node_modules", ".bin", "biome");
+  const eslintBin = isWindows ? path50.join(projectDir, "node_modules", ".bin", "eslint.cmd") : path50.join(projectDir, "node_modules", ".bin", "eslint");
   const localResult = await _detectAvailableLinter(projectDir, biomeBin, eslintBin);
   if (localResult)
     return localResult;
-  const biomeAncestor = findBinInAncestors(path49.dirname(projectDir), isWindows ? "biome.EXE" : "biome");
-  const eslintAncestor = findBinInAncestors(path49.dirname(projectDir), isWindows ? "eslint.cmd" : "eslint");
+  const biomeAncestor = findBinInAncestors(path50.dirname(projectDir), isWindows ? "biome.EXE" : "biome");
+  const eslintAncestor = findBinInAncestors(path50.dirname(projectDir), isWindows ? "eslint.cmd" : "eslint");
   if (biomeAncestor || eslintAncestor) {
     return _detectAvailableLinter(projectDir, biomeAncestor ?? biomeBin, eslintAncestor ?? eslintBin);
   }
@@ -59137,7 +59221,7 @@ async function runAdditionalLint(linter, mode, cwd) {
     };
   }
 }
-var MAX_OUTPUT_BYTES = 512000, MAX_COMMAND_LENGTH = 500, lint, _internals35;
+var MAX_OUTPUT_BYTES = 512000, MAX_COMMAND_LENGTH = 500, lint, _internals36;
 var init_lint = __esm(() => {
   init_zod();
   init_discovery();
@@ -59169,15 +59253,15 @@ var init_lint = __esm(() => {
       }
       const { mode } = args;
       const cwd = directory;
-      const linter = await _internals35.detectAvailableLinter(directory);
+      const linter = await _internals36.detectAvailableLinter(directory);
       if (linter) {
-        const result = await _internals35.runLint(linter, mode, directory);
+        const result = await _internals36.runLint(linter, mode, directory);
         return JSON.stringify(result, null, 2);
       }
-      const additionalLinter = _internals35.detectAdditionalLinter(cwd);
+      const additionalLinter = _internals36.detectAdditionalLinter(cwd);
       if (additionalLinter) {
         warn(`[lint] Using ${additionalLinter} linter for this project`);
-        const result = await _internals35.runAdditionalLint(additionalLinter, mode, cwd);
+        const result = await _internals36.runAdditionalLint(additionalLinter, mode, cwd);
         return JSON.stringify(result, null, 2);
       }
       const errorResult = {
@@ -59191,7 +59275,7 @@ For Rust: rustup component add clippy`
       return JSON.stringify(errorResult, null, 2);
     }
   });
-  _internals35 = {
+  _internals36 = {
     detectAvailableLinter,
     runLint,
     detectAdditionalLinter,
@@ -59201,7 +59285,7 @@ For Rust: rustup component add clippy`
 
 // src/tools/secretscan.ts
 import * as fs20 from "fs";
-import * as path50 from "path";
+import * as path51 from "path";
 function calculateShannonEntropy(str) {
   if (str.length === 0)
     return 0;
@@ -59249,7 +59333,7 @@ function isGlobOrPathPattern(pattern) {
   return pattern.includes("/") || pattern.includes("\\") || /[*?[\]{}]/.test(pattern);
 }
 function loadSecretScanIgnore(scanDir) {
-  const ignorePath = path50.join(scanDir, ".secretscanignore");
+  const ignorePath = path51.join(scanDir, ".secretscanignore");
   try {
     if (!fs20.existsSync(ignorePath))
       return [];
@@ -59272,7 +59356,7 @@ function isExcluded(entry, relPath, exactNames, globPatterns) {
   if (exactNames.has(entry))
     return true;
   for (const pattern of globPatterns) {
-    if (path50.matchesGlob(relPath, pattern))
+    if (path51.matchesGlob(relPath, pattern))
       return true;
   }
   return false;
@@ -59293,7 +59377,7 @@ function validateDirectoryInput(dir) {
   return null;
 }
 function isBinaryFile(filePath, buffer) {
-  const ext = path50.extname(filePath).toLowerCase();
+  const ext = path51.extname(filePath).toLowerCase();
   if (DEFAULT_EXCLUDE_EXTENSIONS.has(ext)) {
     return true;
   }
@@ -59429,9 +59513,9 @@ function isSymlinkLoop(realPath, visited) {
   return false;
 }
 function isPathWithinScope(realPath, scanDir) {
-  const resolvedScanDir = path50.resolve(scanDir);
-  const resolvedRealPath = path50.resolve(realPath);
-  return resolvedRealPath === resolvedScanDir || resolvedRealPath.startsWith(resolvedScanDir + path50.sep) || resolvedRealPath.startsWith(`${resolvedScanDir}/`) || resolvedRealPath.startsWith(`${resolvedScanDir}\\`);
+  const resolvedScanDir = path51.resolve(scanDir);
+  const resolvedRealPath = path51.resolve(realPath);
+  return resolvedRealPath === resolvedScanDir || resolvedRealPath.startsWith(resolvedScanDir + path51.sep) || resolvedRealPath.startsWith(`${resolvedScanDir}/`) || resolvedRealPath.startsWith(`${resolvedScanDir}\\`);
 }
 function findScannableFiles(dir, excludeExact, excludeGlobs, scanDir, visited, stats2 = {
   skippedDirs: 0,
@@ -59457,8 +59541,8 @@ function findScannableFiles(dir, excludeExact, excludeGlobs, scanDir, visited, s
     return a.localeCompare(b);
   });
   for (const entry of entries) {
-    const fullPath = path50.join(dir, entry);
-    const relPath = path50.relative(scanDir, fullPath).replace(/\\/g, "/");
+    const fullPath = path51.join(dir, entry);
+    const relPath = path51.relative(scanDir, fullPath).replace(/\\/g, "/");
     if (isExcluded(entry, relPath, excludeExact, excludeGlobs)) {
       stats2.skippedDirs++;
       continue;
@@ -59493,7 +59577,7 @@ function findScannableFiles(dir, excludeExact, excludeGlobs, scanDir, visited, s
       const subFiles = findScannableFiles(fullPath, excludeExact, excludeGlobs, scanDir, visited, stats2);
       files.push(...subFiles);
     } else if (lstat3.isFile()) {
-      const ext = path50.extname(fullPath).toLowerCase();
+      const ext = path51.extname(fullPath).toLowerCase();
       if (!DEFAULT_EXCLUDE_EXTENSIONS.has(ext)) {
         files.push(fullPath);
       } else {
@@ -59505,7 +59589,7 @@ function findScannableFiles(dir, excludeExact, excludeGlobs, scanDir, visited, s
 }
 async function runSecretscan(directory) {
   try {
-    const result = await _internals36.secretscan.execute({ directory }, {});
+    const result = await _internals37.secretscan.execute({ directory }, {});
     const jsonStr = typeof result === "string" ? result : result.output;
     return JSON.parse(jsonStr);
   } catch (e) {
@@ -59520,7 +59604,7 @@ async function runSecretscan(directory) {
     return errorResult;
   }
 }
-var MAX_FILE_PATH_LENGTH = 500, MAX_FILE_SIZE_BYTES, MAX_FILES_SCANNED = 1000, MAX_FINDINGS = 100, MAX_OUTPUT_BYTES2 = 512000, MAX_LINE_LENGTH = 1e4, MAX_CONTENT_BYTES, BINARY_SIGNATURES, BINARY_PREFIX_BYTES = 4, BINARY_NULL_CHECK_BYTES = 8192, BINARY_NULL_THRESHOLD = 0.1, DEFAULT_EXCLUDE_DIRS, DEFAULT_EXCLUDE_EXTENSIONS, SECRET_PATTERNS2, O_NOFOLLOW, secretscan, _internals36;
+var MAX_FILE_PATH_LENGTH = 500, MAX_FILE_SIZE_BYTES, MAX_FILES_SCANNED = 1000, MAX_FINDINGS = 100, MAX_OUTPUT_BYTES2 = 512000, MAX_LINE_LENGTH = 1e4, MAX_CONTENT_BYTES, BINARY_SIGNATURES, BINARY_PREFIX_BYTES = 4, BINARY_NULL_CHECK_BYTES = 8192, BINARY_NULL_THRESHOLD = 0.1, DEFAULT_EXCLUDE_DIRS, DEFAULT_EXCLUDE_EXTENSIONS, SECRET_PATTERNS2, O_NOFOLLOW, secretscan, _internals37;
 var init_secretscan = __esm(() => {
   init_zod();
   init_path_security();
@@ -59753,7 +59837,7 @@ var init_secretscan = __esm(() => {
         }
       }
       try {
-        const _scanDirRaw = path50.resolve(directory);
+        const _scanDirRaw = path51.resolve(directory);
         const scanDir = (() => {
           try {
             return fs20.realpathSync(_scanDirRaw);
@@ -59892,7 +59976,7 @@ var init_secretscan = __esm(() => {
       }
     }
   });
-  _internals36 = {
+  _internals37 = {
     secretscan,
     runSecretscan
   };
@@ -59900,7 +59984,7 @@ var init_secretscan = __esm(() => {
 
 // src/lang/default-backend.ts
 import * as fs21 from "fs";
-import * as path51 from "path";
+import * as path52 from "path";
 function detectFileExists(dir, pattern) {
   if (pattern.includes("*") || pattern.includes("?")) {
     try {
@@ -59912,7 +59996,7 @@ function detectFileExists(dir, pattern) {
     }
   }
   try {
-    fs21.accessSync(path51.join(dir, pattern));
+    fs21.accessSync(path52.join(dir, pattern));
     return true;
   } catch {
     return false;
@@ -60051,8 +60135,8 @@ function defaultBuildTestCommand(profile, framework, files, dir = ".", opts = {}
       return ["mvn", "test"];
     case "gradle": {
       const isWindows = process.platform === "win32";
-      const hasGradlewBat = fs21.existsSync(path51.join(dir, "gradlew.bat"));
-      const hasGradlew = fs21.existsSync(path51.join(dir, "gradlew"));
+      const hasGradlewBat = fs21.existsSync(path52.join(dir, "gradlew.bat"));
+      const hasGradlew = fs21.existsSync(path52.join(dir, "gradlew"));
       if (hasGradlewBat && isWindows)
         return ["gradlew.bat", "test"];
       if (hasGradlew)
@@ -60069,7 +60153,7 @@ function defaultBuildTestCommand(profile, framework, files, dir = ".", opts = {}
         "cmake-build-release",
         "out"
       ];
-      const actualBuildDir = buildDirCandidates.find((d) => fs21.existsSync(path51.join(dir, d, "CMakeCache.txt"))) ?? "build";
+      const actualBuildDir = buildDirCandidates.find((d) => fs21.existsSync(path52.join(dir, d, "CMakeCache.txt"))) ?? "build";
       return ["ctest", "--test-dir", actualBuildDir];
     }
     case "swift-test":
@@ -60358,17 +60442,17 @@ async function defaultSelectBuildCommand(profile, dir) {
   return null;
 }
 async function defaultTestFilesFor(profile, sourceFile, dir) {
-  const ext = path51.extname(sourceFile);
+  const ext = path52.extname(sourceFile);
   if (!profile.extensions.includes(ext))
     return [];
-  const base = path51.basename(sourceFile, ext);
-  const rel = path51.relative(dir, sourceFile);
-  const relDir = path51.dirname(rel);
+  const base = path52.basename(sourceFile, ext);
+  const rel = path52.relative(dir, sourceFile);
+  const relDir = path52.dirname(rel);
   const stripSrc = relDir.replace(/^src(\/|\\)/, "");
   const candidates = new Set;
   for (const tDir of ["tests", "test", "__tests__", "spec"]) {
     for (const suffix of ["", "_test", ".test", "_spec", ".spec"]) {
-      candidates.add(path51.join(dir, tDir, stripSrc, `${base}${suffix}${ext}`));
+      candidates.add(path52.join(dir, tDir, stripSrc, `${base}${suffix}${ext}`));
     }
   }
   const existing = [];
@@ -60409,7 +60493,7 @@ var init_default_backend = __esm(() => {
 
 // src/lang/backends/go.ts
 import * as fs22 from "fs";
-import * as path52 from "path";
+import * as path53 from "path";
 function extractImports(_sourceFile, source) {
   const out = new Set;
   IMPORT_REGEX_SINGLE.lastIndex = 0;
@@ -60435,7 +60519,7 @@ function extractImports(_sourceFile, source) {
 async function selectFramework(dir) {
   let content;
   try {
-    content = fs22.readFileSync(path52.join(dir, "go.mod"), "utf-8");
+    content = fs22.readFileSync(path53.join(dir, "go.mod"), "utf-8");
   } catch {
     return null;
   }
@@ -60456,16 +60540,16 @@ async function selectFramework(dir) {
 async function selectEntryPoints(dir) {
   const points = [];
   try {
-    fs22.accessSync(path52.join(dir, "main.go"));
+    fs22.accessSync(path53.join(dir, "main.go"));
     points.push("main.go");
   } catch {}
   try {
-    const cmdDir = path52.join(dir, "cmd");
+    const cmdDir = path53.join(dir, "cmd");
     const subdirs = fs22.readdirSync(cmdDir, { withFileTypes: true }).filter((d) => d.isDirectory());
     for (const sub of subdirs) {
-      const main = path52.join("cmd", sub.name, "main.go");
+      const main = path53.join("cmd", sub.name, "main.go");
       try {
-        fs22.accessSync(path52.join(dir, main));
+        fs22.accessSync(path53.join(dir, main));
         points.push(main);
       } catch {}
     }
@@ -60484,19 +60568,19 @@ function buildGoBackend() {
     selectEntryPoints
   };
 }
-var PROFILE_ID = "go", IMPORT_REGEX_SINGLE, IMPORT_REGEX_GROUP, IMPORT_REGEX_GROUP_LINE, _internals37;
+var PROFILE_ID = "go", IMPORT_REGEX_SINGLE, IMPORT_REGEX_GROUP, IMPORT_REGEX_GROUP_LINE, _internals38;
 var init_go = __esm(() => {
   init_default_backend();
   init_profiles();
   IMPORT_REGEX_SINGLE = /^\s*import\s+(?:[a-zA-Z_.][a-zA-Z0-9_]*\s+)?"([^"]+)"/gm;
   IMPORT_REGEX_GROUP = /^\s*import\s*\(([\s\S]*?)\)/gm;
   IMPORT_REGEX_GROUP_LINE = /(?:[a-zA-Z_.][a-zA-Z0-9_]*\s+)?"([^"]+)"/g;
-  _internals37 = { extractImports };
+  _internals38 = { extractImports };
 });
 
 // src/lang/backends/python.ts
 import * as fs23 from "fs";
-import * as path53 from "path";
+import * as path54 from "path";
 function parseImportTargets(rawTargets) {
   const cleaned = rawTargets.replace(/[()]/g, "").split(`
 `).map((line) => line.replace(/#.*$/, "").replace(/\\\s*$/, "")).join(" ");
@@ -60556,7 +60640,7 @@ async function selectFramework2(dir) {
   ];
   for (const candidate of ["pyproject.toml", "requirements.txt", "setup.py"]) {
     try {
-      const content = fs23.readFileSync(path53.join(dir, candidate), "utf-8");
+      const content = fs23.readFileSync(path54.join(dir, candidate), "utf-8");
       const lower = content.toLowerCase();
       for (const [pkg, name] of candidates) {
         if (lower.includes(pkg)) {
@@ -60570,7 +60654,7 @@ async function selectFramework2(dir) {
 async function selectEntryPoints2(dir) {
   const points = new Set;
   try {
-    const content = fs23.readFileSync(path53.join(dir, "pyproject.toml"), "utf-8");
+    const content = fs23.readFileSync(path54.join(dir, "pyproject.toml"), "utf-8");
     const scriptsBlock = content.match(/\[project\.scripts\][\s\S]*?(?=\n\[|$)/);
     if (scriptsBlock) {
       for (const line of scriptsBlock[0].split(`
@@ -60585,7 +60669,7 @@ async function selectEntryPoints2(dir) {
   } catch {}
   for (const name of ["manage.py", "main.py", "app.py", "__main__.py"]) {
     try {
-      fs23.accessSync(path53.join(dir, name));
+      fs23.accessSync(path54.join(dir, name));
       points.add(name);
     } catch {}
   }
@@ -60603,18 +60687,18 @@ function buildPythonBackend() {
     selectEntryPoints: selectEntryPoints2
   };
 }
-var PROFILE_ID2 = "python", IMPORT_REGEX_FROM_WITH_TARGETS, IMPORT_REGEX_IMPORT, _internals38;
+var PROFILE_ID2 = "python", IMPORT_REGEX_FROM_WITH_TARGETS, IMPORT_REGEX_IMPORT, _internals39;
 var init_python = __esm(() => {
   init_default_backend();
   init_profiles();
   IMPORT_REGEX_FROM_WITH_TARGETS = /^\s*from\s+(\.*[\w.]*)\s+import\s+(\([^)]*\)|[^\n#]+)/gm;
   IMPORT_REGEX_IMPORT = /^\s*import\s+([^\n#]+)/gm;
-  _internals38 = { extractImports: extractImports2 };
+  _internals39 = { extractImports: extractImports2 };
 });
 
 // src/test-impact/analyzer.ts
 import fs24 from "fs";
-import path54 from "path";
+import path55 from "path";
 function normalizePath(p) {
   return p.replace(/\\/g, "/");
 }
@@ -60648,8 +60732,8 @@ function resolveRelativeImport(fromDir, importPath) {
   if (!importPath.startsWith(".")) {
     return null;
   }
-  const resolved = path54.resolve(fromDir, importPath);
-  if (path54.extname(resolved)) {
+  const resolved = path55.resolve(fromDir, importPath);
+  if (path55.extname(resolved)) {
     if (fs24.existsSync(resolved) && fs24.statSync(resolved).isFile()) {
       return normalizePath(resolved);
     }
@@ -60669,20 +60753,20 @@ function resolvePythonImport(fromDir, module) {
   const leadingDots = module.match(/^\.+/)?.[0].length ?? 0;
   let baseDir = fromDir;
   for (let i = 1;i < leadingDots; i++) {
-    baseDir = path54.dirname(baseDir);
+    baseDir = path55.dirname(baseDir);
   }
   const rest = module.slice(leadingDots);
   if (rest.length === 0) {
-    const initPath = path54.join(baseDir, "__init__.py");
+    const initPath = path55.join(baseDir, "__init__.py");
     if (fs24.existsSync(initPath) && fs24.statSync(initPath).isFile()) {
       return normalizePath(initPath);
     }
     return null;
   }
-  const subpath = rest.replace(/\./g, path54.sep);
+  const subpath = rest.replace(/\./g, path55.sep);
   const candidates = [
-    `${path54.join(baseDir, subpath)}.py`,
-    path54.join(baseDir, subpath, "__init__.py")
+    `${path55.join(baseDir, subpath)}.py`,
+    path55.join(baseDir, subpath, "__init__.py")
   ];
   for (const c of candidates) {
     if (fs24.existsSync(c) && fs24.statSync(c).isFile())
@@ -60691,7 +60775,7 @@ function resolvePythonImport(fromDir, module) {
   return null;
 }
 function findGoModule(fromDir) {
-  const resolved = path54.resolve(fromDir);
+  const resolved = path55.resolve(fromDir);
   let cur = resolved;
   const walked = [];
   for (let i = 0;i < 16; i++) {
@@ -60703,7 +60787,7 @@ function findGoModule(fromDir) {
     }
     walked.push(cur);
     try {
-      const goMod = path54.join(cur, "go.mod");
+      const goMod = path55.join(cur, "go.mod");
       const content = fs24.readFileSync(goMod, "utf-8");
       const moduleMatch = content.match(/^\s*module\s+"?([^"\s/]+(?:\/[^"\s]+)*)"?/m);
       if (moduleMatch) {
@@ -60714,10 +60798,10 @@ function findGoModule(fromDir) {
       }
     } catch {}
     try {
-      fs24.accessSync(path54.join(cur, ".git"));
+      fs24.accessSync(path55.join(cur, ".git"));
       break;
     } catch {}
-    const parent = path54.dirname(cur);
+    const parent = path55.dirname(cur);
     if (parent === cur)
       break;
     cur = parent;
@@ -60729,12 +60813,12 @@ function findGoModule(fromDir) {
 function resolveGoImport(fromDir, importPath) {
   let dir = null;
   if (importPath.startsWith(".")) {
-    dir = path54.resolve(fromDir, importPath);
+    dir = path55.resolve(fromDir, importPath);
   } else {
     const mod = findGoModule(fromDir);
     if (mod && (importPath === mod.modulePath || importPath.startsWith(`${mod.modulePath}/`))) {
       const subpath = importPath.slice(mod.modulePath.length);
-      dir = path54.join(mod.moduleRoot, subpath);
+      dir = path55.join(mod.moduleRoot, subpath);
     }
   }
   if (dir === null)
@@ -60742,7 +60826,7 @@ function resolveGoImport(fromDir, importPath) {
   if (!fs24.existsSync(dir) || !fs24.statSync(dir).isDirectory())
     return [];
   try {
-    return fs24.readdirSync(dir).filter((f) => f.endsWith(".go") && !f.endsWith("_test.go")).map((f) => normalizePath(path54.join(dir, f)));
+    return fs24.readdirSync(dir).filter((f) => f.endsWith(".go") && !f.endsWith("_test.go")).map((f) => normalizePath(path55.join(dir, f)));
   } catch {
     return [];
   }
@@ -60781,15 +60865,15 @@ function findTestFilesSync(cwd) {
     for (const entry of entries) {
       if (entry.isDirectory()) {
         if (!skipDirs.has(entry.name)) {
-          walk(path54.join(dir, entry.name), visitedInodes);
+          walk(path55.join(dir, entry.name), visitedInodes);
         }
       } else if (entry.isFile()) {
         const name = entry.name;
         const isTsTest = /\.(test|spec)\.(ts|tsx|js|jsx)$/.test(name) || dir.includes("__tests__") && /\.(ts|tsx|js|jsx)$/.test(name);
-        const isPyTest = /^test_.+\.py$/.test(name) || /.+_test\.py$/.test(name) || dir.includes(`${path54.sep}tests${path54.sep}`) && name.endsWith(".py");
+        const isPyTest = /^test_.+\.py$/.test(name) || /.+_test\.py$/.test(name) || dir.includes(`${path55.sep}tests${path55.sep}`) && name.endsWith(".py");
         const isGoTest = /.+_test\.go$/.test(name);
         if (isTsTest || isPyTest || isGoTest) {
-          testFiles.push(normalizePath(path54.join(dir, entry.name)));
+          testFiles.push(normalizePath(path55.join(dir, entry.name)));
         }
       }
     }
@@ -60814,8 +60898,8 @@ function extractImports3(content) {
   ];
 }
 function addImpactEdgesForTestFile(testFile, content, impactMap) {
-  const ext = path54.extname(testFile).toLowerCase();
-  const testDir = path54.dirname(testFile);
+  const ext = path55.extname(testFile).toLowerCase();
+  const testDir = path55.dirname(testFile);
   function addEdge(source) {
     if (!impactMap[source])
       impactMap[source] = [];
@@ -60833,7 +60917,7 @@ function addImpactEdgesForTestFile(testFile, content, impactMap) {
     return;
   }
   if (PYTHON_EXTENSIONS.has(ext)) {
-    const modules = _internals38.extractImports(testFile, content);
+    const modules = _internals39.extractImports(testFile, content);
     for (const mod of modules) {
       const resolved = resolvePythonImport(testDir, mod);
       if (resolved !== null)
@@ -60842,7 +60926,7 @@ function addImpactEdgesForTestFile(testFile, content, impactMap) {
     return;
   }
   if (GO_EXTENSIONS.has(ext)) {
-    const imports = _internals37.extractImports(testFile, content);
+    const imports = _internals38.extractImports(testFile, content);
     for (const importPath of imports) {
       const sourceFiles = resolveGoImport(testDir, importPath);
       for (const source of sourceFiles)
@@ -60869,12 +60953,12 @@ async function buildImpactMapInternal(cwd) {
   return impactMap;
 }
 async function buildImpactMap(cwd) {
-  const impactMap = await _internals39.buildImpactMapInternal(cwd);
-  await _internals39.saveImpactMap(cwd, impactMap);
+  const impactMap = await _internals40.buildImpactMapInternal(cwd);
+  await _internals40.saveImpactMap(cwd, impactMap);
   return impactMap;
 }
 async function loadImpactMap(cwd, options) {
-  const cachePath = path54.join(cwd, ".swarm", "cache", "impact-map.json");
+  const cachePath = path55.join(cwd, ".swarm", "cache", "impact-map.json");
   if (fs24.existsSync(cachePath)) {
     try {
       const content = fs24.readFileSync(cachePath, "utf-8");
@@ -60884,7 +60968,7 @@ async function loadImpactMap(cwd, options) {
         const hasValidValues = Object.values(map3).every((v) => Array.isArray(v) && v.every((item) => typeof item === "string"));
         if (hasValidValues) {
           const generatedAt = new Date(data.generatedAt).getTime();
-          if (!_internals39.isCacheStale(map3, generatedAt)) {
+          if (!_internals40.isCacheStale(map3, generatedAt)) {
             return map3;
           }
           if (options?.skipRebuild) {
@@ -60904,15 +60988,15 @@ async function loadImpactMap(cwd, options) {
   if (options?.skipRebuild) {
     return {};
   }
-  return _internals39.buildImpactMap(cwd);
+  return _internals40.buildImpactMap(cwd);
 }
 async function saveImpactMap(cwd, impactMap) {
-  if (!path54.isAbsolute(cwd)) {
+  if (!path55.isAbsolute(cwd)) {
     throw new Error(`saveImpactMap requires an absolute project root path, got: "${cwd}"`);
   }
-  _internals39.validateProjectRoot(cwd);
-  const cacheDir2 = path54.join(cwd, ".swarm", "cache");
-  const cachePath = path54.join(cacheDir2, "impact-map.json");
+  _internals40.validateProjectRoot(cwd);
+  const cacheDir2 = path55.join(cwd, ".swarm", "cache");
+  const cachePath = path55.join(cacheDir2, "impact-map.json");
   if (!fs24.existsSync(cacheDir2)) {
     fs24.mkdirSync(cacheDir2, { recursive: true });
   }
@@ -60934,7 +61018,7 @@ async function analyzeImpact(changedFiles, cwd, budget) {
     };
   }
   const validFiles = changedFiles.filter((f) => typeof f === "string" && f.length > 0 && !f.includes("\x00"));
-  const impactMap = await _internals39.loadImpactMap(cwd);
+  const impactMap = await _internals40.loadImpactMap(cwd);
   const impactedTestsSet = new Set;
   const untestedFiles = [];
   let visitedCount = 0;
@@ -60944,7 +61028,7 @@ async function analyzeImpact(changedFiles, cwd, budget) {
       budgetExceeded = true;
       break;
     }
-    const normalizedChanged = normalizePath(path54.resolve(changedFile));
+    const normalizedChanged = normalizePath(path55.resolve(changedFile));
     const tests = impactMap[normalizedChanged];
     if (tests && tests.length > 0) {
       for (const test of tests) {
@@ -60958,13 +61042,13 @@ async function analyzeImpact(changedFiles, cwd, budget) {
       if (budgetExceeded)
         break;
     } else {
-      const changedDir = normalizePath(path54.dirname(normalizedChanged));
-      const changedInputDir = normalizePath(path54.dirname(changedFile));
+      const changedDir = normalizePath(path55.dirname(normalizedChanged));
+      const changedInputDir = normalizePath(path55.dirname(changedFile));
       const suffixMatches = Object.entries(impactMap).filter(([sourcePath]) => {
         return sourcePath.endsWith(changedFile) || changedFile.endsWith(sourcePath) || sourcePath.endsWith(normalizedChanged) || normalizedChanged.endsWith(sourcePath);
       }).sort(([sourceA], [sourceB]) => {
-        const sourceDirA = normalizePath(path54.dirname(sourceA));
-        const sourceDirB = normalizePath(path54.dirname(sourceB));
+        const sourceDirA = normalizePath(path55.dirname(sourceA));
+        const sourceDirB = normalizePath(path55.dirname(sourceB));
         const exactA = sourceDirA === changedDir || changedInputDir !== "." && (sourceDirA === changedInputDir || sourceDirA.endsWith(`/${changedInputDir}`));
         const exactB = sourceDirB === changedDir || changedInputDir !== "." && (sourceDirB === changedInputDir || sourceDirB.endsWith(`/${changedInputDir}`));
         if (exactA !== exactB)
@@ -61019,7 +61103,7 @@ async function analyzeImpact(changedFiles, cwd, budget) {
     budgetExceeded
   };
 }
-var IMPORT_REGEX_ES, IMPORT_REGEX_REQUIRE, IMPORT_REGEX_REEXPORT, TS_EXTENSIONS, PYTHON_EXTENSIONS, GO_EXTENSIONS, EXTENSIONS_TO_TRY, goModuleCache, _internals39;
+var IMPORT_REGEX_ES, IMPORT_REGEX_REQUIRE, IMPORT_REGEX_REEXPORT, TS_EXTENSIONS, PYTHON_EXTENSIONS, GO_EXTENSIONS, EXTENSIONS_TO_TRY, goModuleCache, _internals40;
 var init_analyzer = __esm(() => {
   init_manager2();
   init_go();
@@ -61032,7 +61116,7 @@ var init_analyzer = __esm(() => {
   GO_EXTENSIONS = new Set([".go"]);
   EXTENSIONS_TO_TRY = [".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs"];
   goModuleCache = new Map;
-  _internals39 = {
+  _internals40 = {
     validateProjectRoot,
     normalizePath,
     isCacheStale,
@@ -61094,12 +61178,12 @@ function buildErrnoPatternPair(errno, contextPattern) {
   ];
 }
 function isInfrastructureFailure(currentResult) {
-  const errorMessage = currentResult.errorMessage || "";
+  const errorMessage2 = currentResult.errorMessage || "";
   const stackPrefix = currentResult.stackPrefix || "";
-  if (/\bassertionerror\b/i.test(errorMessage)) {
+  if (/\bassertionerror\b/i.test(errorMessage2)) {
     return false;
   }
-  const combinedText = `${errorMessage}
+  const combinedText = `${errorMessage2}
 ${stackPrefix}`;
   return INFRASTRUCTURE_FAILURE_PATTERNS.some((pattern) => pattern.test(combinedText));
 }
@@ -61319,24 +61403,24 @@ var FLAKY_THRESHOLD = 0.3, MIN_RUNS_FOR_QUARANTINE = 5, MAX_HISTORY_RUNS = 20;
 
 // src/test-impact/history-store.ts
 import fs25 from "fs";
-import path55 from "path";
+import path56 from "path";
 function getHistoryPath(workingDir) {
   if (!workingDir) {
     throw new Error("getHistoryPath requires a working directory \u2014 project root must be provided by the caller");
   }
-  if (!path55.isAbsolute(workingDir)) {
+  if (!path56.isAbsolute(workingDir)) {
     throw new Error(`getHistoryPath requires an absolute project root path, got: "${workingDir}"`);
   }
-  return path55.join(workingDir, ".swarm", "cache", "test-history.jsonl");
+  return path56.join(workingDir, ".swarm", "cache", "test-history.jsonl");
 }
-function sanitizeErrorMessage(errorMessage) {
-  if (errorMessage === undefined) {
+function sanitizeErrorMessage(errorMessage2) {
+  if (errorMessage2 === undefined) {
     return;
   }
-  if (errorMessage.length > MAX_ERROR_LENGTH) {
-    return errorMessage.substring(0, MAX_ERROR_LENGTH);
+  if (errorMessage2.length > MAX_ERROR_LENGTH) {
+    return errorMessage2.substring(0, MAX_ERROR_LENGTH);
   }
-  return errorMessage;
+  return errorMessage2;
 }
 function sanitizeStackPrefix(stackPrefix) {
   if (stackPrefix === undefined) {
@@ -61414,8 +61498,8 @@ function batchAppendTestRuns(records, workingDir) {
     }
   }
   const historyPath = getHistoryPath(workingDir);
-  const historyDir = path55.dirname(historyPath);
-  _internals40.validateProjectRoot(workingDir);
+  const historyDir = path56.dirname(historyPath);
+  _internals41.validateProjectRoot(workingDir);
   if (!fs25.existsSync(historyDir)) {
     fs25.mkdirSync(historyDir, { recursive: true });
   }
@@ -61538,7 +61622,7 @@ function getAllHistory(workingDir) {
   records.sort((a, b) => new Date(a.timestamp).getTime() - new Date(b.timestamp).getTime());
   return records;
 }
-var MAX_HISTORY_PER_TEST = 20, MAX_ERROR_LENGTH = 500, MAX_STACK_LENGTH = 200, MAX_CHANGED_FILES = 50, HISTORY_WRITE_LOCK_TIMEOUT_MS = 5000, HISTORY_WRITE_LOCK_STALE_MS = 60000, HISTORY_WRITE_LOCK_BACKOFF_MS = 10, DANGEROUS_PROPERTY_NAMES, _internals40;
+var MAX_HISTORY_PER_TEST = 20, MAX_ERROR_LENGTH = 500, MAX_STACK_LENGTH = 200, MAX_CHANGED_FILES = 50, HISTORY_WRITE_LOCK_TIMEOUT_MS = 5000, HISTORY_WRITE_LOCK_STALE_MS = 60000, HISTORY_WRITE_LOCK_BACKOFF_MS = 10, DANGEROUS_PROPERTY_NAMES, _internals41;
 var init_history_store = __esm(() => {
   init_manager2();
   DANGEROUS_PROPERTY_NAMES = new Set([
@@ -61546,14 +61630,14 @@ var init_history_store = __esm(() => {
     "constructor",
     "prototype"
   ]);
-  _internals40 = {
+  _internals41 = {
     validateProjectRoot
   };
 });
 
 // src/tools/resolve-working-directory.ts
 import * as fs26 from "fs";
-import * as path56 from "path";
+import * as path57 from "path";
 function resolveWorkingDirectory(workingDirectory, fallbackDirectory) {
   if (workingDirectory == null || workingDirectory === "") {
     if (typeof fallbackDirectory !== "string" || fallbackDirectory === "") {
@@ -61585,15 +61669,15 @@ function resolveWorkingDirectory(workingDirectory, fallbackDirectory) {
       };
     }
   }
-  const rawPathParts = workingDirectory.split(path56.sep);
+  const rawPathParts = workingDirectory.split(path57.sep);
   if (rawPathParts.includes("..")) {
     return {
       success: false,
       message: "Invalid working_directory: path traversal sequences (..) are not allowed"
     };
   }
-  const normalizedDir = path56.normalize(workingDirectory);
-  const resolvedDir = path56.resolve(normalizedDir);
+  const normalizedDir = path57.normalize(workingDirectory);
+  const resolvedDir = path57.resolve(normalizedDir);
   let statResult;
   try {
     statResult = fs26.statSync(resolvedDir);
@@ -61612,7 +61696,7 @@ function resolveWorkingDirectory(workingDirectory, fallbackDirectory) {
   if (typeof fallbackDirectory !== "string" || fallbackDirectory === "") {
     return { success: true, directory: resolvedDir };
   }
-  const resolvedFallback = path56.resolve(fallbackDirectory);
+  const resolvedFallback = path57.resolve(fallbackDirectory);
   let fallbackExists = false;
   try {
     fs26.statSync(resolvedFallback);
@@ -61621,7 +61705,7 @@ function resolveWorkingDirectory(workingDirectory, fallbackDirectory) {
     fallbackExists = false;
   }
   if (fallbackExists) {
-    const isSubdirectory = resolvedDir.startsWith(resolvedFallback + path56.sep);
+    const isSubdirectory = resolvedDir.startsWith(resolvedFallback + path57.sep);
     if (isSubdirectory) {
       return {
         success: false,
@@ -61668,7 +61752,7 @@ var init_registry_backend = __esm(() => {
 
 // src/lang/framework-detector.ts
 import * as fs27 from "fs";
-import * as path57 from "path";
+import * as path58 from "path";
 function detectLaravelProject(directory) {
   const signals = getLaravelSignals(directory);
   const signalCount = [
@@ -61685,7 +61769,7 @@ function getLaravelSignals(directory) {
   return { hasArtisanFile, hasLaravelFrameworkDep, hasConfigApp };
 }
 function checkArtisanFile(directory) {
-  const artisanPath = path57.join(directory, "artisan");
+  const artisanPath = path58.join(directory, "artisan");
   if (!fs27.existsSync(artisanPath))
     return false;
   try {
@@ -61695,7 +61779,7 @@ function checkArtisanFile(directory) {
   }
 }
 function checkLaravelFrameworkDep(directory) {
-  const composerPath = path57.join(directory, "composer.json");
+  const composerPath = path58.join(directory, "composer.json");
   if (!fs27.existsSync(composerPath))
     return false;
   try {
@@ -61708,7 +61792,7 @@ function checkLaravelFrameworkDep(directory) {
   }
 }
 function checkConfigApp(directory) {
-  return fs27.existsSync(path57.join(directory, "config", "app.php"));
+  return fs27.existsSync(path58.join(directory, "config", "app.php"));
 }
 var init_framework_detector = () => {};
 
@@ -61741,17 +61825,17 @@ var init_php = __esm(() => {
 
 // src/lang/backends/typescript.ts
 import * as fs28 from "fs";
-import * as path58 from "path";
+import * as path59 from "path";
 function readPackageJsonRaw(dir) {
   try {
-    const content = fs28.readFileSync(path58.join(dir, "package.json"), "utf-8");
+    const content = fs28.readFileSync(path59.join(dir, "package.json"), "utf-8");
     return JSON.parse(content);
   } catch {
     return null;
   }
 }
 function readPackageJson(dir) {
-  return _internals41.readPackageJsonRaw(dir);
+  return _internals42.readPackageJsonRaw(dir);
 }
 function readPackageJsonTestScript(dir) {
   return readPackageJson(dir)?.scripts?.test ?? null;
@@ -61921,7 +62005,7 @@ function buildTypescriptBackend() {
     selectEntryPoints: selectEntryPoints3
   };
 }
-var PROFILE_ID4 = "typescript", IMPORT_REGEX_ES2, IMPORT_REGEX_BARE, IMPORT_REGEX_REQUIRE2, IMPORT_REGEX_DYNAMIC, IMPORT_REGEX_REEXPORT2, _internals41;
+var PROFILE_ID4 = "typescript", IMPORT_REGEX_ES2, IMPORT_REGEX_BARE, IMPORT_REGEX_REQUIRE2, IMPORT_REGEX_DYNAMIC, IMPORT_REGEX_REEXPORT2, _internals42;
 var init_typescript = __esm(() => {
   init_default_backend();
   init_profiles();
@@ -61930,7 +62014,7 @@ var init_typescript = __esm(() => {
   IMPORT_REGEX_REQUIRE2 = /require\s*\(\s*['"]([^'"]+)['"]\s*\)/g;
   IMPORT_REGEX_DYNAMIC = /import\s*\(\s*['"]([^'"]+)['"]\s*\)/g;
   IMPORT_REGEX_REEXPORT2 = /export\s+(?:\{[^}]*\}|\*)\s+from\s+['"]([^'"]+)['"]/g;
-  _internals41 = {
+  _internals42 = {
     readPackageJsonRaw,
     readPackageJsonTestScript,
     frameworkFromScriptsTest
@@ -61963,10 +62047,10 @@ __export(exports_dispatch, {
   pickedProfiles: () => pickedProfiles,
   pickBackend: () => pickBackend,
   clearDispatchCache: () => clearDispatchCache,
-  _internals: () => _internals42
+  _internals: () => _internals43
 });
 import * as fs29 from "fs";
-import * as path59 from "path";
+import * as path60 from "path";
 function safeReaddirSet(dir) {
   try {
     return new Set(fs29.readdirSync(dir));
@@ -61983,14 +62067,14 @@ function manifestHash(dir) {
     if (!entries.has(name))
       continue;
     try {
-      const stat9 = fs29.statSync(path59.join(dir, name));
+      const stat9 = fs29.statSync(path60.join(dir, name));
       parts.push(`${name}:${stat9.size}:${stat9.mtimeMs}:${stat9.ino}`);
     } catch {}
   }
   return parts.join("|");
 }
 function findManifestRoot(start) {
-  const resolved = path59.resolve(start);
+  const resolved = path60.resolve(start);
   const cached3 = manifestRootCache.get(resolved);
   if (cached3 !== undefined)
     return cached3;
@@ -62009,7 +62093,7 @@ function findManifestRoot(start) {
         return cur;
       }
     }
-    const parent = path59.dirname(cur);
+    const parent = path60.dirname(cur);
     if (parent === cur)
       break;
     cur = parent;
@@ -62018,7 +62102,7 @@ function findManifestRoot(start) {
   return start;
 }
 function evictIfNeeded() {
-  if (cache.size <= _internals42.cacheCapacity)
+  if (cache.size <= _internals43.cacheCapacity)
     return;
   let oldestKey;
   let oldestOrder = Infinity;
@@ -62049,7 +62133,7 @@ async function pickBackend(dir) {
     evictIfNeeded();
     return null;
   }
-  const profiles = await _internals42.detectProjectLanguages(root);
+  const profiles = await _internals43.detectProjectLanguages(root);
   if (profiles.length === 0) {
     cache.set(cacheKey, {
       hash: hash4,
@@ -62081,12 +62165,12 @@ function clearDispatchCache() {
   manifestRootCache.clear();
   insertCounter = 0;
 }
-var _internals42, cache, insertCounter = 0, MANIFEST_FILES, _MANIFEST_SET, manifestRootCache;
+var _internals43, cache, insertCounter = 0, MANIFEST_FILES, _MANIFEST_SET, manifestRootCache;
 var init_dispatch = __esm(() => {
   init_backends();
   init_detector();
   init_registry_backend();
-  _internals42 = {
+  _internals43 = {
     detectProjectLanguages,
     cacheCapacity: 64
   };
@@ -62119,13 +62203,13 @@ var init_dispatch = __esm(() => {
 
 // src/tools/test-runner.ts
 import * as fs30 from "fs";
-import * as path60 from "path";
+import * as path61 from "path";
 async function estimateFanOut(sourceFiles, cwd) {
   try {
     const impactMap = await loadImpactMap(cwd, { skipRebuild: true });
     const uniqueTestFiles = new Set;
     for (const sourceFile of sourceFiles) {
-      const resolvedPath = path60.resolve(cwd, sourceFile);
+      const resolvedPath = path61.resolve(cwd, sourceFile);
       const normalizedPath = resolvedPath.replace(/\\/g, "/");
       const testFiles = impactMap[normalizedPath];
       if (testFiles) {
@@ -62207,14 +62291,14 @@ function hasDevDependency(devDeps, ...patterns) {
   return hasPackageJsonDependency(devDeps, ...patterns);
 }
 function detectGoTest(cwd) {
-  return fs30.existsSync(path60.join(cwd, "go.mod")) && isCommandAvailable("go");
+  return fs30.existsSync(path61.join(cwd, "go.mod")) && isCommandAvailable("go");
 }
 function detectJavaMaven(cwd) {
-  return fs30.existsSync(path60.join(cwd, "pom.xml")) && isCommandAvailable("mvn");
+  return fs30.existsSync(path61.join(cwd, "pom.xml")) && isCommandAvailable("mvn");
 }
 function detectGradle(cwd) {
-  const hasBuildFile = fs30.existsSync(path60.join(cwd, "build.gradle")) || fs30.existsSync(path60.join(cwd, "build.gradle.kts"));
-  const hasGradlew = fs30.existsSync(path60.join(cwd, "gradlew")) || fs30.existsSync(path60.join(cwd, "gradlew.bat"));
+  const hasBuildFile = fs30.existsSync(path61.join(cwd, "build.gradle")) || fs30.existsSync(path61.join(cwd, "build.gradle.kts"));
+  const hasGradlew = fs30.existsSync(path61.join(cwd, "gradlew")) || fs30.existsSync(path61.join(cwd, "gradlew.bat"));
   return hasBuildFile && (hasGradlew || isCommandAvailable("gradle"));
 }
 function detectDotnetTest(cwd) {
@@ -62227,25 +62311,25 @@ function detectDotnetTest(cwd) {
   }
 }
 function detectCTest(cwd) {
-  const hasSource = fs30.existsSync(path60.join(cwd, "CMakeLists.txt"));
-  const hasBuildCache = fs30.existsSync(path60.join(cwd, "CMakeCache.txt")) || fs30.existsSync(path60.join(cwd, "build", "CMakeCache.txt"));
+  const hasSource = fs30.existsSync(path61.join(cwd, "CMakeLists.txt"));
+  const hasBuildCache = fs30.existsSync(path61.join(cwd, "CMakeCache.txt")) || fs30.existsSync(path61.join(cwd, "build", "CMakeCache.txt"));
   return (hasSource || hasBuildCache) && isCommandAvailable("ctest");
 }
 function detectSwiftTest(cwd) {
-  return fs30.existsSync(path60.join(cwd, "Package.swift")) && isCommandAvailable("swift");
+  return fs30.existsSync(path61.join(cwd, "Package.swift")) && isCommandAvailable("swift");
 }
 function detectDartTest(cwd) {
-  return fs30.existsSync(path60.join(cwd, "pubspec.yaml")) && (isCommandAvailable("dart") || isCommandAvailable("flutter"));
+  return fs30.existsSync(path61.join(cwd, "pubspec.yaml")) && (isCommandAvailable("dart") || isCommandAvailable("flutter"));
 }
 function detectRSpec(cwd) {
-  const hasRSpecFile = fs30.existsSync(path60.join(cwd, ".rspec"));
-  const hasGemfile = fs30.existsSync(path60.join(cwd, "Gemfile"));
-  const hasSpecDir = fs30.existsSync(path60.join(cwd, "spec"));
+  const hasRSpecFile = fs30.existsSync(path61.join(cwd, ".rspec"));
+  const hasGemfile = fs30.existsSync(path61.join(cwd, "Gemfile"));
+  const hasSpecDir = fs30.existsSync(path61.join(cwd, "spec"));
   const hasRSpec = hasRSpecFile || hasGemfile && hasSpecDir;
   return hasRSpec && (isCommandAvailable("bundle") || isCommandAvailable("rspec"));
 }
 function detectMinitest(cwd) {
-  return fs30.existsSync(path60.join(cwd, "test")) && (fs30.existsSync(path60.join(cwd, "Gemfile")) || fs30.existsSync(path60.join(cwd, "Rakefile"))) && isCommandAvailable("ruby");
+  return fs30.existsSync(path61.join(cwd, "test")) && (fs30.existsSync(path61.join(cwd, "Gemfile")) || fs30.existsSync(path61.join(cwd, "Rakefile"))) && isCommandAvailable("ruby");
 }
 async function detectTestFrameworkViaDispatch(cwd) {
   try {
@@ -62308,7 +62392,7 @@ async function parseTestOutputViaDispatch(framework, output, baseDir) {
 async function detectTestFramework(cwd) {
   const baseDir = cwd;
   try {
-    const packageJsonPath = path60.join(baseDir, "package.json");
+    const packageJsonPath = path61.join(baseDir, "package.json");
     if (fs30.existsSync(packageJsonPath)) {
       const content = fs30.readFileSync(packageJsonPath, "utf-8");
       const pkg = JSON.parse(content);
@@ -62329,16 +62413,16 @@ async function detectTestFramework(cwd) {
         return "jest";
       if (hasDevDependency(devDeps, "mocha", "@types/mocha"))
         return "mocha";
-      if (fs30.existsSync(path60.join(baseDir, "bun.lockb")) || fs30.existsSync(path60.join(baseDir, "bun.lock"))) {
+      if (fs30.existsSync(path61.join(baseDir, "bun.lockb")) || fs30.existsSync(path61.join(baseDir, "bun.lock"))) {
         if (scripts.test?.includes("bun"))
           return "bun";
       }
     }
   } catch {}
   try {
-    const pyprojectTomlPath = path60.join(baseDir, "pyproject.toml");
-    const setupCfgPath = path60.join(baseDir, "setup.cfg");
-    const requirementsTxtPath = path60.join(baseDir, "requirements.txt");
+    const pyprojectTomlPath = path61.join(baseDir, "pyproject.toml");
+    const setupCfgPath = path61.join(baseDir, "setup.cfg");
+    const requirementsTxtPath = path61.join(baseDir, "requirements.txt");
     if (fs30.existsSync(pyprojectTomlPath)) {
       const content = fs30.readFileSync(pyprojectTomlPath, "utf-8");
       if (content.includes("[tool.pytest"))
@@ -62358,7 +62442,7 @@ async function detectTestFramework(cwd) {
     }
   } catch {}
   try {
-    const cargoTomlPath = path60.join(baseDir, "Cargo.toml");
+    const cargoTomlPath = path61.join(baseDir, "Cargo.toml");
     if (fs30.existsSync(cargoTomlPath)) {
       const content = fs30.readFileSync(cargoTomlPath, "utf-8");
       if (content.includes("[dev-dependencies]")) {
@@ -62369,9 +62453,9 @@ async function detectTestFramework(cwd) {
     }
   } catch {}
   try {
-    const pesterConfigPath = path60.join(baseDir, "pester.config.ps1");
-    const pesterConfigJsonPath = path60.join(baseDir, "pester.config.ps1.json");
-    const pesterPs1Path = path60.join(baseDir, "tests.ps1");
+    const pesterConfigPath = path61.join(baseDir, "pester.config.ps1");
+    const pesterConfigJsonPath = path61.join(baseDir, "pester.config.ps1.json");
+    const pesterPs1Path = path61.join(baseDir, "tests.ps1");
     if (fs30.existsSync(pesterConfigPath) || fs30.existsSync(pesterConfigJsonPath) || fs30.existsSync(pesterPs1Path)) {
       return "pester";
     }
@@ -62400,12 +62484,12 @@ function isTestDirectoryPath(normalizedPath) {
   return normalizedPath.split("/").some((segment) => TEST_DIRECTORY_NAMES.includes(segment));
 }
 function resolveWorkspacePath(file3, workingDir) {
-  return path60.isAbsolute(file3) ? path60.resolve(file3) : path60.resolve(workingDir, file3);
+  return path61.isAbsolute(file3) ? path61.resolve(file3) : path61.resolve(workingDir, file3);
 }
 function toWorkspaceOutputPath(absolutePath, workingDir, preferRelative) {
   if (!preferRelative)
     return absolutePath;
-  return path60.relative(workingDir, absolutePath);
+  return path61.relative(workingDir, absolutePath);
 }
 function dedupePush(target, value) {
   if (!target.includes(value)) {
@@ -62442,18 +62526,18 @@ function buildLanguageSpecificTestNames(nameWithoutExt, ext) {
   }
 }
 function getRepoLevelCandidateDirectories(workingDir, relativePath, ext) {
-  const relativeDir = path60.dirname(relativePath);
+  const relativeDir = path61.dirname(relativePath);
   const nestedRelativeDir = relativeDir === "." ? "" : relativeDir;
   const directories = TEST_DIRECTORY_NAMES.flatMap((dirName) => {
-    const rootDir = path60.join(workingDir, dirName);
-    return nestedRelativeDir ? [rootDir, path60.join(rootDir, nestedRelativeDir)] : [rootDir];
+    const rootDir = path61.join(workingDir, dirName);
+    return nestedRelativeDir ? [rootDir, path61.join(rootDir, nestedRelativeDir)] : [rootDir];
   });
   const normalizedRelativePath = relativePath.replace(/\\/g, "/");
   if (ext === ".java" && normalizedRelativePath.startsWith("src/main/java/")) {
-    directories.push(path60.join(workingDir, "src/test/java", path60.dirname(normalizedRelativePath.slice("src/main/java/".length))));
+    directories.push(path61.join(workingDir, "src/test/java", path61.dirname(normalizedRelativePath.slice("src/main/java/".length))));
   }
   if ((ext === ".kt" || ext === ".java") && normalizedRelativePath.startsWith("src/main/kotlin/")) {
-    directories.push(path60.join(workingDir, "src/test/kotlin", path60.dirname(normalizedRelativePath.slice("src/main/kotlin/".length))));
+    directories.push(path61.join(workingDir, "src/test/kotlin", path61.dirname(normalizedRelativePath.slice("src/main/kotlin/".length))));
   }
   return [...new Set(directories)];
 }
@@ -62481,23 +62565,23 @@ function isLanguageSpecificTestFile(basename9) {
 }
 function isConventionTestFilePath(filePath) {
   const normalizedPath = filePath.replace(/\\/g, "/");
-  const basename9 = path60.basename(filePath);
+  const basename9 = path61.basename(filePath);
   return hasCompoundTestExtension(basename9) || basename9.includes(".spec.") || basename9.includes(".test.") || isLanguageSpecificTestFile(basename9) || isTestDirectoryPath(normalizedPath);
 }
 function getTestFilesFromConvention(sourceFiles, workingDir = process.cwd()) {
   const testFiles = [];
   for (const file3 of sourceFiles) {
     const absoluteFile = resolveWorkspacePath(file3, workingDir);
-    const relativeFile = path60.relative(workingDir, absoluteFile);
-    const basename9 = path60.basename(absoluteFile);
-    const dirname34 = path60.dirname(absoluteFile);
-    const preferRelativeOutput = !path60.isAbsolute(file3);
+    const relativeFile = path61.relative(workingDir, absoluteFile);
+    const basename9 = path61.basename(absoluteFile);
+    const dirname34 = path61.dirname(absoluteFile);
+    const preferRelativeOutput = !path61.isAbsolute(file3);
     if (isConventionTestFilePath(relativeFile) || isConventionTestFilePath(file3)) {
       dedupePush(testFiles, toWorkspaceOutputPath(absoluteFile, workingDir, preferRelativeOutput));
       continue;
     }
     const nameWithoutExt = basename9.replace(/\.[^.]+$/, "");
-    const ext = path60.extname(basename9);
+    const ext = path61.extname(basename9);
     const genericTestNames = [
       `${nameWithoutExt}.spec${ext}`,
       `${nameWithoutExt}.test${ext}`
@@ -62506,7 +62590,7 @@ function getTestFilesFromConvention(sourceFiles, workingDir = process.cwd()) {
     const colocatedCandidates = [
       ...genericTestNames,
       ...languageSpecificTestNames
-    ].map((candidateName) => path60.join(dirname34, candidateName));
+    ].map((candidateName) => path61.join(dirname34, candidateName));
     const testDirectoryNames = [
       basename9,
       ...genericTestNames,
@@ -62515,8 +62599,8 @@ function getTestFilesFromConvention(sourceFiles, workingDir = process.cwd()) {
     const repoLevelDirectories = getRepoLevelCandidateDirectories(workingDir, relativeFile, ext);
     const possibleTestFiles = [
       ...colocatedCandidates,
-      ...TEST_DIRECTORY_NAMES.flatMap((dirName) => testDirectoryNames.map((candidateName) => path60.join(dirname34, dirName, candidateName))),
-      ...repoLevelDirectories.flatMap((candidateDir) => testDirectoryNames.map((candidateName) => path60.join(candidateDir, candidateName)))
+      ...TEST_DIRECTORY_NAMES.flatMap((dirName) => testDirectoryNames.map((candidateName) => path61.join(dirname34, dirName, candidateName))),
+      ...repoLevelDirectories.flatMap((candidateDir) => testDirectoryNames.map((candidateName) => path61.join(candidateDir, candidateName)))
     ];
     for (const testFile of possibleTestFiles) {
       if (fs30.existsSync(testFile)) {
@@ -62537,7 +62621,7 @@ async function getTestFilesFromGraph(sourceFiles, workingDir) {
     try {
       const absoluteTestFile = resolveWorkspacePath(testFile, workingDir);
       const content = fs30.readFileSync(absoluteTestFile, "utf-8");
-      const testDir = path60.dirname(absoluteTestFile);
+      const testDir = path61.dirname(absoluteTestFile);
       const importRegex = /import\s+.*?\s+from\s+['"]([^'"]+)['"]/g;
       let match;
       match = importRegex.exec(content);
@@ -62545,8 +62629,8 @@ async function getTestFilesFromGraph(sourceFiles, workingDir) {
         const importPath = match[1];
         let resolvedImport;
         if (importPath.startsWith(".")) {
-          resolvedImport = path60.resolve(testDir, importPath);
-          const existingExt = path60.extname(resolvedImport);
+          resolvedImport = path61.resolve(testDir, importPath);
+          const existingExt = path61.extname(resolvedImport);
           if (!existingExt) {
             for (const extToTry of [
               ".ts",
@@ -62566,12 +62650,12 @@ async function getTestFilesFromGraph(sourceFiles, workingDir) {
         } else {
           continue;
         }
-        const importBasename = path60.basename(resolvedImport, path60.extname(resolvedImport));
-        const importDir = path60.dirname(resolvedImport);
+        const importBasename = path61.basename(resolvedImport, path61.extname(resolvedImport));
+        const importDir = path61.dirname(resolvedImport);
         for (const sourceFile of absoluteSourceFiles) {
-          const sourceDir = path60.dirname(sourceFile);
-          const sourceBasename = path60.basename(sourceFile, path60.extname(sourceFile));
-          const isRelatedDir = importDir === sourceDir || importDir === path60.join(sourceDir, "__tests__") || importDir === path60.join(sourceDir, "tests") || importDir === path60.join(sourceDir, "test") || importDir === path60.join(sourceDir, "spec");
+          const sourceDir = path61.dirname(sourceFile);
+          const sourceBasename = path61.basename(sourceFile, path61.extname(sourceFile));
+          const isRelatedDir = importDir === sourceDir || importDir === path61.join(sourceDir, "__tests__") || importDir === path61.join(sourceDir, "tests") || importDir === path61.join(sourceDir, "test") || importDir === path61.join(sourceDir, "spec");
           if (resolvedImport === sourceFile || importBasename === sourceBasename && isRelatedDir) {
             dedupePush(testFiles, testFile);
             break;
@@ -62584,8 +62668,8 @@ async function getTestFilesFromGraph(sourceFiles, workingDir) {
       while (match !== null) {
         const importPath = match[1];
         if (importPath.startsWith(".")) {
-          let resolvedImport = path60.resolve(testDir, importPath);
-          const existingExt = path60.extname(resolvedImport);
+          let resolvedImport = path61.resolve(testDir, importPath);
+          const existingExt = path61.extname(resolvedImport);
           if (!existingExt) {
             for (const extToTry of [
               ".ts",
@@ -62602,12 +62686,12 @@ async function getTestFilesFromGraph(sourceFiles, workingDir) {
               }
             }
           }
-          const importDir = path60.dirname(resolvedImport);
-          const importBasename = path60.basename(resolvedImport, path60.extname(resolvedImport));
+          const importDir = path61.dirname(resolvedImport);
+          const importBasename = path61.basename(resolvedImport, path61.extname(resolvedImport));
           for (const sourceFile of absoluteSourceFiles) {
-            const sourceDir = path60.dirname(sourceFile);
-            const sourceBasename = path60.basename(sourceFile, path60.extname(sourceFile));
-            const isRelatedDir = importDir === sourceDir || importDir === path60.join(sourceDir, "__tests__") || importDir === path60.join(sourceDir, "tests") || importDir === path60.join(sourceDir, "test") || importDir === path60.join(sourceDir, "spec");
+            const sourceDir = path61.dirname(sourceFile);
+            const sourceBasename = path61.basename(sourceFile, path61.extname(sourceFile));
+            const isRelatedDir = importDir === sourceDir || importDir === path61.join(sourceDir, "__tests__") || importDir === path61.join(sourceDir, "tests") || importDir === path61.join(sourceDir, "test") || importDir === path61.join(sourceDir, "spec");
             if (resolvedImport === sourceFile || importBasename === sourceBasename && isRelatedDir) {
               dedupePush(testFiles, testFile);
               break;
@@ -62727,8 +62811,8 @@ function buildTestCommand2(framework, scope, files, coverage, baseDir, bail) {
       return ["mvn", "test"];
     case "gradle": {
       const isWindows = process.platform === "win32";
-      const hasGradlewBat = fs30.existsSync(path60.join(baseDir, "gradlew.bat"));
-      const hasGradlew = fs30.existsSync(path60.join(baseDir, "gradlew"));
+      const hasGradlewBat = fs30.existsSync(path61.join(baseDir, "gradlew.bat"));
+      const hasGradlew = fs30.existsSync(path61.join(baseDir, "gradlew"));
       if (hasGradlewBat && isWindows)
         return ["gradlew.bat", "test"];
       if (hasGradlew)
@@ -62745,7 +62829,7 @@ function buildTestCommand2(framework, scope, files, coverage, baseDir, bail) {
         "cmake-build-release",
         "out"
       ];
-      const actualBuildDir = buildDirCandidates.find((d) => fs30.existsSync(path60.join(baseDir, d, "CMakeCache.txt"))) ?? "build";
+      const actualBuildDir = buildDirCandidates.find((d) => fs30.existsSync(path61.join(baseDir, d, "CMakeCache.txt"))) ?? "build";
       return ["ctest", "--test-dir", actualBuildDir];
     }
     case "swift-test":
@@ -63179,11 +63263,11 @@ async function runTests(framework, scope, files, coverage, timeout_ms, cwd, bail
     };
   }
   const startTime = Date.now();
-  const vitestJsonOutputPath = framework === "vitest" ? path60.join(cwd, ".swarm", "cache", "test-runner-vitest.json") : undefined;
+  const vitestJsonOutputPath = framework === "vitest" ? path61.join(cwd, ".swarm", "cache", "test-runner-vitest.json") : undefined;
   try {
     if (vitestJsonOutputPath) {
       try {
-        fs30.mkdirSync(path60.dirname(vitestJsonOutputPath), { recursive: true });
+        fs30.mkdirSync(path61.dirname(vitestJsonOutputPath), { recursive: true });
         if (fs30.existsSync(vitestJsonOutputPath)) {
           fs30.unlinkSync(vitestJsonOutputPath);
         }
@@ -63299,10 +63383,10 @@ async function runTests(framework, scope, files, coverage, timeout_ms, cwd, bail
 }
 function normalizeHistoryTestFile(testFile, workingDir) {
   const normalized = testFile.replace(/\\/g, "/");
-  if (!path60.isAbsolute(testFile))
+  if (!path61.isAbsolute(testFile))
     return normalized;
-  const relative12 = path60.relative(workingDir, testFile);
-  if (relative12.startsWith("..") || path60.isAbsolute(relative12)) {
+  const relative12 = path61.relative(workingDir, testFile);
+  if (relative12.startsWith("..") || path61.isAbsolute(relative12)) {
     return normalized;
   }
   return relative12.replace(/\\/g, "/");
@@ -63641,7 +63725,7 @@ var init_test_runner = __esm(() => {
         const sourceFiles = args.files.filter((file3) => {
           if (directTestFiles.includes(file3))
             return false;
-          const ext = path60.extname(file3).toLowerCase();
+          const ext = path61.extname(file3).toLowerCase();
           return SOURCE_EXTENSIONS.has(ext);
         });
         const invalidFiles = args.files.filter((file3) => !directTestFiles.includes(file3) && !sourceFiles.includes(file3));
@@ -63687,7 +63771,7 @@ var init_test_runner = __esm(() => {
           if (isConventionTestFilePath(f)) {
             return false;
           }
-          const ext = path60.extname(f).toLowerCase();
+          const ext = path61.extname(f).toLowerCase();
           return SOURCE_EXTENSIONS.has(ext);
         });
         if (sourceFiles.length === 0) {
@@ -63737,7 +63821,7 @@ var init_test_runner = __esm(() => {
           if (isConventionTestFilePath(f)) {
             return false;
           }
-          const ext = path60.extname(f).toLowerCase();
+          const ext = path61.extname(f).toLowerCase();
           return SOURCE_EXTENSIONS.has(ext);
         });
         if (sourceFiles.length === 0) {
@@ -63789,8 +63873,8 @@ var init_test_runner = __esm(() => {
           }
           if (impactResult.impactedTests.length > 0) {
             testFiles = impactResult.impactedTests.map((absPath) => {
-              const relativePath = path60.relative(workingDir, absPath);
-              return path60.isAbsolute(relativePath) ? absPath : relativePath;
+              const relativePath = path61.relative(workingDir, absPath);
+              return path61.isAbsolute(relativePath) ? absPath : relativePath;
             });
           } else {
             graphFallbackReason = "no impacted tests found via impact analysis, falling back to graph";
@@ -63869,7 +63953,7 @@ var init_test_runner = __esm(() => {
 
 // src/services/preflight-service.ts
 import * as fs31 from "fs";
-import * as path61 from "path";
+import * as path62 from "path";
 function validateDirectoryPath(dir) {
   if (!dir || typeof dir !== "string") {
     throw new Error("Directory path is required");
@@ -63877,8 +63961,8 @@ function validateDirectoryPath(dir) {
   if (dir.includes("..")) {
     throw new Error("Directory path must not contain path traversal sequences");
   }
-  const normalized = path61.normalize(dir);
-  const absolutePath = path61.isAbsolute(normalized) ? normalized : path61.resolve(normalized);
+  const normalized = path62.normalize(dir);
+  const absolutePath = path62.isAbsolute(normalized) ? normalized : path62.resolve(normalized);
   return absolutePath;
 }
 function validateTimeout(timeoutMs, defaultValue) {
@@ -63901,7 +63985,7 @@ function validateTimeout(timeoutMs, defaultValue) {
 }
 function getPackageVersion(dir) {
   try {
-    const packagePath = path61.join(dir, "package.json");
+    const packagePath = path62.join(dir, "package.json");
     if (fs31.existsSync(packagePath)) {
       const content = fs31.readFileSync(packagePath, "utf-8");
       const pkg = JSON.parse(content);
@@ -63912,7 +63996,7 @@ function getPackageVersion(dir) {
 }
 function getChangelogVersion(dir) {
   try {
-    const changelogPath = path61.join(dir, "CHANGELOG.md");
+    const changelogPath = path62.join(dir, "CHANGELOG.md");
     if (fs31.existsSync(changelogPath)) {
       const content = fs31.readFileSync(changelogPath, "utf-8");
       const match = content.match(/^##\s*\[?(\d+\.\d+\.\d+)\]?/m);
@@ -63926,7 +64010,7 @@ function getChangelogVersion(dir) {
 function getVersionFileVersion(dir) {
   const possibleFiles = ["VERSION.txt", "version.txt", "VERSION", "version"];
   for (const file3 of possibleFiles) {
-    const filePath = path61.join(dir, file3);
+    const filePath = path62.join(dir, file3);
     if (fs31.existsSync(filePath)) {
       try {
         const content = fs31.readFileSync(filePath, "utf-8").trim();
@@ -63942,9 +64026,9 @@ function getVersionFileVersion(dir) {
 async function runVersionCheck(dir, _timeoutMs) {
   const startTime = Date.now();
   try {
-    const packageVersion = _internals43.getPackageVersion(dir);
-    const changelogVersion = _internals43.getChangelogVersion(dir);
-    const versionFileVersion = _internals43.getVersionFileVersion(dir);
+    const packageVersion = _internals44.getPackageVersion(dir);
+    const changelogVersion = _internals44.getChangelogVersion(dir);
+    const versionFileVersion = _internals44.getVersionFileVersion(dir);
     const versions3 = [];
     if (packageVersion)
       versions3.push(`package.json: ${packageVersion}`);
@@ -64308,7 +64392,7 @@ async function runPreflight(dir, phase, config3) {
   const reportId = `preflight-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
   let validatedDir;
   try {
-    validatedDir = _internals43.validateDirectoryPath(dir);
+    validatedDir = _internals44.validateDirectoryPath(dir);
   } catch (error93) {
     return {
       id: reportId,
@@ -64328,7 +64412,7 @@ async function runPreflight(dir, phase, config3) {
   }
   let validatedTimeout;
   try {
-    validatedTimeout = _internals43.validateTimeout(config3?.checkTimeoutMs, DEFAULT_CONFIG.checkTimeoutMs);
+    validatedTimeout = _internals44.validateTimeout(config3?.checkTimeoutMs, DEFAULT_CONFIG.checkTimeoutMs);
   } catch (error93) {
     return {
       id: reportId,
@@ -64369,12 +64453,12 @@ async function runPreflight(dir, phase, config3) {
   });
   const checks5 = [];
   log("[Preflight] Running lint check...");
-  const lintResult = await _internals43.runLintCheck(validatedDir, cfg.linter, cfg.checkTimeoutMs);
+  const lintResult = await _internals44.runLintCheck(validatedDir, cfg.linter, cfg.checkTimeoutMs);
   checks5.push(lintResult);
   log(`[Preflight] Lint check: ${lintResult.status} ${lintResult.message}`);
   if (!cfg.skipTests) {
     log("[Preflight] Running tests check...");
-    const testsResult = await _internals43.runTestsCheck(validatedDir, cfg.testScope, cfg.checkTimeoutMs);
+    const testsResult = await _internals44.runTestsCheck(validatedDir, cfg.testScope, cfg.checkTimeoutMs);
     checks5.push(testsResult);
     log(`[Preflight] Tests check: ${testsResult.status} ${testsResult.message}`);
   } else {
@@ -64386,7 +64470,7 @@ async function runPreflight(dir, phase, config3) {
   }
   if (!cfg.skipSecrets) {
     log("[Preflight] Running secrets check...");
-    const secretsResult = await _internals43.runSecretsCheck(validatedDir, cfg.checkTimeoutMs);
+    const secretsResult = await _internals44.runSecretsCheck(validatedDir, cfg.checkTimeoutMs);
     checks5.push(secretsResult);
     log(`[Preflight] Secrets check: ${secretsResult.status} ${secretsResult.message}`);
   } else {
@@ -64398,7 +64482,7 @@ async function runPreflight(dir, phase, config3) {
   }
   if (!cfg.skipEvidence) {
     log("[Preflight] Running evidence check...");
-    const evidenceResult = await _internals43.runEvidenceCheck(validatedDir);
+    const evidenceResult = await _internals44.runEvidenceCheck(validatedDir);
     checks5.push(evidenceResult);
     log(`[Preflight] Evidence check: ${evidenceResult.status} ${evidenceResult.message}`);
   } else {
@@ -64409,12 +64493,12 @@ async function runPreflight(dir, phase, config3) {
     });
   }
   log("[Preflight] Running requirement coverage check...");
-  const reqCoverageResult = await _internals43.runRequirementCoverageCheck(validatedDir, phase);
+  const reqCoverageResult = await _internals44.runRequirementCoverageCheck(validatedDir, phase);
   checks5.push(reqCoverageResult);
   log(`[Preflight] Requirement coverage check: ${reqCoverageResult.status} ${reqCoverageResult.message}`);
   if (!cfg.skipVersion) {
     log("[Preflight] Running version check...");
-    const versionResult = await _internals43.runVersionCheck(validatedDir, cfg.checkTimeoutMs);
+    const versionResult = await _internals44.runVersionCheck(validatedDir, cfg.checkTimeoutMs);
     checks5.push(versionResult);
     log(`[Preflight] Version check: ${versionResult.status} ${versionResult.message}`);
   } else {
@@ -64477,10 +64561,10 @@ function formatPreflightMarkdown(report) {
 async function handlePreflightCommand(directory, _args) {
   const plan = await loadPlan(directory);
   const phase = plan?.current_phase ?? 1;
-  const report = await _internals43.runPreflight(directory, phase);
-  return _internals43.formatPreflightMarkdown(report);
+  const report = await _internals44.runPreflight(directory, phase);
+  return _internals44.formatPreflightMarkdown(report);
 }
-var MIN_CHECK_TIMEOUT_MS = 5000, MAX_CHECK_TIMEOUT_MS = 300000, DEFAULT_CONFIG, _internals43;
+var MIN_CHECK_TIMEOUT_MS = 5000, MAX_CHECK_TIMEOUT_MS = 300000, DEFAULT_CONFIG, _internals44;
 var init_preflight_service = __esm(() => {
   init_gate_bridge();
   init_manager2();
@@ -64499,7 +64583,7 @@ var init_preflight_service = __esm(() => {
     testScope: "convention",
     linter: "biome"
   };
-  _internals43 = {
+  _internals44 = {
     runPreflight,
     formatPreflightMarkdown,
     handlePreflightCommand,
@@ -65386,7 +65470,7 @@ var init_manager3 = __esm(() => {
 
 // src/commands/reset.ts
 import * as fs32 from "fs";
-import * as path62 from "path";
+import * as path63 from "path";
 async function handleResetCommand(directory, args) {
   const hasConfirm = args.includes("--confirm");
   if (!hasConfirm) {
@@ -65426,7 +65510,7 @@ async function handleResetCommand(directory, args) {
   }
   for (const filename of ["SWARM_PLAN.md", "SWARM_PLAN.json"]) {
     try {
-      const rootPath = path62.join(directory, filename);
+      const rootPath = path63.join(directory, filename);
       if (fs32.existsSync(rootPath)) {
         fs32.unlinkSync(rootPath);
         results.push(`- \u2705 Deleted ${filename} (root)`);
@@ -65466,7 +65550,7 @@ var init_reset = __esm(() => {
 
 // src/commands/reset-session.ts
 import * as fs33 from "fs";
-import * as path63 from "path";
+import * as path64 from "path";
 async function handleResetSessionCommand(directory, _args) {
   const results = [];
   try {
@@ -65481,13 +65565,13 @@ async function handleResetSessionCommand(directory, _args) {
     results.push("\u274C Failed to delete state.json");
   }
   try {
-    const sessionDir = path63.dirname(validateSwarmPath(directory, "session/state.json"));
+    const sessionDir = path64.dirname(validateSwarmPath(directory, "session/state.json"));
     if (fs33.existsSync(sessionDir)) {
       const files = fs33.readdirSync(sessionDir);
       const otherFiles = files.filter((f) => f !== "state.json");
       let deletedCount = 0;
       for (const file3 of otherFiles) {
-        const filePath = path63.join(sessionDir, file3);
+        const filePath = path64.join(sessionDir, file3);
         if (fs33.lstatSync(filePath).isFile()) {
           fs33.unlinkSync(filePath);
           deletedCount++;
@@ -65519,7 +65603,7 @@ var init_reset_session = __esm(() => {
 });
 
 // src/summaries/manager.ts
-import * as path64 from "path";
+import * as path65 from "path";
 function sanitizeSummaryId(id) {
   if (!id || id.length === 0) {
     throw new Error("Invalid summary ID: empty string");
@@ -65542,7 +65626,7 @@ function sanitizeSummaryId(id) {
 }
 async function loadFullOutput(directory, id) {
   const sanitizedId = sanitizeSummaryId(id);
-  const relativePath = path64.join("summaries", `${sanitizedId}.json`);
+  const relativePath = path65.join("summaries", `${sanitizedId}.json`);
   validateSwarmPath(directory, relativePath);
   const content = await readSwarmFileAsync(directory, relativePath);
   if (content === null) {
@@ -65605,7 +65689,7 @@ var init_retrieve = __esm(() => {
 
 // src/commands/rollback.ts
 import * as fs34 from "fs";
-import * as path65 from "path";
+import * as path66 from "path";
 async function handleRollbackCommand(directory, args) {
   const phaseArg = args[0];
   if (!phaseArg) {
@@ -65670,8 +65754,8 @@ async function handleRollbackCommand(directory, args) {
     if (EXCLUDE_FILES.has(file3) || file3.startsWith("plan-ledger.archived-")) {
       continue;
     }
-    const src = path65.join(checkpointDir, file3);
-    const dest = path65.join(swarmDir, file3);
+    const src = path66.join(checkpointDir, file3);
+    const dest = path66.join(swarmDir, file3);
     try {
       fs34.cpSync(src, dest, { recursive: true, force: true });
       successes.push(file3);
@@ -65690,12 +65774,12 @@ async function handleRollbackCommand(directory, args) {
     ].join(`
 `);
   }
-  const existingLedgerPath = path65.join(swarmDir, "plan-ledger.jsonl");
+  const existingLedgerPath = path66.join(swarmDir, "plan-ledger.jsonl");
   if (fs34.existsSync(existingLedgerPath)) {
     fs34.unlinkSync(existingLedgerPath);
   }
   try {
-    const planJsonPath = path65.join(swarmDir, "plan.json");
+    const planJsonPath = path66.join(swarmDir, "plan.json");
     if (fs34.existsSync(planJsonPath)) {
       const planRaw = fs34.readFileSync(planJsonPath, "utf-8");
       const plan = PlanSchema.parse(JSON.parse(planRaw));
@@ -65924,7 +66008,7 @@ async function handleSimulateCommand(directory, args) {
   }
   let darkMatterPairs;
   try {
-    darkMatterPairs = await _internals23.detectDarkMatter(directory, options);
+    darkMatterPairs = await _internals24.detectDarkMatter(directory, options);
   } catch (err) {
     const errMsg = err instanceof Error ? err.message : String(err);
     return `## Simulate Report
@@ -65954,9 +66038,9 @@ Ensure this is a git repository with commit history.`;
 `);
   try {
     const fs35 = await import("fs/promises");
-    const path66 = await import("path");
-    const reportPath = path66.join(directory, ".swarm", "simulate-report.md");
-    await fs35.mkdir(path66.dirname(reportPath), { recursive: true });
+    const path67 = await import("path");
+    const reportPath = path67.join(directory, ".swarm", "simulate-report.md");
+    await fs35.mkdir(path67.dirname(reportPath), { recursive: true });
     await fs35.writeFile(reportPath, report, "utf-8");
   } catch (err) {
     const writeErr = err instanceof Error ? err.message : String(err);
@@ -65980,12 +66064,12 @@ async function handleSpecifyCommand(_directory, args) {
 
 // src/turbo/lean/state.ts
 import * as fs35 from "fs";
-import * as path66 from "path";
+import * as path67 from "path";
 function nowISO2() {
   return new Date().toISOString();
 }
 function ensureSwarmDir3(directory) {
-  const swarmDir = path66.resolve(directory, ".swarm");
+  const swarmDir = path67.resolve(directory, ".swarm");
   if (!fs35.existsSync(swarmDir)) {
     fs35.mkdirSync(swarmDir, { recursive: true });
   }
@@ -66029,7 +66113,7 @@ function markStateUnreadable2(directory, reason) {
 }
 function readPersisted2(directory) {
   try {
-    const filePath = path66.join(directory, ".swarm", STATE_FILE2);
+    const filePath = path67.join(directory, ".swarm", STATE_FILE2);
     if (!fs35.existsSync(filePath)) {
       const seed = emptyPersisted2();
       try {
@@ -66065,7 +66149,7 @@ function writePersisted2(directory, persisted) {
   let payload;
   try {
     ensureSwarmDir3(directory);
-    filePath = path66.join(directory, ".swarm", STATE_FILE2);
+    filePath = path67.join(directory, ".swarm", STATE_FILE2);
     tmpPath = `${filePath}.tmp.${Date.now()}`;
     persisted.updatedAt = nowISO2();
     payload = `${JSON.stringify(persisted, null, 2)}
@@ -66193,10 +66277,10 @@ var init_context_budget_service = __esm(() => {
 // src/services/status-service.ts
 import * as fsSync3 from "fs";
 import { readFile as readFile19 } from "fs/promises";
-import * as path67 from "path";
+import * as path68 from "path";
 function readSpecStalenessSnapshot(directory) {
   try {
-    const p = path67.join(directory, ".swarm", "spec-staleness.json");
+    const p = path68.join(directory, ".swarm", "spec-staleness.json");
     if (!fsSync3.existsSync(p))
       return { stale: false };
     const raw = fsSync3.readFileSync(p, "utf-8");
@@ -66294,7 +66378,7 @@ async function getStatusData(directory, agents) {
 }
 function enrichWithLeanTurbo(status, directory) {
   const turboMode = hasActiveTurboMode();
-  const leanActive = _internals44.hasActiveLeanTurbo();
+  const leanActive = _internals45.hasActiveLeanTurbo();
   let turboStrategy = "off";
   if (leanActive) {
     turboStrategy = "lean";
@@ -66313,7 +66397,7 @@ function enrichWithLeanTurbo(status, directory) {
     }
   }
   if (leanSessionID) {
-    const runState = _internals44.loadLeanTurboRunState(directory, leanSessionID);
+    const runState = _internals45.loadLeanTurboRunState(directory, leanSessionID);
     if (runState) {
       status.leanTurboPhase = runState.phase;
       status.leanMaxParallelCoders = runState.maxParallelCoders;
@@ -66345,7 +66429,7 @@ function enrichWithLeanTurbo(status, directory) {
       }
     }
   }
-  status.fullAutoActive = _internals44.hasActiveFullAuto();
+  status.fullAutoActive = _internals45.hasActiveFullAuto();
   return status;
 }
 function formatStatusMarkdown(status) {
@@ -66473,7 +66557,7 @@ async function countProposals(directory) {
     return 0;
   }
 }
-var _internals44;
+var _internals45;
 var init_status_service = __esm(() => {
   init_extractors();
   init_knowledge_escalator();
@@ -66483,7 +66567,7 @@ var init_status_service = __esm(() => {
   init_state3();
   init_compaction_service();
   init_context_budget_service();
-  _internals44 = {
+  _internals45 = {
     loadLeanTurboRunState,
     hasActiveLeanTurbo,
     hasActiveFullAuto
@@ -66574,7 +66658,7 @@ async function handleTurboCommand(directory, args, sessionID) {
   if (arg0 === "on") {
     let strategy = "standard";
     try {
-      const { config: config3 } = _internals45.loadPluginConfigWithMeta(directory);
+      const { config: config3 } = _internals46.loadPluginConfigWithMeta(directory);
       if (config3.turbo?.strategy === "lean") {
         strategy = "lean";
       }
@@ -66629,7 +66713,7 @@ function enableLeanTurbo(session, directory, sessionID) {
   let maxParallelCoders = 4;
   let conflictPolicy = "serialize";
   try {
-    const { config: config3 } = _internals45.loadPluginConfigWithMeta(directory);
+    const { config: config3 } = _internals46.loadPluginConfigWithMeta(directory);
     const leanConfig = config3.turbo?.lean;
     if (leanConfig) {
       maxParallelCoders = leanConfig.max_parallel_coders ?? 4;
@@ -66699,13 +66783,13 @@ function buildStatusMessage2(session, directory, sessionID) {
   ].join(`
 `);
 }
-var _internals45;
+var _internals46;
 var init_turbo = __esm(() => {
   init_config();
   init_state();
   init_state3();
   init_logger();
-  _internals45 = {
+  _internals46 = {
     loadPluginConfigWithMeta
   };
 });
@@ -67262,24 +67346,24 @@ function validateAliases() {
       }
       aliasTargets.get(target).push(name);
       const visited = new Set;
-      const path68 = [];
+      const path69 = [];
       let current = target;
       while (current) {
         const currentEntry = COMMAND_REGISTRY[current];
         if (!currentEntry)
           break;
         if (visited.has(current)) {
-          const cycleStart = path68.indexOf(current);
+          const cycleStart = path69.indexOf(current);
           const fullChain = [
             name,
-            ...path68.slice(0, cycleStart > 0 ? cycleStart : path68.length),
+            ...path69.slice(0, cycleStart > 0 ? cycleStart : path69.length),
             current
           ].join(" \u2192 ");
           errors5.push(`Circular alias detected: ${fullChain}`);
           break;
         }
         visited.add(current);
-        path68.push(current);
+        path69.push(current);
         current = currentEntry.aliasOf || "";
       }
     }
@@ -68147,57 +68231,57 @@ init_cache_paths();
 init_constants();
 import * as fs36 from "fs";
 import * as os10 from "os";
-import * as path68 from "path";
+import * as path69 from "path";
 var { version: version5 } = package_default;
 var CONFIG_DIR = getPluginConfigDir();
-var OPENCODE_CONFIG_PATH = path68.join(CONFIG_DIR, "opencode.json");
-var PLUGIN_CONFIG_PATH = path68.join(CONFIG_DIR, "opencode-swarm.json");
-var PROMPTS_DIR = path68.join(CONFIG_DIR, "opencode-swarm");
+var OPENCODE_CONFIG_PATH = path69.join(CONFIG_DIR, "opencode.json");
+var PLUGIN_CONFIG_PATH = path69.join(CONFIG_DIR, "opencode-swarm.json");
+var PROMPTS_DIR = path69.join(CONFIG_DIR, "opencode-swarm");
 var OPENCODE_PLUGIN_CACHE_PATHS = getPluginCachePaths();
 var OPENCODE_PLUGIN_LOCK_FILE_PATHS = getPluginLockFilePaths();
 function isSafeCachePath(p) {
-  const resolved = path68.resolve(p);
-  const home = path68.resolve(os10.homedir());
+  const resolved = path69.resolve(p);
+  const home = path69.resolve(os10.homedir());
   if (resolved === "/" || resolved === home || resolved.length <= home.length) {
     return false;
   }
-  const segments = resolved.split(path68.sep).filter((s) => s.length > 0);
+  const segments = resolved.split(path69.sep).filter((s) => s.length > 0);
   if (segments.length < 4) {
     return false;
   }
-  const leaf = path68.basename(resolved);
+  const leaf = path69.basename(resolved);
   if (leaf !== "opencode-swarm@latest" && leaf !== "opencode-swarm") {
     return false;
   }
-  const parent = path68.basename(path68.dirname(resolved));
+  const parent = path69.basename(path69.dirname(resolved));
   if (parent !== "packages" && parent !== "node_modules") {
     return false;
   }
-  const grandparent = path68.basename(path68.dirname(path68.dirname(resolved)));
+  const grandparent = path69.basename(path69.dirname(path69.dirname(resolved)));
   if (grandparent !== "opencode") {
     return false;
   }
   return true;
 }
 function isSafeLockFilePath(p) {
-  const resolved = path68.resolve(p);
-  const home = path68.resolve(os10.homedir());
+  const resolved = path69.resolve(p);
+  const home = path69.resolve(os10.homedir());
   if (resolved === "/" || resolved === home || resolved.length <= home.length) {
     return false;
   }
-  const segments = resolved.split(path68.sep).filter((s) => s.length > 0);
+  const segments = resolved.split(path69.sep).filter((s) => s.length > 0);
   if (segments.length < 4) {
     return false;
   }
-  const leaf = path68.basename(resolved);
+  const leaf = path69.basename(resolved);
   if (leaf !== "bun.lock" && leaf !== "bun.lockb" && leaf !== "package-lock.json") {
     return false;
   }
-  const parent = path68.basename(path68.dirname(resolved));
+  const parent = path69.basename(path69.dirname(resolved));
   if (parent !== "opencode") {
     return false;
   }
-  const grandparent = path68.basename(path68.dirname(path68.dirname(resolved)));
+  const grandparent = path69.basename(path69.dirname(path69.dirname(resolved)));
   if (grandparent === "opencode") {
     return false;
   }
@@ -68223,8 +68307,8 @@ function saveJson(filepath, data) {
 }
 function writeProjectConfigIfMissing(cwd) {
   try {
-    const opencodeDir = path68.join(cwd, ".opencode");
-    const projectConfigPath = path68.join(opencodeDir, "opencode-swarm.json");
+    const opencodeDir = path69.join(cwd, ".opencode");
+    const projectConfigPath = path69.join(opencodeDir, "opencode-swarm.json");
     if (fs36.existsSync(projectConfigPath)) {
       return;
     }
@@ -68241,7 +68325,7 @@ async function install() {
 `);
   ensureDir(CONFIG_DIR);
   ensureDir(PROMPTS_DIR);
-  const LEGACY_CONFIG_PATH = path68.join(CONFIG_DIR, "config.json");
+  const LEGACY_CONFIG_PATH = path69.join(CONFIG_DIR, "config.json");
   let opencodeConfig = loadJson(OPENCODE_CONFIG_PATH);
   if (!opencodeConfig) {
     const legacyConfig = loadJson(LEGACY_CONFIG_PATH);