opencode-swarm 7.106.0 → 7.107.0

package/dist/cli/{index-f4yjypa4.js → index-fhw0jm5c.js}

@@ -117,7 +117,7 @@ import {
   validateProjectRoot,
   validateSpeckit,
   writeProjectedSpecSync
-} from "./index-k2rmw9sz.js";
+} from "./index-25pev4e7.js";
 import {
   _internals as _internals2,
   _internals1 as _internals3,
@@ -316,7 +316,7 @@ var init_bubblewrap = __esm(() => {
 import { spawnSync as spawnSync2 } from "child_process";
 import { mkdtempSync, writeFileSync } from "fs";
 import * as os5 from "os";
-import * as path10 from "path";
+import * as path11 from "path";
 function probeSandboxExec() {
   try {
     const result = spawnSync2("sandbox-exec", ["--version"], {
@@ -344,8 +344,8 @@ function probeSandboxExec() {
 function shellEscape2(s) {
   return s.replace(/'/g, "'\\''");
 }
-function sbplEscapePath(path11) {
-  const withoutControlChars = path11.split("").filter((ch) => {
+function sbplEscapePath(path12) {
+  const withoutControlChars = path12.split("").filter((ch) => {
     const cp = ch.codePointAt(0);
     return cp >= 32 && cp !== 127;
   }).join("");
@@ -421,8 +421,8 @@ class MacOSSandboxExecutor {
     const profile = buildSandboxProfile(allScopes, temp);
     let profilePath;
     try {
-      const profileDir = mkdtempSync(path10.join(os5.tmpdir(), "sandbox-"));
-      profilePath = path10.join(profileDir, `profile-${process.pid}-${Date.now()}.sb`);
+      const profileDir = mkdtempSync(path11.join(os5.tmpdir(), "sandbox-"));
+      profilePath = path11.join(profileDir, `profile-${process.pid}-${Date.now()}.sb`);
       writeFileSync(profilePath, profile, { mode: 384 });
     } catch (err) {
       const message = err instanceof Error ? err.message : String(err);
@@ -529,7 +529,7 @@ var init_edge_cases = () => {};
 // src/sandbox/win32/restricted-environment-executor.ts
 import { spawnSync as spawnSync3 } from "child_process";
 import * as os6 from "os";
-import * as path11 from "path";
+import * as path12 from "path";
 function probeWindowsSandbox() {
   try {
     const result = spawnSync3("cmd", ["/c", "echo", "ok"], {
@@ -576,7 +576,7 @@ function isPathInScopes(command, scopes) {
   const paths = command.match(pathPattern) || [];
   if (paths.length === 0)
     return true;
-  const normalizedPaths = paths.map((p) => path11.win32.resolve(p));
+  const normalizedPaths = paths.map((p) => path12.win32.resolve(p));
   const normalizedScopes = scopes.map((s) => s.toLowerCase().replace(/\\+$/, ""));
   return normalizedPaths.every((p) => {
     const lower = p.toLowerCase();
@@ -713,7 +713,7 @@ var init_restricted_environment_executor = __esm(() => {
 import * as crypto2 from "crypto";
 import * as fs3 from "fs";
 import * as os7 from "os";
-import * as path12 from "path";
+import * as path13 from "path";
 
 class NativeWindowsSandboxExecutor {
   mechanism;
@@ -775,11 +775,11 @@ class NativeWindowsSandboxExecutor {
     policy.workspace_roots = scopePaths.length > 0 ? scopePaths : [workspaceRoot];
     policy.writable_roots = policy.workspace_roots;
     const policyJson = JSON.stringify(policy);
-    const policyDir = path12.join(os7.tmpdir(), "swarm-sandbox-policies");
+    const policyDir = path13.join(os7.tmpdir(), "swarm-sandbox-policies");
     try {
       fs3.mkdirSync(policyDir, { recursive: true });
     } catch {}
-    const policyFile = path12.join(policyDir, `${runId}.json`);
+    const policyFile = path13.join(policyDir, `${runId}.json`);
     fs3.writeFileSync(policyFile, policyJson, "utf-8");
     const mode = this._probeResult.mode === "none" ? "auto" : this._probeResult.mode;
     const escapedBinary = binary.includes(" ") ? `"${binary}"` : binary;
@@ -912,7 +912,7 @@ var init_executor = __esm(() => {
 // package.json
 var package_default = {
   name: "opencode-swarm",
-  version: "7.106.0",
+  version: "7.107.0",
   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",
@@ -1020,6 +1020,7 @@ var package_default = {
 
 // src/commands/acknowledge-spec-drift.ts
 import { promises as fsPromises } from "fs";
+import * as path from "path";
 async function handleAcknowledgeSpecDriftCommand(directory, _args, acknowledgedBy = "unknown") {
   const specStalenessPath = validateSwarmPath(directory, "spec-staleness.json");
   let stalenessContent;
@@ -1053,6 +1054,13 @@ Please re-run the relevant phase to detect current drift status.`;
       currentHash = await computeSpecHash(directory);
       plan.specHash = currentHash ?? undefined;
       await savePlan(directory, plan);
+      try {
+        const currentSpec = readEffectiveSpecSync(directory);
+        if (currentSpec) {
+          const snapshotPath = path.join(directory, ".swarm", "spec-snapshot.md");
+          await fsPromises.writeFile(snapshotPath, currentSpec.content, "utf-8");
+        }
+      } catch {}
     }
   } catch (planError) {
     console.error("[acknowledge-spec-drift] Failed to update plan specHash:", planError instanceof Error ? planError.message : String(planError));
@@ -1169,11 +1177,11 @@ async function handleAnalyzeCommand(_directory, args) {
 // src/config/loader.ts
 import * as fs from "fs";
 import * as os from "os";
-import * as path from "path";
+import * as path2 from "path";
 var CONFIG_FILENAME = "opencode-swarm.json";
 var MAX_CONFIG_FILE_BYTES = 102400;
 function getUserConfigDir() {
-  return process.env.XDG_CONFIG_HOME || path.join(os.homedir(), ".config");
+  return process.env.XDG_CONFIG_HOME || path2.join(os.homedir(), ".config");
 }
 function loadRawConfigFromPath(configPath) {
   try {
@@ -1259,8 +1267,8 @@ function rawFullAutoLocked(raw) {
   return fullAuto.locked === true;
 }
 function loadPluginConfig(directory) {
-  const userConfigPath = path.join(getUserConfigDir(), "opencode", CONFIG_FILENAME);
-  const projectConfigPath = path.join(directory, ".opencode", CONFIG_FILENAME);
+  const userConfigPath = path2.join(getUserConfigDir(), "opencode", CONFIG_FILENAME);
+  const projectConfigPath = path2.join(directory, ".opencode", CONFIG_FILENAME);
   const userResult = loadRawConfigFromPath(userConfigPath);
   const projectResult = loadRawConfigFromPath(projectConfigPath);
   const rawUserConfig = userResult.config;
@@ -1305,8 +1313,8 @@ function loadPluginConfig(directory) {
   return result.data;
 }
 function loadPluginConfigWithMeta(directory) {
-  const userConfigPath = path.join(getUserConfigDir(), "opencode", CONFIG_FILENAME);
-  const projectConfigPath = path.join(directory, ".opencode", CONFIG_FILENAME);
+  const userConfigPath = path2.join(getUserConfigDir(), "opencode", CONFIG_FILENAME);
+  const projectConfigPath = path2.join(directory, ".opencode", CONFIG_FILENAME);
   const userResult = loadRawConfigFromPath(userConfigPath);
   const projectResult = loadRawConfigFromPath(projectConfigPath);
   const loadedFromFile = userResult.fileExisted || projectResult.fileExisted;
@@ -1394,7 +1402,7 @@ async function handleArchiveCommand(directory, args) {
 // src/config/bundled-skills.ts
 import * as fs2 from "fs";
 import * as fsp from "fs/promises";
-import * as path2 from "path";
+import * as path3 from "path";
 var BUNDLED_PROJECT_SKILLS = [
   "brainstorm",
   "specify",
@@ -1427,7 +1435,7 @@ var MAX_SKILL_FILES = 64;
 var MAX_SKILL_BYTES = 512000;
 var syncedProjectSkillTargets = new Set;
 function getSyncCacheKey(projectDirectory, packageRoot) {
-  return `${path2.resolve(projectDirectory)}\x00${path2.resolve(packageRoot)}`;
+  return `${path3.resolve(projectDirectory)}\x00${path3.resolve(packageRoot)}`;
 }
 function warnBundledSkillSyncFailure(err) {
   const message = err instanceof Error ? err.message : String(err);
@@ -1457,12 +1465,12 @@ async function pathExistsAsync(p) {
   }
 }
 async function collectBundledSkillFilesBoundedAsync(sourceDir, state, relativeDir = "") {
-  const currentSource = path2.join(sourceDir, relativeDir);
+  const currentSource = path3.join(sourceDir, relativeDir);
   const entries = await fsp.readdir(currentSource, { withFileTypes: true });
   const files = [];
   for (const entry of entries) {
-    const relativeEntry = path2.join(relativeDir, entry.name);
-    const sourcePath = path2.join(sourceDir, relativeEntry);
+    const relativeEntry = path3.join(relativeDir, entry.name);
+    const sourcePath = path3.join(sourceDir, relativeEntry);
     if (entry.isSymbolicLink() || await isSymbolicLinkAsync(sourcePath))
       continue;
     if (entry.isDirectory()) {
@@ -1484,21 +1492,21 @@ async function collectBundledSkillFilesBoundedAsync(sourceDir, state, relativeDi
   return files;
 }
 async function rollbackCopiedFilesAsync(copiedFiles, destDir) {
-  const safeDestDir = path2.resolve(destDir);
+  const safeDestDir = path3.resolve(destDir);
   const dirs = new Set;
   for (const copiedFile of copiedFiles) {
-    const resolvedFile = path2.resolve(copiedFile);
-    const relative2 = path2.relative(safeDestDir, resolvedFile);
-    if (relative2.startsWith("..") || path2.isAbsolute(relative2))
+    const resolvedFile = path3.resolve(copiedFile);
+    const relative2 = path3.relative(safeDestDir, resolvedFile);
+    if (relative2.startsWith("..") || path3.isAbsolute(relative2))
       continue;
     try {
       await fsp.rm(resolvedFile, { force: true });
     } catch {}
-    dirs.add(path2.dirname(resolvedFile));
+    dirs.add(path3.dirname(resolvedFile));
   }
   for (const dir of [...dirs].sort((a, b) => b.length - a.length)) {
-    const relative2 = path2.relative(safeDestDir, path2.resolve(dir));
-    if (relative2.startsWith("..") || path2.isAbsolute(relative2))
+    const relative2 = path3.relative(safeDestDir, path3.resolve(dir));
+    if (relative2.startsWith("..") || path3.isAbsolute(relative2))
       continue;
     try {
       await fsp.rmdir(dir);
@@ -1513,9 +1521,9 @@ async function copyBundledDirectoryBoundedAsync(sourceDir, destDir) {
   const copiedFiles = [];
   try {
     for (const file of files) {
-      const sourcePath = path2.join(sourceDir, file.relativePath);
-      const destPath = path2.join(destDir, file.relativePath);
-      await fsp.mkdir(path2.dirname(destPath), { recursive: true });
+      const sourcePath = path3.join(sourceDir, file.relativePath);
+      const destPath = path3.join(destDir, file.relativePath);
+      await fsp.mkdir(path3.dirname(destPath), { recursive: true });
       try {
         await fsp.copyFile(sourcePath, destPath, fs2.constants.COPYFILE_EXCL);
         copiedFiles.push(destPath);
@@ -1534,19 +1542,19 @@ async function syncBundledProjectSkillsIfMissingAsync(projectDirectory, packageR
     const cacheKey = getSyncCacheKey(projectDirectory, packageRoot);
     if (syncedProjectSkillTargets.has(cacheKey))
       return;
-    const sourceRoot = path2.join(packageRoot, ".opencode", "skills");
-    const opencodeDir = path2.join(projectDirectory, ".opencode");
-    const skillsDir = path2.join(opencodeDir, "skills");
+    const sourceRoot = path3.join(packageRoot, ".opencode", "skills");
+    const opencodeDir = path3.join(projectDirectory, ".opencode");
+    const skillsDir = path3.join(opencodeDir, "skills");
     let sawBundledSource = false;
     if (!await ensureNotSymlinkedDirectoryAsync(opencodeDir))
       return;
     if (!await ensureNotSymlinkedDirectoryAsync(skillsDir))
       return;
     for (const slug of BUNDLED_PROJECT_SKILLS) {
-      const sourceDir = path2.join(sourceRoot, slug);
-      const sourceSkill = path2.join(sourceDir, "SKILL.md");
-      const destDir = path2.join(skillsDir, slug);
-      const destSkill = path2.join(destDir, "SKILL.md");
+      const sourceDir = path3.join(sourceRoot, slug);
+      const sourceSkill = path3.join(sourceDir, "SKILL.md");
+      const destDir = path3.join(skillsDir, slug);
+      const destSkill = path3.join(destDir, "SKILL.md");
       if (!await pathExistsAsync(sourceSkill))
         continue;
       sawBundledSource = true;
@@ -1572,7 +1580,7 @@ init_logger();
 
 // src/state.ts
 import * as fs6 from "fs/promises";
-import * as path17 from "path";
+import * as path18 from "path";
 
 // src/db/qa-gate-profile.ts
 import { createHash } from "crypto";
@@ -1580,7 +1588,7 @@ import { createHash } from "crypto";
 // src/db/project-db.ts
 import { existsSync as existsSync2, mkdirSync } from "fs";
 import { createRequire } from "module";
-import { join as join3, resolve as resolve2 } from "path";
+import { join as join4, resolve as resolve2 } from "path";
 var _DatabaseCtor = null;
 function loadDatabaseCtor() {
   if (_DatabaseCtor)
@@ -1647,7 +1655,7 @@ function runProjectMigrations(db) {
   }
 }
 function projectDbPath(directory) {
-  return join3(resolve2(directory), ".swarm", "swarm.db");
+  return join4(resolve2(directory), ".swarm", "swarm.db");
 }
 function projectDbExists(directory) {
   return existsSync2(projectDbPath(directory));
@@ -1657,10 +1665,10 @@ function getProjectDb(directory) {
   const existing = _projectDbs.get(key);
   if (existing)
     return existing;
-  const swarmDir = join3(key, ".swarm");
+  const swarmDir = join4(key, ".swarm");
   mkdirSync(swarmDir, { recursive: true });
   const Db = loadDatabaseCtor();
-  const db = new Db(join3(swarmDir, "swarm.db"));
+  const db = new Db(join4(swarmDir, "swarm.db"));
   db.run("PRAGMA journal_mode = WAL;");
   db.run("PRAGMA synchronous = NORMAL;");
   db.run("PRAGMA busy_timeout = 5000;");
@@ -1863,6 +1871,76 @@ var _internals6 = {
   platform: process.platform,
   sleep: (ms) => new Promise((resolve3) => setTimeout(resolve3, ms))
 };
+var MERGE_TIMEOUT_MS = 30000;
+async function runGit2(args, cwd, timeoutMs = MERGE_TIMEOUT_MS) {
+  const proc = _internals6.bunSpawn(["git", ...args], {
+    cwd,
+    timeout: timeoutMs,
+    stdin: "ignore",
+    stdout: "pipe",
+    stderr: "pipe",
+    env: { ...process.env, LC_ALL: "C" }
+  });
+  try {
+    const exitCode = await proc.exited;
+    const stdout = await proc.stdout.text();
+    const stderr = await proc.stderr.text();
+    return { exitCode, stdout, stderr };
+  } finally {
+    try {
+      proc.kill();
+    } catch {}
+  }
+}
+function extractSessionId(branchName) {
+  const segments = branchName.trim().split("/");
+  if (segments.length >= 3 && segments[0] === "swarm-lane") {
+    return segments[1];
+  }
+  if (segments.length >= 4 && segments[0] === "swarm" && segments[1] === "lane") {
+    return segments[2];
+  }
+  return null;
+}
+async function listLaneBranches(directory) {
+  const branches = new Set;
+  for (const pattern of ["swarm-lane/*", "swarm/lane/*"]) {
+    const result = await runGit2(["branch", "--format=%(refname:short)", "--list", pattern], directory);
+    if (result.exitCode !== 0)
+      continue;
+    for (const line of result.stdout.split(`
+`)) {
+      const branch = line.trim();
+      if (branch.length > 0)
+        branches.add(branch);
+    }
+  }
+  return [...branches];
+}
+async function cleanupOrphanedBranches(directory, activeSessionIds = []) {
+  const removed = [];
+  const skipped = [];
+  const errors = [];
+  const branches = await listLaneBranches(directory);
+  for (const branch of branches) {
+    const sessionId = extractSessionId(branch);
+    if (sessionId !== null && activeSessionIds.includes(sessionId)) {
+      skipped.push(branch);
+      continue;
+    }
+    const deleteResult = await runGit2(["branch", "-D", branch], directory);
+    if (deleteResult.exitCode === 0) {
+      removed.push(branch);
+    } else {
+      errors.push({
+        branch,
+        error: deleteResult.stderr.trim() || deleteResult.stdout.trim()
+      });
+    }
+  }
+  await runGit2(["worktree", "prune"], directory);
+  return { removed, skipped, errors };
+}
 // src/hooks/delegation-gate/worktree-isolation.ts
 var standardWorktreeByCallID = new Map;
 var standardWorktreeSerializationSessions = new Set;
@@ -2092,7 +2170,7 @@ import {
   rename,
   writeFile
 } from "fs/promises";
-import * as path3 from "path";
+import * as path4 from "path";
 
 // src/memory/schema.ts
 import { createHash as createHash2 } from "crypto";
@@ -3056,7 +3134,7 @@ class LocalJsonlMemoryProvider {
   pathFor(file) {
     const storageDir = this.config.storageDir.replace(/^\.swarm[/\\]?/, "");
     const filename = file === "memories" ? "memories.jsonl" : file === "proposals" ? "proposals.jsonl" : file === "audit" ? "audit.jsonl" : "reward-events.jsonl";
-    return validateSwarmPath(this.rootDirectory, path3.join(storageDir, filename));
+    return validateSwarmPath(this.rootDirectory, path4.join(storageDir, filename));
   }
   async initialize() {
     if (this.initialized)
@@ -3488,12 +3566,12 @@ function parseRewardEvent(value) {
   };
 }
 async function appendJsonl(filePath, value) {
-  await mkdir2(path3.dirname(filePath), { recursive: true });
+  await mkdir2(path4.dirname(filePath), { recursive: true });
   await appendFile(filePath, `${JSON.stringify(value)}
 `, "utf-8");
 }
 async function writeJsonlAtomic(filePath, values) {
-  await mkdir2(path3.dirname(filePath), { recursive: true });
+  await mkdir2(path4.dirname(filePath), { recursive: true });
   const tmp = `${filePath}.tmp.${randomUUID()}`;
   const content = values.map((value) => JSON.stringify(value)).join(`
 `) + (values.length > 0 ? `
@@ -3504,13 +3582,13 @@ async function writeJsonlAtomic(filePath, values) {
 
 // src/memory/provider-pool.ts
 import { realpathSync } from "fs";
-import * as path8 from "path";
+import * as path9 from "path";
 
 // src/memory/sqlite-provider.ts
 import { randomUUID as randomUUID2 } from "crypto";
 import { mkdirSync as mkdirSync4 } from "fs";
 import { createRequire as createRequire4 } from "module";
-import * as path7 from "path";
+import * as path8 from "path";
 
 // src/memory/embeddings/cache.ts
 var DEFAULT_CACHE_SIZE = 256;
@@ -3629,7 +3707,7 @@ function minMaxNormalise(candidates) {
 import { mkdirSync as mkdirSync2 } from "fs";
 import { createRequire as createRequire2 } from "module";
 import * as os3 from "os";
-import * as path4 from "path";
+import * as path5 from "path";
 
 // src/memory/embeddings/types.ts
 class EmbeddingUnavailableError extends Error {
@@ -3655,16 +3733,16 @@ var _internals7 = {
   resolveEmbeddingCacheDir() {
     let base;
     if (process.platform === "win32") {
-      base = process.env.LOCALAPPDATA || path4.join(os3.homedir(), "AppData", "Local");
+      base = process.env.LOCALAPPDATA || path5.join(os3.homedir(), "AppData", "Local");
     } else if (process.platform === "darwin") {
-      base = path4.join(os3.homedir(), "Library", "Caches");
+      base = path5.join(os3.homedir(), "Library", "Caches");
     } else {
-      base = process.env.XDG_CACHE_HOME || path4.join(os3.homedir(), ".cache");
+      base = process.env.XDG_CACHE_HOME || path5.join(os3.homedir(), ".cache");
     }
-    const resolved = path4.join(base, "opencode", "embeddings");
-    const segments = resolved.split(path4.sep);
+    const resolved = path5.join(base, "opencode", "embeddings");
+    const segments = resolved.split(path5.sep);
     if (segments.includes(".swarm")) {
-      const safeDefault = process.platform === "win32" ? path4.join(os3.homedir(), "AppData", "Local", "opencode", "embeddings") : process.platform === "darwin" ? path4.join(os3.homedir(), "Library", "Caches", "opencode", "embeddings") : path4.join(os3.homedir(), ".cache", "opencode", "embeddings");
+      const safeDefault = process.platform === "win32" ? path5.join(os3.homedir(), "AppData", "Local", "opencode", "embeddings") : process.platform === "darwin" ? path5.join(os3.homedir(), "Library", "Caches", "opencode", "embeddings") : path5.join(os3.homedir(), ".cache", "opencode", "embeddings");
       warn("Embedding cache dir resolved under .swarm/ \u2014 falling back to safe default");
       return safeDefault;
     }
@@ -3782,7 +3860,7 @@ class LocalEmbeddingProvider {
 import { mkdirSync as mkdirSync3 } from "fs";
 import { createRequire as createRequire3 } from "module";
 import * as os4 from "os";
-import * as path5 from "path";
+import * as path6 from "path";
 function shouldRerank(previousRecallElapsedMs, latencyBudgetMs) {
   return previousRecallElapsedMs <= latencyBudgetMs;
 }
@@ -3850,16 +3928,16 @@ class CrossEncoderReranker {
 function resolveRerankerCacheDir() {
   let base;
   if (process.platform === "win32") {
-    base = process.env.LOCALAPPDATA || path5.join(os4.homedir(), "AppData", "Local");
+    base = process.env.LOCALAPPDATA || path6.join(os4.homedir(), "AppData", "Local");
   } else if (process.platform === "darwin") {
-    base = path5.join(os4.homedir(), "Library", "Caches");
+    base = path6.join(os4.homedir(), "Library", "Caches");
   } else {
-    base = process.env.XDG_CACHE_HOME || path5.join(os4.homedir(), ".cache");
+    base = process.env.XDG_CACHE_HOME || path6.join(os4.homedir(), ".cache");
   }
-  const resolved = path5.join(base, "opencode", "embeddings");
-  const segments = resolved.split(path5.sep);
+  const resolved = path6.join(base, "opencode", "embeddings");
+  const segments = resolved.split(path6.sep);
   if (segments.includes(".swarm")) {
-    const safeDefault = process.platform === "win32" ? path5.join(os4.homedir(), "AppData", "Local", "opencode", "embeddings") : process.platform === "darwin" ? path5.join(os4.homedir(), "Library", "Caches", "opencode", "embeddings") : path5.join(os4.homedir(), ".cache", "opencode", "embeddings");
+    const safeDefault = process.platform === "win32" ? path6.join(os4.homedir(), "AppData", "Local", "opencode", "embeddings") : process.platform === "darwin" ? path6.join(os4.homedir(), "Library", "Caches", "opencode", "embeddings") : path6.join(os4.homedir(), ".cache", "opencode", "embeddings");
     warn("Reranker cache dir resolved under .swarm/ \u2014 falling back to safe default");
     return safeDefault;
   }
@@ -3869,7 +3947,7 @@ function resolveRerankerCacheDir() {
 // src/memory/jsonl-migration.ts
 import { existsSync as existsSync4, renameSync, unlinkSync } from "fs";
 import { copyFile as copyFile2, mkdir as mkdir3, readFile as readFile2, stat as stat2, writeFile as writeFile2 } from "fs/promises";
-import * as path6 from "path";
+import * as path7 from "path";
 var LEGACY_JSONL_MIGRATION_VERSION = 2;
 var LEGACY_JSONL_MIGRATION_NAME = "legacy_jsonl_import_complete";
 function resolveMemoryStorageDir(rootDirectory, config = {}) {
@@ -3885,8 +3963,8 @@ function resolveSqliteDatabasePath(rootDirectory, config = {}) {
 async function readLegacyJsonl(rootDirectory, config = {}) {
   const resolved = resolveConfig(config);
   const storageDir = resolveMemoryStorageDir(rootDirectory, resolved);
-  const memoryLoad = await readMemoryJsonl(path6.join(storageDir, "memories.jsonl"), resolved);
-  const proposalLoad = await readProposalJsonl(path6.join(storageDir, "proposals.jsonl"), resolved);
+  const memoryLoad = await readMemoryJsonl(path7.join(storageDir, "memories.jsonl"), resolved);
+  const proposalLoad = await readProposalJsonl(path7.join(storageDir, "proposals.jsonl"), resolved);
   return {
     memories: memoryLoad.records,
     proposals: proposalLoad.records,
@@ -3896,14 +3974,14 @@ async function readLegacyJsonl(rootDirectory, config = {}) {
 }
 async function backupLegacyJsonl(rootDirectory, config = {}) {
   const storageDir = resolveMemoryStorageDir(rootDirectory, config);
-  const backupDir = path6.join(storageDir, "backups");
+  const backupDir = path7.join(storageDir, "backups");
   await mkdir3(backupDir, { recursive: true });
   const results = [];
   for (const filename of ["memories.jsonl", "proposals.jsonl"]) {
-    const source = path6.join(storageDir, filename);
+    const source = path7.join(storageDir, filename);
     if (!existsSync4(source))
       continue;
-    const backup = path6.join(backupDir, `${filename}.pre-sqlite-migration`);
+    const backup = path7.join(backupDir, `${filename}.pre-sqlite-migration`);
     if (existsSync4(backup)) {
       results.push({ source, backup, created: false });
       continue;
@@ -3914,11 +3992,11 @@ async function backupLegacyJsonl(rootDirectory, config = {}) {
   return results;
 }
 async function writeJsonlExport(rootDirectory, config, memories, proposals) {
-  const exportDir = path6.join(resolveMemoryStorageDir(rootDirectory, config), "export");
+  const exportDir = path7.join(resolveMemoryStorageDir(rootDirectory, config), "export");
   await mkdir3(exportDir, { recursive: true });
-  const memoriesPath = path6.join(exportDir, "memories.jsonl");
-  const proposalsPath = path6.join(exportDir, "proposals.jsonl");
-  const memoriesTempPath = path6.join(path6.dirname(memoriesPath), `${path6.basename(memoriesPath)}.tmp.${Date.now()}.${Math.floor(Math.random() * 1e9)}`);
+  const memoriesPath = path7.join(exportDir, "memories.jsonl");
+  const proposalsPath = path7.join(exportDir, "proposals.jsonl");
+  const memoriesTempPath = path7.join(path7.dirname(memoriesPath), `${path7.basename(memoriesPath)}.tmp.${Date.now()}.${Math.floor(Math.random() * 1e9)}`);
   try {
     await writeFile2(memoriesTempPath, toJsonl(memories), "utf-8");
     renameSync(memoriesTempPath, memoriesPath);
@@ -3928,7 +4006,7 @@ async function writeJsonlExport(rootDirectory, config, memories, proposals) {
     } catch {}
     throw err;
   }
-  const proposalsTempPath = path6.join(path6.dirname(proposalsPath), `${path6.basename(proposalsPath)}.tmp.${Date.now()}.${Math.floor(Math.random() * 1e9)}`);
+  const proposalsTempPath = path7.join(path7.dirname(proposalsPath), `${path7.basename(proposalsPath)}.tmp.${Date.now()}.${Math.floor(Math.random() * 1e9)}`);
   try {
     await writeFile2(proposalsTempPath, toJsonl(proposals), "utf-8");
     renameSync(proposalsTempPath, proposalsPath);
@@ -3941,9 +4019,9 @@ async function writeJsonlExport(rootDirectory, config, memories, proposals) {
   return { directory: exportDir, memoriesPath, proposalsPath };
 }
 async function writeMigrationReport(rootDirectory, report, config = {}) {
-  const reportPath = path6.join(resolveMemoryStorageDir(rootDirectory, config), "migration-report.json");
-  await mkdir3(path6.dirname(reportPath), { recursive: true });
-  const reportTempPath = path6.join(path6.dirname(reportPath), `${path6.basename(reportPath)}.tmp.${Date.now()}.${Math.floor(Math.random() * 1e9)}`);
+  const reportPath = path7.join(resolveMemoryStorageDir(rootDirectory, config), "migration-report.json");
+  await mkdir3(path7.dirname(reportPath), { recursive: true });
+  const reportTempPath = path7.join(path7.dirname(reportPath), `${path7.basename(reportPath)}.tmp.${Date.now()}.${Math.floor(Math.random() * 1e9)}`);
   try {
     await writeFile2(reportTempPath, `${JSON.stringify(report, null, 2)}
 `, "utf-8");
@@ -3957,7 +4035,7 @@ async function writeMigrationReport(rootDirectory, report, config = {}) {
   return reportPath;
 }
 async function readMigrationReport(rootDirectory, config = {}) {
-  const reportPath = path6.join(resolveMemoryStorageDir(rootDirectory, config), "migration-report.json");
+  const reportPath = path7.join(resolveMemoryStorageDir(rootDirectory, config), "migration-report.json");
   if (!existsSync4(reportPath))
     return null;
   try {
@@ -3970,7 +4048,7 @@ async function getLegacyJsonlFileStatus(rootDirectory, config = {}) {
   const storageDir = resolveMemoryStorageDir(rootDirectory, config);
   const statuses = [];
   for (const file of ["memories.jsonl", "proposals.jsonl"]) {
-    const filePath = path6.join(storageDir, file);
+    const filePath = path7.join(storageDir, file);
     let sizeBytes = 0;
     if (existsSync4(filePath)) {
       sizeBytes = (await stat2(filePath)).size;
@@ -4341,7 +4419,7 @@ class SQLiteMemoryProvider {
   }
   async doInitialize() {
     const dbPath = this.databasePath();
-    mkdirSync4(path7.dirname(dbPath), { recursive: true });
+    mkdirSync4(path8.dirname(dbPath), { recursive: true });
     const Db = loadDatabaseCtor2();
     this.db = new Db(dbPath);
     this.db.run("PRAGMA journal_mode = WAL;");
@@ -5133,9 +5211,9 @@ class SQLiteMemoryProvider {
     try {
       const dimension = Math.max(1, Math.trunc(this.config.embeddings.dimension ?? 384));
       const req = createRequire4(import.meta.url);
-      const pkgDir = path7.dirname(req.resolve("@sqlite/sqlite-vec/package.json"));
+      const pkgDir = path8.dirname(req.resolve("@sqlite/sqlite-vec/package.json"));
       const ext = process.platform === "win32" ? ".dll" : process.platform === "darwin" ? ".dylib" : ".so";
-      const vec0Path = path7.join(pkgDir, `vec0${ext}`);
+      const vec0Path = path8.join(pkgDir, `vec0${ext}`);
       db.loadExtension(vec0Path);
       db.run(`CREATE VIRTUAL TABLE IF NOT EXISTS memory_items_vec USING vec0(
 				id TEXT PRIMARY KEY, embedding FLOAT[${dimension}]
@@ -5808,7 +5886,7 @@ function resolvePoolKey(directory) {
   try {
     return realpathSync(directory);
   } catch {
-    return path8.resolve(directory);
+    return path9.resolve(directory);
   }
 }
 function evictAndClose(directory) {
@@ -6259,6 +6337,24 @@ Before reviewing the plan, check whether it was silently mutated since last crit
    - If \`drift_detected: "unknown"\`: flag as warning and proceed with caution.
 3. Report spec-intent divergence: compare the approved baseline intent against what the current plan actually does, not just structural diff. Identify if the plan's purpose or scope has drifted from the original approved intent.
 
+## OBLIGATION TRACEABILITY CHECK (mandatory before plan review)
+
+Before scoring the plan against the quality rubric, verify that every MUST/SHALL
+SC-### obligation in .swarm/spec.md maps to at least one plan task.
+
+1. Read .swarm/spec.md. Extract every MUST/SHALL SC-### obligation.
+2. Read the full plan object (.swarm/plan.json) or .swarm/plan.md. Extract
+   every task ID, description, AND acceptance criteria.
+3. For each MUST/SHALL SC-###: determine whether any plan task covers it
+   (semantic match, not exact phrase). An SC-### is "mapped" if it is
+   referenced in ANY task's description OR acceptance field.
+4. If ANY MUST/SHALL SC-### has zero covering tasks: this is a structural
+   completeness failure. Return VERDICT: REJECTED immediately, enumerating
+   each unmapped obligation. Do not proceed to the quality rubric.
+
+This check mirrors the existing ANALYZE-mode SC-### coverage check
+(see ANALYZE mode, step 4).
+
 ## PLAN ASSESSMENT DIMENSIONS
 Evaluate ALL seven dimensions. Report any that fail:
 1. TASK ATOMICITY: Can each task be completed and QA'd independently?
@@ -6291,6 +6387,7 @@ RULES:
 - No code writing
 - Don't reject for style/formatting \u2014 focus on substance
 - If the plan is fundamentally sound with only minor concerns, APPROVE it
+- Unmapped MUST/SHALL SC-### obligations: VERDICT must be REJECTED (structural completeness failure, not a style concern)
 
 ---
 
@@ -7362,7 +7459,7 @@ function extractCurrentPhaseFromPlan(plan) {
 
 // src/hooks/guardrails/destructive-command.ts
 import * as fsSync from "fs";
-import * as path9 from "path";
+import * as path10 from "path";
 var DC_MAX_UNWRAP_DEPTH = 5;
 var DC_SAFE_TARGETS = new Set([
   "node_modules",
@@ -7526,16 +7623,16 @@ function dcIsRemotePath(p) {
   return DC_REMOTE_PREFIXES.some((pfx) => p.startsWith(pfx));
 }
 function dcLstatAncestorWalk(targetPath, cwd) {
-  const normalizedTarget = path9.resolve(cwd, targetPath);
-  const normalizedCwd = path9.resolve(cwd);
+  const normalizedTarget = path10.resolve(cwd, targetPath);
+  const normalizedCwd = path10.resolve(cwd);
   const ancestors = [];
   let current = normalizedTarget;
   while (true) {
     ancestors.push(current);
-    const parent = path9.dirname(current);
+    const parent = path10.dirname(current);
     if (parent === current)
       break;
-    const rel = path9.relative(normalizedCwd, current);
+    const rel = path10.relative(normalizedCwd, current);
     if (rel === "" || rel.startsWith(".."))
       break;
     current = parent;
@@ -7574,14 +7671,14 @@ function dcValidateTargets(targets, cwd) {
     const lstatBlock = dcLstatAncestorWalk(t, cwd);
     if (lstatBlock)
       return lstatBlock;
-    const basename3 = path9.basename(t);
+    const basename3 = path10.basename(t);
     if (t === basename3 && DC_SAFE_TARGETS.has(t)) {
       continue;
     }
     if (DC_FS_ROOTS.has(t) || DC_FS_ROOTS.has(t.replace(/\//g, "\\"))) {
       return `BLOCKED: Destructive command targets filesystem root "${t}"`;
     }
-    if (path9.isAbsolute(t) || /^[A-Za-z]:/.test(t)) {
+    if (path10.isAbsolute(t) || /^[A-Za-z]:/.test(t)) {
       for (const blocked of DC_BLOCKED_ABSOLUTE_PREFIXES) {
         if (t.startsWith(blocked)) {
           return `BLOCKED: Destructive command targets system path "${t}" which is under protected prefix "${blocked}"`;
@@ -7596,9 +7693,9 @@ function dcCheckJunctionCreation(segment, cwd) {
   if (mklinkMatch) {
     const target = mklinkMatch[2].trim();
     if (!dcHasUnresolvableVars(target)) {
-      const resolved = path9.resolve(cwd, target);
-      const rel = path9.relative(cwd, resolved);
-      if (rel.startsWith("..") || path9.isAbsolute(rel)) {
+      const resolved = path10.resolve(cwd, target);
+      const rel = path10.relative(cwd, resolved);
+      if (rel.startsWith("..") || path10.isAbsolute(rel)) {
         return `BLOCKED: Junction/symlink creation targeting path outside working directory: mklink target "${target}" resolves to "${resolved}" which is outside "${cwd}". Creating junctions to external paths and then deleting them recursively can destroy data.`;
       }
     }
@@ -7610,9 +7707,9 @@ function dcCheckJunctionCreation(segment, cwd) {
   if (newItemMatch) {
     const target = newItemMatch[1].trim();
     if (!dcHasUnresolvableVars(target)) {
-      const resolved = path9.resolve(cwd, target);
-      const rel = path9.relative(cwd, resolved);
-      if (rel.startsWith("..") || path9.isAbsolute(rel)) {
+      const resolved = path10.resolve(cwd, target);
+      const rel = path10.relative(cwd, resolved);
+      if (rel.startsWith("..") || path10.isAbsolute(rel)) {
         return `BLOCKED: Junction/symlink creation targeting path outside working directory: New-Item target "${target}" resolves to "${resolved}" which is outside "${cwd}". This pattern caused the K2.6 data-loss incident.`;
       }
     }
@@ -7622,9 +7719,9 @@ function dcCheckJunctionCreation(segment, cwd) {
   if (lnMatch) {
     const target = lnMatch[1].trim();
     if (!dcHasUnresolvableVars(target)) {
-      const resolved = path9.resolve(cwd, target);
-      const rel = path9.relative(cwd, resolved);
-      if (rel.startsWith("..") || path9.isAbsolute(rel)) {
+      const resolved = path10.resolve(cwd, target);
+      const rel = path10.relative(cwd, resolved);
+      if (rel.startsWith("..") || path10.isAbsolute(rel)) {
         return `BLOCKED: Symlink creation targeting path outside working directory: ln -s target "${target}" resolves to "${resolved}" which is outside "${cwd}". Symlinks to external paths combined with recursive deletion can destroy data.`;
       }
     }
@@ -7915,7 +8012,7 @@ init_executor();
 // src/scope/scope-persistence.ts
 var import_proper_lockfile = __toESM(require_proper_lockfile(), 1);
 import * as fs4 from "fs";
-import * as path13 from "path";
+import * as path14 from "path";
 var DEFAULT_TTL_MS = 24 * 60 * 60 * 1000;
 var LOCK_STALE_MS = 30 * 1000;
 var SCOPES_DIR = ".swarm/scopes";
@@ -7946,7 +8043,7 @@ var WINDOWS_RESERVED = new Set([
   "LPT9"
 ]);
 function getScopesDir(directory) {
-  return path13.join(directory, SCOPES_DIR);
+  return path14.join(directory, SCOPES_DIR);
 }
 function clearAllScopes(directory) {
   try {
@@ -7955,10 +8052,10 @@ function clearAllScopes(directory) {
 }
 
 // src/hooks/shell-write-detect.ts
-import * as path14 from "path";
+import * as path15 from "path";
 import parse from "bash-parser";
-function buildDedupeKey(category, operator, path15) {
-  return `${category}|${operator}|${path15 ?? "null"}`;
+function buildDedupeKey(category, operator, path16) {
+  return `${category}|${operator}|${path16 ?? "null"}`;
 }
 var REDIRECT_WRITE_TOKENS = new Set([
   "GREAT",
@@ -8018,16 +8115,16 @@ function detectProcessSubstitutionWrites(command) {
         results.push(builtinResult);
       const appendMatch = stage.match(/^\s*(.*?)\s*>>(\s*)(\S+)\s*$/);
       if (appendMatch) {
-        const path15 = appendMatch[3];
-        if (path15 && !isNullDevice(path15)) {
-          results.push({ category: "redirect", operator: ">>", path: path15 });
+        const path16 = appendMatch[3];
+        if (path16 && !isNullDevice(path16)) {
+          results.push({ category: "redirect", operator: ">>", path: path16 });
         }
       } else {
         const writeMatch = stage.match(/^\s*(.*?)\s*>(?!>)(\s*)(\S+)\s*$/);
         if (writeMatch) {
-          const path15 = writeMatch[3];
-          if (path15 && !isNullDevice(path15)) {
-            results.push({ category: "redirect", operator: ">", path: path15 });
+          const path16 = writeMatch[3];
+          if (path16 && !isNullDevice(path16)) {
+            results.push({ category: "redirect", operator: ">", path: path16 });
           }
         }
       }
@@ -8201,8 +8298,8 @@ function extractRedirectPath(fileNode) {
     return null;
   return text;
 }
-function isNullDevice(path15) {
-  return path15 === "/dev/null" || path15 === "/dev/zero" || path15 === "/dev/urandom";
+function isNullDevice(path16) {
+  return path16 === "/dev/null" || path16 === "/dev/zero" || path16 === "/dev/urandom";
 }
 function isNumeric(s) {
   return /^\d+$/.test(s);
@@ -8222,12 +8319,12 @@ function detectRedirects(cmd) {
     if (!opType || !REDIRECT_ALL_WRITE_TOKENS.has(opType))
       continue;
     const fileNode = r.file;
-    const path15 = extractRedirectPath(fileNode);
+    const path16 = extractRedirectPath(fileNode);
     const opLabel = operatorLabel(opNode);
     if (REDIRECT_WRITE_TOKENS.has(opType)) {
-      results.push({ category: "redirect", operator: opLabel, path: path15 });
+      results.push({ category: "redirect", operator: opLabel, path: path16 });
     } else if (REDIRECT_HERE_TOKENS.has(opType)) {
-      results.push({ category: "here_doc", operator: opLabel, path: path15 });
+      results.push({ category: "here_doc", operator: opLabel, path: path16 });
     }
   }
   return results;
@@ -8270,9 +8367,9 @@ function detectBuiltinWrites(cmd) {
     const suffixWords2 = getSuffixWords(cmd);
     for (const word of suffixWords2) {
       if (word.startsWith("of=")) {
-        const path15 = word.slice(3);
-        if (path15 && !isNullDevice(path15)) {
-          results.push({ category: "builtin_write", operator: "dd of=", path: path15 });
+        const path16 = word.slice(3);
+        if (path16 && !isNullDevice(path16)) {
+          results.push({ category: "builtin_write", operator: "dd of=", path: path16 });
         }
       }
     }
@@ -8391,12 +8488,12 @@ function detectNetworkDownloaders(cmd) {
     for (let i = 0;i < suffixWords.length; i++) {
       const word = suffixWords[i];
       if (word === "-o" && i + 1 < suffixWords.length) {
-        const path15 = suffixWords[i + 1];
-        if (!path15.startsWith("-")) {
+        const path16 = suffixWords[i + 1];
+        if (!path16.startsWith("-")) {
           results.push({
             category: "network_download",
             operator: "curl -o",
-            path: path15
+            path: path16
           });
         }
       } else if (word.startsWith("-o") && word.length > 2) {
@@ -8411,12 +8508,12 @@ function detectNetworkDownloaders(cmd) {
     for (let i = 0;i < suffixWords.length; i++) {
       const word = suffixWords[i];
       if (word === "-O" && i + 1 < suffixWords.length) {
-        const path15 = suffixWords[i + 1];
-        if (!path15.startsWith("-")) {
+        const path16 = suffixWords[i + 1];
+        if (!path16.startsWith("-")) {
           results.push({
             category: "network_download",
             operator: "wget -O",
-            path: path15
+            path: path16
           });
         }
       } else if (word.startsWith("-O") && word.length > 2) {
@@ -8525,9 +8622,9 @@ function detectGitDestructive(cmd) {
   if (first === "checkout") {
     const dashDashIdx = suffixWords.indexOf("--");
     if (dashDashIdx !== -1 && dashDashIdx + 1 < suffixWords.length) {
-      const path15 = suffixWords[dashDashIdx + 1];
-      const op = path15 === "." ? "git checkout -- ." : "git checkout --";
-      results.push({ category: "git_destructive", operator: op, path: path15 });
+      const path16 = suffixWords[dashDashIdx + 1];
+      const op = path16 === "." ? "git checkout -- ." : "git checkout --";
+      results.push({ category: "git_destructive", operator: op, path: path16 });
     }
   } else if (first === "restore") {
     const hasHard = suffixWords.some((w) => w === "--hard" || w === "-H" || w.startsWith("-") && w.includes("H"));
@@ -8647,10 +8744,10 @@ function detectPowerShellWrites(command) {
   if (redirectMatch) {
     const beforeRedirect = redirectMatch[1];
     const op = redirectMatch[2];
-    const path15 = redirectMatch[3];
+    const path16 = redirectMatch[3];
     const fdRedirectPattern = /\d>\s*$|\s\d>&$/;
     if (!fdRedirectPattern.test(`${beforeRedirect} ${op}`)) {
-      results.push({ category: "redirect", operator: op, path: path15 });
+      results.push({ category: "redirect", operator: op, path: path16 });
     }
   }
   const leadingRedirect = innerCommand.match(/^((?:>){1,2})\s+(\S+)$/);
@@ -8663,12 +8760,12 @@ function detectPowerShellWrites(command) {
   }
   const iwrMatch = trimmed.match(/^(?:Invoke-WebRequest|curl)\s.*?(?:-OutFile\s+(\S+)|-o\s+(\S+))/i);
   if (iwrMatch) {
-    const path15 = iwrMatch[1] || iwrMatch[2];
-    if (path15) {
+    const path16 = iwrMatch[1] || iwrMatch[2];
+    if (path16) {
       results.push({
         category: "network_download",
         operator: "Invoke-WebRequest -OutFile",
-        path: path15
+        path: path16
       });
     }
   }
@@ -8680,15 +8777,15 @@ function detectPowerShellWrites(command) {
     const rest = cmd.slice(cmdletMatch[0].length).trim();
     const pathFlagMatch = rest.match(/(?:-Path|-FilePath|-LiteralPath)\s+("([^"]+)"|'([^']+)'|(\S+))/i);
     if (pathFlagMatch) {
-      const path15 = pathFlagMatch[2] ?? pathFlagMatch[3] ?? pathFlagMatch[4] ?? "";
-      return { category: "redirect", operator: cmdletName, path: path15 };
+      const path16 = pathFlagMatch[2] ?? pathFlagMatch[3] ?? pathFlagMatch[4] ?? "";
+      return { category: "redirect", operator: cmdletName, path: path16 };
     }
     const tokens = rest.match(/(?:[^\s"-]+|"[^"]*"|'[^']*'|-[^\s]+)/g) ?? [];
     for (const token of tokens) {
       if (token.startsWith("-"))
         continue;
-      const path15 = token.replace(/^["']|["']$/g, "");
-      return { category: "redirect", operator: cmdletName, path: path15 };
+      const path16 = token.replace(/^["']|["']$/g, "");
+      return { category: "redirect", operator: cmdletName, path: path16 };
     }
     return null;
   }
@@ -8704,9 +8801,9 @@ function detectPowerShellWrites(command) {
     for (const token of tokens) {
       if (token.startsWith("-"))
         continue;
-      const path15 = token.replace(/^["']|["']$/g, "");
-      if (path15) {
-        results.push({ category: "redirect", operator: cmdletName, path: path15 });
+      const path16 = token.replace(/^["']|["']$/g, "");
+      if (path16) {
+        results.push({ category: "redirect", operator: cmdletName, path: path16 });
         break;
       }
     }
@@ -8719,8 +8816,8 @@ function detectPowerShellWrites(command) {
     const rest = cmd.slice(opMatch[0].length).trim();
     const destFlagMatch = rest.match(/-Destination\s+(\S+|"[^"]+"|'[^']+')/i);
     if (destFlagMatch) {
-      const path15 = destFlagMatch[1].replace(/^["']|["']$/g, "");
-      return { category: "builtin_write", operator: cmdletName, path: path15 };
+      const path16 = destFlagMatch[1].replace(/^["']|["']$/g, "");
+      return { category: "builtin_write", operator: cmdletName, path: path16 };
     }
     const tokens = [];
     const flagTakingValue = new Set([
@@ -8759,11 +8856,11 @@ function detectPowerShellWrites(command) {
       }
     }
     if (tokens.length >= 2) {
-      const path15 = tokens[tokens.length - 1].replace(/^["']|["']$/g, "");
-      return { category: "builtin_write", operator: cmdletName, path: path15 };
+      const path16 = tokens[tokens.length - 1].replace(/^["']|["']$/g, "");
+      return { category: "builtin_write", operator: cmdletName, path: path16 };
     } else if (tokens.length === 1) {
-      const path15 = tokens[0].replace(/^["']|["']$/g, "");
-      return { category: "builtin_write", operator: cmdletName, path: path15 };
+      const path16 = tokens[0].replace(/^["']|["']$/g, "");
+      return { category: "builtin_write", operator: cmdletName, path: path16 };
     }
     return null;
   }
@@ -8777,14 +8874,14 @@ function detectPowerShellWrites(command) {
     const afterCmdlet = pipeFileOpMatch[2].trim();
     const destFlagMatch = afterCmdlet.match(/-Destination\s+(\S+|"[^"]+"|'[^']+')/i);
     if (destFlagMatch) {
-      const path15 = destFlagMatch[1].replace(/^["']|["']$/g, "");
-      results.push({ category: "builtin_write", operator: cmdletName, path: path15 });
+      const path16 = destFlagMatch[1].replace(/^["']|["']$/g, "");
+      results.push({ category: "builtin_write", operator: cmdletName, path: path16 });
     } else {
       const tokens = afterCmdlet.match(/(?:[^\s"-]+|"[^"]*"|'[^']*'|-[^\s]+)/g) ?? [];
       const nonFlagTokens = tokens.filter((t) => !t.startsWith("-") && t.length > 0);
       if (nonFlagTokens.length > 0) {
-        const path15 = nonFlagTokens[nonFlagTokens.length - 1].replace(/^["']|["']$/g, "");
-        results.push({ category: "builtin_write", operator: cmdletName, path: path15 });
+        const path16 = nonFlagTokens[nonFlagTokens.length - 1].replace(/^["']|["']$/g, "");
+        results.push({ category: "builtin_write", operator: cmdletName, path: path16 });
       }
     }
   }
@@ -8837,10 +8934,10 @@ function detectCmdWrites(command) {
   if (redirectMatch) {
     const beforeRedirect = redirectMatch[1];
     const op = redirectMatch[2];
-    const path15 = redirectMatch[3];
+    const path16 = redirectMatch[3];
     const fdRedirectPattern = /\d>&?$/;
     if (!fdRedirectPattern.test(beforeRedirect)) {
-      results.push({ category: "redirect", operator: op, path: path15 });
+      results.push({ category: "redirect", operator: op, path: path16 });
     }
   }
   const leadingRedirect = innerCommand.match(/^((?:>){1,2})\s+(\S+)$/);
@@ -8898,8 +8995,8 @@ function detectCmdWrites(command) {
     const rawTokens = rest.match(/(\/?[^\s]+|"[^"]*"|'[^']*')/g) ?? [];
     const tokens = rawTokens.filter((t) => !t.startsWith("/"));
     if (tokens.length > 0) {
-      const path15 = tokens[0].replace(/^["']|["']$/g, "");
-      return { category: "builtin_write", operator: "del", path: path15 };
+      const path16 = tokens[0].replace(/^["']|["']$/g, "");
+      return { category: "builtin_write", operator: "del", path: path16 };
     }
     return null;
   }
@@ -8909,16 +9006,16 @@ function detectCmdWrites(command) {
   }
   const rdMatch = innerCommand.match(/^rd\s+(?:\/s\s+|\/q\s+)*(\S+)/i);
   if (rdMatch) {
-    const path15 = rdMatch[1].replace(/^["']|["']$/g, "");
-    if (!path15.startsWith("/")) {
-      results.push({ category: "builtin_write", operator: "rd", path: path15 });
+    const path16 = rdMatch[1].replace(/^["']|["']$/g, "");
+    if (!path16.startsWith("/")) {
+      results.push({ category: "builtin_write", operator: "rd", path: path16 });
     }
   }
   const mdMatch = trimmed.match(/^md\s+(\S+)/i);
   if (mdMatch) {
-    const path15 = mdMatch[1].replace(/^["']|["']$/g, "");
-    if (!path15.startsWith("/")) {
-      results.push({ category: "builtin_write", operator: "md", path: path15 });
+    const path16 = mdMatch[1].replace(/^["']|["']$/g, "");
+    if (!path16.startsWith("/")) {
+      results.push({ category: "builtin_write", operator: "md", path: path16 });
     }
   }
   const echoMatch = trimmed.match(/^echo\s+(\S+.*?)\s+((?:>){1,2})\s*(\S+)$/i);
@@ -9034,9 +9131,9 @@ function resolvePath(pathText, cwd) {
     return null;
   const isWindowsPath = /^[a-zA-Z]:[\\\\/]/.test(cwd) || cwd.includes("\\");
   if (isWindowsPath) {
-    return path14.win32.resolve(cwd, pathText);
+    return path15.win32.resolve(cwd, pathText);
   }
-  return path14.posix.resolve(cwd, pathText);
+  return path15.posix.resolve(cwd, pathText);
 }
 function getCdTarget(cmd) {
   if (!cmd || typeof cmd !== "object")
@@ -9103,7 +9200,7 @@ function collectWritesWithNodes(node, out, cwdStack) {
         for (const cmd of node.commands) {
           const cdTarget = getCdTarget(cmd);
           if (cdTarget) {
-            currentStack[0] = path14.posix.resolve(currentStack[0] ?? "/", cdTarget);
+            currentStack[0] = path15.posix.resolve(currentStack[0] ?? "/", cdTarget);
             collectWritesWithNodes(cmd, out, currentStack);
           } else {
             collectWritesWithNodes(cmd, out, currentStack);
@@ -9149,7 +9246,7 @@ function collectWritesWithNodes(node, out, cwdStack) {
       const effectiveCwd = cwdStack[0] ?? "/";
       const cdTarget = getCdTarget(node);
       if (cdTarget) {
-        cwdStack[0] = path14.posix.resolve(cwdStack[0] ?? "/", cdTarget);
+        cwdStack[0] = path15.posix.resolve(cwdStack[0] ?? "/", cdTarget);
         return;
       }
       const writesFromRedirs = getWritesFromCommandRedirs(node, effectiveCwd);
@@ -9195,12 +9292,12 @@ function getWritesFromRedirectNode(redirect, _context) {
   if (!opType || !REDIRECT_ALL_WRITE_TOKENS.has(opType))
     return [];
   const fileNode = r.file;
-  const path15 = extractRedirectPath(fileNode);
+  const path16 = extractRedirectPath(fileNode);
   const opLabel = operatorLabel(opNode);
   if (REDIRECT_WRITE_TOKENS.has(opType)) {
-    return [{ category: "redirect", operator: opLabel, path: path15 }];
+    return [{ category: "redirect", operator: opLabel, path: path16 }];
   } else if (REDIRECT_HERE_TOKENS.has(opType)) {
-    return [{ category: "here_doc", operator: opLabel, path: path15 }];
+    return [{ category: "here_doc", operator: opLabel, path: path16 }];
   }
   return [];
 }
@@ -9333,10 +9430,10 @@ function clearTrajectoryStepCounters(sessionId) {
 
 // src/prm/trajectory-store.ts
 import * as fs5 from "fs/promises";
-import * as path15 from "path";
+import * as path16 from "path";
 var MAX_TRACKED_TRAJECTORY_SESSIONS = 500;
 function getTrajectoryPath(sessionId, directory) {
-  const relativePath = path15.join("trajectories", `${sessionId}.jsonl`);
+  const relativePath = path16.join("trajectories", `${sessionId}.jsonl`);
   return validateSwarmPath(directory, relativePath);
 }
 var _inMemoryTrajectoryCache = new Map;
@@ -9395,7 +9492,7 @@ async function cleanupOldTrajectoryFiles(directory, maxAgeDays = 7) {
       for (const entry of entries) {
         if (!entry.isFile())
           continue;
-        const filePath = path15.join(dirPath, entry.name);
+        const filePath = path16.join(dirPath, entry.name);
         try {
           const stat4 = await fs5.stat(filePath);
           if (now - stat4.mtimeMs > cutoffMs) {
@@ -9409,13 +9506,13 @@ async function cleanupOldTrajectoryFiles(directory, maxAgeDays = 7) {
 
 // src/session/session-start-store.ts
 import { existsSync as existsSync5, mkdirSync as mkdirSync7, readFileSync as readFileSync3, writeFileSync as writeFileSync3 } from "fs";
-import * as path16 from "path";
+import * as path17 from "path";
 var SESSION_START_FILE = "session-start.jsonl";
 function recordSessionStart(directory, startMs) {
   try {
-    const swarmDir = path16.join(directory, ".swarm");
-    const sessionDir = path16.join(swarmDir, "session");
-    const filePath = path16.join(sessionDir, SESSION_START_FILE);
+    const swarmDir = path17.join(directory, ".swarm");
+    const sessionDir = path17.join(swarmDir, "session");
+    const filePath = path17.join(sessionDir, SESSION_START_FILE);
     const line = JSON.stringify({ startMs, ts: Date.now() });
     mkdirSync7(sessionDir, { recursive: true });
     writeFileSync3(filePath, `${line}
@@ -9424,7 +9521,7 @@ function recordSessionStart(directory, startMs) {
 }
 function readEarliestSessionStart(directory) {
   try {
-    const filePath = path16.join(directory, ".swarm", "session", SESSION_START_FILE);
+    const filePath = path17.join(directory, ".swarm", "session", SESSION_START_FILE);
     if (!existsSync5(filePath))
       return null;
     const content = readFileSync3(filePath, "utf-8");
@@ -10071,7 +10168,7 @@ function evidenceToWorkflowState(evidence) {
 }
 async function readPlanFromDisk(directory) {
   try {
-    const planPath = path17.join(directory, ".swarm", "plan.json");
+    const planPath = path18.join(directory, ".swarm", "plan.json");
     const content = await fs6.readFile(planPath, "utf-8");
     const parsed = JSON.parse(content);
     return PlanSchema.parse(parsed);
@@ -10082,7 +10179,7 @@ async function readPlanFromDisk(directory) {
 async function readGateEvidenceFromDisk(directory) {
   const evidenceMap = new Map;
   try {
-    const evidenceDir = path17.join(directory, ".swarm", "evidence");
+    const evidenceDir = path18.join(directory, ".swarm", "evidence");
     const entries = await fs6.readdir(evidenceDir, { withFileTypes: true });
     for (const entry of entries) {
       if (!entry.isFile() || !entry.name.endsWith(".json")) {
@@ -10093,7 +10190,7 @@ async function readGateEvidenceFromDisk(directory) {
         continue;
       }
       try {
-        const filePath = path17.join(evidenceDir, entry.name);
+        const filePath = path18.join(evidenceDir, entry.name);
         const content = await fs6.readFile(filePath, "utf-8");
         const parsed = JSON.parse(content);
         if (parsed && typeof parsed.taskId === "string" && Array.isArray(parsed.required_gates)) {
@@ -10315,7 +10412,7 @@ async function handleAutoProceedCommand(_directory, args, sessionID) {
 // src/services/cost-accounting.ts
 import * as fs7 from "fs";
 import * as os8 from "os";
-import * as path18 from "path";
+import * as path19 from "path";
 function summarizeTelemetryCosts(directory) {
   const summary = createEmptySummary();
   for (const event of readTelemetryEvents(directory)) {
@@ -10326,18 +10423,18 @@ function summarizeTelemetryCosts(directory) {
   return finalizeSummary(summary);
 }
 function readTelemetryEvents(directory) {
-  const swarmDir = path18.join(directory, ".swarm");
+  const swarmDir = path19.join(directory, ".swarm");
   const files = [
-    path18.join(swarmDir, "telemetry.jsonl.1"),
-    path18.join(swarmDir, "telemetry.jsonl")
+    path19.join(swarmDir, "telemetry.jsonl.1"),
+    path19.join(swarmDir, "telemetry.jsonl")
   ];
-  const tmpDir = fs7.mkdtempSync(path18.join(os8.tmpdir(), "telemetry-snapshot-"));
+  const tmpDir = fs7.mkdtempSync(path19.join(os8.tmpdir(), "telemetry-snapshot-"));
   const snapshotFiles = [];
   try {
     for (const file of files) {
       if (!fs7.existsSync(file))
         continue;
-      const snap = path18.join(tmpDir, path18.basename(file));
+      const snap = path19.join(tmpDir, path19.basename(file));
       try {
         fs7.copyFileSync(file, snap);
         snapshotFiles.push(snap);
@@ -10894,7 +10991,7 @@ async function handleBrainstormCommand(_directory, args) {
 // src/tools/checkpoint.ts
 import * as child_process from "child_process";
 import * as fs8 from "fs";
-import * as path19 from "path";
+import * as path20 from "path";
 
 // src/tools/create-tool.ts
 function classifyToolError(error2) {
@@ -10981,7 +11078,7 @@ function validateLabel(label) {
   return null;
 }
 function getCheckpointLogPath(directory) {
-  return path19.join(directory, CHECKPOINT_LOG_PATH);
+  return path20.join(directory, CHECKPOINT_LOG_PATH);
 }
 function readCheckpointLog(directory) {
   const logPath = getCheckpointLogPath(directory);
@@ -10999,7 +11096,7 @@ function readCheckpointLog(directory) {
 }
 function writeCheckpointLog(log2, directory) {
   const logPath = getCheckpointLogPath(directory);
-  const dir = path19.dirname(logPath);
+  const dir = path20.dirname(logPath);
   if (!fs8.existsSync(dir)) {
     fs8.mkdirSync(dir, { recursive: true });
   }
@@ -11036,7 +11133,7 @@ function gitExec(args, cwd) {
 }
 function appendRetentionEvent(directory, event) {
   try {
-    const eventsPath = path19.join(directory, ".swarm", "events.jsonl");
+    const eventsPath = path20.join(directory, ".swarm", "events.jsonl");
     const line = `${JSON.stringify({ ...event, timestamp: new Date().toISOString() })}
 `;
     fs8.appendFileSync(eventsPath, line);
@@ -11402,7 +11499,7 @@ async function handleClarifyCommand(_directory, args) {
 import { spawnSync as spawnSync5 } from "child_process";
 import * as fsSync2 from "fs";
 import { promises as fs13 } from "fs";
-import path32 from "path";
+import path33 from "path";
 
 // src/hooks/abort-utils.ts
 function isAbortError(err) {
@@ -11532,7 +11629,7 @@ function createCuratorLLMDelegate(directory, mode = "init", sessionId) {
 
 // src/hooks/curator-postmortem.ts
 import { existsSync as existsSync8, readdirSync, readFileSync as readFileSync6 } from "fs";
-import * as path20 from "path";
+import * as path21 from "path";
 var MAX_INPUT_TEXT_CHARS = 500;
 var MAX_KNOWLEDGE_ENTRIES = 500;
 var MAX_PROPOSALS = 50;
@@ -11599,13 +11696,13 @@ function readJsonlFile(filePath, maxLines) {
 }
 function collectRetrospectives(directory) {
   const results = [];
-  const evidenceDir = path20.join(directory, ".swarm", "evidence");
+  const evidenceDir = path21.join(directory, ".swarm", "evidence");
   try {
     if (!existsSync8(evidenceDir))
       return results;
     const retroDirs = readdirSync(evidenceDir, { withFileTypes: true }).filter((e) => e.isDirectory() && e.name.startsWith("retro-")).slice(0, MAX_RETROSPECTIVES);
     for (const entry of retroDirs) {
-      const retroPath = path20.join(evidenceDir, entry.name, "evidence.json");
+      const retroPath = path21.join(evidenceDir, entry.name, "evidence.json");
       if (existsSync8(retroPath)) {
         try {
           results.push(readFileSync6(retroPath, "utf-8"));
@@ -11617,14 +11714,14 @@ function collectRetrospectives(directory) {
 }
 function collectDriftReports(directory) {
   const results = [];
-  const swarmDir = path20.join(directory, ".swarm");
+  const swarmDir = path21.join(directory, ".swarm");
   try {
     if (!existsSync8(swarmDir))
       return results;
     const driftFiles = readdirSync(swarmDir).filter((e) => e.startsWith("drift-report-phase-") && e.endsWith(".json")).slice(0, MAX_DRIFT_REPORTS);
     for (const entry of driftFiles) {
       try {
-        results.push(readFileSync6(path20.join(swarmDir, entry), "utf-8"));
+        results.push(readFileSync6(path21.join(swarmDir, entry), "utf-8"));
       } catch {}
     }
   } catch {}
@@ -11632,7 +11729,7 @@ function collectDriftReports(directory) {
 }
 function collectPendingProposals(directory) {
   const results = [];
-  const insightPath = path20.join(directory, ".swarm", "insight-candidates.jsonl");
+  const insightPath = path21.join(directory, ".swarm", "insight-candidates.jsonl");
   if (existsSync8(insightPath)) {
     try {
       results.push({
@@ -11641,7 +11738,7 @@ function collectPendingProposals(directory) {
       });
     } catch {}
   }
-  const proposalsDir = path20.join(directory, ".swarm", "skills", "proposals");
+  const proposalsDir = path21.join(directory, ".swarm", "skills", "proposals");
   try {
     if (existsSync8(proposalsDir)) {
       const proposalFiles = readdirSync(proposalsDir).filter((e) => e.endsWith(".md") || e.endsWith(".json")).slice(0, MAX_PROPOSALS);
@@ -11649,7 +11746,7 @@ function collectPendingProposals(directory) {
         try {
           results.push({
             source: `proposals/${entry}`,
-            content: readFileSync6(path20.join(proposalsDir, entry), "utf-8")
+            content: readFileSync6(path21.join(proposalsDir, entry), "utf-8")
           });
         } catch {}
       }
@@ -11870,7 +11967,7 @@ async function runCuratorPostMortem(directory, options = {}) {
       warnings.push(`Pending proposals capped at ${MAX_PROPOSALS} (had ${proposals.length}); older entries truncated.`);
       proposals = proposals.slice(0, MAX_PROPOSALS);
     }
-    const unactionablePath = path20.join(resolveKnowledgeStoreDir(directory), "knowledge-unactionable.jsonl");
+    const unactionablePath = path21.join(resolveKnowledgeStoreDir(directory), "knowledge-unactionable.jsonl");
     let unactionable = readJsonlFile(unactionablePath, MAX_UNACTIONABLE);
     if (unactionable.length > MAX_UNACTIONABLE) {
       warnings.push(`Unactionable entries capped at ${MAX_UNACTIONABLE} (had ${unactionable.length}); older entries truncated.`);
@@ -11920,7 +12017,7 @@ ${llmOutput}`;
     }
     try {
       const { mkdirSync: mkdirSync9 } = await import("fs");
-      mkdirSync9(path20.dirname(reportPath), { recursive: true });
+      mkdirSync9(path21.dirname(reportPath), { recursive: true });
       await atomicWriteFile(reportPath, reportContent);
     } catch (err) {
       const msg = err instanceof Error ? err.message : String(err);
@@ -11968,7 +12065,7 @@ var _internals14 = {
 };
 
 // src/hooks/hive-promoter.ts
-import path23 from "path";
+import path24 from "path";
 
 // src/background/event-bus.ts
 class AutomationEventBus {
@@ -12474,7 +12571,7 @@ init_logger();
 var import_proper_lockfile2 = __toESM(require_proper_lockfile(), 1);
 import { existsSync as existsSync9 } from "fs";
 import { mkdir as mkdir5, readFile as readFile5, rename as rename2, writeFile as writeFile4 } from "fs/promises";
-import * as path21 from "path";
+import * as path22 from "path";
 var LOCK_ACQUIRE_TIMEOUT_MS = 1e4;
 var LOCK_RETRY_OPTS = {
   retries: {
@@ -12503,7 +12600,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 path21.join(directory, ".swarm", fileName);
+  return path22.join(directory, ".swarm", fileName);
 }
 function todayKey(window, now = new Date) {
   if (window === "utc") {
@@ -12529,7 +12626,7 @@ async function readState(filePath) {
   }
 }
 async function writeState(filePath, state) {
-  await mkdir5(path21.dirname(filePath), { recursive: true });
+  await mkdir5(path22.dirname(filePath), { recursive: true });
   const tmp = `${filePath}.tmp-${process.pid}`;
   await writeFile4(tmp, JSON.stringify(state, null, 2), "utf-8");
   await rename2(tmp, filePath);
@@ -12552,10 +12649,10 @@ async function getQuotaState(directory, opts) {
 }
 async function reserveQuota(directory, opts) {
   const filePath = resolveQuotaPath(directory, opts.scope);
-  await mkdir5(path21.dirname(filePath), { recursive: true });
+  await mkdir5(path22.dirname(filePath), { recursive: true });
   let release = null;
   try {
-    release = await acquireLock(path21.dirname(filePath));
+    release = await acquireLock(path22.dirname(filePath));
     const state = await getQuotaState(directory, opts);
     if (state.calls_used + opts.nCalls > opts.maxCalls) {
       return {
@@ -12582,10 +12679,10 @@ async function reserveQuota(directory, opts) {
 }
 async function releaseQuota(directory, opts) {
   const filePath = resolveQuotaPath(directory, opts.scope);
-  await mkdir5(path21.dirname(filePath), { recursive: true });
+  await mkdir5(path22.dirname(filePath), { recursive: true });
   let release = null;
   try {
-    release = await acquireLock(path21.dirname(filePath));
+    release = await acquireLock(path22.dirname(filePath));
     const state = await getQuotaState(directory, opts);
     const next = {
       ...state,
@@ -12609,7 +12706,7 @@ init_logger();
 // src/hooks/skill-usage-log.ts
 import * as crypto3 from "crypto";
 import * as fs9 from "fs";
-import * as path22 from "path";
+import * as path23 from "path";
 function resolveLogPath(directory) {
   return validateSwarmPath(directory, "skill-usage.jsonl");
 }
@@ -12708,7 +12805,7 @@ function appendFeedbackAppliedMarker(directory, processedEntryIds) {
   if (processedEntryIds.length === 0)
     return;
   const resolved = resolveLogPath(directory);
-  const dir = path22.dirname(resolved);
+  const dir = path23.dirname(resolved);
   if (!_internals15.existsSync(dir)) {
     _internals15.mkdirSync(dir, { recursive: true });
   }
@@ -12753,7 +12850,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 = path22.dirname(resolved);
+  const dir = path23.dirname(resolved);
   if (!_internals15.existsSync(dir)) {
     _internals15.mkdirSync(dir, { recursive: true });
   }
@@ -12929,8 +13026,8 @@ function pruneSkillUsageLog(directory, maxEntriesPerSkill = 500) {
   }
   if (entries.length === 0) {
     if (preservedMarkers.length > 0) {
-      const dir2 = path22.dirname(resolved);
-      const tmpPath2 = path22.join(dir2, `skill-usage-${Date.now()}.tmp`);
+      const dir2 = path23.dirname(resolved);
+      const tmpPath2 = path23.join(dir2, `skill-usage-${Date.now()}.tmp`);
       const content2 = preservedMarkers.join(`
 `).concat(preservedMarkers.length > 0 ? `
 ` : "");
@@ -12972,8 +13069,8 @@ function pruneSkillUsageLog(directory, maxEntriesPerSkill = 500) {
   if (pruned === 0) {
     return { pruned: 0, remaining: entries.length };
   }
-  const dir = path22.dirname(resolved);
-  const tmpPath = path22.join(dir, `skill-usage-${Date.now()}.tmp`);
+  const dir = path23.dirname(resolved);
+  const tmpPath = path23.join(dir, `skill-usage-${Date.now()}.tmp`);
   const entryLines = surviving.map((e) => JSON.stringify(e));
   const allLines = [...entryLines, ...preservedMarkers];
   const content = allLines.join(`
@@ -13002,9 +13099,9 @@ async function resolveSourceKnowledgeIds(directory, skillPath) {
     if (/\.\.[/\\]/.test(cleanPath)) {
       return [];
     }
-    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);
+    const absolute = path23.normalize(path23.isAbsolute(cleanPath) ? cleanPath : path23.resolve(directory, cleanPath));
+    const baseDir = path23.normalize(path23.resolve(directory));
+    const isContained = process.platform === "win32" ? absolute.toLowerCase().startsWith((baseDir + path23.sep).toLowerCase()) : absolute.startsWith(baseDir + path23.sep);
     if (!isContained) {
       return [];
     }
@@ -13316,7 +13413,7 @@ async function promoteToHive(directory, lesson, category) {
     schema_version: 1,
     created_at: new Date().toISOString(),
     updated_at: new Date().toISOString(),
-    source_project: path23.basename(directory) || "unknown",
+    source_project: path24.basename(directory) || "unknown",
     encounter_score: 1
   };
   await appendKnowledge(resolveHiveKnowledgePath(), newHiveEntry);
@@ -13370,7 +13467,7 @@ async function promoteFromSwarm(directory, lessonId) {
 import { createHash as createHash4 } from "crypto";
 import { existsSync as existsSync13 } from "fs";
 import { appendFile as appendFile3, mkdir as mkdir7, readFile as readFile8, writeFile as writeFile7 } from "fs/promises";
-import * as path28 from "path";
+import * as path29 from "path";
 
 // src/services/synonym-map.ts
 var import_proper_lockfile3 = __toESM(require_proper_lockfile(), 1);
@@ -13382,7 +13479,7 @@ import {
   unlink as unlink2,
   writeFile as writeFile5
 } from "fs/promises";
-import * as path24 from "path";
+import * as path25 from "path";
 var SYNONYM_MAP_FILENAME = "synonym-map.json";
 var MAX_TOKEN_LENGTH = 64;
 var DEFAULT_MAX_PAIRS = 500;
@@ -13537,7 +13634,7 @@ async function readSynonymMap(directory, maxPairs = DEFAULT_MAX_PAIRS) {
   }
 }
 async function writeSynonymMapAtomic(filePath, map) {
-  await mkdir6(path24.dirname(filePath), { recursive: true });
+  await mkdir6(path25.dirname(filePath), { recursive: true });
   const tmp = `${filePath}.tmp.${Date.now()}.${Math.floor(Math.random() * 1e9)}`;
   try {
     await writeFile5(tmp, JSON.stringify(map, null, 2), "utf-8");
@@ -13550,7 +13647,7 @@ async function writeSynonymMapAtomic(filePath, map) {
 }
 async function rebuildSynonymMap(directory, entries, maxPairs = DEFAULT_MAX_PAIRS) {
   const filePath = resolveSynonymMapPath(directory);
-  const dir = path24.dirname(filePath);
+  const dir = path25.dirname(filePath);
   await mkdir6(dir, { recursive: true });
   let release = null;
   try {
@@ -13615,17 +13712,17 @@ function reinforceSwarmKnowledgeEntry(entry, confirmation) {
 // src/hooks/micro-reflector.ts
 import { existsSync as existsSync12 } from "fs";
 import { readFile as readFile7, writeFile as writeFile6 } from "fs/promises";
-import * as path27 from "path";
+import * as path28 from "path";
 init_logger();
 
 // src/hooks/skill-propagation-gate.ts
 import * as fs11 from "fs";
-import * as path26 from "path";
+import * as path27 from "path";
 init_logger();
 
 // src/hooks/skill-scoring.ts
 import * as fs10 from "fs";
-import * as path25 from "path";
+import * as path26 from "path";
 var FREQUENCY_CAP = 10;
 var FREQUENCY_WEIGHT = 0.3;
 var COMPLIANCE_WEIGHT = 0.3;
@@ -13653,10 +13750,10 @@ var _internals16 = {
   computeTriggerMatchBoost: null
 };
 function extractSkillName(skillPath) {
-  const base = path25.basename(skillPath, path25.extname(skillPath));
+  const base = path26.basename(skillPath, path26.extname(skillPath));
   if (base !== "SKILL")
     return base;
-  const parent = path25.basename(path25.dirname(skillPath));
+  const parent = path26.basename(path26.dirname(skillPath));
   return parent;
 }
 function stripQuotes(value) {
@@ -13811,12 +13908,12 @@ function readSkillMetadata(skillPath, directory) {
   const normalizedPath = skillPath.replace(/^file:/, "").replace(/\\/g, "/");
   const fallback = parseSkillFrontmatter("", normalizedPath);
   try {
-    if (path25.isAbsolute(normalizedPath) || normalizedPath.split("/").includes("..")) {
+    if (path26.isAbsolute(normalizedPath) || normalizedPath.split("/").includes("..")) {
       return fallback;
     }
-    const root = path25.resolve(directory);
-    const absolutePath = path25.resolve(directory, normalizedPath);
-    if (absolutePath !== root && !absolutePath.startsWith(root + path25.sep)) {
+    const root = path26.resolve(directory);
+    const absolutePath = path26.resolve(directory, normalizedPath);
+    if (absolutePath !== root && !absolutePath.startsWith(root + path26.sep)) {
       return fallback;
     }
     const content = readFilePrefix(absolutePath);
@@ -13950,7 +14047,7 @@ function getSkillStats(skillPath, directory) {
   };
 }
 function formatSkillIndexWithContext(skills, directory) {
-  const usageLogPath = path25.join(directory, ".swarm", "skill-usage.jsonl");
+  const usageLogPath = path26.join(directory, ".swarm", "skill-usage.jsonl");
   let hasHistory = false;
   try {
     const stat5 = fs10.statSync(usageLogPath);
@@ -14084,7 +14181,7 @@ function parseYamlValue(value) {
   return trimmed;
 }
 function loadRoutingSkills(directory, targetAgent) {
-  const routingPath = path26.join(directory, ".opencode", "skill-routing.yaml");
+  const routingPath = path27.join(directory, ".opencode", "skill-routing.yaml");
   if (!_internals17.existsSync(routingPath))
     return [];
   try {
@@ -14144,7 +14241,7 @@ var _internals17 = {
 function discoverAvailableSkills(directory) {
   const results = [];
   for (const root of SKILL_SEARCH_ROOTS) {
-    const rootPath = path26.join(directory, root);
+    const rootPath = path27.join(directory, root);
     if (!_internals17.existsSync(rootPath))
       continue;
     let entries;
@@ -14156,13 +14253,13 @@ function discoverAvailableSkills(directory) {
     for (const entry of entries) {
       if (entry.startsWith("."))
         continue;
-      const skillDir = path26.join(rootPath, entry);
-      if (_internals17.existsSync(path26.join(skillDir, "retired.marker")) || _internals17.existsSync(path26.join(skillDir, "stale.marker")))
+      const skillDir = path27.join(rootPath, entry);
+      if (_internals17.existsSync(path27.join(skillDir, "retired.marker")) || _internals17.existsSync(path27.join(skillDir, "stale.marker")))
         continue;
-      const skillFile = path26.join(skillDir, "SKILL.md");
+      const skillFile = path27.join(skillDir, "SKILL.md");
       try {
         if (_internals17.statSync(skillDir).isDirectory() && _internals17.existsSync(skillFile)) {
-          results.push(path26.join(root, entry, "SKILL.md").replace(/\\/g, "/"));
+          results.push(path27.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)}`);
@@ -14231,9 +14328,9 @@ function extractSkillsFieldFromPrompt(prompt) {
   return "";
 }
 function writeWarnEvent(directory, record) {
-  const filePath = path26.join(directory, ".swarm", "events.jsonl");
+  const filePath = path27.join(directory, ".swarm", "events.jsonl");
   try {
-    const dir = path26.dirname(filePath);
+    const dir = path27.dirname(filePath);
     if (!_internals17.existsSync(dir)) {
       _internals17.mkdirSync(dir, { recursive: true });
     }
@@ -14362,8 +14459,8 @@ async function skillPropagationGateBefore(directory, input, config) {
     if (routingPaths.length > 0) {
       const existingPaths = new Set(scored.map((s) => s.skillPath));
       for (const routingPath of routingPaths) {
-        const routedSkillDir = path26.dirname(path26.join(directory, routingPath));
-        if (_internals17.existsSync(path26.join(routedSkillDir, "retired.marker")) || _internals17.existsSync(path26.join(routedSkillDir, "stale.marker")))
+        const routedSkillDir = path27.dirname(path27.join(directory, routingPath));
+        if (_internals17.existsSync(path27.join(routedSkillDir, "retired.marker")) || _internals17.existsSync(path27.join(routedSkillDir, "stale.marker")))
           continue;
         if (!existingPaths.has(routingPath)) {
           scored.push({
@@ -14382,8 +14479,8 @@ async function skillPropagationGateBefore(directory, input, config) {
       let skillsForIndex = availableSkills;
       if (scoringSkipped) {
         skillsForIndex = [...availableSkills].sort((a, b) => {
-          const nameA = path26.basename(path26.dirname(a));
-          const nameB = path26.basename(path26.dirname(b));
+          const nameA = path27.basename(path27.dirname(a));
+          const nameB = path27.basename(path27.dirname(b));
           return nameA.localeCompare(nameB);
         });
       } else if (typeof scored !== "undefined" && scored.length > 0) {
@@ -14391,7 +14488,7 @@ async function skillPropagationGateBefore(directory, input, config) {
       }
       const formattedIndex = _internals17.formatSkillIndexWithContext(skillsForIndex, directory);
       if (formattedIndex.length > 0) {
-        const contextPath = path26.join(directory, ".swarm", "context.md");
+        const contextPath = path27.join(directory, ".swarm", "context.md");
         let existingContent = "";
         if (_internals17.existsSync(contextPath)) {
           existingContent = _internals17.readFileSync(contextPath, "utf-8");
@@ -14413,7 +14510,7 @@ ${newSection}`;
             updatedContent = existingContent + newSection;
           }
         }
-        const swarmDir = path26.dirname(contextPath);
+        const swarmDir = path27.dirname(contextPath);
         if (!_internals17.existsSync(swarmDir)) {
           _internals17.mkdirSync(swarmDir, { recursive: true });
         }
@@ -14639,7 +14736,7 @@ function resolveInsightCandidatesPath(directory) {
 }
 async function readTaskTrajectory(directory, taskId) {
   try {
-    const rel = path27.join("evidence", sanitizeTaskId(taskId), "trajectory.jsonl");
+    const rel = path28.join("evidence", sanitizeTaskId(taskId), "trajectory.jsonl");
     const filePath = validateSwarmPath(directory, rel);
     if (!existsSync12(filePath))
       return [];
@@ -15069,8 +15166,8 @@ RETRY: your last output was missing ${result.missing.join("; ")}; produce valid
 }
 async function appendCuratorSkippedEvent(directory, record) {
   try {
-    const filePath = path28.join(directory, ".swarm", "events.jsonl");
-    await mkdir7(path28.dirname(filePath), { recursive: true });
+    const filePath = path29.join(directory, ".swarm", "events.jsonl");
+    await mkdir7(path29.dirname(filePath), { recursive: true });
     await appendFile3(filePath, `${JSON.stringify({
       timestamp: new Date().toISOString(),
       event: "curator_skipped",
@@ -15597,7 +15694,7 @@ var _internals19 = {
 
 // src/services/session-reflection.ts
 import { promises as fs12 } from "fs";
-import * as path29 from "path";
+import * as path30 from "path";
 
 // src/hooks/skill-improver-llm-factory.ts
 function resolveSkillImproverAgentName(sessionId) {
@@ -15750,11 +15847,11 @@ async function gatherRetroLessonsAndTaxonomy(directory) {
   const lessons = [];
   const taxonomy = {};
   try {
-    const evidenceDir = path29.join(directory, ".swarm", "evidence");
+    const evidenceDir = path30.join(directory, ".swarm", "evidence");
     const entries = await fs12.readdir(evidenceDir);
     const retroDirs = entries.filter((e) => e.startsWith("retro-")).sort((a, b) => a.localeCompare(b, undefined, { numeric: true }));
     for (const retroDir of retroDirs) {
-      const evidencePath = path29.join(evidenceDir, retroDir, "evidence.json");
+      const evidencePath = path30.join(evidenceDir, retroDir, "evidence.json");
       try {
         const content = await fs12.readFile(evidencePath, "utf-8");
         const parsed = JSON.parse(content);
@@ -15783,12 +15880,12 @@ async function gatherRetroLessonsAndTaxonomy(directory) {
 async function gatherGateFailures(directory) {
   const failures = new Map;
   try {
-    const evidenceDir = path29.join(directory, ".swarm", "evidence");
+    const evidenceDir = path30.join(directory, ".swarm", "evidence");
     const entries = await fs12.readdir(evidenceDir);
     for (const entry of entries) {
       if (entry.startsWith("retro-"))
         continue;
-      const evidencePath = path29.join(evidenceDir, entry, "evidence.json");
+      const evidencePath = path30.join(evidenceDir, entry, "evidence.json");
       try {
         const content = await fs12.readFile(evidencePath, "utf-8");
         const parsed = JSON.parse(content);
@@ -15989,12 +16086,12 @@ async function writeSessionReflection(directory, result) {
 // src/services/skill-improver.ts
 import { existsSync as existsSync15 } from "fs";
 import { mkdir as mkdir9, readFile as readFile9, rename as rename4, writeFile as writeFile9 } from "fs/promises";
-import * as path31 from "path";
+import * as path32 from "path";
 init_logger();
 
 // src/services/trajectory-cluster.ts
 import { mkdir as mkdir8, writeFile as writeFile8 } from "fs/promises";
-import * as path30 from "path";
+import * as path31 from "path";
 init_logger();
 var MACRO_TRAJECTORY_WINDOW = 200;
 var MOTIF_MIN_TASKS = 2;
@@ -16126,11 +16223,11 @@ async function writeMotifProposals(directory, opts = {}) {
     if (motifs.length === 0)
       return result;
     const max = opts.maxProposals ?? 10;
-    const proposalsDir = validateSwarmPath(directory, path30.join("skills", "proposals"));
+    const proposalsDir = validateSwarmPath(directory, path31.join("skills", "proposals"));
     await mkdir8(proposalsDir, { recursive: true });
     for (const motif of motifs.slice(0, max)) {
       const slug = `motif-${slugify(motif.signature)}`;
-      const filePath = path30.join(proposalsDir, `${slug}.md`);
+      const filePath = path31.join(proposalsDir, `${slug}.md`);
       await writeFile8(filePath, buildMotifProposal(motif), "utf-8");
       result.proposalsWritten.push(filePath);
     }
@@ -16271,11 +16368,11 @@ async function writeSuccessMotifProposals(directory, opts = {}) {
     if (motifs.length === 0)
       return result;
     const max = opts.maxProposals ?? 10;
-    const proposalsDir = validateSwarmPath(directory, path30.join("skills", "proposals"));
+    const proposalsDir = validateSwarmPath(directory, path31.join("skills", "proposals"));
     await mkdir8(proposalsDir, { recursive: true });
     for (const motif of motifs.slice(0, max)) {
       const slug = workflowSlug(motif.signature);
-      const filePath = path30.join(proposalsDir, `${slug}.md`);
+      const filePath = path31.join(proposalsDir, `${slug}.md`);
       await writeFile8(filePath, buildWorkflowProposal(motif), "utf-8");
       result.proposalsWritten.push(filePath);
     }
@@ -16398,7 +16495,7 @@ function timestampSlug(d) {
   return d.toISOString().replace(/[:.]/g, "-");
 }
 async function atomicWrite(p, content) {
-  await mkdir9(path31.dirname(p), { recursive: true });
+  await mkdir9(path32.dirname(p), { recursive: true });
   const tmp = `${p}.tmp-${process.pid}-${Date.now()}`;
   await writeFile9(tmp, content, "utf-8");
   await rename4(tmp, p);
@@ -16801,8 +16898,8 @@ async function runSkillImprover(req) {
     }
     throw err;
   }
-  const proposalDir = path31.join(req.directory, ".swarm", "skill-improver", "proposals");
-  const proposalFile = path31.join(proposalDir, `${timestampSlug(now)}.md`);
+  const proposalDir = path32.join(req.directory, ".swarm", "skill-improver", "proposals");
+  const proposalFile = path32.join(proposalDir, `${timestampSlug(now)}.md`);
   const finalBody = source === "llm" ? buildLLMProposalFrame({
     body,
     targets,
@@ -17288,8 +17385,8 @@ async function copyDirRecursiveWithFailures(src, dest) {
   const entries = await fs13.readdir(src);
   await fs13.mkdir(dest, { recursive: true });
   for (const entry of entries) {
-    const srcEntry = path32.join(src, entry);
-    const destEntry = path32.join(dest, entry);
+    const srcEntry = path33.join(src, entry);
+    const destEntry = path33.join(dest, entry);
     try {
       const stat5 = await fs13.stat(srcEntry);
       if (stat5.isDirectory()) {
@@ -17474,18 +17571,18 @@ async function runFinalizeStage(ctx) {
       ctx.warnings.push(`Session retrospective write threw: ${retroError instanceof Error ? retroError.message : String(retroError)}`);
     }
   }
-  const lessonsFilePath = path32.join(ctx.swarmDir, "close-lessons.md");
+  const lessonsFilePath = path33.join(ctx.swarmDir, "close-lessons.md");
   try {
     const lessonsText = await fs13.readFile(lessonsFilePath, "utf-8");
     ctx.explicitLessons = lessonsText.split(`
 `).map((line) => line.trim()).filter((line) => line.length > 0 && !line.startsWith("#"));
   } catch {}
   try {
-    const evidenceDir = path32.join(ctx.swarmDir, "evidence");
+    const evidenceDir = path33.join(ctx.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 = path32.join(evidenceDir, retroDir, "evidence.json");
+      const evidencePath = path33.join(evidenceDir, retroDir, "evidence.json");
       try {
         const content = await fs13.readFile(evidencePath, "utf-8");
         const parsed = JSON.parse(content);
@@ -17667,7 +17764,7 @@ async function copySqliteSafe(srcPath, destPath) {
   let checkpointVerified = false;
   try {
     const result = spawnSync5("sqlite3", [srcPath, "PRAGMA wal_checkpoint(TRUNCATE);"], {
-      cwd: path32.dirname(srcPath),
+      cwd: path33.dirname(srcPath),
       encoding: "utf-8",
       stdio: ["ignore", "pipe", "pipe"],
       timeout: 1e4,
@@ -17735,7 +17832,7 @@ async function copySqliteSafe(srcPath, destPath) {
 async function runArchiveStage(ctx) {
   ctx.timestamp = new Date().toISOString().replace(/[:.]/g, "-");
   ctx.archiveSuffix = Math.random().toString(36).slice(2, 8);
-  ctx.archiveDir = path32.join(ctx.swarmDir, "archive", `swarm-${ctx.timestamp}-${ctx.archiveSuffix}`);
+  ctx.archiveDir = path33.join(ctx.swarmDir, "archive", `swarm-${ctx.timestamp}-${ctx.archiveSuffix}`);
   try {
     await fs13.mkdir(ctx.archiveDir, { recursive: true });
     const WAL_SIDECAR_FILES = new Set(["swarm.db-shm", "swarm.db-wal"]);
@@ -17750,8 +17847,8 @@ async function runArchiveStage(ctx) {
       if (linkedKnowledgeShared && KNOWLEDGE_FAMILY_ARTIFACTS.has(artifact)) {
         continue;
       }
-      const srcPath = path32.join(ctx.swarmDir, artifact);
-      const destPath = path32.join(ctx.archiveDir, artifact);
+      const srcPath = path33.join(ctx.swarmDir, artifact);
+      const destPath = path33.join(ctx.archiveDir, artifact);
       if (artifact === "swarm.db") {
         const result = await copySqliteSafe(srcPath, destPath);
         if (result.skipped) {} else if (result.success) {
@@ -17783,8 +17880,8 @@ async function runArchiveStage(ctx) {
       }
     }
     for (const dirName of ACTIVE_STATE_DIRS_TO_CLEAN) {
-      const srcDir = path32.join(ctx.swarmDir, dirName);
-      const destDir = path32.join(ctx.archiveDir, dirName);
+      const srcDir = path33.join(ctx.swarmDir, dirName);
+      const destDir = path33.join(ctx.archiveDir, dirName);
       try {
         const result = await copyDirRecursiveWithFailures(srcDir, destDir);
         ctx.archivedFileCount += result.copied;
@@ -17861,7 +17958,7 @@ async function runCleanStage(ctx) {
         ctx.warnings.push(reason ? `Preserved ${artifact} because it was not successfully archived: ${reason}.` : `Preserved ${artifact} because it was not successfully archived.`);
         continue;
       }
-      const filePath = path32.join(ctx.swarmDir, artifact);
+      const filePath = path33.join(ctx.swarmDir, artifact);
       try {
         await fs13.unlink(filePath);
         cleanedFiles.push(artifact);
@@ -17880,7 +17977,7 @@ async function runCleanStage(ctx) {
     if (!ctx.archivedActiveStateDirs.has(dirName)) {
       continue;
     }
-    const dirPath = path32.join(ctx.swarmDir, dirName);
+    const dirPath = path33.join(ctx.swarmDir, dirName);
     try {
       await fs13.rm(dirPath, { recursive: true, force: true });
       cleanedFiles.push(`${dirName}/`);
@@ -17891,7 +17988,7 @@ async function runCleanStage(ctx) {
     const configBackups = swarmFiles.filter((f) => f.startsWith("config-backup-") && f.endsWith(".json"));
     for (const backup of configBackups) {
       try {
-        await fs13.unlink(path32.join(ctx.swarmDir, backup));
+        await fs13.unlink(path33.join(ctx.swarmDir, backup));
         configBackupsRemoved++;
       } catch (err) {
         const errno = err?.code;
@@ -17904,7 +18001,7 @@ async function runCleanStage(ctx) {
     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(path32.join(ctx.swarmDir, sibling));
+        await fs13.unlink(path33.join(ctx.swarmDir, sibling));
       } catch (err) {
         const errno = err?.code;
         if (errno === "ENOENT") {} else {
@@ -17922,12 +18019,12 @@ async function runCleanStage(ctx) {
   }
   let swarmPlanFilesRemoved = 0;
   const candidates = [
-    path32.join(ctx.directory, ".swarm", "plan-export", "SWARM_PLAN.json"),
-    path32.join(ctx.directory, ".swarm", "plan-export", "SWARM_PLAN.md"),
-    path32.join(ctx.directory, ".swarm", "SWARM_PLAN.json"),
-    path32.join(ctx.directory, ".swarm", "SWARM_PLAN.md"),
-    path32.join(ctx.directory, "SWARM_PLAN.json"),
-    path32.join(ctx.directory, "SWARM_PLAN.md")
+    path33.join(ctx.directory, ".swarm", "plan-export", "SWARM_PLAN.json"),
+    path33.join(ctx.directory, ".swarm", "plan-export", "SWARM_PLAN.md"),
+    path33.join(ctx.directory, ".swarm", "SWARM_PLAN.json"),
+    path33.join(ctx.directory, ".swarm", "SWARM_PLAN.md"),
+    path33.join(ctx.directory, "SWARM_PLAN.json"),
+    path33.join(ctx.directory, "SWARM_PLAN.md")
   ];
   for (const candidate of candidates) {
     try {
@@ -17945,7 +18042,7 @@ async function runCleanStage(ctx) {
     const tmpFiles = swarmFiles.filter((f) => f.startsWith(".tmp."));
     for (const tmp of tmpFiles) {
       try {
-        await fs13.unlink(path32.join(ctx.swarmDir, tmp));
+        await fs13.unlink(path33.join(ctx.swarmDir, tmp));
         tmpFilesRemoved++;
       } catch (err) {
         const errno = err?.code;
@@ -17967,7 +18064,7 @@ async function runCleanStage(ctx) {
   }
   for (const terminalFile of TERMINAL_STATE_FILES) {
     try {
-      await fs13.unlink(path32.join(ctx.swarmDir, terminalFile));
+      await fs13.unlink(path33.join(ctx.swarmDir, terminalFile));
       if (!cleanedFiles.includes(terminalFile)) {
         cleanedFiles.push(terminalFile);
       }
@@ -17980,7 +18077,7 @@ async function runCleanStage(ctx) {
     }
   }
   clearAllScopes(ctx.directory);
-  const contextPath = path32.join(ctx.swarmDir, "context.md");
+  const contextPath = path33.join(ctx.swarmDir, "context.md");
   const contextContent = [
     "# Context",
     "",
@@ -17992,7 +18089,7 @@ async function runCleanStage(ctx) {
     ""
   ].join(`
 `);
-  const contextTempPath = path32.join(path32.dirname(contextPath), `${path32.basename(contextPath)}.tmp.${Date.now()}.${Math.floor(Math.random() * 1e9)}`);
+  const contextTempPath = path33.join(path33.dirname(contextPath), `${path33.basename(contextPath)}.tmp.${Date.now()}.${Math.floor(Math.random() * 1e9)}`);
   try {
     await fs13.writeFile(contextTempPath, contextContent, "utf-8");
     fsSync2.renameSync(contextTempPath, contextPath);
@@ -18056,7 +18153,7 @@ async function runAlignStage(ctx) {
   return { gitAlignResult, prunedBranches };
 }
 async function handleCloseCommand(directory, args, options = {}) {
-  const swarmDir = path32.join(directory, ".swarm");
+  const swarmDir = path33.join(directory, ".swarm");
   try {
     const stat5 = fsSync2.lstatSync(swarmDir);
     if (stat5.isSymbolicLink()) {
@@ -18070,7 +18167,7 @@ async function handleCloseCommand(directory, args, options = {}) {
   const planPath = validateSwarmPath(directory, "plan.json");
   let planExists = false;
   let planData = {
-    title: path32.basename(directory) || "Ad-hoc session",
+    title: path33.basename(directory) || "Ad-hoc session",
     phases: []
   };
   try {
@@ -18095,7 +18192,7 @@ async function handleCloseCommand(directory, args, options = {}) {
   }
   try {
     if (!planExists) {
-      const archiveDir = path32.join(swarmDir, "archive");
+      const archiveDir = path33.join(swarmDir, "archive");
       try {
         const archiveEntries = await fs13.readdir(archiveDir);
         const hasArchiveBundle = archiveEntries.some((entry) => entry.startsWith("swarm-"));
@@ -18103,7 +18200,7 @@ async function handleCloseCommand(directory, args, options = {}) {
           const hasActiveState = [
             ...ACTIVE_STATE_TO_CLEAN,
             ...ACTIVE_STATE_DIRS_TO_CLEAN
-          ].some((entry) => fsSync2.existsSync(path32.join(swarmDir, entry)));
+          ].some((entry) => fsSync2.existsSync(path33.join(swarmDir, entry)));
           if (!hasActiveState) {
             return `\u2705 Already finalized \u2014 nothing to do.
 
@@ -18231,7 +18328,7 @@ This project was already finalized in a previous /swarm close run. The plan has
       ...ctx.warnings.length > 0 ? ["## Warnings", ...ctx.warnings.map((w) => `- ${w}`), ""] : []
     ].join(`
 `);
-    const closeSummaryTempPath = path32.join(path32.dirname(closeSummaryPath), `${path32.basename(closeSummaryPath)}.tmp.${Date.now()}.${Math.floor(Math.random() * 1e9)}`);
+    const closeSummaryTempPath = path33.join(path33.dirname(closeSummaryPath), `${path33.basename(closeSummaryPath)}.tmp.${Date.now()}.${Math.floor(Math.random() * 1e9)}`);
     try {
       await fs13.writeFile(closeSummaryTempPath, summaryContent, "utf-8");
       fsSync2.renameSync(closeSummaryTempPath, closeSummaryPath);
@@ -18575,14 +18672,14 @@ function buildStatusMessage(session, plan) {
 
 // src/commands/config.ts
 import * as os9 from "os";
-import * as path33 from "path";
+import * as path34 from "path";
 function getUserConfigDir2() {
-  return process.env.XDG_CONFIG_HOME || path33.join(os9.homedir(), ".config");
+  return process.env.XDG_CONFIG_HOME || path34.join(os9.homedir(), ".config");
 }
 async function handleConfigCommand(directory, _args) {
   const config = loadPluginConfig(directory);
-  const userConfigPath = path33.join(getUserConfigDir2(), "opencode", "opencode-swarm.json");
-  const projectConfigPath = path33.join(directory, ".opencode", "opencode-swarm.json");
+  const userConfigPath = path34.join(getUserConfigDir2(), "opencode", "opencode-swarm.json");
+  const projectConfigPath = path34.join(directory, ".opencode", "opencode-swarm.json");
   const lines = [
     "## Swarm Configuration",
     "",
@@ -18602,7 +18699,7 @@ async function handleConfigCommand(directory, _args) {
 // src/services/skill-consolidation.ts
 import { existsSync as existsSync17 } from "fs";
 import { mkdir as mkdir10, readFile as readFile10, rename as rename5, writeFile as writeFile10 } from "fs/promises";
-import * as path34 from "path";
+import * as path35 from "path";
 
 // src/utils/timeout.ts
 async function withTimeout(promise, ms, timeoutError) {
@@ -18627,7 +18724,7 @@ var DEFAULT_CONSOLIDATION_MAX_CALLS_PER_RUN = 1;
 var CONSOLIDATION_RUN_TIMEOUT_MS = 5 * 60 * 1000;
 var runningByDirectory = new Map;
 function consolidationStatePath(directory) {
-  return path34.join(directory, ".swarm", "skill-improver", "consolidation-state.json");
+  return path35.join(directory, ".swarm", "skill-improver", "consolidation-state.json");
 }
 async function readState2(directory) {
   const filePath = consolidationStatePath(directory);
@@ -18643,7 +18740,7 @@ async function readState2(directory) {
   }
 }
 async function atomicWrite2(filePath, content) {
-  await mkdir10(path34.dirname(filePath), { recursive: true });
+  await mkdir10(path35.dirname(filePath), { recursive: true });
   const tmp = `${filePath}.tmp-${process.pid}-${Date.now()}`;
   await writeFile10(tmp, content, "utf-8");
   await rename5(tmp, filePath);
@@ -18723,7 +18820,7 @@ async function runSkillConsolidationInner(req) {
   };
 }
 async function runSkillConsolidation(req) {
-  const key = path34.resolve(req.directory);
+  const key = path35.resolve(req.directory);
   const existing = runningByDirectory.get(key);
   if (existing) {
     return {
@@ -18925,7 +19022,7 @@ async function handleCouncilCommand(_directory, args) {
 // src/commands/coupling.ts
 import { randomBytes } from "crypto";
 import * as fs14 from "fs";
-import * as path36 from "path";
+import * as path37 from "path";
 
 // src/turbo/epic/cochange-source.ts
 import * as child_process3 from "child_process";
@@ -18935,7 +19032,7 @@ import { promisify as promisify2 } from "util";
 import * as child_process2 from "child_process";
 import { randomUUID as randomUUID5 } from "crypto";
 import { readdir as readdir4, readFile as readFile11, stat as stat5 } from "fs/promises";
-import * as path35 from "path";
+import * as path36 from "path";
 import { promisify } from "util";
 function getExecFileAsync() {
   return promisify(child_process2.execFile);
@@ -19039,7 +19136,7 @@ async function scanSourceFiles(dir) {
   try {
     const entries = await readdir4(dir, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = path35.join(dir, entry.name);
+      const fullPath = path36.join(dir, entry.name);
       if (entry.isDirectory()) {
         if (skipDirs.has(entry.name)) {
           continue;
@@ -19047,7 +19144,7 @@ async function scanSourceFiles(dir) {
         const subFiles = await scanSourceFiles(fullPath);
         results.push(...subFiles);
       } else if (entry.isFile()) {
-        const ext = path35.extname(entry.name);
+        const ext = path36.extname(entry.name);
         if ([".ts", ".tsx", ".js", ".jsx", ".mjs"].includes(ext)) {
           results.push(fullPath);
         }
@@ -19069,8 +19166,8 @@ async function getStaticEdges(directory) {
           continue;
         }
         try {
-          const sourceDir = path35.dirname(sourceFile);
-          const resolvedPath = path35.resolve(sourceDir, importPath);
+          const sourceDir = path36.dirname(sourceFile);
+          const resolvedPath = path36.resolve(sourceDir, importPath);
           const extensions = [
             "",
             ".ts",
@@ -19095,8 +19192,8 @@ async function getStaticEdges(directory) {
           if (!targetFile) {
             continue;
           }
-          const relSource = path35.relative(directory, sourceFile).replace(/\\/g, "/");
-          const relTarget = path35.relative(directory, targetFile).replace(/\\/g, "/");
+          const relSource = path36.relative(directory, sourceFile).replace(/\\/g, "/");
+          const relTarget = path36.relative(directory, targetFile).replace(/\\/g, "/");
           const [key] = relSource < relTarget ? [`${relSource}::${relTarget}`, relSource, relTarget] : [`${relTarget}::${relSource}`, relTarget, relSource];
           edges.add(key);
         } catch {}
@@ -19108,7 +19205,7 @@ async function getStaticEdges(directory) {
 function isTestImplementationPair(fileA, fileB) {
   const testPatterns = [".test.ts", ".test.js", ".spec.ts", ".spec.js"];
   const getBaseName = (filePath) => {
-    const base = path35.basename(filePath);
+    const base = path36.basename(filePath);
     for (const pattern of testPatterns) {
       if (base.endsWith(pattern)) {
         return base.slice(0, -pattern.length);
@@ -19118,16 +19215,16 @@ function isTestImplementationPair(fileA, fileB) {
   };
   const baseA = getBaseName(fileA);
   const baseB = getBaseName(fileB);
-  return baseA === baseB && baseA !== path35.basename(fileA) && baseA !== path35.basename(fileB);
+  return baseA === baseB && baseA !== path36.basename(fileA) && baseA !== path36.basename(fileB);
 }
 function hasSharedPrefix(fileA, fileB) {
-  const dirA = path35.dirname(fileA);
-  const dirB = path35.dirname(fileB);
+  const dirA = path36.dirname(fileA);
+  const dirB = path36.dirname(fileB);
   if (dirA !== dirB) {
     return false;
   }
-  const baseA = path35.basename(fileA).replace(/\.(ts|js|tsx|jsx|mjs)$/, "");
-  const baseB = path35.basename(fileB).replace(/\.(ts|js|tsx|jsx|mjs)$/, "");
+  const baseA = path36.basename(fileA).replace(/\.(ts|js|tsx|jsx|mjs)$/, "");
+  const baseB = path36.basename(fileB).replace(/\.(ts|js|tsx|jsx|mjs)$/, "");
   if (baseA.startsWith(baseB) || baseB.startsWith(baseA)) {
     return true;
   }
@@ -19182,8 +19279,8 @@ function darkMatterToKnowledgeEntries(pairs, projectName) {
   const entries = [];
   const now = new Date().toISOString();
   for (const pair of pairs.slice(0, 10)) {
-    const baseA = path35.basename(pair.fileA);
-    const baseB = path35.basename(pair.fileB);
+    const baseA = path36.basename(pair.fileA);
+    const baseB = path36.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.`;
@@ -19609,9 +19706,9 @@ function parseArgs3(args) {
   return parsed;
 }
 function persistReportJson(directory, report) {
-  const epicDir = path36.join(directory, ".swarm", "epic");
+  const epicDir = path37.join(directory, ".swarm", "epic");
   fs14.mkdirSync(epicDir, { recursive: true });
-  const filePath = path36.join(epicDir, "coupling-report.json");
+  const filePath = path37.join(epicDir, "coupling-report.json");
   const tmpPath = `${filePath}.tmp.${randomBytes(8).toString("hex")}`;
   fs14.writeFileSync(tmpPath, `${JSON.stringify(report, null, 2)}
 `, "utf-8");
@@ -19670,7 +19767,7 @@ Usage: /swarm coupling [--phase <n>] [--threshold <-1..1>] [--min-co-changes <n>
       persistStatus = {
         requested: true,
         written: true,
-        path: path36.relative(directory, writtenAt)
+        path: path37.relative(directory, writtenAt)
       };
     } catch (err) {
       persistStatus = {
@@ -19729,7 +19826,7 @@ function formatCurationSummary(summary) {
 }
 
 // src/commands/dark-matter.ts
-import path37 from "path";
+import path38 from "path";
 async function handleDarkMatterCommand(directory, args) {
   const options = {};
   for (let i = 0;i < args.length; i++) {
@@ -19761,7 +19858,7 @@ Ensure this is a git repository with commit history.`;
   const output = formatDarkMatterOutput(pairs);
   if (pairs.length > 0) {
     try {
-      const projectName = path37.basename(path37.resolve(directory));
+      const projectName = path38.basename(path38.resolve(directory));
       const entries = darkMatterToKnowledgeEntries(pairs, projectName);
       if (entries.length > 0) {
         const knowledgePath = resolveSwarmKnowledgePath(directory);
@@ -20128,49 +20225,49 @@ ${USAGE5}`;
 // src/services/diagnose-service.ts
 import * as child_process4 from "child_process";
 import { existsSync as existsSync20, readdirSync as readdirSync3, readFileSync as readFileSync10, statSync as statSync6 } from "fs";
-import path39 from "path";
+import path40 from "path";
 import { fileURLToPath } from "url";
 
 // src/config/cache-paths.ts
 import * as os10 from "os";
-import * as path38 from "path";
+import * as path39 from "path";
 function getPluginConfigDir() {
-  return path38.join(process.env.XDG_CONFIG_HOME || path38.join(os10.homedir(), ".config"), "opencode");
+  return path39.join(process.env.XDG_CONFIG_HOME || path39.join(os10.homedir(), ".config"), "opencode");
 }
 function getPluginCachePaths() {
-  const cacheBase = process.env.XDG_CACHE_HOME || path38.join(os10.homedir(), ".cache");
+  const cacheBase = process.env.XDG_CACHE_HOME || path39.join(os10.homedir(), ".cache");
   const configDir = getPluginConfigDir();
   const paths = [
-    path38.join(cacheBase, "opencode", "node_modules", "opencode-swarm"),
-    path38.join(cacheBase, "opencode", "packages", "opencode-swarm@latest"),
-    path38.join(configDir, "node_modules", "opencode-swarm")
+    path39.join(cacheBase, "opencode", "node_modules", "opencode-swarm"),
+    path39.join(cacheBase, "opencode", "packages", "opencode-swarm@latest"),
+    path39.join(configDir, "node_modules", "opencode-swarm")
   ];
   if (process.platform === "darwin") {
-    const libCaches = path38.join(os10.homedir(), "Library", "Caches");
-    paths.push(path38.join(libCaches, "opencode", "node_modules", "opencode-swarm"), path38.join(libCaches, "opencode", "packages", "opencode-swarm@latest"));
+    const libCaches = path39.join(os10.homedir(), "Library", "Caches");
+    paths.push(path39.join(libCaches, "opencode", "node_modules", "opencode-swarm"), path39.join(libCaches, "opencode", "packages", "opencode-swarm@latest"));
   }
   if (process.platform === "win32") {
-    const localAppData = process.env.LOCALAPPDATA || path38.join(os10.homedir(), "AppData", "Local");
-    const appData = process.env.APPDATA || path38.join(os10.homedir(), "AppData", "Roaming");
-    paths.push(path38.join(localAppData, "opencode", "node_modules", "opencode-swarm"), path38.join(localAppData, "opencode", "packages", "opencode-swarm@latest"), path38.join(appData, "opencode", "node_modules", "opencode-swarm"));
+    const localAppData = process.env.LOCALAPPDATA || path39.join(os10.homedir(), "AppData", "Local");
+    const appData = process.env.APPDATA || path39.join(os10.homedir(), "AppData", "Roaming");
+    paths.push(path39.join(localAppData, "opencode", "node_modules", "opencode-swarm"), path39.join(localAppData, "opencode", "packages", "opencode-swarm@latest"), path39.join(appData, "opencode", "node_modules", "opencode-swarm"));
   }
   return paths;
 }
 function getPluginLockFilePaths() {
-  const cacheBase = process.env.XDG_CACHE_HOME || path38.join(os10.homedir(), ".cache");
+  const cacheBase = process.env.XDG_CACHE_HOME || path39.join(os10.homedir(), ".cache");
   const configDir = getPluginConfigDir();
   const paths = [
-    path38.join(cacheBase, "opencode", "bun.lock"),
-    path38.join(cacheBase, "opencode", "bun.lockb"),
-    path38.join(configDir, "package-lock.json")
+    path39.join(cacheBase, "opencode", "bun.lock"),
+    path39.join(cacheBase, "opencode", "bun.lockb"),
+    path39.join(configDir, "package-lock.json")
   ];
   if (process.platform === "darwin") {
-    const libCaches = path38.join(os10.homedir(), "Library", "Caches");
-    paths.push(path38.join(libCaches, "opencode", "bun.lock"), path38.join(libCaches, "opencode", "bun.lockb"));
+    const libCaches = path39.join(os10.homedir(), "Library", "Caches");
+    paths.push(path39.join(libCaches, "opencode", "bun.lock"), path39.join(libCaches, "opencode", "bun.lockb"));
   }
   if (process.platform === "win32") {
-    const localAppData = process.env.LOCALAPPDATA || path38.join(os10.homedir(), "AppData", "Local");
-    paths.push(path38.join(localAppData, "opencode", "bun.lock"), path38.join(localAppData, "opencode", "bun.lockb"));
+    const localAppData = process.env.LOCALAPPDATA || path39.join(os10.homedir(), "AppData", "Local");
+    paths.push(path39.join(localAppData, "opencode", "bun.lock"), path39.join(localAppData, "opencode", "bun.lockb"));
   }
   return paths;
 }
@@ -20186,24 +20283,24 @@ import { readFile as readFile12 } from "fs/promises";
 // src/services/version-check.ts
 import { existsSync as existsSync18, mkdirSync as mkdirSync12, readFileSync as readFileSync9, writeFileSync as writeFileSync8 } from "fs";
 import { homedir as homedir6 } from "os";
-import { join as join32 } from "path";
+import { join as join33 } from "path";
 var CHECK_INTERVAL_MS = 24 * 60 * 60 * 1000;
 var SEMVER_REGEX = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-((?:0|[1-9]\d*|\d*[A-Za-z-][0-9A-Za-z-]*)(?:\.(?:0|[1-9]\d*|\d*[A-Za-z-][0-9A-Za-z-]*))*))?(?:\+([0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*))?$/;
 var MAX_RESPONSE_BYTES = 256 * 1024;
 function cacheDir() {
   const xdg = process.env.XDG_CACHE_HOME;
-  const base = xdg && xdg.length > 0 ? xdg : join32(homedir6(), ".cache");
-  return join32(base, "opencode-swarm");
+  const base = xdg && xdg.length > 0 ? xdg : join33(homedir6(), ".cache");
+  return join33(base, "opencode-swarm");
 }
 function cacheFile() {
-  return join32(cacheDir(), "version-check.json");
+  return join33(cacheDir(), "version-check.json");
 }
 function readVersionCache() {
   try {
-    const path39 = cacheFile();
-    if (!existsSync18(path39))
+    const path40 = cacheFile();
+    if (!existsSync18(path40))
       return null;
-    const raw = readFileSync9(path39, "utf-8");
+    const raw = readFileSync9(path40, "utf-8");
     const parsed = JSON.parse(raw);
     if (typeof parsed?.checkedAt !== "number")
       return null;
@@ -20458,7 +20555,7 @@ var REQUIRED_CACHE_GRAMMAR_ASSETS = [
   "tree-sitter-typescript.wasm"
 ];
 function resolveCachePackageRoot(cachePath) {
-  const nestedPackageRoot = path39.join(cachePath, "node_modules", "opencode-swarm");
+  const nestedPackageRoot = path40.join(cachePath, "node_modules", "opencode-swarm");
   return existsSync20(nestedPackageRoot) ? nestedPackageRoot : cachePath;
 }
 var _internals26 = {
@@ -20774,7 +20871,7 @@ async function checkSpecStaleness(directory, plan) {
   };
 }
 async function checkConfigParseability(directory) {
-  const configPath = path39.join(directory, ".opencode/opencode-swarm.json");
+  const configPath = path40.join(directory, ".opencode/opencode-swarm.json");
   if (!existsSync20(configPath)) {
     return {
       name: "Config Parseability",
@@ -20803,7 +20900,7 @@ function resolveGrammarDir(thisDir) {
   const normalized = thisDir.replace(/\\/g, "/");
   const isSource = normalized.endsWith("/src/services");
   const isCliBundle = normalized.endsWith("/cli");
-  return isSource || isCliBundle ? path39.join(thisDir, "..", "lang", "grammars") : path39.join(thisDir, "lang", "grammars");
+  return isSource || isCliBundle ? path40.join(thisDir, "..", "lang", "grammars") : path40.join(thisDir, "lang", "grammars");
 }
 async function checkGrammarWasmFiles() {
   const grammarFiles = [
@@ -20827,14 +20924,14 @@ async function checkGrammarWasmFiles() {
     "tree-sitter-ini.wasm",
     "tree-sitter-regex.wasm"
   ];
-  const thisDir = path39.dirname(fileURLToPath(import.meta.url));
+  const thisDir = path40.dirname(fileURLToPath(import.meta.url));
   const grammarDir = resolveGrammarDir(thisDir);
   const missing = [];
-  if (!existsSync20(path39.join(grammarDir, "tree-sitter.wasm"))) {
+  if (!existsSync20(path40.join(grammarDir, "tree-sitter.wasm"))) {
     missing.push("tree-sitter.wasm (core runtime)");
   }
   for (const file of grammarFiles) {
-    if (!existsSync20(path39.join(grammarDir, file))) {
+    if (!existsSync20(path40.join(grammarDir, file))) {
       missing.push(file);
     }
   }
@@ -20852,7 +20949,7 @@ async function checkGrammarWasmFiles() {
   };
 }
 async function checkCheckpointManifest(directory) {
-  const manifestPath = path39.join(directory, ".swarm/checkpoints.json");
+  const manifestPath = path40.join(directory, ".swarm/checkpoints.json");
   if (!existsSync20(manifestPath)) {
     return {
       name: "Checkpoint Manifest",
@@ -20904,7 +21001,7 @@ async function checkCheckpointManifest(directory) {
   }
 }
 async function checkEventStreamIntegrity(directory) {
-  const eventsPath = path39.join(directory, ".swarm/events.jsonl");
+  const eventsPath = path40.join(directory, ".swarm/events.jsonl");
   if (!existsSync20(eventsPath)) {
     return {
       name: "Event Stream",
@@ -20945,7 +21042,7 @@ async function checkEventStreamIntegrity(directory) {
   }
 }
 async function checkSteeringDirectives(directory) {
-  const eventsPath = path39.join(directory, ".swarm/events.jsonl");
+  const eventsPath = path40.join(directory, ".swarm/events.jsonl");
   if (!existsSync20(eventsPath)) {
     return {
       name: "Steering Directives",
@@ -21001,7 +21098,7 @@ async function checkCurator(directory) {
         detail: "Disabled (enable via curator.enabled)"
       };
     }
-    const summaryPath = path39.join(directory, ".swarm/curator-summary.json");
+    const summaryPath = path40.join(directory, ".swarm/curator-summary.json");
     if (!existsSync20(summaryPath)) {
       return {
         name: "Curator",
@@ -21203,7 +21300,7 @@ async function getDiagnoseData(directory) {
   checks.push(await checkCurator(directory));
   checks.push(await checkKnowledgeHealth(directory));
   try {
-    const evidenceDir = path39.join(directory, ".swarm", "evidence");
+    const evidenceDir = path40.join(directory, ".swarm", "evidence");
     const snapshotFiles = existsSync20(evidenceDir) ? readdirSync3(evidenceDir).filter((f) => f.startsWith("agent-tools-") && f.endsWith(".json")) : [];
     if (snapshotFiles.length > 0) {
       const latest = snapshotFiles.sort().pop();
@@ -21243,8 +21340,8 @@ async function getDiagnoseData(directory) {
       }
       const packageRoot = resolveCachePackageRoot(cachePath);
       const cacheLabel = packageRoot === cachePath ? cachePath : `${cachePath} -> ${packageRoot}`;
-      const missingGrammarAssets = REQUIRED_CACHE_GRAMMAR_ASSETS.filter((file) => !existsSync20(path39.join(packageRoot, "dist", "lang", "grammars", file)));
-      const pkgJsonPath = path39.join(packageRoot, "package.json");
+      const missingGrammarAssets = REQUIRED_CACHE_GRAMMAR_ASSETS.filter((file) => !existsSync20(path40.join(packageRoot, "dist", "lang", "grammars", file)));
+      const pkgJsonPath = path40.join(packageRoot, "package.json");
       try {
         const raw = readFileSync10(pkgJsonPath, "utf-8");
         const parsed = JSON.parse(raw);
@@ -21620,9 +21717,9 @@ function decideEpicActivation(tasks, cochangePairs, commitsObserved, options) {
 // src/turbo/epic/calibration.ts
 init_logger();
 import * as fs15 from "fs";
-import * as path40 from "path";
+import * as path41 from "path";
 var STATE_FILE = "calibration.json";
-var STATE_REL_DIR = path40.join(".swarm", "epic");
+var STATE_REL_DIR = path41.join(".swarm", "epic");
 function nowISO() {
   return new Date().toISOString();
 }
@@ -21644,7 +21741,7 @@ function markUnreadable(directory, reason) {
   error(`[epic/calibration] state file unreadable for ${directory}: ${reason} \u2014 failing closed`);
 }
 function repairCalibrationUnreadable(directory) {
-  const filePath = path40.join(directory, STATE_REL_DIR, STATE_FILE);
+  const filePath = path41.join(directory, STATE_REL_DIR, STATE_FILE);
   if (!fs15.existsSync(filePath)) {
     stateUnreadableMap.delete(directory);
     return;
@@ -21676,7 +21773,7 @@ function isValidCalibrationShape(candidate) {
   return true;
 }
 function ensureSwarmEpicDir(directory) {
-  const dir = path40.resolve(directory, STATE_REL_DIR);
+  const dir = path41.resolve(directory, STATE_REL_DIR);
   if (!fs15.existsSync(dir)) {
     fs15.mkdirSync(dir, { recursive: true });
   }
@@ -21688,7 +21785,7 @@ function loadCalibrationState(directory) {
     if (stateUnreadableMap.get(directory))
       return null;
   }
-  const filePath = path40.join(directory, STATE_REL_DIR, STATE_FILE);
+  const filePath = path41.join(directory, STATE_REL_DIR, STATE_FILE);
   try {
     if (!fs15.existsSync(filePath)) {
       const seed = emptyCalibrationState();
@@ -21715,12 +21812,12 @@ function loadCalibrationState(directory) {
 // src/turbo/epic/divergence-recorder.ts
 init_logger();
 import * as fs16 from "fs";
-import * as path41 from "path";
-var EVIDENCE_REL_DIR = path41.join(".swarm", "epic");
+import * as path42 from "path";
+var EVIDENCE_REL_DIR = path42.join(".swarm", "epic");
 var EVIDENCE_FILE = "divergence.jsonl";
 var MAX_TAIL_BYTES2 = 16 * 1024 * 1024;
 function readDivergenceHistory(directory, options) {
-  const filePath = path41.join(directory, EVIDENCE_REL_DIR, EVIDENCE_FILE);
+  const filePath = path42.join(directory, EVIDENCE_REL_DIR, EVIDENCE_FILE);
   if (!fs16.existsSync(filePath)) {
     return [];
   }
@@ -21769,11 +21866,11 @@ function readDivergenceHistory(directory, options) {
 
 // src/turbo/epic/promotion-evidence.ts
 import * as fs17 from "fs";
-import * as path42 from "path";
-var EVIDENCE_REL_DIR2 = path42.join(".swarm", "evidence");
+import * as path43 from "path";
+var EVIDENCE_REL_DIR2 = path43.join(".swarm", "evidence");
 var EVIDENCE_FILE2 = "epic-promotions.jsonl";
 function readPromotionEvidence(directory) {
-  const filePath = path42.join(directory, EVIDENCE_REL_DIR2, EVIDENCE_FILE2);
+  const filePath = path43.join(directory, EVIDENCE_REL_DIR2, EVIDENCE_FILE2);
   if (!fs17.existsSync(filePath)) {
     return [];
   }
@@ -22282,7 +22379,7 @@ async function handleEvidenceCommand(directory, args) {
   return formatTaskEvidenceMarkdown(evidenceData);
 }
 async function handleEvidenceSummaryCommand(directory) {
-  const { buildEvidenceSummary } = await import("./evidence-summary-service-v9kmv783.js");
+  const { buildEvidenceSummary } = await import("./evidence-summary-service-zhw4rkjb.js");
   const artifact = await buildEvidenceSummary(directory);
   if (!artifact) {
     return "No plan found. Run `/swarm plan` to check plan status.";
@@ -22347,7 +22444,7 @@ async function handleExportCommand(directory, _args) {
 // src/full-auto/state.ts
 var import_proper_lockfile4 = __toESM(require_proper_lockfile(), 1);
 import * as fs18 from "fs";
-import * as path43 from "path";
+import * as path44 from "path";
 init_logger();
 var lockfile4 = import_proper_lockfile4.default;
 var STATE_FILE2 = "full-auto-state.json";
@@ -22355,7 +22452,7 @@ function nowISO2() {
   return new Date().toISOString();
 }
 function ensureSwarmDir(directory) {
-  const swarmDir = path43.resolve(directory, ".swarm");
+  const swarmDir = path44.resolve(directory, ".swarm");
   if (!fs18.existsSync(swarmDir)) {
     fs18.mkdirSync(swarmDir, { recursive: true });
   }
@@ -23167,7 +23264,7 @@ var _internals29 = {
 
 // src/session/snapshot-writer.ts
 import { closeSync as closeSync6, fsyncSync as fsyncSync2, mkdirSync as mkdirSync17, openSync as openSync6, renameSync as renameSync9 } from "fs";
-import * as path44 from "path";
+import * as path45 from "path";
 var _writeInFlight = Promise.resolve();
 function serializeAgentSession(s) {
   const gateLog = {};
@@ -23274,7 +23371,7 @@ async function writeSnapshot(directory, state) {
     }
     const content = JSON.stringify(snapshot, null, 2);
     const resolvedPath = validateSwarmPath(directory, "session/state.json");
-    const dir = path44.dirname(resolvedPath);
+    const dir = path45.dirname(resolvedPath);
     mkdirSync17(dir, { recursive: true });
     const tempPath = `${resolvedPath}.tmp.${Date.now()}.${Math.random().toString(36).slice(2)}`;
     await bunWrite(tempPath, content);
@@ -23777,7 +23874,7 @@ ${USAGE6}`;
 }
 
 // src/commands/knowledge.ts
-import { join as join37 } from "path";
+import { join as join38 } from "path";
 
 // src/hooks/knowledge-migrator.ts
 init_logger();
@@ -23785,15 +23882,15 @@ import { randomUUID as randomUUID6 } from "crypto";
 import { existsSync as existsSync25, readFileSync as readFileSync15 } from "fs";
 import { mkdir as mkdir11, readFile as readFile13, writeFile as writeFile11 } from "fs/promises";
 import * as os11 from "os";
-import * as path45 from "path";
+import * as path46 from "path";
 
 // src/hooks/knowledge-types.ts
 var KNOWLEDGE_SCHEMA_VERSION = 2;
 
 // src/hooks/knowledge-migrator.ts
 async function migrateKnowledgeToExternal(_directory, _config) {
-  const externalSentinelPath = path45.join(_directory, ".swarm", ".knowledge-external-migrated");
-  const contextPath = path45.join(_directory, ".swarm", "context.md");
+  const externalSentinelPath = path46.join(_directory, ".swarm", ".knowledge-external-migrated");
+  const contextPath = path46.join(_directory, ".swarm", "context.md");
   if (_internals32.existsSync(externalSentinelPath)) {
     return {
       migrated: false,
@@ -23858,8 +23955,8 @@ var _internals32 = {
   writeFile: writeFile11
 };
 async function migrateContextToKnowledge(directory, config) {
-  const sentinelPath = path45.join(directory, ".swarm", ".knowledge-migrated");
-  const contextPath = path45.join(directory, ".swarm", "context.md");
+  const sentinelPath = path46.join(directory, ".swarm", ".knowledge-migrated");
+  const contextPath = path46.join(directory, ".swarm", "context.md");
   const knowledgePath = resolveSwarmKnowledgePath(directory);
   if (existsSync25(sentinelPath)) {
     return {
@@ -23961,7 +24058,7 @@ async function migrateContextToKnowledge(directory, config) {
 async function migrateHiveKnowledgeLegacy(config) {
   const legacyHivePath = _internals32.resolveLegacyHiveKnowledgePath();
   const canonicalHivePath = resolveHiveKnowledgePath();
-  const sentinelPath = path45.join(path45.dirname(canonicalHivePath), ".hive-knowledge-migrated");
+  const sentinelPath = path46.join(path46.dirname(canonicalHivePath), ".hive-knowledge-migrated");
   if (existsSync25(sentinelPath)) {
     return {
       migrated: false,
@@ -24172,7 +24269,7 @@ function truncateLesson2(text) {
   return `${text.slice(0, 277)}...`;
 }
 function inferProjectName(directory) {
-  const packageJsonPath = path45.join(directory, "package.json");
+  const packageJsonPath = path46.join(directory, "package.json");
   if (existsSync25(packageJsonPath)) {
     try {
       const pkg = JSON.parse(readFileSync15(packageJsonPath, "utf-8"));
@@ -24181,7 +24278,7 @@ function inferProjectName(directory) {
       }
     } catch {}
   }
-  return path45.basename(directory);
+  return path46.basename(directory);
 }
 async function writeSentinel(sentinelPath, migrated, dropped) {
   const sentinel = {
@@ -24193,7 +24290,7 @@ async function writeSentinel(sentinelPath, migrated, dropped) {
     schema_version: 1,
     migration_tool: "knowledge-migrator.ts"
   };
-  await _internals32.mkdir(path45.dirname(sentinelPath), { recursive: true });
+  await _internals32.mkdir(path46.dirname(sentinelPath), { recursive: true });
   await _internals32.writeFile(sentinelPath, JSON.stringify(sentinel, null, 2), "utf-8");
 }
 function resolveLegacyHiveKnowledgePath() {
@@ -24201,13 +24298,13 @@ function resolveLegacyHiveKnowledgePath() {
   const home = process.env.HOME || os11.homedir();
   let dataDir;
   if (platform === "win32") {
-    dataDir = path45.join(process.env.LOCALAPPDATA || path45.join(home, "AppData", "Local"), "opencode-swarm", "Data");
+    dataDir = path46.join(process.env.LOCALAPPDATA || path46.join(home, "AppData", "Local"), "opencode-swarm", "Data");
   } else if (platform === "darwin") {
-    dataDir = path45.join(home, "Library", "Application Support", "opencode-swarm");
+    dataDir = path46.join(home, "Library", "Application Support", "opencode-swarm");
   } else {
-    dataDir = path45.join(process.env.XDG_DATA_HOME || path45.join(home, ".local", "share"), "opencode-swarm");
+    dataDir = path46.join(process.env.XDG_DATA_HOME || path46.join(home, ".local", "share"), "opencode-swarm");
   }
-  return path45.join(dataDir, "hive-knowledge.jsonl");
+  return path46.join(dataDir, "hive-knowledge.jsonl");
 }
 
 // src/commands/knowledge.ts
@@ -24261,7 +24358,7 @@ async function handleKnowledgeRestoreCommand(directory, args) {
     return "Invalid entry ID. IDs must be 1-64 characters: letters, digits, hyphens, underscores only.";
   }
   try {
-    const quarantinePath = join37(resolveKnowledgeStoreDir(directory), "knowledge-quarantined.jsonl");
+    const quarantinePath = join38(resolveKnowledgeStoreDir(directory), "knowledge-quarantined.jsonl");
     const entries = await readKnowledge(quarantinePath);
     const resolved = resolveEntryByPrefix(entries, inputId);
     if ("error" in resolved) {
@@ -24513,14 +24610,14 @@ var _internals33 = {
 
 // src/commands/link.ts
 import { existsSync as existsSync26 } from "fs";
-import * as path47 from "path";
+import * as path48 from "path";
 
 // src/knowledge/identity.ts
 import * as child_process5 from "child_process";
 import { createHash as createHash5 } from "crypto";
-import * as path46 from "path";
+import * as path47 from "path";
 function deriveProjectHash(directory) {
-  const absolutePath = path46.resolve(directory);
+  const absolutePath = path47.resolve(directory);
   let hashInput;
   try {
     const remoteUrl = child_process5.execSync("git remote get-url origin", {
@@ -24540,8 +24637,8 @@ function deriveProjectHash(directory) {
 // src/commands/link.ts
 var DEDUP_THRESHOLD = 0.6;
 async function mergeLocalKnowledgeIntoLink(localSwarmDir, linkDir) {
-  const localPath = path47.join(localSwarmDir, "knowledge.jsonl");
-  const sharedPath = path47.join(linkDir, "knowledge.jsonl");
+  const localPath = path48.join(localSwarmDir, "knowledge.jsonl");
+  const sharedPath = path48.join(linkDir, "knowledge.jsonl");
   if (!existsSync26(localPath))
     return { merged: 0, skipped: 0 };
   let merged = 0;
@@ -24639,7 +24736,7 @@ ${formatStatus(directory)}`;
   const linkDir = resolveLinkDir(linkId);
   let merge;
   try {
-    merge = await mergeLocalKnowledgeIntoLink(path47.join(directory, ".swarm"), linkDir);
+    merge = await mergeLocalKnowledgeIntoLink(path48.join(directory, ".swarm"), linkDir);
   } catch (error2) {
     return `\u274C Failed to merge local knowledge into the link store: ${error2 instanceof Error ? error2.message : String(error2)}`;
   }
@@ -24836,12 +24933,12 @@ ${USAGE7}`;
 
 // src/commands/memory.ts
 import { existsSync as existsSync27 } from "fs";
-import * as path50 from "path";
+import * as path51 from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 // src/memory/evaluation.ts
 import * as fs19 from "fs/promises";
 import * as os12 from "os";
-import * as path48 from "path";
+import * as path49 from "path";
 var DEFAULT_PROVIDERS = [
   "local-jsonl",
   "sqlite"
@@ -24853,7 +24950,7 @@ var DEFAULT_MODES = [
 ];
 var DEFAULT_TIMESTAMP = "2026-05-26T12:00:00.000Z";
 async function evaluateMemoryRecallFixtures(options) {
-  const fixtureDirectory = path48.resolve(options.fixtureDirectory);
+  const fixtureDirectory = path49.resolve(options.fixtureDirectory);
   const providers = options.providers ?? DEFAULT_PROVIDERS;
   const modes = options.modes ?? DEFAULT_MODES;
   const generatedAt = new Date().toISOString();
@@ -24862,7 +24959,7 @@ async function evaluateMemoryRecallFixtures(options) {
   for (const fixture of fixtures) {
     const materialized = materializeFixture(fixture);
     for (const providerName of providers) {
-      const tempRoot = await fs19.realpath(await fs19.mkdtemp(path48.join(os12.tmpdir(), "swarm-memory-eval-")));
+      const tempRoot = await fs19.realpath(await fs19.mkdtemp(path49.join(os12.tmpdir(), "swarm-memory-eval-")));
       const provider = createEvaluationProvider(providerName, tempRoot);
       try {
         await provider.initialize?.();
@@ -24919,7 +25016,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 file of files) {
-    const raw = await fs19.readFile(path48.join(fixtureDirectory, file), "utf-8");
+    const raw = await fs19.readFile(path49.join(fixtureDirectory, file), "utf-8");
     fixtures.push(validateFixture(JSON.parse(raw), file));
   }
   return fixtures;
@@ -25196,8 +25293,8 @@ var CuratorOutputMemoryDecisionSchema = exports_external.object({
 }).passthrough();
 // src/memory/consolidation-log.ts
 import { appendFile as appendFile4, mkdir as mkdir12, readFile as readFile15 } from "fs/promises";
-import * as path49 from "path";
-var LOG_RELATIVE_PATH = path49.join("memory", "consolidation-log.jsonl");
+import * as path50 from "path";
+var LOG_RELATIVE_PATH = path50.join("memory", "consolidation-log.jsonl");
 async function readConsolidationLog(directory) {
   const filePath = validateSwarmPath(directory, LOG_RELATIVE_PATH);
   let raw;
@@ -25220,7 +25317,7 @@ async function readConsolidationLog(directory) {
 }
 
 // src/commands/memory.ts
-var PACKAGE_ROOT = path50.resolve(resolvePackageRootFromModule(fileURLToPath2(import.meta.url)));
+var PACKAGE_ROOT = path51.resolve(resolvePackageRootFromModule(fileURLToPath2(import.meta.url)));
 async function handleMemoryCommand(_directory, _args) {
   return [
     "## Swarm Memory",
@@ -25577,7 +25674,7 @@ function resolveCommandMemoryConfig(directory) {
 }
 function parseEvaluateArgs(directory, args) {
   let json = false;
-  let fixtureDirectory = path50.join(PACKAGE_ROOT, "tests", "fixtures", "memory-recall");
+  let fixtureDirectory = path51.join(PACKAGE_ROOT, "tests", "fixtures", "memory-recall");
   for (let i = 0;i < args.length; i++) {
     const arg = args[i];
     if (arg === "--json") {
@@ -25591,10 +25688,10 @@ function parseEvaluateArgs(directory, args) {
           error: "Usage: /swarm memory evaluate [--json] [--fixtures <directory>]"
         };
       }
-      const resolvedFixtures = path50.resolve(directory, next);
-      const canonical = path50.normalize(resolvedFixtures) + path50.sep;
-      const allowedRootA = path50.normalize(directory) + path50.sep;
-      const allowedRootB = path50.normalize(path50.join(PACKAGE_ROOT, "tests", "fixtures", "memory-recall")) + path50.sep;
+      const resolvedFixtures = path51.resolve(directory, next);
+      const canonical = path51.normalize(resolvedFixtures) + path51.sep;
+      const allowedRootA = path51.normalize(directory) + path51.sep;
+      const allowedRootB = path51.normalize(path51.join(PACKAGE_ROOT, "tests", "fixtures", "memory-recall")) + path51.sep;
       if (!canonical.startsWith(allowedRootA) && !canonical.startsWith(allowedRootB)) {
         return {
           error: "--fixtures <directory> must resolve under the project directory or the bundled tests/fixtures/memory-recall directory"
@@ -25633,15 +25730,15 @@ function parseMaintenanceArgs(args, options) {
   return { limit, confirm };
 }
 function resolvePackageRootFromModule(modulePath) {
-  const moduleDir = path50.dirname(modulePath);
-  const leaf = path50.basename(moduleDir);
+  const moduleDir = path51.dirname(modulePath);
+  const leaf = path51.basename(moduleDir);
   if (leaf === "commands" || leaf === "cli") {
-    return path50.resolve(moduleDir, "..", "..");
+    return path51.resolve(moduleDir, "..", "..");
   }
   if (leaf === "dist") {
-    return path50.resolve(moduleDir, "..");
+    return path51.resolve(moduleDir, "..");
   }
-  return path50.resolve(moduleDir, "..");
+  return path51.resolve(moduleDir, "..");
 }
 function formatMigrationResult(label, report) {
   if (!report) {
@@ -26340,11 +26437,11 @@ var _internals39 = {
 
 // src/services/preflight-service.ts
 import * as fs26 from "fs";
-import * as path57 from "path";
+import * as path58 from "path";
 
 // src/tools/lint.ts
 import * as fs20 from "fs";
-import * as path51 from "path";
+import * as path52 from "path";
 
 // src/utils/path-security.ts
 function containsPathTraversal(str) {
@@ -26400,9 +26497,9 @@ function validateArgs(args) {
 }
 function getLinterCommand(linter, mode, projectDir) {
   const isWindows = process.platform === "win32";
-  const binDir = path51.join(projectDir, "node_modules", ".bin");
-  const biomeBin = isWindows ? path51.join(binDir, "biome.EXE") : path51.join(binDir, "biome");
-  const eslintBin = isWindows ? path51.join(binDir, "eslint.cmd") : path51.join(binDir, "eslint");
+  const binDir = path52.join(projectDir, "node_modules", ".bin");
+  const biomeBin = isWindows ? path52.join(binDir, "biome.EXE") : path52.join(binDir, "biome");
+  const eslintBin = isWindows ? path52.join(binDir, "eslint.cmd") : path52.join(binDir, "eslint");
   switch (linter) {
     case "biome":
       if (mode === "fix") {
@@ -26418,7 +26515,7 @@ function getLinterCommand(linter, mode, projectDir) {
 }
 function getAdditionalLinterCommand(linter, mode, cwd) {
   const gradlewName = process.platform === "win32" ? "gradlew.bat" : "gradlew";
-  const gradlew = fs20.existsSync(path51.join(cwd, gradlewName)) ? path51.join(cwd, gradlewName) : null;
+  const gradlew = fs20.existsSync(path52.join(cwd, gradlewName)) ? path52.join(cwd, gradlewName) : null;
   switch (linter) {
     case "ruff":
       return mode === "fix" ? ["ruff", "check", "--fix", "."] : ["ruff", "check", "."];
@@ -26452,10 +26549,10 @@ function getAdditionalLinterCommand(linter, mode, cwd) {
   }
 }
 function detectRuff(cwd) {
-  if (fs20.existsSync(path51.join(cwd, "ruff.toml")))
+  if (fs20.existsSync(path52.join(cwd, "ruff.toml")))
     return isCommandAvailable("ruff");
   try {
-    const pyproject = path51.join(cwd, "pyproject.toml");
+    const pyproject = path52.join(cwd, "pyproject.toml");
     if (fs20.existsSync(pyproject)) {
       const content = fs20.readFileSync(pyproject, "utf-8");
       if (content.includes("[tool.ruff]"))
@@ -26465,19 +26562,19 @@ function detectRuff(cwd) {
   return false;
 }
 function detectClippy(cwd) {
-  return fs20.existsSync(path51.join(cwd, "Cargo.toml")) && isCommandAvailable("cargo");
+  return fs20.existsSync(path52.join(cwd, "Cargo.toml")) && isCommandAvailable("cargo");
 }
 function detectGolangciLint(cwd) {
-  return fs20.existsSync(path51.join(cwd, "go.mod")) && isCommandAvailable("golangci-lint");
+  return fs20.existsSync(path52.join(cwd, "go.mod")) && isCommandAvailable("golangci-lint");
 }
 function detectCheckstyle(cwd) {
-  const hasMaven = fs20.existsSync(path51.join(cwd, "pom.xml"));
-  const hasGradle = fs20.existsSync(path51.join(cwd, "build.gradle")) || fs20.existsSync(path51.join(cwd, "build.gradle.kts"));
-  const hasBinary = hasMaven && isCommandAvailable("mvn") || hasGradle && (fs20.existsSync(path51.join(cwd, "gradlew")) || isCommandAvailable("gradle"));
+  const hasMaven = fs20.existsSync(path52.join(cwd, "pom.xml"));
+  const hasGradle = fs20.existsSync(path52.join(cwd, "build.gradle")) || fs20.existsSync(path52.join(cwd, "build.gradle.kts"));
+  const hasBinary = hasMaven && isCommandAvailable("mvn") || hasGradle && (fs20.existsSync(path52.join(cwd, "gradlew")) || isCommandAvailable("gradle"));
   return (hasMaven || hasGradle) && hasBinary;
 }
 function detectKtlint(cwd) {
-  const hasKotlin = fs20.existsSync(path51.join(cwd, "build.gradle.kts")) || fs20.existsSync(path51.join(cwd, "build.gradle")) || (() => {
+  const hasKotlin = fs20.existsSync(path52.join(cwd, "build.gradle.kts")) || fs20.existsSync(path52.join(cwd, "build.gradle")) || (() => {
     try {
       return fs20.readdirSync(cwd).some((f) => f.endsWith(".kt") || f.endsWith(".kts"));
     } catch {
@@ -26496,11 +26593,11 @@ function detectDotnetFormat(cwd) {
   }
 }
 function detectCppcheck(cwd) {
-  if (fs20.existsSync(path51.join(cwd, "CMakeLists.txt"))) {
+  if (fs20.existsSync(path52.join(cwd, "CMakeLists.txt"))) {
     return isCommandAvailable("cppcheck");
   }
   try {
-    const dirsToCheck = [cwd, path51.join(cwd, "src")];
+    const dirsToCheck = [cwd, path52.join(cwd, "src")];
     const hasCpp = dirsToCheck.some((dir) => {
       try {
         return fs20.readdirSync(dir).some((f) => /\.(c|cpp|cc|cxx|h|hpp)$/.test(f));
@@ -26514,13 +26611,13 @@ function detectCppcheck(cwd) {
   }
 }
 function detectSwiftlint(cwd) {
-  return fs20.existsSync(path51.join(cwd, "Package.swift")) && isCommandAvailable("swiftlint");
+  return fs20.existsSync(path52.join(cwd, "Package.swift")) && isCommandAvailable("swiftlint");
 }
 function detectDartAnalyze(cwd) {
-  return fs20.existsSync(path51.join(cwd, "pubspec.yaml")) && (isCommandAvailable("dart") || isCommandAvailable("flutter"));
+  return fs20.existsSync(path52.join(cwd, "pubspec.yaml")) && (isCommandAvailable("dart") || isCommandAvailable("flutter"));
 }
 function detectRubocop(cwd) {
-  return (fs20.existsSync(path51.join(cwd, "Gemfile")) || fs20.existsSync(path51.join(cwd, "gems.rb")) || fs20.existsSync(path51.join(cwd, ".rubocop.yml"))) && (isCommandAvailable("rubocop") || isCommandAvailable("bundle"));
+  return (fs20.existsSync(path52.join(cwd, "Gemfile")) || fs20.existsSync(path52.join(cwd, "gems.rb")) || fs20.existsSync(path52.join(cwd, ".rubocop.yml"))) && (isCommandAvailable("rubocop") || isCommandAvailable("bundle"));
 }
 function detectAdditionalLinter(cwd) {
   if (detectRuff(cwd))
@@ -26548,10 +26645,10 @@ function detectAdditionalLinter(cwd) {
 function findBinInAncestors(startDir, binName) {
   let dir = startDir;
   while (true) {
-    const candidate = path51.join(dir, "node_modules", ".bin", binName);
+    const candidate = path52.join(dir, "node_modules", ".bin", binName);
     if (fs20.existsSync(candidate))
       return candidate;
-    const parent = path51.dirname(dir);
+    const parent = path52.dirname(dir);
     if (parent === dir)
       break;
     dir = parent;
@@ -26560,10 +26657,10 @@ function findBinInAncestors(startDir, binName) {
 }
 function findBinInEnvPath(binName) {
   const searchPath = process.env.PATH ?? "";
-  for (const dir of searchPath.split(path51.delimiter)) {
+  for (const dir of searchPath.split(path52.delimiter)) {
     if (!dir)
       continue;
-    const candidate = path51.join(dir, binName);
+    const candidate = path52.join(dir, binName);
     if (fs20.existsSync(candidate))
       return candidate;
   }
@@ -26576,13 +26673,13 @@ async function detectAvailableLinter(directory) {
     return null;
   const projectDir = directory;
   const isWindows = process.platform === "win32";
-  const biomeBin = isWindows ? path51.join(projectDir, "node_modules", ".bin", "biome.EXE") : path51.join(projectDir, "node_modules", ".bin", "biome");
-  const eslintBin = isWindows ? path51.join(projectDir, "node_modules", ".bin", "eslint.cmd") : path51.join(projectDir, "node_modules", ".bin", "eslint");
+  const biomeBin = isWindows ? path52.join(projectDir, "node_modules", ".bin", "biome.EXE") : path52.join(projectDir, "node_modules", ".bin", "biome");
+  const eslintBin = isWindows ? path52.join(projectDir, "node_modules", ".bin", "eslint.cmd") : path52.join(projectDir, "node_modules", ".bin", "eslint");
   const localResult = await _detectAvailableLinter(projectDir, biomeBin, eslintBin);
   if (localResult)
     return localResult;
-  const biomeAncestor = findBinInAncestors(path51.dirname(projectDir), isWindows ? "biome.EXE" : "biome");
-  const eslintAncestor = findBinInAncestors(path51.dirname(projectDir), isWindows ? "eslint.cmd" : "eslint");
+  const biomeAncestor = findBinInAncestors(path52.dirname(projectDir), isWindows ? "biome.EXE" : "biome");
+  const eslintAncestor = findBinInAncestors(path52.dirname(projectDir), isWindows ? "eslint.cmd" : "eslint");
   if (biomeAncestor || eslintAncestor) {
     return _detectAvailableLinter(projectDir, biomeAncestor ?? biomeBin, eslintAncestor ?? eslintBin);
   }
@@ -26796,7 +26893,7 @@ var _internals40 = {
 
 // src/tools/secretscan.ts
 import * as fs21 from "fs";
-import * as path52 from "path";
+import * as path53 from "path";
 var MAX_FILE_PATH_LENGTH = 500;
 var MAX_FILE_SIZE_BYTES = 512 * 1024;
 var MAX_FILES_SCANNED = 1000;
@@ -27023,7 +27120,7 @@ function isGlobOrPathPattern(pattern) {
   return pattern.includes("/") || pattern.includes("\\") || /[*?[\]{}]/.test(pattern);
 }
 function loadSecretScanIgnore(scanDir) {
-  const ignorePath = path52.join(scanDir, ".secretscanignore");
+  const ignorePath = path53.join(scanDir, ".secretscanignore");
   try {
     if (!fs21.existsSync(ignorePath))
       return [];
@@ -27046,7 +27143,7 @@ function isExcluded(entry, relPath, exactNames, globPatterns) {
   if (exactNames.has(entry))
     return true;
   for (const pattern of globPatterns) {
-    if (path52.matchesGlob(relPath, pattern))
+    if (path53.matchesGlob(relPath, pattern))
       return true;
   }
   return false;
@@ -27067,7 +27164,7 @@ function validateDirectoryInput(dir) {
   return null;
 }
 function isBinaryFile(filePath, buffer) {
-  const ext = path52.extname(filePath).toLowerCase();
+  const ext = path53.extname(filePath).toLowerCase();
   if (DEFAULT_EXCLUDE_EXTENSIONS.has(ext)) {
     return true;
   }
@@ -27204,9 +27301,9 @@ function isSymlinkLoop(realPath, visited) {
   return false;
 }
 function isPathWithinScope(realPath, scanDir) {
-  const resolvedScanDir = path52.resolve(scanDir);
-  const resolvedRealPath = path52.resolve(realPath);
-  return resolvedRealPath === resolvedScanDir || resolvedRealPath.startsWith(resolvedScanDir + path52.sep) || resolvedRealPath.startsWith(`${resolvedScanDir}/`) || resolvedRealPath.startsWith(`${resolvedScanDir}\\`);
+  const resolvedScanDir = path53.resolve(scanDir);
+  const resolvedRealPath = path53.resolve(realPath);
+  return resolvedRealPath === resolvedScanDir || resolvedRealPath.startsWith(resolvedScanDir + path53.sep) || resolvedRealPath.startsWith(`${resolvedScanDir}/`) || resolvedRealPath.startsWith(`${resolvedScanDir}\\`);
 }
 function findScannableFiles(dir, excludeExact, excludeGlobs, scanDir, visited, stats = {
   skippedDirs: 0,
@@ -27232,8 +27329,8 @@ function findScannableFiles(dir, excludeExact, excludeGlobs, scanDir, visited, s
     return a.localeCompare(b);
   });
   for (const entry of entries) {
-    const fullPath = path52.join(dir, entry);
-    const relPath = path52.relative(scanDir, fullPath).replace(/\\/g, "/");
+    const fullPath = path53.join(dir, entry);
+    const relPath = path53.relative(scanDir, fullPath).replace(/\\/g, "/");
     if (isExcluded(entry, relPath, excludeExact, excludeGlobs)) {
       stats.skippedDirs++;
       continue;
@@ -27268,7 +27365,7 @@ function findScannableFiles(dir, excludeExact, excludeGlobs, scanDir, visited, s
       const subFiles = findScannableFiles(fullPath, excludeExact, excludeGlobs, scanDir, visited, stats);
       files.push(...subFiles);
     } else if (lstat2.isFile()) {
-      const ext = path52.extname(fullPath).toLowerCase();
+      const ext = path53.extname(fullPath).toLowerCase();
       if (!DEFAULT_EXCLUDE_EXTENSIONS.has(ext)) {
         files.push(fullPath);
       } else {
@@ -27334,7 +27431,7 @@ var secretscan = createSwarmTool({
       }
     }
     try {
-      const _scanDirRaw = path52.resolve(directory);
+      const _scanDirRaw = path53.resolve(directory);
       const scanDir = (() => {
         try {
           return fs21.realpathSync(_scanDirRaw);
@@ -27497,11 +27594,11 @@ var _internals41 = {
 
 // src/tools/test-runner.ts
 import * as fs25 from "fs";
-import * as path56 from "path";
+import * as path57 from "path";
 
 // src/test-impact/analyzer.ts
 import fs22 from "fs";
-import path53 from "path";
+import path54 from "path";
 var IMPORT_REGEX_ES = /import\s+[\s\S]*?\s+from\s+['"]([^'"]+)['"]/g;
 var IMPORT_REGEX_REQUIRE = /require\s*\(\s*['"]([^'"]+)['"]\s*\)/g;
 var IMPORT_REGEX_REEXPORT = /export\s+(?:\{[^}]*\}|\*)\s+from\s+['"]([^'"]+)['"]/g;
@@ -27542,8 +27639,8 @@ function resolveRelativeImport(fromDir, importPath) {
   if (!importPath.startsWith(".")) {
     return null;
   }
-  const resolved = path53.resolve(fromDir, importPath);
-  if (path53.extname(resolved)) {
+  const resolved = path54.resolve(fromDir, importPath);
+  if (path54.extname(resolved)) {
     if (fs22.existsSync(resolved) && fs22.statSync(resolved).isFile()) {
       return normalizePath2(resolved);
     }
@@ -27563,20 +27660,20 @@ function resolvePythonImport(fromDir, module) {
   const leadingDots = module.match(/^\.+/)?.[0].length ?? 0;
   let baseDir = fromDir;
   for (let i = 1;i < leadingDots; i++) {
-    baseDir = path53.dirname(baseDir);
+    baseDir = path54.dirname(baseDir);
   }
   const rest = module.slice(leadingDots);
   if (rest.length === 0) {
-    const initPath = path53.join(baseDir, "__init__.py");
+    const initPath = path54.join(baseDir, "__init__.py");
     if (fs22.existsSync(initPath) && fs22.statSync(initPath).isFile()) {
       return normalizePath2(initPath);
     }
     return null;
   }
-  const subpath = rest.replace(/\./g, path53.sep);
+  const subpath = rest.replace(/\./g, path54.sep);
   const candidates = [
-    `${path53.join(baseDir, subpath)}.py`,
-    path53.join(baseDir, subpath, "__init__.py")
+    `${path54.join(baseDir, subpath)}.py`,
+    path54.join(baseDir, subpath, "__init__.py")
   ];
   for (const c of candidates) {
     if (fs22.existsSync(c) && fs22.statSync(c).isFile())
@@ -27586,7 +27683,7 @@ function resolvePythonImport(fromDir, module) {
 }
 var goModuleCache = new Map;
 function findGoModule(fromDir) {
-  const resolved = path53.resolve(fromDir);
+  const resolved = path54.resolve(fromDir);
   let cur = resolved;
   const walked = [];
   for (let i = 0;i < 16; i++) {
@@ -27598,7 +27695,7 @@ function findGoModule(fromDir) {
     }
     walked.push(cur);
     try {
-      const goMod = path53.join(cur, "go.mod");
+      const goMod = path54.join(cur, "go.mod");
       const content = fs22.readFileSync(goMod, "utf-8");
       const moduleMatch = content.match(/^\s*module\s+"?([^"\s/]+(?:\/[^"\s]+)*)"?/m);
       if (moduleMatch) {
@@ -27609,10 +27706,10 @@ function findGoModule(fromDir) {
       }
     } catch {}
     try {
-      fs22.accessSync(path53.join(cur, ".git"));
+      fs22.accessSync(path54.join(cur, ".git"));
       break;
     } catch {}
-    const parent = path53.dirname(cur);
+    const parent = path54.dirname(cur);
     if (parent === cur)
       break;
     cur = parent;
@@ -27624,12 +27721,12 @@ function findGoModule(fromDir) {
 function resolveGoImport(fromDir, importPath) {
   let dir = null;
   if (importPath.startsWith(".")) {
-    dir = path53.resolve(fromDir, importPath);
+    dir = path54.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 = path53.join(mod.moduleRoot, subpath);
+      dir = path54.join(mod.moduleRoot, subpath);
     }
   }
   if (dir === null)
@@ -27637,7 +27734,7 @@ function resolveGoImport(fromDir, importPath) {
   if (!fs22.existsSync(dir) || !fs22.statSync(dir).isDirectory())
     return [];
   try {
-    return fs22.readdirSync(dir).filter((f) => f.endsWith(".go") && !f.endsWith("_test.go")).map((f) => normalizePath2(path53.join(dir, f)));
+    return fs22.readdirSync(dir).filter((f) => f.endsWith(".go") && !f.endsWith("_test.go")).map((f) => normalizePath2(path54.join(dir, f)));
   } catch {
     return [];
   }
@@ -27676,15 +27773,15 @@ function findTestFilesSync(cwd) {
     for (const entry of entries) {
       if (entry.isDirectory()) {
         if (!skipDirs.has(entry.name)) {
-          walk(path53.join(dir, entry.name), visitedInodes);
+          walk(path54.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(`${path53.sep}tests${path53.sep}`) && name.endsWith(".py");
+        const isPyTest = /^test_.+\.py$/.test(name) || /.+_test\.py$/.test(name) || dir.includes(`${path54.sep}tests${path54.sep}`) && name.endsWith(".py");
         const isGoTest = /.+_test\.go$/.test(name);
         if (isTsTest || isPyTest || isGoTest) {
-          testFiles.push(normalizePath2(path53.join(dir, entry.name)));
+          testFiles.push(normalizePath2(path54.join(dir, entry.name)));
         }
       }
     }
@@ -27709,8 +27806,8 @@ function extractImports(content) {
   ];
 }
 function addImpactEdgesForTestFile(testFile, content, impactMap) {
-  const ext = path53.extname(testFile).toLowerCase();
-  const testDir = path53.dirname(testFile);
+  const ext = path54.extname(testFile).toLowerCase();
+  const testDir = path54.dirname(testFile);
   function addEdge(source) {
     if (!impactMap[source])
       impactMap[source] = [];
@@ -27783,7 +27880,7 @@ async function buildImpactMap(cwd) {
   return impactMap;
 }
 async function loadImpactMap(cwd, options) {
-  const cachePath = path53.join(cwd, ".swarm", "cache", "impact-map.json");
+  const cachePath = path54.join(cwd, ".swarm", "cache", "impact-map.json");
   if (fs22.existsSync(cachePath)) {
     try {
       const content = fs22.readFileSync(cachePath, "utf-8");
@@ -27816,12 +27913,12 @@ async function loadImpactMap(cwd, options) {
   return _internals42.buildImpactMap(cwd);
 }
 async function saveImpactMap(cwd, impactMap) {
-  if (!path53.isAbsolute(cwd)) {
+  if (!path54.isAbsolute(cwd)) {
     throw new Error(`saveImpactMap requires an absolute project root path, got: "${cwd}"`);
   }
   _internals42.validateProjectRoot(cwd);
-  const cacheDir2 = path53.join(cwd, ".swarm", "cache");
-  const cachePath = path53.join(cacheDir2, "impact-map.json");
+  const cacheDir2 = path54.join(cwd, ".swarm", "cache");
+  const cachePath = path54.join(cacheDir2, "impact-map.json");
   if (!fs22.existsSync(cacheDir2)) {
     fs22.mkdirSync(cacheDir2, { recursive: true });
   }
@@ -27853,7 +27950,7 @@ async function analyzeImpact(changedFiles, cwd, budget) {
       budgetExceeded = true;
       break;
     }
-    const normalizedChanged = normalizePath2(path53.resolve(changedFile));
+    const normalizedChanged = normalizePath2(path54.resolve(changedFile));
     const tests = impactMap[normalizedChanged];
     if (tests && tests.length > 0) {
       for (const test of tests) {
@@ -27867,13 +27964,13 @@ async function analyzeImpact(changedFiles, cwd, budget) {
       if (budgetExceeded)
         break;
     } else {
-      const changedDir = normalizePath2(path53.dirname(normalizedChanged));
-      const changedInputDir = normalizePath2(path53.dirname(changedFile));
+      const changedDir = normalizePath2(path54.dirname(normalizedChanged));
+      const changedInputDir = normalizePath2(path54.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 = normalizePath2(path53.dirname(sourceA));
-        const sourceDirB = normalizePath2(path53.dirname(sourceB));
+        const sourceDirA = normalizePath2(path54.dirname(sourceA));
+        const sourceDirB = normalizePath2(path54.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)
@@ -28200,7 +28297,7 @@ function detectFlakyTests(allHistory) {
 
 // src/test-impact/history-store.ts
 import fs23 from "fs";
-import path54 from "path";
+import path55 from "path";
 var MAX_HISTORY_PER_TEST = 20;
 var MAX_ERROR_LENGTH = 500;
 var MAX_STACK_LENGTH = 200;
@@ -28212,10 +28309,10 @@ function getHistoryPath(workingDir) {
   if (!workingDir) {
     throw new Error("getHistoryPath requires a working directory \u2014 project root must be provided by the caller");
   }
-  if (!path54.isAbsolute(workingDir)) {
+  if (!path55.isAbsolute(workingDir)) {
     throw new Error(`getHistoryPath requires an absolute project root path, got: "${workingDir}"`);
   }
-  return path54.join(workingDir, ".swarm", "cache", "test-history.jsonl");
+  return path55.join(workingDir, ".swarm", "cache", "test-history.jsonl");
 }
 function sanitizeErrorMessage(errorMessage) {
   if (errorMessage === undefined) {
@@ -28307,7 +28404,7 @@ function batchAppendTestRuns(records, workingDir) {
     }
   }
   const historyPath = getHistoryPath(workingDir);
-  const historyDir = path54.dirname(historyPath);
+  const historyDir = path55.dirname(historyPath);
   _internals43.validateProjectRoot(workingDir);
   if (!fs23.existsSync(historyDir)) {
     fs23.mkdirSync(historyDir, { recursive: true });
@@ -28437,7 +28534,7 @@ var _internals43 = {
 
 // src/tools/resolve-working-directory.ts
 import * as fs24 from "fs";
-import * as path55 from "path";
+import * as path56 from "path";
 function resolveWorkingDirectory(workingDirectory, fallbackDirectory) {
   if (workingDirectory == null || workingDirectory === "") {
     if (typeof fallbackDirectory !== "string" || fallbackDirectory === "") {
@@ -28476,8 +28573,8 @@ function resolveWorkingDirectory(workingDirectory, fallbackDirectory) {
       message: "Invalid working_directory: path traversal sequences (..) are not allowed"
     };
   }
-  const normalizedDir = path55.normalize(workingDirectory);
-  const resolvedDir = path55.resolve(normalizedDir);
+  const normalizedDir = path56.normalize(workingDirectory);
+  const resolvedDir = path56.resolve(normalizedDir);
   let statResult;
   try {
     statResult = fs24.statSync(resolvedDir);
@@ -28496,7 +28593,7 @@ function resolveWorkingDirectory(workingDirectory, fallbackDirectory) {
   if (typeof fallbackDirectory !== "string" || fallbackDirectory === "") {
     return { success: true, directory: resolvedDir };
   }
-  const resolvedFallback = path55.resolve(fallbackDirectory);
+  const resolvedFallback = path56.resolve(fallbackDirectory);
   let fallbackExists = false;
   try {
     fs24.statSync(resolvedFallback);
@@ -28505,7 +28602,7 @@ function resolveWorkingDirectory(workingDirectory, fallbackDirectory) {
     fallbackExists = false;
   }
   if (fallbackExists) {
-    const isSubdirectory = resolvedDir.startsWith(resolvedFallback + path55.sep);
+    const isSubdirectory = resolvedDir.startsWith(resolvedFallback + path56.sep);
     if (isSubdirectory) {
       return {
         success: false,
@@ -28528,7 +28625,7 @@ async function estimateFanOut(sourceFiles, cwd) {
     const impactMap = await loadImpactMap(cwd, { skipRebuild: true });
     const uniqueTestFiles = new Set;
     for (const sourceFile of sourceFiles) {
-      const resolvedPath = path56.resolve(cwd, sourceFile);
+      const resolvedPath = path57.resolve(cwd, sourceFile);
       const normalizedPath = resolvedPath.replace(/\\/g, "/");
       const testFiles = impactMap[normalizedPath];
       if (testFiles) {
@@ -28613,14 +28710,14 @@ function hasDevDependency(devDeps, ...patterns) {
   return hasPackageJsonDependency(devDeps, ...patterns);
 }
 function detectGoTest(cwd) {
-  return fs25.existsSync(path56.join(cwd, "go.mod")) && isCommandAvailable("go");
+  return fs25.existsSync(path57.join(cwd, "go.mod")) && isCommandAvailable("go");
 }
 function detectJavaMaven(cwd) {
-  return fs25.existsSync(path56.join(cwd, "pom.xml")) && isCommandAvailable("mvn");
+  return fs25.existsSync(path57.join(cwd, "pom.xml")) && isCommandAvailable("mvn");
 }
 function detectGradle(cwd) {
-  const hasBuildFile = fs25.existsSync(path56.join(cwd, "build.gradle")) || fs25.existsSync(path56.join(cwd, "build.gradle.kts"));
-  const hasGradlew = fs25.existsSync(path56.join(cwd, "gradlew")) || fs25.existsSync(path56.join(cwd, "gradlew.bat"));
+  const hasBuildFile = fs25.existsSync(path57.join(cwd, "build.gradle")) || fs25.existsSync(path57.join(cwd, "build.gradle.kts"));
+  const hasGradlew = fs25.existsSync(path57.join(cwd, "gradlew")) || fs25.existsSync(path57.join(cwd, "gradlew.bat"));
   return hasBuildFile && (hasGradlew || isCommandAvailable("gradle"));
 }
 function detectDotnetTest(cwd) {
@@ -28633,25 +28730,25 @@ function detectDotnetTest(cwd) {
   }
 }
 function detectCTest(cwd) {
-  const hasSource = fs25.existsSync(path56.join(cwd, "CMakeLists.txt"));
-  const hasBuildCache = fs25.existsSync(path56.join(cwd, "CMakeCache.txt")) || fs25.existsSync(path56.join(cwd, "build", "CMakeCache.txt"));
+  const hasSource = fs25.existsSync(path57.join(cwd, "CMakeLists.txt"));
+  const hasBuildCache = fs25.existsSync(path57.join(cwd, "CMakeCache.txt")) || fs25.existsSync(path57.join(cwd, "build", "CMakeCache.txt"));
   return (hasSource || hasBuildCache) && isCommandAvailable("ctest");
 }
 function detectSwiftTest(cwd) {
-  return fs25.existsSync(path56.join(cwd, "Package.swift")) && isCommandAvailable("swift");
+  return fs25.existsSync(path57.join(cwd, "Package.swift")) && isCommandAvailable("swift");
 }
 function detectDartTest(cwd) {
-  return fs25.existsSync(path56.join(cwd, "pubspec.yaml")) && (isCommandAvailable("dart") || isCommandAvailable("flutter"));
+  return fs25.existsSync(path57.join(cwd, "pubspec.yaml")) && (isCommandAvailable("dart") || isCommandAvailable("flutter"));
 }
 function detectRSpec(cwd) {
-  const hasRSpecFile = fs25.existsSync(path56.join(cwd, ".rspec"));
-  const hasGemfile = fs25.existsSync(path56.join(cwd, "Gemfile"));
-  const hasSpecDir = fs25.existsSync(path56.join(cwd, "spec"));
+  const hasRSpecFile = fs25.existsSync(path57.join(cwd, ".rspec"));
+  const hasGemfile = fs25.existsSync(path57.join(cwd, "Gemfile"));
+  const hasSpecDir = fs25.existsSync(path57.join(cwd, "spec"));
   const hasRSpec = hasRSpecFile || hasGemfile && hasSpecDir;
   return hasRSpec && (isCommandAvailable("bundle") || isCommandAvailable("rspec"));
 }
 function detectMinitest(cwd) {
-  return fs25.existsSync(path56.join(cwd, "test")) && (fs25.existsSync(path56.join(cwd, "Gemfile")) || fs25.existsSync(path56.join(cwd, "Rakefile"))) && isCommandAvailable("ruby");
+  return fs25.existsSync(path57.join(cwd, "test")) && (fs25.existsSync(path57.join(cwd, "Gemfile")) || fs25.existsSync(path57.join(cwd, "Rakefile"))) && isCommandAvailable("ruby");
 }
 var DISPATCH_FRAMEWORK_MAP = {
   bun: "bun",
@@ -28736,7 +28833,7 @@ async function parseTestOutputViaDispatch(framework, output, baseDir) {
 async function detectTestFramework(cwd) {
   const baseDir = cwd;
   try {
-    const packageJsonPath = path56.join(baseDir, "package.json");
+    const packageJsonPath = path57.join(baseDir, "package.json");
     if (fs25.existsSync(packageJsonPath)) {
       const content = fs25.readFileSync(packageJsonPath, "utf-8");
       const pkg = JSON.parse(content);
@@ -28757,16 +28854,16 @@ async function detectTestFramework(cwd) {
         return "jest";
       if (hasDevDependency(devDeps, "mocha", "@types/mocha"))
         return "mocha";
-      if (fs25.existsSync(path56.join(baseDir, "bun.lockb")) || fs25.existsSync(path56.join(baseDir, "bun.lock"))) {
+      if (fs25.existsSync(path57.join(baseDir, "bun.lockb")) || fs25.existsSync(path57.join(baseDir, "bun.lock"))) {
         if (scripts.test?.includes("bun"))
           return "bun";
       }
     }
   } catch {}
   try {
-    const pyprojectTomlPath = path56.join(baseDir, "pyproject.toml");
-    const setupCfgPath = path56.join(baseDir, "setup.cfg");
-    const requirementsTxtPath = path56.join(baseDir, "requirements.txt");
+    const pyprojectTomlPath = path57.join(baseDir, "pyproject.toml");
+    const setupCfgPath = path57.join(baseDir, "setup.cfg");
+    const requirementsTxtPath = path57.join(baseDir, "requirements.txt");
     if (fs25.existsSync(pyprojectTomlPath)) {
       const content = fs25.readFileSync(pyprojectTomlPath, "utf-8");
       if (content.includes("[tool.pytest"))
@@ -28786,7 +28883,7 @@ async function detectTestFramework(cwd) {
     }
   } catch {}
   try {
-    const cargoTomlPath = path56.join(baseDir, "Cargo.toml");
+    const cargoTomlPath = path57.join(baseDir, "Cargo.toml");
     if (fs25.existsSync(cargoTomlPath)) {
       const content = fs25.readFileSync(cargoTomlPath, "utf-8");
       if (content.includes("[dev-dependencies]")) {
@@ -28797,9 +28894,9 @@ async function detectTestFramework(cwd) {
     }
   } catch {}
   try {
-    const pesterConfigPath = path56.join(baseDir, "pester.config.ps1");
-    const pesterConfigJsonPath = path56.join(baseDir, "pester.config.ps1.json");
-    const pesterPs1Path = path56.join(baseDir, "tests.ps1");
+    const pesterConfigPath = path57.join(baseDir, "pester.config.ps1");
+    const pesterConfigJsonPath = path57.join(baseDir, "pester.config.ps1.json");
+    const pesterPs1Path = path57.join(baseDir, "tests.ps1");
     if (fs25.existsSync(pesterConfigPath) || fs25.existsSync(pesterConfigJsonPath) || fs25.existsSync(pesterPs1Path)) {
       return "pester";
     }
@@ -28842,12 +28939,12 @@ function isTestDirectoryPath(normalizedPath) {
   return normalizedPath.split("/").some((segment) => TEST_DIRECTORY_NAMES.includes(segment));
 }
 function resolveWorkspacePath(file, workingDir) {
-  return path56.isAbsolute(file) ? path56.resolve(file) : path56.resolve(workingDir, file);
+  return path57.isAbsolute(file) ? path57.resolve(file) : path57.resolve(workingDir, file);
 }
 function toWorkspaceOutputPath(absolutePath, workingDir, preferRelative) {
   if (!preferRelative)
     return absolutePath;
-  return path56.relative(workingDir, absolutePath);
+  return path57.relative(workingDir, absolutePath);
 }
 function dedupePush(target, value) {
   if (!target.includes(value)) {
@@ -28884,18 +28981,18 @@ function buildLanguageSpecificTestNames(nameWithoutExt, ext) {
   }
 }
 function getRepoLevelCandidateDirectories(workingDir, relativePath, ext) {
-  const relativeDir = path56.dirname(relativePath);
+  const relativeDir = path57.dirname(relativePath);
   const nestedRelativeDir = relativeDir === "." ? "" : relativeDir;
   const directories = TEST_DIRECTORY_NAMES.flatMap((dirName) => {
-    const rootDir = path56.join(workingDir, dirName);
-    return nestedRelativeDir ? [rootDir, path56.join(rootDir, nestedRelativeDir)] : [rootDir];
+    const rootDir = path57.join(workingDir, dirName);
+    return nestedRelativeDir ? [rootDir, path57.join(rootDir, nestedRelativeDir)] : [rootDir];
   });
   const normalizedRelativePath = relativePath.replace(/\\/g, "/");
   if (ext === ".java" && normalizedRelativePath.startsWith("src/main/java/")) {
-    directories.push(path56.join(workingDir, "src/test/java", path56.dirname(normalizedRelativePath.slice("src/main/java/".length))));
+    directories.push(path57.join(workingDir, "src/test/java", path57.dirname(normalizedRelativePath.slice("src/main/java/".length))));
   }
   if ((ext === ".kt" || ext === ".java") && normalizedRelativePath.startsWith("src/main/kotlin/")) {
-    directories.push(path56.join(workingDir, "src/test/kotlin", path56.dirname(normalizedRelativePath.slice("src/main/kotlin/".length))));
+    directories.push(path57.join(workingDir, "src/test/kotlin", path57.dirname(normalizedRelativePath.slice("src/main/kotlin/".length))));
   }
   return [...new Set(directories)];
 }
@@ -28923,23 +29020,23 @@ function isLanguageSpecificTestFile(basename10) {
 }
 function isConventionTestFilePath(filePath) {
   const normalizedPath = filePath.replace(/\\/g, "/");
-  const basename10 = path56.basename(filePath);
+  const basename10 = path57.basename(filePath);
   return hasCompoundTestExtension(basename10) || basename10.includes(".spec.") || basename10.includes(".test.") || isLanguageSpecificTestFile(basename10) || isTestDirectoryPath(normalizedPath);
 }
 function getTestFilesFromConvention(sourceFiles, workingDir = process.cwd()) {
   const testFiles = [];
   for (const file of sourceFiles) {
     const absoluteFile = resolveWorkspacePath(file, workingDir);
-    const relativeFile = path56.relative(workingDir, absoluteFile);
-    const basename10 = path56.basename(absoluteFile);
-    const dirname25 = path56.dirname(absoluteFile);
-    const preferRelativeOutput = !path56.isAbsolute(file);
+    const relativeFile = path57.relative(workingDir, absoluteFile);
+    const basename10 = path57.basename(absoluteFile);
+    const dirname25 = path57.dirname(absoluteFile);
+    const preferRelativeOutput = !path57.isAbsolute(file);
     if (isConventionTestFilePath(relativeFile) || isConventionTestFilePath(file)) {
       dedupePush(testFiles, toWorkspaceOutputPath(absoluteFile, workingDir, preferRelativeOutput));
       continue;
     }
     const nameWithoutExt = basename10.replace(/\.[^.]+$/, "");
-    const ext = path56.extname(basename10);
+    const ext = path57.extname(basename10);
     const genericTestNames = [
       `${nameWithoutExt}.spec${ext}`,
       `${nameWithoutExt}.test${ext}`
@@ -28948,7 +29045,7 @@ function getTestFilesFromConvention(sourceFiles, workingDir = process.cwd()) {
     const colocatedCandidates = [
       ...genericTestNames,
       ...languageSpecificTestNames
-    ].map((candidateName) => path56.join(dirname25, candidateName));
+    ].map((candidateName) => path57.join(dirname25, candidateName));
     const testDirectoryNames = [
       basename10,
       ...genericTestNames,
@@ -28957,8 +29054,8 @@ function getTestFilesFromConvention(sourceFiles, workingDir = process.cwd()) {
     const repoLevelDirectories = getRepoLevelCandidateDirectories(workingDir, relativeFile, ext);
     const possibleTestFiles = [
       ...colocatedCandidates,
-      ...TEST_DIRECTORY_NAMES.flatMap((dirName) => testDirectoryNames.map((candidateName) => path56.join(dirname25, dirName, candidateName))),
-      ...repoLevelDirectories.flatMap((candidateDir) => testDirectoryNames.map((candidateName) => path56.join(candidateDir, candidateName)))
+      ...TEST_DIRECTORY_NAMES.flatMap((dirName) => testDirectoryNames.map((candidateName) => path57.join(dirname25, dirName, candidateName))),
+      ...repoLevelDirectories.flatMap((candidateDir) => testDirectoryNames.map((candidateName) => path57.join(candidateDir, candidateName)))
     ];
     for (const testFile of possibleTestFiles) {
       if (fs25.existsSync(testFile)) {
@@ -28979,7 +29076,7 @@ async function getTestFilesFromGraph(sourceFiles, workingDir) {
     try {
       const absoluteTestFile = resolveWorkspacePath(testFile, workingDir);
       const content = fs25.readFileSync(absoluteTestFile, "utf-8");
-      const testDir = path56.dirname(absoluteTestFile);
+      const testDir = path57.dirname(absoluteTestFile);
       const importRegex = /import\s+.*?\s+from\s+['"]([^'"]+)['"]/g;
       let match;
       match = importRegex.exec(content);
@@ -28987,8 +29084,8 @@ async function getTestFilesFromGraph(sourceFiles, workingDir) {
         const importPath = match[1];
         let resolvedImport;
         if (importPath.startsWith(".")) {
-          resolvedImport = path56.resolve(testDir, importPath);
-          const existingExt = path56.extname(resolvedImport);
+          resolvedImport = path57.resolve(testDir, importPath);
+          const existingExt = path57.extname(resolvedImport);
           if (!existingExt) {
             for (const extToTry of [
               ".ts",
@@ -29008,12 +29105,12 @@ async function getTestFilesFromGraph(sourceFiles, workingDir) {
         } else {
           continue;
         }
-        const importBasename = path56.basename(resolvedImport, path56.extname(resolvedImport));
-        const importDir = path56.dirname(resolvedImport);
+        const importBasename = path57.basename(resolvedImport, path57.extname(resolvedImport));
+        const importDir = path57.dirname(resolvedImport);
         for (const sourceFile of absoluteSourceFiles) {
-          const sourceDir = path56.dirname(sourceFile);
-          const sourceBasename = path56.basename(sourceFile, path56.extname(sourceFile));
-          const isRelatedDir = importDir === sourceDir || importDir === path56.join(sourceDir, "__tests__") || importDir === path56.join(sourceDir, "tests") || importDir === path56.join(sourceDir, "test") || importDir === path56.join(sourceDir, "spec");
+          const sourceDir = path57.dirname(sourceFile);
+          const sourceBasename = path57.basename(sourceFile, path57.extname(sourceFile));
+          const isRelatedDir = importDir === sourceDir || importDir === path57.join(sourceDir, "__tests__") || importDir === path57.join(sourceDir, "tests") || importDir === path57.join(sourceDir, "test") || importDir === path57.join(sourceDir, "spec");
           if (resolvedImport === sourceFile || importBasename === sourceBasename && isRelatedDir) {
             dedupePush(testFiles, testFile);
             break;
@@ -29026,8 +29123,8 @@ async function getTestFilesFromGraph(sourceFiles, workingDir) {
       while (match !== null) {
         const importPath = match[1];
         if (importPath.startsWith(".")) {
-          let resolvedImport = path56.resolve(testDir, importPath);
-          const existingExt = path56.extname(resolvedImport);
+          let resolvedImport = path57.resolve(testDir, importPath);
+          const existingExt = path57.extname(resolvedImport);
           if (!existingExt) {
             for (const extToTry of [
               ".ts",
@@ -29044,12 +29141,12 @@ async function getTestFilesFromGraph(sourceFiles, workingDir) {
               }
             }
           }
-          const importDir = path56.dirname(resolvedImport);
-          const importBasename = path56.basename(resolvedImport, path56.extname(resolvedImport));
+          const importDir = path57.dirname(resolvedImport);
+          const importBasename = path57.basename(resolvedImport, path57.extname(resolvedImport));
           for (const sourceFile of absoluteSourceFiles) {
-            const sourceDir = path56.dirname(sourceFile);
-            const sourceBasename = path56.basename(sourceFile, path56.extname(sourceFile));
-            const isRelatedDir = importDir === sourceDir || importDir === path56.join(sourceDir, "__tests__") || importDir === path56.join(sourceDir, "tests") || importDir === path56.join(sourceDir, "test") || importDir === path56.join(sourceDir, "spec");
+            const sourceDir = path57.dirname(sourceFile);
+            const sourceBasename = path57.basename(sourceFile, path57.extname(sourceFile));
+            const isRelatedDir = importDir === sourceDir || importDir === path57.join(sourceDir, "__tests__") || importDir === path57.join(sourceDir, "tests") || importDir === path57.join(sourceDir, "test") || importDir === path57.join(sourceDir, "spec");
             if (resolvedImport === sourceFile || importBasename === sourceBasename && isRelatedDir) {
               dedupePush(testFiles, testFile);
               break;
@@ -29169,8 +29266,8 @@ function buildTestCommand(framework, scope, files, coverage, baseDir, bail) {
       return ["mvn", "test"];
     case "gradle": {
       const isWindows = process.platform === "win32";
-      const hasGradlewBat = fs25.existsSync(path56.join(baseDir, "gradlew.bat"));
-      const hasGradlew = fs25.existsSync(path56.join(baseDir, "gradlew"));
+      const hasGradlewBat = fs25.existsSync(path57.join(baseDir, "gradlew.bat"));
+      const hasGradlew = fs25.existsSync(path57.join(baseDir, "gradlew"));
       if (hasGradlewBat && isWindows)
         return ["gradlew.bat", "test"];
       if (hasGradlew)
@@ -29187,7 +29284,7 @@ function buildTestCommand(framework, scope, files, coverage, baseDir, bail) {
         "cmake-build-release",
         "out"
       ];
-      const actualBuildDir = buildDirCandidates.find((d) => fs25.existsSync(path56.join(baseDir, d, "CMakeCache.txt"))) ?? "build";
+      const actualBuildDir = buildDirCandidates.find((d) => fs25.existsSync(path57.join(baseDir, d, "CMakeCache.txt"))) ?? "build";
       return ["ctest", "--test-dir", actualBuildDir];
     }
     case "swift-test":
@@ -29621,11 +29718,11 @@ async function runTests(framework, scope, files, coverage, timeout_ms, cwd, bail
     };
   }
   const startTime = Date.now();
-  const vitestJsonOutputPath = framework === "vitest" ? path56.join(cwd, ".swarm", "cache", "test-runner-vitest.json") : undefined;
+  const vitestJsonOutputPath = framework === "vitest" ? path57.join(cwd, ".swarm", "cache", "test-runner-vitest.json") : undefined;
   try {
     if (vitestJsonOutputPath) {
       try {
-        fs25.mkdirSync(path56.dirname(vitestJsonOutputPath), { recursive: true });
+        fs25.mkdirSync(path57.dirname(vitestJsonOutputPath), { recursive: true });
         if (fs25.existsSync(vitestJsonOutputPath)) {
           fs25.unlinkSync(vitestJsonOutputPath);
         }
@@ -29793,10 +29890,10 @@ var SKIP_DIRECTORIES = new Set([
 ]);
 function normalizeHistoryTestFile(testFile, workingDir) {
   const normalized = testFile.replace(/\\/g, "/");
-  if (!path56.isAbsolute(testFile))
+  if (!path57.isAbsolute(testFile))
     return normalized;
-  const relative8 = path56.relative(workingDir, testFile);
-  if (relative8.startsWith("..") || path56.isAbsolute(relative8)) {
+  const relative8 = path57.relative(workingDir, testFile);
+  if (relative8.startsWith("..") || path57.isAbsolute(relative8)) {
     return normalized;
   }
   return relative8.replace(/\\/g, "/");
@@ -30035,7 +30132,7 @@ var test_runner = createSwarmTool({
       const sourceFiles = args.files.filter((file) => {
         if (directTestFiles.includes(file))
           return false;
-        const ext = path56.extname(file).toLowerCase();
+        const ext = path57.extname(file).toLowerCase();
         return SOURCE_EXTENSIONS.has(ext);
       });
       const invalidFiles = args.files.filter((file) => !directTestFiles.includes(file) && !sourceFiles.includes(file));
@@ -30081,7 +30178,7 @@ var test_runner = createSwarmTool({
         if (isConventionTestFilePath(f)) {
           return false;
         }
-        const ext = path56.extname(f).toLowerCase();
+        const ext = path57.extname(f).toLowerCase();
         return SOURCE_EXTENSIONS.has(ext);
       });
       if (sourceFiles.length === 0) {
@@ -30131,7 +30228,7 @@ var test_runner = createSwarmTool({
         if (isConventionTestFilePath(f)) {
           return false;
         }
-        const ext = path56.extname(f).toLowerCase();
+        const ext = path57.extname(f).toLowerCase();
         return SOURCE_EXTENSIONS.has(ext);
       });
       if (sourceFiles.length === 0) {
@@ -30183,8 +30280,8 @@ var test_runner = createSwarmTool({
         }
         if (impactResult.impactedTests.length > 0) {
           testFiles = impactResult.impactedTests.map((absPath) => {
-            const relativePath = path56.relative(workingDir, absPath);
-            return path56.isAbsolute(relativePath) ? absPath : relativePath;
+            const relativePath = path57.relative(workingDir, absPath);
+            return path57.isAbsolute(relativePath) ? absPath : relativePath;
           });
         } else {
           graphFallbackReason = "no impacted tests found via impact analysis, falling back to graph";
@@ -30279,8 +30376,8 @@ function validateDirectoryPath(dir) {
   if (dir.includes("..")) {
     throw new Error("Directory path must not contain path traversal sequences");
   }
-  const normalized = path57.normalize(dir);
-  const absolutePath = path57.isAbsolute(normalized) ? normalized : path57.resolve(normalized);
+  const normalized = path58.normalize(dir);
+  const absolutePath = path58.isAbsolute(normalized) ? normalized : path58.resolve(normalized);
   return absolutePath;
 }
 function validateTimeout(timeoutMs, defaultValue) {
@@ -30303,7 +30400,7 @@ function validateTimeout(timeoutMs, defaultValue) {
 }
 function getPackageVersion(dir) {
   try {
-    const packagePath = path57.join(dir, "package.json");
+    const packagePath = path58.join(dir, "package.json");
     if (fs26.existsSync(packagePath)) {
       const content = fs26.readFileSync(packagePath, "utf-8");
       const pkg = JSON.parse(content);
@@ -30314,7 +30411,7 @@ function getPackageVersion(dir) {
 }
 function getChangelogVersion(dir) {
   try {
-    const changelogPath = path57.join(dir, "CHANGELOG.md");
+    const changelogPath = path58.join(dir, "CHANGELOG.md");
     if (fs26.existsSync(changelogPath)) {
       const content = fs26.readFileSync(changelogPath, "utf-8");
       const match = content.match(/^##\s*\[?(\d+\.\d+\.\d+)\]?/m);
@@ -30328,7 +30425,7 @@ function getChangelogVersion(dir) {
 function getVersionFileVersion(dir) {
   const possibleFiles = ["VERSION.txt", "version.txt", "VERSION", "version"];
   for (const file of possibleFiles) {
-    const filePath = path57.join(dir, file);
+    const filePath = path58.join(dir, file);
     if (fs26.existsSync(filePath)) {
       try {
         const content = fs26.readFileSync(filePath, "utf-8").trim();
@@ -31066,7 +31163,7 @@ async function handleQaGatesCommand(directory, args, sessionID) {
 
 // src/commands/reset.ts
 import * as fs27 from "fs";
-import * as path58 from "path";
+import * as path59 from "path";
 
 // src/background/circuit-breaker.ts
 class CircuitBreaker {
@@ -31785,7 +31882,7 @@ async function handleResetCommand(directory, args) {
   }
   for (const filename of ["SWARM_PLAN.md", "SWARM_PLAN.json"]) {
     try {
-      const rootPath = path58.join(directory, filename);
+      const rootPath = path59.join(directory, filename);
       if (fs27.existsSync(rootPath)) {
         fs27.unlinkSync(rootPath);
         results.push(`- \u2705 Deleted ${filename} (root)`);
@@ -31823,7 +31920,7 @@ async function handleResetCommand(directory, args) {
 
 // src/commands/reset-session.ts
 import * as fs29 from "fs";
-import * as path60 from "path";
+import * as path61 from "path";
 
 // src/hooks/trajectory-logger.ts
 var callStartTimes = new Map;
@@ -32230,16 +32327,16 @@ function detectPatterns(trajectory, config, lastProcessedStep = 0) {
 }
 // src/prm/replay.ts
 import { promises as fs28 } from "fs";
-import path59 from "path";
+import path60 from "path";
 function isPathSafe(targetPath, basePath) {
-  const resolvedTarget = path59.resolve(targetPath);
-  const resolvedBase = path59.resolve(basePath);
-  const rel = path59.relative(resolvedBase, resolvedTarget);
-  return !rel.startsWith("..") && !path59.isAbsolute(rel);
+  const resolvedTarget = path60.resolve(targetPath);
+  const resolvedBase = path60.resolve(basePath);
+  const rel = path60.relative(resolvedBase, resolvedTarget);
+  return !rel.startsWith("..") && !path60.isAbsolute(rel);
 }
 function isWithinReplaysDir(targetPath) {
-  const resolved = path59.resolve(targetPath);
-  const parts = resolved.split(path59.sep);
+  const resolved = path60.resolve(targetPath);
+  const parts = resolved.split(path60.sep);
   for (let i = 0;i < parts.length - 1; i++) {
     if (parts[i] === ".swarm" && parts[i + 1] === "replays") {
       return true;
@@ -32252,10 +32349,10 @@ function sanitizeFilename(input) {
 }
 async function startReplayRecording(sessionID, directory) {
   try {
-    const replayDir = path59.join(directory, ".swarm", "replays");
+    const replayDir = path60.join(directory, ".swarm", "replays");
     const safeSessionID = sanitizeFilename(sessionID);
     const filename = `${safeSessionID}-${Date.now()}.jsonl`;
-    const filepath = path59.join(replayDir, filename);
+    const filepath = path60.join(replayDir, filename);
     if (!isPathSafe(filepath, replayDir)) {
       console.warn(`[replay] Invalid path detected - path traversal attempt blocked for session ${sessionID}`);
       return null;
@@ -32315,6 +32412,9 @@ function resetPrmSessionState(session, sessionId) {
 }
 
 // src/commands/reset-session.ts
+var _internals46 = {
+  cleanupOrphanedBranches
+};
 function errorMessage(err) {
   if (err instanceof Error)
     return err.message;
@@ -32333,7 +32433,7 @@ async function handleResetSessionCommand(directory, _args) {
   } catch {
     results.push("\u274C Failed to delete state.json");
   }
-  const sessionDir = path60.dirname(validateSwarmPath(directory, "session/state.json"));
+  const sessionDir = path61.dirname(validateSwarmPath(directory, "session/state.json"));
   let sessionFiles = [];
   if (fs29.existsSync(sessionDir)) {
     try {
@@ -32345,7 +32445,7 @@ async function handleResetSessionCommand(directory, _args) {
   for (const file of sessionFiles) {
     if (file === "state.json")
       continue;
-    const filePath = path60.join(sessionDir, file);
+    const filePath = path61.join(sessionDir, file);
     try {
       if (!fs29.existsSync(filePath))
         continue;
@@ -32367,6 +32467,26 @@ async function handleResetSessionCommand(directory, _args) {
   const chainCount = swarmState.delegationChains.size;
   swarmState.delegationChains.clear();
   results.push(`\u2705 Cleared ${chainCount} delegation chain(s)`);
+  const worktreesDir = path61.resolve(path61.dirname(directory), ".swarm-worktrees");
+  try {
+    if (fs29.existsSync(worktreesDir)) {
+      fs29.rmSync(worktreesDir, { recursive: true, force: true });
+      results.push("\u2705 Removed .swarm-worktrees/ directory");
+    }
+  } catch (err) {
+    results.push(`\u26A0\uFE0F Failed to remove .swarm-worktrees/: ${errorMessage(err)}`);
+  }
+  try {
+    const branchResult = await _internals46.cleanupOrphanedBranches(directory, []);
+    if (branchResult.removed.length > 0) {
+      results.push(`\u2705 Removed ${branchResult.removed.length} orphan swarm-lane branch(es)`);
+    }
+    if (branchResult.errors.length > 0) {
+      results.push(`\u26A0\uFE0F Failed to remove ${branchResult.errors.length} branch(es): ${branchResult.errors.map((e) => e.error).join("; ")}`);
+    }
+  } catch (err) {
+    results.push(`\u26A0\uFE0F Failed to cleanup orphan branches: ${errorMessage(err)}`);
+  }
   return [
     "## Session State Reset",
     "",
@@ -32380,7 +32500,7 @@ async function handleResetSessionCommand(directory, _args) {
 }
 
 // src/summaries/manager.ts
-import * as path61 from "path";
+import * as path62 from "path";
 var SUMMARY_ID_REGEX = /^S\d+$/;
 function sanitizeSummaryId(id) {
   if (!id || id.length === 0) {
@@ -32404,7 +32524,7 @@ function sanitizeSummaryId(id) {
 }
 async function loadFullOutput(directory, id) {
   const sanitizedId = sanitizeSummaryId(id);
-  const relativePath = path61.join("summaries", `${sanitizedId}.json`);
+  const relativePath = path62.join("summaries", `${sanitizedId}.json`);
   validateSwarmPath(directory, relativePath);
   const content = await readSwarmFileAsync(directory, relativePath);
   if (content === null) {
@@ -32457,7 +32577,7 @@ ${error2 instanceof Error ? error2.message : String(error2)}`;
 
 // src/commands/rollback.ts
 import * as fs30 from "fs";
-import * as path62 from "path";
+import * as path63 from "path";
 async function handleRollbackCommand(directory, args) {
   const phaseArg = args[0];
   if (!phaseArg) {
@@ -32523,8 +32643,8 @@ async function handleRollbackCommand(directory, args) {
     if (EXCLUDE_FILES.has(file) || file.startsWith("plan-ledger.archived-")) {
       continue;
     }
-    const src = path62.join(checkpointDir, file);
-    const dest = path62.join(swarmDir, file);
+    const src = path63.join(checkpointDir, file);
+    const dest = path63.join(swarmDir, file);
     try {
       fs30.cpSync(src, dest, { recursive: true, force: true });
       successes.push(file);
@@ -32543,7 +32663,7 @@ async function handleRollbackCommand(directory, args) {
     ].join(`
 `);
   }
-  const existingLedgerPath = path62.join(swarmDir, "plan-ledger.jsonl");
+  const existingLedgerPath = path63.join(swarmDir, "plan-ledger.jsonl");
   let ledgerDeletionFailed = false;
   if (fs30.existsSync(existingLedgerPath)) {
     try {
@@ -32556,7 +32676,7 @@ async function handleRollbackCommand(directory, args) {
   }
   if (!ledgerDeletionFailed) {
     try {
-      const planJsonPath = path62.join(swarmDir, "plan.json");
+      const planJsonPath = path63.join(swarmDir, "plan.json");
       if (fs30.existsSync(planJsonPath)) {
         const planRaw = fs30.readFileSync(planJsonPath, "utf-8");
         const plan = PlanSchema.parse(JSON.parse(planRaw));
@@ -32604,8 +32724,8 @@ async function handleRollbackCommand(directory, args) {
 
 // src/commands/sdd.ts
 import * as fs31 from "fs";
-import * as path63 from "path";
-var SWARM_SPEC_REL = path63.join(".swarm", "spec.md");
+import * as path64 from "path";
+var SWARM_SPEC_REL = path64.join(".swarm", "spec.md");
 var USAGE9 = `Usage:
   /swarm sdd status [--json] [--source <provider>]
   /swarm sdd validate [--json] [--change <id>] [--source <provider>] [--feature <id>]
@@ -32721,7 +32841,7 @@ ${USAGE9}`;
   }
   const speckitDetection = detectSpeckit(directory);
   const speckitPresent = speckitDetection.features.length > 0;
-  const nativeSpecExists = fs31.existsSync(path63.join(directory, SWARM_SPEC_REL));
+  const nativeSpecExists = fs31.existsSync(path64.join(directory, SWARM_SPEC_REL));
   if (speckitPresent && !parsed.source && !nativeSpecExists) {
     const openspecProjection = buildOpenSpecProjectionSync(directory);
     if (openspecProjection !== null) {
@@ -32791,7 +32911,7 @@ ${USAGE9}`;
 ${USAGE9}`;
   }
   let useSpeckit = false;
-  const nativeSpecExists = fs31.existsSync(path63.join(directory, SWARM_SPEC_REL));
+  const nativeSpecExists = fs31.existsSync(path64.join(directory, SWARM_SPEC_REL));
   if (parsed.source === "speckit") {
     useSpeckit = true;
   } else if (!parsed.source && !nativeSpecExists) {
@@ -33103,10 +33223,10 @@ Ensure this is a git repository with commit history.`;
 `);
   try {
     const fs32 = await import("fs/promises");
-    const path64 = await import("path");
-    const reportPath = path64.join(directory, ".swarm", "simulate-report.md");
-    await fs32.mkdir(path64.dirname(reportPath), { recursive: true });
-    const reportTempPath = path64.join(path64.dirname(reportPath), `${path64.basename(reportPath)}.tmp.${Date.now()}.${Math.floor(Math.random() * 1e9)}`);
+    const path65 = await import("path");
+    const reportPath = path65.join(directory, ".swarm", "simulate-report.md");
+    await fs32.mkdir(path65.dirname(reportPath), { recursive: true });
+    const reportTempPath = path65.join(path65.dirname(reportPath), `${path65.basename(reportPath)}.tmp.${Date.now()}.${Math.floor(Math.random() * 1e9)}`);
     try {
       await fs32.writeFile(reportTempPath, report, "utf-8");
       renameSync11(reportTempPath, reportPath);
@@ -33135,18 +33255,18 @@ async function handleSpecifyCommand(_directory, args) {
 // src/services/status-service.ts
 import * as fsSync3 from "fs";
 import { readFile as readFile16 } from "fs/promises";
-import * as path65 from "path";
+import * as path66 from "path";
 
 // src/turbo/lean/state.ts
 init_logger();
 import * as fs32 from "fs";
-import * as path64 from "path";
+import * as path65 from "path";
 var STATE_FILE3 = "turbo-state.json";
 function nowISO3() {
   return new Date().toISOString();
 }
 function ensureSwarmDir2(directory) {
-  const swarmDir = path64.resolve(directory, ".swarm");
+  const swarmDir = path65.resolve(directory, ".swarm");
   if (!fs32.existsSync(swarmDir)) {
     fs32.mkdirSync(swarmDir, { recursive: true });
   }
@@ -33191,7 +33311,7 @@ function markStateUnreadable2(directory, reason) {
 }
 function readPersisted2(directory) {
   try {
-    const filePath = path64.join(directory, ".swarm", STATE_FILE3);
+    const filePath = path65.join(directory, ".swarm", STATE_FILE3);
     if (!fs32.existsSync(filePath)) {
       const seed = emptyPersisted2();
       try {
@@ -33227,7 +33347,7 @@ function writePersisted2(directory, persisted) {
   let payload;
   try {
     ensureSwarmDir2(directory);
-    filePath = path64.join(directory, ".swarm", STATE_FILE3);
+    filePath = path65.join(directory, ".swarm", STATE_FILE3);
     tmpPath = `${filePath}.tmp.${Date.now()}`;
     persisted.updatedAt = nowISO3();
     payload = `${JSON.stringify(persisted, null, 2)}
@@ -33338,14 +33458,14 @@ var DEFAULT_CONTEXT_BUDGET_CONFIG = {
 };
 
 // src/services/status-service.ts
-var _internals46 = {
+var _internals47 = {
   loadLeanTurboRunState,
   hasActiveLeanTurbo,
   hasActiveFullAuto
 };
 function readSpecStalenessSnapshot(directory) {
   try {
-    const p = path65.join(directory, ".swarm", "spec-staleness.json");
+    const p = path66.join(directory, ".swarm", "spec-staleness.json");
     if (!fsSync3.existsSync(p))
       return { stale: false };
     const raw = fsSync3.readFileSync(p, "utf-8");
@@ -33443,7 +33563,7 @@ async function getStatusData(directory, agents) {
 }
 function enrichWithLeanTurbo(status, directory) {
   const turboMode = hasActiveTurboMode();
-  const leanActive = _internals46.hasActiveLeanTurbo();
+  const leanActive = _internals47.hasActiveLeanTurbo();
   let turboStrategy = "off";
   if (leanActive) {
     turboStrategy = "lean";
@@ -33462,7 +33582,7 @@ function enrichWithLeanTurbo(status, directory) {
     }
   }
   if (leanSessionID) {
-    const runState = _internals46.loadLeanTurboRunState(directory, leanSessionID);
+    const runState = _internals47.loadLeanTurboRunState(directory, leanSessionID);
     if (runState) {
       status.leanTurboPhase = runState.phase;
       status.leanMaxParallelCoders = runState.maxParallelCoders;
@@ -33494,7 +33614,7 @@ function enrichWithLeanTurbo(status, directory) {
       }
     }
   }
-  status.fullAutoActive = _internals46.hasActiveFullAuto();
+  status.fullAutoActive = _internals47.hasActiveFullAuto();
   return status;
 }
 function formatStatusMarkdown(status) {
@@ -33648,7 +33768,7 @@ No active swarm plan found. Nothing to sync.`;
 
 // src/commands/turbo.ts
 init_logger();
-var _internals47 = {
+var _internals48 = {
   loadPluginConfigWithMeta
 };
 async function handleTurboCommand(directory, args, sessionID) {
@@ -33708,7 +33828,7 @@ async function handleTurboCommand(directory, args, sessionID) {
   if (arg0 === "on") {
     let strategy = "standard";
     try {
-      const { config } = _internals47.loadPluginConfigWithMeta(directory);
+      const { config } = _internals48.loadPluginConfigWithMeta(directory);
       if (config.turbo?.strategy === "lean") {
         strategy = "lean";
       }
@@ -33805,7 +33925,7 @@ function enableLeanTurbo(session, directory, sessionID) {
   let maxParallelCoders = 4;
   let conflictPolicy = "serialize";
   try {
-    const { config } = _internals47.loadPluginConfigWithMeta(directory);
+    const { config } = _internals48.loadPluginConfigWithMeta(directory);
     const leanConfig = config.turbo?.lean;
     if (leanConfig) {
       maxParallelCoders = leanConfig.max_parallel_coders ?? 4;
@@ -33878,11 +33998,11 @@ function buildStatusMessage2(session, directory, sessionID) {
 
 // src/commands/unlink.ts
 import { existsSync as existsSync38 } from "fs";
-import * as path66 from "path";
+import * as path67 from "path";
 var DEDUP_THRESHOLD2 = 0.6;
 async function copySharedKnowledgeToLocal(linkDir, localSwarmDir) {
-  const sharedPath = path66.join(linkDir, "knowledge.jsonl");
-  const localPath = path66.join(localSwarmDir, "knowledge.jsonl");
+  const sharedPath = path67.join(linkDir, "knowledge.jsonl");
+  const localPath = path67.join(localSwarmDir, "knowledge.jsonl");
   if (!existsSync38(sharedPath))
     return 0;
   const sharedEntries = await readKnowledge(sharedPath);
@@ -33917,7 +34037,7 @@ async function handleUnlinkCommand(directory, args) {
   let copied = 0;
   if (copyBack) {
     try {
-      copied = await copySharedKnowledgeToLocal(linkDir, path66.join(directory, ".swarm"));
+      copied = await copySharedKnowledgeToLocal(linkDir, path67.join(directory, ".swarm"));
     } catch (error2) {
       return `\u274C Failed to copy shared knowledge back to local: ${error2 instanceof Error ? error2.message : String(error2)}`;
     }
@@ -34021,7 +34141,7 @@ function findSimilarCommands(query) {
   }
   const scored = VALID_COMMANDS.map((cmd) => {
     const cmdLower = cmd.toLowerCase();
-    const fullScore = _internals48.levenshteinDistance(q, cmdLower);
+    const fullScore = _internals49.levenshteinDistance(q, cmdLower);
     let tokenScore = Infinity;
     if (cmd.includes(" ") || cmd.includes("-")) {
       const qTokens = q.split(/[\s-]+/);
@@ -34034,7 +34154,7 @@ function findSimilarCommands(query) {
         for (const ct of cmdTokens) {
           if (ct.length === 0)
             continue;
-          const dist = _internals48.levenshteinDistance(qt, ct);
+          const dist = _internals49.levenshteinDistance(qt, ct);
           if (dist < minDist)
             minDist = dist;
         }
@@ -34044,7 +34164,7 @@ function findSimilarCommands(query) {
     }
     const dashStrippedQ = q.replace(/-/g, "");
     const dashStrippedCmd = cmdLower.replace(/-/g, "");
-    const dashScore = _internals48.levenshteinDistance(dashStrippedQ, dashStrippedCmd);
+    const dashScore = _internals49.levenshteinDistance(dashStrippedQ, dashStrippedCmd);
     const score = Math.min(fullScore, tokenScore, dashScore);
     return { cmd, score };
   });
@@ -34079,16 +34199,16 @@ function buildDetailedHelp(commandName, entry) {
 async function handleHelpCommand(ctx) {
   const targetCommand = ctx.args.join(" ");
   if (!targetCommand) {
-    const { buildHelpText } = await import("./index-z4t3w4xf.js");
+    const { buildHelpText } = await import("./index-v90bnn0f.js");
     return buildHelpText();
   }
   const tokens = targetCommand.split(/\s+/);
-  const resolved = _internals48.resolveCommand(tokens);
+  const resolved = _internals49.resolveCommand(tokens);
   if (resolved) {
-    return _internals48.buildDetailedHelp(resolved.key, resolved.entry);
+    return _internals49.buildDetailedHelp(resolved.key, resolved.entry);
   }
-  const similar = _internals48.findSimilarCommands(targetCommand);
-  const { buildHelpText: fullHelp } = await import("./index-z4t3w4xf.js");
+  const similar = _internals49.findSimilarCommands(targetCommand);
+  const { buildHelpText: fullHelp } = await import("./index-v90bnn0f.js");
   if (similar.length > 0) {
     return `Command '/swarm ${targetCommand}' not found.
 
@@ -34152,7 +34272,7 @@ var COMMAND_REGISTRY = {
     toolNoArgs: true
   },
   help: {
-    handler: (ctx) => _internals48.handleHelpCommand(ctx),
+    handler: (ctx) => _internals49.handleHelpCommand(ctx),
     description: "Show help for swarm commands",
     category: "core",
     args: "[command]",
@@ -34221,7 +34341,7 @@ var COMMAND_REGISTRY = {
   },
   "guardrail explain": {
     handler: async (ctx) => {
-      const { handleGuardrailExplain } = await import("./guardrail-explain-fvjc90wa.js");
+      const { handleGuardrailExplain } = await import("./guardrail-explain-6xt0pb56.js");
       return handleGuardrailExplain(ctx.directory, ctx.args);
     },
     description: "Dry-run: show what the guardrails would do to a command or write target (executes nothing)",
@@ -35002,24 +35122,24 @@ function validateAliases() {
         continue;
       }
       const visited = new Set;
-      const path67 = [];
+      const path68 = [];
       let current = target;
       while (current) {
         const currentEntry = COMMAND_REGISTRY[current];
         if (!currentEntry)
           break;
         if (visited.has(current)) {
-          const cycleStart = path67.indexOf(current);
+          const cycleStart = path68.indexOf(current);
           const fullChain = [
             name,
-            ...path67.slice(0, cycleStart > 0 ? cycleStart : path67.length),
+            ...path68.slice(0, cycleStart > 0 ? cycleStart : path68.length),
             current
           ].join(" \u2192 ");
           errors.push(`Circular alias detected: ${fullChain}`);
           break;
         }
         visited.add(current);
-        path67.push(current);
+        path68.push(current);
         current = currentEntry.aliasOf || "";
       }
     }
@@ -35038,7 +35158,7 @@ function validateToolPolicy() {
   }
   return { valid: warnings.length === 0, warnings };
 }
-var _internals48 = {
+var _internals49 = {
   handleHelpCommand,
   validateAliases,
   validateToolPolicy,
@@ -35048,16 +35168,16 @@ var _internals48 = {
   findSimilarCommands,
   buildDetailedHelp
 };
-var validation = _internals48.validateAliases();
+var validation = _internals49.validateAliases();
 if (!validation.valid) {
   throw new Error(`COMMAND_REGISTRY alias validation failed:
 ${validation.errors.join(`
 `)}`);
 }
-_internals48.emitValidationWarnings("COMMAND_REGISTRY alias warnings", validation.warnings);
+_internals49.emitValidationWarnings("COMMAND_REGISTRY alias warnings", validation.warnings);
 try {
-  const toolPolicyValidation = _internals48.validateToolPolicy();
-  _internals48.emitValidationWarnings("COMMAND_REGISTRY toolPolicy warnings", toolPolicyValidation.warnings);
+  const toolPolicyValidation = _internals49.validateToolPolicy();
+  _internals49.emitValidationWarnings("COMMAND_REGISTRY toolPolicy warnings", toolPolicyValidation.warnings);
 } catch (e) {
   warn(`COMMAND_REGISTRY toolPolicy validation failed (non-fatal): ${e.message}`);
 }
@@ -35116,7 +35236,7 @@ function formatCommandNotFound(tokens) {
   const attemptedCommand = tokens[0] || "";
   const MAX_DISPLAY = 100;
   const displayCommand = attemptedCommand.length > MAX_DISPLAY ? `${attemptedCommand.slice(0, MAX_DISPLAY)}...` : attemptedCommand;
-  const similar = _internals48.findSimilarCommands(attemptedCommand);
+  const similar = _internals49.findSimilarCommands(attemptedCommand);
   const header = `Command \`/swarm ${displayCommand}\` not found.`;
   const suggestions = similar.length > 0 ? `Did you mean:
 ${similar.map((cmd) => `  - /swarm ${cmd}`).join(`
@@ -35173,4 +35293,4 @@ ${text}`;
   };
 }
 
-export { package_default, handleAcknowledgeSpecDriftCommand, handleAgentsCommand, handleAnalyzeCommand, handleArchiveCommand, DC_SAFE_TARGETS, dcNormalizeCommand, dcUnwrapWrappers, dcSplitSegments, dcValidateTargets, dcCheckJunctionCreation, dcExtractWindowsCmdTargets, dcExtractPowerShellTargets, normalizeSwarmCommandInput, canonicalCommandKey, formatCommandNotFound, executeSwarmCommand, SWARM_COMMAND_TOOL_COMMANDS, SWARM_COMMAND_TOOL_ALLOWLIST, HUMAN_ONLY_SWARM_COMMANDS, classifySwarmCommandToolUse, classifySwarmCommandChatFallbackUse, detectPosixWrites, detectWindowsWrites, resolveWriteTargets, handleAutoProceedCommand, handleBenchmarkCommand, handleBrainstormCommand, handleCheckpointCommand, handleClarifyCommand, handleCloseCommand, handleCodebaseReviewCommand, handleConcurrencyCommand, handleConfigCommand, handleConsolidateCommand, handleCostsCommand, handleCouncilCommand, handleCurateCommand, handleDarkMatterCommand, handleDeepDiveCommand, handleDeepResearchCommand, getPluginConfigDir, getPluginCachePaths, getPluginLockFilePaths, handleDiagnoseCommand, handleDoctorCommand, handleEvidenceCommand, handleEvidenceSummaryCommand, handleExportCommand, handleFullAutoCommand, handleHandoffCommand, handleHistoryCommand, handleKnowledgeQuarantineCommand, handleKnowledgeRestoreCommand, handleKnowledgeMigrateCommand, handleKnowledgeListCommand, handleKnowledgeUnactionableCommand, handleKnowledgeRetryHardeningCommand, handleLearningCommand, handleLinkCommand, handleMemoryCommand, handleMemoryStatusCommand, handleMemoryValueLogCommand, handleMemoryMigrateCommand, handleMemoryImportCommand, handleMemoryExportCommand, handlePlanCommand, handlePreflightCommand, handlePromoteCommand, handleQaGatesCommand, handleResetCommand, handleResetSessionCommand, handleRetrieveCommand, handleRollbackCommand, handleSddStatusCommand, handleSddValidateCommand, handleSddProjectCommand, handleSddCommand, handleSimulateCommand, handleSpecifyCommand, handleStatusCommand, handleSyncPlanCommand, handleTurboCommand, handleUnlinkCommand, handleWriteRetroCommand, handleHelpCommand, COMMAND_REGISTRY, VALID_COMMANDS, _internals48 as _internals, resolveCommand };
+export { package_default, handleAcknowledgeSpecDriftCommand, handleAgentsCommand, handleAnalyzeCommand, handleArchiveCommand, DC_SAFE_TARGETS, dcNormalizeCommand, dcUnwrapWrappers, dcSplitSegments, dcValidateTargets, dcCheckJunctionCreation, dcExtractWindowsCmdTargets, dcExtractPowerShellTargets, normalizeSwarmCommandInput, canonicalCommandKey, formatCommandNotFound, executeSwarmCommand, SWARM_COMMAND_TOOL_COMMANDS, SWARM_COMMAND_TOOL_ALLOWLIST, HUMAN_ONLY_SWARM_COMMANDS, classifySwarmCommandToolUse, classifySwarmCommandChatFallbackUse, detectPosixWrites, detectWindowsWrites, resolveWriteTargets, handleAutoProceedCommand, handleBenchmarkCommand, handleBrainstormCommand, handleCheckpointCommand, handleClarifyCommand, handleCloseCommand, handleCodebaseReviewCommand, handleConcurrencyCommand, handleConfigCommand, handleConsolidateCommand, handleCostsCommand, handleCouncilCommand, handleCurateCommand, handleDarkMatterCommand, handleDeepDiveCommand, handleDeepResearchCommand, getPluginConfigDir, getPluginCachePaths, getPluginLockFilePaths, handleDiagnoseCommand, handleDoctorCommand, handleEvidenceCommand, handleEvidenceSummaryCommand, handleExportCommand, handleFullAutoCommand, handleHandoffCommand, handleHistoryCommand, handleKnowledgeQuarantineCommand, handleKnowledgeRestoreCommand, handleKnowledgeMigrateCommand, handleKnowledgeListCommand, handleKnowledgeUnactionableCommand, handleKnowledgeRetryHardeningCommand, handleLearningCommand, handleLinkCommand, handleMemoryCommand, handleMemoryStatusCommand, handleMemoryValueLogCommand, handleMemoryMigrateCommand, handleMemoryImportCommand, handleMemoryExportCommand, handlePlanCommand, handlePreflightCommand, handlePromoteCommand, handleQaGatesCommand, handleResetCommand, handleResetSessionCommand, handleRetrieveCommand, handleRollbackCommand, handleSddStatusCommand, handleSddValidateCommand, handleSddProjectCommand, handleSddCommand, handleSimulateCommand, handleSpecifyCommand, handleStatusCommand, handleSyncPlanCommand, handleTurboCommand, handleUnlinkCommand, handleWriteRetroCommand, handleHelpCommand, COMMAND_REGISTRY, VALID_COMMANDS, _internals49 as _internals, resolveCommand };