opencode-swarm 7.107.1 → 7.107.3

package/dist/cli/{index-gt514nt1.js → index-cyzzdbvw.js}

@@ -44,7 +44,7 @@ import {
   savePlan,
   transientBackoff,
   validateProjectRoot
-} from "./index-jjp5qrjv.js";
+} from "./index-kzfkggjx.js";
 import {
   _internals as _internals2,
   _internals1 as _internals3,
@@ -136,7 +136,7 @@ import {
   resolveSpeckitProjection,
   validateSpeckit,
   writeProjectedSpecSync
-} from "./index-357p0baj.js";
+} from "./index-91j1sqzm.js";
 import {
   SandboxCapabilityProbe,
   _internals,
@@ -154,12 +154,12 @@ import {
   listActive,
   subscribe,
   unsubscribe
-} from "./index-t4hbye3v.js";
+} from "./index-hkpw4wwa.js";
 import {
   readSwarmFileAsync,
   safeHook,
   validateSwarmPath
-} from "./index-mpe0yk9s.js";
+} from "./index-57ymmh7h.js";
 import {
   deepMerge
 } from "./index-p0arc26j.js";
@@ -329,7 +329,7 @@ var init_bubblewrap = __esm(() => {
 import { spawnSync as spawnSync4 } from "child_process";
 import { mkdtempSync as mkdtempSync2, writeFileSync as writeFileSync6 } from "fs";
 import * as os8 from "os";
-import * as path34 from "path";
+import * as path35 from "path";
 function probeSandboxExec() {
   try {
     const result = spawnSync4("sandbox-exec", ["--version"], {
@@ -357,8 +357,8 @@ function probeSandboxExec() {
 function shellEscape2(s) {
   return s.replace(/'/g, "'\\''");
 }
-function sbplEscapePath(path35) {
-  const withoutControlChars = path35.split("").filter((ch) => {
+function sbplEscapePath(path36) {
+  const withoutControlChars = path36.split("").filter((ch) => {
     const cp = ch.codePointAt(0);
     return cp >= 32 && cp !== 127;
   }).join("");
@@ -434,8 +434,8 @@ class MacOSSandboxExecutor {
     const profile = buildSandboxProfile(allScopes, temp);
     let profilePath;
     try {
-      const profileDir = mkdtempSync2(path34.join(os8.tmpdir(), "sandbox-"));
-      profilePath = path34.join(profileDir, `profile-${process.pid}-${Date.now()}.sb`);
+      const profileDir = mkdtempSync2(path35.join(os8.tmpdir(), "sandbox-"));
+      profilePath = path35.join(profileDir, `profile-${process.pid}-${Date.now()}.sb`);
       writeFileSync6(profilePath, profile, { mode: 384 });
     } catch (err) {
       const message = err instanceof Error ? err.message : String(err);
@@ -542,7 +542,7 @@ var init_edge_cases = () => {};
 // src/sandbox/win32/restricted-environment-executor.ts
 import { spawnSync as spawnSync5 } from "child_process";
 import * as os9 from "os";
-import * as path35 from "path";
+import * as path36 from "path";
 function probeWindowsSandbox() {
   try {
     const result = spawnSync5("cmd", ["/c", "echo", "ok"], {
@@ -589,7 +589,7 @@ function isPathInScopes(command, scopes) {
   const paths = command.match(pathPattern) || [];
   if (paths.length === 0)
     return true;
-  const normalizedPaths = paths.map((p) => path35.win32.resolve(p));
+  const normalizedPaths = paths.map((p) => path36.win32.resolve(p));
   const normalizedScopes = scopes.map((s) => s.toLowerCase().replace(/\\+$/, ""));
   return normalizedPaths.every((p) => {
     const lower = p.toLowerCase();
@@ -724,9 +724,9 @@ var init_restricted_environment_executor = __esm(() => {
 
 // src/sandbox/win32/native-sandbox-executor.ts
 import * as crypto3 from "crypto";
-import * as fs13 from "fs";
+import * as fs12 from "fs";
 import * as os10 from "os";
-import * as path36 from "path";
+import * as path37 from "path";
 
 class NativeWindowsSandboxExecutor {
   mechanism;
@@ -788,12 +788,12 @@ class NativeWindowsSandboxExecutor {
     policy.workspace_roots = scopePaths.length > 0 ? scopePaths : [workspaceRoot];
     policy.writable_roots = policy.workspace_roots;
     const policyJson = JSON.stringify(policy);
-    const policyDir = path36.join(os10.tmpdir(), "swarm-sandbox-policies");
+    const policyDir = path37.join(os10.tmpdir(), "swarm-sandbox-policies");
     try {
-      fs13.mkdirSync(policyDir, { recursive: true });
+      fs12.mkdirSync(policyDir, { recursive: true });
     } catch {}
-    const policyFile = path36.join(policyDir, `${runId}.json`);
-    fs13.writeFileSync(policyFile, policyJson, "utf-8");
+    const policyFile = path37.join(policyDir, `${runId}.json`);
+    fs12.writeFileSync(policyFile, policyJson, "utf-8");
     const mode = this._probeResult.mode === "none" ? "auto" : this._probeResult.mode;
     const escapedBinary = binary.includes(" ") ? `"${binary}"` : binary;
     const escapedPolicyFile = policyFile.includes(" ") ? `"${policyFile}"` : policyFile;
@@ -924,8 +924,8 @@ var init_executor = __esm(() => {
 });
 
 // src/state.ts
-import * as fs33 from "fs/promises";
-import * as path68 from "path";
+import * as fs32 from "fs/promises";
+import * as path69 from "path";
 
 // src/db/qa-gate-profile.ts
 import { createHash } from "crypto";
@@ -5646,7 +5646,7 @@ function getDeferredWarnings() {
 }
 
 // src/config/bundled-skills.ts
-import * as fs2 from "fs";
+import { randomUUID as randomUUID3 } from "crypto";
 import * as fsp from "fs/promises";
 import * as path8 from "path";
 var BUNDLED_PROJECT_SKILLS = [
@@ -5679,10 +5679,6 @@ var BUNDLED_PROJECT_SKILLS = [
 ];
 var MAX_SKILL_FILES = 64;
 var MAX_SKILL_BYTES = 512000;
-var syncedProjectSkillTargets = new Set;
-function getSyncCacheKey(projectDirectory, packageRoot) {
-  return `${path8.resolve(projectDirectory)}\x00${path8.resolve(packageRoot)}`;
-}
 function warnBundledSkillSyncFailure(err) {
   const message = err instanceof Error ? err.message : String(err);
   console.warn(`[opencode-swarm] Could not install bundled project skills; continuing without sync: ${message}`);
@@ -5737,7 +5733,7 @@ async function collectBundledSkillFilesBoundedAsync(sourceDir, state, relativeDi
   }
   return files;
 }
-async function rollbackCopiedFilesAsync(copiedFiles, destDir) {
+async function rollbackCopiedFilesAsync(copiedFiles, destDir, overwrittenFiles = []) {
   const safeDestDir = path8.resolve(destDir);
   const dirs = new Set;
   for (const copiedFile of copiedFiles) {
@@ -5750,6 +5746,15 @@ async function rollbackCopiedFilesAsync(copiedFiles, destDir) {
     } catch {}
     dirs.add(path8.dirname(resolvedFile));
   }
+  for (const overwritten of overwrittenFiles.reverse()) {
+    const resolvedFile = path8.resolve(overwritten.path);
+    const relative2 = path8.relative(safeDestDir, resolvedFile);
+    if (relative2.startsWith("..") || path8.isAbsolute(relative2))
+      continue;
+    try {
+      await fsp.writeFile(resolvedFile, overwritten.contents);
+    } catch {}
+  }
   for (const dir of [...dirs].sort((a, b) => b.length - a.length)) {
     const relative2 = path8.relative(safeDestDir, path8.resolve(dir));
     if (relative2.startsWith("..") || path8.isAbsolute(relative2))
@@ -5759,39 +5764,58 @@ async function rollbackCopiedFilesAsync(copiedFiles, destDir) {
     } catch {}
   }
 }
+async function copyFileAtomicAsync(sourcePath, destPath) {
+  const tempPath = path8.join(path8.dirname(destPath), `.${path8.basename(destPath)}.tmp.${randomUUID3()}`);
+  try {
+    await fsp.copyFile(sourcePath, tempPath);
+    await fsp.rename(tempPath, destPath);
+  } catch (err) {
+    try {
+      await fsp.rm(tempPath, { force: true });
+    } catch {}
+    throw err;
+  }
+}
 async function copyBundledDirectoryBoundedAsync(sourceDir, destDir) {
   const files = await collectBundledSkillFilesBoundedAsync(sourceDir, {
     files: 0,
     bytes: 0
   });
   const copiedFiles = [];
+  const overwrittenFiles = [];
   try {
     for (const file of files) {
       const sourcePath = path8.join(sourceDir, file.relativePath);
       const destPath = path8.join(destDir, file.relativePath);
       await fsp.mkdir(path8.dirname(destPath), { recursive: true });
-      try {
-        await fsp.copyFile(sourcePath, destPath, fs2.constants.COPYFILE_EXCL);
+      if (await pathExistsAsync(destPath)) {
+        if (await isSymbolicLinkAsync(destPath)) {
+          throw new Error("refusing to overwrite symlinked bundled skill file");
+        }
+        const [sourceContents, destContents] = await Promise.all([
+          fsp.readFile(sourcePath),
+          fsp.readFile(destPath)
+        ]);
+        if (sourceContents.equals(destContents)) {
+          continue;
+        }
+        overwrittenFiles.push({ path: destPath, contents: destContents });
+        await copyFileAtomicAsync(sourcePath, destPath);
+      } else {
+        await copyFileAtomicAsync(sourcePath, destPath);
         copiedFiles.push(destPath);
-      } catch (err) {
-        if (err.code !== "EEXIST")
-          throw err;
       }
     }
   } catch (err) {
-    await rollbackCopiedFilesAsync(copiedFiles, destDir);
+    await rollbackCopiedFilesAsync(copiedFiles, destDir, overwrittenFiles);
     throw err;
   }
 }
 async function syncBundledProjectSkillsIfMissingAsync(projectDirectory, packageRoot, quiet = false) {
   try {
-    const cacheKey = getSyncCacheKey(projectDirectory, packageRoot);
-    if (syncedProjectSkillTargets.has(cacheKey))
-      return;
     const sourceRoot = path8.join(packageRoot, ".opencode", "skills");
     const opencodeDir = path8.join(projectDirectory, ".opencode");
     const skillsDir = path8.join(opencodeDir, "skills");
-    let sawBundledSource = false;
     if (!await ensureNotSymlinkedDirectoryAsync(opencodeDir))
       return;
     if (!await ensureNotSymlinkedDirectoryAsync(skillsDir))
@@ -5800,21 +5824,15 @@ async function syncBundledProjectSkillsIfMissingAsync(projectDirectory, packageR
       const sourceDir = path8.join(sourceRoot, slug);
       const sourceSkill = path8.join(sourceDir, "SKILL.md");
       const destDir = path8.join(skillsDir, slug);
-      const destSkill = path8.join(destDir, "SKILL.md");
       if (!await pathExistsAsync(sourceSkill))
         continue;
-      sawBundledSource = true;
-      if (await pathExistsAsync(destSkill))
-        continue;
       if (!await ensureNotSymlinkedDirectoryAsync(destDir))
         continue;
       await copyBundledDirectoryBoundedAsync(sourceDir, destDir);
       if (!quiet) {
-        console.warn(`[opencode-swarm] Installed bundled skill .opencode/skills/${slug}/SKILL.md for first-class /swarm command support`);
+        console.warn(`[opencode-swarm] Synchronized bundled skill .opencode/skills/${slug}/SKILL.md for first-class /swarm command support`);
       }
     }
-    if (sawBundledSource)
-      syncedProjectSkillTargets.add(cacheKey);
   } catch (err) {
     if (!quiet)
       warnBundledSkillSyncFailure(err);
@@ -6092,7 +6110,7 @@ async function handleAutoProceedCommand(_directory, args, sessionID) {
 }
 
 // src/services/cost-accounting.ts
-import * as fs3 from "fs";
+import * as fs2 from "fs";
 import * as os5 from "os";
 import * as path10 from "path";
 function summarizeTelemetryCosts(directory) {
@@ -6110,15 +6128,15 @@ function readTelemetryEvents(directory) {
     path10.join(swarmDir, "telemetry.jsonl.1"),
     path10.join(swarmDir, "telemetry.jsonl")
   ];
-  const tmpDir = fs3.mkdtempSync(path10.join(os5.tmpdir(), "telemetry-snapshot-"));
+  const tmpDir = fs2.mkdtempSync(path10.join(os5.tmpdir(), "telemetry-snapshot-"));
   const snapshotFiles = [];
   try {
     for (const file of files) {
-      if (!fs3.existsSync(file))
+      if (!fs2.existsSync(file))
         continue;
       const snap = path10.join(tmpDir, path10.basename(file));
       try {
-        fs3.copyFileSync(file, snap);
+        fs2.copyFileSync(file, snap);
         snapshotFiles.push(snap);
       } catch {}
     }
@@ -6127,7 +6145,7 @@ function readTelemetryEvents(directory) {
   for (const file of snapshotFiles) {
     let content = "";
     try {
-      content = fs3.readFileSync(file, "utf-8");
+      content = fs2.readFileSync(file, "utf-8");
     } catch {
       continue;
     }
@@ -6145,10 +6163,10 @@ function readTelemetryEvents(directory) {
   try {
     for (const f of snapshotFiles) {
       try {
-        fs3.unlinkSync(f);
+        fs2.unlinkSync(f);
       } catch {}
     }
-    fs3.rmdirSync(tmpDir);
+    fs2.rmdirSync(tmpDir);
   } catch {}
   return events;
 }
@@ -6672,7 +6690,7 @@ async function handleBrainstormCommand(_directory, args) {
 
 // src/tools/checkpoint.ts
 import * as child_process from "child_process";
-import * as fs4 from "fs";
+import * as fs3 from "fs";
 import * as path11 from "path";
 
 // src/tools/create-tool.ts
@@ -6765,8 +6783,8 @@ function getCheckpointLogPath(directory) {
 function readCheckpointLog(directory) {
   const logPath = getCheckpointLogPath(directory);
   try {
-    if (fs4.existsSync(logPath)) {
-      const content = fs4.readFileSync(logPath, "utf-8");
+    if (fs3.existsSync(logPath)) {
+      const content = fs3.readFileSync(logPath, "utf-8");
       const parsed = JSON.parse(content);
       if (!parsed.checkpoints || !Array.isArray(parsed.checkpoints)) {
         return { version: 1, checkpoints: [] };
@@ -6779,12 +6797,12 @@ function readCheckpointLog(directory) {
 function writeCheckpointLog(log2, directory) {
   const logPath = getCheckpointLogPath(directory);
   const dir = path11.dirname(logPath);
-  if (!fs4.existsSync(dir)) {
-    fs4.mkdirSync(dir, { recursive: true });
+  if (!fs3.existsSync(dir)) {
+    fs3.mkdirSync(dir, { recursive: true });
   }
   const tempPath = `${logPath}.tmp`;
-  fs4.writeFileSync(tempPath, JSON.stringify(log2, null, 2), "utf-8");
-  fs4.renameSync(tempPath, logPath);
+  fs3.writeFileSync(tempPath, JSON.stringify(log2, null, 2), "utf-8");
+  fs3.renameSync(tempPath, logPath);
 }
 function gitExec(args, cwd) {
   for (let attempt = 0;attempt < MAX_TRANSIENT_RETRIES; attempt++) {
@@ -6818,7 +6836,7 @@ function appendRetentionEvent(directory, event) {
     const eventsPath = path11.join(directory, ".swarm", "events.jsonl");
     const line = `${JSON.stringify({ ...event, timestamp: new Date().toISOString() })}
 `;
-    fs4.appendFileSync(eventsPath, line);
+    fs3.appendFileSync(eventsPath, line);
   } catch {}
 }
 function getCurrentSha(directory) {
@@ -6922,13 +6940,15 @@ function handleRestore(label, directory) {
         error: `checkpoint not found: "${label}"`
       }, null, 2);
     }
-    gitExec(["reset", "--soft", checkpoint.sha], directory);
+    const logBeforeReset = log2;
+    gitExec(["reset", "--hard", checkpoint.sha], directory);
+    writeCheckpointLog(logBeforeReset, directory);
     return JSON.stringify({
       action: "restore",
       success: true,
       label,
       sha: checkpoint.sha,
-      message: `Restored to checkpoint: "${label}" (soft reset)`
+      message: `Restored to checkpoint: "${label}" (hard reset)`
     }, null, 2);
   } catch (e) {
     const errorMessage = e instanceof Error ? `restore failed: ${e.message}` : "restore failed: unknown error";
@@ -6978,7 +6998,7 @@ function handleDelete(label, directory) {
   }
 }
 var checkpoint = createSwarmTool({
-  description: "Save, restore, list, and delete git checkpoints. " + "Use save to create a named snapshot, restore to return to a checkpoint (soft reset), " + "list to see all checkpoints, and delete to remove a checkpoint from the log. " + "Git commits are preserved on delete.",
+  description: "Save, restore, list, and delete git checkpoints. " + "Use save to create a named snapshot, restore to return tracked files to a checkpoint, " + "list to see all checkpoints, and delete to remove a checkpoint from the log. " + "Git commits are preserved on delete.",
   args: {
     action: exports_external.string().describe("Action to perform: save, restore, list, or delete"),
     label: exports_external.string().optional().describe("Checkpoint label (required for save, restore, delete)")
@@ -7180,8 +7200,8 @@ async function handleClarifyCommand(_directory, args) {
 // src/commands/close.ts
 import { spawnSync as spawnSync2 } from "child_process";
 import * as fsSync from "fs";
-import { promises as fs11 } from "fs";
-import path27 from "path";
+import { promises as fs10 } from "fs";
+import path28 from "path";
 
 // src/hooks/curator-postmortem.ts
 import { existsSync as existsSync7, readdirSync, readFileSync as readFileSync4 } from "fs";
@@ -7900,11 +7920,11 @@ var _internals8 = {
     return KnowledgeConfigSchema2.parse({});
   },
   applyCuratorKnowledgeUpdates: async (directory, recommendations, knowledgeConfig) => {
-    const { applyCuratorKnowledgeUpdates } = await import("./curator-np2ky29t.js");
+    const { applyCuratorKnowledgeUpdates } = await import("./curator-1nr4qszq.js");
     return applyCuratorKnowledgeUpdates(directory, recommendations, knowledgeConfig);
   },
   checkHivePromotions: async (entries, knowledgeConfig) => {
-    const { checkHivePromotions } = await import("./hive-promoter-y9r8d315.js");
+    const { checkHivePromotions } = await import("./hive-promoter-j4e6rfa6.js");
     return checkHivePromotions(entries, knowledgeConfig);
   },
   applyProposalTriage: async (directory, triage) => {
@@ -7954,7 +7974,7 @@ var _internals8 = {
     return result;
   },
   readPriorDriftReports: async (directory) => {
-    const { readPriorDriftReports } = await import("./curator-drift-6ad8mxxb.js");
+    const { readPriorDriftReports } = await import("./curator-drift-ed7p5mfy.js");
     return readPriorDriftReports(directory);
   },
   readSwarmKnowledge: (directory) => readKnowledge(resolveSwarmKnowledgePath(directory))
@@ -7964,8 +7984,8 @@ var _internals8 = {
 import path16 from "path";
 
 // src/hooks/curator.ts
-import { randomUUID as randomUUID4 } from "crypto";
-import * as fs6 from "fs";
+import { randomUUID as randomUUID5 } from "crypto";
+import * as fs5 from "fs";
 import * as path15 from "path";
 
 // src/hooks/knowledge-escalator.ts
@@ -8403,12 +8423,12 @@ function formatLearningSummary(metrics) {
 
 // src/services/skill-reviser.ts
 init_logger();
-import { readFile as readFile4, rename as rename3, writeFile as writeFile4 } from "fs/promises";
+import { readFile as readFile5, rename as rename4, writeFile as writeFile5 } from "fs/promises";
 
 // src/services/skill-improver-quota.ts
 var import_proper_lockfile = __toESM(require_proper_lockfile(), 1);
 import { existsSync as existsSync8 } from "fs";
-import { mkdir as mkdir4, readFile as readFile3, rename as rename2, writeFile as writeFile3 } from "fs/promises";
+import { mkdir as mkdir4, readFile as readFile4, rename as rename3, writeFile as writeFile4 } from "fs/promises";
 import * as path13 from "path";
 var LOCK_ACQUIRE_TIMEOUT_MS = 1e4;
 var LOCK_RETRY_OPTS = {
@@ -8453,7 +8473,7 @@ async function readState(filePath) {
   if (!existsSync8(filePath))
     return null;
   try {
-    const raw = await readFile3(filePath, "utf-8");
+    const raw = await readFile4(filePath, "utf-8");
     const parsed = JSON.parse(raw);
     if (typeof parsed.date !== "string" || typeof parsed.calls_used !== "number" || typeof parsed.max_calls !== "number" || parsed.window !== "utc" && parsed.window !== "local") {
       return null;
@@ -8466,8 +8486,8 @@ async function readState(filePath) {
 async function writeState(filePath, state) {
   await mkdir4(path13.dirname(filePath), { recursive: true });
   const tmp = `${filePath}.tmp-${process.pid}`;
-  await writeFile3(tmp, JSON.stringify(state, null, 2), "utf-8");
-  await rename2(tmp, filePath);
+  await writeFile4(tmp, JSON.stringify(state, null, 2), "utf-8");
+  await rename3(tmp, filePath);
 }
 async function getQuotaState(directory, opts) {
   const filePath = resolveQuotaPath(directory, opts.scope);
@@ -8544,7 +8564,7 @@ var MAX_REVISION_CALLS_PER_PHASE = 3;
 var DEFAULT_MAX_CALLS = 10;
 async function getSkillVersion(skillPath) {
   try {
-    const content = await readFile4(skillPath, "utf-8");
+    const content = await readFile5(skillPath, "utf-8");
     const match = content.match(/^version:\s*(\d+)\s*$/m);
     return match ? parseInt(match[1], 10) : 1;
   } catch {
@@ -8681,8 +8701,8 @@ async function reviseSkill(params) {
         };
       }
       const tmpPath = `${params.skillPath}.tmp-${process.pid}-${Date.now()}`;
-      await writeFile4(tmpPath, revised, "utf-8");
-      await rename3(tmpPath, params.skillPath);
+      await writeFile5(tmpPath, revised, "utf-8");
+      await rename4(tmpPath, params.skillPath);
       const newVersion = params.currentVersion + 1;
       const entry = {
         version: newVersion,
@@ -8758,9 +8778,9 @@ async function reviseSkill(params) {
       };
     }
     const tmpPath = `${params.skillPath}.tmp-${process.pid}-${Date.now()}`;
-    await writeFile4(tmpPath, `${finalOutput}
+    await writeFile5(tmpPath, `${finalOutput}
 `, "utf-8");
-    await rename3(tmpPath, params.skillPath);
+    await rename4(tmpPath, params.skillPath);
     const newVersion = expectedVersion;
     const entry = {
       version: newVersion,
@@ -8814,7 +8834,7 @@ init_logger();
 
 // src/hooks/skill-usage-log.ts
 import * as crypto2 from "crypto";
-import * as fs5 from "fs";
+import * as fs4 from "fs";
 import * as path14 from "path";
 function resolveLogPath(directory) {
   return validateSwarmPath(directory, "skill-usage.jsonl");
@@ -8824,16 +8844,16 @@ function normalizeComplianceVerdict(verdict) {
 }
 var _internals10 = {
   generateId: () => crypto2.randomUUID(),
-  appendFileSync: fs5.appendFileSync.bind(fs5),
-  readFileSync: fs5.readFileSync.bind(fs5),
-  writeFileSync: fs5.writeFileSync.bind(fs5),
-  renameSync: fs5.renameSync.bind(fs5),
-  mkdirSync: fs5.mkdirSync.bind(fs5),
-  existsSync: fs5.existsSync.bind(fs5),
-  statSync: fs5.statSync.bind(fs5),
-  openSync: fs5.openSync.bind(fs5),
-  readSync: fs5.readSync.bind(fs5),
-  closeSync: fs5.closeSync.bind(fs5),
+  appendFileSync: fs4.appendFileSync.bind(fs4),
+  readFileSync: fs4.readFileSync.bind(fs4),
+  writeFileSync: fs4.writeFileSync.bind(fs4),
+  renameSync: fs4.renameSync.bind(fs4),
+  mkdirSync: fs4.mkdirSync.bind(fs4),
+  existsSync: fs4.existsSync.bind(fs4),
+  statSync: fs4.statSync.bind(fs4),
+  openSync: fs4.openSync.bind(fs4),
+  readSync: fs4.readSync.bind(fs4),
+  closeSync: fs4.closeSync.bind(fs4),
   pruneSkillUsageLog,
   resolveSourceKnowledgeIds,
   applySkillUsageFeedback,
@@ -9340,7 +9360,7 @@ var _internals11 = {
   retireOrMarkStale,
   retireSkill,
   getArchivedKnowledgeIds,
-  readFileAsync: (filePath, encoding) => import("fs/promises").then((fs7) => fs7.readFile(filePath, encoding)),
+  readFileAsync: (filePath, encoding) => import("fs/promises").then((fs6) => fs6.readFile(filePath, encoding)),
   readKnowledge,
   reviseSkill,
   getSkillVersion,
@@ -9393,13 +9413,25 @@ async function autoRetireSkills(directory, _curatorKnowledgePath, excludeSlugs)
         warn(`[curator] ${observations[observations.length - 1]}`);
         continue;
       }
-      const result = await _internals11.retireOrMarkStale(directory, path15.dirname(active.path), allArchivedIds);
-      if (result.action === "retire") {
-        observations.push(`Skill '${active.slug}' auto-retired: all source knowledge entries archived`);
-        warn(`[curator] ${observations[observations.length - 1]}`);
-      } else if (result.action === "stale") {
-        observations.push(`Skill '${active.slug}' marked stale: some source knowledge entries archived`);
-        warn(`[curator] ${observations[observations.length - 1]}`);
+      let archivedSourceMatched = false;
+      if (allArchivedIds.size > 0) {
+        try {
+          const content = await _internals11.readFileAsync(active.path, "utf-8");
+          const sourceIds = _internals11.parseDraftFrontmatter(content)?.sourceKnowledgeIds ?? [];
+          archivedSourceMatched = sourceIds.some((id) => allArchivedIds.has(id));
+        } catch {
+          archivedSourceMatched = false;
+        }
+      }
+      if (archivedSourceMatched) {
+        const result = await _internals11.retireOrMarkStale(directory, path15.dirname(active.path), allArchivedIds);
+        if (result.action === "retire") {
+          observations.push(`Skill '${active.slug}' auto-retired: all source knowledge entries archived`);
+          warn(`[curator] ${observations[observations.length - 1]}`);
+        } else if (result.action === "stale") {
+          observations.push(`Skill '${active.slug}' marked stale: some source knowledge entries archived`);
+          warn(`[curator] ${observations[observations.length - 1]}`);
+        }
       }
     }
   } catch (autoRetireErr) {
@@ -9424,6 +9456,29 @@ function parseKnowledgeRecommendationsWithDiagnostics(llmOutput) {
         continue;
       const match = trimmed.match(/^-\s+entry\s+(\S+)\s+\(([^)]+)\):\s+(.+)$/i);
       if (!match) {
+        const newCandidate = trimmed.match(/^-\s+new candidate:\s+(.+)$/i);
+        if (newCandidate) {
+          const text2 = newCandidate[1].trim().replace(/\s+\([^)]+\)$/, "");
+          recommendations.push({
+            action: "promote",
+            entry_id: undefined,
+            lesson: text2,
+            reason: text2
+          });
+          continue;
+        }
+        const staleEntry = trimmed.match(/^-\s+entry\s+(\S+)\s+appears stale:\s+(.+)$/i);
+        if (staleEntry) {
+          const uuid2 = staleEntry[1];
+          const text2 = staleEntry[2].trim().replace(/\s+\([^)]+\)$/, "");
+          recommendations.push({
+            action: "archive",
+            entry_id: UUID_V4.test(uuid2) ? uuid2 : undefined,
+            lesson: text2,
+            reason: text2
+          });
+          continue;
+        }
         diagnostics.push({
           section: "OBSERVATIONS",
           line: trimmed,
@@ -9567,16 +9622,16 @@ function arrayOfStrings(v) {
 function readLatestPostMortemDigest(directory) {
   try {
     const swarmDir = path15.join(directory, ".swarm");
-    if (!fs6.existsSync(swarmDir))
+    if (!fs5.existsSync(swarmDir))
       return null;
-    const candidates = fs6.readdirSync(swarmDir).filter((name) => /^post-mortem-[^/\\]+\.md$/.test(name)).map((name) => {
+    const candidates = fs5.readdirSync(swarmDir).filter((name) => /^post-mortem-[^/\\]+\.md$/.test(name)).map((name) => {
       const filePath = path15.join(swarmDir, name);
-      return { name, filePath, mtimeMs: fs6.statSync(filePath).mtimeMs };
+      return { name, filePath, mtimeMs: fs5.statSync(filePath).mtimeMs };
     }).sort((a, b) => b.mtimeMs - a.mtimeMs);
     const latest = candidates[0];
     if (!latest)
       return null;
-    const content = fs6.readFileSync(latest.filePath, "utf-8");
+    const content = fs5.readFileSync(latest.filePath, "utf-8");
     const summary = content.match(/SUMMARY:\s*\n([\s\S]*?)(?:\n[A-Z_]+:|\n##|$)/);
     const body = (summary?.[1]?.trim() || content.slice(0, 1500)).slice(0, 1500);
     return `${latest.name}
@@ -9613,7 +9668,7 @@ async function readCuratorSummary(directory) {
 }
 async function writeCuratorSummary(directory, summary) {
   const resolvedPath = validateSwarmPath(directory, "curator-summary.json");
-  fs6.mkdirSync(path15.dirname(resolvedPath), { recursive: true });
+  fs5.mkdirSync(path15.dirname(resolvedPath), { recursive: true });
   await bunWrite(resolvedPath, JSON.stringify(summary, null, 2));
 }
 function normalizeAgentName(name) {
@@ -10054,7 +10109,7 @@ async function runCuratorPhase(directory, phase, agentsDispatched, config, knowl
     if (knowledgeApplicationFindings.length > 0) {
       try {
         const evidenceDir = path15.join(directory, ".swarm", "evidence", String(phase));
-        fs6.mkdirSync(evidenceDir, { recursive: true });
+        fs5.mkdirSync(evidenceDir, { recursive: true });
         const findingsPath = path15.join(evidenceDir, "curator-findings.json");
         await bunWrite(findingsPath, JSON.stringify({ findings: knowledgeApplicationFindings }, null, 2));
       } catch (err) {
@@ -10357,7 +10412,7 @@ async function applyCuratorKnowledgeUpdates(directory, recommendations, knowledg
     }
     const now = new Date().toISOString();
     const newEntry = {
-      id: randomUUID4(),
+      id: randomUUID5(),
       tier: "swarm",
       lesson,
       category: rec.category ?? "other",
@@ -10674,18 +10729,18 @@ async function promoteFromSwarm(directory, lessonId) {
 // src/hooks/knowledge-curator.ts
 import { createHash as createHash4 } from "crypto";
 import { existsSync as existsSync13 } from "fs";
-import { appendFile as appendFile2, mkdir as mkdir6, readFile as readFile7, writeFile as writeFile7 } from "fs/promises";
+import { appendFile as appendFile2, mkdir as mkdir6, readFile as readFile8, writeFile as writeFile8 } from "fs/promises";
 import * as path21 from "path";
 
 // src/services/synonym-map.ts
 var import_proper_lockfile2 = __toESM(require_proper_lockfile(), 1);
 import {
   mkdir as mkdir5,
-  readFile as readFile5,
-  rename as rename4,
+  readFile as readFile6,
+  rename as rename5,
   stat as stat3,
   unlink,
-  writeFile as writeFile5
+  writeFile as writeFile6
 } from "fs/promises";
 import * as path17 from "path";
 var SYNONYM_MAP_FILENAME = "synonym-map.json";
@@ -10835,7 +10890,7 @@ async function readSynonymMap(directory, maxPairs = DEFAULT_MAX_PAIRS) {
     const st = await stat3(filePath);
     if (st.size > ceiling)
       return emptySynonymMap();
-    const raw = await readFile5(filePath, "utf-8");
+    const raw = await readFile6(filePath, "utf-8");
     return coerceSynonymMap(JSON.parse(raw), maxPairs);
   } catch {
     return emptySynonymMap();
@@ -10845,8 +10900,8 @@ async function writeSynonymMapAtomic(filePath, map) {
   await mkdir5(path17.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");
-    await rename4(tmp, filePath);
+    await writeFile6(tmp, JSON.stringify(map, null, 2), "utf-8");
+    await rename5(tmp, filePath);
   } finally {
     try {
       await unlink(tmp);
@@ -10919,17 +10974,17 @@ function reinforceSwarmKnowledgeEntry(entry, confirmation) {
 
 // src/hooks/micro-reflector.ts
 import { existsSync as existsSync12 } from "fs";
-import { readFile as readFile6, writeFile as writeFile6 } from "fs/promises";
+import { readFile as readFile7, writeFile as writeFile7 } from "fs/promises";
 import * as path20 from "path";
 init_logger();
 
 // src/hooks/skill-propagation-gate.ts
-import * as fs8 from "fs";
+import * as fs7 from "fs";
 import * as path19 from "path";
 init_logger();
 
 // src/hooks/skill-scoring.ts
-import * as fs7 from "fs";
+import * as fs6 from "fs";
 import * as path18 from "path";
 var FREQUENCY_CAP = 10;
 var FREQUENCY_WEIGHT = 0.3;
@@ -10997,6 +11052,9 @@ function normalizeTriggerList(values) {
   }
   return out;
 }
+function finiteRankValue(value) {
+  return Number.isFinite(value) ? value : 0;
+}
 function parseInlineStringList(rawValue) {
   const trimmed = rawValue.trim();
   if (!trimmed)
@@ -11103,13 +11161,13 @@ function parseSkillFrontmatter(content, skillPath) {
   return meta;
 }
 function readFilePrefix(filePath) {
-  const fd = fs7.openSync(filePath, "r");
+  const fd = fs6.openSync(filePath, "r");
   try {
     const buffer = Buffer.alloc(SKILL_FRONTMATTER_READ_BYTES);
-    const bytesRead = fs7.readSync(fd, buffer, 0, SKILL_FRONTMATTER_READ_BYTES, 0);
+    const bytesRead = fs6.readSync(fd, buffer, 0, SKILL_FRONTMATTER_READ_BYTES, 0);
     return buffer.toString("utf-8", 0, bytesRead);
   } finally {
-    fs7.closeSync(fd);
+    fs6.closeSync(fd);
   }
 }
 function readSkillMetadata(skillPath, directory) {
@@ -11215,15 +11273,19 @@ function rankSkillsForContext(skills, taskContext, directory) {
     const complianceRate = entriesWithVerdict.length > 0 ? compliantCount / entriesWithVerdict.length : 0;
     results.push({
       skillPath,
-      score,
+      score: finiteRankValue(score),
       usageCount: skillEntries.length,
       complianceRate
     });
   }
   results.sort((a, b) => {
-    if (b.score !== a.score)
-      return b.score - a.score;
-    return b.usageCount - a.usageCount;
+    const scoreDelta = finiteRankValue(b.score) - finiteRankValue(a.score);
+    if (scoreDelta !== 0)
+      return scoreDelta;
+    const usageDelta = b.usageCount - a.usageCount;
+    if (usageDelta !== 0)
+      return usageDelta;
+    return a.skillPath.localeCompare(b.skillPath);
   });
   return results;
 }
@@ -11258,7 +11320,7 @@ function formatSkillIndexWithContext(skills, directory) {
   const usageLogPath = path18.join(directory, ".swarm", "skill-usage.jsonl");
   let hasHistory = false;
   try {
-    const stat4 = fs7.statSync(usageLogPath);
+    const stat4 = fs6.statSync(usageLogPath);
     hasHistory = stat4.size > 0;
   } catch {}
   if (!hasHistory) {
@@ -11421,13 +11483,13 @@ var SKILL_SEARCH_ROOTS = [
 ];
 var MAX_SCORING_SESSION_ENTRIES = 500;
 var _internals13 = {
-  readdirSync: fs8.readdirSync.bind(fs8),
-  existsSync: fs8.existsSync.bind(fs8),
-  statSync: fs8.statSync.bind(fs8),
-  mkdirSync: fs8.mkdirSync.bind(fs8),
-  appendFileSync: fs8.appendFileSync.bind(fs8),
-  readFileSync: fs8.readFileSync.bind(fs8),
-  writeFileSync: fs8.writeFileSync.bind(fs8),
+  readdirSync: fs7.readdirSync.bind(fs7),
+  existsSync: fs7.existsSync.bind(fs7),
+  statSync: fs7.statSync.bind(fs7),
+  mkdirSync: fs7.mkdirSync.bind(fs7),
+  appendFileSync: fs7.appendFileSync.bind(fs7),
+  readFileSync: fs7.readFileSync.bind(fs7),
+  writeFileSync: fs7.writeFileSync.bind(fs7),
   skillPropagationGateBefore: null,
   skillPropagationTransformScan: null,
   SKILL_CAPABLE_AGENTS,
@@ -11948,7 +12010,7 @@ async function readTaskTrajectory(directory, taskId) {
     const filePath = validateSwarmPath(directory, rel);
     if (!existsSync12(filePath))
       return [];
-    const content = await readFile6(filePath, "utf-8");
+    const content = await readFile7(filePath, "utf-8");
     const out = [];
     for (const line of content.split(`
 `)) {
@@ -12418,11 +12480,11 @@ async function consumeInsightCandidates(directory, batchLimit = MESO_INSIGHT_BAT
     if (!existsSync13(filePath))
       return [];
     const consumed = [];
-    await transactFile(filePath, async (p) => readInsightJsonl(await readFile7(p, "utf-8").catch(() => "")), async (p, data) => {
+    await transactFile(filePath, async (p) => readInsightJsonl(await readFile8(p, "utf-8").catch(() => "")), async (p, data) => {
       const body = data.length === 0 ? "" : `${data.map((c) => JSON.stringify(c)).join(`
 `)}
 `;
-      await writeFile7(p, body, "utf-8");
+      await writeFile8(p, body, "utf-8");
     }, (all) => {
       if (all.length === 0)
         return null;
@@ -12902,7 +12964,7 @@ var _internals15 = {
 
 // src/scope/scope-persistence.ts
 var import_proper_lockfile3 = __toESM(require_proper_lockfile(), 1);
-import * as fs9 from "fs";
+import * as fs8 from "fs";
 import * as path22 from "path";
 var DEFAULT_TTL_MS = 24 * 60 * 60 * 1000;
 var LOCK_STALE_MS = 30 * 1000;
@@ -12938,12 +13000,12 @@ function getScopesDir(directory) {
 }
 function clearAllScopes(directory) {
   try {
-    fs9.rmSync(getScopesDir(directory), { recursive: true, force: true });
+    fs8.rmSync(getScopesDir(directory), { recursive: true, force: true });
   } catch {}
 }
 
 // src/services/session-reflection.ts
-import { promises as fs10 } from "fs";
+import { promises as fs9 } from "fs";
 import * as path23 from "path";
 
 // src/hooks/abort-utils.ts
@@ -13106,12 +13168,12 @@ async function gatherRetroLessonsAndTaxonomy(directory) {
   const taxonomy = {};
   try {
     const evidenceDir = path23.join(directory, ".swarm", "evidence");
-    const entries = await fs10.readdir(evidenceDir);
+    const entries = await fs9.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 = path23.join(evidenceDir, retroDir, "evidence.json");
       try {
-        const content = await fs10.readFile(evidencePath, "utf-8");
+        const content = await fs9.readFile(evidencePath, "utf-8");
         const parsed = JSON.parse(content);
         const bundleEntries = parsed.entries ?? [parsed];
         for (const entry of bundleEntries) {
@@ -13139,13 +13201,13 @@ async function gatherGateFailures(directory) {
   const failures = new Map;
   try {
     const evidenceDir = path23.join(directory, ".swarm", "evidence");
-    const entries = await fs10.readdir(evidenceDir);
+    const entries = await fs9.readdir(evidenceDir);
     for (const entry of entries) {
       if (entry.startsWith("retro-"))
         continue;
       const evidencePath = path23.join(evidenceDir, entry, "evidence.json");
       try {
-        const content = await fs10.readFile(evidencePath, "utf-8");
+        const content = await fs9.readFile(evidencePath, "utf-8");
         const parsed = JSON.parse(content);
         const bundleEntries = parsed.entries ?? [parsed];
         for (const e of bundleEntries) {
@@ -13337,18 +13399,18 @@ async function writeSessionReflection(directory, result) {
   lines.push(result.architectReport);
   const content = lines.join(`
 `);
-  await fs10.writeFile(reflectionPath, content, "utf-8");
+  await fs9.writeFile(reflectionPath, content, "utf-8");
   return reflectionPath;
 }
 
 // src/services/skill-improver.ts
 import { existsSync as existsSync15 } from "fs";
-import { mkdir as mkdir8, readFile as readFile8, rename as rename5, writeFile as writeFile9 } from "fs/promises";
+import { mkdir as mkdir8, readFile as readFile9, rename as rename6, writeFile as writeFile10 } from "fs/promises";
 import * as path25 from "path";
 init_logger();
 
 // src/services/trajectory-cluster.ts
-import { mkdir as mkdir7, writeFile as writeFile8 } from "fs/promises";
+import { mkdir as mkdir7, writeFile as writeFile9 } from "fs/promises";
 import * as path24 from "path";
 init_logger();
 var MACRO_TRAJECTORY_WINDOW = 200;
@@ -13486,7 +13548,7 @@ async function writeMotifProposals(directory, opts = {}) {
     for (const motif of motifs.slice(0, max)) {
       const slug = `motif-${slugify(motif.signature)}`;
       const filePath = path24.join(proposalsDir, `${slug}.md`);
-      await writeFile8(filePath, buildMotifProposal(motif), "utf-8");
+      await writeFile9(filePath, buildMotifProposal(motif), "utf-8");
       result.proposalsWritten.push(filePath);
     }
     return result;
@@ -13631,7 +13693,7 @@ async function writeSuccessMotifProposals(directory, opts = {}) {
     for (const motif of motifs.slice(0, max)) {
       const slug = workflowSlug(motif.signature);
       const filePath = path24.join(proposalsDir, `${slug}.md`);
-      await writeFile8(filePath, buildWorkflowProposal(motif), "utf-8");
+      await writeFile9(filePath, buildWorkflowProposal(motif), "utf-8");
       result.proposalsWritten.push(filePath);
     }
     return result;
@@ -13755,8 +13817,8 @@ function timestampSlug(d) {
 async function atomicWrite(p, content) {
   await mkdir8(path25.dirname(p), { recursive: true });
   const tmp = `${p}.tmp-${process.pid}-${Date.now()}`;
-  await writeFile9(tmp, content, "utf-8");
-  await rename5(tmp, p);
+  await writeFile10(tmp, content, "utf-8");
+  await rename6(tmp, p);
 }
 async function gatherInventory(directory) {
   const swarm = await readKnowledge(resolveSwarmKnowledgePath(directory));
@@ -13770,7 +13832,7 @@ async function gatherInventory(directory) {
   for (const skill of skills.active) {
     let content;
     try {
-      content = await readFile8(skill.path, "utf-8");
+      content = await readFile9(skill.path, "utf-8");
     } catch {
       continue;
     }
@@ -13946,7 +14008,7 @@ async function reconcileStaleActiveSkills(directory, options = {}) {
   for (const skill of skills.active) {
     let content;
     try {
-      content = await readFile8(skill.path, "utf-8");
+      content = await readFile9(skill.path, "utf-8");
     } catch {
       continue;
     }
@@ -14268,6 +14330,8 @@ function readEarliestSessionStart(directory) {
 }
 
 // src/tools/write-retro.ts
+import { existsSync as existsSync17 } from "fs";
+import path27 from "path";
 async function executeWriteRetro(args, directory) {
   if (/^(CON|PRN|AUX|NUL|COM[0-9]|LPT[0-9])(:|$)/i.test(directory)) {
     return JSON.stringify({
@@ -14275,6 +14339,12 @@ async function executeWriteRetro(args, directory) {
       message: "Invalid directory: reserved device name"
     }, null, 2);
   }
+  if (!existsSync17(path27.join(directory, ".swarm"))) {
+    return JSON.stringify({
+      success: false,
+      message: `Cannot write evidence in "${directory}" \u2014 no .swarm/ folder was found. Run write_retro from an initialized project root.`
+    }, null, 2);
+  }
   const phase = args.phase;
   if (!Number.isInteger(phase) || phase < 1) {
     return JSON.stringify({
@@ -14682,20 +14752,20 @@ function countSessionKnowledgeEntries(entries, sessionStart, fallbackCount) {
 async function copyDirRecursiveWithFailures(src, dest) {
   let count = 0;
   const failures = [];
-  const entries = await fs11.readdir(src);
-  await fs11.mkdir(dest, { recursive: true });
+  const entries = await fs10.readdir(src);
+  await fs10.mkdir(dest, { recursive: true });
   for (const entry of entries) {
-    const srcEntry = path27.join(src, entry);
-    const destEntry = path27.join(dest, entry);
+    const srcEntry = path28.join(src, entry);
+    const destEntry = path28.join(dest, entry);
     try {
-      const stat4 = await fs11.stat(srcEntry);
+      const stat4 = await fs10.stat(srcEntry);
       if (stat4.isDirectory()) {
         const subResult = await copyDirRecursiveWithFailures(srcEntry, destEntry);
         count += subResult.copied;
         failures.push(...subResult.failures);
       } else {
         try {
-          await fs11.copyFile(srcEntry, destEntry);
+          await fs10.copyFile(srcEntry, destEntry);
           count++;
         } catch (err) {
           const errno = err?.code;
@@ -14871,20 +14941,20 @@ async function runFinalizeStage(ctx) {
       ctx.warnings.push(`Session retrospective write threw: ${retroError instanceof Error ? retroError.message : String(retroError)}`);
     }
   }
-  const lessonsFilePath = path27.join(ctx.swarmDir, "close-lessons.md");
+  const lessonsFilePath = path28.join(ctx.swarmDir, "close-lessons.md");
   try {
-    const lessonsText = await fs11.readFile(lessonsFilePath, "utf-8");
+    const lessonsText = await fs10.readFile(lessonsFilePath, "utf-8");
     ctx.explicitLessons = lessonsText.split(`
 `).map((line) => line.trim()).filter((line) => line.length > 0 && !line.startsWith("#"));
   } catch {}
   try {
-    const evidenceDir = path27.join(ctx.swarmDir, "evidence");
-    const evidenceEntries = await fs11.readdir(evidenceDir);
+    const evidenceDir = path28.join(ctx.swarmDir, "evidence");
+    const evidenceEntries = await fs10.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 = path27.join(evidenceDir, retroDir, "evidence.json");
+      const evidencePath = path28.join(evidenceDir, retroDir, "evidence.json");
       try {
-        const content = await fs11.readFile(evidencePath, "utf-8");
+        const content = await fs10.readFile(evidencePath, "utf-8");
         const parsed = JSON.parse(content);
         const entries = parsed.entries ?? [parsed];
         for (const entry of entries) {
@@ -14928,7 +14998,7 @@ async function runFinalizeStage(ctx) {
     console.warn("[close-command] curateAndStoreSwarm error:", error2);
   }
   if (ctx.curationSucceeded && ctx.allLessons.length > 0) {
-    await fs11.unlink(lessonsFilePath).catch(() => {});
+    await fs10.unlink(lessonsFilePath).catch(() => {});
   }
   if (ctx.curationSucceeded) {
     if (ctx.config.hive_enabled === false) {} else {
@@ -15066,7 +15136,7 @@ async function copySqliteSafe(srcPath, destPath) {
   let checkpointVerified = false;
   try {
     const result = spawnSync2("sqlite3", [srcPath, "PRAGMA wal_checkpoint(TRUNCATE);"], {
-      cwd: path27.dirname(srcPath),
+      cwd: path28.dirname(srcPath),
       encoding: "utf-8",
       stdio: ["ignore", "pipe", "pipe"],
       timeout: 1e4,
@@ -15077,7 +15147,7 @@ async function copySqliteSafe(srcPath, destPath) {
       const code = result.error.code;
       if (code === "ENOENT") {
         try {
-          await fs11.copyFile(srcPath, destPath);
+          await fs10.copyFile(srcPath, destPath);
           return {
             success: true,
             reason: "copied without WAL checkpoint (sqlite3 CLI unavailable)"
@@ -15116,7 +15186,7 @@ async function copySqliteSafe(srcPath, destPath) {
     };
   }
   try {
-    await fs11.copyFile(srcPath, destPath);
+    await fs10.copyFile(srcPath, destPath);
     if (checkpointVerified) {
       return { success: true };
     }
@@ -15134,9 +15204,9 @@ 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 = path27.join(ctx.swarmDir, "archive", `swarm-${ctx.timestamp}-${ctx.archiveSuffix}`);
+  ctx.archiveDir = path28.join(ctx.swarmDir, "archive", `swarm-${ctx.timestamp}-${ctx.archiveSuffix}`);
   try {
-    await fs11.mkdir(ctx.archiveDir, { recursive: true });
+    await fs10.mkdir(ctx.archiveDir, { recursive: true });
     const WAL_SIDECAR_FILES = new Set(["swarm.db-shm", "swarm.db-wal"]);
     const linkedKnowledgeShared = isLinked(ctx.directory);
     if (linkedKnowledgeShared) {
@@ -15149,8 +15219,8 @@ async function runArchiveStage(ctx) {
       if (linkedKnowledgeShared && KNOWLEDGE_FAMILY_ARTIFACTS.has(artifact)) {
         continue;
       }
-      const srcPath = path27.join(ctx.swarmDir, artifact);
-      const destPath = path27.join(ctx.archiveDir, artifact);
+      const srcPath = path28.join(ctx.swarmDir, artifact);
+      const destPath = path28.join(ctx.archiveDir, artifact);
       if (artifact === "swarm.db") {
         const result = await copySqliteSafe(srcPath, destPath);
         if (result.skipped) {} else if (result.success) {
@@ -15166,7 +15236,7 @@ async function runArchiveStage(ctx) {
         }
       } else {
         try {
-          await fs11.copyFile(srcPath, destPath);
+          await fs10.copyFile(srcPath, destPath);
           ctx.archivedFileCount++;
           if (ACTIVE_STATE_TO_CLEAN.includes(artifact)) {
             ctx.archivedActiveStateFiles.add(artifact);
@@ -15181,12 +15251,12 @@ async function runArchiveStage(ctx) {
         }
       }
     }
-    const dynamicArchiveArtifacts = (await fs11.readdir(ctx.swarmDir).catch(() => [])).filter((name) => /^post-mortem-[^/\\]+\.md$/.test(name) || /^drift-report-phase-\d+\.json$/.test(name));
+    const dynamicArchiveArtifacts = (await fs10.readdir(ctx.swarmDir).catch(() => [])).filter((name) => /^post-mortem-[^/\\]+\.md$/.test(name) || /^drift-report-phase-\d+\.json$/.test(name));
     for (const artifact of dynamicArchiveArtifacts) {
-      const srcPath = path27.join(ctx.swarmDir, artifact);
-      const destPath = path27.join(ctx.archiveDir, artifact);
+      const srcPath = path28.join(ctx.swarmDir, artifact);
+      const destPath = path28.join(ctx.archiveDir, artifact);
       try {
-        await fs11.copyFile(srcPath, destPath);
+        await fs10.copyFile(srcPath, destPath);
         ctx.archivedFileCount++;
         ctx.archivedActiveStateFiles.add(artifact);
       } catch (err) {
@@ -15199,8 +15269,8 @@ async function runArchiveStage(ctx) {
       }
     }
     for (const dirName of ACTIVE_STATE_DIRS_TO_CLEAN) {
-      const srcDir = path27.join(ctx.swarmDir, dirName);
-      const destDir = path27.join(ctx.archiveDir, dirName);
+      const srcDir = path28.join(ctx.swarmDir, dirName);
+      const destDir = path28.join(ctx.archiveDir, dirName);
       try {
         const result = await copyDirRecursiveWithFailures(srcDir, destDir);
         ctx.archivedFileCount += result.copied;
@@ -15277,9 +15347,9 @@ 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 = path27.join(ctx.swarmDir, artifact);
+      const filePath = path28.join(ctx.swarmDir, artifact);
       try {
-        await fs11.unlink(filePath);
+        await fs10.unlink(filePath);
         cleanedFiles.push(artifact);
       } catch (err) {
         const errno = err?.code;
@@ -15297,7 +15367,7 @@ async function runCleanStage(ctx) {
       continue;
     }
     try {
-      await fs11.unlink(path27.join(ctx.swarmDir, artifact));
+      await fs10.unlink(path28.join(ctx.swarmDir, artifact));
       cleanedFiles.push(artifact);
     } catch (err) {
       const errno = err?.code;
@@ -15311,18 +15381,18 @@ async function runCleanStage(ctx) {
     if (!ctx.archivedActiveStateDirs.has(dirName)) {
       continue;
     }
-    const dirPath = path27.join(ctx.swarmDir, dirName);
+    const dirPath = path28.join(ctx.swarmDir, dirName);
     try {
-      await fs11.rm(dirPath, { recursive: true, force: true });
+      await fs10.rm(dirPath, { recursive: true, force: true });
       cleanedFiles.push(`${dirName}/`);
     } catch {}
   }
   try {
-    const swarmFiles = await fs11.readdir(ctx.swarmDir);
+    const swarmFiles = await fs10.readdir(ctx.swarmDir);
     const configBackups = swarmFiles.filter((f) => f.startsWith("config-backup-") && f.endsWith(".json"));
     for (const backup of configBackups) {
       try {
-        await fs11.unlink(path27.join(ctx.swarmDir, backup));
+        await fs10.unlink(path28.join(ctx.swarmDir, backup));
         configBackupsRemoved++;
       } catch (err) {
         const errno = err?.code;
@@ -15335,7 +15405,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 fs11.unlink(path27.join(ctx.swarmDir, sibling));
+        await fs10.unlink(path28.join(ctx.swarmDir, sibling));
       } catch (err) {
         const errno = err?.code;
         if (errno === "ENOENT") {} else {
@@ -15353,16 +15423,16 @@ async function runCleanStage(ctx) {
   }
   let swarmPlanFilesRemoved = 0;
   const candidates = [
-    path27.join(ctx.directory, ".swarm", "plan-export", "SWARM_PLAN.json"),
-    path27.join(ctx.directory, ".swarm", "plan-export", "SWARM_PLAN.md"),
-    path27.join(ctx.directory, ".swarm", "SWARM_PLAN.json"),
-    path27.join(ctx.directory, ".swarm", "SWARM_PLAN.md"),
-    path27.join(ctx.directory, "SWARM_PLAN.json"),
-    path27.join(ctx.directory, "SWARM_PLAN.md")
+    path28.join(ctx.directory, ".swarm", "plan-export", "SWARM_PLAN.json"),
+    path28.join(ctx.directory, ".swarm", "plan-export", "SWARM_PLAN.md"),
+    path28.join(ctx.directory, ".swarm", "SWARM_PLAN.json"),
+    path28.join(ctx.directory, ".swarm", "SWARM_PLAN.md"),
+    path28.join(ctx.directory, "SWARM_PLAN.json"),
+    path28.join(ctx.directory, "SWARM_PLAN.md")
   ];
   for (const candidate of candidates) {
     try {
-      await fs11.unlink(candidate);
+      await fs10.unlink(candidate);
       swarmPlanFilesRemoved++;
     } catch (err) {
       if (err?.code !== "ENOENT") {
@@ -15372,11 +15442,11 @@ async function runCleanStage(ctx) {
   }
   let tmpFilesRemoved = 0;
   try {
-    const swarmFiles = await fs11.readdir(ctx.swarmDir);
+    const swarmFiles = await fs10.readdir(ctx.swarmDir);
     const tmpFiles = swarmFiles.filter((f) => f.startsWith(".tmp."));
     for (const tmp of tmpFiles) {
       try {
-        await fs11.unlink(path27.join(ctx.swarmDir, tmp));
+        await fs10.unlink(path28.join(ctx.swarmDir, tmp));
         tmpFilesRemoved++;
       } catch (err) {
         const errno = err?.code;
@@ -15398,7 +15468,7 @@ async function runCleanStage(ctx) {
   }
   for (const terminalFile of TERMINAL_STATE_FILES) {
     try {
-      await fs11.unlink(path27.join(ctx.swarmDir, terminalFile));
+      await fs10.unlink(path28.join(ctx.swarmDir, terminalFile));
       if (!cleanedFiles.includes(terminalFile)) {
         cleanedFiles.push(terminalFile);
       }
@@ -15411,7 +15481,7 @@ async function runCleanStage(ctx) {
     }
   }
   clearAllScopes(ctx.directory);
-  const contextPath = path27.join(ctx.swarmDir, "context.md");
+  const contextPath = path28.join(ctx.swarmDir, "context.md");
   const contextContent = [
     "# Context",
     "",
@@ -15423,9 +15493,9 @@ async function runCleanStage(ctx) {
     ""
   ].join(`
 `);
-  const contextTempPath = path27.join(path27.dirname(contextPath), `${path27.basename(contextPath)}.tmp.${Date.now()}.${Math.floor(Math.random() * 1e9)}`);
+  const contextTempPath = path28.join(path28.dirname(contextPath), `${path28.basename(contextPath)}.tmp.${Date.now()}.${Math.floor(Math.random() * 1e9)}`);
   try {
-    await fs11.writeFile(contextTempPath, contextContent, "utf-8");
+    await fs10.writeFile(contextTempPath, contextContent, "utf-8");
     fsSync.renameSync(contextTempPath, contextPath);
   } catch (error2) {
     try {
@@ -15487,7 +15557,7 @@ async function runAlignStage(ctx) {
   return { gitAlignResult, prunedBranches };
 }
 async function handleCloseCommand(directory, args, options = {}) {
-  const swarmDir = path27.join(directory, ".swarm");
+  const swarmDir = path28.join(directory, ".swarm");
   try {
     const stat4 = fsSync.lstatSync(swarmDir);
     if (stat4.isSymbolicLink()) {
@@ -15501,18 +15571,18 @@ async function handleCloseCommand(directory, args, options = {}) {
   const planPath = validateSwarmPath(directory, "plan.json");
   let planExists = false;
   let planData = {
-    title: path27.basename(directory) || "Ad-hoc session",
+    title: path28.basename(directory) || "Ad-hoc session",
     phases: []
   };
   try {
-    const content = await fs11.readFile(planPath, "utf-8");
+    const content = await fs10.readFile(planPath, "utf-8");
     planData = JSON.parse(content);
     planExists = true;
   } catch (error2) {
     if (error2?.code !== "ENOENT") {
       return `\u274C Failed to read plan.json: ${error2 instanceof Error ? error2.message : String(error2)}`;
     }
-    const swarmDirExists = await fs11.access(swarmDir).then(() => true).catch(() => false);
+    const swarmDirExists = await fs10.access(swarmDir).then(() => true).catch(() => false);
     if (!swarmDirExists) {
       return `\u274C No .swarm/ directory found in ${directory}. Run /swarm close from the project root, or run /swarm plan first.`;
     }
@@ -15526,15 +15596,15 @@ async function handleCloseCommand(directory, args, options = {}) {
   }
   try {
     if (!planExists) {
-      const archiveDir = path27.join(swarmDir, "archive");
+      const archiveDir = path28.join(swarmDir, "archive");
       try {
-        const archiveEntries = await fs11.readdir(archiveDir);
+        const archiveEntries = await fs10.readdir(archiveDir);
         const hasArchiveBundle = archiveEntries.some((entry) => entry.startsWith("swarm-"));
         if (hasArchiveBundle) {
           const hasActiveState = [
             ...ACTIVE_STATE_TO_CLEAN,
             ...ACTIVE_STATE_DIRS_TO_CLEAN
-          ].some((entry) => fsSync.existsSync(path27.join(swarmDir, entry)));
+          ].some((entry) => fsSync.existsSync(path28.join(swarmDir, entry)));
           if (!hasActiveState) {
             return `\u2705 Already finalized \u2014 nothing to do.
 
@@ -15662,9 +15732,9 @@ 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 = path27.join(path27.dirname(closeSummaryPath), `${path27.basename(closeSummaryPath)}.tmp.${Date.now()}.${Math.floor(Math.random() * 1e9)}`);
+    const closeSummaryTempPath = path28.join(path28.dirname(closeSummaryPath), `${path28.basename(closeSummaryPath)}.tmp.${Date.now()}.${Math.floor(Math.random() * 1e9)}`);
     try {
-      await fs11.writeFile(closeSummaryTempPath, summaryContent, "utf-8");
+      await fs10.writeFile(closeSummaryTempPath, summaryContent, "utf-8");
       fsSync.renameSync(closeSummaryTempPath, closeSummaryPath);
     } catch (error2) {
       try {
@@ -16006,14 +16076,14 @@ function buildStatusMessage(session, plan) {
 
 // src/commands/config.ts
 import * as os6 from "os";
-import * as path28 from "path";
+import * as path29 from "path";
 function getUserConfigDir2() {
-  return process.env.XDG_CONFIG_HOME || path28.join(os6.homedir(), ".config");
+  return process.env.XDG_CONFIG_HOME || path29.join(os6.homedir(), ".config");
 }
 async function handleConfigCommand(directory, _args) {
   const config = loadPluginConfig(directory);
-  const userConfigPath = path28.join(getUserConfigDir2(), "opencode", "opencode-swarm.json");
-  const projectConfigPath = path28.join(directory, ".opencode", "opencode-swarm.json");
+  const userConfigPath = path29.join(getUserConfigDir2(), "opencode", "opencode-swarm.json");
+  const projectConfigPath = path29.join(directory, ".opencode", "opencode-swarm.json");
   const lines = [
     "## Swarm Configuration",
     "",
@@ -16031,9 +16101,9 @@ async function handleConfigCommand(directory, _args) {
 }
 
 // src/services/skill-consolidation.ts
-import { existsSync as existsSync18 } from "fs";
-import { mkdir as mkdir9, readFile as readFile9, rename as rename6, writeFile as writeFile10 } from "fs/promises";
-import * as path29 from "path";
+import { existsSync as existsSync19 } from "fs";
+import { mkdir as mkdir9, readFile as readFile10, rename as rename7, writeFile as writeFile11 } from "fs/promises";
+import * as path30 from "path";
 
 // src/utils/timeout.ts
 async function withTimeout(promise, ms, timeoutError) {
@@ -16058,14 +16128,14 @@ var DEFAULT_CONSOLIDATION_MAX_CALLS_PER_RUN = 1;
 var CONSOLIDATION_RUN_TIMEOUT_MS = 5 * 60 * 1000;
 var runningByDirectory = new Map;
 function consolidationStatePath(directory) {
-  return path29.join(directory, ".swarm", "skill-improver", "consolidation-state.json");
+  return path30.join(directory, ".swarm", "skill-improver", "consolidation-state.json");
 }
 async function readState2(directory) {
   const filePath = consolidationStatePath(directory);
-  if (!existsSync18(filePath))
+  if (!existsSync19(filePath))
     return {};
   try {
-    const parsed = JSON.parse(await readFile9(filePath, "utf-8"));
+    const parsed = JSON.parse(await readFile10(filePath, "utf-8"));
     if (!parsed || typeof parsed !== "object")
       return {};
     return parsed;
@@ -16074,10 +16144,10 @@ async function readState2(directory) {
   }
 }
 async function atomicWrite2(filePath, content) {
-  await mkdir9(path29.dirname(filePath), { recursive: true });
+  await mkdir9(path30.dirname(filePath), { recursive: true });
   const tmp = `${filePath}.tmp-${process.pid}-${Date.now()}`;
-  await writeFile10(tmp, content, "utf-8");
-  await rename6(tmp, filePath);
+  await writeFile11(tmp, content, "utf-8");
+  await rename7(tmp, filePath);
 }
 async function writeState2(directory, state) {
   await atomicWrite2(consolidationStatePath(directory), `${JSON.stringify(state, null, 2)}
@@ -16154,7 +16224,7 @@ async function runSkillConsolidationInner(req) {
   };
 }
 async function runSkillConsolidation(req) {
-  const key = path29.resolve(req.directory);
+  const key = path30.resolve(req.directory);
   const existing = runningByDirectory.get(key);
   if (existing) {
     return {
@@ -16355,8 +16425,8 @@ async function handleCouncilCommand(_directory, args) {
 
 // src/commands/coupling.ts
 import { randomBytes } from "crypto";
-import * as fs12 from "fs";
-import * as path31 from "path";
+import * as fs11 from "fs";
+import * as path32 from "path";
 
 // src/turbo/epic/cochange-source.ts
 import * as child_process3 from "child_process";
@@ -16364,9 +16434,9 @@ import { promisify as promisify2 } from "util";
 
 // src/tools/co-change-analyzer.ts
 import * as child_process2 from "child_process";
-import { randomUUID as randomUUID5 } from "crypto";
-import { readdir as readdir2, readFile as readFile10, stat as stat4 } from "fs/promises";
-import * as path30 from "path";
+import { randomUUID as randomUUID6 } from "crypto";
+import { readdir as readdir2, readFile as readFile11, stat as stat4 } from "fs/promises";
+import * as path31 from "path";
 import { promisify } from "util";
 function getExecFileAsync() {
   return promisify(child_process2.execFile);
@@ -16470,7 +16540,7 @@ async function scanSourceFiles(dir) {
   try {
     const entries = await readdir2(dir, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = path30.join(dir, entry.name);
+      const fullPath = path31.join(dir, entry.name);
       if (entry.isDirectory()) {
         if (skipDirs.has(entry.name)) {
           continue;
@@ -16478,7 +16548,7 @@ async function scanSourceFiles(dir) {
         const subFiles = await scanSourceFiles(fullPath);
         results.push(...subFiles);
       } else if (entry.isFile()) {
-        const ext = path30.extname(entry.name);
+        const ext = path31.extname(entry.name);
         if ([".ts", ".tsx", ".js", ".jsx", ".mjs"].includes(ext)) {
           results.push(fullPath);
         }
@@ -16492,7 +16562,7 @@ async function getStaticEdges(directory) {
   const sourceFiles = await scanSourceFiles(directory);
   for (const sourceFile of sourceFiles) {
     try {
-      const content = await readFile10(sourceFile, "utf-8");
+      const content = await readFile11(sourceFile, "utf-8");
       const importRegex = /(?:import|require)\s*(?:\(?\s*['"`]|.*?from\s+['"`])([^'"`]+)['"`]/g;
       for (let match = importRegex.exec(content);match !== null; match = importRegex.exec(content)) {
         const importPath = match[1].trim();
@@ -16500,8 +16570,8 @@ async function getStaticEdges(directory) {
           continue;
         }
         try {
-          const sourceDir = path30.dirname(sourceFile);
-          const resolvedPath = path30.resolve(sourceDir, importPath);
+          const sourceDir = path31.dirname(sourceFile);
+          const resolvedPath = path31.resolve(sourceDir, importPath);
           const extensions = [
             "",
             ".ts",
@@ -16526,8 +16596,8 @@ async function getStaticEdges(directory) {
           if (!targetFile) {
             continue;
           }
-          const relSource = path30.relative(directory, sourceFile).replace(/\\/g, "/");
-          const relTarget = path30.relative(directory, targetFile).replace(/\\/g, "/");
+          const relSource = path31.relative(directory, sourceFile).replace(/\\/g, "/");
+          const relTarget = path31.relative(directory, targetFile).replace(/\\/g, "/");
           const [key] = relSource < relTarget ? [`${relSource}::${relTarget}`, relSource, relTarget] : [`${relTarget}::${relSource}`, relTarget, relSource];
           edges.add(key);
         } catch {}
@@ -16539,7 +16609,7 @@ async function getStaticEdges(directory) {
 function isTestImplementationPair(fileA, fileB) {
   const testPatterns = [".test.ts", ".test.js", ".spec.ts", ".spec.js"];
   const getBaseName = (filePath) => {
-    const base = path30.basename(filePath);
+    const base = path31.basename(filePath);
     for (const pattern of testPatterns) {
       if (base.endsWith(pattern)) {
         return base.slice(0, -pattern.length);
@@ -16549,16 +16619,16 @@ function isTestImplementationPair(fileA, fileB) {
   };
   const baseA = getBaseName(fileA);
   const baseB = getBaseName(fileB);
-  return baseA === baseB && baseA !== path30.basename(fileA) && baseA !== path30.basename(fileB);
+  return baseA === baseB && baseA !== path31.basename(fileA) && baseA !== path31.basename(fileB);
 }
 function hasSharedPrefix(fileA, fileB) {
-  const dirA = path30.dirname(fileA);
-  const dirB = path30.dirname(fileB);
+  const dirA = path31.dirname(fileA);
+  const dirB = path31.dirname(fileB);
   if (dirA !== dirB) {
     return false;
   }
-  const baseA = path30.basename(fileA).replace(/\.(ts|js|tsx|jsx|mjs)$/, "");
-  const baseB = path30.basename(fileB).replace(/\.(ts|js|tsx|jsx|mjs)$/, "");
+  const baseA = path31.basename(fileA).replace(/\.(ts|js|tsx|jsx|mjs)$/, "");
+  const baseB = path31.basename(fileB).replace(/\.(ts|js|tsx|jsx|mjs)$/, "");
   if (baseA.startsWith(baseB) || baseB.startsWith(baseA)) {
     return true;
   }
@@ -16613,8 +16683,8 @@ function darkMatterToKnowledgeEntries(pairs, projectName) {
   const entries = [];
   const now = new Date().toISOString();
   for (const pair of pairs.slice(0, 10)) {
-    const baseA = path30.basename(pair.fileA);
-    const baseB = path30.basename(pair.fileB);
+    const baseA = path31.basename(pair.fileA);
+    const baseB = path31.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.`;
@@ -16627,7 +16697,7 @@ function darkMatterToKnowledgeEntries(pairs, projectName) {
     }
     const confidence = Math.min(0.3 + 0.2 * Math.min(pair.coChangeCount / 10, 1), 0.5);
     entries.push({
-      id: randomUUID5(),
+      id: randomUUID6(),
       tier: "swarm",
       lesson,
       category: "architecture",
@@ -17040,17 +17110,17 @@ function parseArgs3(args) {
   return parsed;
 }
 function persistReportJson(directory, report) {
-  const epicDir = path31.join(directory, ".swarm", "epic");
-  fs12.mkdirSync(epicDir, { recursive: true });
-  const filePath = path31.join(epicDir, "coupling-report.json");
+  const epicDir = path32.join(directory, ".swarm", "epic");
+  fs11.mkdirSync(epicDir, { recursive: true });
+  const filePath = path32.join(epicDir, "coupling-report.json");
   const tmpPath = `${filePath}.tmp.${randomBytes(8).toString("hex")}`;
-  fs12.writeFileSync(tmpPath, `${JSON.stringify(report, null, 2)}
+  fs11.writeFileSync(tmpPath, `${JSON.stringify(report, null, 2)}
 `, "utf-8");
   try {
-    fs12.renameSync(tmpPath, filePath);
+    fs11.renameSync(tmpPath, filePath);
   } catch (err) {
     try {
-      fs12.unlinkSync(tmpPath);
+      fs11.unlinkSync(tmpPath);
     } catch {}
     throw err;
   }
@@ -17101,7 +17171,7 @@ Usage: /swarm coupling [--phase <n>] [--threshold <-1..1>] [--min-co-changes <n>
       persistStatus = {
         requested: true,
         written: true,
-        path: path31.relative(directory, writtenAt)
+        path: path32.relative(directory, writtenAt).replace(/\\/g, "/")
       };
     } catch (err) {
       persistStatus = {
@@ -17140,8 +17210,8 @@ var _internals22 = {
   loadCuratorDeps: async () => {
     const [{ CuratorConfigSchema }, curator, { createCuratorLLMDelegate: createCuratorLLMDelegate2 }] = await Promise.all([
       import("./schema-vw2ffhe9.js"),
-      import("./curator-np2ky29t.js"),
-      import("./curator-llm-factory-gdhtm1hh.js")
+      import("./curator-1nr4qszq.js"),
+      import("./curator-llm-factory-x9tk7e6m.js")
     ]);
     return { CuratorConfigSchema, curator, createCuratorLLMDelegate: createCuratorLLMDelegate2 };
   }
@@ -17233,7 +17303,7 @@ function formatCurationSummary(summary) {
 }
 
 // src/commands/dark-matter.ts
-import path32 from "path";
+import path33 from "path";
 async function handleDarkMatterCommand(directory, args) {
   const options = {};
   for (let i = 0;i < args.length; i++) {
@@ -17265,7 +17335,7 @@ Ensure this is a git repository with commit history.`;
   const output = formatDarkMatterOutput(pairs);
   if (pairs.length > 0) {
     try {
-      const projectName = path32.basename(path32.resolve(directory));
+      const projectName = path33.basename(path33.resolve(directory));
       const entries = darkMatterToKnowledgeEntries(pairs, projectName);
       if (entries.length > 0) {
         const knowledgePath = resolveSwarmKnowledgePath(directory);
@@ -17631,13 +17701,13 @@ ${USAGE5}`;
 
 // src/services/diagnose-service.ts
 import * as child_process4 from "child_process";
-import { existsSync as existsSync21, readdirSync as readdirSync4, readFileSync as readFileSync11, statSync as statSync7 } from "fs";
-import path37 from "path";
+import { existsSync as existsSync22, readdirSync as readdirSync4, readFileSync as readFileSync11, statSync as statSync7 } from "fs";
+import * as path38 from "path";
 import { fileURLToPath } from "url";
 // package.json
 var package_default = {
   name: "opencode-swarm",
-  version: "7.107.1",
+  version: "7.107.3",
   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",
@@ -17745,44 +17815,44 @@ var package_default = {
 
 // src/config/cache-paths.ts
 import * as os7 from "os";
-import * as path33 from "path";
+import * as path34 from "path";
 function getPluginConfigDir() {
-  return path33.join(process.env.XDG_CONFIG_HOME || path33.join(os7.homedir(), ".config"), "opencode");
+  return path34.join(process.env.XDG_CONFIG_HOME || path34.join(os7.homedir(), ".config"), "opencode");
 }
 function getPluginCachePaths() {
-  const cacheBase = process.env.XDG_CACHE_HOME || path33.join(os7.homedir(), ".cache");
+  const cacheBase = process.env.XDG_CACHE_HOME || path34.join(os7.homedir(), ".cache");
   const configDir = getPluginConfigDir();
   const paths = [
-    path33.join(cacheBase, "opencode", "node_modules", "opencode-swarm"),
-    path33.join(cacheBase, "opencode", "packages", "opencode-swarm@latest"),
-    path33.join(configDir, "node_modules", "opencode-swarm")
+    path34.join(cacheBase, "opencode", "node_modules", "opencode-swarm"),
+    path34.join(cacheBase, "opencode", "packages", "opencode-swarm@latest"),
+    path34.join(configDir, "node_modules", "opencode-swarm")
   ];
   if (process.platform === "darwin") {
-    const libCaches = path33.join(os7.homedir(), "Library", "Caches");
-    paths.push(path33.join(libCaches, "opencode", "node_modules", "opencode-swarm"), path33.join(libCaches, "opencode", "packages", "opencode-swarm@latest"));
+    const libCaches = path34.join(os7.homedir(), "Library", "Caches");
+    paths.push(path34.join(libCaches, "opencode", "node_modules", "opencode-swarm"), path34.join(libCaches, "opencode", "packages", "opencode-swarm@latest"));
   }
   if (process.platform === "win32") {
-    const localAppData = process.env.LOCALAPPDATA || path33.join(os7.homedir(), "AppData", "Local");
-    const appData = process.env.APPDATA || path33.join(os7.homedir(), "AppData", "Roaming");
-    paths.push(path33.join(localAppData, "opencode", "node_modules", "opencode-swarm"), path33.join(localAppData, "opencode", "packages", "opencode-swarm@latest"), path33.join(appData, "opencode", "node_modules", "opencode-swarm"));
+    const localAppData = process.env.LOCALAPPDATA || path34.join(os7.homedir(), "AppData", "Local");
+    const appData = process.env.APPDATA || path34.join(os7.homedir(), "AppData", "Roaming");
+    paths.push(path34.join(localAppData, "opencode", "node_modules", "opencode-swarm"), path34.join(localAppData, "opencode", "packages", "opencode-swarm@latest"), path34.join(appData, "opencode", "node_modules", "opencode-swarm"));
   }
   return paths;
 }
 function getPluginLockFilePaths() {
-  const cacheBase = process.env.XDG_CACHE_HOME || path33.join(os7.homedir(), ".cache");
+  const cacheBase = process.env.XDG_CACHE_HOME || path34.join(os7.homedir(), ".cache");
   const configDir = getPluginConfigDir();
   const paths = [
-    path33.join(cacheBase, "opencode", "bun.lock"),
-    path33.join(cacheBase, "opencode", "bun.lockb"),
-    path33.join(configDir, "package-lock.json")
+    path34.join(cacheBase, "opencode", "bun.lock"),
+    path34.join(cacheBase, "opencode", "bun.lockb"),
+    path34.join(configDir, "package-lock.json")
   ];
   if (process.platform === "darwin") {
-    const libCaches = path33.join(os7.homedir(), "Library", "Caches");
-    paths.push(path33.join(libCaches, "opencode", "bun.lock"), path33.join(libCaches, "opencode", "bun.lockb"));
+    const libCaches = path34.join(os7.homedir(), "Library", "Caches");
+    paths.push(path34.join(libCaches, "opencode", "bun.lock"), path34.join(libCaches, "opencode", "bun.lockb"));
   }
   if (process.platform === "win32") {
-    const localAppData = process.env.LOCALAPPDATA || path33.join(os7.homedir(), "AppData", "Local");
-    paths.push(path33.join(localAppData, "opencode", "bun.lock"), path33.join(localAppData, "opencode", "bun.lockb"));
+    const localAppData = process.env.LOCALAPPDATA || path34.join(os7.homedir(), "AppData", "Local");
+    paths.push(path34.join(localAppData, "opencode", "bun.lock"), path34.join(localAppData, "opencode", "bun.lockb"));
   }
   return paths;
 }
@@ -17792,11 +17862,11 @@ init_capability_probe();
 init_executor();
 
 // src/services/knowledge-diagnostics.ts
-import { existsSync as existsSync20 } from "fs";
-import { readFile as readFile11 } from "fs/promises";
+import { existsSync as existsSync21 } from "fs";
+import { readFile as readFile12 } from "fs/promises";
 
 // src/services/version-check.ts
-import { existsSync as existsSync19, mkdirSync as mkdirSync13, readFileSync as readFileSync10, writeFileSync as writeFileSync8 } from "fs";
+import { existsSync as existsSync20, mkdirSync as mkdirSync13, readFileSync as readFileSync10, writeFileSync as writeFileSync8 } from "fs";
 import { homedir as homedir6 } from "os";
 import { join as join32 } from "path";
 var CHECK_INTERVAL_MS = 24 * 60 * 60 * 1000;
@@ -17812,10 +17882,10 @@ function cacheFile() {
 }
 function readVersionCache() {
   try {
-    const path37 = cacheFile();
-    if (!existsSync19(path37))
+    const path38 = cacheFile();
+    if (!existsSync20(path38))
       return null;
-    const raw = readFileSync10(path37, "utf-8");
+    const raw = readFileSync10(path38, "utf-8");
     const parsed = JSON.parse(raw);
     if (typeof parsed?.checkedAt !== "number")
       return null;
@@ -17867,9 +17937,9 @@ var SEVEN_DAYS_MS2 = 7 * 24 * 60 * 60 * 1000;
 var UNACTIONABLE_BACKLOG_WARN = 100;
 var INSIGHT_BACKLOG_WARN = 50;
 async function readRawLines(filePath) {
-  if (!existsSync20(filePath))
+  if (!existsSync21(filePath))
     return { entries: [], corrupt: 0 };
-  const content = await readFile11(filePath, "utf-8");
+  const content = await readFile12(filePath, "utf-8");
   const entries = [];
   let corrupt = 0;
   for (const line of content.split(`
@@ -17992,10 +18062,10 @@ async function computeKnowledgeDebug(directory) {
   };
 }
 async function safeJsonlCount(filePath) {
-  if (!filePath || !existsSync20(filePath))
+  if (!filePath || !existsSync21(filePath))
     return 0;
   try {
-    const content = await readFile11(filePath, "utf-8");
+    const content = await readFile12(filePath, "utf-8");
     let n = 0;
     for (const line of content.split(`
 `)) {
@@ -18070,8 +18140,8 @@ var REQUIRED_CACHE_GRAMMAR_ASSETS = [
   "tree-sitter-typescript.wasm"
 ];
 function resolveCachePackageRoot(cachePath) {
-  const nestedPackageRoot = path37.join(cachePath, "node_modules", "opencode-swarm");
-  return existsSync21(nestedPackageRoot) ? nestedPackageRoot : cachePath;
+  const nestedPackageRoot = path38.join(cachePath, "node_modules", "opencode-swarm");
+  return existsSync22(nestedPackageRoot) ? nestedPackageRoot : cachePath;
 }
 var _internals26 = {
   detectSandboxCapability: () => sandboxCapabilityProbe.detect(),
@@ -18322,7 +18392,7 @@ async function checkConfigBackups(directory) {
 }
 async function checkGitRepository(directory) {
   try {
-    if (!existsSync21(directory) || !statSync7(directory).isDirectory()) {
+    if (!existsSync22(directory) || !statSync7(directory).isDirectory()) {
       return {
         name: "Git Repository",
         status: "\u274C",
@@ -18386,8 +18456,8 @@ async function checkSpecStaleness(directory, plan) {
   };
 }
 async function checkConfigParseability(directory) {
-  const configPath = path37.join(directory, ".opencode/opencode-swarm.json");
-  if (!existsSync21(configPath)) {
+  const configPath = path38.join(directory, ".opencode/opencode-swarm.json");
+  if (!existsSync22(configPath)) {
     return {
       name: "Config Parseability",
       status: "\u2705",
@@ -18415,7 +18485,7 @@ function resolveGrammarDir(thisDir) {
   const normalized = thisDir.replace(/\\/g, "/");
   const isSource = normalized.endsWith("/src/services");
   const isCliBundle = normalized.endsWith("/cli");
-  return isSource || isCliBundle ? path37.join(thisDir, "..", "lang", "grammars") : path37.join(thisDir, "lang", "grammars");
+  return isSource || isCliBundle ? path38.join(thisDir, "..", "lang", "grammars") : path38.join(thisDir, "lang", "grammars");
 }
 async function checkGrammarWasmFiles() {
   const grammarFiles = [
@@ -18439,14 +18509,14 @@ async function checkGrammarWasmFiles() {
     "tree-sitter-ini.wasm",
     "tree-sitter-regex.wasm"
   ];
-  const thisDir = path37.dirname(fileURLToPath(import.meta.url));
+  const thisDir = path38.dirname(fileURLToPath(import.meta.url));
   const grammarDir = resolveGrammarDir(thisDir);
   const missing = [];
-  if (!existsSync21(path37.join(grammarDir, "tree-sitter.wasm"))) {
+  if (!existsSync22(path38.join(grammarDir, "tree-sitter.wasm"))) {
     missing.push("tree-sitter.wasm (core runtime)");
   }
   for (const file of grammarFiles) {
-    if (!existsSync21(path37.join(grammarDir, file))) {
+    if (!existsSync22(path38.join(grammarDir, file))) {
       missing.push(file);
     }
   }
@@ -18464,8 +18534,8 @@ async function checkGrammarWasmFiles() {
   };
 }
 async function checkCheckpointManifest(directory) {
-  const manifestPath = path37.join(directory, ".swarm/checkpoints.json");
-  if (!existsSync21(manifestPath)) {
+  const manifestPath = path38.join(directory, ".swarm/checkpoints.json");
+  if (!existsSync22(manifestPath)) {
     return {
       name: "Checkpoint Manifest",
       status: "\u2705",
@@ -18516,8 +18586,8 @@ async function checkCheckpointManifest(directory) {
   }
 }
 async function checkEventStreamIntegrity(directory) {
-  const eventsPath = path37.join(directory, ".swarm/events.jsonl");
-  if (!existsSync21(eventsPath)) {
+  const eventsPath = path38.join(directory, ".swarm/events.jsonl");
+  if (!existsSync22(eventsPath)) {
     return {
       name: "Event Stream",
       status: "\u2705",
@@ -18557,8 +18627,8 @@ async function checkEventStreamIntegrity(directory) {
   }
 }
 async function checkSteeringDirectives(directory) {
-  const eventsPath = path37.join(directory, ".swarm/events.jsonl");
-  if (!existsSync21(eventsPath)) {
+  const eventsPath = path38.join(directory, ".swarm/events.jsonl");
+  if (!existsSync22(eventsPath)) {
     return {
       name: "Steering Directives",
       status: "\u2705",
@@ -18613,8 +18683,8 @@ async function checkCurator(directory) {
         detail: "Disabled (enable via curator.enabled)"
       };
     }
-    const summaryPath = path37.join(directory, ".swarm/curator-summary.json");
-    if (!existsSync21(summaryPath)) {
+    const summaryPath = path38.join(directory, ".swarm/curator-summary.json");
+    if (!existsSync22(summaryPath)) {
       return {
         name: "Curator",
         status: "\u2705",
@@ -18815,8 +18885,8 @@ async function getDiagnoseData(directory) {
   checks.push(await checkCurator(directory));
   checks.push(await checkKnowledgeHealth(directory));
   try {
-    const evidenceDir = path37.join(directory, ".swarm", "evidence");
-    const snapshotFiles = existsSync21(evidenceDir) ? readdirSync4(evidenceDir).filter((f) => f.startsWith("agent-tools-") && f.endsWith(".json")) : [];
+    const evidenceDir = path38.join(directory, ".swarm", "evidence");
+    const snapshotFiles = existsSync22(evidenceDir) ? readdirSync4(evidenceDir).filter((f) => f.startsWith("agent-tools-") && f.endsWith(".json")) : [];
     if (snapshotFiles.length > 0) {
       const latest = snapshotFiles.sort().pop();
       checks.push({
@@ -18849,14 +18919,14 @@ async function getDiagnoseData(directory) {
   const cacheRows = [];
   for (const cachePath of cachePaths) {
     try {
-      if (!existsSync21(cachePath)) {
+      if (!existsSync22(cachePath)) {
         cacheRows.push(`\u2B1C ${cachePath} \u2014 absent`);
         continue;
       }
       const packageRoot = resolveCachePackageRoot(cachePath);
       const cacheLabel = packageRoot === cachePath ? cachePath : `${cachePath} -> ${packageRoot}`;
-      const missingGrammarAssets = REQUIRED_CACHE_GRAMMAR_ASSETS.filter((file) => !existsSync21(path37.join(packageRoot, "dist", "lang", "grammars", file)));
-      const pkgJsonPath = path37.join(packageRoot, "package.json");
+      const missingGrammarAssets = REQUIRED_CACHE_GRAMMAR_ASSETS.filter((file) => !existsSync22(path38.join(packageRoot, "dist", "lang", "grammars", file)));
+      const pkgJsonPath = path38.join(packageRoot, "package.json");
       try {
         const raw = readFileSync11(pkgJsonPath, "utf-8");
         const parsed = JSON.parse(raw);
@@ -19231,10 +19301,10 @@ function decideEpicActivation(tasks, cochangePairs, commitsObserved, options) {
 
 // src/turbo/epic/calibration.ts
 init_logger();
-import * as fs14 from "fs";
-import * as path38 from "path";
+import * as fs13 from "fs";
+import * as path39 from "path";
 var STATE_FILE = "calibration.json";
-var STATE_REL_DIR = path38.join(".swarm", "epic");
+var STATE_REL_DIR = path39.join(".swarm", "epic");
 function nowISO() {
   return new Date().toISOString();
 }
@@ -19256,13 +19326,13 @@ function markUnreadable(directory, reason) {
   error(`[epic/calibration] state file unreadable for ${directory}: ${reason} \u2014 failing closed`);
 }
 function repairCalibrationUnreadable(directory) {
-  const filePath = path38.join(directory, STATE_REL_DIR, STATE_FILE);
-  if (!fs14.existsSync(filePath)) {
+  const filePath = path39.join(directory, STATE_REL_DIR, STATE_FILE);
+  if (!fs13.existsSync(filePath)) {
     stateUnreadableMap.delete(directory);
     return;
   }
   try {
-    const raw = fs14.readFileSync(filePath, "utf-8");
+    const raw = fs13.readFileSync(filePath, "utf-8");
     const parsed = JSON.parse(raw);
     if (!isValidCalibrationShape(parsed)) {
       stateUnreadableMap.set(directory, true);
@@ -19288,9 +19358,9 @@ function isValidCalibrationShape(candidate) {
   return true;
 }
 function ensureSwarmEpicDir(directory) {
-  const dir = path38.resolve(directory, STATE_REL_DIR);
-  if (!fs14.existsSync(dir)) {
-    fs14.mkdirSync(dir, { recursive: true });
+  const dir = path39.resolve(directory, STATE_REL_DIR);
+  if (!fs13.existsSync(dir)) {
+    fs13.mkdirSync(dir, { recursive: true });
   }
   return dir;
 }
@@ -19300,18 +19370,18 @@ function loadCalibrationState(directory) {
     if (stateUnreadableMap.get(directory))
       return null;
   }
-  const filePath = path38.join(directory, STATE_REL_DIR, STATE_FILE);
+  const filePath = path39.join(directory, STATE_REL_DIR, STATE_FILE);
   try {
-    if (!fs14.existsSync(filePath)) {
+    if (!fs13.existsSync(filePath)) {
       const seed = emptyCalibrationState();
       try {
         ensureSwarmEpicDir(directory);
-        fs14.writeFileSync(filePath, `${JSON.stringify(seed, null, 2)}
+        fs13.writeFileSync(filePath, `${JSON.stringify(seed, null, 2)}
 `, "utf-8");
       } catch {}
       return seed;
     }
-    const raw = fs14.readFileSync(filePath, "utf-8");
+    const raw = fs13.readFileSync(filePath, "utf-8");
     const parsed = JSON.parse(raw);
     if (!isValidCalibrationShape(parsed)) {
       markUnreadable(directory, `malformed shape (version=${parsed?.version}, hotModuleAdditions type=${Array.isArray(parsed?.hotModuleAdditions) ? "array" : typeof parsed?.hotModuleAdditions})`);
@@ -19326,36 +19396,36 @@ function loadCalibrationState(directory) {
 
 // src/turbo/epic/divergence-recorder.ts
 init_logger();
-import * as fs15 from "fs";
-import * as path39 from "path";
-var EVIDENCE_REL_DIR = path39.join(".swarm", "epic");
+import * as fs14 from "fs";
+import * as path40 from "path";
+var EVIDENCE_REL_DIR = path40.join(".swarm", "epic");
 var EVIDENCE_FILE = "divergence.jsonl";
 var MAX_TAIL_BYTES2 = 16 * 1024 * 1024;
 function readDivergenceHistory(directory, options) {
-  const filePath = path39.join(directory, EVIDENCE_REL_DIR, EVIDENCE_FILE);
-  if (!fs15.existsSync(filePath)) {
+  const filePath = path40.join(directory, EVIDENCE_REL_DIR, EVIDENCE_FILE);
+  if (!fs14.existsSync(filePath)) {
     return [];
   }
   const maxBytes = options?.maxBytes ?? MAX_TAIL_BYTES2;
   let raw;
   let tailTruncated = false;
   try {
-    const stat5 = fs15.statSync(filePath);
+    const stat5 = fs14.statSync(filePath);
     if (Number.isFinite(maxBytes) && stat5.size > maxBytes) {
-      const fd = fs15.openSync(filePath, "r");
+      const fd = fs14.openSync(filePath, "r");
       try {
         const buf = Buffer.alloc(maxBytes);
         const offset = stat5.size - maxBytes;
-        fs15.readSync(fd, buf, 0, maxBytes, offset);
+        fs14.readSync(fd, buf, 0, maxBytes, offset);
         raw = buf.toString("utf-8");
         tailTruncated = true;
       } finally {
         try {
-          fs15.closeSync(fd);
+          fs14.closeSync(fd);
         } catch {}
       }
     } else {
-      raw = fs15.readFileSync(filePath, "utf-8");
+      raw = fs14.readFileSync(filePath, "utf-8");
     }
   } catch {
     return [];
@@ -19380,16 +19450,16 @@ function readDivergenceHistory(directory, options) {
 }
 
 // src/turbo/epic/promotion-evidence.ts
-import * as fs16 from "fs";
-import * as path40 from "path";
-var EVIDENCE_REL_DIR2 = path40.join(".swarm", "evidence");
+import * as fs15 from "fs";
+import * as path41 from "path";
+var EVIDENCE_REL_DIR2 = path41.join(".swarm", "evidence");
 var EVIDENCE_FILE2 = "epic-promotions.jsonl";
 function readPromotionEvidence(directory) {
-  const filePath = path40.join(directory, EVIDENCE_REL_DIR2, EVIDENCE_FILE2);
-  if (!fs16.existsSync(filePath)) {
+  const filePath = path41.join(directory, EVIDENCE_REL_DIR2, EVIDENCE_FILE2);
+  if (!fs15.existsSync(filePath)) {
     return [];
   }
-  const raw = fs16.readFileSync(filePath, "utf-8");
+  const raw = fs15.readFileSync(filePath, "utf-8");
   const lines = raw.split(`
 `).filter((l) => l.trim().length > 0);
   const records = [];
@@ -19894,7 +19964,7 @@ async function handleEvidenceCommand(directory, args) {
   return formatTaskEvidenceMarkdown(evidenceData);
 }
 async function handleEvidenceSummaryCommand(directory) {
-  const { buildEvidenceSummary } = await import("./evidence-summary-service-dh44gevz.js");
+  const { buildEvidenceSummary } = await import("./evidence-summary-service-9r28ds8t.js");
   const artifact = await buildEvidenceSummary(directory);
   if (!artifact) {
     return "No plan found. Run `/swarm plan` to check plan status.";
@@ -19958,8 +20028,8 @@ async function handleExportCommand(directory, _args) {
 }
 // src/full-auto/state.ts
 var import_proper_lockfile4 = __toESM(require_proper_lockfile(), 1);
-import * as fs17 from "fs";
-import * as path41 from "path";
+import * as fs16 from "fs";
+import * as path42 from "path";
 init_logger();
 var lockfile4 = import_proper_lockfile4.default;
 var STATE_FILE2 = "full-auto-state.json";
@@ -19967,9 +20037,9 @@ function nowISO2() {
   return new Date().toISOString();
 }
 function ensureSwarmDir(directory) {
-  const swarmDir = path41.resolve(directory, ".swarm");
-  if (!fs17.existsSync(swarmDir)) {
-    fs17.mkdirSync(swarmDir, { recursive: true });
+  const swarmDir = path42.resolve(directory, ".swarm");
+  if (!fs16.existsSync(swarmDir)) {
+    fs16.mkdirSync(swarmDir, { recursive: true });
   }
   return swarmDir;
 }
@@ -20027,7 +20097,7 @@ function withStateLock(directory, fn) {
   let release;
   try {
     const lockTarget = validateSwarmPath(directory, STATE_FILE2);
-    if (!fs17.existsSync(lockTarget)) {
+    if (!fs16.existsSync(lockTarget)) {
       ensureSwarmDir(directory);
       const seed = {
         version: 2,
@@ -20035,7 +20105,7 @@ function withStateLock(directory, fn) {
         oversightSequence: 0,
         sessions: {}
       };
-      fs17.writeFileSync(lockTarget, `${JSON.stringify(seed, null, 2)}
+      fs16.writeFileSync(lockTarget, `${JSON.stringify(seed, null, 2)}
 `, "utf-8");
     }
     release = lockfile4.lockSync(lockTarget, {
@@ -20085,7 +20155,7 @@ function readPersisted(directory) {
     const filePath = validateSwarmPath(directory, STATE_FILE2);
     let stats;
     try {
-      stats = fs17.statSync(filePath);
+      stats = fs16.statSync(filePath);
     } catch {
       clearStateUnreadable();
       readCache.delete(filePath);
@@ -20096,7 +20166,7 @@ function readPersisted(directory) {
       clearStateUnreadable();
       return structuredClone(cached.state);
     }
-    const raw = fs17.readFileSync(filePath, "utf-8");
+    const raw = fs16.readFileSync(filePath, "utf-8");
     const parsed = JSON.parse(raw);
     if (!parsed || typeof parsed !== "object" || Array.isArray(parsed) || parsed.version !== 2 || !parsed.sessions || typeof parsed.sessions !== "object" || Array.isArray(parsed.sessions)) {
       markStateUnreadable(`malformed shape (version=${parsed?.version}, sessions type=${Array.isArray(parsed?.sessions) ? "array" : typeof parsed?.sessions})`);
@@ -20121,8 +20191,8 @@ function readPersisted(directory) {
     error(`[full-auto/state] Failed to read ${STATE_FILE2}: ${reason} \u2014 attempting .bak recovery`);
     try {
       const bakPath = validateSwarmPath(directory, `${STATE_FILE2}.bak`);
-      if (fs17.existsSync(bakPath)) {
-        const raw = fs17.readFileSync(bakPath, "utf-8");
+      if (fs16.existsSync(bakPath)) {
+        const raw = fs16.readFileSync(bakPath, "utf-8");
         const parsed = JSON.parse(raw);
         if (parsed?.version === 2 && parsed.sessions && !Array.isArray(parsed.sessions)) {
           warn(`[full-auto/state] Recovered from ${STATE_FILE2}.bak`);
@@ -20162,23 +20232,23 @@ function writePersisted(directory, persisted) {
     throw new Error(`Full-Auto state persistence prepare failed: ${msg}`);
   }
   try {
-    if (fs17.existsSync(filePath)) {
-      fs17.copyFileSync(filePath, bakPath);
+    if (fs16.existsSync(filePath)) {
+      fs16.copyFileSync(filePath, bakPath);
     }
   } catch {}
   try {
-    fs17.writeFileSync(tmpPath, payload, "utf-8");
+    fs16.writeFileSync(tmpPath, payload, "utf-8");
     try {
-      const fd = fs17.openSync(tmpPath, "r+");
+      const fd = fs16.openSync(tmpPath, "r+");
       try {
-        fs17.fsyncSync(fd);
+        fs16.fsyncSync(fd);
       } finally {
-        fs17.closeSync(fd);
+        fs16.closeSync(fd);
       }
     } catch {}
-    fs17.renameSync(tmpPath, filePath);
+    fs16.renameSync(tmpPath, filePath);
     readCache.delete(filePath);
-    const readback = fs17.readFileSync(filePath, "utf-8");
+    const readback = fs16.readFileSync(filePath, "utf-8");
     const parsed = JSON.parse(readback);
     if (parsed?.version !== 2) {
       throw new Error("Round-trip readback returned wrong version");
@@ -20779,7 +20849,7 @@ var _internals29 = {
 
 // src/session/snapshot-writer.ts
 import { closeSync as closeSync6, fsyncSync as fsyncSync2, mkdirSync as mkdirSync18, openSync as openSync6, renameSync as renameSync9 } from "fs";
-import * as path42 from "path";
+import * as path43 from "path";
 var _writeInFlight = Promise.resolve();
 function serializeAgentSession(s) {
   const gateLog = {};
@@ -20832,6 +20902,12 @@ function serializeAgentSession(s) {
     lastCoderDelegationTaskId: s.lastCoderDelegationTaskId ?? null,
     currentTaskId: s.currentTaskId ?? null,
     turboMode: s.turboMode ?? false,
+    ...s.turboStrategy !== undefined && { turboStrategy: s.turboStrategy },
+    leanTurboActive: s.leanTurboActive ?? false,
+    ...s.leanTurboCurrentPhase !== undefined && {
+      leanTurboCurrentPhase: s.leanTurboCurrentPhase
+    },
+    epicModeActive: s.epicModeActive ?? false,
     gateLog,
     reviewerCallCount,
     lastGateFailure: s.lastGateFailure ?? null,
@@ -20886,7 +20962,7 @@ async function writeSnapshot(directory, state) {
     }
     const content = JSON.stringify(snapshot, null, 2);
     const resolvedPath = validateSwarmPath(directory, "session/state.json");
-    const dir = path42.dirname(resolvedPath);
+    const dir = path43.dirname(resolvedPath);
     mkdirSync18(dir, { recursive: true });
     const tempPath = `${resolvedPath}.tmp.${Date.now()}.${Math.random().toString(36).slice(2)}`;
     await bunWrite(tempPath, content);
@@ -20922,13 +20998,21 @@ var _internals30 = {
 };
 
 // src/commands/handoff.ts
-async function handleHandoffCommand(directory, _args) {
+var HANDOFF_SOURCE_SESSION_PREFIX = "<!-- opencode-swarm-handoff-source-session:";
+function formatSessionScopedHandoffMarkdown(markdown, sessionID) {
+  if (!sessionID) {
+    return markdown;
+  }
+  return `${HANDOFF_SOURCE_SESSION_PREFIX} ${encodeURIComponent(sessionID)} -->
+${markdown}`;
+}
+async function handleHandoffCommand(directory, _args, sessionID) {
   const handoffData = await getHandoffData(directory);
   const markdown = formatHandoffMarkdown(handoffData);
   try {
     const resolvedPath = validateSwarmPath(directory, "handoff.md");
     const tempPath = `${resolvedPath}.tmp.${crypto4.randomUUID()}`;
-    await bunWrite(tempPath, markdown);
+    await bunWrite(tempPath, formatSessionScopedHandoffMarkdown(markdown, sessionID));
     try {
       renameSync10(tempPath, resolvedPath);
     } catch (renameErr) {
@@ -21389,23 +21473,23 @@ ${USAGE6}`;
 }
 
 // src/commands/knowledge.ts
-import { join as join37 } from "path";
+import { join as join38 } from "path";
 
 // src/hooks/knowledge-migrator.ts
 init_logger();
-import { randomUUID as randomUUID7 } from "crypto";
-import { existsSync as existsSync26, readFileSync as readFileSync16 } from "fs";
-import { mkdir as mkdir10, readFile as readFile12, writeFile as writeFile11 } from "fs/promises";
+import { randomUUID as randomUUID8 } from "crypto";
+import { existsSync as existsSync27, readFileSync as readFileSync16 } from "fs";
+import { mkdir as mkdir10, readFile as readFile13, writeFile as writeFile12 } from "fs/promises";
 import * as os11 from "os";
-import * as path43 from "path";
+import * as path44 from "path";
 
 // src/hooks/knowledge-types.ts
 var KNOWLEDGE_SCHEMA_VERSION = 2;
 
 // src/hooks/knowledge-migrator.ts
 async function migrateKnowledgeToExternal(_directory, _config) {
-  const externalSentinelPath = path43.join(_directory, ".swarm", ".knowledge-external-migrated");
-  const contextPath = path43.join(_directory, ".swarm", "context.md");
+  const externalSentinelPath = path44.join(_directory, ".swarm", ".knowledge-external-migrated");
+  const contextPath = path44.join(_directory, ".swarm", "context.md");
   if (_internals32.existsSync(externalSentinelPath)) {
     return {
       migrated: false,
@@ -21463,17 +21547,17 @@ var _internals32 = {
   inferProjectName,
   writeSentinel,
   resolveLegacyHiveKnowledgePath,
-  existsSync: existsSync26,
+  existsSync: existsSync27,
   readFileSync: readFileSync16,
-  readFile: readFile12,
+  readFile: readFile13,
   mkdir: mkdir10,
-  writeFile: writeFile11
+  writeFile: writeFile12
 };
 async function migrateContextToKnowledge(directory, config) {
-  const sentinelPath = path43.join(directory, ".swarm", ".knowledge-migrated");
-  const contextPath = path43.join(directory, ".swarm", "context.md");
+  const sentinelPath = path44.join(directory, ".swarm", ".knowledge-migrated");
+  const contextPath = path44.join(directory, ".swarm", "context.md");
   const knowledgePath = resolveSwarmKnowledgePath(directory);
-  if (existsSync26(sentinelPath)) {
+  if (existsSync27(sentinelPath)) {
     return {
       migrated: false,
       entriesMigrated: 0,
@@ -21482,7 +21566,7 @@ async function migrateContextToKnowledge(directory, config) {
       skippedReason: "sentinel-exists"
     };
   }
-  if (!existsSync26(contextPath)) {
+  if (!existsSync27(contextPath)) {
     return {
       migrated: false,
       entriesMigrated: 0,
@@ -21491,7 +21575,7 @@ async function migrateContextToKnowledge(directory, config) {
       skippedReason: "no-context-file"
     };
   }
-  const contextContent = await readFile12(contextPath, "utf-8");
+  const contextContent = await readFile13(contextPath, "utf-8");
   if (contextContent.trim().length === 0) {
     return {
       migrated: false,
@@ -21535,7 +21619,7 @@ async function migrateContextToKnowledge(directory, config) {
     }
     const inferredTags = inferTags(raw.text);
     const entry = {
-      id: randomUUID7(),
+      id: randomUUID8(),
       tier: "swarm",
       lesson: _internals32.truncateLesson(raw.text),
       category: raw.categoryHint ?? _internals32.inferCategoryFromText(raw.text),
@@ -21573,8 +21657,8 @@ async function migrateContextToKnowledge(directory, config) {
 async function migrateHiveKnowledgeLegacy(config) {
   const legacyHivePath = _internals32.resolveLegacyHiveKnowledgePath();
   const canonicalHivePath = resolveHiveKnowledgePath();
-  const sentinelPath = path43.join(path43.dirname(canonicalHivePath), ".hive-knowledge-migrated");
-  if (existsSync26(sentinelPath)) {
+  const sentinelPath = path44.join(path44.dirname(canonicalHivePath), ".hive-knowledge-migrated");
+  if (existsSync27(sentinelPath)) {
     return {
       migrated: false,
       entriesMigrated: 0,
@@ -21583,7 +21667,7 @@ async function migrateHiveKnowledgeLegacy(config) {
       skippedReason: "sentinel-exists"
     };
   }
-  if (!existsSync26(legacyHivePath)) {
+  if (!existsSync27(legacyHivePath)) {
     return {
       migrated: false,
       entriesMigrated: 0,
@@ -21635,7 +21719,7 @@ async function migrateHiveKnowledgeLegacy(config) {
       const scopeTag = legacyEntry.scope_tag || "global";
       const legacyId = legacyEntry.id;
       const existingIds = new Set(existingHiveEntries.map((e) => e.id));
-      const resolvedId = legacyId && existingIds.has(legacyId) ? randomUUID7() : legacyId || randomUUID7();
+      const resolvedId = legacyId && existingIds.has(legacyId) ? randomUUID8() : legacyId || randomUUID8();
       if (legacyId && existingIds.has(legacyId)) {
         warn(`[knowledge-migrator] Legacy entry ID collision for "${legacyId}", generating new UUID`);
       }
@@ -21784,8 +21868,8 @@ function truncateLesson2(text) {
   return `${text.slice(0, 277)}...`;
 }
 function inferProjectName(directory) {
-  const packageJsonPath = path43.join(directory, "package.json");
-  if (existsSync26(packageJsonPath)) {
+  const packageJsonPath = path44.join(directory, "package.json");
+  if (existsSync27(packageJsonPath)) {
     try {
       const pkg = JSON.parse(readFileSync16(packageJsonPath, "utf-8"));
       if (pkg.name && typeof pkg.name === "string") {
@@ -21793,7 +21877,7 @@ function inferProjectName(directory) {
       }
     } catch {}
   }
-  return path43.basename(directory);
+  return path44.basename(directory);
 }
 async function writeSentinel(sentinelPath, migrated, dropped) {
   const sentinel = {
@@ -21805,7 +21889,7 @@ async function writeSentinel(sentinelPath, migrated, dropped) {
     schema_version: 1,
     migration_tool: "knowledge-migrator.ts"
   };
-  await _internals32.mkdir(path43.dirname(sentinelPath), { recursive: true });
+  await _internals32.mkdir(path44.dirname(sentinelPath), { recursive: true });
   await _internals32.writeFile(sentinelPath, JSON.stringify(sentinel, null, 2), "utf-8");
 }
 function resolveLegacyHiveKnowledgePath() {
@@ -21813,13 +21897,13 @@ function resolveLegacyHiveKnowledgePath() {
   const home = process.env.HOME || os11.homedir();
   let dataDir;
   if (platform === "win32") {
-    dataDir = path43.join(process.env.LOCALAPPDATA || path43.join(home, "AppData", "Local"), "opencode-swarm", "Data");
+    dataDir = path44.join(process.env.LOCALAPPDATA || path44.join(home, "AppData", "Local"), "opencode-swarm", "Data");
   } else if (platform === "darwin") {
-    dataDir = path43.join(home, "Library", "Application Support", "opencode-swarm");
+    dataDir = path44.join(home, "Library", "Application Support", "opencode-swarm");
   } else {
-    dataDir = path43.join(process.env.XDG_DATA_HOME || path43.join(home, ".local", "share"), "opencode-swarm");
+    dataDir = path44.join(process.env.XDG_DATA_HOME || path44.join(home, ".local", "share"), "opencode-swarm");
   }
-  return path43.join(dataDir, "hive-knowledge.jsonl");
+  return path44.join(dataDir, "hive-knowledge.jsonl");
 }
 
 // src/commands/knowledge.ts
@@ -21873,7 +21957,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) {
@@ -22124,15 +22208,15 @@ var _internals33 = {
 };
 
 // src/commands/link.ts
-import { existsSync as existsSync27 } from "fs";
-import * as path45 from "path";
+import { existsSync as existsSync28 } from "fs";
+import * as path46 from "path";
 
 // src/knowledge/identity.ts
 import * as child_process5 from "child_process";
 import { createHash as createHash5 } from "crypto";
-import * as path44 from "path";
+import * as path45 from "path";
 function deriveProjectHash(directory) {
-  const absolutePath = path44.resolve(directory);
+  const absolutePath = path45.resolve(directory);
   let hashInput;
   try {
     const remoteUrl = child_process5.execSync("git remote get-url origin", {
@@ -22152,9 +22236,9 @@ function deriveProjectHash(directory) {
 // src/commands/link.ts
 var DEDUP_THRESHOLD = 0.6;
 async function mergeLocalKnowledgeIntoLink(localSwarmDir, linkDir) {
-  const localPath = path45.join(localSwarmDir, "knowledge.jsonl");
-  const sharedPath = path45.join(linkDir, "knowledge.jsonl");
-  if (!existsSync27(localPath))
+  const localPath = path46.join(localSwarmDir, "knowledge.jsonl");
+  const sharedPath = path46.join(linkDir, "knowledge.jsonl");
+  if (!existsSync28(localPath))
     return { merged: 0, skipped: 0 };
   let merged = 0;
   let skipped = 0;
@@ -22251,7 +22335,7 @@ ${formatStatus(directory)}`;
   const linkDir = resolveLinkDir(linkId);
   let merge;
   try {
-    merge = await mergeLocalKnowledgeIntoLink(path45.join(directory, ".swarm"), linkDir);
+    merge = await mergeLocalKnowledgeIntoLink(path46.join(directory, ".swarm"), linkDir);
   } catch (error2) {
     return `\u274C Failed to merge local knowledge into the link store: ${error2 instanceof Error ? error2.message : String(error2)}`;
   }
@@ -22447,13 +22531,13 @@ ${USAGE7}`;
 }
 
 // src/commands/memory.ts
-import { existsSync as existsSync28 } from "fs";
-import * as path48 from "path";
+import { existsSync as existsSync29 } from "fs";
+import * as path49 from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 // src/memory/evaluation.ts
-import * as fs18 from "fs/promises";
+import * as fs17 from "fs/promises";
 import * as os12 from "os";
-import * as path46 from "path";
+import * as path47 from "path";
 var DEFAULT_PROVIDERS = [
   "local-jsonl",
   "sqlite"
@@ -22465,7 +22549,7 @@ var DEFAULT_MODES = [
 ];
 var DEFAULT_TIMESTAMP = "2026-05-26T12:00:00.000Z";
 async function evaluateMemoryRecallFixtures(options) {
-  const fixtureDirectory = path46.resolve(options.fixtureDirectory);
+  const fixtureDirectory = path47.resolve(options.fixtureDirectory);
   const providers = options.providers ?? DEFAULT_PROVIDERS;
   const modes = options.modes ?? DEFAULT_MODES;
   const generatedAt = new Date().toISOString();
@@ -22474,7 +22558,7 @@ async function evaluateMemoryRecallFixtures(options) {
   for (const fixture of fixtures) {
     const materialized = materializeFixture(fixture);
     for (const providerName of providers) {
-      const tempRoot = await fs18.realpath(await fs18.mkdtemp(path46.join(os12.tmpdir(), "swarm-memory-eval-")));
+      const tempRoot = await fs17.realpath(await fs17.mkdtemp(path47.join(os12.tmpdir(), "swarm-memory-eval-")));
       const provider = createEvaluationProvider(providerName, tempRoot);
       try {
         await provider.initialize?.();
@@ -22517,7 +22601,7 @@ async function evaluateMemoryRecallFixtures(options) {
 async function rmTempRoot(tempRoot) {
   for (let attempt = 0;attempt < 10; attempt++) {
     try {
-      await fs18.rm(tempRoot, { recursive: true, force: true });
+      await fs17.rm(tempRoot, { recursive: true, force: true });
       return;
     } catch (err) {
       if (attempt === 9)
@@ -22527,11 +22611,11 @@ async function rmTempRoot(tempRoot) {
   }
 }
 async function loadRecallEvaluationFixtures(fixtureDirectory) {
-  const entries = await fs18.readdir(fixtureDirectory, { withFileTypes: true });
+  const entries = await fs17.readdir(fixtureDirectory, { withFileTypes: true });
   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 fs18.readFile(path46.join(fixtureDirectory, file), "utf-8");
+    const raw = await fs17.readFile(path47.join(fixtureDirectory, file), "utf-8");
     fixtures.push(validateFixture(JSON.parse(raw), file));
   }
   return fixtures;
@@ -22807,14 +22891,14 @@ var CuratorOutputMemoryDecisionSchema = exports_external.object({
   curatorMemoryDecisions: exports_external.array(CuratorMemoryDecisionSchema).max(20).optional()
 }).passthrough();
 // src/memory/consolidation-log.ts
-import { appendFile as appendFile3, mkdir as mkdir11, readFile as readFile14 } from "fs/promises";
-import * as path47 from "path";
-var LOG_RELATIVE_PATH = path47.join("memory", "consolidation-log.jsonl");
+import { appendFile as appendFile3, mkdir as mkdir11, readFile as readFile15 } from "fs/promises";
+import * as path48 from "path";
+var LOG_RELATIVE_PATH = path48.join("memory", "consolidation-log.jsonl");
 async function readConsolidationLog(directory) {
   const filePath = validateSwarmPath(directory, LOG_RELATIVE_PATH);
   let raw;
   try {
-    raw = await readFile14(filePath, "utf-8");
+    raw = await readFile15(filePath, "utf-8");
   } catch {
     return [];
   }
@@ -22832,7 +22916,7 @@ async function readConsolidationLog(directory) {
 }
 
 // src/commands/memory.ts
-var PACKAGE_ROOT = path48.resolve(resolvePackageRootFromModule(fileURLToPath2(import.meta.url)));
+var PACKAGE_ROOT = path49.resolve(resolvePackageRootFromModule(fileURLToPath2(import.meta.url)));
 async function handleMemoryCommand(_directory, _args) {
   return [
     "## Swarm Memory",
@@ -22891,7 +22975,7 @@ async function handleMemoryStatusCommand(directory, _args) {
     `- Provider: \`${config.provider}\``,
     `- Storage: \`${storageDir}\``,
     `- SQLite path: \`${sqlitePath}\``,
-    `- SQLite database exists: \`${existsSync28(sqlitePath)}\``,
+    `- SQLite database exists: \`${existsSync29(sqlitePath)}\``,
     `- Automatic destructive cleanup: \`disabled\``,
     "",
     "### Legacy JSONL"
@@ -23189,7 +23273,7 @@ function resolveCommandMemoryConfig(directory) {
 }
 function parseEvaluateArgs(directory, args) {
   let json = false;
-  let fixtureDirectory = path48.join(PACKAGE_ROOT, "tests", "fixtures", "memory-recall");
+  let fixtureDirectory = path49.join(PACKAGE_ROOT, "tests", "fixtures", "memory-recall");
   for (let i = 0;i < args.length; i++) {
     const arg = args[i];
     if (arg === "--json") {
@@ -23203,10 +23287,10 @@ function parseEvaluateArgs(directory, args) {
           error: "Usage: /swarm memory evaluate [--json] [--fixtures <directory>]"
         };
       }
-      const resolvedFixtures = path48.resolve(directory, next);
-      const canonical = path48.normalize(resolvedFixtures) + path48.sep;
-      const allowedRootA = path48.normalize(directory) + path48.sep;
-      const allowedRootB = path48.normalize(path48.join(PACKAGE_ROOT, "tests", "fixtures", "memory-recall")) + path48.sep;
+      const resolvedFixtures = path49.resolve(directory, next);
+      const canonical = path49.normalize(resolvedFixtures) + path49.sep;
+      const allowedRootA = path49.normalize(directory) + path49.sep;
+      const allowedRootB = path49.normalize(path49.join(PACKAGE_ROOT, "tests", "fixtures", "memory-recall")) + path49.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"
@@ -23245,15 +23329,15 @@ function parseMaintenanceArgs(args, options) {
   return { limit, confirm };
 }
 function resolvePackageRootFromModule(modulePath) {
-  const moduleDir = path48.dirname(modulePath);
-  const leaf = path48.basename(moduleDir);
+  const moduleDir = path49.dirname(modulePath);
+  const leaf = path49.basename(moduleDir);
   if (leaf === "commands" || leaf === "cli") {
-    return path48.resolve(moduleDir, "..", "..");
+    return path49.resolve(moduleDir, "..", "..");
   }
   if (leaf === "dist") {
-    return path48.resolve(moduleDir, "..");
+    return path49.resolve(moduleDir, "..");
   }
-  return path48.resolve(moduleDir, "..");
+  return path49.resolve(moduleDir, "..");
 }
 function formatMigrationResult(label, report) {
   if (!report) {
@@ -23987,12 +24071,12 @@ var _internals39 = {
 };
 
 // src/services/preflight-service.ts
-import * as fs25 from "fs";
-import * as path55 from "path";
+import * as fs24 from "fs";
+import * as path56 from "path";
 
 // src/tools/lint.ts
-import * as fs19 from "fs";
-import * as path49 from "path";
+import * as fs18 from "fs";
+import * as path50 from "path";
 
 // src/utils/path-security.ts
 function containsPathTraversal(str) {
@@ -24048,9 +24132,9 @@ function validateArgs(args) {
 }
 function getLinterCommand(linter, mode, projectDir) {
   const isWindows = process.platform === "win32";
-  const binDir = path49.join(projectDir, "node_modules", ".bin");
-  const biomeBin = isWindows ? path49.join(binDir, "biome.EXE") : path49.join(binDir, "biome");
-  const eslintBin = isWindows ? path49.join(binDir, "eslint.cmd") : path49.join(binDir, "eslint");
+  const binDir = path50.join(projectDir, "node_modules", ".bin");
+  const biomeBin = isWindows ? path50.join(binDir, "biome.EXE") : path50.join(binDir, "biome");
+  const eslintBin = isWindows ? path50.join(binDir, "eslint.cmd") : path50.join(binDir, "eslint");
   switch (linter) {
     case "biome":
       if (mode === "fix") {
@@ -24066,7 +24150,7 @@ function getLinterCommand(linter, mode, projectDir) {
 }
 function getAdditionalLinterCommand(linter, mode, cwd) {
   const gradlewName = process.platform === "win32" ? "gradlew.bat" : "gradlew";
-  const gradlew = fs19.existsSync(path49.join(cwd, gradlewName)) ? path49.join(cwd, gradlewName) : null;
+  const gradlew = fs18.existsSync(path50.join(cwd, gradlewName)) ? path50.join(cwd, gradlewName) : null;
   switch (linter) {
     case "ruff":
       return mode === "fix" ? ["ruff", "check", "--fix", "."] : ["ruff", "check", "."];
@@ -24100,12 +24184,12 @@ function getAdditionalLinterCommand(linter, mode, cwd) {
   }
 }
 function detectRuff(cwd) {
-  if (fs19.existsSync(path49.join(cwd, "ruff.toml")))
+  if (fs18.existsSync(path50.join(cwd, "ruff.toml")))
     return isCommandAvailable("ruff");
   try {
-    const pyproject = path49.join(cwd, "pyproject.toml");
-    if (fs19.existsSync(pyproject)) {
-      const content = fs19.readFileSync(pyproject, "utf-8");
+    const pyproject = path50.join(cwd, "pyproject.toml");
+    if (fs18.existsSync(pyproject)) {
+      const content = fs18.readFileSync(pyproject, "utf-8");
       if (content.includes("[tool.ruff]"))
         return isCommandAvailable("ruff");
     }
@@ -24113,21 +24197,21 @@ function detectRuff(cwd) {
   return false;
 }
 function detectClippy(cwd) {
-  return fs19.existsSync(path49.join(cwd, "Cargo.toml")) && isCommandAvailable("cargo");
+  return fs18.existsSync(path50.join(cwd, "Cargo.toml")) && isCommandAvailable("cargo");
 }
 function detectGolangciLint(cwd) {
-  return fs19.existsSync(path49.join(cwd, "go.mod")) && isCommandAvailable("golangci-lint");
+  return fs18.existsSync(path50.join(cwd, "go.mod")) && isCommandAvailable("golangci-lint");
 }
 function detectCheckstyle(cwd) {
-  const hasMaven = fs19.existsSync(path49.join(cwd, "pom.xml"));
-  const hasGradle = fs19.existsSync(path49.join(cwd, "build.gradle")) || fs19.existsSync(path49.join(cwd, "build.gradle.kts"));
-  const hasBinary = hasMaven && isCommandAvailable("mvn") || hasGradle && (fs19.existsSync(path49.join(cwd, "gradlew")) || isCommandAvailable("gradle"));
+  const hasMaven = fs18.existsSync(path50.join(cwd, "pom.xml"));
+  const hasGradle = fs18.existsSync(path50.join(cwd, "build.gradle")) || fs18.existsSync(path50.join(cwd, "build.gradle.kts"));
+  const hasBinary = hasMaven && isCommandAvailable("mvn") || hasGradle && (fs18.existsSync(path50.join(cwd, "gradlew")) || isCommandAvailable("gradle"));
   return (hasMaven || hasGradle) && hasBinary;
 }
 function detectKtlint(cwd) {
-  const hasKotlin = fs19.existsSync(path49.join(cwd, "build.gradle.kts")) || fs19.existsSync(path49.join(cwd, "build.gradle")) || (() => {
+  const hasKotlin = fs18.existsSync(path50.join(cwd, "build.gradle.kts")) || fs18.existsSync(path50.join(cwd, "build.gradle")) || (() => {
     try {
-      return fs19.readdirSync(cwd).some((f) => f.endsWith(".kt") || f.endsWith(".kts"));
+      return fs18.readdirSync(cwd).some((f) => f.endsWith(".kt") || f.endsWith(".kts"));
     } catch {
       return false;
     }
@@ -24136,7 +24220,7 @@ function detectKtlint(cwd) {
 }
 function detectDotnetFormat(cwd) {
   try {
-    const files = fs19.readdirSync(cwd);
+    const files = fs18.readdirSync(cwd);
     const hasCsproj = files.some((f) => f.endsWith(".csproj") || f.endsWith(".sln"));
     return hasCsproj && isCommandAvailable("dotnet");
   } catch {
@@ -24144,14 +24228,14 @@ function detectDotnetFormat(cwd) {
   }
 }
 function detectCppcheck(cwd) {
-  if (fs19.existsSync(path49.join(cwd, "CMakeLists.txt"))) {
+  if (fs18.existsSync(path50.join(cwd, "CMakeLists.txt"))) {
     return isCommandAvailable("cppcheck");
   }
   try {
-    const dirsToCheck = [cwd, path49.join(cwd, "src")];
+    const dirsToCheck = [cwd, path50.join(cwd, "src")];
     const hasCpp = dirsToCheck.some((dir) => {
       try {
-        return fs19.readdirSync(dir).some((f) => /\.(c|cpp|cc|cxx|h|hpp)$/.test(f));
+        return fs18.readdirSync(dir).some((f) => /\.(c|cpp|cc|cxx|h|hpp)$/.test(f));
       } catch {
         return false;
       }
@@ -24162,13 +24246,13 @@ function detectCppcheck(cwd) {
   }
 }
 function detectSwiftlint(cwd) {
-  return fs19.existsSync(path49.join(cwd, "Package.swift")) && isCommandAvailable("swiftlint");
+  return fs18.existsSync(path50.join(cwd, "Package.swift")) && isCommandAvailable("swiftlint");
 }
 function detectDartAnalyze(cwd) {
-  return fs19.existsSync(path49.join(cwd, "pubspec.yaml")) && (isCommandAvailable("dart") || isCommandAvailable("flutter"));
+  return fs18.existsSync(path50.join(cwd, "pubspec.yaml")) && (isCommandAvailable("dart") || isCommandAvailable("flutter"));
 }
 function detectRubocop(cwd) {
-  return (fs19.existsSync(path49.join(cwd, "Gemfile")) || fs19.existsSync(path49.join(cwd, "gems.rb")) || fs19.existsSync(path49.join(cwd, ".rubocop.yml"))) && (isCommandAvailable("rubocop") || isCommandAvailable("bundle"));
+  return (fs18.existsSync(path50.join(cwd, "Gemfile")) || fs18.existsSync(path50.join(cwd, "gems.rb")) || fs18.existsSync(path50.join(cwd, ".rubocop.yml"))) && (isCommandAvailable("rubocop") || isCommandAvailable("bundle"));
 }
 function detectAdditionalLinter(cwd) {
   if (detectRuff(cwd))
@@ -24196,10 +24280,10 @@ function detectAdditionalLinter(cwd) {
 function findBinInAncestors(startDir, binName) {
   let dir = startDir;
   while (true) {
-    const candidate = path49.join(dir, "node_modules", ".bin", binName);
-    if (fs19.existsSync(candidate))
+    const candidate = path50.join(dir, "node_modules", ".bin", binName);
+    if (fs18.existsSync(candidate))
       return candidate;
-    const parent = path49.dirname(dir);
+    const parent = path50.dirname(dir);
     if (parent === dir)
       break;
     dir = parent;
@@ -24208,11 +24292,11 @@ function findBinInAncestors(startDir, binName) {
 }
 function findBinInEnvPath(binName) {
   const searchPath = process.env.PATH ?? "";
-  for (const dir of searchPath.split(path49.delimiter)) {
+  for (const dir of searchPath.split(path50.delimiter)) {
     if (!dir)
       continue;
-    const candidate = path49.join(dir, binName);
-    if (fs19.existsSync(candidate))
+    const candidate = path50.join(dir, binName);
+    if (fs18.existsSync(candidate))
       return candidate;
   }
   return null;
@@ -24220,17 +24304,17 @@ function findBinInEnvPath(binName) {
 async function detectAvailableLinter(directory) {
   if (!directory)
     return null;
-  if (!fs19.existsSync(directory))
+  if (!fs18.existsSync(directory))
     return null;
   const projectDir = directory;
   const isWindows = process.platform === "win32";
-  const biomeBin = isWindows ? path49.join(projectDir, "node_modules", ".bin", "biome.EXE") : path49.join(projectDir, "node_modules", ".bin", "biome");
-  const eslintBin = isWindows ? path49.join(projectDir, "node_modules", ".bin", "eslint.cmd") : path49.join(projectDir, "node_modules", ".bin", "eslint");
+  const biomeBin = isWindows ? path50.join(projectDir, "node_modules", ".bin", "biome.EXE") : path50.join(projectDir, "node_modules", ".bin", "biome");
+  const eslintBin = isWindows ? path50.join(projectDir, "node_modules", ".bin", "eslint.cmd") : path50.join(projectDir, "node_modules", ".bin", "eslint");
   const localResult = await _detectAvailableLinter(projectDir, biomeBin, eslintBin);
   if (localResult)
     return localResult;
-  const biomeAncestor = findBinInAncestors(path49.dirname(projectDir), isWindows ? "biome.EXE" : "biome");
-  const eslintAncestor = findBinInAncestors(path49.dirname(projectDir), isWindows ? "eslint.cmd" : "eslint");
+  const biomeAncestor = findBinInAncestors(path50.dirname(projectDir), isWindows ? "biome.EXE" : "biome");
+  const eslintAncestor = findBinInAncestors(path50.dirname(projectDir), isWindows ? "eslint.cmd" : "eslint");
   if (biomeAncestor || eslintAncestor) {
     return _detectAvailableLinter(projectDir, biomeAncestor ?? biomeBin, eslintAncestor ?? eslintBin);
   }
@@ -24253,7 +24337,7 @@ async function _detectAvailableLinter(_projectDir, biomeBin, eslintBin) {
     const result = await Promise.race([biomeExit, timeout]);
     if (result === "timeout") {
       biomeProc.kill();
-    } else if (biomeProc.exitCode === 0 && fs19.existsSync(biomeBin)) {
+    } else if (biomeProc.exitCode === 0 && fs18.existsSync(biomeBin)) {
       return "biome";
     }
   } catch {}
@@ -24267,7 +24351,7 @@ async function _detectAvailableLinter(_projectDir, biomeBin, eslintBin) {
     const result = await Promise.race([eslintExit, timeout]);
     if (result === "timeout") {
       eslintProc.kill();
-    } else if (eslintProc.exitCode === 0 && fs19.existsSync(eslintBin)) {
+    } else if (eslintProc.exitCode === 0 && fs18.existsSync(eslintBin)) {
       return "eslint";
     }
   } catch {}
@@ -24443,8 +24527,8 @@ var _internals40 = {
 };
 
 // src/tools/secretscan.ts
-import * as fs20 from "fs";
-import * as path50 from "path";
+import * as fs19 from "fs";
+import * as path51 from "path";
 var MAX_FILE_PATH_LENGTH = 500;
 var MAX_FILE_SIZE_BYTES = 512 * 1024;
 var MAX_FILES_SCANNED = 1000;
@@ -24671,11 +24755,11 @@ function isGlobOrPathPattern(pattern) {
   return pattern.includes("/") || pattern.includes("\\") || /[*?[\]{}]/.test(pattern);
 }
 function loadSecretScanIgnore(scanDir) {
-  const ignorePath = path50.join(scanDir, ".secretscanignore");
+  const ignorePath = path51.join(scanDir, ".secretscanignore");
   try {
-    if (!fs20.existsSync(ignorePath))
+    if (!fs19.existsSync(ignorePath))
       return [];
-    const content = fs20.readFileSync(ignorePath, "utf8");
+    const content = fs19.readFileSync(ignorePath, "utf8");
     const patterns = [];
     for (const rawLine of content.split(/\r?\n/)) {
       const line = rawLine.trim();
@@ -24694,7 +24778,7 @@ function isExcluded(entry, relPath, exactNames, globPatterns) {
   if (exactNames.has(entry))
     return true;
   for (const pattern of globPatterns) {
-    if (path50.matchesGlob(relPath, pattern))
+    if (path51.matchesGlob(relPath, pattern))
       return true;
   }
   return false;
@@ -24715,7 +24799,7 @@ function validateDirectoryInput(dir) {
   return null;
 }
 function isBinaryFile(filePath, buffer) {
-  const ext = path50.extname(filePath).toLowerCase();
+  const ext = path51.extname(filePath).toLowerCase();
   if (DEFAULT_EXCLUDE_EXTENSIONS.has(ext)) {
     return true;
   }
@@ -24790,11 +24874,11 @@ function createRedactedContext(line, findings) {
   result += line.slice(lastEnd);
   return result;
 }
-var O_NOFOLLOW = process.platform !== "win32" ? fs20.constants.O_NOFOLLOW : undefined;
+var O_NOFOLLOW = process.platform !== "win32" ? fs19.constants.O_NOFOLLOW : undefined;
 function scanFileForSecrets(filePath) {
   const findings = [];
   try {
-    const lstat2 = fs20.lstatSync(filePath);
+    const lstat2 = fs19.lstatSync(filePath);
     if (lstat2.isSymbolicLink()) {
       return findings;
     }
@@ -24803,14 +24887,14 @@ function scanFileForSecrets(filePath) {
     }
     let buffer;
     if (O_NOFOLLOW !== undefined) {
-      const fd = fs20.openSync(filePath, "r", O_NOFOLLOW);
+      const fd = fs19.openSync(filePath, "r", O_NOFOLLOW);
       try {
-        buffer = fs20.readFileSync(fd);
+        buffer = fs19.readFileSync(fd);
       } finally {
-        fs20.closeSync(fd);
+        fs19.closeSync(fd);
       }
     } else {
-      buffer = fs20.readFileSync(filePath);
+      buffer = fs19.readFileSync(filePath);
     }
     if (isBinaryFile(filePath, buffer)) {
       return findings;
@@ -24852,9 +24936,9 @@ function isSymlinkLoop(realPath, visited) {
   return false;
 }
 function isPathWithinScope(realPath, scanDir) {
-  const resolvedScanDir = path50.resolve(scanDir);
-  const resolvedRealPath = path50.resolve(realPath);
-  return resolvedRealPath === resolvedScanDir || resolvedRealPath.startsWith(resolvedScanDir + path50.sep) || resolvedRealPath.startsWith(`${resolvedScanDir}/`) || resolvedRealPath.startsWith(`${resolvedScanDir}\\`);
+  const resolvedScanDir = path51.resolve(scanDir);
+  const resolvedRealPath = path51.resolve(realPath);
+  return resolvedRealPath === resolvedScanDir || resolvedRealPath.startsWith(resolvedScanDir + path51.sep) || resolvedRealPath.startsWith(`${resolvedScanDir}/`) || resolvedRealPath.startsWith(`${resolvedScanDir}\\`);
 }
 function findScannableFiles(dir, excludeExact, excludeGlobs, scanDir, visited, stats = {
   skippedDirs: 0,
@@ -24865,7 +24949,7 @@ function findScannableFiles(dir, excludeExact, excludeGlobs, scanDir, visited, s
   const files = [];
   let entries;
   try {
-    entries = fs20.readdirSync(dir);
+    entries = fs19.readdirSync(dir);
   } catch {
     stats.fileErrors++;
     return files;
@@ -24880,15 +24964,15 @@ function findScannableFiles(dir, excludeExact, excludeGlobs, scanDir, visited, s
     return a.localeCompare(b);
   });
   for (const entry of entries) {
-    const fullPath = path50.join(dir, entry);
-    const relPath = path50.relative(scanDir, fullPath).replace(/\\/g, "/");
+    const fullPath = path51.join(dir, entry);
+    const relPath = path51.relative(scanDir, fullPath).replace(/\\/g, "/");
     if (isExcluded(entry, relPath, excludeExact, excludeGlobs)) {
       stats.skippedDirs++;
       continue;
     }
     let lstat2;
     try {
-      lstat2 = fs20.lstatSync(fullPath);
+      lstat2 = fs19.lstatSync(fullPath);
     } catch {
       stats.fileErrors++;
       continue;
@@ -24900,7 +24984,7 @@ function findScannableFiles(dir, excludeExact, excludeGlobs, scanDir, visited, s
     if (lstat2.isDirectory()) {
       let realPath;
       try {
-        realPath = fs20.realpathSync(fullPath);
+        realPath = fs19.realpathSync(fullPath);
       } catch {
         stats.fileErrors++;
         continue;
@@ -24916,7 +25000,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 = path50.extname(fullPath).toLowerCase();
+      const ext = path51.extname(fullPath).toLowerCase();
       if (!DEFAULT_EXCLUDE_EXTENSIONS.has(ext)) {
         files.push(fullPath);
       } else {
@@ -24982,15 +25066,15 @@ var secretscan = createSwarmTool({
       }
     }
     try {
-      const _scanDirRaw = path50.resolve(directory);
+      const _scanDirRaw = path51.resolve(directory);
       const scanDir = (() => {
         try {
-          return fs20.realpathSync(_scanDirRaw);
+          return fs19.realpathSync(_scanDirRaw);
         } catch {
           return _scanDirRaw;
         }
       })();
-      if (!fs20.existsSync(scanDir)) {
+      if (!fs19.existsSync(scanDir)) {
         const errorResult = {
           error: "directory not found",
           scan_dir: directory,
@@ -25001,7 +25085,7 @@ var secretscan = createSwarmTool({
         };
         return JSON.stringify(errorResult, null, 2);
       }
-      const dirStat = fs20.statSync(scanDir);
+      const dirStat = fs19.statSync(scanDir);
       if (!dirStat.isDirectory()) {
         const errorResult = {
           error: "target must be a directory, not a file",
@@ -25052,7 +25136,7 @@ var secretscan = createSwarmTool({
           break;
         const fileFindings = scanFileForSecrets(filePath);
         try {
-          const stat5 = fs20.statSync(filePath);
+          const stat5 = fs19.statSync(filePath);
           if (stat5.size > MAX_FILE_SIZE_BYTES) {
             skippedFiles++;
             continue;
@@ -25144,12 +25228,12 @@ var _internals41 = {
 };
 
 // src/tools/test-runner.ts
-import * as fs24 from "fs";
-import * as path54 from "path";
+import * as fs23 from "fs";
+import * as path55 from "path";
 
 // src/test-impact/analyzer.ts
-import fs21 from "fs";
-import path51 from "path";
+import fs20 from "fs";
+import path52 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;
@@ -25176,7 +25260,7 @@ function sharedTrailingSegments(a, b) {
 function isCacheStale(impactMap, generatedAtMs) {
   for (const sourcePath of Object.keys(impactMap)) {
     try {
-      const stat5 = fs21.statSync(sourcePath);
+      const stat5 = fs20.statSync(sourcePath);
       if (stat5.mtimeMs > generatedAtMs) {
         return true;
       }
@@ -25190,15 +25274,15 @@ function resolveRelativeImport(fromDir, importPath) {
   if (!importPath.startsWith(".")) {
     return null;
   }
-  const resolved = path51.resolve(fromDir, importPath);
-  if (path51.extname(resolved)) {
-    if (fs21.existsSync(resolved) && fs21.statSync(resolved).isFile()) {
+  const resolved = path52.resolve(fromDir, importPath);
+  if (path52.extname(resolved)) {
+    if (fs20.existsSync(resolved) && fs20.statSync(resolved).isFile()) {
       return normalizePath2(resolved);
     }
   } else {
     for (const ext of EXTENSIONS_TO_TRY) {
       const withExt = resolved + ext;
-      if (fs21.existsSync(withExt) && fs21.statSync(withExt).isFile()) {
+      if (fs20.existsSync(withExt) && fs20.statSync(withExt).isFile()) {
         return normalizePath2(withExt);
       }
     }
@@ -25211,30 +25295,30 @@ function resolvePythonImport(fromDir, module) {
   const leadingDots = module.match(/^\.+/)?.[0].length ?? 0;
   let baseDir = fromDir;
   for (let i = 1;i < leadingDots; i++) {
-    baseDir = path51.dirname(baseDir);
+    baseDir = path52.dirname(baseDir);
   }
   const rest = module.slice(leadingDots);
   if (rest.length === 0) {
-    const initPath = path51.join(baseDir, "__init__.py");
-    if (fs21.existsSync(initPath) && fs21.statSync(initPath).isFile()) {
+    const initPath = path52.join(baseDir, "__init__.py");
+    if (fs20.existsSync(initPath) && fs20.statSync(initPath).isFile()) {
       return normalizePath2(initPath);
     }
     return null;
   }
-  const subpath = rest.replace(/\./g, path51.sep);
+  const subpath = rest.replace(/\./g, path52.sep);
   const candidates = [
-    `${path51.join(baseDir, subpath)}.py`,
-    path51.join(baseDir, subpath, "__init__.py")
+    `${path52.join(baseDir, subpath)}.py`,
+    path52.join(baseDir, subpath, "__init__.py")
   ];
   for (const c of candidates) {
-    if (fs21.existsSync(c) && fs21.statSync(c).isFile())
+    if (fs20.existsSync(c) && fs20.statSync(c).isFile())
       return normalizePath2(c);
   }
   return null;
 }
 var goModuleCache = new Map;
 function findGoModule(fromDir) {
-  const resolved = path51.resolve(fromDir);
+  const resolved = path52.resolve(fromDir);
   let cur = resolved;
   const walked = [];
   for (let i = 0;i < 16; i++) {
@@ -25246,8 +25330,8 @@ function findGoModule(fromDir) {
     }
     walked.push(cur);
     try {
-      const goMod = path51.join(cur, "go.mod");
-      const content = fs21.readFileSync(goMod, "utf-8");
+      const goMod = path52.join(cur, "go.mod");
+      const content = fs20.readFileSync(goMod, "utf-8");
       const moduleMatch = content.match(/^\s*module\s+"?([^"\s/]+(?:\/[^"\s]+)*)"?/m);
       if (moduleMatch) {
         const result = { moduleRoot: cur, modulePath: moduleMatch[1] };
@@ -25257,10 +25341,10 @@ function findGoModule(fromDir) {
       }
     } catch {}
     try {
-      fs21.accessSync(path51.join(cur, ".git"));
+      fs20.accessSync(path52.join(cur, ".git"));
       break;
     } catch {}
-    const parent = path51.dirname(cur);
+    const parent = path52.dirname(cur);
     if (parent === cur)
       break;
     cur = parent;
@@ -25272,20 +25356,20 @@ function findGoModule(fromDir) {
 function resolveGoImport(fromDir, importPath) {
   let dir = null;
   if (importPath.startsWith(".")) {
-    dir = path51.resolve(fromDir, importPath);
+    dir = path52.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 = path51.join(mod.moduleRoot, subpath);
+      dir = path52.join(mod.moduleRoot, subpath);
     }
   }
   if (dir === null)
     return [];
-  if (!fs21.existsSync(dir) || !fs21.statSync(dir).isDirectory())
+  if (!fs20.existsSync(dir) || !fs20.statSync(dir).isDirectory())
     return [];
   try {
-    return fs21.readdirSync(dir).filter((f) => f.endsWith(".go") && !f.endsWith("_test.go")).map((f) => normalizePath2(path51.join(dir, f)));
+    return fs20.readdirSync(dir).filter((f) => f.endsWith(".go") && !f.endsWith("_test.go")).map((f) => normalizePath2(path52.join(dir, f)));
   } catch {
     return [];
   }
@@ -25305,13 +25389,13 @@ function findTestFilesSync(cwd) {
   function walk(dir, visitedInodes) {
     let entries;
     try {
-      entries = fs21.readdirSync(dir, { withFileTypes: true });
+      entries = fs20.readdirSync(dir, { withFileTypes: true });
     } catch {
       return;
     }
     let dirInode;
     try {
-      dirInode = fs21.statSync(dir).ino;
+      dirInode = fs20.statSync(dir).ino;
     } catch {
       return;
     }
@@ -25324,15 +25408,15 @@ function findTestFilesSync(cwd) {
     for (const entry of entries) {
       if (entry.isDirectory()) {
         if (!skipDirs.has(entry.name)) {
-          walk(path51.join(dir, entry.name), visitedInodes);
+          walk(path52.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(`${path51.sep}tests${path51.sep}`) && name.endsWith(".py");
+        const isPyTest = /^test_.+\.py$/.test(name) || /.+_test\.py$/.test(name) || dir.includes(`${path52.sep}tests${path52.sep}`) && name.endsWith(".py");
         const isGoTest = /.+_test\.go$/.test(name);
         if (isTsTest || isPyTest || isGoTest) {
-          testFiles.push(normalizePath2(path51.join(dir, entry.name)));
+          testFiles.push(normalizePath2(path52.join(dir, entry.name)));
         }
       }
     }
@@ -25357,8 +25441,8 @@ function extractImports(content) {
   ];
 }
 function addImpactEdgesForTestFile(testFile, content, impactMap) {
-  const ext = path51.extname(testFile).toLowerCase();
-  const testDir = path51.dirname(testFile);
+  const ext = path52.extname(testFile).toLowerCase();
+  const testDir = path52.dirname(testFile);
   function addEdge(source) {
     if (!impactMap[source])
       impactMap[source] = [];
@@ -25395,12 +25479,13 @@ function addImpactEdgesForTestFile(testFile, content, impactMap) {
   }
 }
 async function buildImpactMapInternal(cwd) {
+  _clearGoModuleCache();
   const testFiles = findTestFilesSync(cwd);
   const impactMap = {};
   for (const testFile of testFiles) {
     let content;
     try {
-      content = fs21.readFileSync(testFile, "utf-8");
+      content = fs20.readFileSync(testFile, "utf-8");
     } catch {
       continue;
     }
@@ -25431,10 +25516,10 @@ async function buildImpactMap(cwd) {
   return impactMap;
 }
 async function loadImpactMap(cwd, options) {
-  const cachePath = path51.join(cwd, ".swarm", "cache", "impact-map.json");
-  if (fs21.existsSync(cachePath)) {
+  const cachePath = path52.join(cwd, ".swarm", "cache", "impact-map.json");
+  if (fs20.existsSync(cachePath)) {
     try {
-      const content = fs21.readFileSync(cachePath, "utf-8");
+      const content = fs20.readFileSync(cachePath, "utf-8");
       const data = JSON.parse(content);
       if (data.map !== null && typeof data.map === "object" && !Array.isArray(data.map)) {
         const map = data.map;
@@ -25464,21 +25549,21 @@ async function loadImpactMap(cwd, options) {
   return _internals42.buildImpactMap(cwd);
 }
 async function saveImpactMap(cwd, impactMap) {
-  if (!path51.isAbsolute(cwd)) {
+  if (!path52.isAbsolute(cwd)) {
     throw new Error(`saveImpactMap requires an absolute project root path, got: "${cwd}"`);
   }
   _internals42.validateProjectRoot(cwd);
-  const cacheDir2 = path51.join(cwd, ".swarm", "cache");
-  const cachePath = path51.join(cacheDir2, "impact-map.json");
-  if (!fs21.existsSync(cacheDir2)) {
-    fs21.mkdirSync(cacheDir2, { recursive: true });
+  const cacheDir2 = path52.join(cwd, ".swarm", "cache");
+  const cachePath = path52.join(cacheDir2, "impact-map.json");
+  if (!fs20.existsSync(cacheDir2)) {
+    fs20.mkdirSync(cacheDir2, { recursive: true });
   }
   const data = {
     generatedAt: new Date().toISOString(),
     fileCount: Object.keys(impactMap).length,
     map: impactMap
   };
-  fs21.writeFileSync(cachePath, JSON.stringify(data, null, 2), "utf-8");
+  fs20.writeFileSync(cachePath, JSON.stringify(data, null, 2), "utf-8");
 }
 async function analyzeImpact(changedFiles, cwd, budget) {
   if (!Array.isArray(changedFiles)) {
@@ -25501,7 +25586,7 @@ async function analyzeImpact(changedFiles, cwd, budget) {
       budgetExceeded = true;
       break;
     }
-    const normalizedChanged = normalizePath2(path51.resolve(changedFile));
+    const normalizedChanged = normalizePath2(path52.resolve(changedFile));
     const tests = impactMap[normalizedChanged];
     if (tests && tests.length > 0) {
       for (const test of tests) {
@@ -25515,13 +25600,13 @@ async function analyzeImpact(changedFiles, cwd, budget) {
       if (budgetExceeded)
         break;
     } else {
-      const changedDir = normalizePath2(path51.dirname(normalizedChanged));
-      const changedInputDir = normalizePath2(path51.dirname(changedFile));
+      const changedDir = normalizePath2(path52.dirname(normalizedChanged));
+      const changedInputDir = normalizePath2(path52.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(path51.dirname(sourceA));
-        const sourceDirB = normalizePath2(path51.dirname(sourceB));
+        const sourceDirA = normalizePath2(path52.dirname(sourceA));
+        const sourceDirB = normalizePath2(path52.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)
@@ -25847,8 +25932,8 @@ function detectFlakyTests(allHistory) {
 }
 
 // src/test-impact/history-store.ts
-import fs22 from "fs";
-import path52 from "path";
+import fs21 from "fs";
+import path53 from "path";
 var MAX_HISTORY_PER_TEST = 20;
 var MAX_ERROR_LENGTH = 500;
 var MAX_STACK_LENGTH = 200;
@@ -25860,10 +25945,10 @@ function getHistoryPath(workingDir) {
   if (!workingDir) {
     throw new Error("getHistoryPath requires a working directory \u2014 project root must be provided by the caller");
   }
-  if (!path52.isAbsolute(workingDir)) {
+  if (!path53.isAbsolute(workingDir)) {
     throw new Error(`getHistoryPath requires an absolute project root path, got: "${workingDir}"`);
   }
-  return path52.join(workingDir, ".swarm", "cache", "test-history.jsonl");
+  return path53.join(workingDir, ".swarm", "cache", "test-history.jsonl");
 }
 function sanitizeErrorMessage(errorMessage) {
   if (errorMessage === undefined) {
@@ -25955,10 +26040,10 @@ function batchAppendTestRuns(records, workingDir) {
     }
   }
   const historyPath = getHistoryPath(workingDir);
-  const historyDir = path52.dirname(historyPath);
+  const historyDir = path53.dirname(historyPath);
   _internals43.validateProjectRoot(workingDir);
-  if (!fs22.existsSync(historyDir)) {
-    fs22.mkdirSync(historyDir, { recursive: true });
+  if (!fs21.existsSync(historyDir)) {
+    fs21.mkdirSync(historyDir, { recursive: true });
   }
   withHistoryWriteLock(historyPath, () => {
     const existingRecords = readAllRecords(historyPath);
@@ -25992,13 +26077,13 @@ function batchAppendTestRuns(records, workingDir) {
 `)}
 `;
       const tempPath = `${historyPath}.tmp`;
-      fs22.writeFileSync(tempPath, content, "utf-8");
-      fs22.renameSync(tempPath, historyPath);
+      fs21.writeFileSync(tempPath, content, "utf-8");
+      fs21.renameSync(tempPath, historyPath);
     } catch (err) {
       try {
         const tempPath = `${historyPath}.tmp`;
-        if (fs22.existsSync(tempPath)) {
-          fs22.unlinkSync(tempPath);
+        if (fs21.existsSync(tempPath)) {
+          fs21.unlinkSync(tempPath);
         }
       } catch {}
       throw new Error(`Failed to write test history: ${err instanceof Error ? err.message : String(err)}`);
@@ -26010,7 +26095,7 @@ function withHistoryWriteLock(historyPath, fn) {
   const deadline = Date.now() + HISTORY_WRITE_LOCK_TIMEOUT_MS;
   while (true) {
     try {
-      fs22.mkdirSync(lockPath);
+      fs21.mkdirSync(lockPath);
       break;
     } catch (error2) {
       const code = error2 instanceof Error && "code" in error2 ? error2.code : undefined;
@@ -26021,9 +26106,9 @@ function withHistoryWriteLock(historyPath, fn) {
         throw new Error(`Timed out waiting for test history lock: ${historyPath}`);
       }
       try {
-        const lockStat = fs22.statSync(lockPath);
+        const lockStat = fs21.statSync(lockPath);
         if (Date.now() - lockStat.mtimeMs >= HISTORY_WRITE_LOCK_STALE_MS) {
-          fs22.rmSync(lockPath, { recursive: true, force: true });
+          fs21.rmSync(lockPath, { recursive: true, force: true });
           continue;
         }
       } catch {}
@@ -26038,7 +26123,7 @@ function withHistoryWriteLock(historyPath, fn) {
     return fn();
   } finally {
     try {
-      fs22.rmSync(lockPath, { recursive: true, force: true });
+      fs21.rmSync(lockPath, { recursive: true, force: true });
     } catch {}
   }
   function sleepSync(ms) {
@@ -26047,11 +26132,11 @@ function withHistoryWriteLock(historyPath, fn) {
   }
 }
 function readAllRecords(historyPath) {
-  if (!fs22.existsSync(historyPath)) {
+  if (!fs21.existsSync(historyPath)) {
     return [];
   }
   try {
-    const content = fs22.readFileSync(historyPath, "utf-8");
+    const content = fs21.readFileSync(historyPath, "utf-8");
     const lines = content.split(`
 `);
     const records = [];
@@ -26084,8 +26169,8 @@ var _internals43 = {
 };
 
 // src/tools/resolve-working-directory.ts
-import * as fs23 from "fs";
-import * as path53 from "path";
+import * as fs22 from "fs";
+import * as path54 from "path";
 function resolveWorkingDirectory(workingDirectory, fallbackDirectory) {
   if (workingDirectory == null || workingDirectory === "") {
     if (typeof fallbackDirectory !== "string" || fallbackDirectory === "") {
@@ -26108,14 +26193,12 @@ function resolveWorkingDirectory(workingDirectory, fallbackDirectory) {
       message: "Invalid working_directory: null bytes are not allowed"
     };
   }
-  if (process.platform === "win32") {
-    const devicePathPattern = /^\\\\|^(NUL|CON|AUX|COM[1-9]|LPT[1-9])(\..*)?$/i;
-    if (devicePathPattern.test(workingDirectory)) {
-      return {
-        success: false,
-        message: "Invalid working_directory: Windows device paths are not allowed"
-      };
-    }
+  const reservedDevicePattern = /^(NUL|CON|AUX|COM[1-9]|LPT[1-9])(\..*)?$/i;
+  if (workingDirectory.startsWith("\\\\") || process.platform === "win32" && reservedDevicePattern.test(workingDirectory)) {
+    return {
+      success: false,
+      message: "Invalid working_directory: Windows device paths are not allowed"
+    };
   }
   const rawPathParts = workingDirectory.split(/[\\/]/);
   if (rawPathParts.includes("..")) {
@@ -26124,11 +26207,11 @@ function resolveWorkingDirectory(workingDirectory, fallbackDirectory) {
       message: "Invalid working_directory: path traversal sequences (..) are not allowed"
     };
   }
-  const normalizedDir = path53.normalize(workingDirectory);
-  const resolvedDir = path53.resolve(normalizedDir);
+  const normalizedDir = path54.normalize(workingDirectory);
+  const resolvedDir = path54.resolve(normalizedDir);
   let statResult;
   try {
-    statResult = fs23.statSync(resolvedDir);
+    statResult = fs22.statSync(resolvedDir);
   } catch {
     return {
       success: false,
@@ -26144,16 +26227,16 @@ function resolveWorkingDirectory(workingDirectory, fallbackDirectory) {
   if (typeof fallbackDirectory !== "string" || fallbackDirectory === "") {
     return { success: true, directory: resolvedDir };
   }
-  const resolvedFallback = path53.resolve(fallbackDirectory);
+  const resolvedFallback = path54.resolve(fallbackDirectory);
   let fallbackExists = false;
   try {
-    fs23.statSync(resolvedFallback);
+    fs22.statSync(resolvedFallback);
     fallbackExists = true;
   } catch {
     fallbackExists = false;
   }
   if (fallbackExists) {
-    const isSubdirectory = resolvedDir.startsWith(resolvedFallback + path53.sep);
+    const isSubdirectory = resolvedDir.startsWith(resolvedFallback + path54.sep);
     if (isSubdirectory) {
       return {
         success: false,
@@ -26176,7 +26259,7 @@ async function estimateFanOut(sourceFiles, cwd) {
     const impactMap = await loadImpactMap(cwd, { skipRebuild: true });
     const uniqueTestFiles = new Set;
     for (const sourceFile of sourceFiles) {
-      const resolvedPath = path54.resolve(cwd, sourceFile);
+      const resolvedPath = path55.resolve(cwd, sourceFile);
       const normalizedPath = resolvedPath.replace(/\\/g, "/");
       const testFiles = impactMap[normalizedPath];
       if (testFiles) {
@@ -26261,19 +26344,19 @@ function hasDevDependency(devDeps, ...patterns) {
   return hasPackageJsonDependency(devDeps, ...patterns);
 }
 function detectGoTest(cwd) {
-  return fs24.existsSync(path54.join(cwd, "go.mod")) && isCommandAvailable("go");
+  return fs23.existsSync(path55.join(cwd, "go.mod")) && isCommandAvailable("go");
 }
 function detectJavaMaven(cwd) {
-  return fs24.existsSync(path54.join(cwd, "pom.xml")) && isCommandAvailable("mvn");
+  return fs23.existsSync(path55.join(cwd, "pom.xml")) && isCommandAvailable("mvn");
 }
 function detectGradle(cwd) {
-  const hasBuildFile = fs24.existsSync(path54.join(cwd, "build.gradle")) || fs24.existsSync(path54.join(cwd, "build.gradle.kts"));
-  const hasGradlew = fs24.existsSync(path54.join(cwd, "gradlew")) || fs24.existsSync(path54.join(cwd, "gradlew.bat"));
+  const hasBuildFile = fs23.existsSync(path55.join(cwd, "build.gradle")) || fs23.existsSync(path55.join(cwd, "build.gradle.kts"));
+  const hasGradlew = fs23.existsSync(path55.join(cwd, "gradlew")) || fs23.existsSync(path55.join(cwd, "gradlew.bat"));
   return hasBuildFile && (hasGradlew || isCommandAvailable("gradle"));
 }
 function detectDotnetTest(cwd) {
   try {
-    const files = fs24.readdirSync(cwd);
+    const files = fs23.readdirSync(cwd);
     const hasCsproj = files.some((f) => f.endsWith(".csproj"));
     return hasCsproj && isCommandAvailable("dotnet");
   } catch {
@@ -26281,25 +26364,25 @@ function detectDotnetTest(cwd) {
   }
 }
 function detectCTest(cwd) {
-  const hasSource = fs24.existsSync(path54.join(cwd, "CMakeLists.txt"));
-  const hasBuildCache = fs24.existsSync(path54.join(cwd, "CMakeCache.txt")) || fs24.existsSync(path54.join(cwd, "build", "CMakeCache.txt"));
+  const hasSource = fs23.existsSync(path55.join(cwd, "CMakeLists.txt"));
+  const hasBuildCache = fs23.existsSync(path55.join(cwd, "CMakeCache.txt")) || fs23.existsSync(path55.join(cwd, "build", "CMakeCache.txt"));
   return (hasSource || hasBuildCache) && isCommandAvailable("ctest");
 }
 function detectSwiftTest(cwd) {
-  return fs24.existsSync(path54.join(cwd, "Package.swift")) && isCommandAvailable("swift");
+  return fs23.existsSync(path55.join(cwd, "Package.swift")) && isCommandAvailable("swift");
 }
 function detectDartTest(cwd) {
-  return fs24.existsSync(path54.join(cwd, "pubspec.yaml")) && (isCommandAvailable("dart") || isCommandAvailable("flutter"));
+  return fs23.existsSync(path55.join(cwd, "pubspec.yaml")) && (isCommandAvailable("dart") || isCommandAvailable("flutter"));
 }
 function detectRSpec(cwd) {
-  const hasRSpecFile = fs24.existsSync(path54.join(cwd, ".rspec"));
-  const hasGemfile = fs24.existsSync(path54.join(cwd, "Gemfile"));
-  const hasSpecDir = fs24.existsSync(path54.join(cwd, "spec"));
+  const hasRSpecFile = fs23.existsSync(path55.join(cwd, ".rspec"));
+  const hasGemfile = fs23.existsSync(path55.join(cwd, "Gemfile"));
+  const hasSpecDir = fs23.existsSync(path55.join(cwd, "spec"));
   const hasRSpec = hasRSpecFile || hasGemfile && hasSpecDir;
   return hasRSpec && (isCommandAvailable("bundle") || isCommandAvailable("rspec"));
 }
 function detectMinitest(cwd) {
-  return fs24.existsSync(path54.join(cwd, "test")) && (fs24.existsSync(path54.join(cwd, "Gemfile")) || fs24.existsSync(path54.join(cwd, "Rakefile"))) && isCommandAvailable("ruby");
+  return fs23.existsSync(path55.join(cwd, "test")) && (fs23.existsSync(path55.join(cwd, "Gemfile")) || fs23.existsSync(path55.join(cwd, "Rakefile"))) && isCommandAvailable("ruby");
 }
 var DISPATCH_FRAMEWORK_MAP = {
   bun: "bun",
@@ -26384,9 +26467,9 @@ async function parseTestOutputViaDispatch(framework, output, baseDir) {
 async function detectTestFramework(cwd) {
   const baseDir = cwd;
   try {
-    const packageJsonPath = path54.join(baseDir, "package.json");
-    if (fs24.existsSync(packageJsonPath)) {
-      const content = fs24.readFileSync(packageJsonPath, "utf-8");
+    const packageJsonPath = path55.join(baseDir, "package.json");
+    if (fs23.existsSync(packageJsonPath)) {
+      const content = fs23.readFileSync(packageJsonPath, "utf-8");
       const pkg = JSON.parse(content);
       const _deps = pkg.dependencies || {};
       const devDeps = pkg.devDependencies || {};
@@ -26405,38 +26488,38 @@ async function detectTestFramework(cwd) {
         return "jest";
       if (hasDevDependency(devDeps, "mocha", "@types/mocha"))
         return "mocha";
-      if (fs24.existsSync(path54.join(baseDir, "bun.lockb")) || fs24.existsSync(path54.join(baseDir, "bun.lock"))) {
+      if (fs23.existsSync(path55.join(baseDir, "bun.lockb")) || fs23.existsSync(path55.join(baseDir, "bun.lock"))) {
         if (scripts.test?.includes("bun"))
           return "bun";
       }
     }
   } catch {}
   try {
-    const pyprojectTomlPath = path54.join(baseDir, "pyproject.toml");
-    const setupCfgPath = path54.join(baseDir, "setup.cfg");
-    const requirementsTxtPath = path54.join(baseDir, "requirements.txt");
-    if (fs24.existsSync(pyprojectTomlPath)) {
-      const content = fs24.readFileSync(pyprojectTomlPath, "utf-8");
+    const pyprojectTomlPath = path55.join(baseDir, "pyproject.toml");
+    const setupCfgPath = path55.join(baseDir, "setup.cfg");
+    const requirementsTxtPath = path55.join(baseDir, "requirements.txt");
+    if (fs23.existsSync(pyprojectTomlPath)) {
+      const content = fs23.readFileSync(pyprojectTomlPath, "utf-8");
       if (content.includes("[tool.pytest"))
         return "pytest";
       if (content.includes("pytest"))
         return "pytest";
     }
-    if (fs24.existsSync(setupCfgPath)) {
-      const content = fs24.readFileSync(setupCfgPath, "utf-8");
+    if (fs23.existsSync(setupCfgPath)) {
+      const content = fs23.readFileSync(setupCfgPath, "utf-8");
       if (content.includes("[pytest]"))
         return "pytest";
     }
-    if (fs24.existsSync(requirementsTxtPath)) {
-      const content = fs24.readFileSync(requirementsTxtPath, "utf-8");
+    if (fs23.existsSync(requirementsTxtPath)) {
+      const content = fs23.readFileSync(requirementsTxtPath, "utf-8");
       if (content.includes("pytest"))
         return "pytest";
     }
   } catch {}
   try {
-    const cargoTomlPath = path54.join(baseDir, "Cargo.toml");
-    if (fs24.existsSync(cargoTomlPath)) {
-      const content = fs24.readFileSync(cargoTomlPath, "utf-8");
+    const cargoTomlPath = path55.join(baseDir, "Cargo.toml");
+    if (fs23.existsSync(cargoTomlPath)) {
+      const content = fs23.readFileSync(cargoTomlPath, "utf-8");
       if (content.includes("[dev-dependencies]")) {
         if (content.includes("tokio") || content.includes("mockall") || content.includes("pretty_assertions")) {
           return "cargo";
@@ -26445,10 +26528,10 @@ async function detectTestFramework(cwd) {
     }
   } catch {}
   try {
-    const pesterConfigPath = path54.join(baseDir, "pester.config.ps1");
-    const pesterConfigJsonPath = path54.join(baseDir, "pester.config.ps1.json");
-    const pesterPs1Path = path54.join(baseDir, "tests.ps1");
-    if (fs24.existsSync(pesterConfigPath) || fs24.existsSync(pesterConfigJsonPath) || fs24.existsSync(pesterPs1Path)) {
+    const pesterConfigPath = path55.join(baseDir, "pester.config.ps1");
+    const pesterConfigJsonPath = path55.join(baseDir, "pester.config.ps1.json");
+    const pesterPs1Path = path55.join(baseDir, "tests.ps1");
+    if (fs23.existsSync(pesterConfigPath) || fs23.existsSync(pesterConfigJsonPath) || fs23.existsSync(pesterPs1Path)) {
       return "pester";
     }
   } catch {}
@@ -26490,12 +26573,12 @@ function isTestDirectoryPath(normalizedPath) {
   return normalizedPath.split("/").some((segment) => TEST_DIRECTORY_NAMES.includes(segment));
 }
 function resolveWorkspacePath(file, workingDir) {
-  return path54.isAbsolute(file) ? path54.resolve(file) : path54.resolve(workingDir, file);
+  return path55.isAbsolute(file) ? path55.resolve(file) : path55.resolve(workingDir, file);
 }
 function toWorkspaceOutputPath(absolutePath, workingDir, preferRelative) {
   if (!preferRelative)
     return absolutePath;
-  return path54.relative(workingDir, absolutePath);
+  return path55.relative(workingDir, absolutePath);
 }
 function dedupePush(target, value) {
   if (!target.includes(value)) {
@@ -26532,18 +26615,18 @@ function buildLanguageSpecificTestNames(nameWithoutExt, ext) {
   }
 }
 function getRepoLevelCandidateDirectories(workingDir, relativePath, ext) {
-  const relativeDir = path54.dirname(relativePath);
+  const relativeDir = path55.dirname(relativePath);
   const nestedRelativeDir = relativeDir === "." ? "" : relativeDir;
   const directories = TEST_DIRECTORY_NAMES.flatMap((dirName) => {
-    const rootDir = path54.join(workingDir, dirName);
-    return nestedRelativeDir ? [rootDir, path54.join(rootDir, nestedRelativeDir)] : [rootDir];
+    const rootDir = path55.join(workingDir, dirName);
+    return nestedRelativeDir ? [rootDir, path55.join(rootDir, nestedRelativeDir)] : [rootDir];
   });
   const normalizedRelativePath = relativePath.replace(/\\/g, "/");
   if (ext === ".java" && normalizedRelativePath.startsWith("src/main/java/")) {
-    directories.push(path54.join(workingDir, "src/test/java", path54.dirname(normalizedRelativePath.slice("src/main/java/".length))));
+    directories.push(path55.join(workingDir, "src/test/java", path55.dirname(normalizedRelativePath.slice("src/main/java/".length))));
   }
   if ((ext === ".kt" || ext === ".java") && normalizedRelativePath.startsWith("src/main/kotlin/")) {
-    directories.push(path54.join(workingDir, "src/test/kotlin", path54.dirname(normalizedRelativePath.slice("src/main/kotlin/".length))));
+    directories.push(path55.join(workingDir, "src/test/kotlin", path55.dirname(normalizedRelativePath.slice("src/main/kotlin/".length))));
   }
   return [...new Set(directories)];
 }
@@ -26551,19 +26634,19 @@ function hasCompoundTestExtension(filename) {
   const lower = filename.toLowerCase();
   return COMPOUND_TEST_EXTENSIONS.some((ext) => lower.endsWith(ext));
 }
-function isLanguageSpecificTestFile(basename10) {
-  const lower = basename10.toLowerCase();
+function isLanguageSpecificTestFile(basename11) {
+  const lower = basename11.toLowerCase();
   if (lower.endsWith("_test.go"))
     return true;
   if (lower.endsWith(".py") && (lower.startsWith("test_") || lower.endsWith("_test.py")))
     return true;
   if (lower.endsWith("_spec.rb"))
     return true;
-  if (lower.endsWith(".java") && (/^Test[A-Z]/.test(basename10) || basename10.endsWith("Test.java") || basename10.endsWith("Tests.java") || lower.endsWith("it.java")))
+  if (lower.endsWith(".java") && (/^Test[A-Z]/.test(basename11) || basename11.endsWith("Test.java") || basename11.endsWith("Tests.java") || lower.endsWith("it.java")))
     return true;
   if (lower.endsWith(".cs") && (lower.endsWith("test.cs") || lower.endsWith("tests.cs")))
     return true;
-  if (lower.endsWith(".kt") && (/^Test[A-Z]/.test(basename10) || lower.endsWith("test.kt") || lower.endsWith("tests.kt")))
+  if (lower.endsWith(".kt") && (/^Test[A-Z]/.test(basename11) || lower.endsWith("test.kt") || lower.endsWith("tests.kt")))
     return true;
   if (lower.endsWith(".tests.ps1"))
     return true;
@@ -26571,23 +26654,23 @@ function isLanguageSpecificTestFile(basename10) {
 }
 function isConventionTestFilePath(filePath) {
   const normalizedPath = filePath.replace(/\\/g, "/");
-  const basename10 = path54.basename(filePath);
-  return hasCompoundTestExtension(basename10) || basename10.includes(".spec.") || basename10.includes(".test.") || isLanguageSpecificTestFile(basename10) || isTestDirectoryPath(normalizedPath);
+  const basename11 = path55.basename(filePath);
+  return hasCompoundTestExtension(basename11) || basename11.includes(".spec.") || basename11.includes(".test.") || isLanguageSpecificTestFile(basename11) || isTestDirectoryPath(normalizedPath);
 }
 function getTestFilesFromConvention(sourceFiles, workingDir = process.cwd()) {
   const testFiles = [];
   for (const file of sourceFiles) {
     const absoluteFile = resolveWorkspacePath(file, workingDir);
-    const relativeFile = path54.relative(workingDir, absoluteFile);
-    const basename10 = path54.basename(absoluteFile);
-    const dirname24 = path54.dirname(absoluteFile);
-    const preferRelativeOutput = !path54.isAbsolute(file);
+    const relativeFile = path55.relative(workingDir, absoluteFile);
+    const basename11 = path55.basename(absoluteFile);
+    const dirname25 = path55.dirname(absoluteFile);
+    const preferRelativeOutput = !path55.isAbsolute(file);
     if (isConventionTestFilePath(relativeFile) || isConventionTestFilePath(file)) {
       dedupePush(testFiles, toWorkspaceOutputPath(absoluteFile, workingDir, preferRelativeOutput));
       continue;
     }
-    const nameWithoutExt = basename10.replace(/\.[^.]+$/, "");
-    const ext = path54.extname(basename10);
+    const nameWithoutExt = basename11.replace(/\.[^.]+$/, "");
+    const ext = path55.extname(basename11);
     const genericTestNames = [
       `${nameWithoutExt}.spec${ext}`,
       `${nameWithoutExt}.test${ext}`
@@ -26596,20 +26679,20 @@ function getTestFilesFromConvention(sourceFiles, workingDir = process.cwd()) {
     const colocatedCandidates = [
       ...genericTestNames,
       ...languageSpecificTestNames
-    ].map((candidateName) => path54.join(dirname24, candidateName));
+    ].map((candidateName) => path55.join(dirname25, candidateName));
     const testDirectoryNames = [
-      basename10,
+      basename11,
       ...genericTestNames,
       ...languageSpecificTestNames
     ];
     const repoLevelDirectories = getRepoLevelCandidateDirectories(workingDir, relativeFile, ext);
     const possibleTestFiles = [
       ...colocatedCandidates,
-      ...TEST_DIRECTORY_NAMES.flatMap((dirName) => testDirectoryNames.map((candidateName) => path54.join(dirname24, dirName, candidateName))),
-      ...repoLevelDirectories.flatMap((candidateDir) => testDirectoryNames.map((candidateName) => path54.join(candidateDir, candidateName)))
+      ...TEST_DIRECTORY_NAMES.flatMap((dirName) => testDirectoryNames.map((candidateName) => path55.join(dirname25, dirName, candidateName))),
+      ...repoLevelDirectories.flatMap((candidateDir) => testDirectoryNames.map((candidateName) => path55.join(candidateDir, candidateName)))
     ];
     for (const testFile of possibleTestFiles) {
-      if (fs24.existsSync(testFile)) {
+      if (fs23.existsSync(testFile)) {
         dedupePush(testFiles, toWorkspaceOutputPath(testFile, workingDir, preferRelativeOutput));
       }
     }
@@ -26626,8 +26709,8 @@ async function getTestFilesFromGraph(sourceFiles, workingDir) {
   for (const testFile of candidateTestFiles) {
     try {
       const absoluteTestFile = resolveWorkspacePath(testFile, workingDir);
-      const content = fs24.readFileSync(absoluteTestFile, "utf-8");
-      const testDir = path54.dirname(absoluteTestFile);
+      const content = fs23.readFileSync(absoluteTestFile, "utf-8");
+      const testDir = path55.dirname(absoluteTestFile);
       const importRegex = /import\s+.*?\s+from\s+['"]([^'"]+)['"]/g;
       let match;
       match = importRegex.exec(content);
@@ -26635,8 +26718,8 @@ async function getTestFilesFromGraph(sourceFiles, workingDir) {
         const importPath = match[1];
         let resolvedImport;
         if (importPath.startsWith(".")) {
-          resolvedImport = path54.resolve(testDir, importPath);
-          const existingExt = path54.extname(resolvedImport);
+          resolvedImport = path55.resolve(testDir, importPath);
+          const existingExt = path55.extname(resolvedImport);
           if (!existingExt) {
             for (const extToTry of [
               ".ts",
@@ -26647,7 +26730,7 @@ async function getTestFilesFromGraph(sourceFiles, workingDir) {
               ".cjs"
             ]) {
               const withExt = resolvedImport + extToTry;
-              if (absoluteSourceFiles.includes(withExt) || fs24.existsSync(withExt)) {
+              if (absoluteSourceFiles.includes(withExt) || fs23.existsSync(withExt)) {
                 resolvedImport = withExt;
                 break;
               }
@@ -26656,12 +26739,12 @@ async function getTestFilesFromGraph(sourceFiles, workingDir) {
         } else {
           continue;
         }
-        const importBasename = path54.basename(resolvedImport, path54.extname(resolvedImport));
-        const importDir = path54.dirname(resolvedImport);
+        const importBasename = path55.basename(resolvedImport, path55.extname(resolvedImport));
+        const importDir = path55.dirname(resolvedImport);
         for (const sourceFile of absoluteSourceFiles) {
-          const sourceDir = path54.dirname(sourceFile);
-          const sourceBasename = path54.basename(sourceFile, path54.extname(sourceFile));
-          const isRelatedDir = importDir === sourceDir || importDir === path54.join(sourceDir, "__tests__") || importDir === path54.join(sourceDir, "tests") || importDir === path54.join(sourceDir, "test") || importDir === path54.join(sourceDir, "spec");
+          const sourceDir = path55.dirname(sourceFile);
+          const sourceBasename = path55.basename(sourceFile, path55.extname(sourceFile));
+          const isRelatedDir = importDir === sourceDir || importDir === path55.join(sourceDir, "__tests__") || importDir === path55.join(sourceDir, "tests") || importDir === path55.join(sourceDir, "test") || importDir === path55.join(sourceDir, "spec");
           if (resolvedImport === sourceFile || importBasename === sourceBasename && isRelatedDir) {
             dedupePush(testFiles, testFile);
             break;
@@ -26674,8 +26757,8 @@ async function getTestFilesFromGraph(sourceFiles, workingDir) {
       while (match !== null) {
         const importPath = match[1];
         if (importPath.startsWith(".")) {
-          let resolvedImport = path54.resolve(testDir, importPath);
-          const existingExt = path54.extname(resolvedImport);
+          let resolvedImport = path55.resolve(testDir, importPath);
+          const existingExt = path55.extname(resolvedImport);
           if (!existingExt) {
             for (const extToTry of [
               ".ts",
@@ -26686,18 +26769,18 @@ async function getTestFilesFromGraph(sourceFiles, workingDir) {
               ".cjs"
             ]) {
               const withExt = resolvedImport + extToTry;
-              if (absoluteSourceFiles.includes(withExt) || fs24.existsSync(withExt)) {
+              if (absoluteSourceFiles.includes(withExt) || fs23.existsSync(withExt)) {
                 resolvedImport = withExt;
                 break;
               }
             }
           }
-          const importDir = path54.dirname(resolvedImport);
-          const importBasename = path54.basename(resolvedImport, path54.extname(resolvedImport));
+          const importDir = path55.dirname(resolvedImport);
+          const importBasename = path55.basename(resolvedImport, path55.extname(resolvedImport));
           for (const sourceFile of absoluteSourceFiles) {
-            const sourceDir = path54.dirname(sourceFile);
-            const sourceBasename = path54.basename(sourceFile, path54.extname(sourceFile));
-            const isRelatedDir = importDir === sourceDir || importDir === path54.join(sourceDir, "__tests__") || importDir === path54.join(sourceDir, "tests") || importDir === path54.join(sourceDir, "test") || importDir === path54.join(sourceDir, "spec");
+            const sourceDir = path55.dirname(sourceFile);
+            const sourceBasename = path55.basename(sourceFile, path55.extname(sourceFile));
+            const isRelatedDir = importDir === sourceDir || importDir === path55.join(sourceDir, "__tests__") || importDir === path55.join(sourceDir, "tests") || importDir === path55.join(sourceDir, "test") || importDir === path55.join(sourceDir, "spec");
             if (resolvedImport === sourceFile || importBasename === sourceBasename && isRelatedDir) {
               dedupePush(testFiles, testFile);
               break;
@@ -26817,8 +26900,8 @@ function buildTestCommand(framework, scope, files, coverage, baseDir, bail) {
       return ["mvn", "test"];
     case "gradle": {
       const isWindows = process.platform === "win32";
-      const hasGradlewBat = fs24.existsSync(path54.join(baseDir, "gradlew.bat"));
-      const hasGradlew = fs24.existsSync(path54.join(baseDir, "gradlew"));
+      const hasGradlewBat = fs23.existsSync(path55.join(baseDir, "gradlew.bat"));
+      const hasGradlew = fs23.existsSync(path55.join(baseDir, "gradlew"));
       if (hasGradlewBat && isWindows)
         return ["gradlew.bat", "test"];
       if (hasGradlew)
@@ -26835,7 +26918,7 @@ function buildTestCommand(framework, scope, files, coverage, baseDir, bail) {
         "cmake-build-release",
         "out"
       ];
-      const actualBuildDir = buildDirCandidates.find((d) => fs24.existsSync(path54.join(baseDir, d, "CMakeCache.txt"))) ?? "build";
+      const actualBuildDir = buildDirCandidates.find((d) => fs23.existsSync(path55.join(baseDir, d, "CMakeCache.txt"))) ?? "build";
       return ["ctest", "--test-dir", actualBuildDir];
     }
     case "swift-test":
@@ -27269,13 +27352,13 @@ async function runTests(framework, scope, files, coverage, timeout_ms, cwd, bail
     };
   }
   const startTime = Date.now();
-  const vitestJsonOutputPath = framework === "vitest" ? path54.join(cwd, ".swarm", "cache", "test-runner-vitest.json") : undefined;
+  const vitestJsonOutputPath = framework === "vitest" ? path55.join(cwd, ".swarm", "cache", "test-runner-vitest.json") : undefined;
   try {
     if (vitestJsonOutputPath) {
       try {
-        fs24.mkdirSync(path54.dirname(vitestJsonOutputPath), { recursive: true });
-        if (fs24.existsSync(vitestJsonOutputPath)) {
-          fs24.unlinkSync(vitestJsonOutputPath);
+        fs23.mkdirSync(path55.dirname(vitestJsonOutputPath), { recursive: true });
+        if (fs23.existsSync(vitestJsonOutputPath)) {
+          fs23.unlinkSync(vitestJsonOutputPath);
         }
       } catch {}
     }
@@ -27301,8 +27384,8 @@ async function runTests(framework, scope, files, coverage, timeout_ms, cwd, bail
     }
     if (vitestJsonOutputPath) {
       try {
-        if (fs24.existsSync(vitestJsonOutputPath)) {
-          const vitestJsonOutput = fs24.readFileSync(vitestJsonOutputPath, "utf-8");
+        if (fs23.existsSync(vitestJsonOutputPath)) {
+          const vitestJsonOutput = fs23.readFileSync(vitestJsonOutputPath, "utf-8");
           if (vitestJsonOutput.trim().length > 0) {
             output += (output ? `
 ` : "") + vitestJsonOutput;
@@ -27441,10 +27524,10 @@ var SKIP_DIRECTORIES = new Set([
 ]);
 function normalizeHistoryTestFile(testFile, workingDir) {
   const normalized = testFile.replace(/\\/g, "/");
-  if (!path54.isAbsolute(testFile))
+  if (!path55.isAbsolute(testFile))
     return normalized;
-  const relative7 = path54.relative(workingDir, testFile);
-  if (relative7.startsWith("..") || path54.isAbsolute(relative7)) {
+  const relative7 = path55.relative(workingDir, testFile);
+  if (relative7.startsWith("..") || path55.isAbsolute(relative7)) {
     return normalized;
   }
   return relative7.replace(/\\/g, "/");
@@ -27683,7 +27766,7 @@ var test_runner = createSwarmTool({
       const sourceFiles = args.files.filter((file) => {
         if (directTestFiles.includes(file))
           return false;
-        const ext = path54.extname(file).toLowerCase();
+        const ext = path55.extname(file).toLowerCase();
         return SOURCE_EXTENSIONS.has(ext);
       });
       const invalidFiles = args.files.filter((file) => !directTestFiles.includes(file) && !sourceFiles.includes(file));
@@ -27729,7 +27812,7 @@ var test_runner = createSwarmTool({
         if (isConventionTestFilePath(f)) {
           return false;
         }
-        const ext = path54.extname(f).toLowerCase();
+        const ext = path55.extname(f).toLowerCase();
         return SOURCE_EXTENSIONS.has(ext);
       });
       if (sourceFiles.length === 0) {
@@ -27779,7 +27862,7 @@ var test_runner = createSwarmTool({
         if (isConventionTestFilePath(f)) {
           return false;
         }
-        const ext = path54.extname(f).toLowerCase();
+        const ext = path55.extname(f).toLowerCase();
         return SOURCE_EXTENSIONS.has(ext);
       });
       if (sourceFiles.length === 0) {
@@ -27831,8 +27914,8 @@ var test_runner = createSwarmTool({
         }
         if (impactResult.impactedTests.length > 0) {
           testFiles = impactResult.impactedTests.map((absPath) => {
-            const relativePath = path54.relative(workingDir, absPath);
-            return path54.isAbsolute(relativePath) ? absPath : relativePath;
+            const relativePath = path55.relative(workingDir, absPath);
+            return path55.isAbsolute(relativePath) ? absPath : relativePath;
           });
         } else {
           graphFallbackReason = "no impacted tests found via impact analysis, falling back to graph";
@@ -27927,8 +28010,8 @@ function validateDirectoryPath(dir) {
   if (dir.includes("..")) {
     throw new Error("Directory path must not contain path traversal sequences");
   }
-  const normalized = path55.normalize(dir);
-  const absolutePath = path55.isAbsolute(normalized) ? normalized : path55.resolve(normalized);
+  const normalized = path56.normalize(dir);
+  const absolutePath = path56.isAbsolute(normalized) ? normalized : path56.resolve(normalized);
   return absolutePath;
 }
 function validateTimeout(timeoutMs, defaultValue) {
@@ -27951,9 +28034,9 @@ function validateTimeout(timeoutMs, defaultValue) {
 }
 function getPackageVersion(dir) {
   try {
-    const packagePath = path55.join(dir, "package.json");
-    if (fs25.existsSync(packagePath)) {
-      const content = fs25.readFileSync(packagePath, "utf-8");
+    const packagePath = path56.join(dir, "package.json");
+    if (fs24.existsSync(packagePath)) {
+      const content = fs24.readFileSync(packagePath, "utf-8");
       const pkg = JSON.parse(content);
       return pkg.version ?? null;
     }
@@ -27962,9 +28045,9 @@ function getPackageVersion(dir) {
 }
 function getChangelogVersion(dir) {
   try {
-    const changelogPath = path55.join(dir, "CHANGELOG.md");
-    if (fs25.existsSync(changelogPath)) {
-      const content = fs25.readFileSync(changelogPath, "utf-8");
+    const changelogPath = path56.join(dir, "CHANGELOG.md");
+    if (fs24.existsSync(changelogPath)) {
+      const content = fs24.readFileSync(changelogPath, "utf-8");
       const match = content.match(/^##\s*\[?(\d+\.\d+\.\d+)\]?/m);
       if (match) {
         return match[1];
@@ -27976,10 +28059,10 @@ function getChangelogVersion(dir) {
 function getVersionFileVersion(dir) {
   const possibleFiles = ["VERSION.txt", "version.txt", "VERSION", "version"];
   for (const file of possibleFiles) {
-    const filePath = path55.join(dir, file);
-    if (fs25.existsSync(filePath)) {
+    const filePath = path56.join(dir, file);
+    if (fs24.existsSync(filePath)) {
       try {
-        const content = fs25.readFileSync(filePath, "utf-8").trim();
+        const content = fs24.readFileSync(filePath, "utf-8").trim();
         const match = content.match(/(\d+\.\d+\.\d+)/);
         if (match) {
           return match[1];
@@ -28713,8 +28796,8 @@ async function handleQaGatesCommand(directory, args, sessionID) {
 }
 
 // src/commands/reset.ts
-import * as fs26 from "fs";
-import * as path56 from "path";
+import * as fs25 from "fs";
+import * as path57 from "path";
 
 // src/background/circuit-breaker.ts
 class CircuitBreaker {
@@ -29421,8 +29504,8 @@ async function handleResetCommand(directory, args) {
   for (const filename of filesToReset) {
     try {
       const resolvedPath = validateSwarmPath(directory, filename);
-      if (fs26.existsSync(resolvedPath)) {
-        fs26.unlinkSync(resolvedPath);
+      if (fs25.existsSync(resolvedPath)) {
+        fs25.unlinkSync(resolvedPath);
         results.push(`- \u2705 Deleted ${filename}`);
       } else {
         results.push(`- \u23ED\uFE0F ${filename} not found (skipped)`);
@@ -29433,9 +29516,9 @@ async function handleResetCommand(directory, args) {
   }
   for (const filename of ["SWARM_PLAN.md", "SWARM_PLAN.json"]) {
     try {
-      const rootPath = path56.join(directory, filename);
-      if (fs26.existsSync(rootPath)) {
-        fs26.unlinkSync(rootPath);
+      const rootPath = path57.join(directory, filename);
+      if (fs25.existsSync(rootPath)) {
+        fs25.unlinkSync(rootPath);
         results.push(`- \u2705 Deleted ${filename} (root)`);
       }
     } catch (err) {
@@ -29450,8 +29533,8 @@ async function handleResetCommand(directory, args) {
   }
   try {
     const summariesPath = validateSwarmPath(directory, "summaries");
-    if (fs26.existsSync(summariesPath)) {
-      fs26.rmSync(summariesPath, { recursive: true, force: true });
+    if (fs25.existsSync(summariesPath)) {
+      fs25.rmSync(summariesPath, { recursive: true, force: true });
       results.push("- \u2705 Deleted summaries/ directory");
     } else {
       results.push("- \u23ED\uFE0F summaries/ not found (skipped)");
@@ -29470,15 +29553,15 @@ async function handleResetCommand(directory, args) {
 }
 
 // src/commands/reset-session.ts
-import * as fs29 from "fs";
-import * as path59 from "path";
+import * as fs28 from "fs";
+import * as path60 from "path";
 
 // src/prm/trajectory-store.ts
-import * as fs27 from "fs/promises";
-import * as path57 from "path";
+import * as fs26 from "fs/promises";
+import * as path58 from "path";
 var MAX_TRACKED_TRAJECTORY_SESSIONS = 500;
 function getTrajectoryPath(sessionId, directory) {
-  const relativePath = path57.join("trajectories", `${sessionId}.jsonl`);
+  const relativePath = path58.join("trajectories", `${sessionId}.jsonl`);
   return validateSwarmPath(directory, relativePath);
 }
 var _inMemoryTrajectoryCache = new Map;
@@ -29508,7 +29591,7 @@ function clearTrajectoryCache(sessionId) {
 async function readTrajectory(sessionId, directory) {
   try {
     const trajectoryPath = getTrajectoryPath(sessionId, directory);
-    const content = await fs27.readFile(trajectoryPath, "utf-8");
+    const content = await fs26.readFile(trajectoryPath, "utf-8");
     const lines = content.split(`
 `).filter((line) => line.trim().length > 0);
     const entries = [];
@@ -29533,15 +29616,15 @@ async function cleanupOldTrajectoryFiles(directory, maxAgeDays = 7) {
   for (const subdir of ["trajectories", "replays"]) {
     try {
       const dirPath = validateSwarmPath(directory, subdir);
-      const entries = await fs27.readdir(dirPath, { withFileTypes: true });
+      const entries = await fs26.readdir(dirPath, { withFileTypes: true });
       for (const entry of entries) {
         if (!entry.isFile())
           continue;
-        const filePath = path57.join(dirPath, entry.name);
+        const filePath = path58.join(dirPath, entry.name);
         try {
-          const stat6 = await fs27.stat(filePath);
+          const stat6 = await fs26.stat(filePath);
           if (now - stat6.mtimeMs > cutoffMs) {
-            await fs27.unlink(filePath);
+            await fs26.unlink(filePath);
           }
         } catch {}
       }
@@ -29963,17 +30046,17 @@ function detectPatterns(trajectory, config, lastProcessedStep = 0) {
   };
 }
 // src/prm/replay.ts
-import { promises as fs28 } from "fs";
-import path58 from "path";
+import { promises as fs27 } from "fs";
+import path59 from "path";
 function isPathSafe(targetPath, basePath) {
-  const resolvedTarget = path58.resolve(targetPath);
-  const resolvedBase = path58.resolve(basePath);
-  const rel = path58.relative(resolvedBase, resolvedTarget);
-  return !rel.startsWith("..") && !path58.isAbsolute(rel);
+  const resolvedTarget = path59.resolve(targetPath);
+  const resolvedBase = path59.resolve(basePath);
+  const rel = path59.relative(resolvedBase, resolvedTarget);
+  return !rel.startsWith("..") && !path59.isAbsolute(rel);
 }
 function isWithinReplaysDir(targetPath) {
-  const resolved = path58.resolve(targetPath);
-  const parts = resolved.split(path58.sep);
+  const resolved = path59.resolve(targetPath);
+  const parts = resolved.split(path59.sep);
   for (let i = 0;i < parts.length - 1; i++) {
     if (parts[i] === ".swarm" && parts[i + 1] === "replays") {
       return true;
@@ -29986,15 +30069,15 @@ function sanitizeFilename(input) {
 }
 async function startReplayRecording(sessionID, directory) {
   try {
-    const replayDir = path58.join(directory, ".swarm", "replays");
+    const replayDir = path59.join(directory, ".swarm", "replays");
     const safeSessionID = sanitizeFilename(sessionID);
     const filename = `${safeSessionID}-${Date.now()}.jsonl`;
-    const filepath = path58.join(replayDir, filename);
+    const filepath = path59.join(replayDir, filename);
     if (!isPathSafe(filepath, replayDir)) {
       console.warn(`[replay] Invalid path detected - path traversal attempt blocked for session ${sessionID}`);
       return null;
     }
-    await fs28.mkdir(replayDir, { recursive: true });
+    await fs27.mkdir(replayDir, { recursive: true });
     return filepath;
   } catch (err) {
     console.warn(`[replay] Failed to start recording for session ${sessionID}: ${err}`);
@@ -30014,7 +30097,7 @@ async function recordReplayEntry(artifactPath, sessionID, entry) {
     };
     const line = `${JSON.stringify(fullEntry)}
 `;
-    await fs28.appendFile(artifactPath, line, "utf-8");
+    await fs27.appendFile(artifactPath, line, "utf-8");
   } catch (err) {
     console.warn(`[replay] Failed to record entry: ${err}`);
   }
@@ -30059,10 +30142,11 @@ function errorMessage(err) {
 }
 async function handleResetSessionCommand(directory, _args) {
   const results = [];
+  let statePath;
   try {
-    const statePath = validateSwarmPath(directory, "session/state.json");
-    if (fs29.existsSync(statePath)) {
-      fs29.unlinkSync(statePath);
+    statePath = validateSwarmPath(directory, "session/state.json");
+    if (fs28.existsSync(statePath)) {
+      fs28.unlinkSync(statePath);
       results.push("\u2705 Deleted .swarm/session/state.json");
     } else {
       results.push("\u23ED\uFE0F state.json not found (already clean)");
@@ -30070,11 +30154,11 @@ async function handleResetSessionCommand(directory, _args) {
   } catch {
     results.push("\u274C Failed to delete state.json");
   }
-  const sessionDir = path59.dirname(validateSwarmPath(directory, "session/state.json"));
+  const sessionDir = statePath ? path60.dirname(statePath) : undefined;
   let sessionFiles = [];
-  if (fs29.existsSync(sessionDir)) {
+  if (sessionDir && fs28.existsSync(sessionDir)) {
     try {
-      sessionFiles = fs29.readdirSync(sessionDir);
+      sessionFiles = fs28.readdirSync(sessionDir);
     } catch (err) {
       results.push(`\u274C Failed to read session directory: ${errorMessage(err)}`);
     }
@@ -30082,13 +30166,13 @@ async function handleResetSessionCommand(directory, _args) {
   for (const file of sessionFiles) {
     if (file === "state.json")
       continue;
-    const filePath = path59.join(sessionDir, file);
+    const filePath = path60.join(sessionDir, file);
     try {
-      if (!fs29.existsSync(filePath))
+      if (!fs28.existsSync(filePath))
         continue;
-      if (!fs29.lstatSync(filePath).isFile())
+      if (!fs28.lstatSync(filePath).isFile())
         continue;
-      fs29.unlinkSync(filePath);
+      fs28.unlinkSync(filePath);
       results.push(`\u2713 Deleted ${file}`);
     } catch (err) {
       results.push(`\u274C Failed to delete ${file}: ${errorMessage(err)}`);
@@ -30104,10 +30188,10 @@ async function handleResetSessionCommand(directory, _args) {
   const chainCount = swarmState.delegationChains.size;
   swarmState.delegationChains.clear();
   results.push(`\u2705 Cleared ${chainCount} delegation chain(s)`);
-  const worktreesDir = path59.resolve(path59.dirname(directory), ".swarm-worktrees");
+  const worktreesDir = path60.resolve(path60.dirname(directory), ".swarm-worktrees");
   try {
-    if (fs29.existsSync(worktreesDir)) {
-      fs29.rmSync(worktreesDir, { recursive: true, force: true });
+    if (fs28.existsSync(worktreesDir)) {
+      fs28.rmSync(worktreesDir, { recursive: true, force: true });
       results.push("\u2705 Removed .swarm-worktrees/ directory");
     }
   } catch (err) {
@@ -30137,7 +30221,7 @@ async function handleResetSessionCommand(directory, _args) {
 }
 
 // src/summaries/manager.ts
-import * as path60 from "path";
+import * as path61 from "path";
 var SUMMARY_ID_REGEX = /^S\d+$/;
 function sanitizeSummaryId(id) {
   if (!id || id.length === 0) {
@@ -30161,7 +30245,7 @@ function sanitizeSummaryId(id) {
 }
 async function loadFullOutput(directory, id) {
   const sanitizedId = sanitizeSummaryId(id);
-  const relativePath = path60.join("summaries", `${sanitizedId}.json`);
+  const relativePath = path61.join("summaries", `${sanitizedId}.json`);
   validateSwarmPath(directory, relativePath);
   const content = await readSwarmFileAsync(directory, relativePath);
   if (content === null) {
@@ -30213,18 +30297,91 @@ ${error2 instanceof Error ? error2.message : String(error2)}`;
 }
 
 // src/commands/rollback.ts
-import * as fs30 from "fs";
-import * as path61 from "path";
+import * as fs29 from "fs";
+import * as path62 from "path";
+function safeParseToolJson(result) {
+  try {
+    const jsonStr = typeof result === "string" ? result : result.output;
+    return JSON.parse(jsonStr);
+  } catch {
+    return null;
+  }
+}
+async function listGitCheckpoints(directory) {
+  try {
+    const result = await checkpoint.execute({ action: "list" }, {
+      directory
+    });
+    const parsed = safeParseToolJson(result);
+    if (!parsed)
+      return null;
+    if (parsed.success !== true || !Array.isArray(parsed.checkpoints)) {
+      return null;
+    }
+    return parsed.checkpoints;
+  } catch {
+    return null;
+  }
+}
+function formatGitCheckpointList(checkpoints) {
+  if (checkpoints.length === 0) {
+    return "No checkpoints found. Create one with `/swarm checkpoint save <label>`";
+  }
+  return [
+    "## Available Checkpoints",
+    "",
+    ...checkpoints.map((c, index) => `- ${index + 1}. "${c.label}" - ${new Date(c.timestamp).toLocaleString()} (${c.sha.slice(0, 12)})`),
+    "",
+    "Run `/swarm rollback <label-or-number>` to restore to a checkpoint."
+  ].join(`
+`);
+}
+function resolveGitCheckpoint(checkpoints, selector) {
+  const index = Number.parseInt(selector, 10);
+  if (/^\d+$/.test(selector) && index >= 1 && index <= checkpoints.length) {
+    return checkpoints[index - 1] ?? null;
+  }
+  return checkpoints.find((c) => c.label === selector) ?? null;
+}
+async function restoreGitCheckpoint(directory, selected) {
+  const result = await checkpoint.execute({ action: "restore", label: selected.label }, { directory });
+  const parsed = safeParseToolJson(result);
+  if (!parsed) {
+    return `Error: Failed to parse checkpoint response for "${selected.label}"`;
+  }
+  if (parsed.success !== true) {
+    return `Error: ${parsed.error || `Failed to restore checkpoint "${selected.label}"`}`;
+  }
+  const eventsPath = validateSwarmPath(directory, "events.jsonl");
+  const rollbackEvent = {
+    type: "rollback",
+    label: selected.label,
+    sha: selected.sha,
+    timestamp: new Date().toISOString(),
+    source: "checkpoints.json"
+  };
+  try {
+    fs29.appendFileSync(eventsPath, `${JSON.stringify(rollbackEvent)}
+`);
+  } catch (error2) {
+    console.error("Failed to write rollback event:", error2 instanceof Error ? error2.message : String(error2));
+  }
+  return `Rolled back to checkpoint "${selected.label}" (${selected.sha.slice(0, 12)})`;
+}
 async function handleRollbackCommand(directory, args) {
   const phaseArg = args[0];
   if (!phaseArg) {
     const manifestPath2 = validateSwarmPath(directory, "checkpoints/manifest.json");
-    if (!fs30.existsSync(manifestPath2)) {
-      return "No checkpoints found. Use `/swarm checkpoint` to create checkpoints.";
+    if (!fs29.existsSync(manifestPath2)) {
+      const gitCheckpoints = await listGitCheckpoints(directory);
+      if (gitCheckpoints) {
+        return formatGitCheckpointList(gitCheckpoints);
+      }
+      return "No checkpoints found. Use `/swarm checkpoint save <label>` to create checkpoints.";
     }
     let manifest2;
     try {
-      manifest2 = JSON.parse(fs30.readFileSync(manifestPath2, "utf-8"));
+      manifest2 = JSON.parse(fs29.readFileSync(manifestPath2, "utf-8"));
     } catch {
       return "Error: Checkpoint manifest is corrupted. Delete .swarm/checkpoints/manifest.json and re-checkpoint.";
     }
@@ -30243,15 +30400,31 @@ async function handleRollbackCommand(directory, args) {
   }
   const targetPhase = parseInt(phaseArg, 10);
   if (Number.isNaN(targetPhase) || targetPhase < 1) {
-    return "Error: Phase number must be a positive integer.";
+    const gitCheckpoints = await listGitCheckpoints(directory);
+    if (!gitCheckpoints) {
+      return "Error: Phase number must be a positive integer.";
+    }
+    const selected = resolveGitCheckpoint(gitCheckpoints, phaseArg);
+    if (!selected) {
+      return `Error: Checkpoint "${phaseArg}" not found. Available checkpoints: ${gitCheckpoints.map((c) => `"${c.label}"`).join(", ") || "none"}`;
+    }
+    return restoreGitCheckpoint(directory, selected);
   }
   const manifestPath = validateSwarmPath(directory, "checkpoints/manifest.json");
-  if (!fs30.existsSync(manifestPath)) {
-    return `Error: No checkpoints found. Cannot rollback to phase ${targetPhase}.`;
+  if (!fs29.existsSync(manifestPath)) {
+    const gitCheckpoints = await listGitCheckpoints(directory);
+    if (!gitCheckpoints) {
+      return `Error: No checkpoints found. Cannot rollback to phase ${targetPhase}.`;
+    }
+    const selected = resolveGitCheckpoint(gitCheckpoints, phaseArg);
+    if (!selected) {
+      return `Error: Checkpoint ${phaseArg} not found. Available checkpoints: ${gitCheckpoints.map((c, index) => `${index + 1}="${c.label}"`).join(", ") || "none"}`;
+    }
+    return restoreGitCheckpoint(directory, selected);
   }
   let manifest;
   try {
-    manifest = JSON.parse(fs30.readFileSync(manifestPath, "utf-8"));
+    manifest = JSON.parse(fs29.readFileSync(manifestPath, "utf-8"));
   } catch {
     return `Error: Checkpoint manifest is corrupted. Delete .swarm/checkpoints/manifest.json and re-checkpoint.`;
   }
@@ -30261,10 +30434,10 @@ async function handleRollbackCommand(directory, args) {
     return `Error: Checkpoint for phase ${targetPhase} not found. Available phases: ${available}`;
   }
   const checkpointDir = validateSwarmPath(directory, `checkpoints/phase-${targetPhase}`);
-  if (!fs30.existsSync(checkpointDir)) {
+  if (!fs29.existsSync(checkpointDir)) {
     return `Error: Checkpoint directory for phase ${targetPhase} does not exist.`;
   }
-  const checkpointFiles = fs30.readdirSync(checkpointDir);
+  const checkpointFiles = fs29.readdirSync(checkpointDir);
   if (checkpointFiles.length === 0) {
     return `Error: Checkpoint for phase ${targetPhase} is empty. Cannot rollback.`;
   }
@@ -30280,10 +30453,10 @@ async function handleRollbackCommand(directory, args) {
     if (EXCLUDE_FILES.has(file) || file.startsWith("plan-ledger.archived-")) {
       continue;
     }
-    const src = path61.join(checkpointDir, file);
-    const dest = path61.join(swarmDir, file);
+    const src = path62.join(checkpointDir, file);
+    const dest = path62.join(swarmDir, file);
     try {
-      fs30.cpSync(src, dest, { recursive: true, force: true });
+      fs29.cpSync(src, dest, { recursive: true, force: true });
       successes.push(file);
     } catch (error2) {
       failures.push({ file, error: error2.message });
@@ -30300,11 +30473,11 @@ async function handleRollbackCommand(directory, args) {
     ].join(`
 `);
   }
-  const existingLedgerPath = path61.join(swarmDir, "plan-ledger.jsonl");
+  const existingLedgerPath = path62.join(swarmDir, "plan-ledger.jsonl");
   let ledgerDeletionFailed = false;
-  if (fs30.existsSync(existingLedgerPath)) {
+  if (fs29.existsSync(existingLedgerPath)) {
     try {
-      fs30.unlinkSync(existingLedgerPath);
+      fs29.unlinkSync(existingLedgerPath);
     } catch (err) {
       ledgerDeletionFailed = true;
       const errMsg = err instanceof Error ? err.message : String(err);
@@ -30313,9 +30486,9 @@ async function handleRollbackCommand(directory, args) {
   }
   if (!ledgerDeletionFailed) {
     try {
-      const planJsonPath = path61.join(swarmDir, "plan.json");
-      if (fs30.existsSync(planJsonPath)) {
-        const planRaw = fs30.readFileSync(planJsonPath, "utf-8");
+      const planJsonPath = path62.join(swarmDir, "plan.json");
+      if (fs29.existsSync(planJsonPath)) {
+        const planRaw = fs29.readFileSync(planJsonPath, "utf-8");
         const plan = PlanSchema.parse(JSON.parse(planRaw));
         const planId = derivePlanId(plan);
         const planHash = computePlanHash(plan);
@@ -30343,7 +30516,7 @@ async function handleRollbackCommand(directory, args) {
     timestamp: new Date().toISOString()
   };
   try {
-    fs30.appendFileSync(eventsPath, `${JSON.stringify(rollbackEvent)}
+    fs29.appendFileSync(eventsPath, `${JSON.stringify(rollbackEvent)}
 `);
   } catch (error2) {
     console.error("Failed to write rollback event:", error2 instanceof Error ? error2.message : String(error2));
@@ -30360,9 +30533,9 @@ async function handleRollbackCommand(directory, args) {
 }
 
 // src/commands/sdd.ts
-import * as fs31 from "fs";
-import * as path62 from "path";
-var SWARM_SPEC_REL = path62.join(".swarm", "spec.md");
+import * as fs30 from "fs";
+import * as path63 from "path";
+var SWARM_SPEC_REL = path63.join(".swarm", "spec.md");
 var USAGE9 = `Usage:
   /swarm sdd status [--json] [--source <provider>]
   /swarm sdd validate [--json] [--change <id>] [--source <provider>] [--feature <id>]
@@ -30478,7 +30651,7 @@ ${USAGE9}`;
   }
   const speckitDetection = detectSpeckit(directory);
   const speckitPresent = speckitDetection.features.length > 0;
-  const nativeSpecExists = fs31.existsSync(path62.join(directory, SWARM_SPEC_REL));
+  const nativeSpecExists = fs30.existsSync(path63.join(directory, SWARM_SPEC_REL));
   if (speckitPresent && !parsed.source && !nativeSpecExists) {
     const openspecProjection = buildOpenSpecProjectionSync(directory);
     if (openspecProjection !== null) {
@@ -30548,7 +30721,7 @@ ${USAGE9}`;
 ${USAGE9}`;
   }
   let useSpeckit = false;
-  const nativeSpecExists = fs31.existsSync(path62.join(directory, SWARM_SPEC_REL));
+  const nativeSpecExists = fs30.existsSync(path63.join(directory, SWARM_SPEC_REL));
   if (parsed.source === "speckit") {
     useSpeckit = true;
   } else if (!parsed.source && !nativeSpecExists) {
@@ -30859,13 +31032,13 @@ Ensure this is a git repository with commit history.`;
   const report = reportLines.filter(Boolean).join(`
 `);
   try {
-    const fs32 = await import("fs/promises");
-    const path63 = await import("path");
-    const reportPath = path63.join(directory, ".swarm", "simulate-report.md");
-    await fs32.mkdir(path63.dirname(reportPath), { recursive: true });
-    const reportTempPath = path63.join(path63.dirname(reportPath), `${path63.basename(reportPath)}.tmp.${Date.now()}.${Math.floor(Math.random() * 1e9)}`);
+    const fs31 = await import("fs/promises");
+    const path64 = await import("path");
+    const reportPath = path64.join(directory, ".swarm", "simulate-report.md");
+    await fs31.mkdir(path64.dirname(reportPath), { recursive: true });
+    const reportTempPath = path64.join(path64.dirname(reportPath), `${path64.basename(reportPath)}.tmp.${Date.now()}.${Math.floor(Math.random() * 1e9)}`);
     try {
-      await fs32.writeFile(reportTempPath, report, "utf-8");
+      await fs31.writeFile(reportTempPath, report, "utf-8");
       renameSync11(reportTempPath, reportPath);
     } catch (err) {
       try {
@@ -30891,8 +31064,8 @@ async function handleSpecifyCommand(_directory, args) {
 
 // src/services/status-service.ts
 import * as fsSync2 from "fs";
-import { readFile as readFile16 } from "fs/promises";
-import * as path64 from "path";
+import { readFile as readFile17 } from "fs/promises";
+import * as path65 from "path";
 
 // src/hooks/extractors.ts
 function extractCurrentPhase(planContent) {
@@ -30936,16 +31109,16 @@ function extractCurrentPhaseFromPlan2(plan) {
 
 // src/turbo/lean/state.ts
 init_logger();
-import * as fs32 from "fs";
-import * as path63 from "path";
+import * as fs31 from "fs";
+import * as path64 from "path";
 var STATE_FILE3 = "turbo-state.json";
 function nowISO3() {
   return new Date().toISOString();
 }
 function ensureSwarmDir2(directory) {
-  const swarmDir = path63.resolve(directory, ".swarm");
-  if (!fs32.existsSync(swarmDir)) {
-    fs32.mkdirSync(swarmDir, { recursive: true });
+  const swarmDir = path64.resolve(directory, ".swarm");
+  if (!fs31.existsSync(swarmDir)) {
+    fs31.mkdirSync(swarmDir, { recursive: true });
   }
   return swarmDir;
 }
@@ -30988,17 +31161,17 @@ function markStateUnreadable2(directory, reason) {
 }
 function readPersisted2(directory) {
   try {
-    const filePath = path63.join(directory, ".swarm", STATE_FILE3);
-    if (!fs32.existsSync(filePath)) {
+    const filePath = path64.join(directory, ".swarm", STATE_FILE3);
+    if (!fs31.existsSync(filePath)) {
       const seed = emptyPersisted2();
       try {
         ensureSwarmDir2(directory);
-        fs32.writeFileSync(filePath, `${JSON.stringify(seed, null, 2)}
+        fs31.writeFileSync(filePath, `${JSON.stringify(seed, null, 2)}
 `, "utf-8");
       } catch {}
       return seed;
     }
-    const raw = fs32.readFileSync(filePath, "utf-8");
+    const raw = fs31.readFileSync(filePath, "utf-8");
     const parsed = JSON.parse(raw);
     if (!parsed || typeof parsed !== "object" || Array.isArray(parsed) || parsed.version !== 1 || !parsed.sessions || typeof parsed.sessions !== "object" || Array.isArray(parsed.sessions)) {
       markStateUnreadable2(directory, `malformed shape (version=${parsed?.version}, sessions type=${Array.isArray(parsed?.sessions) ? "array" : typeof parsed?.sessions})`);
@@ -31024,7 +31197,7 @@ function writePersisted2(directory, persisted) {
   let payload;
   try {
     ensureSwarmDir2(directory);
-    filePath = path63.join(directory, ".swarm", STATE_FILE3);
+    filePath = path64.join(directory, ".swarm", STATE_FILE3);
     tmpPath = `${filePath}.tmp.${Date.now()}`;
     persisted.updatedAt = nowISO3();
     payload = `${JSON.stringify(persisted, null, 2)}
@@ -31035,14 +31208,14 @@ function writePersisted2(directory, persisted) {
     throw new Error(`Lean Turbo state persistence prepare failed: ${msg}`);
   }
   try {
-    fs32.writeFileSync(tmpPath, payload, "utf-8");
-    fs32.renameSync(tmpPath, filePath);
+    fs31.writeFileSync(tmpPath, payload, "utf-8");
+    fs31.renameSync(tmpPath, filePath);
   } catch (error2) {
     const msg = error2 instanceof Error ? error2.message : String(error2);
     error(`[turbo/lean/state] Failed to persist ${STATE_FILE3} atomically: ${msg}`);
     try {
-      if (fs32.existsSync(tmpPath)) {
-        fs32.unlinkSync(tmpPath);
+      if (fs31.existsSync(tmpPath)) {
+        fs31.unlinkSync(tmpPath);
       }
     } catch {}
     throw new Error(`Lean Turbo state persistence failed: ${msg}`);
@@ -31142,7 +31315,7 @@ var _internals47 = {
 };
 function readSpecStalenessSnapshot(directory) {
   try {
-    const p = path64.join(directory, ".swarm", "spec-staleness.json");
+    const p = path65.join(directory, ".swarm", "spec-staleness.json");
     if (!fsSync2.existsSync(p))
       return { stale: false };
     const raw = fsSync2.readFileSync(p, "utf-8");
@@ -31395,7 +31568,7 @@ async function safeLineCount(filePath) {
   try {
     if (!fsSync2.existsSync(filePath))
       return 0;
-    const content = await readFile16(filePath, "utf-8");
+    const content = await readFile17(filePath, "utf-8");
     let n = 0;
     for (const line of content.split(`
 `)) {
@@ -31674,13 +31847,13 @@ function buildStatusMessage2(session, directory, sessionID) {
 }
 
 // src/commands/unlink.ts
-import { existsSync as existsSync39 } from "fs";
-import * as path65 from "path";
+import { existsSync as existsSync40 } from "fs";
+import * as path66 from "path";
 var DEDUP_THRESHOLD2 = 0.6;
 async function copySharedKnowledgeToLocal(linkDir, localSwarmDir) {
-  const sharedPath = path65.join(linkDir, "knowledge.jsonl");
-  const localPath = path65.join(localSwarmDir, "knowledge.jsonl");
-  if (!existsSync39(sharedPath))
+  const sharedPath = path66.join(linkDir, "knowledge.jsonl");
+  const localPath = path66.join(localSwarmDir, "knowledge.jsonl");
+  if (!existsSync40(sharedPath))
     return 0;
   const sharedEntries = await readKnowledge(sharedPath);
   if (sharedEntries.length === 0)
@@ -31714,7 +31887,7 @@ async function handleUnlinkCommand(directory, args) {
   let copied = 0;
   if (copyBack) {
     try {
-      copied = await copySharedKnowledgeToLocal(linkDir, path65.join(directory, ".swarm"));
+      copied = await copySharedKnowledgeToLocal(linkDir, path66.join(directory, ".swarm"));
     } catch (error2) {
       return `\u274C Failed to copy shared knowledge back to local: ${error2 instanceof Error ? error2.message : String(error2)}`;
     }
@@ -31876,7 +32049,7 @@ function buildDetailedHelp(commandName, entry) {
 async function handleHelpCommand(ctx) {
   const targetCommand = ctx.args.join(" ");
   if (!targetCommand) {
-    const { buildHelpText } = await import("./index-87d4wsv9.js");
+    const { buildHelpText } = await import("./index-502f6np6.js");
     return buildHelpText();
   }
   const tokens = targetCommand.split(/\s+/);
@@ -31885,7 +32058,7 @@ async function handleHelpCommand(ctx) {
     return _internals49.buildDetailedHelp(resolved.key, resolved.entry);
   }
   const similar = _internals49.findSimilarCommands(targetCommand);
-  const { buildHelpText: fullHelp } = await import("./index-87d4wsv9.js");
+  const { buildHelpText: fullHelp } = await import("./index-502f6np6.js");
   if (similar.length > 0) {
     return `Command '/swarm ${targetCommand}' not found.
 
@@ -32018,7 +32191,7 @@ var COMMAND_REGISTRY = {
   },
   "guardrail explain": {
     handler: async (ctx) => {
-      const { handleGuardrailExplain } = await import("./guardrail-explain-414smfg4.js");
+      const { handleGuardrailExplain } = await import("./guardrail-explain-etdrhd4d.js");
       return handleGuardrailExplain(ctx.directory, ctx.args);
     },
     description: "Dry-run: show what the guardrails would do to a command or write target (executes nothing)",
@@ -32028,7 +32201,7 @@ var COMMAND_REGISTRY = {
   },
   "guardrail-log": {
     handler: async (ctx) => {
-      const { handleGuardrailLog } = await import("./guardrail-log-fsc85hwa.js");
+      const { handleGuardrailLog } = await import("./guardrail-log-2rns4g6d.js");
       return handleGuardrailLog(ctx.directory, ctx.args);
     },
     description: "Read the guardrail decision log (use --blocks-only for blocks)",
@@ -32540,9 +32713,9 @@ Subcommands:
   },
   rollback: {
     handler: (ctx) => handleRollbackCommand(ctx.directory, ctx.args),
-    description: "Restore swarm state to a checkpoint <phase>",
-    details: "Restores .swarm/ state by directly overwriting files from a checkpoint directory (checkpoints/phase-<N>). Writes rollback event to events.jsonl. Without phase argument, lists available checkpoints. Partial failures are reported but processing continues.",
-    args: "<phase-number>",
+    description: "Restore swarm state or project files to a checkpoint",
+    details: "Restores legacy .swarm/ phase checkpoints from checkpoints/phase-<N> when present. Otherwise restores named git checkpoints from .swarm/checkpoints.json by label or list number. Writes rollback event to events.jsonl. Without an argument, lists available checkpoints.",
+    args: "<phase-number|label|list-number>",
     category: "utility",
     toolPolicy: "restricted"
   },
@@ -32555,7 +32728,7 @@ Subcommands:
     toolPolicy: "agent"
   },
   handoff: {
-    handler: (ctx) => handleHandoffCommand(ctx.directory, ctx.args),
+    handler: (ctx) => handleHandoffCommand(ctx.directory, ctx.args, ctx.sessionID),
     description: "Prepare state for clean model switch (new session)",
     args: "",
     details: "Generates handoff.md with full session state snapshot, including plan progress, recent decisions, and agent delegation history. Prepended to the next session prompt for seamless model switches.",
@@ -32781,7 +32954,7 @@ Subcommands:
   checkpoint: {
     handler: (ctx) => handleCheckpointCommand(ctx.directory, ctx.args),
     description: "Manage project checkpoints [save|restore|delete|list] <label>",
-    details: "save: creates named snapshot of current .swarm/ state. restore: soft-resets to checkpoint by overwriting current .swarm/ files. delete: removes named checkpoint. list: shows all checkpoints with timestamps. All subcommands require a label except list.",
+    details: "save: creates named git checkpoint. restore: hard-resets tracked files to the checkpoint. delete: removes named checkpoint metadata. list: shows all checkpoints with timestamps. All subcommands require a label except list.",
     args: "<save|restore|delete|list> <label>",
     category: "utility",
     clashesWithNativeCcCommand: "/checkpoint",
@@ -32801,24 +32974,24 @@ function validateAliases() {
         continue;
       }
       const visited = new Set;
-      const path66 = [];
+      const path67 = [];
       let current = target;
       while (current) {
         const currentEntry = COMMAND_REGISTRY[current];
         if (!currentEntry)
           break;
         if (visited.has(current)) {
-          const cycleStart = path66.indexOf(current);
+          const cycleStart = path67.indexOf(current);
           const fullChain = [
             name,
-            ...path66.slice(0, cycleStart > 0 ? cycleStart : path66.length),
+            ...path67.slice(0, cycleStart > 0 ? cycleStart : path67.length),
             current
           ].join(" \u2192 ");
           errors.push(`Circular alias detected: ${fullChain}`);
           break;
         }
         visited.add(current);
-        path66.push(current);
+        path67.push(current);
         current = currentEntry.aliasOf || "";
       }
     }
@@ -34157,7 +34330,7 @@ init_logger();
 
 // src/hooks/guardrails/destructive-command.ts
 import * as fsSync3 from "fs";
-import * as path66 from "path";
+import * as path67 from "path";
 var DC_MAX_UNWRAP_DEPTH = 5;
 var DC_SAFE_TARGETS = new Set([
   "node_modules",
@@ -34321,16 +34494,16 @@ function dcIsRemotePath(p) {
   return DC_REMOTE_PREFIXES.some((pfx) => p.startsWith(pfx));
 }
 function dcLstatAncestorWalk(targetPath, cwd) {
-  const normalizedTarget = path66.resolve(cwd, targetPath);
-  const normalizedCwd = path66.resolve(cwd);
+  const normalizedTarget = path67.resolve(cwd, targetPath);
+  const normalizedCwd = path67.resolve(cwd);
   const ancestors = [];
   let current = normalizedTarget;
   while (true) {
     ancestors.push(current);
-    const parent = path66.dirname(current);
+    const parent = path67.dirname(current);
     if (parent === current)
       break;
-    const rel = path66.relative(normalizedCwd, current);
+    const rel = path67.relative(normalizedCwd, current);
     if (rel === "" || rel.startsWith(".."))
       break;
     current = parent;
@@ -34369,14 +34542,14 @@ function dcValidateTargets(targets, cwd) {
     const lstatBlock = dcLstatAncestorWalk(t, cwd);
     if (lstatBlock)
       return lstatBlock;
-    const basename11 = path66.basename(t);
-    if (t === basename11 && DC_SAFE_TARGETS.has(t)) {
+    const basename12 = path67.basename(t);
+    if (t === basename12 && 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 (path66.isAbsolute(t) || /^[A-Za-z]:/.test(t)) {
+    if (path67.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}"`;
@@ -34391,9 +34564,9 @@ function dcCheckJunctionCreation(segment, cwd) {
   if (mklinkMatch) {
     const target = mklinkMatch[2].trim();
     if (!dcHasUnresolvableVars(target)) {
-      const resolved = path66.resolve(cwd, target);
-      const rel = path66.relative(cwd, resolved);
-      if (rel.startsWith("..") || path66.isAbsolute(rel)) {
+      const resolved = path67.resolve(cwd, target);
+      const rel = path67.relative(cwd, resolved);
+      if (rel.startsWith("..") || path67.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.`;
       }
     }
@@ -34405,9 +34578,9 @@ function dcCheckJunctionCreation(segment, cwd) {
   if (newItemMatch) {
     const target = newItemMatch[1].trim();
     if (!dcHasUnresolvableVars(target)) {
-      const resolved = path66.resolve(cwd, target);
-      const rel = path66.relative(cwd, resolved);
-      if (rel.startsWith("..") || path66.isAbsolute(rel)) {
+      const resolved = path67.resolve(cwd, target);
+      const rel = path67.relative(cwd, resolved);
+      if (rel.startsWith("..") || path67.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.`;
       }
     }
@@ -34417,9 +34590,9 @@ function dcCheckJunctionCreation(segment, cwd) {
   if (lnMatch) {
     const target = lnMatch[1].trim();
     if (!dcHasUnresolvableVars(target)) {
-      const resolved = path66.resolve(cwd, target);
-      const rel = path66.relative(cwd, resolved);
-      if (rel.startsWith("..") || path66.isAbsolute(rel)) {
+      const resolved = path67.resolve(cwd, target);
+      const rel = path67.relative(cwd, resolved);
+      if (rel.startsWith("..") || path67.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.`;
       }
     }
@@ -34790,10 +34963,10 @@ function classifySwarmCommandChatFallbackUse(resolved) {
 init_executor();
 
 // src/hooks/shell-write-detect.ts
-import * as path67 from "path";
+import * as path68 from "path";
 import parse from "bash-parser";
-function buildDedupeKey(category, operator, path68) {
-  return `${category}|${operator}|${path68 ?? "null"}`;
+function buildDedupeKey(category, operator, path69) {
+  return `${category}|${operator}|${path69 ?? "null"}`;
 }
 var REDIRECT_WRITE_TOKENS = new Set([
   "GREAT",
@@ -34853,16 +35026,16 @@ function detectProcessSubstitutionWrites(command) {
         results.push(builtinResult);
       const appendMatch = stage.match(/^\s*(.*?)\s*>>(\s*)(\S+)\s*$/);
       if (appendMatch) {
-        const path68 = appendMatch[3];
-        if (path68 && !isNullDevice(path68)) {
-          results.push({ category: "redirect", operator: ">>", path: path68 });
+        const path69 = appendMatch[3];
+        if (path69 && !isNullDevice(path69)) {
+          results.push({ category: "redirect", operator: ">>", path: path69 });
         }
       } else {
         const writeMatch = stage.match(/^\s*(.*?)\s*>(?!>)(\s*)(\S+)\s*$/);
         if (writeMatch) {
-          const path68 = writeMatch[3];
-          if (path68 && !isNullDevice(path68)) {
-            results.push({ category: "redirect", operator: ">", path: path68 });
+          const path69 = writeMatch[3];
+          if (path69 && !isNullDevice(path69)) {
+            results.push({ category: "redirect", operator: ">", path: path69 });
           }
         }
       }
@@ -35036,8 +35209,8 @@ function extractRedirectPath(fileNode) {
     return null;
   return text;
 }
-function isNullDevice(path68) {
-  return path68 === "/dev/null" || path68 === "/dev/zero" || path68 === "/dev/urandom";
+function isNullDevice(path69) {
+  return path69 === "/dev/null" || path69 === "/dev/zero" || path69 === "/dev/urandom";
 }
 function isNumeric(s) {
   return /^\d+$/.test(s);
@@ -35057,12 +35230,12 @@ function detectRedirects(cmd) {
     if (!opType || !REDIRECT_ALL_WRITE_TOKENS.has(opType))
       continue;
     const fileNode = r.file;
-    const path68 = extractRedirectPath(fileNode);
+    const path69 = extractRedirectPath(fileNode);
     const opLabel = operatorLabel(opNode);
     if (REDIRECT_WRITE_TOKENS.has(opType)) {
-      results.push({ category: "redirect", operator: opLabel, path: path68 });
+      results.push({ category: "redirect", operator: opLabel, path: path69 });
     } else if (REDIRECT_HERE_TOKENS.has(opType)) {
-      results.push({ category: "here_doc", operator: opLabel, path: path68 });
+      results.push({ category: "here_doc", operator: opLabel, path: path69 });
     }
   }
   return results;
@@ -35105,9 +35278,9 @@ function detectBuiltinWrites(cmd) {
     const suffixWords2 = getSuffixWords(cmd);
     for (const word of suffixWords2) {
       if (word.startsWith("of=")) {
-        const path68 = word.slice(3);
-        if (path68 && !isNullDevice(path68)) {
-          results.push({ category: "builtin_write", operator: "dd of=", path: path68 });
+        const path69 = word.slice(3);
+        if (path69 && !isNullDevice(path69)) {
+          results.push({ category: "builtin_write", operator: "dd of=", path: path69 });
         }
       }
     }
@@ -35226,12 +35399,12 @@ function detectNetworkDownloaders(cmd) {
     for (let i = 0;i < suffixWords.length; i++) {
       const word = suffixWords[i];
       if (word === "-o" && i + 1 < suffixWords.length) {
-        const path68 = suffixWords[i + 1];
-        if (!path68.startsWith("-")) {
+        const path69 = suffixWords[i + 1];
+        if (!path69.startsWith("-")) {
           results.push({
             category: "network_download",
             operator: "curl -o",
-            path: path68
+            path: path69
           });
         }
       } else if (word.startsWith("-o") && word.length > 2) {
@@ -35246,12 +35419,12 @@ function detectNetworkDownloaders(cmd) {
     for (let i = 0;i < suffixWords.length; i++) {
       const word = suffixWords[i];
       if (word === "-O" && i + 1 < suffixWords.length) {
-        const path68 = suffixWords[i + 1];
-        if (!path68.startsWith("-")) {
+        const path69 = suffixWords[i + 1];
+        if (!path69.startsWith("-")) {
           results.push({
             category: "network_download",
             operator: "wget -O",
-            path: path68
+            path: path69
           });
         }
       } else if (word.startsWith("-O") && word.length > 2) {
@@ -35360,9 +35533,9 @@ function detectGitDestructive(cmd) {
   if (first === "checkout") {
     const dashDashIdx = suffixWords.indexOf("--");
     if (dashDashIdx !== -1 && dashDashIdx + 1 < suffixWords.length) {
-      const path68 = suffixWords[dashDashIdx + 1];
-      const op = path68 === "." ? "git checkout -- ." : "git checkout --";
-      results.push({ category: "git_destructive", operator: op, path: path68 });
+      const path69 = suffixWords[dashDashIdx + 1];
+      const op = path69 === "." ? "git checkout -- ." : "git checkout --";
+      results.push({ category: "git_destructive", operator: op, path: path69 });
     }
   } else if (first === "restore") {
     const hasHard = suffixWords.some((w) => w === "--hard" || w === "-H" || w.startsWith("-") && w.includes("H"));
@@ -35482,10 +35655,10 @@ function detectPowerShellWrites(command) {
   if (redirectMatch) {
     const beforeRedirect = redirectMatch[1];
     const op = redirectMatch[2];
-    const path68 = redirectMatch[3];
+    const path69 = redirectMatch[3];
     const fdRedirectPattern = /\d>\s*$|\s\d>&$/;
     if (!fdRedirectPattern.test(`${beforeRedirect} ${op}`)) {
-      results.push({ category: "redirect", operator: op, path: path68 });
+      results.push({ category: "redirect", operator: op, path: path69 });
     }
   }
   const leadingRedirect = innerCommand.match(/^((?:>){1,2})\s+(\S+)$/);
@@ -35498,12 +35671,12 @@ function detectPowerShellWrites(command) {
   }
   const iwrMatch = trimmed.match(/^(?:Invoke-WebRequest|curl)\s.*?(?:-OutFile\s+(\S+)|-o\s+(\S+))/i);
   if (iwrMatch) {
-    const path68 = iwrMatch[1] || iwrMatch[2];
-    if (path68) {
+    const path69 = iwrMatch[1] || iwrMatch[2];
+    if (path69) {
       results.push({
         category: "network_download",
         operator: "Invoke-WebRequest -OutFile",
-        path: path68
+        path: path69
       });
     }
   }
@@ -35515,15 +35688,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 path68 = pathFlagMatch[2] ?? pathFlagMatch[3] ?? pathFlagMatch[4] ?? "";
-      return { category: "redirect", operator: cmdletName, path: path68 };
+      const path69 = pathFlagMatch[2] ?? pathFlagMatch[3] ?? pathFlagMatch[4] ?? "";
+      return { category: "redirect", operator: cmdletName, path: path69 };
     }
     const tokens = rest.match(/(?:[^\s"-]+|"[^"]*"|'[^']*'|-[^\s]+)/g) ?? [];
     for (const token of tokens) {
       if (token.startsWith("-"))
         continue;
-      const path68 = token.replace(/^["']|["']$/g, "");
-      return { category: "redirect", operator: cmdletName, path: path68 };
+      const path69 = token.replace(/^["']|["']$/g, "");
+      return { category: "redirect", operator: cmdletName, path: path69 };
     }
     return null;
   }
@@ -35539,9 +35712,9 @@ function detectPowerShellWrites(command) {
     for (const token of tokens) {
       if (token.startsWith("-"))
         continue;
-      const path68 = token.replace(/^["']|["']$/g, "");
-      if (path68) {
-        results.push({ category: "redirect", operator: cmdletName, path: path68 });
+      const path69 = token.replace(/^["']|["']$/g, "");
+      if (path69) {
+        results.push({ category: "redirect", operator: cmdletName, path: path69 });
         break;
       }
     }
@@ -35554,8 +35727,8 @@ function detectPowerShellWrites(command) {
     const rest = cmd.slice(opMatch[0].length).trim();
     const destFlagMatch = rest.match(/-Destination\s+(\S+|"[^"]+"|'[^']+')/i);
     if (destFlagMatch) {
-      const path68 = destFlagMatch[1].replace(/^["']|["']$/g, "");
-      return { category: "builtin_write", operator: cmdletName, path: path68 };
+      const path69 = destFlagMatch[1].replace(/^["']|["']$/g, "");
+      return { category: "builtin_write", operator: cmdletName, path: path69 };
     }
     const tokens = [];
     const flagTakingValue = new Set([
@@ -35594,11 +35767,11 @@ function detectPowerShellWrites(command) {
       }
     }
     if (tokens.length >= 2) {
-      const path68 = tokens[tokens.length - 1].replace(/^["']|["']$/g, "");
-      return { category: "builtin_write", operator: cmdletName, path: path68 };
+      const path69 = tokens[tokens.length - 1].replace(/^["']|["']$/g, "");
+      return { category: "builtin_write", operator: cmdletName, path: path69 };
     } else if (tokens.length === 1) {
-      const path68 = tokens[0].replace(/^["']|["']$/g, "");
-      return { category: "builtin_write", operator: cmdletName, path: path68 };
+      const path69 = tokens[0].replace(/^["']|["']$/g, "");
+      return { category: "builtin_write", operator: cmdletName, path: path69 };
     }
     return null;
   }
@@ -35612,14 +35785,14 @@ function detectPowerShellWrites(command) {
     const afterCmdlet = pipeFileOpMatch[2].trim();
     const destFlagMatch = afterCmdlet.match(/-Destination\s+(\S+|"[^"]+"|'[^']+')/i);
     if (destFlagMatch) {
-      const path68 = destFlagMatch[1].replace(/^["']|["']$/g, "");
-      results.push({ category: "builtin_write", operator: cmdletName, path: path68 });
+      const path69 = destFlagMatch[1].replace(/^["']|["']$/g, "");
+      results.push({ category: "builtin_write", operator: cmdletName, path: path69 });
     } else {
       const tokens = afterCmdlet.match(/(?:[^\s"-]+|"[^"]*"|'[^']*'|-[^\s]+)/g) ?? [];
       const nonFlagTokens = tokens.filter((t) => !t.startsWith("-") && t.length > 0);
       if (nonFlagTokens.length > 0) {
-        const path68 = nonFlagTokens[nonFlagTokens.length - 1].replace(/^["']|["']$/g, "");
-        results.push({ category: "builtin_write", operator: cmdletName, path: path68 });
+        const path69 = nonFlagTokens[nonFlagTokens.length - 1].replace(/^["']|["']$/g, "");
+        results.push({ category: "builtin_write", operator: cmdletName, path: path69 });
       }
     }
   }
@@ -35672,10 +35845,10 @@ function detectCmdWrites(command) {
   if (redirectMatch) {
     const beforeRedirect = redirectMatch[1];
     const op = redirectMatch[2];
-    const path68 = redirectMatch[3];
+    const path69 = redirectMatch[3];
     const fdRedirectPattern = /\d>&?$/;
     if (!fdRedirectPattern.test(beforeRedirect)) {
-      results.push({ category: "redirect", operator: op, path: path68 });
+      results.push({ category: "redirect", operator: op, path: path69 });
     }
   }
   const leadingRedirect = innerCommand.match(/^((?:>){1,2})\s+(\S+)$/);
@@ -35733,8 +35906,8 @@ function detectCmdWrites(command) {
     const rawTokens = rest.match(/(\/?[^\s]+|"[^"]*"|'[^']*')/g) ?? [];
     const tokens = rawTokens.filter((t) => !t.startsWith("/"));
     if (tokens.length > 0) {
-      const path68 = tokens[0].replace(/^["']|["']$/g, "");
-      return { category: "builtin_write", operator: "del", path: path68 };
+      const path69 = tokens[0].replace(/^["']|["']$/g, "");
+      return { category: "builtin_write", operator: "del", path: path69 };
     }
     return null;
   }
@@ -35744,16 +35917,16 @@ function detectCmdWrites(command) {
   }
   const rdMatch = innerCommand.match(/^rd\s+(?:\/s\s+|\/q\s+)*(\S+)/i);
   if (rdMatch) {
-    const path68 = rdMatch[1].replace(/^["']|["']$/g, "");
-    if (!path68.startsWith("/")) {
-      results.push({ category: "builtin_write", operator: "rd", path: path68 });
+    const path69 = rdMatch[1].replace(/^["']|["']$/g, "");
+    if (!path69.startsWith("/")) {
+      results.push({ category: "builtin_write", operator: "rd", path: path69 });
     }
   }
   const mdMatch = trimmed.match(/^md\s+(\S+)/i);
   if (mdMatch) {
-    const path68 = mdMatch[1].replace(/^["']|["']$/g, "");
-    if (!path68.startsWith("/")) {
-      results.push({ category: "builtin_write", operator: "md", path: path68 });
+    const path69 = mdMatch[1].replace(/^["']|["']$/g, "");
+    if (!path69.startsWith("/")) {
+      results.push({ category: "builtin_write", operator: "md", path: path69 });
     }
   }
   const echoMatch = trimmed.match(/^echo\s+(\S+.*?)\s+((?:>){1,2})\s*(\S+)$/i);
@@ -35869,9 +36042,10 @@ function resolvePath(pathText, cwd) {
     return null;
   const isWindowsPath = /^[a-zA-Z]:[\\\\/]/.test(cwd) || cwd.includes("\\");
   if (isWindowsPath) {
-    return path67.win32.resolve(cwd, pathText);
+    return path68.win32.resolve(cwd, pathText);
   }
-  return path67.posix.resolve(cwd, pathText);
+  const normalizedRelativeWindowsPath = !path68.posix.isAbsolute(pathText) && !/^[a-zA-Z]:[\\/]/.test(pathText) ? pathText.replace(/\\/g, "/") : pathText;
+  return path68.posix.resolve(cwd, normalizedRelativeWindowsPath);
 }
 function getCdTarget(cmd) {
   if (!cmd || typeof cmd !== "object")
@@ -35938,7 +36112,7 @@ function collectWritesWithNodes(node, out, cwdStack) {
         for (const cmd of node.commands) {
           const cdTarget = getCdTarget(cmd);
           if (cdTarget) {
-            currentStack[0] = path67.posix.resolve(currentStack[0] ?? "/", cdTarget);
+            currentStack[0] = path68.posix.resolve(currentStack[0] ?? "/", cdTarget);
             collectWritesWithNodes(cmd, out, currentStack);
           } else {
             collectWritesWithNodes(cmd, out, currentStack);
@@ -35984,7 +36158,7 @@ function collectWritesWithNodes(node, out, cwdStack) {
       const effectiveCwd = cwdStack[0] ?? "/";
       const cdTarget = getCdTarget(node);
       if (cdTarget) {
-        cwdStack[0] = path67.posix.resolve(cwdStack[0] ?? "/", cdTarget);
+        cwdStack[0] = path68.posix.resolve(cwdStack[0] ?? "/", cdTarget);
         return;
       }
       const writesFromRedirs = getWritesFromCommandRedirs(node, effectiveCwd);
@@ -36030,12 +36204,12 @@ function getWritesFromRedirectNode(redirect, _context) {
   if (!opType || !REDIRECT_ALL_WRITE_TOKENS.has(opType))
     return [];
   const fileNode = r.file;
-  const path68 = extractRedirectPath(fileNode);
+  const path69 = extractRedirectPath(fileNode);
   const opLabel = operatorLabel(opNode);
   if (REDIRECT_WRITE_TOKENS.has(opType)) {
-    return [{ category: "redirect", operator: opLabel, path: path68 }];
+    return [{ category: "redirect", operator: opLabel, path: path69 }];
   } else if (REDIRECT_HERE_TOKENS.has(opType)) {
-    return [{ category: "here_doc", operator: opLabel, path: path68 }];
+    return [{ category: "here_doc", operator: opLabel, path: path69 }];
   }
   return [];
 }
@@ -36156,6 +36330,15 @@ var ACTIVE_PARALLEL_TASK_STATES = new Set([
   "tests_run"
 ]);
 
+// src/hooks/realtime-learning-nudge.ts
+var realtimeLearningNudgeBySession = new Map;
+function resetRealtimeLearningNudgeState() {
+  realtimeLearningNudgeBySession.clear();
+}
+function clearRealtimeLearningNudgeSession(sessionID) {
+  realtimeLearningNudgeBySession.delete(sessionID);
+}
+
 // src/session/worktree-link-suggestion.ts
 import { execFile as execFile3 } from "child_process";
 var GIT_TIMEOUT_MS2 = 1500;
@@ -36298,6 +36481,7 @@ function resetSwarmState() {
   swarmState.environmentProfiles.clear();
   clearPendingCoderScope();
   resetStandardWorktreeIsolationState();
+  resetRealtimeLearningNudgeState();
   _councilDisagreementWarned.clear();
 }
 function resetSwarmStatePreservingSingletons() {
@@ -36436,6 +36620,7 @@ function startAgentSession(sessionId, agentName, staleDurationMs = STALE_SESSION
 }
 function endAgentSession(sessionId) {
   swarmState.agentSessions.delete(sessionId);
+  clearRealtimeLearningNudgeSession(sessionId);
 }
 function getAgentSession(sessionId) {
   return swarmState.agentSessions.get(sessionId);
@@ -36778,8 +36963,8 @@ function evidenceToWorkflowState(evidence) {
 }
 async function readPlanFromDisk(directory) {
   try {
-    const planPath = path68.join(directory, ".swarm", "plan.json");
-    const content = await fs33.readFile(planPath, "utf-8");
+    const planPath = path69.join(directory, ".swarm", "plan.json");
+    const content = await fs32.readFile(planPath, "utf-8");
     const parsed = JSON.parse(content);
     return PlanSchema.parse(parsed);
   } catch {
@@ -36789,8 +36974,8 @@ async function readPlanFromDisk(directory) {
 async function readGateEvidenceFromDisk(directory) {
   const evidenceMap = new Map;
   try {
-    const evidenceDir = path68.join(directory, ".swarm", "evidence");
-    const entries = await fs33.readdir(evidenceDir, { withFileTypes: true });
+    const evidenceDir = path69.join(directory, ".swarm", "evidence");
+    const entries = await fs32.readdir(evidenceDir, { withFileTypes: true });
     for (const entry of entries) {
       if (!entry.isFile() || !entry.name.endsWith(".json")) {
         continue;
@@ -36800,8 +36985,8 @@ async function readGateEvidenceFromDisk(directory) {
         continue;
       }
       try {
-        const filePath = path68.join(evidenceDir, entry.name);
-        const content = await fs33.readFile(filePath, "utf-8");
+        const filePath = path69.join(evidenceDir, entry.name);
+        const content = await fs32.readFile(filePath, "utf-8");
         const parsed = JSON.parse(content);
         if (parsed && typeof parsed.taskId === "string" && Array.isArray(parsed.required_gates)) {
           evidenceMap.set(taskId, parsed);
@@ -36942,7 +37127,7 @@ function hasActiveEpicMode(sessionID) {
 async function rehydratePrSubscriptions(sessionID, directory) {
   const map = new Map;
   try {
-    const { listActive: listActive2 } = await import("./pr-subscriptions-3c34rnm1.js");
+    const { listActive: listActive2 } = await import("./pr-subscriptions-0dpn4epk.js");
     const records = await listActive2(directory);
     for (const record of records) {
       if (record.sessionID !== sessionID)