opencode-swarm 7.121.0 → 7.121.2

package/dist/cli/{index-gmc34yzt.js → index-y0qa3xf0.js}

@@ -65,7 +65,7 @@ import {
   saveTaskSetSnapshot,
   transientBackoff,
   validateProjectRoot
-} from "./index-j5xv8zbp.js";
+} from "./index-emkb0bbe.js";
 import {
   withTimeout
 } from "./index-4905hd2m.js";
@@ -95,15 +95,15 @@ import {
   retireSkill,
   selectCandidateEntries,
   syncBundledProjectSkillsIfMissingAsync
-} from "./index-78b192v7.js";
+} from "./index-x4fwtd59.js";
 import {
   readRecentEscalations
-} from "./index-0k4r8111.js";
+} from "./index-ft6jw816.js";
 import {
   alreadyCuratedThisGeneration,
   claimNextScanBatch,
   resolveCohortId
-} from "./index-0e1v02hq.js";
+} from "./index-j8349ac0.js";
 import {
   CURATOR_INIT_PROMPT,
   CURATOR_PHASE_PROMPT,
@@ -136,11 +136,11 @@ import {
   validateActionability,
   validateActionableFields,
   validateLesson
-} from "./index-3366gs26.js";
+} from "./index-db82jxt7.js";
 import {
   authorizeCuration,
   buildConfigFingerprintInput
-} from "./index-69ms9ny1.js";
+} from "./index-5a3xsnzg.js";
 import {
   cohortConfigFingerprint
 } from "./index-rtry5xyf.js";
@@ -170,7 +170,7 @@ import {
   transactFile,
   transactKnowledge,
   wordBigrams
-} from "./index-rywkdacj.js";
+} from "./index-0f800qg7.js";
 import {
   MAX_EVENT_LOG_ENTRIES,
   _internals,
@@ -180,7 +180,7 @@ import {
   recordHiveKnowledgeEvent,
   recordKnowledgeEvent,
   resolveKnowledgeEventsPath
-} from "./index-nhgw7de8.js";
+} from "./index-35xyj7gn.js";
 import {
   resolveHiveDataDir,
   resolveHiveEventsPath,
@@ -204,7 +204,7 @@ import {
 import {
   PlanSchema,
   RetrospectiveEvidenceSchema
-} from "./index-0mbmfmt0.js";
+} from "./index-qt2yaghg.js";
 import {
   AGENT_TOOL_MAP,
   ALL_SUBAGENT_NAMES,
@@ -271,8 +271,8 @@ import {
 } from "./index-a76rekgs.js";
 
 // src/state.ts
-import * as fs40 from "fs/promises";
-import * as path79 from "path";
+import * as fs41 from "fs/promises";
+import * as path80 from "path";
 
 // src/db/qa-gate-profile.ts
 import { createHash } from "crypto";
@@ -9759,7 +9759,7 @@ async function runCuratorPhase(directory, phase, agentsDispatched, config, knowl
     }
     if (config.skill_generation_enabled === true && skillCandidates.length > 0) {
       try {
-        const skillModule = await import("./skill-generator-tkv7s12g.js");
+        const skillModule = await import("./skill-generator-hkyxdc3j.js");
         for (const cand of skillCandidates) {
           if (cand.confidence < (config.min_skill_confidence ?? DEFAULT_SKILL_MIN_CONFIDENCE)) {
             continue;
@@ -10096,7 +10096,7 @@ async function applyCuratorKnowledgeUpdates(directory, recommendations, knowledg
     } catch {}
   }
   if (contradictedEntries.length > 0 && knowledgeConfig.contradiction_threshold_action === "quarantine") {
-    const { maybeQuarantineOnContradiction } = await import("./knowledge-escalator-0ejqs8c9.js");
+    const { maybeQuarantineOnContradiction } = await import("./knowledge-escalator-8ajq1fhb.js");
     for (const { id } of contradictedEntries) {
       try {
         await maybeQuarantineOnContradiction(directory, id, knowledgeConfig.contradiction_quarantine_threshold, knowledgeConfig.contradiction_quarantine_window_days);
@@ -10894,7 +10894,7 @@ async function runCuratorPostMortem(directory, options = {}) {
       warnings.push("Failed to collect knowledge summary.");
     }
     try {
-      const { getScanStatus } = await import("./scan-cursor-qapm0sxj.js");
+      const { getScanStatus } = await import("./scan-cursor-qmsmmg1b.js");
       const scanStatus = await getScanStatus(directory);
       if (scanStatus.remaining_estimate > 0) {
         warnings.push(`Fair scan: reviewed ${knowledgeSummary.length} entries this sweep (generation ${scanStatus.generation}); ${scanStatus.remaining_estimate} more eligible entries will be visited in future curation sweeps.`);
@@ -11068,7 +11068,7 @@ var _internals15 = {
   loadDefaultKnowledgeConfig: async (directory) => {
     const { KnowledgeConfigSchema: KnowledgeConfigSchema2 } = await import("./schema-vwxpsk6j.js");
     try {
-      const { loadPluginConfigWithMeta: loadPluginConfigWithMeta2 } = await import("./index-fndvr7fr.js");
+      const { loadPluginConfigWithMeta: loadPluginConfigWithMeta2 } = await import("./index-rbfq77sz.js");
       const loaded = loadPluginConfigWithMeta2(directory);
       return KnowledgeConfigSchema2.parse(loaded.config.knowledge ?? {});
     } catch {
@@ -11076,11 +11076,11 @@ var _internals15 = {
     }
   },
   applyCuratorKnowledgeUpdates: async (directory, recommendations, knowledgeConfig, generation) => {
-    const { applyCuratorKnowledgeUpdates: applyCuratorKnowledgeUpdates2 } = await import("./curator-8m0pf9cz.js");
+    const { applyCuratorKnowledgeUpdates: applyCuratorKnowledgeUpdates2 } = await import("./curator-mwvrryf3.js");
     return applyCuratorKnowledgeUpdates2(directory, recommendations, knowledgeConfig, generation);
   },
   checkHivePromotions: async (entries, knowledgeConfig, directory) => {
-    const { checkHivePromotions } = await import("./hive-promoter-8303gnfk.js");
+    const { checkHivePromotions } = await import("./hive-promoter-z4tw1gfv.js");
     return checkHivePromotions(entries, knowledgeConfig, directory);
   },
   applyProposalTriage: async (directory, triage) => {
@@ -11089,7 +11089,7 @@ var _internals15 = {
       activateProposal,
       listSkills: listSkills2,
       sanitizeSlug
-    } = await import("./skill-generator-tkv7s12g.js");
+    } = await import("./skill-generator-hkyxdc3j.js");
     const result = {
       approved: [],
       rejected: [],
@@ -11278,14 +11278,14 @@ async function transactHiveStore(mutate) {
 ` : "");
     await _internals16.atomicWriteFile(hivePath, content);
     if (outcome.rejects && outcome.rejects.length > 0) {
-      const rejectBlock = outcome.rejects.map((r) => JSON.stringify(r)).join(`
-`) + `
+      const rejectBlock = `${outcome.rejects.map((r) => JSON.stringify(r)).join(`
+`)}
 `;
       await appendFile2(rejectedPath, rejectBlock, "utf-8");
     }
     if (outcome.audit && outcome.audit.length > 0) {
-      const auditBlock = outcome.audit.map((a) => a.line).join(`
-`) + `
+      const auditBlock = `${outcome.audit.map((a) => a.line).join(`
+`)}
 `;
       await appendFile2(eventsPath, auditBlock, "utf-8");
       try {
@@ -13557,7 +13557,7 @@ function hashContent(content) {
 async function loadConfigForPolicyCurator(directory) {
   const { KnowledgeConfigSchema: KnowledgeConfigSchema2 } = await import("./schema-vwxpsk6j.js");
   try {
-    const { loadPluginConfigWithMeta: loadPluginConfigWithMeta2 } = await import("./index-fndvr7fr.js");
+    const { loadPluginConfigWithMeta: loadPluginConfigWithMeta2 } = await import("./index-rbfq77sz.js");
     const { config: loadedConfig } = loadPluginConfigWithMeta2(directory);
     return KnowledgeConfigSchema2.parse(loadedConfig.knowledge ?? {});
   } catch {
@@ -18867,8 +18867,8 @@ var _internals28 = {
   loadCuratorDeps: async () => {
     const [{ CuratorConfigSchema }, curator, { createCuratorLLMDelegate: createCuratorLLMDelegate2 }] = await Promise.all([
       import("./schema-vwxpsk6j.js"),
-      import("./curator-8m0pf9cz.js"),
-      import("./curator-llm-factory-jta9tggm.js")
+      import("./curator-mwvrryf3.js"),
+      import("./curator-llm-factory-vcyvbny0.js")
     ]);
     return { CuratorConfigSchema, curator, createCuratorLLMDelegate: createCuratorLLMDelegate2 };
   }
@@ -19366,7 +19366,7 @@ import { fileURLToPath } from "url";
 // package.json
 var package_default = {
   name: "opencode-swarm",
-  version: "7.121.0",
+  version: "7.121.2",
   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",
@@ -19806,7 +19806,7 @@ async function computeCurationDiagnostics(directory, entries) {
   let scanCompleted = false;
   let scanRemaining = 0;
   try {
-    const { getScanStatus } = await import("./scan-cursor-qapm0sxj.js");
+    const { getScanStatus } = await import("./scan-cursor-qmsmmg1b.js");
     const status = await getScanStatus(directory);
     scanGeneration = status.generation;
     scanCompleted = status.completed;
@@ -19819,14 +19819,14 @@ async function computeCurationDiagnostics(directory, entries) {
       const { KnowledgeConfigSchema: KnowledgeConfigSchema2 } = await import("./schema-vwxpsk6j.js");
       let config;
       try {
-        const { loadPluginConfigWithMeta: loadPluginConfigWithMeta2 } = await import("./index-fndvr7fr.js");
+        const { loadPluginConfigWithMeta: loadPluginConfigWithMeta2 } = await import("./index-rbfq77sz.js");
         const loaded = loadPluginConfigWithMeta2(directory);
         config = KnowledgeConfigSchema2.parse(loaded.config.knowledge ?? {});
       } catch {
         config = KnowledgeConfigSchema2.parse({});
       }
       const { cohortConfigFingerprint: cohortConfigFingerprint2 } = await import("./config-fingerprint-v22xh5a2.js");
-      const { buildConfigFingerprintInput: buildConfigFingerprintInput2, readCohortConfigFingerprint } = await import("./curation-policy-re2kaysb.js");
+      const { buildConfigFingerprintInput: buildConfigFingerprintInput2, readCohortConfigFingerprint } = await import("./curation-policy-10wnhpwn.js");
       const currentFp = cohortConfigFingerprint2(buildConfigFingerprintInput2(config));
       const cohortFp = await readCohortConfigFingerprint(directory);
       configMatch = cohortFp === null ? null : currentFp === cohortFp;
@@ -21817,7 +21817,7 @@ async function handleEvidenceCommand(directory, args) {
   return formatTaskEvidenceMarkdown(evidenceData);
 }
 async function handleEvidenceSummaryCommand(directory) {
-  const { buildEvidenceSummary } = await import("./evidence-summary-service-jtx5q3r6.js");
+  const { buildEvidenceSummary } = await import("./evidence-summary-service-k14ykm03.js");
   const artifact = await buildEvidenceSummary(directory);
   if (!artifact) {
     return "No plan found. Run `/swarm plan` to check plan status.";
@@ -27578,6 +27578,8 @@ async function handleHistoryCommand(directory, _args) {
   return formatHistoryMarkdown(historyData);
 }
 // src/commands/issue.ts
+import * as fs24 from "fs";
+import * as path53 from "path";
 var USAGE7 = [
   "Usage: /swarm issue <url|owner/repo#N|N> [--plan] [--trace] [--no-repro]",
   "",
@@ -27663,6 +27665,34 @@ function parseIssueRef(input, directory) {
   }
   return null;
 }
+var _internals41 = {
+  writeFileSync: fs24.writeFileSync,
+  mkdirSync: fs24.mkdirSync,
+  renameSync: fs24.renameSync,
+  unlinkSync: fs24.unlinkSync,
+  readFileSync: fs24.readFileSync,
+  existsSync: fs24.existsSync
+};
+function atomicWriteFileSync(dir, filename, content) {
+  const tmpPath = path53.join(dir, `.tmp-${filename}-${Date.now()}-${process.pid}`);
+  const finalPath = path53.join(dir, filename);
+  _internals41.writeFileSync(tmpPath, content, "utf-8");
+  try {
+    _internals41.renameSync(tmpPath, finalPath);
+  } catch {
+    try {
+      _internals41.unlinkSync(finalPath);
+    } catch {}
+    try {
+      _internals41.renameSync(tmpPath, finalPath);
+    } catch (retryErr) {
+      try {
+        _internals41.unlinkSync(tmpPath);
+      } catch {}
+      throw retryErr;
+    }
+  }
+}
 function handleIssueCommand(directory, args) {
   const parsed = parseArgs8(args);
   const rawInput = parsed.rest.join(" ").trim();
@@ -27681,6 +27711,57 @@ ${USAGE7}`;
   if ("error" in result) {
     return `Error: ${result.error}
 
+${USAGE7}`;
+  }
+  const swarmDir = path53.join(directory, ".swarm");
+  const issueReference = {
+    url: result.sanitized,
+    owner: issueInfo.owner,
+    repo: issueInfo.repo,
+    number: issueInfo.number,
+    timestamp: new Date().toISOString(),
+    flags: {
+      ...parsed.plan && { plan: true },
+      ...parsed.trace && { trace: true },
+      ...parsed.noRepro && { noRepro: true }
+    }
+  };
+  if (parsed.noRepro) {
+    issueReference.noReproWaiver = {
+      waived: true,
+      reason: "--no-repro flag",
+      timestamp: new Date().toISOString()
+    };
+  }
+  const traceState = {
+    issueNumber: issueInfo.number,
+    lastTransition: null,
+    completed: false
+  };
+  let oldTraceState = null;
+  try {
+    oldTraceState = _internals41.readFileSync(path53.join(swarmDir, "issue-trace-state.json"), "utf-8");
+  } catch {}
+  try {
+    _internals41.mkdirSync(swarmDir, { recursive: true });
+    atomicWriteFileSync(swarmDir, "issue-trace-state.json", JSON.stringify(traceState, null, 2));
+    atomicWriteFileSync(swarmDir, "issue-reference.json", JSON.stringify(issueReference, null, 2));
+  } catch (e) {
+    if (oldTraceState !== null) {
+      try {
+        atomicWriteFileSync(swarmDir, "issue-trace-state.json", oldTraceState);
+      } catch {}
+    } else {
+      try {
+        _internals41.unlinkSync(path53.join(swarmDir, "issue-trace-state.json"));
+      } catch {}
+    }
+    try {
+      _internals41.unlinkSync(path53.join(swarmDir, "issue-reference.json"));
+    } catch {}
+    const errMsg = e instanceof Error ? e.message : String(e);
+    return `Error: Failed to persist issue reference durably: ${errMsg}
+
 ${USAGE7}`;
   }
   const flags = [];
@@ -27695,19 +27776,19 @@ ${USAGE7}`;
 }
 
 // src/commands/knowledge.ts
-import { join as join44 } from "path";
+import { join as join45 } from "path";
 
 // src/hooks/knowledge-migrator.ts
 init_logger();
 import { randomUUID as randomUUID7 } from "crypto";
-import { existsSync as existsSync31, readFileSync as readFileSync20 } from "fs";
+import { existsSync as existsSync32, readFileSync as readFileSync21 } from "fs";
 import { mkdir as mkdir12, readFile as readFile13, writeFile as writeFile11 } from "fs/promises";
 import * as os9 from "os";
-import * as path53 from "path";
+import * as path54 from "path";
 async function migrateKnowledgeToExternal(_directory, _config) {
-  const externalSentinelPath = path53.join(_directory, ".swarm", ".knowledge-external-migrated");
-  const contextPath = path53.join(_directory, ".swarm", "context.md");
-  if (_internals41.existsSync(externalSentinelPath)) {
+  const externalSentinelPath = path54.join(_directory, ".swarm", ".knowledge-external-migrated");
+  const contextPath = path54.join(_directory, ".swarm", "context.md");
+  if (_internals42.existsSync(externalSentinelPath)) {
     return {
       migrated: false,
       entriesMigrated: 0,
@@ -27716,7 +27797,7 @@ async function migrateKnowledgeToExternal(_directory, _config) {
       skippedReason: "external-sentinel-exists"
     };
   }
-  if (!_internals41.existsSync(contextPath)) {
+  if (!_internals42.existsSync(contextPath)) {
     return {
       migrated: false,
       entriesMigrated: 0,
@@ -27725,7 +27806,7 @@ async function migrateKnowledgeToExternal(_directory, _config) {
       skippedReason: "no-context-file"
     };
   }
-  const contextContent = await _internals41.readFile(contextPath, "utf-8");
+  const contextContent = await _internals42.readFile(contextPath, "utf-8");
   if (contextContent.trim().length === 0) {
     return {
       migrated: false,
@@ -27743,7 +27824,7 @@ async function migrateKnowledgeToExternal(_directory, _config) {
       entriesCount++;
     }
   }
-  await _internals41.writeSentinel(externalSentinelPath, entriesCount, entriesCount);
+  await _internals42.writeSentinel(externalSentinelPath, entriesCount, entriesCount);
   return {
     migrated: true,
     entriesMigrated: entriesCount,
@@ -27751,7 +27832,7 @@ async function migrateKnowledgeToExternal(_directory, _config) {
     entriesTotal: entriesCount
   };
 }
-var _internals41 = {
+var _internals42 = {
   appendKnowledge,
   migrateContextToKnowledge,
   migrateKnowledgeToExternal,
@@ -27764,17 +27845,17 @@ var _internals41 = {
   inferProjectName,
   writeSentinel,
   resolveLegacyHiveKnowledgePath,
-  existsSync: existsSync31,
-  readFileSync: readFileSync20,
+  existsSync: existsSync32,
+  readFileSync: readFileSync21,
   readFile: readFile13,
   mkdir: mkdir12,
   writeFile: writeFile11
 };
 async function migrateContextToKnowledge(directory, config) {
-  const sentinelPath = path53.join(directory, ".swarm", ".knowledge-migrated");
-  const contextPath = path53.join(directory, ".swarm", "context.md");
+  const sentinelPath = path54.join(directory, ".swarm", ".knowledge-migrated");
+  const contextPath = path54.join(directory, ".swarm", "context.md");
   const knowledgePath = resolveSwarmKnowledgePath(directory);
-  if (existsSync31(sentinelPath)) {
+  if (existsSync32(sentinelPath)) {
     return {
       migrated: false,
       entriesMigrated: 0,
@@ -27783,7 +27864,7 @@ async function migrateContextToKnowledge(directory, config) {
       skippedReason: "sentinel-exists"
     };
   }
-  if (!existsSync31(contextPath)) {
+  if (!existsSync32(contextPath)) {
     return {
       migrated: false,
       entriesMigrated: 0,
@@ -27802,9 +27883,9 @@ async function migrateContextToKnowledge(directory, config) {
       skippedReason: "empty-context"
     };
   }
-  const rawEntries = _internals41.parseContextMd(contextContent);
+  const rawEntries = _internals42.parseContextMd(contextContent);
   if (rawEntries.length === 0) {
-    await _internals41.writeSentinel(sentinelPath, 0, 0);
+    await _internals42.writeSentinel(sentinelPath, 0, 0);
     return {
       migrated: true,
       entriesMigrated: 0,
@@ -27815,10 +27896,10 @@ async function migrateContextToKnowledge(directory, config) {
   const existing = await readKnowledge(knowledgePath);
   let migrated = 0;
   let dropped = 0;
-  const projectName = _internals41.inferProjectName(directory);
+  const projectName = _internals42.inferProjectName(directory);
   for (const raw of rawEntries) {
     if (config.validation_enabled !== false) {
-      const category = raw.categoryHint ?? _internals41.inferCategoryFromText(raw.text);
+      const category = raw.categoryHint ?? _internals42.inferCategoryFromText(raw.text);
       const result = validateLesson(raw.text, existing.map((e) => e.lesson), {
         category,
         scope: "global",
@@ -27838,8 +27919,8 @@ async function migrateContextToKnowledge(directory, config) {
     const entry = {
       id: randomUUID7(),
       tier: "swarm",
-      lesson: _internals41.truncateLesson(raw.text),
-      category: raw.categoryHint ?? _internals41.inferCategoryFromText(raw.text),
+      lesson: _internals42.truncateLesson(raw.text),
+      category: raw.categoryHint ?? _internals42.inferCategoryFromText(raw.text),
       tags: [...inferredTags, `migration:${raw.sourceSection}`],
       scope: "global",
       confidence: 0.3,
@@ -27862,7 +27943,7 @@ async function migrateContextToKnowledge(directory, config) {
   if (migrated > 0) {
     await rewriteKnowledge(knowledgePath, existing);
   }
-  await _internals41.writeSentinel(sentinelPath, migrated, dropped);
+  await _internals42.writeSentinel(sentinelPath, migrated, dropped);
   log(`[knowledge-migrator] Migrated ${migrated} entries, dropped ${dropped}`);
   return {
     migrated: true,
@@ -27872,10 +27953,10 @@ async function migrateContextToKnowledge(directory, config) {
   };
 }
 async function migrateHiveKnowledgeLegacy(config) {
-  const legacyHivePath = _internals41.resolveLegacyHiveKnowledgePath();
+  const legacyHivePath = _internals42.resolveLegacyHiveKnowledgePath();
   const canonicalHivePath = resolveHiveKnowledgePath2();
-  const sentinelPath = path53.join(path53.dirname(canonicalHivePath), ".hive-knowledge-migrated");
-  if (existsSync31(sentinelPath)) {
+  const sentinelPath = path54.join(path54.dirname(canonicalHivePath), ".hive-knowledge-migrated");
+  if (existsSync32(sentinelPath)) {
     return {
       migrated: false,
       entriesMigrated: 0,
@@ -27884,7 +27965,7 @@ async function migrateHiveKnowledgeLegacy(config) {
       skippedReason: "sentinel-exists"
     };
   }
-  if (!existsSync31(legacyHivePath)) {
+  if (!existsSync32(legacyHivePath)) {
     return {
       migrated: false,
       entriesMigrated: 0,
@@ -27895,7 +27976,7 @@ async function migrateHiveKnowledgeLegacy(config) {
   }
   const legacyEntries = await readKnowledge(legacyHivePath);
   if (legacyEntries.length === 0) {
-    await _internals41.writeSentinel(sentinelPath, 0, 0);
+    await _internals42.writeSentinel(sentinelPath, 0, 0);
     return {
       migrated: true,
       entriesMigrated: 0,
@@ -27943,7 +28024,7 @@ async function migrateHiveKnowledgeLegacy(config) {
       const newHiveEntry = {
         id: resolvedId,
         tier: "hive",
-        lesson: _internals41.truncateLesson(lesson),
+        lesson: _internals42.truncateLesson(lesson),
         category,
         tags: ["migration:legacy-hive"],
         scope: scopeTag,
@@ -27962,7 +28043,7 @@ async function migrateHiveKnowledgeLegacy(config) {
         encounter_score: 1
       };
       try {
-        await _internals41.appendKnowledge(canonicalHivePath, newHiveEntry);
+        await _internals42.appendKnowledge(canonicalHivePath, newHiveEntry);
         existingHiveEntries.push(newHiveEntry);
         migrated++;
       } catch (appendError) {
@@ -27978,7 +28059,7 @@ async function migrateHiveKnowledgeLegacy(config) {
       dropped++;
     }
   }
-  await _internals41.writeSentinel(sentinelPath, migrated, dropped);
+  await _internals42.writeSentinel(sentinelPath, migrated, dropped);
   log(`[knowledge-migrator] Migrated ${migrated} legacy hive entries, dropped ${dropped}`);
   return {
     migrated: true,
@@ -27989,7 +28070,7 @@ async function migrateHiveKnowledgeLegacy(config) {
   };
 }
 function parseContextMd(content) {
-  const sections = _internals41.splitIntoSections(content);
+  const sections = _internals42.splitIntoSections(content);
   const entries = [];
   const seen = new Set;
   const sectionPatterns = [
@@ -28005,7 +28086,7 @@ function parseContextMd(content) {
     const match = sectionPatterns.find((sp) => sp.pattern.test(section.heading));
     if (!match)
       continue;
-    const bullets = _internals41.extractBullets(section.body);
+    const bullets = _internals42.extractBullets(section.body);
     for (const bullet of bullets) {
       if (bullet.length < 15)
         continue;
@@ -28014,9 +28095,9 @@ function parseContextMd(content) {
         continue;
       seen.add(normalized);
       entries.push({
-        text: _internals41.truncateLesson(bullet),
+        text: _internals42.truncateLesson(bullet),
         sourceSection: match.sourceSection,
-        categoryHint: _internals41.inferCategoryFromText(bullet)
+        categoryHint: _internals42.inferCategoryFromText(bullet)
       });
     }
   }
@@ -28085,16 +28166,16 @@ function truncateLesson2(text) {
   return `${text.slice(0, 277)}...`;
 }
 function inferProjectName(directory) {
-  const packageJsonPath = path53.join(directory, "package.json");
-  if (existsSync31(packageJsonPath)) {
+  const packageJsonPath = path54.join(directory, "package.json");
+  if (existsSync32(packageJsonPath)) {
     try {
-      const pkg = JSON.parse(readFileSync20(packageJsonPath, "utf-8"));
+      const pkg = JSON.parse(readFileSync21(packageJsonPath, "utf-8"));
       if (pkg.name && typeof pkg.name === "string") {
         return pkg.name;
       }
     } catch {}
   }
-  return path53.basename(directory);
+  return path54.basename(directory);
 }
 async function writeSentinel(sentinelPath, migrated, dropped) {
   const sentinel = {
@@ -28106,21 +28187,21 @@ async function writeSentinel(sentinelPath, migrated, dropped) {
     schema_version: 1,
     migration_tool: "knowledge-migrator.ts"
   };
-  await _internals41.mkdir(path53.dirname(sentinelPath), { recursive: true });
-  await _internals41.writeFile(sentinelPath, JSON.stringify(sentinel, null, 2), "utf-8");
+  await _internals42.mkdir(path54.dirname(sentinelPath), { recursive: true });
+  await _internals42.writeFile(sentinelPath, JSON.stringify(sentinel, null, 2), "utf-8");
 }
 function resolveLegacyHiveKnowledgePath() {
   const platform = process.platform;
   const home = process.env.HOME || os9.homedir();
   let dataDir;
   if (platform === "win32") {
-    dataDir = path53.join(process.env.LOCALAPPDATA || path53.join(home, "AppData", "Local"), "opencode-swarm", "Data");
+    dataDir = path54.join(process.env.LOCALAPPDATA || path54.join(home, "AppData", "Local"), "opencode-swarm", "Data");
   } else if (platform === "darwin") {
-    dataDir = path53.join(home, "Library", "Application Support", "opencode-swarm");
+    dataDir = path54.join(home, "Library", "Application Support", "opencode-swarm");
   } else {
-    dataDir = path53.join(process.env.XDG_DATA_HOME || path53.join(home, ".local", "share"), "opencode-swarm");
+    dataDir = path54.join(process.env.XDG_DATA_HOME || path54.join(home, ".local", "share"), "opencode-swarm");
   }
-  return path53.join(dataDir, "hive-knowledge.jsonl");
+  return path54.join(dataDir, "hive-knowledge.jsonl");
 }
 
 // src/commands/knowledge.ts
@@ -28211,7 +28292,7 @@ async function handleKnowledgeRestoreCommand(directory, args) {
       }
       return `\u274C Entry ${fullId2} could not be unarchived${result.reason ? ` (${result.reason})` : ""}.`;
     }
-    const quarantinePath = join44(resolveKnowledgeStoreDir(directory), "knowledge-quarantined.jsonl");
+    const quarantinePath = join45(resolveKnowledgeStoreDir(directory), "knowledge-quarantined.jsonl");
     const entries = await readKnowledge(quarantinePath);
     const resolved = resolveEntryByPrefix(entries, inputId);
     if ("error" in resolved) {
@@ -28519,7 +28600,7 @@ function timeoutMessage(timeoutMs) {
 async function computeWithTimeout(directory, currentPhase, timeoutMs) {
   const controller = new AbortController;
   let timeout;
-  const metricsPromise = _internals42.computeLearningMetrics(directory, {
+  const metricsPromise = _internals43.computeLearningMetrics(directory, {
     currentPhase,
     signal: controller.signal
   });
@@ -28576,19 +28657,19 @@ ${JSON.stringify({
     return `Error computing learning metrics: ${message}. Run /swarm diagnose to check .swarm/ health.`;
   }
 }
-var _internals42 = {
+var _internals43 = {
   computeLearningMetrics
 };
 
 // src/commands/link.ts
 import { mkdir as mkdir14, writeFile as writeFile12 } from "fs/promises";
-import * as path55 from "path";
+import * as path56 from "path";
 
 // src/knowledge/family-migration.ts
 var import_proper_lockfile5 = __toESM(require_proper_lockfile(), 1);
-import { existsSync as existsSync32, readFileSync as readFileSync21 } from "fs";
+import { existsSync as existsSync33, readFileSync as readFileSync22 } from "fs";
 import { mkdir as mkdir13 } from "fs/promises";
-import * as path54 from "path";
+import * as path55 from "path";
 
 // src/knowledge/family-manifest.ts
 function reqStr(o, field) {
@@ -28693,10 +28774,10 @@ var MIGRATION_LOCK_RETRIES = {
   retries: { retries: 10, minTimeout: 100, maxTimeout: 500 }
 };
 function readJsonl2(filePath) {
-  if (!existsSync32(filePath))
+  if (!existsSync33(filePath))
     return [];
   try {
-    const content = readFileSync21(filePath, "utf-8");
+    const content = readFileSync22(filePath, "utf-8");
     const out = [];
     for (const line of content.split(`
 `)) {
@@ -28713,10 +28794,10 @@ function readJsonl2(filePath) {
   }
 }
 function readJson(filePath) {
-  if (!existsSync32(filePath))
+  if (!existsSync33(filePath))
     return null;
   try {
-    return JSON.parse(readFileSync21(filePath, "utf-8"));
+    return JSON.parse(readFileSync22(filePath, "utf-8"));
   } catch {
     return null;
   }
@@ -28943,7 +29024,7 @@ function validateSerialized(member, serialized) {
   return true;
 }
 function readSourceMember(member, sourceDir) {
-  const filePath = path54.join(sourceDir, member.filename);
+  const filePath = path55.join(sourceDir, member.filename);
   if (member.mergeStrategy === "sum-counters") {
     return readJson(filePath) ?? {};
   }
@@ -29022,7 +29103,7 @@ async function migrateKnowledgeFamily(destinationDir, sourceDir) {
       }
     }
     for (const { member, serialized } of staged) {
-      const destPath = path54.join(destinationDir, member.filename);
+      const destPath = path55.join(destinationDir, member.filename);
       await atomicWriteFile(destPath, serialized);
     }
   } finally {
@@ -29111,7 +29192,7 @@ ${formatStatus(directory)}`;
   let totalSkipped = 0;
   let familySummary = "";
   try {
-    const result = await migrateKnowledgeFamily(linkDir, path55.join(directory, ".swarm"));
+    const result = await migrateKnowledgeFamily(linkDir, path56.join(directory, ".swarm"));
     for (const m of result.perMember) {
       totalMerged += m.merged;
       totalSkipped += m.skipped;
@@ -29142,7 +29223,7 @@ ${formatStatus(directory)}`;
     const config = KnowledgeConfigSchema.parse(loadedConfig.knowledge ?? {});
     const fingerprint = cohortConfigFingerprint(buildConfigFingerprintInput(config));
     await mkdir14(linkDir, { recursive: true });
-    await writeFile12(path55.join(linkDir, "cohort-config.json"), JSON.stringify({ fingerprint, updated_at: new Date().toISOString() }, null, 2), "utf-8");
+    await writeFile12(path56.join(linkDir, "cohort-config.json"), JSON.stringify({ fingerprint, updated_at: new Date().toISOString() }, null, 2), "utf-8");
   } catch {}
   const relinkNote = existing ? `
 (Re-linked from previous link "${existing.linkId}".)` : "";
@@ -29168,7 +29249,7 @@ var MIN_MAX_CYCLES = 1;
 var MAX_MAX_CYCLES = 5;
 async function readLatestLoopState(directory) {
   try {
-    const { readdirSync: readdirSync7, statSync: statSync11, readFileSync: readFileSync22 } = await import("fs");
+    const { readdirSync: readdirSync7, statSync: statSync11, readFileSync: readFileSync23 } = await import("fs");
     const loopDir = `${directory}/.swarm/loop`;
     let latestMtime = 0;
     let latestPath = null;
@@ -29191,14 +29272,14 @@ async function readLatestLoopState(directory) {
     }
     if (!latestPath)
       return null;
-    const raw = readFileSync22(latestPath, "utf-8");
+    const raw = readFileSync23(latestPath, "utf-8");
     const state = JSON.parse(raw);
     return { autonomy: state.params?.autonomy };
   } catch {
     return null;
   }
 }
-var _internals43 = {
+var _internals44 = {
   readLatestLoopState
 };
 var USAGE8 = `Usage: /swarm loop <objective> [--max-cycles 1..5] [--autonomy checkpoint|auto] [--depth standard|exhaustive] [--resume]
@@ -29311,7 +29392,7 @@ ${USAGE8}`;
   }
   let autonomy = parsed.autonomy;
   if (parsed.resume && !parsed.autonomyExplicit) {
-    const state = await _internals43.readLatestLoopState(_directory);
+    const state = await _internals44.readLatestLoopState(_directory);
     if (state?.autonomy && AUTONOMY_LEVELS.has(state.autonomy)) {
       autonomy = state.autonomy;
     }
@@ -29324,13 +29405,13 @@ ${USAGE8}`;
 }
 
 // src/commands/memory.ts
-import { existsSync as existsSync33 } from "fs";
-import * as path58 from "path";
+import { existsSync as existsSync34 } from "fs";
+import * as path59 from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
 // src/memory/evaluation.ts
-import * as fs24 from "fs/promises";
+import * as fs25 from "fs/promises";
 import * as os10 from "os";
-import * as path56 from "path";
+import * as path57 from "path";
 var DEFAULT_PROVIDERS = [
   "local-jsonl",
   "sqlite"
@@ -29342,7 +29423,7 @@ var DEFAULT_MODES = [
 ];
 var DEFAULT_TIMESTAMP = "2026-05-26T12:00:00.000Z";
 async function evaluateMemoryRecallFixtures(options) {
-  const fixtureDirectory = path56.resolve(options.fixtureDirectory);
+  const fixtureDirectory = path57.resolve(options.fixtureDirectory);
   const providers = options.providers ?? DEFAULT_PROVIDERS;
   const modes = options.modes ?? DEFAULT_MODES;
   const generatedAt = new Date().toISOString();
@@ -29351,7 +29432,7 @@ async function evaluateMemoryRecallFixtures(options) {
   for (const fixture of fixtures) {
     const materialized = materializeFixture(fixture);
     for (const providerName of providers) {
-      const tempRoot = await fs24.realpath(await fs24.mkdtemp(path56.join(os10.tmpdir(), "swarm-memory-eval-")));
+      const tempRoot = await fs25.realpath(await fs25.mkdtemp(path57.join(os10.tmpdir(), "swarm-memory-eval-")));
       const provider = createEvaluationProvider(providerName, tempRoot);
       try {
         await provider.initialize?.();
@@ -29394,7 +29475,7 @@ async function evaluateMemoryRecallFixtures(options) {
 async function rmTempRoot(tempRoot) {
   for (let attempt = 0;attempt < 10; attempt++) {
     try {
-      await fs24.rm(tempRoot, { recursive: true, force: true });
+      await fs25.rm(tempRoot, { recursive: true, force: true });
       return;
     } catch (err) {
       if (attempt === 9)
@@ -29404,11 +29485,11 @@ async function rmTempRoot(tempRoot) {
   }
 }
 async function loadRecallEvaluationFixtures(fixtureDirectory) {
-  const entries = await fs24.readdir(fixtureDirectory, { withFileTypes: true });
+  const entries = await fs25.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 fs24.readFile(path56.join(fixtureDirectory, file), "utf-8");
+    const raw = await fs25.readFile(path57.join(fixtureDirectory, file), "utf-8");
     fixtures.push(validateFixture(JSON.parse(raw), file));
   }
   return fixtures;
@@ -29685,8 +29766,8 @@ var CuratorOutputMemoryDecisionSchema = exports_external.object({
 }).passthrough();
 // src/memory/consolidation-log.ts
 import { appendFile as appendFile4, mkdir as mkdir15, readFile as readFile15 } from "fs/promises";
-import * as path57 from "path";
-var LOG_RELATIVE_PATH = path57.join("memory", "consolidation-log.jsonl");
+import * as path58 from "path";
+var LOG_RELATIVE_PATH = path58.join("memory", "consolidation-log.jsonl");
 async function readConsolidationLog(directory) {
   const filePath = validateSwarmPath(directory, LOG_RELATIVE_PATH);
   let raw;
@@ -29709,7 +29790,7 @@ async function readConsolidationLog(directory) {
 }
 
 // src/commands/memory.ts
-var PACKAGE_ROOT = path58.resolve(resolvePackageRootFromModule(fileURLToPath3(import.meta.url)));
+var PACKAGE_ROOT = path59.resolve(resolvePackageRootFromModule(fileURLToPath3(import.meta.url)));
 async function handleMemoryCommand(_directory, _args) {
   return [
     "## Swarm Memory",
@@ -29768,7 +29849,7 @@ async function handleMemoryStatusCommand(directory, _args) {
     `- Provider: \`${config.provider}\``,
     `- Storage: \`${storageDir}\``,
     `- SQLite path: \`${sqlitePath}\``,
-    `- SQLite database exists: \`${existsSync33(sqlitePath)}\``,
+    `- SQLite database exists: \`${existsSync34(sqlitePath)}\``,
     `- Automatic destructive cleanup: \`disabled\``,
     "",
     "### Legacy JSONL"
@@ -30066,7 +30147,7 @@ function resolveCommandMemoryConfig(directory) {
 }
 function parseEvaluateArgs(directory, args) {
   let json = false;
-  let fixtureDirectory = path58.join(PACKAGE_ROOT, "tests", "fixtures", "memory-recall");
+  let fixtureDirectory = path59.join(PACKAGE_ROOT, "tests", "fixtures", "memory-recall");
   for (let i = 0;i < args.length; i++) {
     const arg = args[i];
     if (arg === "--json") {
@@ -30080,10 +30161,10 @@ function parseEvaluateArgs(directory, args) {
           error: "Usage: /swarm memory evaluate [--json] [--fixtures <directory>]"
         };
       }
-      const resolvedFixtures = path58.resolve(directory, next);
-      const canonical = path58.normalize(resolvedFixtures) + path58.sep;
-      const allowedRootA = path58.normalize(directory) + path58.sep;
-      const allowedRootB = path58.normalize(path58.join(PACKAGE_ROOT, "tests", "fixtures", "memory-recall")) + path58.sep;
+      const resolvedFixtures = path59.resolve(directory, next);
+      const canonical = path59.normalize(resolvedFixtures) + path59.sep;
+      const allowedRootA = path59.normalize(directory) + path59.sep;
+      const allowedRootB = path59.normalize(path59.join(PACKAGE_ROOT, "tests", "fixtures", "memory-recall")) + path59.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"
@@ -30122,15 +30203,15 @@ function parseMaintenanceArgs(args, options) {
   return { limit, confirm };
 }
 function resolvePackageRootFromModule(modulePath) {
-  const moduleDir = path58.dirname(modulePath);
-  const leaf = path58.basename(moduleDir);
+  const moduleDir = path59.dirname(modulePath);
+  const leaf = path59.basename(moduleDir);
   if (leaf === "commands" || leaf === "cli") {
-    return path58.resolve(moduleDir, "..", "..");
+    return path59.resolve(moduleDir, "..", "..");
   }
   if (leaf === "dist") {
-    return path58.resolve(moduleDir, "..");
+    return path59.resolve(moduleDir, "..");
   }
-  return path58.resolve(moduleDir, "..");
+  return path59.resolve(moduleDir, "..");
 }
 function formatMigrationResult(label, report) {
   if (!report) {
@@ -30247,15 +30328,15 @@ function truncate(value, maxLength) {
 }
 
 // src/services/plan-service.ts
-var _internals44 = {
+var _internals45 = {
   loadPlanJsonOnly,
   derivePlanMarkdown,
   readSwarmFileAsync
 };
 async function getPlanData(directory, phaseArg) {
-  const plan = await _internals44.loadPlanJsonOnly(directory);
+  const plan = await _internals45.loadPlanJsonOnly(directory);
   if (plan) {
-    const fullMarkdown = _internals44.derivePlanMarkdown(plan);
+    const fullMarkdown = _internals45.derivePlanMarkdown(plan);
     if (phaseArg === undefined || phaseArg === null || phaseArg === "") {
       return {
         hasPlan: true,
@@ -30298,7 +30379,7 @@ async function getPlanData(directory, phaseArg) {
       isLegacy: false
     };
   }
-  const planContent = await _internals44.readSwarmFileAsync(directory, "plan.md");
+  const planContent = await _internals45.readSwarmFileAsync(directory, "plan.md");
   if (!planContent) {
     return {
       hasPlan: false,
@@ -30395,7 +30476,7 @@ async function handlePlanCommand(directory, args) {
   return formatPlanMarkdown(planData);
 }
 // src/commands/post-mortem.ts
-var _internals45 = {
+var _internals46 = {
   createCuratorLLMDelegate,
   runCuratorPostMortem
 };
@@ -30443,10 +30524,10 @@ async function handlePostMortemCommand(directory, args, options) {
     };
     if (options?.sessionID) {
       try {
-        pmOptions.llmDelegate = _internals45.createCuratorLLMDelegate(directory, "postmortem", options.sessionID);
+        pmOptions.llmDelegate = _internals46.createCuratorLLMDelegate(directory, "postmortem", options.sessionID);
       } catch {}
     }
-    const result = await _internals45.runCuratorPostMortem(directory, pmOptions);
+    const result = await _internals46.runCuratorPostMortem(directory, pmOptions);
     const lines = [];
     if (result.success) {
       lines.push("## Post-Mortem Report Generated");
@@ -30603,7 +30684,7 @@ function formatMergeGroupStatus(status, conclusion, htmlUrl) {
   }
   return parts.join(" ");
 }
-var _internals46 = {
+var _internals47 = {
   formatRelativeTime,
   formatMergeGroupStatus,
   listActive,
@@ -30611,7 +30692,7 @@ var _internals46 = {
   parseMergeGroupRuns
 };
 async function handlePrMonitorStatusCommand(directory, _args, sessionID, source) {
-  const allActive = await _internals46.listActive(directory);
+  const allActive = await _internals47.listActive(directory);
   const allSessions = source === "cli";
   const subs = allSessions ? allActive : allActive.filter((record) => record.sessionID === sessionID);
   if (subs.length === 0) {
@@ -30627,7 +30708,7 @@ async function handlePrMonitorStatusCommand(directory, _args, sessionID, source)
     const index = i + 1;
     lines.push(`  ${index}. ${sub.repoFullName}#${sub.prNumber}`);
     lines.push(`     URL: ${sub.prUrl}`);
-    const mergeGroupRuns = await _internals46.listMergeGroupRuns(directory, sub.repoFullName, sub.prNumber);
+    const mergeGroupRuns = await _internals47.listMergeGroupRuns(directory, sub.repoFullName, sub.prNumber);
     if (mergeGroupRuns.runs.length > 0) {
       lines.push("     Merge-group runs:");
       for (const run of mergeGroupRuns.runs) {
@@ -30767,7 +30848,7 @@ async function handlePrSubscribeCommand(directory, args, sessionID) {
   const repoFullName = `${prInfo.owner}/${prInfo.repo}`;
   const prUrl = `https://github.com/${prInfo.owner}/${prInfo.repo}/pull/${prInfo.number}`;
   try {
-    const config = _internals47.loadPluginConfig(directory);
+    const config = _internals48.loadPluginConfig(directory);
     const prMonitorConfig = config.pr_monitor;
     if (!prMonitorConfig?.enabled) {
       return [
@@ -30777,7 +30858,7 @@ async function handlePrSubscribeCommand(directory, args, sessionID) {
       ].join(`
 `);
     }
-    await _internals47.subscribe(directory, {
+    await _internals48.subscribe(directory, {
       sessionID,
       prNumber: prInfo.number,
       repoFullName,
@@ -30805,7 +30886,7 @@ async function handlePrSubscribeCommand(directory, args, sessionID) {
 `);
   }
 }
-var _internals47 = {
+var _internals48 = {
   loadPluginConfig,
   subscribe
 };
@@ -30828,9 +30909,9 @@ async function handlePrUnsubscribeCommand(directory, args, sessionID) {
 `);
   }
   const refToken = rest[0];
-  const prInfo = _internals48.parsePrRef(refToken, directory);
+  const prInfo = _internals49.parsePrRef(refToken, directory);
   if (!prInfo) {
-    if (_internals48.looksLikePrRef(refToken)) {
+    if (_internals49.looksLikePrRef(refToken)) {
       return [
         `Error: Could not resolve PR reference from "${refToken}".`,
         "",
@@ -30851,8 +30932,8 @@ async function handlePrUnsubscribeCommand(directory, args, sessionID) {
   const repoFullName = `${prInfo.owner}/${prInfo.repo}`;
   const prUrl = `https://github.com/${prInfo.owner}/${prInfo.repo}/pull/${prInfo.number}`;
   try {
-    const correlationId = _internals48.buildCorrelationId(sessionID, repoFullName, prInfo.number);
-    const result = await _internals48.unsubscribe(directory, correlationId);
+    const correlationId = _internals49.buildCorrelationId(sessionID, repoFullName, prInfo.number);
+    const result = await _internals49.unsubscribe(directory, correlationId);
     if (!result) {
       return [
         `Not subscribed to ${prUrl}`,
@@ -30879,7 +30960,7 @@ async function handlePrUnsubscribeCommand(directory, args, sessionID) {
 `);
   }
 }
-var _internals48 = {
+var _internals49 = {
   unsubscribe,
   buildCorrelationId,
   parsePrRef,
@@ -30887,12 +30968,12 @@ var _internals48 = {
 };
 
 // src/services/preflight-service.ts
-import * as fs31 from "fs";
-import * as path65 from "path";
+import * as fs32 from "fs";
+import * as path66 from "path";
 
 // src/tools/lint.ts
-import * as fs25 from "fs";
-import * as path59 from "path";
+import * as fs26 from "fs";
+import * as path60 from "path";
 
 // src/utils/path-security.ts
 function containsPathTraversal(str) {
@@ -30948,9 +31029,9 @@ function validateArgs(args) {
 }
 function getLinterCommand(linter, mode, projectDir) {
   const isWindows = process.platform === "win32";
-  const binDir = path59.join(projectDir, "node_modules", ".bin");
-  const biomeBin = isWindows ? path59.join(binDir, "biome.EXE") : path59.join(binDir, "biome");
-  const eslintBin = isWindows ? path59.join(binDir, "eslint.cmd") : path59.join(binDir, "eslint");
+  const binDir = path60.join(projectDir, "node_modules", ".bin");
+  const biomeBin = isWindows ? path60.join(binDir, "biome.EXE") : path60.join(binDir, "biome");
+  const eslintBin = isWindows ? path60.join(binDir, "eslint.cmd") : path60.join(binDir, "eslint");
   switch (linter) {
     case "biome":
       if (mode === "fix") {
@@ -30966,7 +31047,7 @@ function getLinterCommand(linter, mode, projectDir) {
 }
 function getAdditionalLinterCommand(linter, mode, cwd) {
   const gradlewName = process.platform === "win32" ? "gradlew.bat" : "gradlew";
-  const gradlew = fs25.existsSync(path59.join(cwd, gradlewName)) ? path59.join(cwd, gradlewName) : null;
+  const gradlew = fs26.existsSync(path60.join(cwd, gradlewName)) ? path60.join(cwd, gradlewName) : null;
   switch (linter) {
     case "ruff":
       return mode === "fix" ? ["ruff", "check", "--fix", "."] : ["ruff", "check", "."];
@@ -31008,12 +31089,12 @@ function getAdditionalLinterCommand(linter, mode, cwd) {
   }
 }
 function detectRuff(cwd) {
-  if (fs25.existsSync(path59.join(cwd, "ruff.toml")))
+  if (fs26.existsSync(path60.join(cwd, "ruff.toml")))
     return isCommandAvailable("ruff");
   try {
-    const pyproject = path59.join(cwd, "pyproject.toml");
-    if (fs25.existsSync(pyproject)) {
-      const content = fs25.readFileSync(pyproject, "utf-8");
+    const pyproject = path60.join(cwd, "pyproject.toml");
+    if (fs26.existsSync(pyproject)) {
+      const content = fs26.readFileSync(pyproject, "utf-8");
       if (content.includes("[tool.ruff]"))
         return isCommandAvailable("ruff");
     }
@@ -31021,67 +31102,67 @@ function detectRuff(cwd) {
   return false;
 }
 function detectClippy(cwd) {
-  return fs25.existsSync(path59.join(cwd, "Cargo.toml")) && isCommandAvailable("cargo");
+  return fs26.existsSync(path60.join(cwd, "Cargo.toml")) && isCommandAvailable("cargo");
 }
 function detectGolangciLint(cwd) {
-  return fs25.existsSync(path59.join(cwd, "go.mod")) && isCommandAvailable("golangci-lint");
+  return fs26.existsSync(path60.join(cwd, "go.mod")) && isCommandAvailable("golangci-lint");
 }
 function readTextFileSafe(filePath) {
   try {
-    return fs25.readFileSync(filePath, "utf-8");
+    return fs26.readFileSync(filePath, "utf-8");
   } catch {
     return "";
   }
 }
 function phpVendorBin(_cwd, name) {
   const fileName = process.platform === "win32" ? `${name}.bat` : name;
-  return path59.join("vendor", "bin", fileName);
+  return path60.join("vendor", "bin", fileName);
 }
 function phpVendorBinExists(cwd, name) {
-  const local = path59.join(cwd, "vendor", "bin", name);
-  const localWin = path59.join(cwd, "vendor", "bin", `${name}.bat`);
-  return fs25.existsSync(local) || fs25.existsSync(localWin);
+  const local = path60.join(cwd, "vendor", "bin", name);
+  const localWin = path60.join(cwd, "vendor", "bin", `${name}.bat`);
+  return fs26.existsSync(local) || fs26.existsSync(localWin);
 }
 function detectCheckstyle(cwd) {
-  const hasMaven = fs25.existsSync(path59.join(cwd, "pom.xml"));
-  const gradleFiles = ["build.gradle", "build.gradle.kts"].map((file) => path59.join(cwd, file)).filter((file) => fs25.existsSync(file));
-  const hasGradleCheckstyleSignal = fs25.existsSync(path59.join(cwd, "checkstyle.xml")) || fs25.existsSync(path59.join(cwd, "config", "checkstyle", "checkstyle.xml")) || gradleFiles.some((file) => /\bcheckstyle\b/i.test(readTextFileSafe(file)));
-  const hasBinary = hasMaven && isCommandAvailable("mvn") || hasGradleCheckstyleSignal && (fs25.existsSync(path59.join(cwd, "gradlew")) || isCommandAvailable("gradle"));
+  const hasMaven = fs26.existsSync(path60.join(cwd, "pom.xml"));
+  const gradleFiles = ["build.gradle", "build.gradle.kts"].map((file) => path60.join(cwd, file)).filter((file) => fs26.existsSync(file));
+  const hasGradleCheckstyleSignal = fs26.existsSync(path60.join(cwd, "checkstyle.xml")) || fs26.existsSync(path60.join(cwd, "config", "checkstyle", "checkstyle.xml")) || gradleFiles.some((file) => /\bcheckstyle\b/i.test(readTextFileSafe(file)));
+  const hasBinary = hasMaven && isCommandAvailable("mvn") || hasGradleCheckstyleSignal && (fs26.existsSync(path60.join(cwd, "gradlew")) || isCommandAvailable("gradle"));
   return (hasMaven || hasGradleCheckstyleSignal) && hasBinary;
 }
 function hasRootKotlinFile(cwd) {
   try {
-    return fs25.readdirSync(cwd).some((f) => f.endsWith(".kt") || f.endsWith(".kts"));
+    return fs26.readdirSync(cwd).some((f) => f.endsWith(".kt") || f.endsWith(".kts"));
   } catch {
     return false;
   }
 }
 function buildGradleHasKotlinSignal(cwd) {
-  const content = readTextFileSafe(path59.join(cwd, "build.gradle"));
+  const content = readTextFileSafe(path60.join(cwd, "build.gradle"));
   return /\b(kotlin|org\.jetbrains\.kotlin|ktlint)\b/i.test(content);
 }
 function detectKtlint(cwd) {
-  const hasKotlin = fs25.existsSync(path59.join(cwd, "build.gradle.kts")) || fs25.existsSync(path59.join(cwd, "build.gradle")) && buildGradleHasKotlinSignal(cwd) || hasRootKotlinFile(cwd);
+  const hasKotlin = fs26.existsSync(path60.join(cwd, "build.gradle.kts")) || fs26.existsSync(path60.join(cwd, "build.gradle")) && buildGradleHasKotlinSignal(cwd) || hasRootKotlinFile(cwd);
   return hasKotlin && isCommandAvailable("ktlint");
 }
 function detectPhpLinter(cwd) {
-  if ((fs25.existsSync(path59.join(cwd, "phpstan.neon")) || fs25.existsSync(path59.join(cwd, "phpstan.neon.dist"))) && phpVendorBinExists(cwd, "phpstan")) {
+  if ((fs26.existsSync(path60.join(cwd, "phpstan.neon")) || fs26.existsSync(path60.join(cwd, "phpstan.neon.dist"))) && phpVendorBinExists(cwd, "phpstan")) {
     return "phpstan";
   }
-  if (fs25.existsSync(path59.join(cwd, "pint.json")) && phpVendorBinExists(cwd, "pint")) {
+  if (fs26.existsSync(path60.join(cwd, "pint.json")) && phpVendorBinExists(cwd, "pint")) {
     return "pint";
   }
-  if (fs25.existsSync(path59.join(cwd, ".php-cs-fixer.php")) && phpVendorBinExists(cwd, "php-cs-fixer")) {
+  if (fs26.existsSync(path60.join(cwd, ".php-cs-fixer.php")) && phpVendorBinExists(cwd, "php-cs-fixer")) {
     return "php-cs-fixer";
   }
-  if (fs25.existsSync(path59.join(cwd, "phpcs.xml")) && phpVendorBinExists(cwd, "phpcs")) {
+  if (fs26.existsSync(path60.join(cwd, "phpcs.xml")) && phpVendorBinExists(cwd, "phpcs")) {
     return "phpcs";
   }
   return null;
 }
 function detectDotnetFormat(cwd) {
   try {
-    const files = fs25.readdirSync(cwd);
+    const files = fs26.readdirSync(cwd);
     const hasCsproj = files.some((f) => f.endsWith(".csproj") || f.endsWith(".sln"));
     return hasCsproj && isCommandAvailable("dotnet");
   } catch {
@@ -31089,14 +31170,14 @@ function detectDotnetFormat(cwd) {
   }
 }
 function detectCppcheck(cwd) {
-  if (fs25.existsSync(path59.join(cwd, "CMakeLists.txt"))) {
+  if (fs26.existsSync(path60.join(cwd, "CMakeLists.txt"))) {
     return isCommandAvailable("cppcheck");
   }
   try {
-    const dirsToCheck = [cwd, path59.join(cwd, "src")];
+    const dirsToCheck = [cwd, path60.join(cwd, "src")];
     const hasCpp = dirsToCheck.some((dir) => {
       try {
-        return fs25.readdirSync(dir).some((f) => /\.(c|cpp|cc|cxx|h|hpp)$/.test(f));
+        return fs26.readdirSync(dir).some((f) => /\.(c|cpp|cc|cxx|h|hpp)$/.test(f));
       } catch {
         return false;
       }
@@ -31107,13 +31188,13 @@ function detectCppcheck(cwd) {
   }
 }
 function detectSwiftlint(cwd) {
-  return fs25.existsSync(path59.join(cwd, "Package.swift")) && isCommandAvailable("swiftlint");
+  return fs26.existsSync(path60.join(cwd, "Package.swift")) && isCommandAvailable("swiftlint");
 }
 function detectDartAnalyze(cwd) {
-  return fs25.existsSync(path59.join(cwd, "pubspec.yaml")) && (isCommandAvailable("dart") || isCommandAvailable("flutter"));
+  return fs26.existsSync(path60.join(cwd, "pubspec.yaml")) && (isCommandAvailable("dart") || isCommandAvailable("flutter"));
 }
 function detectRubocop(cwd) {
-  return (fs25.existsSync(path59.join(cwd, "Gemfile")) || fs25.existsSync(path59.join(cwd, "gems.rb")) || fs25.existsSync(path59.join(cwd, ".rubocop.yml"))) && (isCommandAvailable("rubocop") || isCommandAvailable("bundle"));
+  return (fs26.existsSync(path60.join(cwd, "Gemfile")) || fs26.existsSync(path60.join(cwd, "gems.rb")) || fs26.existsSync(path60.join(cwd, ".rubocop.yml"))) && (isCommandAvailable("rubocop") || isCommandAvailable("bundle"));
 }
 function detectAdditionalLinter(cwd) {
   if (detectRuff(cwd))
@@ -31144,10 +31225,10 @@ function detectAdditionalLinter(cwd) {
 function findBinInAncestors(startDir, binName) {
   let dir = startDir;
   while (true) {
-    const candidate = path59.join(dir, "node_modules", ".bin", binName);
-    if (fs25.existsSync(candidate))
+    const candidate = path60.join(dir, "node_modules", ".bin", binName);
+    if (fs26.existsSync(candidate))
       return candidate;
-    const parent = path59.dirname(dir);
+    const parent = path60.dirname(dir);
     if (parent === dir)
       break;
     dir = parent;
@@ -31156,11 +31237,11 @@ function findBinInAncestors(startDir, binName) {
 }
 function findBinInEnvPath(binName) {
   const searchPath = process.env.PATH ?? "";
-  for (const dir of searchPath.split(path59.delimiter)) {
+  for (const dir of searchPath.split(path60.delimiter)) {
     if (!dir)
       continue;
-    const candidate = path59.join(dir, binName);
-    if (fs25.existsSync(candidate))
+    const candidate = path60.join(dir, binName);
+    if (fs26.existsSync(candidate))
       return candidate;
   }
   return null;
@@ -31168,17 +31249,17 @@ function findBinInEnvPath(binName) {
 async function detectAvailableLinter(directory) {
   if (!directory)
     return null;
-  if (!fs25.existsSync(directory))
+  if (!fs26.existsSync(directory))
     return null;
   const projectDir = directory;
   const isWindows = process.platform === "win32";
-  const biomeBin = isWindows ? path59.join(projectDir, "node_modules", ".bin", "biome.EXE") : path59.join(projectDir, "node_modules", ".bin", "biome");
-  const eslintBin = isWindows ? path59.join(projectDir, "node_modules", ".bin", "eslint.cmd") : path59.join(projectDir, "node_modules", ".bin", "eslint");
+  const biomeBin = isWindows ? path60.join(projectDir, "node_modules", ".bin", "biome.EXE") : path60.join(projectDir, "node_modules", ".bin", "biome");
+  const eslintBin = isWindows ? path60.join(projectDir, "node_modules", ".bin", "eslint.cmd") : path60.join(projectDir, "node_modules", ".bin", "eslint");
   const localResult = await _detectAvailableLinter(projectDir, biomeBin, eslintBin);
   if (localResult)
     return localResult;
-  const biomeAncestor = findBinInAncestors(path59.dirname(projectDir), isWindows ? "biome.EXE" : "biome");
-  const eslintAncestor = findBinInAncestors(path59.dirname(projectDir), isWindows ? "eslint.cmd" : "eslint");
+  const biomeAncestor = findBinInAncestors(path60.dirname(projectDir), isWindows ? "biome.EXE" : "biome");
+  const eslintAncestor = findBinInAncestors(path60.dirname(projectDir), isWindows ? "eslint.cmd" : "eslint");
   if (biomeAncestor || eslintAncestor) {
     return _detectAvailableLinter(projectDir, biomeAncestor ?? biomeBin, eslintAncestor ?? eslintBin);
   }
@@ -31201,7 +31282,7 @@ async function _detectAvailableLinter(_projectDir, biomeBin, eslintBin) {
     const result = await Promise.race([biomeExit, timeout]);
     if (result === "timeout") {
       biomeProc.kill();
-    } else if (biomeProc.exitCode === 0 && fs25.existsSync(biomeBin)) {
+    } else if (biomeProc.exitCode === 0 && fs26.existsSync(biomeBin)) {
       return "biome";
     }
   } catch {}
@@ -31215,7 +31296,7 @@ async function _detectAvailableLinter(_projectDir, biomeBin, eslintBin) {
     const result = await Promise.race([eslintExit, timeout]);
     if (result === "timeout") {
       eslintProc.kill();
-    } else if (eslintProc.exitCode === 0 && fs25.existsSync(eslintBin)) {
+    } else if (eslintProc.exitCode === 0 && fs26.existsSync(eslintBin)) {
       return "eslint";
     }
   } catch {}
@@ -31361,15 +31442,15 @@ var lint = createSwarmTool({
     }
     const { mode } = args;
     const cwd = directory;
-    const linter = await _internals49.detectAvailableLinter(directory);
+    const linter = await _internals50.detectAvailableLinter(directory);
     if (linter) {
-      const result = await _internals49.runLint(linter, mode, directory);
+      const result = await _internals50.runLint(linter, mode, directory);
       return JSON.stringify(result, null, 2);
     }
-    const additionalLinter = _internals49.detectAdditionalLinter(cwd);
+    const additionalLinter = _internals50.detectAdditionalLinter(cwd);
     if (additionalLinter) {
       warn(`[lint] Using ${additionalLinter} linter for this project`);
-      const result = await _internals49.runAdditionalLint(additionalLinter, mode, cwd);
+      const result = await _internals50.runAdditionalLint(additionalLinter, mode, cwd);
       return JSON.stringify(result, null, 2);
     }
     const errorResult = {
@@ -31383,7 +31464,7 @@ For Rust: rustup component add clippy`
     return JSON.stringify(errorResult, null, 2);
   }
 });
-var _internals49 = {
+var _internals50 = {
   detectAvailableLinter,
   runLint,
   detectAdditionalLinter,
@@ -31391,8 +31472,8 @@ var _internals49 = {
 };
 
 // src/tools/secretscan.ts
-import * as fs26 from "fs";
-import * as path60 from "path";
+import * as fs27 from "fs";
+import * as path61 from "path";
 var MAX_FILE_PATH_LENGTH = 500;
 var MAX_FILE_SIZE_BYTES3 = 512 * 1024;
 var MAX_FILES_SCANNED2 = 1000;
@@ -31619,11 +31700,11 @@ function isGlobOrPathPattern(pattern) {
   return pattern.includes("/") || pattern.includes("\\") || /[*?[\]{}]/.test(pattern);
 }
 function loadSecretScanIgnore(scanDir) {
-  const ignorePath = path60.join(scanDir, ".secretscanignore");
+  const ignorePath = path61.join(scanDir, ".secretscanignore");
   try {
-    if (!fs26.existsSync(ignorePath))
+    if (!fs27.existsSync(ignorePath))
       return [];
-    const content = fs26.readFileSync(ignorePath, "utf8");
+    const content = fs27.readFileSync(ignorePath, "utf8");
     const patterns = [];
     for (const rawLine of content.split(/\r?\n/)) {
       const line = rawLine.trim();
@@ -31642,7 +31723,7 @@ function isExcluded(entry, relPath, exactNames, globPatterns) {
   if (exactNames.has(entry))
     return true;
   for (const pattern of globPatterns) {
-    if (path60.matchesGlob(relPath, pattern))
+    if (path61.matchesGlob(relPath, pattern))
       return true;
   }
   return false;
@@ -31663,7 +31744,7 @@ function validateDirectoryInput(dir) {
   return null;
 }
 function isBinaryFile(filePath, buffer) {
-  const ext = path60.extname(filePath).toLowerCase();
+  const ext = path61.extname(filePath).toLowerCase();
   if (DEFAULT_EXCLUDE_EXTENSIONS.has(ext)) {
     return true;
   }
@@ -31738,11 +31819,11 @@ function createRedactedContext(line, findings) {
   result += line.slice(lastEnd);
   return result;
 }
-var O_NOFOLLOW = process.platform !== "win32" ? fs26.constants.O_NOFOLLOW : undefined;
+var O_NOFOLLOW = process.platform !== "win32" ? fs27.constants.O_NOFOLLOW : undefined;
 function scanFileForSecrets(filePath) {
   const findings = [];
   try {
-    const lstat = fs26.lstatSync(filePath);
+    const lstat = fs27.lstatSync(filePath);
     if (lstat.isSymbolicLink()) {
       return findings;
     }
@@ -31751,14 +31832,14 @@ function scanFileForSecrets(filePath) {
     }
     let buffer;
     if (O_NOFOLLOW !== undefined) {
-      const fd = fs26.openSync(filePath, "r", O_NOFOLLOW);
+      const fd = fs27.openSync(filePath, "r", O_NOFOLLOW);
       try {
-        buffer = fs26.readFileSync(fd);
+        buffer = fs27.readFileSync(fd);
       } finally {
-        fs26.closeSync(fd);
+        fs27.closeSync(fd);
       }
     } else {
-      buffer = fs26.readFileSync(filePath);
+      buffer = fs27.readFileSync(filePath);
     }
     if (isBinaryFile(filePath, buffer)) {
       return findings;
@@ -31800,9 +31881,9 @@ function isSymlinkLoop(realPath, visited) {
   return false;
 }
 function isPathWithinScope(realPath, scanDir) {
-  const resolvedScanDir = path60.resolve(scanDir);
-  const resolvedRealPath = path60.resolve(realPath);
-  return resolvedRealPath === resolvedScanDir || resolvedRealPath.startsWith(resolvedScanDir + path60.sep) || resolvedRealPath.startsWith(`${resolvedScanDir}/`) || resolvedRealPath.startsWith(`${resolvedScanDir}\\`);
+  const resolvedScanDir = path61.resolve(scanDir);
+  const resolvedRealPath = path61.resolve(realPath);
+  return resolvedRealPath === resolvedScanDir || resolvedRealPath.startsWith(resolvedScanDir + path61.sep) || resolvedRealPath.startsWith(`${resolvedScanDir}/`) || resolvedRealPath.startsWith(`${resolvedScanDir}\\`);
 }
 function findScannableFiles(dir, excludeExact, excludeGlobs, scanDir, visited, stats = {
   skippedDirs: 0,
@@ -31813,7 +31894,7 @@ function findScannableFiles(dir, excludeExact, excludeGlobs, scanDir, visited, s
   const files = [];
   let entries;
   try {
-    entries = fs26.readdirSync(dir);
+    entries = fs27.readdirSync(dir);
   } catch {
     stats.fileErrors++;
     return files;
@@ -31828,15 +31909,15 @@ function findScannableFiles(dir, excludeExact, excludeGlobs, scanDir, visited, s
     return a.localeCompare(b);
   });
   for (const entry of entries) {
-    const fullPath = path60.join(dir, entry);
-    const relPath = path60.relative(scanDir, fullPath).replace(/\\/g, "/");
+    const fullPath = path61.join(dir, entry);
+    const relPath = path61.relative(scanDir, fullPath).replace(/\\/g, "/");
     if (isExcluded(entry, relPath, excludeExact, excludeGlobs)) {
       stats.skippedDirs++;
       continue;
     }
     let lstat;
     try {
-      lstat = fs26.lstatSync(fullPath);
+      lstat = fs27.lstatSync(fullPath);
     } catch {
       stats.fileErrors++;
       continue;
@@ -31848,7 +31929,7 @@ function findScannableFiles(dir, excludeExact, excludeGlobs, scanDir, visited, s
     if (lstat.isDirectory()) {
       let realPath;
       try {
-        realPath = fs26.realpathSync(fullPath);
+        realPath = fs27.realpathSync(fullPath);
       } catch {
         stats.fileErrors++;
         continue;
@@ -31864,7 +31945,7 @@ function findScannableFiles(dir, excludeExact, excludeGlobs, scanDir, visited, s
       const subFiles = findScannableFiles(fullPath, excludeExact, excludeGlobs, scanDir, visited, stats);
       files.push(...subFiles);
     } else if (lstat.isFile()) {
-      const ext = path60.extname(fullPath).toLowerCase();
+      const ext = path61.extname(fullPath).toLowerCase();
       if (!DEFAULT_EXCLUDE_EXTENSIONS.has(ext)) {
         files.push(fullPath);
       } else {
@@ -31930,15 +32011,15 @@ var secretscan = createSwarmTool({
       }
     }
     try {
-      const _scanDirRaw = path60.resolve(directory);
+      const _scanDirRaw = path61.resolve(directory);
       const scanDir = (() => {
         try {
-          return fs26.realpathSync(_scanDirRaw);
+          return fs27.realpathSync(_scanDirRaw);
         } catch {
           return _scanDirRaw;
         }
       })();
-      if (!fs26.existsSync(scanDir)) {
+      if (!fs27.existsSync(scanDir)) {
         const errorResult = {
           error: "directory not found",
           scan_dir: directory,
@@ -31949,7 +32030,7 @@ var secretscan = createSwarmTool({
         };
         return JSON.stringify(errorResult, null, 2);
       }
-      const dirStat = fs26.statSync(scanDir);
+      const dirStat = fs27.statSync(scanDir);
       if (!dirStat.isDirectory()) {
         const errorResult = {
           error: "target must be a directory, not a file",
@@ -32000,7 +32081,7 @@ var secretscan = createSwarmTool({
           break;
         const fileFindings = scanFileForSecrets(filePath);
         try {
-          const stat4 = fs26.statSync(filePath);
+          const stat4 = fs27.statSync(filePath);
           if (stat4.size > MAX_FILE_SIZE_BYTES3) {
             skippedFiles++;
             continue;
@@ -32071,7 +32152,7 @@ var secretscan = createSwarmTool({
 });
 async function runSecretscan(directory) {
   try {
-    const result = await _internals50.secretscan.execute({ directory }, {});
+    const result = await _internals51.secretscan.execute({ directory }, {});
     const jsonStr = typeof result === "string" ? result : result.output;
     return JSON.parse(jsonStr);
   } catch (e) {
@@ -32096,17 +32177,17 @@ async function runSecretscanOnFiles(files, directory) {
         skippedFiles++;
         continue;
       }
-      const resolvedPath = path60.isAbsolute(file) ? path60.resolve(file) : path60.resolve(directory, file);
+      const resolvedPath = path61.isAbsolute(file) ? path61.resolve(file) : path61.resolve(directory, file);
       if (!isPathWithinScope(resolvedPath, directory)) {
         skippedFiles++;
         continue;
       }
-      const ext = path60.extname(resolvedPath).toLowerCase();
+      const ext = path61.extname(resolvedPath).toLowerCase();
       if (DEFAULT_EXCLUDE_EXTENSIONS.has(ext)) {
         skippedFiles++;
         continue;
       }
-      if (!fs26.existsSync(resolvedPath)) {
+      if (!fs27.existsSync(resolvedPath)) {
         skippedFiles++;
         continue;
       }
@@ -32143,7 +32224,7 @@ async function runSecretscanOnFiles(files, directory) {
     };
   }
 }
-var _internals50 = {
+var _internals51 = {
   secretscan,
   runSecretscan,
   runSecretscanOnFiles,
@@ -32151,12 +32232,12 @@ var _internals50 = {
 };
 
 // src/tools/test-runner.ts
-import * as fs30 from "fs";
-import * as path64 from "path";
+import * as fs31 from "fs";
+import * as path65 from "path";
 
 // src/test-impact/analyzer.ts
-import fs27 from "fs";
-import path61 from "path";
+import fs28 from "fs";
+import path62 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;
@@ -32183,7 +32264,7 @@ function sharedTrailingSegments(a, b) {
 function isCacheStale(impactMap, generatedAtMs) {
   for (const sourcePath of Object.keys(impactMap)) {
     try {
-      const stat4 = fs27.statSync(sourcePath);
+      const stat4 = fs28.statSync(sourcePath);
       if (stat4.mtimeMs > generatedAtMs) {
         return true;
       }
@@ -32197,15 +32278,15 @@ function resolveRelativeImport(fromDir, importPath) {
   if (!importPath.startsWith(".")) {
     return null;
   }
-  const resolved = path61.resolve(fromDir, importPath);
-  if (path61.extname(resolved)) {
-    if (fs27.existsSync(resolved) && fs27.statSync(resolved).isFile()) {
+  const resolved = path62.resolve(fromDir, importPath);
+  if (path62.extname(resolved)) {
+    if (fs28.existsSync(resolved) && fs28.statSync(resolved).isFile()) {
       return normalizePath2(resolved);
     }
   } else {
     for (const ext of EXTENSIONS_TO_TRY) {
       const withExt = resolved + ext;
-      if (fs27.existsSync(withExt) && fs27.statSync(withExt).isFile()) {
+      if (fs28.existsSync(withExt) && fs28.statSync(withExt).isFile()) {
         return normalizePath2(withExt);
       }
     }
@@ -32218,30 +32299,30 @@ function resolvePythonImport(fromDir, module) {
   const leadingDots = module.match(/^\.+/)?.[0].length ?? 0;
   let baseDir = fromDir;
   for (let i = 1;i < leadingDots; i++) {
-    baseDir = path61.dirname(baseDir);
+    baseDir = path62.dirname(baseDir);
   }
   const rest = module.slice(leadingDots);
   if (rest.length === 0) {
-    const initPath = path61.join(baseDir, "__init__.py");
-    if (fs27.existsSync(initPath) && fs27.statSync(initPath).isFile()) {
+    const initPath = path62.join(baseDir, "__init__.py");
+    if (fs28.existsSync(initPath) && fs28.statSync(initPath).isFile()) {
       return normalizePath2(initPath);
     }
     return null;
   }
-  const subpath = rest.replace(/\./g, path61.sep);
+  const subpath = rest.replace(/\./g, path62.sep);
   const candidates = [
-    `${path61.join(baseDir, subpath)}.py`,
-    path61.join(baseDir, subpath, "__init__.py")
+    `${path62.join(baseDir, subpath)}.py`,
+    path62.join(baseDir, subpath, "__init__.py")
   ];
   for (const c of candidates) {
-    if (fs27.existsSync(c) && fs27.statSync(c).isFile())
+    if (fs28.existsSync(c) && fs28.statSync(c).isFile())
       return normalizePath2(c);
   }
   return null;
 }
 var goModuleCache = new Map;
 function findGoModule(fromDir) {
-  const resolved = path61.resolve(fromDir);
+  const resolved = path62.resolve(fromDir);
   let cur = resolved;
   const walked = [];
   for (let i = 0;i < 16; i++) {
@@ -32253,8 +32334,8 @@ function findGoModule(fromDir) {
     }
     walked.push(cur);
     try {
-      const goMod = path61.join(cur, "go.mod");
-      const content = fs27.readFileSync(goMod, "utf-8");
+      const goMod = path62.join(cur, "go.mod");
+      const content = fs28.readFileSync(goMod, "utf-8");
       const moduleMatch = content.match(/^\s*module\s+"?([^"\s/]+(?:\/[^"\s]+)*)"?/m);
       if (moduleMatch) {
         const result = { moduleRoot: cur, modulePath: moduleMatch[1] };
@@ -32264,10 +32345,10 @@ function findGoModule(fromDir) {
       }
     } catch {}
     try {
-      fs27.accessSync(path61.join(cur, ".git"));
+      fs28.accessSync(path62.join(cur, ".git"));
       break;
     } catch {}
-    const parent = path61.dirname(cur);
+    const parent = path62.dirname(cur);
     if (parent === cur)
       break;
     cur = parent;
@@ -32279,20 +32360,20 @@ function findGoModule(fromDir) {
 function resolveGoImport(fromDir, importPath) {
   let dir = null;
   if (importPath.startsWith(".")) {
-    dir = path61.resolve(fromDir, importPath);
+    dir = path62.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 = path61.join(mod.moduleRoot, subpath);
+      dir = path62.join(mod.moduleRoot, subpath);
     }
   }
   if (dir === null)
     return [];
-  if (!fs27.existsSync(dir) || !fs27.statSync(dir).isDirectory())
+  if (!fs28.existsSync(dir) || !fs28.statSync(dir).isDirectory())
     return [];
   try {
-    return fs27.readdirSync(dir).filter((f) => f.endsWith(".go") && !f.endsWith("_test.go")).map((f) => normalizePath2(path61.join(dir, f)));
+    return fs28.readdirSync(dir).filter((f) => f.endsWith(".go") && !f.endsWith("_test.go")).map((f) => normalizePath2(path62.join(dir, f)));
   } catch {
     return [];
   }
@@ -32312,13 +32393,13 @@ function findTestFilesSync(cwd) {
   function walk(dir, visitedInodes) {
     let entries;
     try {
-      entries = fs27.readdirSync(dir, { withFileTypes: true });
+      entries = fs28.readdirSync(dir, { withFileTypes: true });
     } catch {
       return;
     }
     let dirInode;
     try {
-      dirInode = fs27.statSync(dir).ino;
+      dirInode = fs28.statSync(dir).ino;
     } catch {
       return;
     }
@@ -32331,15 +32412,15 @@ function findTestFilesSync(cwd) {
     for (const entry of entries) {
       if (entry.isDirectory()) {
         if (!skipDirs.has(entry.name)) {
-          walk(path61.join(dir, entry.name), visitedInodes);
+          walk(path62.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(`${path61.sep}tests${path61.sep}`) && name.endsWith(".py");
+        const isPyTest = /^test_.+\.py$/.test(name) || /.+_test\.py$/.test(name) || dir.includes(`${path62.sep}tests${path62.sep}`) && name.endsWith(".py");
         const isGoTest = /.+_test\.go$/.test(name);
         if (isTsTest || isPyTest || isGoTest) {
-          testFiles.push(normalizePath2(path61.join(dir, entry.name)));
+          testFiles.push(normalizePath2(path62.join(dir, entry.name)));
         }
       }
     }
@@ -32364,8 +32445,8 @@ function extractImports(content) {
   ];
 }
 function addImpactEdgesForTestFile(testFile, content, impactMap) {
-  const ext = path61.extname(testFile).toLowerCase();
-  const testDir = path61.dirname(testFile);
+  const ext = path62.extname(testFile).toLowerCase();
+  const testDir = path62.dirname(testFile);
   function addEdge(source) {
     if (!impactMap[source])
       impactMap[source] = [];
@@ -32408,7 +32489,7 @@ async function buildImpactMapInternal(cwd) {
   for (const testFile of testFiles) {
     let content;
     try {
-      content = fs27.readFileSync(testFile, "utf-8");
+      content = fs28.readFileSync(testFile, "utf-8");
     } catch {
       continue;
     }
@@ -32419,7 +32500,7 @@ async function buildImpactMapInternal(cwd) {
   }
   return impactMap;
 }
-var _internals51 = {
+var _internals52 = {
   validateProjectRoot,
   normalizePath: normalizePath2,
   isCacheStale,
@@ -32434,22 +32515,22 @@ var _internals51 = {
   _clearGoModuleCache
 };
 async function buildImpactMap(cwd) {
-  const impactMap = await _internals51.buildImpactMapInternal(cwd);
-  await _internals51.saveImpactMap(cwd, impactMap);
+  const impactMap = await _internals52.buildImpactMapInternal(cwd);
+  await _internals52.saveImpactMap(cwd, impactMap);
   return impactMap;
 }
 async function loadImpactMap(cwd, options) {
-  const cachePath = path61.join(cwd, ".swarm", "cache", "impact-map.json");
-  if (fs27.existsSync(cachePath)) {
+  const cachePath = path62.join(cwd, ".swarm", "cache", "impact-map.json");
+  if (fs28.existsSync(cachePath)) {
     try {
-      const content = fs27.readFileSync(cachePath, "utf-8");
+      const content = fs28.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;
         const hasValidValues = Object.values(map).every((v) => Array.isArray(v) && v.every((item) => typeof item === "string"));
         if (hasValidValues) {
           const generatedAt = new Date(data.generatedAt).getTime();
-          if (!_internals51.isCacheStale(map, generatedAt)) {
+          if (!_internals52.isCacheStale(map, generatedAt)) {
             return map;
           }
           if (options?.skipRebuild) {
@@ -32469,24 +32550,24 @@ async function loadImpactMap(cwd, options) {
   if (options?.skipRebuild) {
     return {};
   }
-  return _internals51.buildImpactMap(cwd);
+  return _internals52.buildImpactMap(cwd);
 }
 async function saveImpactMap(cwd, impactMap) {
-  if (!path61.isAbsolute(cwd)) {
+  if (!path62.isAbsolute(cwd)) {
     throw new Error(`saveImpactMap requires an absolute project root path, got: "${cwd}"`);
   }
-  _internals51.validateProjectRoot(cwd);
-  const cacheDir2 = path61.join(cwd, ".swarm", "cache");
-  const cachePath = path61.join(cacheDir2, "impact-map.json");
-  if (!fs27.existsSync(cacheDir2)) {
-    fs27.mkdirSync(cacheDir2, { recursive: true });
+  _internals52.validateProjectRoot(cwd);
+  const cacheDir2 = path62.join(cwd, ".swarm", "cache");
+  const cachePath = path62.join(cacheDir2, "impact-map.json");
+  if (!fs28.existsSync(cacheDir2)) {
+    fs28.mkdirSync(cacheDir2, { recursive: true });
   }
   const data = {
     generatedAt: new Date().toISOString(),
     fileCount: Object.keys(impactMap).length,
     map: impactMap
   };
-  fs27.writeFileSync(cachePath, JSON.stringify(data, null, 2), "utf-8");
+  fs28.writeFileSync(cachePath, JSON.stringify(data, null, 2), "utf-8");
 }
 async function analyzeImpact(changedFiles, cwd, budget) {
   if (!Array.isArray(changedFiles)) {
@@ -32499,7 +32580,7 @@ async function analyzeImpact(changedFiles, cwd, budget) {
     };
   }
   const validFiles = changedFiles.filter((f) => typeof f === "string" && f.length > 0 && !f.includes("\x00"));
-  const impactMap = await _internals51.loadImpactMap(cwd);
+  const impactMap = await _internals52.loadImpactMap(cwd);
   const impactedTestsSet = new Set;
   const untestedFiles = [];
   let visitedCount = 0;
@@ -32509,7 +32590,7 @@ async function analyzeImpact(changedFiles, cwd, budget) {
       budgetExceeded = true;
       break;
     }
-    const normalizedChanged = normalizePath2(path61.resolve(changedFile));
+    const normalizedChanged = normalizePath2(path62.resolve(changedFile));
     const tests = impactMap[normalizedChanged];
     if (tests && tests.length > 0) {
       for (const test of tests) {
@@ -32523,13 +32604,13 @@ async function analyzeImpact(changedFiles, cwd, budget) {
       if (budgetExceeded)
         break;
     } else {
-      const changedDir = normalizePath2(path61.dirname(normalizedChanged));
-      const changedInputDir = normalizePath2(path61.dirname(changedFile));
+      const changedDir = normalizePath2(path62.dirname(normalizedChanged));
+      const changedInputDir = normalizePath2(path62.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(path61.dirname(sourceA));
-        const sourceDirB = normalizePath2(path61.dirname(sourceB));
+        const sourceDirA = normalizePath2(path62.dirname(sourceA));
+        const sourceDirB = normalizePath2(path62.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)
@@ -32667,8 +32748,8 @@ function detectFlakyTests(allHistory) {
 }
 
 // src/test-impact/history-store.ts
-import fs28 from "fs";
-import path62 from "path";
+import fs29 from "fs";
+import path63 from "path";
 var MAX_HISTORY_PER_TEST = 20;
 var MAX_ERROR_LENGTH = 500;
 var MAX_STACK_LENGTH = 200;
@@ -32680,10 +32761,10 @@ function getHistoryPath(workingDir) {
   if (!workingDir) {
     throw new Error("getHistoryPath requires a working directory \u2014 project root must be provided by the caller");
   }
-  if (!path62.isAbsolute(workingDir)) {
+  if (!path63.isAbsolute(workingDir)) {
     throw new Error(`getHistoryPath requires an absolute project root path, got: "${workingDir}"`);
   }
-  return path62.join(workingDir, ".swarm", "cache", "test-history.jsonl");
+  return path63.join(workingDir, ".swarm", "cache", "test-history.jsonl");
 }
 function sanitizeErrorMessage(errorMessage) {
   if (errorMessage === undefined) {
@@ -32775,10 +32856,10 @@ function batchAppendTestRuns(records, workingDir) {
     }
   }
   const historyPath = getHistoryPath(workingDir);
-  const historyDir = path62.dirname(historyPath);
-  _internals52.validateProjectRoot(workingDir);
-  if (!fs28.existsSync(historyDir)) {
-    fs28.mkdirSync(historyDir, { recursive: true });
+  const historyDir = path63.dirname(historyPath);
+  _internals53.validateProjectRoot(workingDir);
+  if (!fs29.existsSync(historyDir)) {
+    fs29.mkdirSync(historyDir, { recursive: true });
   }
   withHistoryWriteLock(historyPath, () => {
     const existingRecords = readAllRecords(historyPath);
@@ -32812,13 +32893,13 @@ function batchAppendTestRuns(records, workingDir) {
 `)}
 `;
       const tempPath = `${historyPath}.tmp`;
-      fs28.writeFileSync(tempPath, content, "utf-8");
-      fs28.renameSync(tempPath, historyPath);
+      fs29.writeFileSync(tempPath, content, "utf-8");
+      fs29.renameSync(tempPath, historyPath);
     } catch (err) {
       try {
         const tempPath = `${historyPath}.tmp`;
-        if (fs28.existsSync(tempPath)) {
-          fs28.unlinkSync(tempPath);
+        if (fs29.existsSync(tempPath)) {
+          fs29.unlinkSync(tempPath);
         }
       } catch {}
       throw new Error(`Failed to write test history: ${err instanceof Error ? err.message : String(err)}`);
@@ -32830,7 +32911,7 @@ function withHistoryWriteLock(historyPath, fn) {
   const deadline = Date.now() + HISTORY_WRITE_LOCK_TIMEOUT_MS;
   while (true) {
     try {
-      fs28.mkdirSync(lockPath);
+      fs29.mkdirSync(lockPath);
       break;
     } catch (error2) {
       const code = error2 instanceof Error && "code" in error2 ? error2.code : undefined;
@@ -32841,9 +32922,9 @@ function withHistoryWriteLock(historyPath, fn) {
         throw new Error(`Timed out waiting for test history lock: ${historyPath}`);
       }
       try {
-        const lockStat = fs28.statSync(lockPath);
+        const lockStat = fs29.statSync(lockPath);
         if (Date.now() - lockStat.mtimeMs >= HISTORY_WRITE_LOCK_STALE_MS) {
-          fs28.rmSync(lockPath, { recursive: true, force: true });
+          fs29.rmSync(lockPath, { recursive: true, force: true });
           continue;
         }
       } catch {}
@@ -32858,7 +32939,7 @@ function withHistoryWriteLock(historyPath, fn) {
     return fn();
   } finally {
     try {
-      fs28.rmSync(lockPath, { recursive: true, force: true });
+      fs29.rmSync(lockPath, { recursive: true, force: true });
     } catch {}
   }
   function sleepSync(ms) {
@@ -32867,11 +32948,11 @@ function withHistoryWriteLock(historyPath, fn) {
   }
 }
 function readAllRecords(historyPath) {
-  if (!fs28.existsSync(historyPath)) {
+  if (!fs29.existsSync(historyPath)) {
     return [];
   }
   try {
-    const content = fs28.readFileSync(historyPath, "utf-8");
+    const content = fs29.readFileSync(historyPath, "utf-8");
     const lines = content.split(`
 `);
     const records = [];
@@ -32899,13 +32980,13 @@ function getAllHistory(workingDir) {
   records.sort((a, b) => new Date(a.timestamp).getTime() - new Date(b.timestamp).getTime());
   return records;
 }
-var _internals52 = {
+var _internals53 = {
   validateProjectRoot
 };
 
 // src/tools/resolve-working-directory.ts
-import * as fs29 from "fs";
-import * as path63 from "path";
+import * as fs30 from "fs";
+import * as path64 from "path";
 function resolveWorkingDirectory(workingDirectory, fallbackDirectory) {
   if (workingDirectory == null || workingDirectory === "") {
     if (typeof fallbackDirectory !== "string" || fallbackDirectory === "") {
@@ -32942,11 +33023,11 @@ function resolveWorkingDirectory(workingDirectory, fallbackDirectory) {
       message: "Invalid working_directory: path traversal sequences (..) are not allowed"
     };
   }
-  const normalizedDir = path63.normalize(workingDirectory);
-  const resolvedDir = path63.resolve(normalizedDir);
+  const normalizedDir = path64.normalize(workingDirectory);
+  const resolvedDir = path64.resolve(normalizedDir);
   let statResult;
   try {
-    statResult = fs29.statSync(resolvedDir);
+    statResult = fs30.statSync(resolvedDir);
   } catch {
     return {
       success: false,
@@ -32962,16 +33043,16 @@ function resolveWorkingDirectory(workingDirectory, fallbackDirectory) {
   if (typeof fallbackDirectory !== "string" || fallbackDirectory === "") {
     return { success: true, directory: resolvedDir };
   }
-  const resolvedFallback = path63.resolve(fallbackDirectory);
+  const resolvedFallback = path64.resolve(fallbackDirectory);
   let fallbackExists = false;
   try {
-    fs29.statSync(resolvedFallback);
+    fs30.statSync(resolvedFallback);
     fallbackExists = true;
   } catch {
     fallbackExists = false;
   }
   if (fallbackExists) {
-    const isSubdirectory = resolvedDir.startsWith(resolvedFallback + path63.sep);
+    const isSubdirectory = resolvedDir.startsWith(resolvedFallback + path64.sep);
     if (isSubdirectory) {
       return {
         success: false,
@@ -32994,7 +33075,7 @@ async function estimateFanOut(sourceFiles, cwd) {
     const impactMap = await loadImpactMap(cwd, { skipRebuild: true });
     const uniqueTestFiles = new Set;
     for (const sourceFile of sourceFiles) {
-      const resolvedPath = path64.resolve(cwd, sourceFile);
+      const resolvedPath = path65.resolve(cwd, sourceFile);
       const normalizedPath = resolvedPath.replace(/\\/g, "/");
       const testFiles = impactMap[normalizedPath];
       if (testFiles) {
@@ -33079,19 +33160,19 @@ function hasDevDependency(devDeps, ...patterns) {
   return hasPackageJsonDependency(devDeps, ...patterns);
 }
 function detectGoTest(cwd) {
-  return fs30.existsSync(path64.join(cwd, "go.mod")) && isCommandAvailable("go");
+  return fs31.existsSync(path65.join(cwd, "go.mod")) && isCommandAvailable("go");
 }
 function detectJavaMaven(cwd) {
-  return fs30.existsSync(path64.join(cwd, "pom.xml")) && isCommandAvailable("mvn");
+  return fs31.existsSync(path65.join(cwd, "pom.xml")) && isCommandAvailable("mvn");
 }
 function detectGradle(cwd) {
-  const hasBuildFile = fs30.existsSync(path64.join(cwd, "build.gradle")) || fs30.existsSync(path64.join(cwd, "build.gradle.kts"));
-  const hasGradlew = fs30.existsSync(path64.join(cwd, "gradlew")) || fs30.existsSync(path64.join(cwd, "gradlew.bat"));
+  const hasBuildFile = fs31.existsSync(path65.join(cwd, "build.gradle")) || fs31.existsSync(path65.join(cwd, "build.gradle.kts"));
+  const hasGradlew = fs31.existsSync(path65.join(cwd, "gradlew")) || fs31.existsSync(path65.join(cwd, "gradlew.bat"));
   return hasBuildFile && (hasGradlew || isCommandAvailable("gradle"));
 }
 function detectDotnetTest(cwd) {
   try {
-    const files = fs30.readdirSync(cwd);
+    const files = fs31.readdirSync(cwd);
     const hasCsproj = files.some((f) => f.endsWith(".csproj"));
     return hasCsproj && isCommandAvailable("dotnet");
   } catch {
@@ -33099,25 +33180,25 @@ function detectDotnetTest(cwd) {
   }
 }
 function detectCTest(cwd) {
-  const hasSource = fs30.existsSync(path64.join(cwd, "CMakeLists.txt"));
-  const hasBuildCache = fs30.existsSync(path64.join(cwd, "CMakeCache.txt")) || fs30.existsSync(path64.join(cwd, "build", "CMakeCache.txt"));
+  const hasSource = fs31.existsSync(path65.join(cwd, "CMakeLists.txt"));
+  const hasBuildCache = fs31.existsSync(path65.join(cwd, "CMakeCache.txt")) || fs31.existsSync(path65.join(cwd, "build", "CMakeCache.txt"));
   return (hasSource || hasBuildCache) && isCommandAvailable("ctest");
 }
 function detectSwiftTest(cwd) {
-  return fs30.existsSync(path64.join(cwd, "Package.swift")) && isCommandAvailable("swift");
+  return fs31.existsSync(path65.join(cwd, "Package.swift")) && isCommandAvailable("swift");
 }
 function detectDartTest(cwd) {
-  return fs30.existsSync(path64.join(cwd, "pubspec.yaml")) && (isCommandAvailable("dart") || isCommandAvailable("flutter"));
+  return fs31.existsSync(path65.join(cwd, "pubspec.yaml")) && (isCommandAvailable("dart") || isCommandAvailable("flutter"));
 }
 function detectRSpec(cwd) {
-  const hasRSpecFile = fs30.existsSync(path64.join(cwd, ".rspec"));
-  const hasGemfile = fs30.existsSync(path64.join(cwd, "Gemfile"));
-  const hasSpecDir = fs30.existsSync(path64.join(cwd, "spec"));
+  const hasRSpecFile = fs31.existsSync(path65.join(cwd, ".rspec"));
+  const hasGemfile = fs31.existsSync(path65.join(cwd, "Gemfile"));
+  const hasSpecDir = fs31.existsSync(path65.join(cwd, "spec"));
   const hasRSpec = hasRSpecFile || hasGemfile && hasSpecDir;
   return hasRSpec && (isCommandAvailable("bundle") || isCommandAvailable("rspec"));
 }
 function detectMinitest(cwd) {
-  return fs30.existsSync(path64.join(cwd, "test")) && (fs30.existsSync(path64.join(cwd, "Gemfile")) || fs30.existsSync(path64.join(cwd, "Rakefile"))) && isCommandAvailable("ruby");
+  return fs31.existsSync(path65.join(cwd, "test")) && (fs31.existsSync(path65.join(cwd, "Gemfile")) || fs31.existsSync(path65.join(cwd, "Rakefile"))) && isCommandAvailable("ruby");
 }
 var DISPATCH_FRAMEWORK_MAP = {
   bun: "bun",
@@ -33207,9 +33288,9 @@ async function parseTestOutputViaDispatch(framework, output, baseDir) {
 async function detectTestFramework(cwd) {
   const baseDir = cwd;
   try {
-    const packageJsonPath = path64.join(baseDir, "package.json");
-    if (fs30.existsSync(packageJsonPath)) {
-      const content = fs30.readFileSync(packageJsonPath, "utf-8");
+    const packageJsonPath = path65.join(baseDir, "package.json");
+    if (fs31.existsSync(packageJsonPath)) {
+      const content = fs31.readFileSync(packageJsonPath, "utf-8");
       const pkg = JSON.parse(content);
       const _deps = pkg.dependencies || {};
       const devDeps = pkg.devDependencies || {};
@@ -33228,38 +33309,38 @@ async function detectTestFramework(cwd) {
         return "jest";
       if (hasDevDependency(devDeps, "mocha", "@types/mocha"))
         return "mocha";
-      if (fs30.existsSync(path64.join(baseDir, "bun.lockb")) || fs30.existsSync(path64.join(baseDir, "bun.lock"))) {
+      if (fs31.existsSync(path65.join(baseDir, "bun.lockb")) || fs31.existsSync(path65.join(baseDir, "bun.lock"))) {
         if (scripts.test?.includes("bun"))
           return "bun";
       }
     }
   } catch {}
   try {
-    const pyprojectTomlPath = path64.join(baseDir, "pyproject.toml");
-    const setupCfgPath = path64.join(baseDir, "setup.cfg");
-    const requirementsTxtPath = path64.join(baseDir, "requirements.txt");
-    if (fs30.existsSync(pyprojectTomlPath)) {
-      const content = fs30.readFileSync(pyprojectTomlPath, "utf-8");
+    const pyprojectTomlPath = path65.join(baseDir, "pyproject.toml");
+    const setupCfgPath = path65.join(baseDir, "setup.cfg");
+    const requirementsTxtPath = path65.join(baseDir, "requirements.txt");
+    if (fs31.existsSync(pyprojectTomlPath)) {
+      const content = fs31.readFileSync(pyprojectTomlPath, "utf-8");
       if (content.includes("[tool.pytest"))
         return "pytest";
       if (content.includes("pytest"))
         return "pytest";
     }
-    if (fs30.existsSync(setupCfgPath)) {
-      const content = fs30.readFileSync(setupCfgPath, "utf-8");
+    if (fs31.existsSync(setupCfgPath)) {
+      const content = fs31.readFileSync(setupCfgPath, "utf-8");
       if (content.includes("[pytest]"))
         return "pytest";
     }
-    if (fs30.existsSync(requirementsTxtPath)) {
-      const content = fs30.readFileSync(requirementsTxtPath, "utf-8");
+    if (fs31.existsSync(requirementsTxtPath)) {
+      const content = fs31.readFileSync(requirementsTxtPath, "utf-8");
       if (content.includes("pytest"))
         return "pytest";
     }
   } catch {}
   try {
-    const cargoTomlPath = path64.join(baseDir, "Cargo.toml");
-    if (fs30.existsSync(cargoTomlPath)) {
-      const content = fs30.readFileSync(cargoTomlPath, "utf-8");
+    const cargoTomlPath = path65.join(baseDir, "Cargo.toml");
+    if (fs31.existsSync(cargoTomlPath)) {
+      const content = fs31.readFileSync(cargoTomlPath, "utf-8");
       if (content.includes("[dev-dependencies]")) {
         if (content.includes("tokio") || content.includes("mockall") || content.includes("pretty_assertions")) {
           return "cargo";
@@ -33268,10 +33349,10 @@ async function detectTestFramework(cwd) {
     }
   } catch {}
   try {
-    const pesterConfigPath = path64.join(baseDir, "pester.config.ps1");
-    const pesterConfigJsonPath = path64.join(baseDir, "pester.config.ps1.json");
-    const pesterPs1Path = path64.join(baseDir, "tests.ps1");
-    if (fs30.existsSync(pesterConfigPath) || fs30.existsSync(pesterConfigJsonPath) || fs30.existsSync(pesterPs1Path)) {
+    const pesterConfigPath = path65.join(baseDir, "pester.config.ps1");
+    const pesterConfigJsonPath = path65.join(baseDir, "pester.config.ps1.json");
+    const pesterPs1Path = path65.join(baseDir, "tests.ps1");
+    if (fs31.existsSync(pesterConfigPath) || fs31.existsSync(pesterConfigJsonPath) || fs31.existsSync(pesterPs1Path)) {
       return "pester";
     }
   } catch {}
@@ -33299,12 +33380,12 @@ async function detectTestFramework(cwd) {
   return "none";
 }
 function detectPhpTest(cwd) {
-  if (fs30.existsSync(path64.join(cwd, "artisan")) && fs30.existsSync(path64.join(cwd, "composer.json"))) {
+  if (fs31.existsSync(path65.join(cwd, "artisan")) && fs31.existsSync(path65.join(cwd, "composer.json"))) {
     return "php-artisan";
   }
-  if (fs30.existsSync(path64.join(cwd, "Pest.php")))
+  if (fs31.existsSync(path65.join(cwd, "Pest.php")))
     return "pest";
-  if (fs30.existsSync(path64.join(cwd, "phpunit.xml")) || fs30.existsSync(path64.join(cwd, "phpunit.xml.dist"))) {
+  if (fs31.existsSync(path65.join(cwd, "phpunit.xml")) || fs31.existsSync(path65.join(cwd, "phpunit.xml.dist"))) {
     return "phpunit";
   }
   return null;
@@ -33327,12 +33408,12 @@ function isTestDirectoryPath(normalizedPath) {
   return normalizedPath.split("/").some((segment) => TEST_DIRECTORY_NAMES.includes(segment));
 }
 function resolveWorkspacePath(file, workingDir) {
-  return path64.isAbsolute(file) ? path64.resolve(file) : path64.resolve(workingDir, file);
+  return path65.isAbsolute(file) ? path65.resolve(file) : path65.resolve(workingDir, file);
 }
 function toWorkspaceOutputPath(absolutePath2, workingDir, preferRelative) {
   if (!preferRelative)
     return absolutePath2;
-  return path64.relative(workingDir, absolutePath2);
+  return path65.relative(workingDir, absolutePath2);
 }
 function dedupePush(target, value) {
   if (!target.includes(value)) {
@@ -33375,18 +33456,18 @@ function buildLanguageSpecificTestNames(nameWithoutExt, ext) {
   }
 }
 function getRepoLevelCandidateDirectories(workingDir, relativePath2, ext) {
-  const relativeDir = path64.dirname(relativePath2);
+  const relativeDir = path65.dirname(relativePath2);
   const nestedRelativeDir = relativeDir === "." ? "" : relativeDir;
   const directories = TEST_DIRECTORY_NAMES.flatMap((dirName) => {
-    const rootDir = path64.join(workingDir, dirName);
-    return nestedRelativeDir ? [rootDir, path64.join(rootDir, nestedRelativeDir)] : [rootDir];
+    const rootDir = path65.join(workingDir, dirName);
+    return nestedRelativeDir ? [rootDir, path65.join(rootDir, nestedRelativeDir)] : [rootDir];
   });
   const normalizedRelativePath = relativePath2.replace(/\\/g, "/");
   if (ext === ".java" && normalizedRelativePath.startsWith("src/main/java/")) {
-    directories.push(path64.join(workingDir, "src/test/java", path64.dirname(normalizedRelativePath.slice("src/main/java/".length))));
+    directories.push(path65.join(workingDir, "src/test/java", path65.dirname(normalizedRelativePath.slice("src/main/java/".length))));
   }
   if ((ext === ".kt" || ext === ".java") && normalizedRelativePath.startsWith("src/main/kotlin/")) {
-    directories.push(path64.join(workingDir, "src/test/kotlin", path64.dirname(normalizedRelativePath.slice("src/main/kotlin/".length))));
+    directories.push(path65.join(workingDir, "src/test/kotlin", path65.dirname(normalizedRelativePath.slice("src/main/kotlin/".length))));
   }
   return [...new Set(directories)];
 }
@@ -33416,23 +33497,23 @@ function isLanguageSpecificTestFile(basename14) {
 }
 function isConventionTestFilePath(filePath) {
   const normalizedPath = filePath.replace(/\\/g, "/");
-  const basename14 = path64.basename(filePath);
+  const basename14 = path65.basename(filePath);
   return hasCompoundTestExtension(basename14) || basename14.includes(".spec.") || basename14.includes(".test.") || isLanguageSpecificTestFile(basename14) || isTestDirectoryPath(normalizedPath);
 }
 function getTestFilesFromConvention(sourceFiles, workingDir = process.cwd()) {
   const testFiles = [];
   for (const file of sourceFiles) {
     const absoluteFile = resolveWorkspacePath(file, workingDir);
-    const relativeFile = path64.relative(workingDir, absoluteFile);
-    const basename14 = path64.basename(absoluteFile);
-    const dirname26 = path64.dirname(absoluteFile);
-    const preferRelativeOutput = !path64.isAbsolute(file);
+    const relativeFile = path65.relative(workingDir, absoluteFile);
+    const basename14 = path65.basename(absoluteFile);
+    const dirname26 = path65.dirname(absoluteFile);
+    const preferRelativeOutput = !path65.isAbsolute(file);
     if (isConventionTestFilePath(relativeFile) || isConventionTestFilePath(file)) {
       dedupePush(testFiles, toWorkspaceOutputPath(absoluteFile, workingDir, preferRelativeOutput));
       continue;
     }
     const nameWithoutExt = basename14.replace(/\.[^.]+$/, "");
-    const ext = path64.extname(basename14);
+    const ext = path65.extname(basename14);
     const genericTestNames = [
       `${nameWithoutExt}.spec${ext}`,
       `${nameWithoutExt}.test${ext}`
@@ -33441,7 +33522,7 @@ function getTestFilesFromConvention(sourceFiles, workingDir = process.cwd()) {
     const colocatedCandidates = [
       ...genericTestNames,
       ...languageSpecificTestNames
-    ].map((candidateName) => path64.join(dirname26, candidateName));
+    ].map((candidateName) => path65.join(dirname26, candidateName));
     const testDirectoryNames = [
       basename14,
       ...genericTestNames,
@@ -33450,11 +33531,11 @@ function getTestFilesFromConvention(sourceFiles, workingDir = process.cwd()) {
     const repoLevelDirectories = getRepoLevelCandidateDirectories(workingDir, relativeFile, ext);
     const possibleTestFiles = [
       ...colocatedCandidates,
-      ...TEST_DIRECTORY_NAMES.flatMap((dirName) => testDirectoryNames.map((candidateName) => path64.join(dirname26, dirName, candidateName))),
-      ...repoLevelDirectories.flatMap((candidateDir) => testDirectoryNames.map((candidateName) => path64.join(candidateDir, candidateName)))
+      ...TEST_DIRECTORY_NAMES.flatMap((dirName) => testDirectoryNames.map((candidateName) => path65.join(dirname26, dirName, candidateName))),
+      ...repoLevelDirectories.flatMap((candidateDir) => testDirectoryNames.map((candidateName) => path65.join(candidateDir, candidateName)))
     ];
     for (const testFile of possibleTestFiles) {
-      if (fs30.existsSync(testFile)) {
+      if (fs31.existsSync(testFile)) {
         dedupePush(testFiles, toWorkspaceOutputPath(testFile, workingDir, preferRelativeOutput));
       }
     }
@@ -33471,8 +33552,8 @@ async function getTestFilesFromGraph(sourceFiles, workingDir) {
   for (const testFile of candidateTestFiles) {
     try {
       const absoluteTestFile = resolveWorkspacePath(testFile, workingDir);
-      const content = fs30.readFileSync(absoluteTestFile, "utf-8");
-      const testDir = path64.dirname(absoluteTestFile);
+      const content = fs31.readFileSync(absoluteTestFile, "utf-8");
+      const testDir = path65.dirname(absoluteTestFile);
       const importRegex = /import\s+.*?\s+from\s+['"]([^'"]+)['"]/g;
       let match;
       match = importRegex.exec(content);
@@ -33480,8 +33561,8 @@ async function getTestFilesFromGraph(sourceFiles, workingDir) {
         const importPath = match[1];
         let resolvedImport;
         if (importPath.startsWith(".")) {
-          resolvedImport = path64.resolve(testDir, importPath);
-          const existingExt = path64.extname(resolvedImport);
+          resolvedImport = path65.resolve(testDir, importPath);
+          const existingExt = path65.extname(resolvedImport);
           if (!existingExt) {
             for (const extToTry of [
               ".ts",
@@ -33492,7 +33573,7 @@ async function getTestFilesFromGraph(sourceFiles, workingDir) {
               ".cjs"
             ]) {
               const withExt = resolvedImport + extToTry;
-              if (absoluteSourceFiles.includes(withExt) || fs30.existsSync(withExt)) {
+              if (absoluteSourceFiles.includes(withExt) || fs31.existsSync(withExt)) {
                 resolvedImport = withExt;
                 break;
               }
@@ -33501,12 +33582,12 @@ async function getTestFilesFromGraph(sourceFiles, workingDir) {
         } else {
           continue;
         }
-        const importBasename = path64.basename(resolvedImport, path64.extname(resolvedImport));
-        const importDir = path64.dirname(resolvedImport);
+        const importBasename = path65.basename(resolvedImport, path65.extname(resolvedImport));
+        const importDir = path65.dirname(resolvedImport);
         for (const sourceFile of absoluteSourceFiles) {
-          const sourceDir = path64.dirname(sourceFile);
-          const sourceBasename = path64.basename(sourceFile, path64.extname(sourceFile));
-          const isRelatedDir = importDir === sourceDir || importDir === path64.join(sourceDir, "__tests__") || importDir === path64.join(sourceDir, "tests") || importDir === path64.join(sourceDir, "test") || importDir === path64.join(sourceDir, "spec");
+          const sourceDir = path65.dirname(sourceFile);
+          const sourceBasename = path65.basename(sourceFile, path65.extname(sourceFile));
+          const isRelatedDir = importDir === sourceDir || importDir === path65.join(sourceDir, "__tests__") || importDir === path65.join(sourceDir, "tests") || importDir === path65.join(sourceDir, "test") || importDir === path65.join(sourceDir, "spec");
           if (resolvedImport === sourceFile || importBasename === sourceBasename && isRelatedDir) {
             dedupePush(testFiles, testFile);
             break;
@@ -33519,8 +33600,8 @@ async function getTestFilesFromGraph(sourceFiles, workingDir) {
       while (match !== null) {
         const importPath = match[1];
         if (importPath.startsWith(".")) {
-          let resolvedImport = path64.resolve(testDir, importPath);
-          const existingExt = path64.extname(resolvedImport);
+          let resolvedImport = path65.resolve(testDir, importPath);
+          const existingExt = path65.extname(resolvedImport);
           if (!existingExt) {
             for (const extToTry of [
               ".ts",
@@ -33531,18 +33612,18 @@ async function getTestFilesFromGraph(sourceFiles, workingDir) {
               ".cjs"
             ]) {
               const withExt = resolvedImport + extToTry;
-              if (absoluteSourceFiles.includes(withExt) || fs30.existsSync(withExt)) {
+              if (absoluteSourceFiles.includes(withExt) || fs31.existsSync(withExt)) {
                 resolvedImport = withExt;
                 break;
               }
             }
           }
-          const importDir = path64.dirname(resolvedImport);
-          const importBasename = path64.basename(resolvedImport, path64.extname(resolvedImport));
+          const importDir = path65.dirname(resolvedImport);
+          const importBasename = path65.basename(resolvedImport, path65.extname(resolvedImport));
           for (const sourceFile of absoluteSourceFiles) {
-            const sourceDir = path64.dirname(sourceFile);
-            const sourceBasename = path64.basename(sourceFile, path64.extname(sourceFile));
-            const isRelatedDir = importDir === sourceDir || importDir === path64.join(sourceDir, "__tests__") || importDir === path64.join(sourceDir, "tests") || importDir === path64.join(sourceDir, "test") || importDir === path64.join(sourceDir, "spec");
+            const sourceDir = path65.dirname(sourceFile);
+            const sourceBasename = path65.basename(sourceFile, path65.extname(sourceFile));
+            const isRelatedDir = importDir === sourceDir || importDir === path65.join(sourceDir, "__tests__") || importDir === path65.join(sourceDir, "tests") || importDir === path65.join(sourceDir, "test") || importDir === path65.join(sourceDir, "spec");
             if (resolvedImport === sourceFile || importBasename === sourceBasename && isRelatedDir) {
               dedupePush(testFiles, testFile);
               break;
@@ -33662,8 +33743,8 @@ function buildTestCommand(framework, scope, files, coverage, baseDir, bail) {
       return ["mvn", "test"];
     case "gradle": {
       const isWindows = process.platform === "win32";
-      const hasGradlewBat = fs30.existsSync(path64.join(baseDir, "gradlew.bat"));
-      const hasGradlew = fs30.existsSync(path64.join(baseDir, "gradlew"));
+      const hasGradlewBat = fs31.existsSync(path65.join(baseDir, "gradlew.bat"));
+      const hasGradlew = fs31.existsSync(path65.join(baseDir, "gradlew"));
       if (hasGradlewBat && isWindows)
         return ["gradlew.bat", "test"];
       if (hasGradlew)
@@ -33680,7 +33761,7 @@ function buildTestCommand(framework, scope, files, coverage, baseDir, bail) {
         "cmake-build-release",
         "out"
       ];
-      const actualBuildDir = buildDirCandidates.find((d) => fs30.existsSync(path64.join(baseDir, d, "CMakeCache.txt"))) ?? "build";
+      const actualBuildDir = buildDirCandidates.find((d) => fs31.existsSync(path65.join(baseDir, d, "CMakeCache.txt"))) ?? "build";
       return ["ctest", "--test-dir", actualBuildDir];
     }
     case "swift-test":
@@ -33730,7 +33811,7 @@ function buildTestCommand(framework, scope, files, coverage, baseDir, bail) {
   }
 }
 function phpVendorBin2(name) {
-  return path64.join("vendor", "bin", process.platform === "win32" ? `${name}.bat` : name);
+  return path65.join("vendor", "bin", process.platform === "win32" ? `${name}.bat` : name);
 }
 function mapFrameworkStatusToResult(status) {
   if (typeof status !== "string")
@@ -34153,13 +34234,13 @@ async function runTests(framework, scope, files, coverage, timeout_ms, cwd, bail
     };
   }
   const startTime = Date.now();
-  const vitestJsonOutputPath = framework === "vitest" ? path64.join(cwd, ".swarm", "cache", "test-runner-vitest.json") : undefined;
+  const vitestJsonOutputPath = framework === "vitest" ? path65.join(cwd, ".swarm", "cache", "test-runner-vitest.json") : undefined;
   try {
     if (vitestJsonOutputPath) {
       try {
-        fs30.mkdirSync(path64.dirname(vitestJsonOutputPath), { recursive: true });
-        if (fs30.existsSync(vitestJsonOutputPath)) {
-          fs30.unlinkSync(vitestJsonOutputPath);
+        fs31.mkdirSync(path65.dirname(vitestJsonOutputPath), { recursive: true });
+        if (fs31.existsSync(vitestJsonOutputPath)) {
+          fs31.unlinkSync(vitestJsonOutputPath);
         }
       } catch {}
     }
@@ -34185,8 +34266,8 @@ async function runTests(framework, scope, files, coverage, timeout_ms, cwd, bail
     }
     if (vitestJsonOutputPath) {
       try {
-        if (fs30.existsSync(vitestJsonOutputPath)) {
-          const vitestJsonOutput = fs30.readFileSync(vitestJsonOutputPath, "utf-8");
+        if (fs31.existsSync(vitestJsonOutputPath)) {
+          const vitestJsonOutput = fs31.readFileSync(vitestJsonOutputPath, "utf-8");
           if (vitestJsonOutput.trim().length > 0) {
             output += (output ? `
 ` : "") + vitestJsonOutput;
@@ -34326,10 +34407,10 @@ var SKIP_DIRECTORIES = new Set([
 ]);
 function normalizeHistoryTestFile(testFile, workingDir) {
   const normalized = testFile.replace(/\\/g, "/");
-  if (!path64.isAbsolute(testFile))
+  if (!path65.isAbsolute(testFile))
     return normalized;
-  const relative9 = path64.relative(workingDir, testFile);
-  if (relative9.startsWith("..") || path64.isAbsolute(relative9)) {
+  const relative9 = path65.relative(workingDir, testFile);
+  if (relative9.startsWith("..") || path65.isAbsolute(relative9)) {
     return normalized;
   }
   return relative9.replace(/\\/g, "/");
@@ -34567,7 +34648,7 @@ var test_runner = createSwarmTool({
       const sourceFiles = args.files.filter((file) => {
         if (directTestFiles.includes(file))
           return false;
-        const ext = path64.extname(file).toLowerCase();
+        const ext = path65.extname(file).toLowerCase();
         return SOURCE_EXTENSIONS.has(ext);
       });
       const invalidFiles = args.files.filter((file) => !directTestFiles.includes(file) && !sourceFiles.includes(file));
@@ -34613,7 +34694,7 @@ var test_runner = createSwarmTool({
         if (isConventionTestFilePath(f)) {
           return false;
         }
-        const ext = path64.extname(f).toLowerCase();
+        const ext = path65.extname(f).toLowerCase();
         return SOURCE_EXTENSIONS.has(ext);
       });
       if (sourceFiles.length === 0) {
@@ -34663,7 +34744,7 @@ var test_runner = createSwarmTool({
         if (isConventionTestFilePath(f)) {
           return false;
         }
-        const ext = path64.extname(f).toLowerCase();
+        const ext = path65.extname(f).toLowerCase();
         return SOURCE_EXTENSIONS.has(ext);
       });
       if (sourceFiles.length === 0) {
@@ -34715,8 +34796,8 @@ var test_runner = createSwarmTool({
         }
         if (impactResult.impactedTests.length > 0) {
           testFiles = impactResult.impactedTests.map((absPath) => {
-            const relativePath2 = path64.relative(workingDir, absPath);
-            return path64.isAbsolute(relativePath2) ? absPath : relativePath2;
+            const relativePath2 = path65.relative(workingDir, absPath);
+            return path65.isAbsolute(relativePath2) ? absPath : relativePath2;
           });
         } else {
           graphFallbackReason = "no impacted tests found via impact analysis, falling back to graph";
@@ -34811,8 +34892,8 @@ function validateDirectoryPath(dir) {
   if (dir.includes("..")) {
     throw new Error("Directory path must not contain path traversal sequences");
   }
-  const normalized = path65.normalize(dir);
-  const absolutePath2 = path65.isAbsolute(normalized) ? normalized : path65.resolve(normalized);
+  const normalized = path66.normalize(dir);
+  const absolutePath2 = path66.isAbsolute(normalized) ? normalized : path66.resolve(normalized);
   return absolutePath2;
 }
 function validateTimeout(timeoutMs, defaultValue) {
@@ -34835,9 +34916,9 @@ function validateTimeout(timeoutMs, defaultValue) {
 }
 function getPackageVersion(dir) {
   try {
-    const packagePath = path65.join(dir, "package.json");
-    if (fs31.existsSync(packagePath)) {
-      const content = fs31.readFileSync(packagePath, "utf-8");
+    const packagePath = path66.join(dir, "package.json");
+    if (fs32.existsSync(packagePath)) {
+      const content = fs32.readFileSync(packagePath, "utf-8");
       const pkg = JSON.parse(content);
       return pkg.version ?? null;
     }
@@ -34846,9 +34927,9 @@ function getPackageVersion(dir) {
 }
 function getChangelogVersion(dir) {
   try {
-    const changelogPath = path65.join(dir, "CHANGELOG.md");
-    if (fs31.existsSync(changelogPath)) {
-      const content = fs31.readFileSync(changelogPath, "utf-8");
+    const changelogPath = path66.join(dir, "CHANGELOG.md");
+    if (fs32.existsSync(changelogPath)) {
+      const content = fs32.readFileSync(changelogPath, "utf-8");
       const match = content.match(/^##\s*\[?(\d+\.\d+\.\d+)\]?/m);
       if (match) {
         return match[1];
@@ -34860,10 +34941,10 @@ function getChangelogVersion(dir) {
 function getVersionFileVersion(dir) {
   const possibleFiles = ["VERSION.txt", "version.txt", "VERSION", "version"];
   for (const file of possibleFiles) {
-    const filePath = path65.join(dir, file);
-    if (fs31.existsSync(filePath)) {
+    const filePath = path66.join(dir, file);
+    if (fs32.existsSync(filePath)) {
       try {
-        const content = fs31.readFileSync(filePath, "utf-8").trim();
+        const content = fs32.readFileSync(filePath, "utf-8").trim();
         const match = content.match(/(\d+\.\d+\.\d+)/);
         if (match) {
           return match[1];
@@ -34876,9 +34957,9 @@ function getVersionFileVersion(dir) {
 async function runVersionCheck(dir, _timeoutMs) {
   const startTime = Date.now();
   try {
-    const packageVersion = _internals53.getPackageVersion(dir);
-    const changelogVersion = _internals53.getChangelogVersion(dir);
-    const versionFileVersion = _internals53.getVersionFileVersion(dir);
+    const packageVersion = _internals54.getPackageVersion(dir);
+    const changelogVersion = _internals54.getChangelogVersion(dir);
+    const versionFileVersion = _internals54.getVersionFileVersion(dir);
     const versions = [];
     if (packageVersion)
       versions.push(`package.json: ${packageVersion}`);
@@ -35242,7 +35323,7 @@ async function runPreflight(dir, phase, config) {
   const reportId = `preflight-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
   let validatedDir;
   try {
-    validatedDir = _internals53.validateDirectoryPath(dir);
+    validatedDir = _internals54.validateDirectoryPath(dir);
   } catch (error2) {
     return {
       id: reportId,
@@ -35262,7 +35343,7 @@ async function runPreflight(dir, phase, config) {
   }
   let validatedTimeout;
   try {
-    validatedTimeout = _internals53.validateTimeout(config?.checkTimeoutMs, DEFAULT_CONFIG.checkTimeoutMs);
+    validatedTimeout = _internals54.validateTimeout(config?.checkTimeoutMs, DEFAULT_CONFIG.checkTimeoutMs);
   } catch (error2) {
     return {
       id: reportId,
@@ -35303,12 +35384,12 @@ async function runPreflight(dir, phase, config) {
   });
   const checks = [];
   log("[Preflight] Running lint check...");
-  const lintResult = await _internals53.runLintCheck(validatedDir, cfg.linter, cfg.checkTimeoutMs);
+  const lintResult = await _internals54.runLintCheck(validatedDir, cfg.linter, cfg.checkTimeoutMs);
   checks.push(lintResult);
   log(`[Preflight] Lint check: ${lintResult.status} ${lintResult.message}`);
   if (!cfg.skipTests) {
     log("[Preflight] Running tests check...");
-    const testsResult = await _internals53.runTestsCheck(validatedDir, cfg.testScope, cfg.checkTimeoutMs);
+    const testsResult = await _internals54.runTestsCheck(validatedDir, cfg.testScope, cfg.checkTimeoutMs);
     checks.push(testsResult);
     log(`[Preflight] Tests check: ${testsResult.status} ${testsResult.message}`);
   } else {
@@ -35320,7 +35401,7 @@ async function runPreflight(dir, phase, config) {
   }
   if (!cfg.skipSecrets) {
     log("[Preflight] Running secrets check...");
-    const secretsResult = await _internals53.runSecretsCheck(validatedDir, cfg.checkTimeoutMs);
+    const secretsResult = await _internals54.runSecretsCheck(validatedDir, cfg.checkTimeoutMs);
     checks.push(secretsResult);
     log(`[Preflight] Secrets check: ${secretsResult.status} ${secretsResult.message}`);
   } else {
@@ -35332,7 +35413,7 @@ async function runPreflight(dir, phase, config) {
   }
   if (!cfg.skipEvidence) {
     log("[Preflight] Running evidence check...");
-    const evidenceResult = await _internals53.runEvidenceCheck(validatedDir);
+    const evidenceResult = await _internals54.runEvidenceCheck(validatedDir);
     checks.push(evidenceResult);
     log(`[Preflight] Evidence check: ${evidenceResult.status} ${evidenceResult.message}`);
   } else {
@@ -35343,12 +35424,12 @@ async function runPreflight(dir, phase, config) {
     });
   }
   log("[Preflight] Running requirement coverage check...");
-  const reqCoverageResult = await _internals53.runRequirementCoverageCheck(validatedDir, phase);
+  const reqCoverageResult = await _internals54.runRequirementCoverageCheck(validatedDir, phase);
   checks.push(reqCoverageResult);
   log(`[Preflight] Requirement coverage check: ${reqCoverageResult.status} ${reqCoverageResult.message}`);
   if (!cfg.skipVersion) {
     log("[Preflight] Running version check...");
-    const versionResult = await _internals53.runVersionCheck(validatedDir, cfg.checkTimeoutMs);
+    const versionResult = await _internals54.runVersionCheck(validatedDir, cfg.checkTimeoutMs);
     checks.push(versionResult);
     log(`[Preflight] Version check: ${versionResult.status} ${versionResult.message}`);
   } else {
@@ -35411,10 +35492,10 @@ function formatPreflightMarkdown(report) {
 async function handlePreflightCommand(directory, _args) {
   const plan = await loadPlan(directory);
   const phase = plan?.current_phase ?? 1;
-  const report = await _internals53.runPreflight(directory, phase);
-  return _internals53.formatPreflightMarkdown(report);
+  const report = await _internals54.runPreflight(directory, phase);
+  return _internals54.formatPreflightMarkdown(report);
 }
-var _internals53 = {
+var _internals54 = {
   runPreflight,
   formatPreflightMarkdown,
   handlePreflightCommand,
@@ -35616,8 +35697,8 @@ async function handleQaGatesCommand(directory, args, sessionID) {
 }
 
 // src/commands/reset.ts
-import * as fs33 from "fs";
-import * as path67 from "path";
+import * as fs34 from "fs";
+import * as path68 from "path";
 
 // src/background/circuit-breaker.ts
 class CircuitBreaker {
@@ -36310,15 +36391,15 @@ function resetAutomationManager() {
 }
 
 // src/commands/reset-backup.ts
-import * as fs32 from "fs";
-import * as path66 from "path";
+import * as fs33 from "fs";
+import * as path67 from "path";
 var RESET_BACKUP_RETENTION = 5;
 function backupSwarmStateBeforeReset(directory, kind, relEntries) {
   const warnings = [];
   const copied = [];
-  const swarmDir = path66.join(directory, ".swarm");
+  const swarmDir = path67.join(directory, ".swarm");
   try {
-    const stat4 = fs32.lstatSync(swarmDir);
+    const stat4 = fs33.lstatSync(swarmDir);
     if (stat4.isSymbolicLink() || !stat4.isDirectory()) {
       return { backupDir: null, copied, warnings };
     }
@@ -36326,12 +36407,12 @@ function backupSwarmStateBeforeReset(directory, kind, relEntries) {
     return { backupDir: null, copied, warnings };
   }
   const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
-  const backupsRoot = path66.join(swarmDir, "reset-backups");
-  const backupDir = path66.join(backupsRoot, `${kind}-${timestamp}`);
+  const backupsRoot = path67.join(swarmDir, "reset-backups");
+  const backupDir = path67.join(backupsRoot, `${kind}-${timestamp}`);
   let backupDirCreated = false;
   const ensureBackupDir = () => {
     if (!backupDirCreated) {
-      fs32.mkdirSync(backupDir, { recursive: true });
+      fs33.mkdirSync(backupDir, { recursive: true });
       backupDirCreated = true;
     }
   };
@@ -36343,13 +36424,13 @@ function backupSwarmStateBeforeReset(directory, kind, relEntries) {
       warnings.push(`skipped backup of ${rel} (path validation failed)`);
       continue;
     }
-    if (!fs32.existsSync(src))
+    if (!fs33.existsSync(src))
       continue;
     try {
       ensureBackupDir();
-      const dest = path66.join(backupDir, rel);
-      fs32.mkdirSync(path66.dirname(dest), { recursive: true });
-      fs32.cpSync(src, dest, { recursive: true });
+      const dest = path67.join(backupDir, rel);
+      fs33.mkdirSync(path67.dirname(dest), { recursive: true });
+      fs33.cpSync(src, dest, { recursive: true });
       copied.push(rel);
     } catch (err) {
       warnings.push(`failed to back up ${rel}: ${err instanceof Error ? err.message : String(err)}`);
@@ -36358,7 +36439,7 @@ function backupSwarmStateBeforeReset(directory, kind, relEntries) {
   if (copied.length === 0) {
     if (backupDirCreated) {
       try {
-        fs32.rmSync(backupDir, { recursive: true, force: true });
+        fs33.rmSync(backupDir, { recursive: true, force: true });
       } catch {}
     }
     return { backupDir: null, copied, warnings };
@@ -36368,10 +36449,10 @@ function backupSwarmStateBeforeReset(directory, kind, relEntries) {
 }
 function pruneOldResetBackups(backupsRoot, warnings) {
   try {
-    const entries = fs32.readdirSync(backupsRoot, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name).sort().reverse();
+    const entries = fs33.readdirSync(backupsRoot, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name).sort().reverse();
     for (const stale of entries.slice(RESET_BACKUP_RETENTION)) {
       try {
-        fs32.rmSync(path66.join(backupsRoot, stale), {
+        fs33.rmSync(path67.join(backupsRoot, stale), {
           recursive: true,
           force: true
         });
@@ -36385,7 +36466,7 @@ function pruneOldResetBackups(backupsRoot, warnings) {
 }
 
 // src/commands/reset.ts
-var _internals54 = {
+var _internals55 = {
   backupSwarmStateBeforeReset
 };
 async function handleResetCommand(directory, args) {
@@ -36419,12 +36500,12 @@ async function handleResetCommand(directory, args) {
   ];
   const results = [];
   try {
-    const backup = _internals54.backupSwarmStateBeforeReset(directory, "reset", [
+    const backup = _internals55.backupSwarmStateBeforeReset(directory, "reset", [
       ...filesToReset,
       "summaries"
     ]);
     if (backup.backupDir && backup.copied.length > 0) {
-      const rel = path67.relative(directory, backup.backupDir);
+      const rel = path68.relative(directory, backup.backupDir);
       results.push(`- \uD83D\uDCE6 Backed up ${backup.copied.length} item(s) to ${rel}/ (restore by copying files back into .swarm/)`);
     }
     for (const w of backup.warnings) {
@@ -36436,8 +36517,8 @@ async function handleResetCommand(directory, args) {
   for (const filename of filesToReset) {
     try {
       const resolvedPath = validateSwarmPath(directory, filename);
-      if (fs33.existsSync(resolvedPath)) {
-        fs33.unlinkSync(resolvedPath);
+      if (fs34.existsSync(resolvedPath)) {
+        fs34.unlinkSync(resolvedPath);
         results.push(`- \u2705 Deleted ${filename}`);
       } else {
         results.push(`- \u23ED\uFE0F ${filename} not found (skipped)`);
@@ -36448,9 +36529,9 @@ async function handleResetCommand(directory, args) {
   }
   for (const filename of ["SWARM_PLAN.md", "SWARM_PLAN.json"]) {
     try {
-      const rootPath = path67.join(directory, filename);
-      if (fs33.existsSync(rootPath)) {
-        fs33.unlinkSync(rootPath);
+      const rootPath = path68.join(directory, filename);
+      if (fs34.existsSync(rootPath)) {
+        fs34.unlinkSync(rootPath);
         results.push(`- \u2705 Deleted ${filename} (root)`);
       }
     } catch (err) {
@@ -36465,8 +36546,8 @@ async function handleResetCommand(directory, args) {
   }
   try {
     const summariesPath = validateSwarmPath(directory, "summaries");
-    if (fs33.existsSync(summariesPath)) {
-      fs33.rmSync(summariesPath, { recursive: true, force: true });
+    if (fs34.existsSync(summariesPath)) {
+      fs34.rmSync(summariesPath, { recursive: true, force: true });
       results.push("- \u2705 Deleted summaries/ directory");
     } else {
       results.push("- \u23ED\uFE0F summaries/ not found (skipped)");
@@ -36485,16 +36566,16 @@ async function handleResetCommand(directory, args) {
 }
 
 // src/commands/reset-session.ts
-import * as fs36 from "fs";
-import * as path70 from "path";
+import * as fs37 from "fs";
+import * as path71 from "path";
 
 // src/prm/trajectory-store.ts
-import * as fs34 from "fs/promises";
-import * as path68 from "path";
+import * as fs35 from "fs/promises";
+import * as path69 from "path";
 init_logger();
 var MAX_TRACKED_TRAJECTORY_SESSIONS = 500;
 function getTrajectoryPath(sessionId, directory) {
-  const relativePath2 = path68.join("trajectories", `${sessionId}.jsonl`);
+  const relativePath2 = path69.join("trajectories", `${sessionId}.jsonl`);
   return validateSwarmPath(directory, relativePath2);
 }
 var _inMemoryTrajectoryCache = new Map;
@@ -36524,7 +36605,7 @@ function clearTrajectoryCache(sessionId) {
 async function readTrajectory(sessionId, directory) {
   try {
     const trajectoryPath = getTrajectoryPath(sessionId, directory);
-    const content = await fs34.readFile(trajectoryPath, "utf-8");
+    const content = await fs35.readFile(trajectoryPath, "utf-8");
     const lines = content.split(`
 `).filter((line) => line.trim().length > 0);
     const entries = [];
@@ -36549,15 +36630,15 @@ async function cleanupOldTrajectoryFiles(directory, maxAgeDays = 7) {
   for (const subdir of ["trajectories", "replays"]) {
     try {
       const dirPath = validateSwarmPath(directory, subdir);
-      const entries = await fs34.readdir(dirPath, { withFileTypes: true });
+      const entries = await fs35.readdir(dirPath, { withFileTypes: true });
       for (const entry of entries) {
         if (!entry.isFile())
           continue;
-        const filePath = path68.join(dirPath, entry.name);
+        const filePath = path69.join(dirPath, entry.name);
         try {
-          const stat5 = await fs34.stat(filePath);
+          const stat5 = await fs35.stat(filePath);
           if (now - stat5.mtimeMs > cutoffMs) {
-            await fs34.unlink(filePath);
+            await fs35.unlink(filePath);
           }
         } catch {}
       }
@@ -36982,18 +37063,18 @@ function detectPatterns(trajectory, config, lastProcessedStep = 0) {
 init_logger();
 
 // src/prm/replay.ts
-import { promises as fs35 } from "fs";
-import path69 from "path";
+import { promises as fs36 } from "fs";
+import path70 from "path";
 init_logger();
 function isPathSafe(targetPath, basePath) {
-  const resolvedTarget = path69.resolve(targetPath);
-  const resolvedBase = path69.resolve(basePath);
-  const rel = path69.relative(resolvedBase, resolvedTarget);
-  return !rel.startsWith("..") && !path69.isAbsolute(rel);
+  const resolvedTarget = path70.resolve(targetPath);
+  const resolvedBase = path70.resolve(basePath);
+  const rel = path70.relative(resolvedBase, resolvedTarget);
+  return !rel.startsWith("..") && !path70.isAbsolute(rel);
 }
 function isWithinReplaysDir(targetPath) {
-  const resolved = path69.resolve(targetPath);
-  const parts = resolved.split(path69.sep);
+  const resolved = path70.resolve(targetPath);
+  const parts = resolved.split(path70.sep);
   for (let i = 0;i < parts.length - 1; i++) {
     if (parts[i] === ".swarm" && parts[i + 1] === "replays") {
       return true;
@@ -37006,15 +37087,15 @@ function sanitizeFilename(input) {
 }
 async function startReplayRecording(sessionID, directory) {
   try {
-    const replayDir = path69.join(directory, ".swarm", "replays");
+    const replayDir = path70.join(directory, ".swarm", "replays");
     const safeSessionID = sanitizeFilename(sessionID);
     const filename = `${safeSessionID}-${Date.now()}.jsonl`;
-    const filepath = path69.join(replayDir, filename);
+    const filepath = path70.join(replayDir, filename);
     if (!isPathSafe(filepath, replayDir)) {
       advisoryWarn(`[replay] Invalid path detected - path traversal attempt blocked for session ${sessionID}`);
       return null;
     }
-    await fs35.mkdir(replayDir, { recursive: true });
+    await fs36.mkdir(replayDir, { recursive: true });
     return filepath;
   } catch (err) {
     log(`[replay] Failed to start recording for session ${sessionID}: ${err}`);
@@ -37034,14 +37115,14 @@ async function recordReplayEntry(artifactPath, sessionID, entry) {
     };
     const line = `${JSON.stringify(fullEntry)}
 `;
-    await fs35.appendFile(artifactPath, line, "utf-8");
+    await fs36.appendFile(artifactPath, line, "utf-8");
   } catch (err) {
     log(`[replay] Failed to record entry: ${err}`);
   }
 }
 
 // src/prm/index.ts
-var _internals55 = {
+var _internals56 = {
   getAgentSession,
   readTrajectory,
   getInMemoryTrajectory,
@@ -37064,12 +37145,12 @@ function resetPrmSessionState(session, sessionId) {
   session.prmTrajectoryStep = 0;
   session.replayArtifactPath = null;
   if (sessionId) {
-    _internals55.clearTrajectoryCache(sessionId);
+    _internals56.clearTrajectoryCache(sessionId);
   }
 }
 
 // src/commands/reset-session.ts
-var _internals56 = {
+var _internals57 = {
   cleanupOrphanedBranches,
   backupSwarmStateBeforeReset
 };
@@ -37081,9 +37162,9 @@ function errorMessage(err) {
 async function handleResetSessionCommand(directory, _args) {
   const results = [];
   try {
-    const backup = _internals56.backupSwarmStateBeforeReset(directory, "reset-session", ["session"]);
+    const backup = _internals57.backupSwarmStateBeforeReset(directory, "reset-session", ["session"]);
     if (backup.backupDir && backup.copied.length > 0) {
-      const rel = path70.relative(directory, backup.backupDir);
+      const rel = path71.relative(directory, backup.backupDir);
       results.push(`\uD83D\uDCE6 Backed up session state to ${rel}/ (restore by copying files back into .swarm/session/)`);
     }
     for (const w of backup.warnings) {
@@ -37095,8 +37176,8 @@ async function handleResetSessionCommand(directory, _args) {
   let statePath;
   try {
     statePath = validateSwarmPath(directory, "session/state.json");
-    if (fs36.existsSync(statePath)) {
-      fs36.unlinkSync(statePath);
+    if (fs37.existsSync(statePath)) {
+      fs37.unlinkSync(statePath);
       results.push("\u2705 Deleted .swarm/session/state.json");
     } else {
       results.push("\u23ED\uFE0F state.json not found (already clean)");
@@ -37104,11 +37185,11 @@ async function handleResetSessionCommand(directory, _args) {
   } catch {
     results.push("\u274C Failed to delete state.json");
   }
-  const sessionDir = statePath ? path70.dirname(statePath) : undefined;
+  const sessionDir = statePath ? path71.dirname(statePath) : undefined;
   let sessionFiles = [];
-  if (sessionDir && fs36.existsSync(sessionDir)) {
+  if (sessionDir && fs37.existsSync(sessionDir)) {
     try {
-      sessionFiles = fs36.readdirSync(sessionDir);
+      sessionFiles = fs37.readdirSync(sessionDir);
     } catch (err) {
       results.push(`\u274C Failed to read session directory: ${errorMessage(err)}`);
     }
@@ -37116,13 +37197,13 @@ async function handleResetSessionCommand(directory, _args) {
   for (const file of sessionFiles) {
     if (file === "state.json")
       continue;
-    const filePath = path70.join(sessionDir, file);
+    const filePath = path71.join(sessionDir, file);
     try {
-      if (!fs36.existsSync(filePath))
+      if (!fs37.existsSync(filePath))
         continue;
-      if (!fs36.lstatSync(filePath).isFile())
+      if (!fs37.lstatSync(filePath).isFile())
         continue;
-      fs36.unlinkSync(filePath);
+      fs37.unlinkSync(filePath);
       results.push(`\u2713 Deleted ${file}`);
     } catch (err) {
       results.push(`\u274C Failed to delete ${file}: ${errorMessage(err)}`);
@@ -37138,17 +37219,17 @@ async function handleResetSessionCommand(directory, _args) {
   const chainCount = swarmState.delegationChains.size;
   swarmState.delegationChains.clear();
   results.push(`\u2705 Cleared ${chainCount} delegation chain(s)`);
-  const worktreesDir = path70.resolve(path70.dirname(directory), ".swarm-worktrees");
+  const worktreesDir = path71.resolve(path71.dirname(directory), ".swarm-worktrees");
   try {
-    if (fs36.existsSync(worktreesDir)) {
-      fs36.rmSync(worktreesDir, { recursive: true, force: true });
+    if (fs37.existsSync(worktreesDir)) {
+      fs37.rmSync(worktreesDir, { recursive: true, force: true });
       results.push("\u2705 Removed .swarm-worktrees/ directory");
     }
   } catch (err) {
     results.push(`\u26A0\uFE0F Failed to remove .swarm-worktrees/: ${errorMessage(err)}`);
   }
   try {
-    const branchResult = await _internals56.cleanupOrphanedBranches(directory, []);
+    const branchResult = await _internals57.cleanupOrphanedBranches(directory, []);
     if (branchResult.removed.length > 0) {
       results.push(`\u2705 Removed ${branchResult.removed.length} orphan swarm-lane branch(es)`);
     }
@@ -37171,7 +37252,7 @@ async function handleResetSessionCommand(directory, _args) {
 }
 
 // src/summaries/manager.ts
-import * as path71 from "path";
+import * as path72 from "path";
 var SUMMARY_ID_REGEX = /^S\d+$/;
 function sanitizeSummaryId(id) {
   if (!id || id.length === 0) {
@@ -37195,7 +37276,7 @@ function sanitizeSummaryId(id) {
 }
 async function loadFullOutput(directory, id) {
   const sanitizedId = sanitizeSummaryId(id);
-  const relativePath2 = path71.join("summaries", `${sanitizedId}.json`);
+  const relativePath2 = path72.join("summaries", `${sanitizedId}.json`);
   validateSwarmPath(directory, relativePath2);
   const content = await readSwarmFileAsync(directory, relativePath2);
   if (content === null) {
@@ -37247,8 +37328,8 @@ ${error2 instanceof Error ? error2.message : String(error2)}`;
 }
 
 // src/commands/rollback.ts
-import * as fs37 from "fs";
-import * as path72 from "path";
+import * as fs38 from "fs";
+import * as path73 from "path";
 init_logger();
 function safeParseToolJson(result) {
   try {
@@ -37312,7 +37393,7 @@ async function restoreGitCheckpoint(directory, selected) {
     source: "checkpoints.json"
   };
   try {
-    fs37.appendFileSync(eventsPath, `${JSON.stringify(rollbackEvent)}
+    fs38.appendFileSync(eventsPath, `${JSON.stringify(rollbackEvent)}
 `);
   } catch (error2) {
     log("Failed to write rollback event:", error2 instanceof Error ? error2.message : String(error2));
@@ -37323,7 +37404,7 @@ async function handleRollbackCommand(directory, args) {
   const phaseArg = args[0];
   if (!phaseArg) {
     const manifestPath2 = validateSwarmPath(directory, "checkpoints/manifest.json");
-    if (!fs37.existsSync(manifestPath2)) {
+    if (!fs38.existsSync(manifestPath2)) {
       const gitCheckpoints = await listGitCheckpoints(directory);
       if (gitCheckpoints) {
         return formatGitCheckpointList(gitCheckpoints);
@@ -37332,7 +37413,7 @@ async function handleRollbackCommand(directory, args) {
     }
     let manifest2;
     try {
-      manifest2 = JSON.parse(fs37.readFileSync(manifestPath2, "utf-8"));
+      manifest2 = JSON.parse(fs38.readFileSync(manifestPath2, "utf-8"));
     } catch {
       return "Error: Checkpoint manifest is corrupted. Delete .swarm/checkpoints/manifest.json and re-checkpoint.";
     }
@@ -37362,7 +37443,7 @@ async function handleRollbackCommand(directory, args) {
     return restoreGitCheckpoint(directory, selected);
   }
   const manifestPath = validateSwarmPath(directory, "checkpoints/manifest.json");
-  if (!fs37.existsSync(manifestPath)) {
+  if (!fs38.existsSync(manifestPath)) {
     const gitCheckpoints = await listGitCheckpoints(directory);
     if (!gitCheckpoints) {
       return `Error: No checkpoints found. Cannot rollback to phase ${targetPhase}.`;
@@ -37375,7 +37456,7 @@ async function handleRollbackCommand(directory, args) {
   }
   let manifest;
   try {
-    manifest = JSON.parse(fs37.readFileSync(manifestPath, "utf-8"));
+    manifest = JSON.parse(fs38.readFileSync(manifestPath, "utf-8"));
   } catch {
     return `Error: Checkpoint manifest is corrupted. Delete .swarm/checkpoints/manifest.json and re-checkpoint.`;
   }
@@ -37385,10 +37466,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 (!fs37.existsSync(checkpointDir)) {
+  if (!fs38.existsSync(checkpointDir)) {
     return `Error: Checkpoint directory for phase ${targetPhase} does not exist.`;
   }
-  const checkpointFiles = fs37.readdirSync(checkpointDir);
+  const checkpointFiles = fs38.readdirSync(checkpointDir);
   if (checkpointFiles.length === 0) {
     return `Error: Checkpoint for phase ${targetPhase} is empty. Cannot rollback.`;
   }
@@ -37404,10 +37485,10 @@ async function handleRollbackCommand(directory, args) {
     if (EXCLUDE_FILES.has(file) || file.startsWith("plan-ledger.archived-")) {
       continue;
     }
-    const src = path72.join(checkpointDir, file);
-    const dest = path72.join(swarmDir, file);
+    const src = path73.join(checkpointDir, file);
+    const dest = path73.join(swarmDir, file);
     try {
-      fs37.cpSync(src, dest, { recursive: true, force: true });
+      fs38.cpSync(src, dest, { recursive: true, force: true });
       successes.push(file);
     } catch (error2) {
       failures.push({ file, error: error2.message });
@@ -37424,11 +37505,11 @@ async function handleRollbackCommand(directory, args) {
     ].join(`
 `);
   }
-  const existingLedgerPath = path72.join(swarmDir, "plan-ledger.jsonl");
+  const existingLedgerPath = path73.join(swarmDir, "plan-ledger.jsonl");
   let ledgerDeletionFailed = false;
-  if (fs37.existsSync(existingLedgerPath)) {
+  if (fs38.existsSync(existingLedgerPath)) {
     try {
-      fs37.unlinkSync(existingLedgerPath);
+      fs38.unlinkSync(existingLedgerPath);
     } catch (err) {
       ledgerDeletionFailed = true;
       const errMsg = err instanceof Error ? err.message : String(err);
@@ -37437,9 +37518,9 @@ async function handleRollbackCommand(directory, args) {
   }
   if (!ledgerDeletionFailed) {
     try {
-      const planJsonPath = path72.join(swarmDir, "plan.json");
-      if (fs37.existsSync(planJsonPath)) {
-        const planRaw = fs37.readFileSync(planJsonPath, "utf-8");
+      const planJsonPath = path73.join(swarmDir, "plan.json");
+      if (fs38.existsSync(planJsonPath)) {
+        const planRaw = fs38.readFileSync(planJsonPath, "utf-8");
         const plan = PlanSchema.parse(JSON.parse(planRaw));
         const planId = derivePlanId(plan);
         const planHash = computePlanHash(plan);
@@ -37467,7 +37548,7 @@ async function handleRollbackCommand(directory, args) {
     timestamp: new Date().toISOString()
   };
   try {
-    fs37.appendFileSync(eventsPath, `${JSON.stringify(rollbackEvent)}
+    fs38.appendFileSync(eventsPath, `${JSON.stringify(rollbackEvent)}
 `);
   } catch (error2) {
     log("Failed to write rollback event:", error2 instanceof Error ? error2.message : String(error2));
@@ -37484,12 +37565,12 @@ async function handleRollbackCommand(directory, args) {
 }
 
 // src/commands/sdd.ts
-import * as fs38 from "fs";
-import * as path73 from "path";
-var _internals57 = {
+import * as fs39 from "fs";
+import * as path74 from "path";
+var _internals58 = {
   writeProjectedSpecSync
 };
-var SWARM_SPEC_REL = path73.join(".swarm", "spec.md");
+var SWARM_SPEC_REL = path74.join(".swarm", "spec.md");
 var USAGE10 = `Usage:
   /swarm sdd status [--json] [--source <provider>]
   /swarm sdd validate [--json] [--change <id>] [--source <provider>] [--feature <id>]
@@ -37611,7 +37692,7 @@ ${USAGE10}`;
   }
   const speckitDetection = detectSpeckit(directory);
   const speckitPresent = speckitDetection.features.length > 0;
-  const nativeSpecExists = fs38.existsSync(path73.join(directory, SWARM_SPEC_REL));
+  const nativeSpecExists = fs39.existsSync(path74.join(directory, SWARM_SPEC_REL));
   if (speckitPresent && !parsed.source && !nativeSpecExists) {
     const openspecProjection = buildOpenSpecProjectionSync(directory);
     if (openspecProjection !== null) {
@@ -37681,7 +37762,7 @@ ${USAGE10}`;
 ${USAGE10}`;
   }
   let useSpeckit = false;
-  const nativeSpecExists = fs38.existsSync(path73.join(directory, SWARM_SPEC_REL));
+  const nativeSpecExists = fs39.existsSync(path74.join(directory, SWARM_SPEC_REL));
   if (parsed.source === "speckit") {
     useSpeckit = true;
   } else if (!parsed.source && !nativeSpecExists) {
@@ -37835,8 +37916,8 @@ ${USAGE10}`;
 ${USAGE10}`;
   }
   if (!parsed.dryRun) {
-    const nativeSpecPath = path73.join(directory, SWARM_SPEC_REL);
-    if (fs38.existsSync(nativeSpecPath)) {
+    const nativeSpecPath = path74.join(directory, SWARM_SPEC_REL);
+    if (fs39.existsSync(nativeSpecPath)) {
       if (!parsed.overwrite) {
         return [
           "Error: .swarm/spec.md already exists.",
@@ -37882,7 +37963,7 @@ ${USAGE10}`;
 
 ${USAGE10}`;
     }
-    const result2 = _internals57.writeProjectedSpecSync(directory, {
+    const result2 = _internals58.writeProjectedSpecSync(directory, {
       source: "speckit",
       feature: resolution.feature,
       dryRun: parsed.dryRun,
@@ -37940,7 +38021,7 @@ ${formatList(result2.projection.warnings)}` : ""
     ].join(`
 `);
   }
-  const result = _internals57.writeProjectedSpecSync(directory, {
+  const result = _internals58.writeProjectedSpecSync(directory, {
     changeId: parsed.changeId,
     dryRun: parsed.dryRun,
     overwrite: parsed.overwrite
@@ -38002,7 +38083,7 @@ async function handleSddCommand(_directory, _args) {
 }
 
 // src/commands/simulate.ts
-import { renameSync as renameSync11, unlinkSync as unlinkSync13 } from "fs";
+import { renameSync as renameSync12, unlinkSync as unlinkSync14 } from "fs";
 async function handleSimulateCommand(directory, args) {
   const thresholdIndex = args.indexOf("--threshold");
   const minCommitsIndex = args.indexOf("--min-commits");
@@ -38050,17 +38131,17 @@ Ensure this is a git repository with commit history.`;
   const report = reportLines.filter(Boolean).join(`
 `);
   try {
-    const fs39 = await import("fs/promises");
-    const path74 = await import("path");
-    const reportPath = path74.join(directory, ".swarm", "simulate-report.md");
-    await fs39.mkdir(path74.dirname(reportPath), { recursive: true });
-    const reportTempPath = path74.join(path74.dirname(reportPath), `${path74.basename(reportPath)}.tmp.${Date.now()}.${Math.floor(Math.random() * 1e9)}`);
+    const fs40 = await import("fs/promises");
+    const path75 = await import("path");
+    const reportPath = path75.join(directory, ".swarm", "simulate-report.md");
+    await fs40.mkdir(path75.dirname(reportPath), { recursive: true });
+    const reportTempPath = path75.join(path75.dirname(reportPath), `${path75.basename(reportPath)}.tmp.${Date.now()}.${Math.floor(Math.random() * 1e9)}`);
     try {
-      await fs39.writeFile(reportTempPath, report, "utf-8");
-      renameSync11(reportTempPath, reportPath);
+      await fs40.writeFile(reportTempPath, report, "utf-8");
+      renameSync12(reportTempPath, reportPath);
     } catch (err) {
       try {
-        unlinkSync13(reportTempPath);
+        unlinkSync14(reportTempPath);
       } catch {}
       throw err;
     }
@@ -38083,7 +38164,7 @@ async function handleSpecifyCommand(_directory, args) {
 // src/services/status-service.ts
 import * as fsSync2 from "fs";
 import { readFile as readFile17 } from "fs/promises";
-import * as path75 from "path";
+import * as path76 from "path";
 
 // src/hooks/extractors.ts
 function extractCurrentPhase(planContent) {
@@ -38127,16 +38208,16 @@ function extractCurrentPhaseFromPlan2(plan) {
 
 // src/turbo/lean/state.ts
 init_logger();
-import * as fs39 from "fs";
-import * as path74 from "path";
+import * as fs40 from "fs";
+import * as path75 from "path";
 var STATE_FILE3 = "turbo-state.json";
 function nowISO3() {
   return new Date().toISOString();
 }
 function ensureSwarmDir2(directory) {
-  const swarmDir = path74.resolve(directory, ".swarm");
-  if (!fs39.existsSync(swarmDir)) {
-    fs39.mkdirSync(swarmDir, { recursive: true });
+  const swarmDir = path75.resolve(directory, ".swarm");
+  if (!fs40.existsSync(swarmDir)) {
+    fs40.mkdirSync(swarmDir, { recursive: true });
   }
   return swarmDir;
 }
@@ -38179,17 +38260,17 @@ function markStateUnreadable2(directory, reason) {
 }
 function readPersisted2(directory) {
   try {
-    const filePath = path74.join(directory, ".swarm", STATE_FILE3);
-    if (!fs39.existsSync(filePath)) {
+    const filePath = path75.join(directory, ".swarm", STATE_FILE3);
+    if (!fs40.existsSync(filePath)) {
       const seed = emptyPersisted2();
       try {
         ensureSwarmDir2(directory);
-        fs39.writeFileSync(filePath, `${JSON.stringify(seed, null, 2)}
+        fs40.writeFileSync(filePath, `${JSON.stringify(seed, null, 2)}
 `, "utf-8");
       } catch {}
       return seed;
     }
-    const raw = fs39.readFileSync(filePath, "utf-8");
+    const raw = fs40.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})`);
@@ -38215,7 +38296,7 @@ function writePersisted2(directory, persisted) {
   let payload;
   try {
     ensureSwarmDir2(directory);
-    filePath = path74.join(directory, ".swarm", STATE_FILE3);
+    filePath = path75.join(directory, ".swarm", STATE_FILE3);
     tmpPath = `${filePath}.tmp.${Date.now()}`;
     persisted.updatedAt = nowISO3();
     payload = `${JSON.stringify(persisted, null, 2)}
@@ -38226,14 +38307,14 @@ function writePersisted2(directory, persisted) {
     throw new Error(`Lean Turbo state persistence prepare failed: ${msg}`);
   }
   try {
-    fs39.writeFileSync(tmpPath, payload, "utf-8");
-    fs39.renameSync(tmpPath, filePath);
+    fs40.writeFileSync(tmpPath, payload, "utf-8");
+    fs40.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 (fs39.existsSync(tmpPath)) {
-        fs39.unlinkSync(tmpPath);
+      if (fs40.existsSync(tmpPath)) {
+        fs40.unlinkSync(tmpPath);
       }
     } catch {}
     throw new Error(`Lean Turbo state persistence failed: ${msg}`);
@@ -38327,7 +38408,7 @@ var DEFAULT_CONTEXT_BUDGET_CONFIG = {
 };
 
 // src/services/status-service.ts
-var _internals58 = {
+var _internals59 = {
   loadLeanTurboRunState,
   hasActiveLeanTurbo,
   hasActiveFullAuto,
@@ -38336,7 +38417,7 @@ var _internals58 = {
 };
 function readSpecStalenessSnapshot(directory) {
   try {
-    const p = path75.join(directory, ".swarm", "spec-staleness.json");
+    const p = path76.join(directory, ".swarm", "spec-staleness.json");
     if (!fsSync2.existsSync(p))
       return { stale: false };
     const raw = fsSync2.readFileSync(p, "utf-8");
@@ -38448,11 +38529,11 @@ async function getStatusData(directory, agents) {
   } catch {
     status.cohort = { linked: false };
   }
-  status.fullAutoActive = _internals58.hasActiveFullAuto();
+  status.fullAutoActive = _internals59.hasActiveFullAuto();
   if (status.fullAutoActive) {
-    const sid = _internals58.getActiveFullAutoSessionID();
+    const sid = _internals59.getActiveFullAutoSessionID();
     if (sid) {
-      const runState = _internals58.loadFullAutoRunState(directory, sid);
+      const runState = _internals59.loadFullAutoRunState(directory, sid);
       if (runState?.lastEscalation) {
         status.fullAutoEscalation = {
           reason: runState.lastEscalation.reason,
@@ -38467,7 +38548,7 @@ async function getStatusData(directory, agents) {
 }
 function enrichWithLeanTurbo(status, directory) {
   const turboMode = hasActiveTurboMode();
-  const leanActive = _internals58.hasActiveLeanTurbo();
+  const leanActive = _internals59.hasActiveLeanTurbo();
   let turboStrategy = "off";
   if (leanActive) {
     turboStrategy = "lean";
@@ -38486,7 +38567,7 @@ function enrichWithLeanTurbo(status, directory) {
     }
   }
   if (leanSessionID) {
-    const runState = _internals58.loadLeanTurboRunState(directory, leanSessionID);
+    const runState = _internals59.loadLeanTurboRunState(directory, leanSessionID);
     if (runState) {
       status.leanTurboPhase = runState.phase;
       status.leanMaxParallelCoders = runState.maxParallelCoders;
@@ -38693,7 +38774,7 @@ No active swarm plan found. Nothing to sync.`;
 
 // src/commands/turbo.ts
 init_logger();
-var _internals59 = {
+var _internals60 = {
   loadPluginConfigWithMeta
 };
 async function handleTurboCommand(directory, args, sessionID) {
@@ -38753,7 +38834,7 @@ async function handleTurboCommand(directory, args, sessionID) {
   if (arg0 === "on") {
     let strategy = "standard";
     try {
-      const { config } = _internals59.loadPluginConfigWithMeta(directory);
+      const { config } = _internals60.loadPluginConfigWithMeta(directory);
       if (config.turbo?.strategy === "lean") {
         strategy = "lean";
       }
@@ -38850,7 +38931,7 @@ function enableLeanTurbo(session, directory, sessionID) {
   let maxParallelCoders = 4;
   let conflictPolicy = "serialize";
   try {
-    const { config } = _internals59.loadPluginConfigWithMeta(directory);
+    const { config } = _internals60.loadPluginConfigWithMeta(directory);
     const leanConfig = config.turbo?.lean;
     if (leanConfig) {
       maxParallelCoders = leanConfig.max_parallel_coders ?? 4;
@@ -38922,7 +39003,7 @@ function buildStatusMessage2(session, directory, sessionID) {
 }
 
 // src/commands/unlink.ts
-import * as path76 from "path";
+import * as path77 from "path";
 async function handleUnlinkCommand(directory, args) {
   const pointer = readLinkPointer(directory);
   if (!pointer) {
@@ -38935,7 +39016,7 @@ async function handleUnlinkCommand(directory, args) {
   let familySummary = "";
   if (copyBack) {
     try {
-      const result = await migrateKnowledgeFamily(path76.join(directory, ".swarm"), linkDir);
+      const result = await migrateKnowledgeFamily(path77.join(directory, ".swarm"), linkDir);
       for (const m of result.perMember) {
         totalMerged += m.merged;
         totalSkipped += m.skipped;
@@ -39055,7 +39136,7 @@ function findSimilarCommands(query) {
   }
   const scored = VALID_COMMANDS.map((cmd) => {
     const cmdLower = cmd.toLowerCase();
-    const fullScore = _internals60.levenshteinDistance(q, cmdLower);
+    const fullScore = _internals61.levenshteinDistance(q, cmdLower);
     let tokenScore = Infinity;
     if (cmd.includes(" ") || cmd.includes("-")) {
       const qTokens = q.split(/[\s-]+/);
@@ -39068,7 +39149,7 @@ function findSimilarCommands(query) {
         for (const ct of cmdTokens) {
           if (ct.length === 0)
             continue;
-          const dist = _internals60.levenshteinDistance(qt, ct);
+          const dist = _internals61.levenshteinDistance(qt, ct);
           if (dist < minDist)
             minDist = dist;
         }
@@ -39078,7 +39159,7 @@ function findSimilarCommands(query) {
     }
     const dashStrippedQ = q.replace(/-/g, "");
     const dashStrippedCmd = cmdLower.replace(/-/g, "");
-    const dashScore = _internals60.levenshteinDistance(dashStrippedQ, dashStrippedCmd);
+    const dashScore = _internals61.levenshteinDistance(dashStrippedQ, dashStrippedCmd);
     const score = Math.min(fullScore, tokenScore, dashScore);
     return { cmd, score };
   });
@@ -39113,16 +39194,16 @@ function buildDetailedHelp(commandName, entry) {
 async function handleHelpCommand(ctx) {
   const targetCommand = ctx.args.join(" ");
   if (!targetCommand) {
-    const { buildHelpText } = await import("./index-3ygv9535.js");
+    const { buildHelpText } = await import("./index-2ygp3qq4.js");
     return buildHelpText();
   }
   const tokens = targetCommand.split(/\s+/);
-  const resolved = _internals60.resolveCommand(tokens);
+  const resolved = _internals61.resolveCommand(tokens);
   if (resolved) {
-    return _internals60.buildDetailedHelp(resolved.key, resolved.entry);
+    return _internals61.buildDetailedHelp(resolved.key, resolved.entry);
   }
-  const similar = _internals60.findSimilarCommands(targetCommand);
-  const { buildHelpText: fullHelp } = await import("./index-3ygv9535.js");
+  const similar = _internals61.findSimilarCommands(targetCommand);
+  const { buildHelpText: fullHelp } = await import("./index-2ygp3qq4.js");
   if (similar.length > 0) {
     return `Command '/swarm ${targetCommand}' not found.
 
@@ -39186,7 +39267,7 @@ var COMMAND_REGISTRY = {
     toolNoArgs: true
   },
   help: {
-    handler: (ctx) => _internals60.handleHelpCommand(ctx),
+    handler: (ctx) => _internals61.handleHelpCommand(ctx),
     description: "Show help for swarm commands",
     category: "core",
     args: "[command]",
@@ -39255,7 +39336,7 @@ var COMMAND_REGISTRY = {
   },
   "guardrail explain": {
     handler: async (ctx) => {
-      const { handleGuardrailExplain } = await import("./guardrail-explain-nsfm5ksb.js");
+      const { handleGuardrailExplain } = await import("./guardrail-explain-tgkk87z5.js");
       return handleGuardrailExplain(ctx.directory, ctx.args);
     },
     description: "Dry-run: show what the guardrails would do to a command or write target (executes nothing)",
@@ -39265,7 +39346,7 @@ var COMMAND_REGISTRY = {
   },
   "guardrail-explain": {
     handler: async (ctx) => {
-      const { handleGuardrailExplain } = await import("./guardrail-explain-nsfm5ksb.js");
+      const { handleGuardrailExplain } = await import("./guardrail-explain-tgkk87z5.js");
       return handleGuardrailExplain(ctx.directory, ctx.args);
     },
     description: "Dry-run: show what the guardrails would do to a command or write target (executes nothing)",
@@ -40090,24 +40171,24 @@ function validateAliases() {
         continue;
       }
       const visited = new Set;
-      const path77 = [];
+      const path78 = [];
       let current = target;
       while (current) {
         const currentEntry = COMMAND_REGISTRY[current];
         if (!currentEntry)
           break;
         if (visited.has(current)) {
-          const cycleStart = path77.indexOf(current);
+          const cycleStart = path78.indexOf(current);
           const fullChain = [
             name,
-            ...path77.slice(0, cycleStart > 0 ? cycleStart : path77.length),
+            ...path78.slice(0, cycleStart > 0 ? cycleStart : path78.length),
             current
           ].join(" \u2192 ");
           errors.push(`Circular alias detected: ${fullChain}`);
           break;
         }
         visited.add(current);
-        path77.push(current);
+        path78.push(current);
         current = currentEntry.aliasOf || "";
       }
     }
@@ -40126,7 +40207,7 @@ function validateToolPolicy() {
   }
   return { valid: warnings.length === 0, warnings };
 }
-var _internals60 = {
+var _internals61 = {
   handleHelpCommand,
   validateAliases,
   validateToolPolicy,
@@ -40136,16 +40217,16 @@ var _internals60 = {
   findSimilarCommands,
   buildDetailedHelp
 };
-var validation = _internals60.validateAliases();
+var validation = _internals61.validateAliases();
 if (!validation.valid) {
   throw new Error(`COMMAND_REGISTRY alias validation failed:
 ${validation.errors.join(`
 `)}`);
 }
-_internals60.emitValidationWarnings("COMMAND_REGISTRY alias warnings", validation.warnings);
+_internals61.emitValidationWarnings("COMMAND_REGISTRY alias warnings", validation.warnings);
 try {
-  const toolPolicyValidation = _internals60.validateToolPolicy();
-  _internals60.emitValidationWarnings("COMMAND_REGISTRY toolPolicy warnings", toolPolicyValidation.warnings);
+  const toolPolicyValidation = _internals61.validateToolPolicy();
+  _internals61.emitValidationWarnings("COMMAND_REGISTRY toolPolicy warnings", toolPolicyValidation.warnings);
 } catch (e) {
   warn(`COMMAND_REGISTRY toolPolicy validation failed (non-fatal): ${e.message}`);
 }
@@ -40516,6 +40597,8 @@ DELEGATION ENVELOPE FIELDS \u2014 include these in every delegation for traceabi
 
 Before delegating to {{AGENT_PREFIX}}reviewer: call check_gate_status for the current task_id and include the gate results in the GATES field of the reviewer message. Format: GATES: lint=PASS/FAIL, sast_scan=PASS/FAIL, secretscan=PASS/FAIL (use PASS/FAIL/skipped for each gate). If no gates have been run yet, use GATES: none.
 
+ACCEPTANCE FIELD RESOLUTION \u2014 before every {{AGENT_PREFIX}}coder (and {{AGENT_PREFIX}}reviewer) delegation, populate that delegation's ACCEPTANCE field like this: (1) read the current task's \`fr_refs\` from the plan; (2) if \`fr_refs\` is non-empty, look up EVERY listed FR-###/SC-### id in the current \`.swarm/spec.md\` and copy each one's full requirement text into ACCEPTANCE VERBATIM \u2014 byte-for-byte, no summarizing or paraphrasing, and concatenate all of them when a task maps to more than one; (3) if \`fr_refs\` is empty or absent, populate ACCEPTANCE with a task-derived one-line restatement of what DONE looks like instead (the same pattern as \`acceptanceCriteria\` above). ACCEPTANCE must never be empty \u2014 lacking a spec mapping is normal and is not a reason to omit it.
+
 <!-- BEHAVIORAL_GUIDANCE_START -->
 PARTIAL GATE RATIONALIZATIONS \u2014 automated gates \u2260 agent review. Running SOME gates is NOT compliance:
   \u2717 "I ran pre_check_batch so the code is verified" \u2192 pre_check_batch does NOT replace {{AGENT_PREFIX}}reviewer or {{AGENT_PREFIX}}test_engineer
@@ -40692,7 +40775,7 @@ FILE: src/auth/login.ts
 INPUT: Validate email format, password >= 8 chars
 OUTPUT: Modified file
 CONSTRAINT: Do not modify other functions
-ACCEPTANCE: Populate from the plan task's acceptance criteria / FR / SC when the task has them (one item per line, or FR-/SC-style references), so the coder can gate its implementation on each. Omit the field entirely when the task has no structured acceptance criteria.
+ACCEPTANCE: [copied verbatim from spec.md, or a task-derived DONE restatement \u2014 see ACCEPTANCE FIELD RESOLUTION]
 SKILLS: file:.claude/skills/engineering-conventions/SKILL.md
 
 {{AGENT_PREFIX}}reviewer
@@ -40700,8 +40783,9 @@ TASK: Review login validation
 FILE: src/auth/login.ts
 CHECK: [security, correctness, edge-cases]
 GATES: lint=PASS, sast_scan=PASS, secretscan=PASS
+ACCEPTANCE: [copied verbatim from spec.md, or a task-derived DONE restatement \u2014 see ACCEPTANCE FIELD RESOLUTION; same text as the coder delegation for this task]
 SKILLS_USED_BY_CODER: file:.claude/skills/engineering-conventions/SKILL.md
-OUTPUT: VERDICT + RISK + ISSUES
+OUTPUT: VERDICT + RISK + ISSUES + ACCEPTANCE_SATISFACTION
 SKILLS: file:.claude/skills/engineering-conventions/SKILL.md
 
 {{AGENT_PREFIX}}test_engineer
@@ -41064,6 +41148,8 @@ ACTION: Load skill ${bundledProjectSkillFileReference("issue-ingest")} immediate
 HARD CONSTRAINTS:
 - Preserve issue evidence, flag missing repro details, and route non-mega swarms through the active swarm's agents.
 
+RECOVERY: At mode entry, read .swarm/issue-reference.json to recover the source issue URL, number, and flags (plan/trace/noRepro) if the mode signal has been lost or context was compacted.
+
 ### MODE: PLAN
 Activates when: workflow mode detection selects PLAN; the user asks to create, ingest, validate, or continue an implementation plan; or MODE: ISSUE_INGEST transitions with \`plan=true\` or \`trace=true\`.
 
@@ -41096,6 +41182,8 @@ Execution preferences (auto-proceed phase transitions):
 <!-- BEHAVIORAL_GUIDANCE_END -->
 - Preserve task granularity, test task deduplication, phase count guidance, and TRACEABILITY CHECK rules from the loaded skill.
 
+RECOVERY: Read .swarm/issue-reference.json to recover the source issue URL and number for plan traceability if context was compacted.
+
 ### MODE: CRITIC-GATE
 Activates before implementation begins or when a plan needs independent review.
 
@@ -41136,6 +41224,8 @@ HARD CONSTRAINTS (apply regardless of skill load success):
 
 The full retrospective protocol lives in ${bundledProjectSkillFileReference("phase-wrap")}. Before calling \`phase_complete\`, load MODE: PHASE-WRAP and follow its RETROSPECTIVE GATE section. Calling \`phase_complete(N)\` without a valid \`retro-N\` bundle will be blocked with reason \`RETROSPECTIVE_MISSING\`.
 
+RECOVERY: Read .swarm/issue-reference.json if context was compacted to recover the source issue reference.
+
 ### MODE: PHASE-WRAP
 Activates when a phase is ready to close.
 
@@ -41157,6 +41247,8 @@ HARD CONSTRAINTS:
 - SC-001: auto-proceed only skips the phase-transition confirmation. The architect MUST still stop for blocked tasks, user questions, clarification needs, and any decision requiring human input. This behavior is NOT affected by the auto_proceed setting.
 - Full-auto mode (critic oversight) is independent \u2014 its existing "Do NOT ask Ready for Phase N+1?" override continues to work. auto_proceed has no additional effect under full-auto.
 
+RECOVERY: Read .swarm/issue-reference.json for retrospective context and commit-pr Closes #N population.
+
 > **NOTE**: The \`critic_oversight\` agent (\`AUTONOMOUS_OVERSIGHT_PROMPT\`) is dispatched only via full-auto mode (\`src/full-auto/oversight.ts\`). It has no architect MODE dispatch path \u2014 it is **NOT** reachable from \`MODE: CRITIC-GATE\`, \`MODE: EXECUTE\`, or \`MODE: PHASE-WRAP\`. This is intentional: it serves as the sole quality gate in autonomous oversight mode.
 
 ## FILES
@@ -41193,6 +41285,11 @@ Swarm: {{SWARM_ID}}
 ## Patterns
 - <pattern name>: <how and when to use it in this codebase>
 
+## Source Issue
+- URL: <read from .swarm/issue-reference.json>
+- Number: <read from .swarm/issue-reference.json>
+Read .swarm/issue-reference.json if it exists; populate this section with the GitHub issue URL, number, and flags.trace for workflow intent recovery.
+
 \`\`\`
 
 `;
@@ -42213,7 +42310,7 @@ AUTOMATIC REJECTION: Any vaporware indicator triggers immediate rejection before
 Emit event: 'reviewer_substance_check' with fields: { function_name: string, issue_type: string }
 
 TIER 1: CORRECTNESS (mandatory, always run)
-Does the code do what the task acceptance criteria require? Check: every acceptance criterion has corresponding implementation. First-error focus: if you find a correctness issue, stop. Report it. Do not continue to style or optimization issues.
+Does the code do what the task acceptance criteria require? Check: every acceptance criterion has corresponding implementation. When your input includes an ACCEPTANCE field, that field \u2014 not your own impression of "looks correct" \u2014 is the authoritative acceptance criteria: verify the diff satisfies EVERY requirement stated in ACCEPTANCE (including verbatim FR/SC text when the task maps to one or more spec requirements), not merely that the diff is well-formed or plausible in isolation. A diff that is clean, idiomatic, and bug-free but does not satisfy an ACCEPTANCE requirement is a Tier 1 CORRECTNESS failure. First-error focus: if you find a correctness issue, stop. Report it. Do not continue to style or optimization issues.
 
 TIER 2: SAFETY (mandatory for MODERATE+, always for COMPLEX)
 Does the code introduce security vulnerabilities, data loss risks, or breaking changes? Check against: SAST findings, secret scan results, import analysis. Anti-rubber-stamp: "No issues found" requires evidence. State what you checked.
@@ -42251,9 +42348,12 @@ DIFF: [changed files/functions, or "infer from FILE" if omitted]
 AFFECTS: [callers/consumers/dependents to inspect, or "infer from diff"]
 CHECK: [list of dimensions to evaluate]
 GATES: [pre-completed gate results (lint, SAST, secretscan, etc.), or "none" if unavailable]
+ACCEPTANCE: [verbatim FR/SC requirement text this diff must satisfy, copied byte-for-byte from spec.md when the task maps to one or more FR-###/SC-### items \u2014 never a paraphrase or summary. When the task maps to no spec requirement, this is a task-derived, one-line restatement of what DONE looks like instead. This field is never empty.]
 SKILLS: [optional \u2014 either "none", repo-relative file: references (preferred), or inline skill content pasted by architect]
 SKILLS_USED_BY_CODER: [list of skill paths that were passed to the coder for this task, or "none" if no skills were used]
 
+ACCEPTANCE HANDLING: ACCEPTANCE is the authoritative definition of "done" for this task \u2014 evaluate the diff against it explicitly and directly, not only against your own general impression of code quality or correctness in isolation. Before writing your verdict, check EACH item in ACCEPTANCE against the diff and be prepared to state whether it is met. If the diff fails to satisfy any item in ACCEPTANCE, that is a Tier 1 CORRECTNESS failure \u2014 REJECT even if the code otherwise looks clean and well-written, and cite the specific unmet ACCEPTANCE item(s) in your FIXES.
+
 SKILLS HANDLING: If SKILLS is present and not "none", read the skill names/descriptions first, then load every referenced skill that applies before beginning your review. If uncertain whether a skill applies, load it.
 - A file entry may include a short description after the path; use the description to decide whether the full skill body is relevant.
 - For \`file:\` entries, use the search tool to read the referenced \`SKILL.md\` file with \`include\` set to that exact repo-relative path, \`mode: regex\`, \`query: .*\`, \`max_results: 1000\`, and \`max_lines: 1000\`.
@@ -42279,6 +42379,7 @@ VERDICT: APPROVED | REJECTED
 REUSE_RE_VERIFICATION: [VERIFIED | DUPLICATION_DETECTED | SKIPPED] \u2014 DUPLICATION_DETECTED is only valid when VERDICT is REJECTED
 RISK: LOW | MEDIUM | HIGH | CRITICAL
 ISSUES: list with line numbers, grouped by CHECK dimension
+ACCEPTANCE_SATISFACTION: SATISFIED | PARTIAL | NOT_SATISFIED \u2014 one line per item in the input ACCEPTANCE field, stating explicitly whether the diff satisfies it (with evidence: file:line or "no corresponding implementation found"). This is a distinct question from "does the diff look correct" \u2014 assess conformance to ACCEPTANCE even when the diff is otherwise well-written. NOT_SATISFIED on any item forces VERDICT: REJECTED.
 TASK: [task id being reviewed, or "unknown"]
 SKILL_COMPLIANCE: COMPLIANT | PARTIAL | VIOLATED \u2014 [list of violations or "all rules followed"]
 DIRECTIVE_COMPLIANCE: one line per knowledge directive shown during this phase (IDs listed in the DIRECTIVES TO VERIFY block of your prompt, when present). Use exactly one of:
@@ -42479,7 +42580,7 @@ init_logger();
 
 // src/hooks/guardrails/destructive-command.ts
 import * as fsSync3 from "fs";
-import * as path77 from "path";
+import * as path78 from "path";
 var DC_MAX_UNWRAP_DEPTH = 5;
 var DC_SAFE_TARGETS = new Set([
   "node_modules",
@@ -42655,16 +42756,16 @@ function dcIsRemotePath(p) {
   return DC_REMOTE_PREFIXES.some((pfx) => p.startsWith(pfx));
 }
 function dcLstatAncestorWalk(targetPath, cwd) {
-  const normalizedTarget = path77.resolve(cwd, targetPath);
-  const normalizedCwd = path77.resolve(cwd);
+  const normalizedTarget = path78.resolve(cwd, targetPath);
+  const normalizedCwd = path78.resolve(cwd);
   const ancestors = [];
   let current = normalizedTarget;
   while (true) {
     ancestors.push(current);
-    const parent = path77.dirname(current);
+    const parent = path78.dirname(current);
     if (parent === current)
       break;
-    const rel = path77.relative(normalizedCwd, current);
+    const rel = path78.relative(normalizedCwd, current);
     if (rel === "" || rel.startsWith(".."))
       break;
     current = parent;
@@ -42703,14 +42804,14 @@ function dcValidateTargets(targets, cwd) {
     const lstatBlock = dcLstatAncestorWalk(t, cwd);
     if (lstatBlock)
       return lstatBlock;
-    const basename15 = path77.basename(t);
+    const basename15 = path78.basename(t);
     if (t === basename15 && 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 (path77.isAbsolute(t) || /^[A-Za-z]:/.test(t)) {
+    if (path78.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}"`;
@@ -42725,9 +42826,9 @@ function dcCheckJunctionCreation(segment, cwd) {
   if (mklinkMatch) {
     const target = mklinkMatch[2].trim();
     if (!dcHasUnresolvableVars(target)) {
-      const resolved = path77.resolve(cwd, target);
-      const rel = path77.relative(cwd, resolved);
-      if (rel.startsWith("..") || path77.isAbsolute(rel)) {
+      const resolved = path78.resolve(cwd, target);
+      const rel = path78.relative(cwd, resolved);
+      if (rel.startsWith("..") || path78.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.`;
       }
     }
@@ -42739,9 +42840,9 @@ function dcCheckJunctionCreation(segment, cwd) {
   if (newItemMatch) {
     const target = newItemMatch[1].trim();
     if (!dcHasUnresolvableVars(target)) {
-      const resolved = path77.resolve(cwd, target);
-      const rel = path77.relative(cwd, resolved);
-      if (rel.startsWith("..") || path77.isAbsolute(rel)) {
+      const resolved = path78.resolve(cwd, target);
+      const rel = path78.relative(cwd, resolved);
+      if (rel.startsWith("..") || path78.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.`;
       }
     }
@@ -42751,9 +42852,9 @@ function dcCheckJunctionCreation(segment, cwd) {
   if (lnMatch) {
     const target = lnMatch[1].trim();
     if (!dcHasUnresolvableVars(target)) {
-      const resolved = path77.resolve(cwd, target);
-      const rel = path77.relative(cwd, resolved);
-      if (rel.startsWith("..") || path77.isAbsolute(rel)) {
+      const resolved = path78.resolve(cwd, target);
+      const rel = path78.relative(cwd, resolved);
+      if (rel.startsWith("..") || path78.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.`;
       }
     }
@@ -42845,7 +42946,7 @@ function formatCommandNotFound(tokens) {
   const attemptedCommand = tokens[0] || "";
   const MAX_DISPLAY = 100;
   const displayCommand = attemptedCommand.length > MAX_DISPLAY ? `${attemptedCommand.slice(0, MAX_DISPLAY)}...` : attemptedCommand;
-  const similar = _internals60.findSimilarCommands(attemptedCommand);
+  const similar = _internals61.findSimilarCommands(attemptedCommand);
   const header = `Command \`/swarm ${displayCommand}\` not found.`;
   const suggestions = similar.length > 0 ? `Did you mean:
 ${similar.map((cmd) => `  - /swarm ${cmd}`).join(`
@@ -43168,10 +43269,10 @@ function classifySwarmCommandChatFallbackUse(resolved) {
 init_executor();
 
 // src/hooks/shell-write-detect.ts
-import * as path78 from "path";
+import * as path79 from "path";
 import parse from "bash-parser";
-function buildDedupeKey(category, operator, path79) {
-  return `${category}|${operator}|${path79 ?? "null"}`;
+function buildDedupeKey(category, operator, path80) {
+  return `${category}|${operator}|${path80 ?? "null"}`;
 }
 var REDIRECT_WRITE_TOKENS = new Set([
   "GREAT",
@@ -43231,16 +43332,16 @@ function detectProcessSubstitutionWrites(command) {
         results.push(builtinResult);
       const appendMatch = stage.match(/^\s*(.*?)\s*>>(\s*)(\S+)\s*$/);
       if (appendMatch) {
-        const path79 = appendMatch[3];
-        if (path79 && !isNullDevice(path79)) {
-          results.push({ category: "redirect", operator: ">>", path: path79 });
+        const path80 = appendMatch[3];
+        if (path80 && !isNullDevice(path80)) {
+          results.push({ category: "redirect", operator: ">>", path: path80 });
         }
       } else {
         const writeMatch = stage.match(/^\s*(.*?)\s*>(?!>)(\s*)(\S+)\s*$/);
         if (writeMatch) {
-          const path79 = writeMatch[3];
-          if (path79 && !isNullDevice(path79)) {
-            results.push({ category: "redirect", operator: ">", path: path79 });
+          const path80 = writeMatch[3];
+          if (path80 && !isNullDevice(path80)) {
+            results.push({ category: "redirect", operator: ">", path: path80 });
           }
         }
       }
@@ -43414,8 +43515,8 @@ function extractRedirectPath(fileNode) {
     return null;
   return text;
 }
-function isNullDevice(path79) {
-  return path79 === "/dev/null" || path79 === "/dev/zero" || path79 === "/dev/urandom";
+function isNullDevice(path80) {
+  return path80 === "/dev/null" || path80 === "/dev/zero" || path80 === "/dev/urandom";
 }
 function isNumeric(s) {
   return /^\d+$/.test(s);
@@ -43435,12 +43536,12 @@ function detectRedirects(cmd) {
     if (!opType || !REDIRECT_ALL_WRITE_TOKENS.has(opType))
       continue;
     const fileNode = r.file;
-    const path79 = extractRedirectPath(fileNode);
+    const path80 = extractRedirectPath(fileNode);
     const opLabel = operatorLabel(opNode);
     if (REDIRECT_WRITE_TOKENS.has(opType)) {
-      results.push({ category: "redirect", operator: opLabel, path: path79 });
+      results.push({ category: "redirect", operator: opLabel, path: path80 });
     } else if (REDIRECT_HERE_TOKENS.has(opType)) {
-      results.push({ category: "here_doc", operator: opLabel, path: path79 });
+      results.push({ category: "here_doc", operator: opLabel, path: path80 });
     }
   }
   return results;
@@ -43483,9 +43584,9 @@ function detectBuiltinWrites(cmd) {
     const suffixWords2 = getSuffixWords(cmd);
     for (const word of suffixWords2) {
       if (word.startsWith("of=")) {
-        const path79 = word.slice(3);
-        if (path79 && !isNullDevice(path79)) {
-          results.push({ category: "builtin_write", operator: "dd of=", path: path79 });
+        const path80 = word.slice(3);
+        if (path80 && !isNullDevice(path80)) {
+          results.push({ category: "builtin_write", operator: "dd of=", path: path80 });
         }
       }
     }
@@ -43604,12 +43705,12 @@ function detectNetworkDownloaders(cmd) {
     for (let i = 0;i < suffixWords.length; i++) {
       const word = suffixWords[i];
       if (word === "-o" && i + 1 < suffixWords.length) {
-        const path79 = suffixWords[i + 1];
-        if (!path79.startsWith("-")) {
+        const path80 = suffixWords[i + 1];
+        if (!path80.startsWith("-")) {
           results.push({
             category: "network_download",
             operator: "curl -o",
-            path: path79
+            path: path80
           });
         }
       } else if (word.startsWith("-o") && word.length > 2) {
@@ -43624,12 +43725,12 @@ function detectNetworkDownloaders(cmd) {
     for (let i = 0;i < suffixWords.length; i++) {
       const word = suffixWords[i];
       if (word === "-O" && i + 1 < suffixWords.length) {
-        const path79 = suffixWords[i + 1];
-        if (!path79.startsWith("-")) {
+        const path80 = suffixWords[i + 1];
+        if (!path80.startsWith("-")) {
           results.push({
             category: "network_download",
             operator: "wget -O",
-            path: path79
+            path: path80
           });
         }
       } else if (word.startsWith("-O") && word.length > 2) {
@@ -43738,9 +43839,9 @@ function detectGitDestructive(cmd) {
   if (first === "checkout") {
     const dashDashIdx = suffixWords.indexOf("--");
     if (dashDashIdx !== -1 && dashDashIdx + 1 < suffixWords.length) {
-      const path79 = suffixWords[dashDashIdx + 1];
-      const op = path79 === "." ? "git checkout -- ." : "git checkout --";
-      results.push({ category: "git_destructive", operator: op, path: path79 });
+      const path80 = suffixWords[dashDashIdx + 1];
+      const op = path80 === "." ? "git checkout -- ." : "git checkout --";
+      results.push({ category: "git_destructive", operator: op, path: path80 });
     }
   } else if (first === "restore") {
     const hasHard = suffixWords.some((w) => w === "--hard" || w === "-H" || w.startsWith("-") && w.includes("H"));
@@ -43860,10 +43961,10 @@ function detectPowerShellWrites(command) {
   if (redirectMatch) {
     const beforeRedirect = redirectMatch[1];
     const op = redirectMatch[2];
-    const path79 = redirectMatch[3];
+    const path80 = redirectMatch[3];
     const fdRedirectPattern = /\d>\s*$|\s\d>&$/;
     if (!fdRedirectPattern.test(`${beforeRedirect} ${op}`)) {
-      results.push({ category: "redirect", operator: op, path: path79 });
+      results.push({ category: "redirect", operator: op, path: path80 });
     }
   }
   const leadingRedirect = innerCommand.match(/^((?:>){1,2})\s+(\S+)$/);
@@ -43876,12 +43977,12 @@ function detectPowerShellWrites(command) {
   }
   const iwrMatch = trimmed.match(/^(?:Invoke-WebRequest|curl)\s.*?(?:-OutFile\s+(\S+)|-o\s+(\S+))/i);
   if (iwrMatch) {
-    const path79 = iwrMatch[1] || iwrMatch[2];
-    if (path79) {
+    const path80 = iwrMatch[1] || iwrMatch[2];
+    if (path80) {
       results.push({
         category: "network_download",
         operator: "Invoke-WebRequest -OutFile",
-        path: path79
+        path: path80
       });
     }
   }
@@ -43893,15 +43994,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 path79 = pathFlagMatch[2] ?? pathFlagMatch[3] ?? pathFlagMatch[4] ?? "";
-      return { category: "redirect", operator: cmdletName, path: path79 };
+      const path80 = pathFlagMatch[2] ?? pathFlagMatch[3] ?? pathFlagMatch[4] ?? "";
+      return { category: "redirect", operator: cmdletName, path: path80 };
     }
     const tokens = rest.match(/(?:[^\s"-]+|"[^"]*"|'[^']*'|-[^\s]+)/g) ?? [];
     for (const token of tokens) {
       if (token.startsWith("-"))
         continue;
-      const path79 = token.replace(/^["']|["']$/g, "");
-      return { category: "redirect", operator: cmdletName, path: path79 };
+      const path80 = token.replace(/^["']|["']$/g, "");
+      return { category: "redirect", operator: cmdletName, path: path80 };
     }
     return null;
   }
@@ -43917,9 +44018,9 @@ function detectPowerShellWrites(command) {
     for (const token of tokens) {
       if (token.startsWith("-"))
         continue;
-      const path79 = token.replace(/^["']|["']$/g, "");
-      if (path79) {
-        results.push({ category: "redirect", operator: cmdletName, path: path79 });
+      const path80 = token.replace(/^["']|["']$/g, "");
+      if (path80) {
+        results.push({ category: "redirect", operator: cmdletName, path: path80 });
         break;
       }
     }
@@ -43932,8 +44033,8 @@ function detectPowerShellWrites(command) {
     const rest = cmd.slice(opMatch[0].length).trim();
     const destFlagMatch = rest.match(/-Destination\s+(\S+|"[^"]+"|'[^']+')/i);
     if (destFlagMatch) {
-      const path79 = destFlagMatch[1].replace(/^["']|["']$/g, "");
-      return { category: "builtin_write", operator: cmdletName, path: path79 };
+      const path80 = destFlagMatch[1].replace(/^["']|["']$/g, "");
+      return { category: "builtin_write", operator: cmdletName, path: path80 };
     }
     const tokens = [];
     const flagTakingValue = new Set([
@@ -43972,11 +44073,11 @@ function detectPowerShellWrites(command) {
       }
     }
     if (tokens.length >= 2) {
-      const path79 = tokens[tokens.length - 1].replace(/^["']|["']$/g, "");
-      return { category: "builtin_write", operator: cmdletName, path: path79 };
+      const path80 = tokens[tokens.length - 1].replace(/^["']|["']$/g, "");
+      return { category: "builtin_write", operator: cmdletName, path: path80 };
     } else if (tokens.length === 1) {
-      const path79 = tokens[0].replace(/^["']|["']$/g, "");
-      return { category: "builtin_write", operator: cmdletName, path: path79 };
+      const path80 = tokens[0].replace(/^["']|["']$/g, "");
+      return { category: "builtin_write", operator: cmdletName, path: path80 };
     }
     return null;
   }
@@ -43990,14 +44091,14 @@ function detectPowerShellWrites(command) {
     const afterCmdlet = pipeFileOpMatch[2].trim();
     const destFlagMatch = afterCmdlet.match(/-Destination\s+(\S+|"[^"]+"|'[^']+')/i);
     if (destFlagMatch) {
-      const path79 = destFlagMatch[1].replace(/^["']|["']$/g, "");
-      results.push({ category: "builtin_write", operator: cmdletName, path: path79 });
+      const path80 = destFlagMatch[1].replace(/^["']|["']$/g, "");
+      results.push({ category: "builtin_write", operator: cmdletName, path: path80 });
     } else {
       const tokens = afterCmdlet.match(/(?:[^\s"-]+|"[^"]*"|'[^']*'|-[^\s]+)/g) ?? [];
       const nonFlagTokens = tokens.filter((t) => !t.startsWith("-") && t.length > 0);
       if (nonFlagTokens.length > 0) {
-        const path79 = nonFlagTokens[nonFlagTokens.length - 1].replace(/^["']|["']$/g, "");
-        results.push({ category: "builtin_write", operator: cmdletName, path: path79 });
+        const path80 = nonFlagTokens[nonFlagTokens.length - 1].replace(/^["']|["']$/g, "");
+        results.push({ category: "builtin_write", operator: cmdletName, path: path80 });
       }
     }
   }
@@ -44050,10 +44151,10 @@ function detectCmdWrites(command) {
   if (redirectMatch) {
     const beforeRedirect = redirectMatch[1];
     const op = redirectMatch[2];
-    const path79 = redirectMatch[3];
+    const path80 = redirectMatch[3];
     const fdRedirectPattern = /\d>&?$/;
     if (!fdRedirectPattern.test(beforeRedirect)) {
-      results.push({ category: "redirect", operator: op, path: path79 });
+      results.push({ category: "redirect", operator: op, path: path80 });
     }
   }
   const leadingRedirect = innerCommand.match(/^((?:>){1,2})\s+(\S+)$/);
@@ -44111,8 +44212,8 @@ function detectCmdWrites(command) {
     const rawTokens = rest.match(/(\/?[^\s]+|"[^"]*"|'[^']*')/g) ?? [];
     const tokens = rawTokens.filter((t) => !t.startsWith("/"));
     if (tokens.length > 0) {
-      const path79 = tokens[0].replace(/^["']|["']$/g, "");
-      return { category: "builtin_write", operator: "del", path: path79 };
+      const path80 = tokens[0].replace(/^["']|["']$/g, "");
+      return { category: "builtin_write", operator: "del", path: path80 };
     }
     return null;
   }
@@ -44122,16 +44223,16 @@ function detectCmdWrites(command) {
   }
   const rdMatch = innerCommand.match(/^rd\s+(?:\/s\s+|\/q\s+)*(\S+)/i);
   if (rdMatch) {
-    const path79 = rdMatch[1].replace(/^["']|["']$/g, "");
-    if (!path79.startsWith("/")) {
-      results.push({ category: "builtin_write", operator: "rd", path: path79 });
+    const path80 = rdMatch[1].replace(/^["']|["']$/g, "");
+    if (!path80.startsWith("/")) {
+      results.push({ category: "builtin_write", operator: "rd", path: path80 });
     }
   }
   const mdMatch = trimmed.match(/^md\s+(\S+)/i);
   if (mdMatch) {
-    const path79 = mdMatch[1].replace(/^["']|["']$/g, "");
-    if (!path79.startsWith("/")) {
-      results.push({ category: "builtin_write", operator: "md", path: path79 });
+    const path80 = mdMatch[1].replace(/^["']|["']$/g, "");
+    if (!path80.startsWith("/")) {
+      results.push({ category: "builtin_write", operator: "md", path: path80 });
     }
   }
   const echoMatch = trimmed.match(/^echo\s+(\S+.*?)\s+((?:>){1,2})\s*(\S+)$/i);
@@ -44247,10 +44348,10 @@ function resolvePath(pathText, cwd) {
     return null;
   const isWindowsPath = /^[a-zA-Z]:[\\\\/]/.test(cwd) || cwd.includes("\\");
   if (isWindowsPath) {
-    return path78.win32.resolve(cwd, pathText);
+    return path79.win32.resolve(cwd, pathText);
   }
-  const normalizedRelativeWindowsPath = !path78.posix.isAbsolute(pathText) && !/^[a-zA-Z]:[\\/]/.test(pathText) ? pathText.replace(/\\/g, "/") : pathText;
-  return path78.posix.resolve(cwd, normalizedRelativeWindowsPath);
+  const normalizedRelativeWindowsPath = !path79.posix.isAbsolute(pathText) && !/^[a-zA-Z]:[\\/]/.test(pathText) ? pathText.replace(/\\/g, "/") : pathText;
+  return path79.posix.resolve(cwd, normalizedRelativeWindowsPath);
 }
 function getCdTarget(cmd) {
   if (!cmd || typeof cmd !== "object")
@@ -44317,7 +44418,7 @@ function collectWritesWithNodes(node, out, cwdStack) {
         for (const cmd of node.commands) {
           const cdTarget = getCdTarget(cmd);
           if (cdTarget) {
-            currentStack[0] = path78.posix.resolve(currentStack[0] ?? "/", cdTarget);
+            currentStack[0] = path79.posix.resolve(currentStack[0] ?? "/", cdTarget);
             collectWritesWithNodes(cmd, out, currentStack);
           } else {
             collectWritesWithNodes(cmd, out, currentStack);
@@ -44363,7 +44464,7 @@ function collectWritesWithNodes(node, out, cwdStack) {
       const effectiveCwd = cwdStack[0] ?? "/";
       const cdTarget = getCdTarget(node);
       if (cdTarget) {
-        cwdStack[0] = path78.posix.resolve(cwdStack[0] ?? "/", cdTarget);
+        cwdStack[0] = path79.posix.resolve(cwdStack[0] ?? "/", cdTarget);
         return;
       }
       const writesFromRedirs = getWritesFromCommandRedirs(node, effectiveCwd);
@@ -44409,12 +44510,12 @@ function getWritesFromRedirectNode(redirect, _context) {
   if (!opType || !REDIRECT_ALL_WRITE_TOKENS.has(opType))
     return [];
   const fileNode = r.file;
-  const path79 = extractRedirectPath(fileNode);
+  const path80 = extractRedirectPath(fileNode);
   const opLabel = operatorLabel(opNode);
   if (REDIRECT_WRITE_TOKENS.has(opType)) {
-    return [{ category: "redirect", operator: opLabel, path: path79 }];
+    return [{ category: "redirect", operator: opLabel, path: path80 }];
   } else if (REDIRECT_HERE_TOKENS.has(opType)) {
-    return [{ category: "here_doc", operator: opLabel, path: path79 }];
+    return [{ category: "here_doc", operator: opLabel, path: path80 }];
   }
   return [];
 }
@@ -44805,10 +44906,10 @@ function startAgentSession(sessionId, agentName, staleDurationMs = STALE_SESSION
   }
   telemetry.sessionStarted(sessionId, agentName);
   swarmState.activeAgent.set(sessionId, agentName);
-  _internals63.applyRehydrationCache(sessionState);
+  _internals64.applyRehydrationCache(sessionState);
   if (directory) {
     let rehydrationPromise;
-    rehydrationPromise = _internals63.rehydrateSessionFromDisk(directory, sessionState).then(async () => {
+    rehydrationPromise = _internals64.rehydrateSessionFromDisk(directory, sessionState).then(async () => {
       try {
         sessionState.prSubscriptions = await rehydratePrSubscriptions(sessionId, directory);
       } catch (err) {
@@ -44989,7 +45090,7 @@ function ensureAgentSession(sessionId, agentName, directory) {
     maybeSweepStaleSessions();
     return session;
   }
-  _internals63.startAgentSession(sessionId, agentName ?? "unknown", 7200000, directory);
+  _internals64.startAgentSession(sessionId, agentName ?? "unknown", 7200000, directory);
   session = swarmState.agentSessions.get(sessionId);
   if (!session) {
     throw new Error(`Failed to create guardrail session for ${sessionId}`);
@@ -45167,8 +45268,8 @@ function evidenceToWorkflowState(evidence) {
 }
 async function readPlanFromDisk(directory) {
   try {
-    const planPath = path79.join(directory, ".swarm", "plan.json");
-    const content = await fs40.readFile(planPath, "utf-8");
+    const planPath = path80.join(directory, ".swarm", "plan.json");
+    const content = await fs41.readFile(planPath, "utf-8");
     const parsed = JSON.parse(content);
     return PlanSchema.parse(parsed);
   } catch {
@@ -45178,8 +45279,8 @@ async function readPlanFromDisk(directory) {
 async function readGateEvidenceFromDisk(directory) {
   const evidenceMap = new Map;
   try {
-    const evidenceDir = path79.join(directory, ".swarm", "evidence");
-    const entries = await fs40.readdir(evidenceDir, { withFileTypes: true });
+    const evidenceDir = path80.join(directory, ".swarm", "evidence");
+    const entries = await fs41.readdir(evidenceDir, { withFileTypes: true });
     for (const entry of entries) {
       if (!entry.isFile() || !entry.name.endsWith(".json")) {
         continue;
@@ -45189,8 +45290,8 @@ async function readGateEvidenceFromDisk(directory) {
         continue;
       }
       try {
-        const filePath = path79.join(evidenceDir, entry.name);
-        const content = await fs40.readFile(filePath, "utf-8");
+        const filePath = path80.join(evidenceDir, entry.name);
+        const content = await fs41.readFile(filePath, "utf-8");
         const parsed = JSON.parse(content);
         if (parsed && typeof parsed.taskId === "string" && Array.isArray(parsed.required_gates)) {
           evidenceMap.set(taskId, parsed);
@@ -45277,8 +45378,8 @@ function applyRehydrationCache(session) {
   }
 }
 async function rehydrateSessionFromDisk(directory, session) {
-  await _internals63.buildRehydrationCache(directory);
-  _internals63.applyRehydrationCache(session);
+  await _internals64.buildRehydrationCache(directory);
+  _internals64.applyRehydrationCache(session);
 }
 function hasActiveTurboMode(sessionID) {
   if (sessionID) {
@@ -45366,7 +45467,7 @@ async function rehydratePrSubscriptions(sessionID, directory) {
   }
   return map;
 }
-var _internals63 = {
+var _internals64 = {
   swarmState,
   resetSwarmState,
   ensureAgentSession,
@@ -45505,4 +45606,4 @@ function createCuratorLLMDelegate(directory, mode = "init", sessionId) {
   };
 }
 
-export { package_default, handleAcknowledgeSpecDriftCommand, handleAgentsCommand, handleAnalyzeCommand, handleArchiveCommand, DC_SAFE_TARGETS, dcNormalizeCommand, dcUnwrapWrappers, dcSplitSegments, dcValidateTargets, dcCheckJunctionCreation, dcExtractWindowsCmdTargets, dcExtractPowerShellTargets, normalizeSwarmCommandInput, canonicalCommandKey, formatCommandNotFound, executeSwarmCommand, SWARM_COMMAND_TOOL_COMMANDS, SWARM_COMMAND_TOOL_ALLOWLIST, HUMAN_ONLY_SWARM_COMMANDS, classifySwarmCommandToolUse, classifySwarmCommandChatFallbackUse, detectPosixWrites, detectWindowsWrites, resolveWriteTargets, handleAutoProceedCommand, handleBenchmarkCommand, handleBrainstormCommand, handleCheckpointCommand, handleCiSimulateCommand, handleClarifyCommand, createCuratorLLMDelegate, _internals14 as _internals, normalizeRecommendationEntryIdToken, parseKnowledgeRecommendations, parseKnowledgeRecommendationsWithDiagnostics, parseStructuredCuratorBlocks, readCuratorSummary, writeCuratorSummary, appendCuratorRecommendation, mergeCuratorPhaseSummary, filterPhaseEvents, checkPhaseCompliance, runCuratorInit, runCuratorPhase, applyCuratorKnowledgeUpdates, isHiveEligible, countDistinctProjects, checkHivePromotions, _internals17 as _internals1, createHivePromoterHook, promoteToHive, promoteFromSwarm, handleCloseCommand, handleCodebaseReviewCommand, handleConcurrencyCommand, handleConfigCommand, handleConsolidateCommand, handleCostsCommand, handleCouncilCommand, handleCurateCommand, handleDarkMatterCommand, handleDeepDiveCommand, handleDeepResearchCommand, getPluginConfigDir, getPluginCachePaths, getPluginLockFilePaths, handleDiagnoseCommand, handleDoctorCommand, handleEvidenceCommand, handleEvidenceSummaryCommand, handleExportCommand, handleFullAutoCommand, handleGateAuditCommand, handleGateStatsCommand, handleHandoffCommand, handleHistoryCommand, handleKnowledgeQuarantineCommand, handleKnowledgeRestoreCommand, handleKnowledgeMigrateCommand, handleKnowledgeListCommand, handleKnowledgeUnactionableCommand, handleKnowledgeRetryHardeningCommand, handleLearningCommand, handleLinkCommand, handleMemoryCommand, handleMemoryStatusCommand, handleMemoryValueLogCommand, handleMemoryMigrateCommand, handleMemoryImportCommand, handleMemoryExportCommand, handlePlanCommand, handlePreflightCommand, handlePromoteCommand, handleQaGatesCommand, handleResetCommand, handleResetSessionCommand, handleRetrieveCommand, handleRollbackCommand, handleSddStatusCommand, handleSddValidateCommand, handleSddProjectCommand, handleSddCommand, handleSimulateCommand, handleSpecifyCommand, handleStatusCommand, handleSyncPlanCommand, handleTurboCommand, handleUnlinkCommand, handleWriteRetroCommand, handleHelpCommand, COMMAND_REGISTRY, VALID_COMMANDS, _internals60 as _internals2, resolveCommand };
+export { package_default, handleAcknowledgeSpecDriftCommand, handleAgentsCommand, handleAnalyzeCommand, handleArchiveCommand, DC_SAFE_TARGETS, dcNormalizeCommand, dcUnwrapWrappers, dcSplitSegments, dcValidateTargets, dcCheckJunctionCreation, dcExtractWindowsCmdTargets, dcExtractPowerShellTargets, normalizeSwarmCommandInput, canonicalCommandKey, formatCommandNotFound, executeSwarmCommand, SWARM_COMMAND_TOOL_COMMANDS, SWARM_COMMAND_TOOL_ALLOWLIST, HUMAN_ONLY_SWARM_COMMANDS, classifySwarmCommandToolUse, classifySwarmCommandChatFallbackUse, detectPosixWrites, detectWindowsWrites, resolveWriteTargets, handleAutoProceedCommand, handleBenchmarkCommand, handleBrainstormCommand, handleCheckpointCommand, handleCiSimulateCommand, handleClarifyCommand, createCuratorLLMDelegate, _internals14 as _internals, normalizeRecommendationEntryIdToken, parseKnowledgeRecommendations, parseKnowledgeRecommendationsWithDiagnostics, parseStructuredCuratorBlocks, readCuratorSummary, writeCuratorSummary, appendCuratorRecommendation, mergeCuratorPhaseSummary, filterPhaseEvents, checkPhaseCompliance, runCuratorInit, runCuratorPhase, applyCuratorKnowledgeUpdates, isHiveEligible, countDistinctProjects, checkHivePromotions, _internals17 as _internals1, createHivePromoterHook, promoteToHive, promoteFromSwarm, handleCloseCommand, handleCodebaseReviewCommand, handleConcurrencyCommand, handleConfigCommand, handleConsolidateCommand, handleCostsCommand, handleCouncilCommand, handleCurateCommand, handleDarkMatterCommand, handleDeepDiveCommand, handleDeepResearchCommand, getPluginConfigDir, getPluginCachePaths, getPluginLockFilePaths, handleDiagnoseCommand, handleDoctorCommand, handleEvidenceCommand, handleEvidenceSummaryCommand, handleExportCommand, handleFullAutoCommand, handleGateAuditCommand, handleGateStatsCommand, handleHandoffCommand, handleHistoryCommand, handleKnowledgeQuarantineCommand, handleKnowledgeRestoreCommand, handleKnowledgeMigrateCommand, handleKnowledgeListCommand, handleKnowledgeUnactionableCommand, handleKnowledgeRetryHardeningCommand, handleLearningCommand, handleLinkCommand, handleMemoryCommand, handleMemoryStatusCommand, handleMemoryValueLogCommand, handleMemoryMigrateCommand, handleMemoryImportCommand, handleMemoryExportCommand, handlePlanCommand, handlePreflightCommand, handlePromoteCommand, handleQaGatesCommand, handleResetCommand, handleResetSessionCommand, handleRetrieveCommand, handleRollbackCommand, handleSddStatusCommand, handleSddValidateCommand, handleSddProjectCommand, handleSddCommand, handleSimulateCommand, handleSpecifyCommand, handleStatusCommand, handleSyncPlanCommand, handleTurboCommand, handleUnlinkCommand, handleWriteRetroCommand, handleHelpCommand, COMMAND_REGISTRY, VALID_COMMANDS, _internals61 as _internals2, resolveCommand };