opencode-swarm 7.136.3 → 7.136.5

package/dist/cli/{index-brtg922w.js → index-hbzh7yyz.js}

@@ -15,13 +15,13 @@ import {
 } from "./index-nfm9f10v.js";
 import {
   stableCanonicalStringify
-} from "./index-n89fdxwg.js";
+} from "./index-f5qs217h.js";
 import {
   detectStraySwarmDirs,
   readDoctorArtifact,
   removeStraySwarmDir,
   runConfigDoctor
-} from "./index-68tjkaqk.js";
+} from "./index-j7ja83v5.js";
 import {
   MAX_TRANSIENT_RETRIES,
   archiveEvidence,
@@ -113,15 +113,15 @@ import {
   retireSkill,
   selectCandidateEntries,
   syncBundledProjectSkillsIfMissingAsync
-} from "./index-gj5jerzz.js";
+} from "./index-yj61bped.js";
 import {
   readRecentEscalations
-} from "./index-kp5h245k.js";
+} from "./index-tr0ctbhq.js";
 import {
   alreadyCuratedThisGeneration,
   claimNextScanBatch,
   resolveCohortId
-} from "./index-zcrvn579.js";
+} from "./index-8f4346kf.js";
 import {
   CURATOR_INIT_PROMPT,
   CURATOR_PHASE_PROMPT,
@@ -174,11 +174,11 @@ import {
   validateActionableFields,
   validateLesson,
   validateSkillPath
-} from "./index-79pgzj9a.js";
+} from "./index-vm05set2.js";
 import {
   authorizeCuration,
   buildConfigFingerprintInput
-} from "./index-176zwqcq.js";
+} from "./index-6kd0ezgd.js";
 import {
   cohortConfigFingerprint
 } from "./index-rtry5xyf.js";
@@ -211,7 +211,7 @@ import {
   transactFile,
   transactKnowledge,
   wordBigrams
-} from "./index-wbdxmf1a.js";
+} from "./index-qhbr4h5n.js";
 import {
   MAX_EVENT_LOG_ENTRIES,
   _internals,
@@ -221,7 +221,7 @@ import {
   recordHiveKnowledgeEvent,
   recordKnowledgeEvent,
   resolveKnowledgeEventsPath
-} from "./index-mgbpbs1f.js";
+} from "./index-84se71v1.js";
 import {
   resolveHiveDataDir,
   resolveHiveEventsPath,
@@ -246,7 +246,7 @@ import {
   init_loader,
   loadPluginConfig,
   loadPluginConfigWithMeta
-} from "./index-zwh5dewz.js";
+} from "./index-pyz1p8qv.js";
 import {
   RetrospectiveEvidenceSchema
 } from "./index-k5jrywpr.js";
@@ -262,7 +262,7 @@ import {
   package_default,
   resolveAutoReviewConfig,
   stripKnownSwarmPrefix
-} from "./index-0vq9gnqd.js";
+} from "./index-eeb35dnx.js";
 import {
   KNOWLEDGE_SCHEMA_VERSION,
   OUTCOME_BLOCK_THRESHOLD,
@@ -6628,6 +6628,18 @@ var REDACTION_POLICY_SALT = 1;
 function computeRedactionPolicyVersion(rejectDurableSecrets) {
   return REDACTION_POLICY_SALT * 1e6 + SECRET_PATTERNS.length * 2 + (rejectDurableSecrets ? 1 : 0);
 }
+var FINGERPRINT_ALGORITHM_VERSION = 1;
+var LEGACY_FINGERPRINT_ALGORITHM_VERSION = 1;
+var _internals11 = {
+  currentAlgorithmVersion: FINGERPRINT_ALGORITHM_VERSION
+};
+function classifyStoredFingerprintAlgorithmVersion(rawStoredVersion, currentVersion = _internals11.currentAlgorithmVersion) {
+  const storedVersion = rawStoredVersion === undefined ? LEGACY_FINGERPRINT_ALGORITHM_VERSION : rawStoredVersion;
+  if (typeof storedVersion !== "number" || !Number.isFinite(storedVersion)) {
+    return { status: "unknown" };
+  }
+  return storedVersion === currentVersion ? { status: "comparable" } : { status: "mismatch", storedVersion, currentVersion };
+}
 function computeMemoryCohortFingerprint(input) {
   const canonical = stableCanonicalStringify(input);
   return createHash4("sha256").update(canonical).digest("hex").slice(0, 12);
@@ -7906,6 +7918,22 @@ class LocalJsonlMemoryProvider {
       return;
     try {
       const stored = JSON.parse(readFileSync5(configPath, "utf-8"));
+      const versionCheck = classifyStoredFingerprintAlgorithmVersion(stored.algorithm_version);
+      if (versionCheck.status === "unknown") {
+        warn("[memory-cohort] cohort config has a present but non-numeric `algorithm_version`, so its fingerprint cannot be attributed to a known algorithm and the config-coherence check was skipped. Run `/swarm memory link` to rewrite the cohort fingerprint.", {
+          cohortRoot: this.cohortRoot,
+          storedVersion: stored.algorithm_version
+        });
+        return;
+      }
+      if (versionCheck.status === "mismatch") {
+        warn(`[memory-cohort] cohort config was fingerprinted with algorithm version ${versionCheck.storedVersion}, but this worktree computes version ${versionCheck.currentVersion}. Digests from different algorithm versions are not comparable, so the config-coherence check was skipped. Run \`/swarm memory link\` to refresh the cohort fingerprint.`, {
+          cohortRoot: this.cohortRoot,
+          storedVersion: versionCheck.storedVersion,
+          expectedVersion: versionCheck.currentVersion
+        });
+        return;
+      }
       const storedFingerprint = stored.fingerprint;
       if (typeof storedFingerprint !== "string")
         return;
@@ -8217,7 +8245,7 @@ class EmbeddingVersionMismatchError extends Error {
 }
 
 // src/memory/embeddings/local-provider.ts
-var _internals11 = {
+var _internals12 = {
   resolveEmbeddingCacheDir() {
     let base;
     if (process.platform === "win32") {
@@ -8238,7 +8266,7 @@ var _internals11 = {
   }
 };
 function resolveEmbeddingCacheDir() {
-  return _internals11.resolveEmbeddingCacheDir();
+  return _internals12.resolveEmbeddingCacheDir();
 }
 
 class LocalEmbeddingProvider {
@@ -9884,6 +9912,22 @@ class SQLiteMemoryProvider {
     }
     try {
       const stored = JSON.parse(readFileSync6(configPath, "utf-8"));
+      const versionCheck = classifyStoredFingerprintAlgorithmVersion(stored.algorithm_version);
+      if (versionCheck.status === "unknown") {
+        warn("[memory-cohort] cohort config has a present but non-numeric `algorithm_version`, so its fingerprint cannot be attributed to a known algorithm and the config-coherence check was skipped. Run `/swarm memory link` to rewrite the cohort fingerprint.", {
+          cohortRoot: this.cohortRoot,
+          storedVersion: stored.algorithm_version
+        });
+        return;
+      }
+      if (versionCheck.status === "mismatch") {
+        warn(`[memory-cohort] cohort config was fingerprinted with algorithm version ${versionCheck.storedVersion}, but this worktree computes version ${versionCheck.currentVersion}. Digests from different algorithm versions are not comparable, so the config-coherence check was skipped. Run \`/swarm memory link\` to refresh the cohort fingerprint.`, {
+          cohortRoot: this.cohortRoot,
+          storedVersion: versionCheck.storedVersion,
+          expectedVersion: versionCheck.currentVersion
+        });
+        return;
+      }
       const storedFingerprint = stored.fingerprint;
       if (typeof storedFingerprint !== "string") {
         warn("[memory-cohort] cohort config fingerprint file is malformed; config-coherence check skipped.", { cohortRoot: this.cohortRoot });
@@ -11683,7 +11727,7 @@ async function runGit2(directory, args, options) {
   };
   let proc;
   try {
-    proc = _internals12.bunSpawn(["git", "-c", "core.quotepath=false", ...args], spawnOptions);
+    proc = _internals13.bunSpawn(["git", "-c", "core.quotepath=false", ...args], spawnOptions);
   } catch (error2) {
     return {
       ok: false,
@@ -11766,8 +11810,8 @@ function sameCanonicalDirectory(left, right) {
   if (samePath(left, right))
     return true;
   try {
-    const leftStat = _internals12.lstatBigIntSync(left);
-    const rightStat = _internals12.lstatBigIntSync(right);
+    const leftStat = _internals13.lstatBigIntSync(left);
+    const rightStat = _internals13.lstatBigIntSync(right);
     return leftStat.isDirectory() && rightStat.isDirectory() && !leftStat.isSymbolicLink() && !rightStat.isSymbolicLink() && (leftStat.dev !== 0n || leftStat.ino !== 0n) && sameFileIdentity(leftStat, rightStat);
   } catch {
     return false;
@@ -11882,7 +11926,7 @@ function readSafeUntracked(root, rawPath, maxFileBytes) {
   }
   let handle;
   try {
-    const pathStat = _internals12.lstatBigIntSync(candidate);
+    const pathStat = _internals13.lstatBigIntSync(candidate);
     if (pathStat.isSymbolicLink()) {
       return {
         truncated: false,
@@ -11903,7 +11947,7 @@ function readSafeUntracked(root, rawPath, maxFileBytes) {
         }
       };
     }
-    const canonicalBeforeOpen = _internals12.realpathSync(candidate);
+    const canonicalBeforeOpen = _internals13.realpathSync(candidate);
     if (!isContained(root, canonicalBeforeOpen)) {
       return {
         truncated: false,
@@ -11914,9 +11958,9 @@ function readSafeUntracked(root, rawPath, maxFileBytes) {
         }
       };
     }
-    handle = _internals12.openSync(canonicalBeforeOpen, "r");
-    const openedBeforeRead = _internals12.fstatBigIntSync(handle);
-    const canonicalAfterOpen = _internals12.realpathSync(candidate);
+    handle = _internals13.openSync(canonicalBeforeOpen, "r");
+    const openedBeforeRead = _internals13.fstatBigIntSync(handle);
+    const canonicalAfterOpen = _internals13.realpathSync(candidate);
     if (!openedBeforeRead.isFile() || !sameFileSnapshot(pathStat, openedBeforeRead) || !samePath(canonicalBeforeOpen, canonicalAfterOpen) || !isContained(root, canonicalAfterOpen)) {
       return {
         truncated: false,
@@ -11931,13 +11975,13 @@ function readSafeUntracked(root, rawPath, maxFileBytes) {
     const bytes = Buffer.alloc(requested);
     let count = 0;
     while (count < requested) {
-      const read = _internals12.readSync(handle, bytes, count, requested - count, count);
+      const read = _internals13.readSync(handle, bytes, count, requested - count, count);
       if (read === 0)
         break;
       count += read;
     }
-    const openedAfterRead = _internals12.fstatBigIntSync(handle);
-    const canonicalAfterRead = _internals12.realpathSync(candidate);
+    const openedAfterRead = _internals13.fstatBigIntSync(handle);
+    const canonicalAfterRead = _internals13.realpathSync(candidate);
     if (!sameFileSnapshot(openedBeforeRead, openedAfterRead) || !samePath(canonicalBeforeOpen, canonicalAfterRead) || !isContained(root, canonicalAfterRead) || openedBeforeRead.size <= BigInt(maxFileBytes) && BigInt(count) !== openedBeforeRead.size) {
       return {
         truncated: false,
@@ -11989,7 +12033,7 @@ function readSafeUntracked(root, rawPath, maxFileBytes) {
   } finally {
     if (handle !== undefined) {
       try {
-        _internals12.closeSync(handle);
+        _internals13.closeSync(handle);
       } catch {}
     }
   }
@@ -12027,7 +12071,7 @@ async function collectReviewDiff(options) {
   const maxUntrackedFileBytes = boundedPositiveInteger(options.maxUntrackedFileBytes, DEFAULT_MAX_UNTRACKED_FILE_BYTES, MAX_UNTRACKED_FILE_BYTES);
   let root;
   try {
-    root = _internals12.realpathSync(options.directory);
+    root = _internals13.realpathSync(options.directory);
   } catch (error2) {
     return {
       status: "error",
@@ -12050,7 +12094,7 @@ async function collectReviewDiff(options) {
   }
   let gitRoot;
   try {
-    gitRoot = _internals12.realpathSync(topLevel.stdout.trim());
+    gitRoot = _internals13.realpathSync(topLevel.stdout.trim());
   } catch {
     return {
       status: "error",
@@ -12312,7 +12356,7 @@ async function collectReviewDiff(options) {
   const clean = canonicalText.trim().length === 0 && untrackedCount === 0 && skipReasons.length === 0;
   return { status: clean ? "clean" : "ok", ...scope };
 }
-var _internals12 = {
+var _internals13 = {
   bunSpawn,
   realpathSync: fs4.realpathSync,
   lstatBigIntSync: (path19) => fs4.lstatSync(path19, { bigint: true }),
@@ -12347,7 +12391,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 = _internals13.findSimilarCommands(attemptedCommand);
+  const similar = _internals14.findSimilarCommands(attemptedCommand);
   const header = `Command \`/swarm ${displayCommand}\` not found.`;
   const suggestions = similar.length > 0 ? `Did you mean:
 ${similar.map((cmd) => `  - /swarm ${cmd}`).join(`
@@ -14268,7 +14312,7 @@ ${USAGE2}`;
 
 // src/commands/archive.ts
 init_loader();
-var _internals16 = {
+var _internals17 = {
   now: () => new Date
 };
 function artifactLabel(artifact) {
@@ -14324,7 +14368,7 @@ async function handleArchiveCommand(directory, args) {
   const report = await archiveEvidence(directory, maxAgeDays, maxBundles, {
     report: true,
     dryRun,
-    now: _internals16.now(),
+    now: _internals17.now(),
     cacheMaxBytes,
     cacheMaxRecords
   });
@@ -15922,7 +15966,7 @@ var IPV4_PRIVATE_192 = /^192\.168\./;
 var IPV4_ZERO_NETWORK = /^0\./;
 var IPV6_LINK_LOCAL = /^fe80:/i;
 var IPV6_UNIQUE_LOCAL = /^f[cd][0-9a-f]{2}:/i;
-var _internals17 = {
+var _internals18 = {
   spawnSync: (cmd, args, options) => {
     const mergedEnv = mergeEnvForChild(options?.env, options?.envOverrides);
     return child_process2.spawnSync(cmd, args, {
@@ -16040,7 +16084,7 @@ function validateAndSanitizeGithubUrl(rawUrl, resource) {
 }
 function detectGitRemote(cwd, laneEnv) {
   try {
-    const result = _internals17.spawnSync("git", ["remote", "get-url", "origin"], {
+    const result = _internals18.spawnSync("git", ["remote", "get-url", "origin"], {
       encoding: "utf-8",
       stdio: ["ignore", "pipe", "pipe"],
       timeout: 5000,
@@ -16208,7 +16252,7 @@ init_logger();
 var GIT_TIMEOUT_MS4 = 30000;
 var VALIDATION_TIMEOUT_MS = 5 * 60 * 1000;
 var OUTPUT_LIMIT_BYTES = 12000;
-var _internals18 = {
+var _internals19 = {
   runExternalTool,
   getDefaultBaseBranch,
   platform: process.platform,
@@ -16219,7 +16263,7 @@ var _internals18 = {
   }
 };
 async function runGit3(args, cwd, timeoutMs = GIT_TIMEOUT_MS4) {
-  const result = await _internals18.runExternalTool({
+  const result = await _internals19.runExternalTool({
     executable: "git",
     args,
     cwd,
@@ -16237,7 +16281,7 @@ async function runGit3(args, cwd, timeoutMs = GIT_TIMEOUT_MS4) {
 }
 async function runValidationCommand(cmd, cwd, timeoutMs = VALIDATION_TIMEOUT_MS) {
   const [executable, ...args] = cmd;
-  const result = await _internals18.runExternalTool({
+  const result = await _internals19.runExternalTool({
     executable,
     args,
     cwd,
@@ -16265,7 +16309,7 @@ async function getCurrentBranchOrRef(directory) {
   return hashResult.stdout.trim();
 }
 async function setupWorktree(projectRoot, prRef, baseBranch, onWorktreeCreated) {
-  const worktreeBase = path25.join(_internals18.osTmpdir(), "swarm-ci-simulate");
+  const worktreeBase = path25.join(_internals19.osTmpdir(), "swarm-ci-simulate");
   const worktreeName = `pr-${Date.now()}-${Math.floor(Math.random() * 1e6)}`;
   const worktreePath = path25.join(worktreeBase, worktreeName);
   await fsPromises2.mkdir(worktreeBase, { recursive: true });
@@ -16283,8 +16327,8 @@ async function setupWorktree(projectRoot, prRef, baseBranch, onWorktreeCreated)
 async function cleanupWorktree(worktreePath, projectRoot) {
   const removeResult = await runGit3(["worktree", "remove", "--force", worktreePath], projectRoot);
   try {
-    if (_internals18.fs.existsSync(worktreePath)) {
-      _internals18.fs.rmSync(worktreePath, { recursive: true, force: true });
+    if (_internals19.fs.existsSync(worktreePath)) {
+      _internals19.fs.rmSync(worktreePath, { recursive: true, force: true });
     }
   } catch {}
   if (removeResult.exitCode !== 0) {
@@ -16366,7 +16410,7 @@ async function handleCiSimulateCommand(directory, args) {
     steps: []
   };
   try {
-    const baseBranch = _internals18.getDefaultBaseBranch(directory);
+    const baseBranch = _internals19.getDefaultBaseBranch(directory);
     if (!isSafeGitRef(baseBranch)) {
       throw new Error("Detected default branch is not a safe git reference.");
     }
@@ -17058,7 +17102,7 @@ async function readLedgerForTransaction(filePath) {
   }
 }
 async function readLedgerStrict(directory) {
-  const filePath = _internals19.resolveRecommendationLedgerPath(directory);
+  const filePath = _internals20.resolveRecommendationLedgerPath(directory);
   try {
     return parseLedgerJsonl(await readFile7(filePath, "utf-8"));
   } catch (err) {
@@ -17136,7 +17180,7 @@ async function checkRecommendations(directory, candidates) {
   let ledgerKeys = new Set;
   let degraded = false;
   try {
-    const entries = await _internals19.readLedgerStrict(directory);
+    const entries = await _internals20.readLedgerStrict(directory);
     ledgerKeys = new Set(entries.map((entry) => entry.crossKey));
   } catch (err) {
     warn(`[recommendation-ledger] check failed (fail-open, emitting everything): ${err instanceof Error ? err.message : String(err)}`);
@@ -17198,13 +17242,13 @@ async function recordEmittedRecommendations(directory, candidates, options = {})
   if (!candidates.some(hasIdentity)) {
     return { recorded: 0, suppressed: 0, evicted: 0, degraded: false };
   }
-  const emittedAt = options.producedAt ?? _internals19.now().toISOString();
+  const emittedAt = options.producedAt ?? _internals20.now().toISOString();
   let recorded = 0;
   let suppressed = 0;
   let evicted = 0;
   try {
-    const filePath = _internals19.resolveRecommendationLedgerPath(directory);
-    const wrote = await _internals19.transactFile(filePath, readLedgerForTransaction, async (target, data) => {
+    const filePath = _internals20.resolveRecommendationLedgerPath(directory);
+    const wrote = await _internals20.transactFile(filePath, readLedgerForTransaction, async (target, data) => {
       await atomicWriteFile(target, serializeLedger(data));
     }, (existing) => {
       const seen = new Set(existing.map((entry) => entry.crossKey));
@@ -17241,7 +17285,7 @@ async function recordEmittedRecommendations(directory, candidates, options = {})
     return { recorded: 0, suppressed: 0, evicted: 0, degraded: true };
   }
 }
-var _internals19 = {
+var _internals20 = {
   now: () => new Date,
   transactFile,
   readLedgerStrict,
@@ -17607,7 +17651,7 @@ async function reviseSkill(params) {
   }
   if (!params.delegate) {
     try {
-      const revised = _internals20.buildDeterministicRevision(params.currentContent, params.currentVersion, params.violationContexts);
+      const revised = _internals21.buildDeterministicRevision(params.currentContent, params.currentVersion, params.violationContexts);
       const validation = await validateRevisionCandidate(params, revised, "skill_reviser:deterministic");
       if (!validation.passed) {
         return {
@@ -17734,7 +17778,7 @@ async function reviseSkill(params) {
     };
   }
 }
-var _internals20 = {
+var _internals21 = {
   reviseSkill,
   getSkillVersion,
   buildDeterministicRevision,
@@ -18113,7 +18157,7 @@ function planMerges(active, threshold, maxComparisons, maxMerges) {
   };
 }
 async function sweepActiveNearDuplicates(directory, options = {}) {
-  const { loadPluginConfigWithMeta: loadPluginConfigWithMeta2 } = await import("./index-rtgqy0yg.js");
+  const { loadPluginConfigWithMeta: loadPluginConfigWithMeta2 } = await import("./index-bqan4y2y.js");
   const { config } = loadPluginConfigWithMeta2(directory);
   const sweepConfig = config.learning?.dedup_sweep;
   if (sweepConfig?.enabled === false)
@@ -18236,7 +18280,7 @@ function resolveLogPath(directory) {
 function normalizeComplianceVerdict(verdict) {
   return verdict === "violation" ? "violated" : verdict;
 }
-var _internals21 = {
+var _internals22 = {
   generateId: () => crypto2.randomUUID(),
   appendFileSync: fs10.appendFileSync.bind(fs10),
   readFileSync: fs10.readFileSync.bind(fs10),
@@ -18306,9 +18350,9 @@ function parseFeedbackMarker(raw) {
 function readFeedbackAppliedEntryIds(directory) {
   const resolved = resolveLogPath(directory);
   const processed = new Set;
-  if (!_internals21.existsSync(resolved))
+  if (!_internals22.existsSync(resolved))
     return processed;
-  const raw = _internals21.readFileSync(resolved, "utf-8");
+  const raw = _internals22.readFileSync(resolved, "utf-8");
   for (const line of raw.split(`
 `)) {
     const trimmed = line.trim();
@@ -18329,15 +18373,15 @@ function appendFeedbackAppliedMarker(directory, processedEntryIds) {
     return;
   const resolved = resolveLogPath(directory);
   const dir = path30.dirname(resolved);
-  if (!_internals21.existsSync(dir)) {
-    _internals21.mkdirSync(dir, { recursive: true });
+  if (!_internals22.existsSync(dir)) {
+    _internals22.mkdirSync(dir, { recursive: true });
   }
   const marker = {
     type: "feedback_applied",
     timestamp: new Date().toISOString(),
     processedEntryIds: [...new Set(processedEntryIds)]
   };
-  _internals21.appendFileSync(resolved, `${JSON.stringify(marker)}
+  _internals22.appendFileSync(resolved, `${JSON.stringify(marker)}
 `, "utf-8");
 }
 function appendSkillUsageEntry(directory, entry) {
@@ -18374,11 +18418,11 @@ function appendSkillUsageEntry(directory, entry) {
   }
   const resolved = validateSwarmPath(directory, "skill-usage.jsonl");
   const dir = path30.dirname(resolved);
-  if (!_internals21.existsSync(dir)) {
-    _internals21.mkdirSync(dir, { recursive: true });
+  if (!_internals22.existsSync(dir)) {
+    _internals22.mkdirSync(dir, { recursive: true });
   }
   const fullEntry = {
-    id: _internals21.generateId(),
+    id: _internals22.generateId(),
     skillPath,
     agentName,
     taskID,
@@ -18388,21 +18432,21 @@ function appendSkillUsageEntry(directory, entry) {
     ...reviewerNotes !== undefined && { reviewerNotes },
     ...skillVersion !== undefined && { skillVersion }
   };
-  _internals21.appendFileSync(resolved, `${JSON.stringify(fullEntry)}
+  _internals22.appendFileSync(resolved, `${JSON.stringify(fullEntry)}
 `, "utf-8");
   try {
-    const stat4 = _internals21.statSync(resolved);
+    const stat4 = _internals22.statSync(resolved);
     if (stat4.size > SKILL_USAGE_LOG_ROTATE_BYTES) {
-      _internals21.pruneSkillUsageLog(directory, SKILL_USAGE_LOG_MAX_ENTRIES_PER_SKILL);
+      _internals22.pruneSkillUsageLog(directory, SKILL_USAGE_LOG_MAX_ENTRIES_PER_SKILL);
     }
   } catch {}
 }
 function readSkillUsageEntries(directory, options) {
   const resolved = resolveLogPath(directory);
-  if (!_internals21.existsSync(resolved)) {
+  if (!_internals22.existsSync(resolved)) {
     return [];
   }
-  const raw = _internals21.readFileSync(resolved, "utf-8");
+  const raw = _internals22.readFileSync(resolved, "utf-8");
   const entries = [];
   for (const line of raw.split(`
 `)) {
@@ -18445,20 +18489,20 @@ var SKILL_USAGE_LOG_ROTATE_BYTES = 1024 * 1024;
 var SKILL_USAGE_LOG_MAX_ENTRIES_PER_SKILL = 500;
 function readSkillUsageEntriesTail(directory, filters, maxBytes = TAIL_BYTES_DEFAULT) {
   const logPath = resolveLogPath(directory);
-  if (!_internals21.existsSync(logPath))
+  if (!_internals22.existsSync(logPath))
     return [];
   try {
     const normalizedMaxBytes = Number.isFinite(maxBytes) ? maxBytes : TAIL_BYTES_DEFAULT;
     const boundedMaxBytes = Math.min(Math.max(1, normalizedMaxBytes), MAX_TAIL_BYTES);
-    const stat4 = _internals21.statSync(logPath);
+    const stat4 = _internals22.statSync(logPath);
     const start = Math.max(0, stat4.size - boundedMaxBytes);
-    const fd = _internals21.openSync(logPath, "r");
+    const fd = _internals22.openSync(logPath, "r");
     try {
       const readLen = stat4.size - start;
       if (readLen === 0)
         return [];
       const buf = Buffer.alloc(readLen);
-      _internals21.readSync(fd, buf, 0, buf.length, start);
+      _internals22.readSync(fd, buf, 0, buf.length, start);
       const content = buf.toString("utf-8");
       let usable;
       if (start > 0) {
@@ -18485,7 +18529,7 @@ function readSkillUsageEntriesTail(directory, filters, maxBytes = TAIL_BYTES_DEF
       }
       return entries;
     } finally {
-      _internals21.closeSync(fd);
+      _internals22.closeSync(fd);
     }
   } catch {
     return [];
@@ -18522,10 +18566,10 @@ function computeComplianceByVersion(entries, skillPath) {
 }
 function pruneSkillUsageLog(directory, maxEntriesPerSkill = 500) {
   const resolved = resolveLogPath(directory);
-  if (!_internals21.existsSync(resolved)) {
+  if (!_internals22.existsSync(resolved)) {
     return { pruned: 0, remaining: 0 };
   }
-  const raw = _internals21.readFileSync(resolved, "utf-8");
+  const raw = _internals22.readFileSync(resolved, "utf-8");
   const lines = raw.split(`
 `);
   const entries = [];
@@ -18555,13 +18599,13 @@ function pruneSkillUsageLog(directory, maxEntriesPerSkill = 500) {
 `).concat(preservedMarkers.length > 0 ? `
 ` : "");
       try {
-        _internals21.writeFileSync(tmpPath2, content2, "utf-8");
-        _internals21.renameSync(tmpPath2, resolved);
+        _internals22.writeFileSync(tmpPath2, content2, "utf-8");
+        _internals22.renameSync(tmpPath2, resolved);
       } catch (writeErr) {
         const msg = writeErr instanceof Error ? writeErr.message : String(writeErr);
         try {
-          if (_internals21.existsSync(tmpPath2)) {
-            _internals21.writeFileSync(tmpPath2, "", "utf-8");
+          if (_internals22.existsSync(tmpPath2)) {
+            _internals22.writeFileSync(tmpPath2, "", "utf-8");
           }
         } catch {}
         return { pruned: 0, remaining: 0, error: msg };
@@ -18600,13 +18644,13 @@ function pruneSkillUsageLog(directory, maxEntriesPerSkill = 500) {
 `).concat(`
 `);
   try {
-    _internals21.writeFileSync(tmpPath, content, "utf-8");
-    _internals21.renameSync(tmpPath, resolved);
+    _internals22.writeFileSync(tmpPath, content, "utf-8");
+    _internals22.renameSync(tmpPath, resolved);
   } catch (writeErr) {
     const msg = writeErr instanceof Error ? writeErr.message : String(writeErr);
     try {
-      if (_internals21.existsSync(tmpPath)) {
-        _internals21.writeFileSync(tmpPath, "", "utf-8");
+      if (_internals22.existsSync(tmpPath)) {
+        _internals22.writeFileSync(tmpPath, "", "utf-8");
       }
     } catch {}
     return { pruned: 0, remaining: entries.length, error: msg };
@@ -18628,10 +18672,10 @@ async function resolveSourceKnowledgeIds(directory, skillPath) {
     if (!isContained2) {
       return [];
     }
-    if (!_internals21.existsSync(absolute)) {
+    if (!_internals22.existsSync(absolute)) {
       return [];
     }
-    const content = _internals21.readFileSync(absolute, "utf-8");
+    const content = _internals22.readFileSync(absolute, "utf-8");
     return parseGeneratedFromKnowledge(content);
   } catch (err) {
     log("[skill-usage-log] resolveSourceKnowledgeIds failed (fail-open):", err instanceof Error ? err.message : String(err));
@@ -18740,7 +18784,7 @@ var MAX_CURATOR_PHASE_DIGESTS = 50;
 var MAX_CURATOR_COMPLIANCE_OBSERVATIONS = 200;
 var MAX_CURATOR_RECOMMENDATIONS = 200;
 var MAX_LESSON_CHARS = 280;
-var _internals22 = {
+var _internals23 = {
   parseKnowledgeRecommendations,
   parseKnowledgeRecommendationsWithDiagnostics,
   readCuratorSummary,
@@ -18848,9 +18892,9 @@ ${digest.summary}`).join(`
 async function autoRetireSkills(directory, _curatorKnowledgePath, excludeSlugs) {
   const observations = [];
   try {
-    const skillListResult = await _internals22.listSkills(directory);
-    const usageEntries = _internals22.readSkillUsageEntries(directory);
-    const allArchivedIds = await _internals22.getArchivedKnowledgeIds(directory);
+    const skillListResult = await _internals23.listSkills(directory);
+    const usageEntries = _internals23.readSkillUsageEntries(directory);
+    const allArchivedIds = await _internals23.getArchivedKnowledgeIds(directory);
     for (const active of skillListResult.active) {
       if (excludeSlugs?.has(active.slug))
         continue;
@@ -18872,7 +18916,7 @@ async function autoRetireSkills(directory, _curatorKnowledgePath, excludeSlugs)
       const violationRate = skillUsage.length > 0 ? violations / skillUsage.length : 0;
       if (violationRate > 0.3) {
         const reason = `auto-retire: violation rate ${(violationRate * 100).toFixed(0)}% exceeds 30% threshold`;
-        await _internals22.retireSkill(directory, active.slug, reason);
+        await _internals23.retireSkill(directory, active.slug, reason);
         observations.push(`Skill '${active.slug}' auto-retired: ${reason}`);
         warn(`[curator] ${observations[observations.length - 1]}`);
         continue;
@@ -18880,15 +18924,15 @@ async function autoRetireSkills(directory, _curatorKnowledgePath, excludeSlugs)
       let archivedSourceMatched = false;
       if (allArchivedIds.size > 0) {
         try {
-          const content = await _internals22.readFileAsync(active.path, "utf-8");
-          const sourceIds = _internals22.parseDraftFrontmatter(content)?.sourceKnowledgeIds ?? [];
+          const content = await _internals23.readFileAsync(active.path, "utf-8");
+          const sourceIds = _internals23.parseDraftFrontmatter(content)?.sourceKnowledgeIds ?? [];
           archivedSourceMatched = sourceIds.some((id) => allArchivedIds.has(id));
         } catch {
           archivedSourceMatched = false;
         }
       }
       if (archivedSourceMatched) {
-        const result = await _internals22.retireOrMarkStale(directory, path31.dirname(active.path), allArchivedIds);
+        const result = await _internals23.retireOrMarkStale(directory, path31.dirname(active.path), allArchivedIds);
         if (result.action === "retire") {
           observations.push(`Skill '${active.slug}' auto-retired: all source knowledge entries archived`);
           warn(`[curator] ${observations[observations.length - 1]}`);
@@ -19160,7 +19204,7 @@ async function transactCuratorSummary(directory, mutate) {
   const resolvedPath = validateSwarmPath(directory, "curator-summary.json");
   let invoked = false;
   let mutationResult;
-  await _internals22.transactFile(resolvedPath, _internals22.readCuratorSummaryState, _internals22.writeCuratorSummaryState, (state) => {
+  await _internals23.transactFile(resolvedPath, _internals23.readCuratorSummaryState, _internals23.writeCuratorSummaryState, (state) => {
     invoked = true;
     const mutation = mutate(state.summary);
     mutationResult = mutation.result;
@@ -19309,8 +19353,8 @@ function checkPhaseCompliance(phaseEvents, agentsDispatched, requiredAgents, pha
   const observations = [];
   const timestamp = new Date().toISOString();
   for (const agent of requiredAgents) {
-    const normalizedAgent = _internals22.normalizeAgentName(agent);
-    const isDispatched = agentsDispatched.some((a) => _internals22.normalizeAgentName(a) === normalizedAgent);
+    const normalizedAgent = _internals23.normalizeAgentName(agent);
+    const isDispatched = agentsDispatched.some((a) => _internals23.normalizeAgentName(a) === normalizedAgent);
     if (!isDispatched) {
       observations.push({
         phase,
@@ -19329,7 +19373,7 @@ function checkPhaseCompliance(phaseEvents, agentsDispatched, requiredAgents, pha
       if (e.type === "agent.delegation") {
         const agent = e.agent;
         if (agent && typeof agent === "string") {
-          const normalized = _internals22.normalizeAgentName(agent);
+          const normalized = _internals23.normalizeAgentName(agent);
           if (normalized === "coder") {
             coderDelegations.push({ event: e, index: i });
           } else if (normalized === "reviewer") {
@@ -19386,7 +19430,7 @@ function checkPhaseCompliance(phaseEvents, agentsDispatched, requiredAgents, pha
       if (e.type === "agent.delegation" && e.agent) {
         const agent = e.agent;
         if (agent && typeof agent === "string") {
-          const normalized = _internals22.normalizeAgentName(agent);
+          const normalized = _internals23.normalizeAgentName(agent);
           if (normalized === "sme") {
             smeDelegations.push({ event: e, index: i });
           }
@@ -19410,7 +19454,7 @@ function checkPhaseCompliance(phaseEvents, agentsDispatched, requiredAgents, pha
 }
 async function runCuratorInit(directory, config, llmDelegate) {
   try {
-    const priorSummary = await _internals22.readCuratorSummary(directory);
+    const priorSummary = await _internals23.readCuratorSummary(directory);
     const knowledgePath = resolveSwarmKnowledgePath(directory);
     const allEntries = await readKnowledge(knowledgePath);
     const highConfidenceEntries = allEntries.filter((e) => typeof e.confidence === "number" && e.confidence >= config.min_knowledge_confidence);
@@ -19451,7 +19495,7 @@ async function runCuratorInit(directory, config, llmDelegate) {
       const maxContextChars = config.max_summary_tokens * 2;
       briefingParts.push(contextMd.slice(0, maxContextChars));
     }
-    const latestPostMortemDigest = _internals22.readLatestPostMortemDigest(directory);
+    const latestPostMortemDigest = _internals23.readLatestPostMortemDigest(directory);
     if (latestPostMortemDigest) {
       briefingParts.push(`
 ## Latest Post-Mortem`);
@@ -19538,7 +19582,7 @@ Could not load prior session context.`,
 }
 async function runCuratorPhase(directory, phase, agentsDispatched, config, knowledgeConfig, llmDelegate) {
   try {
-    const priorSummary = await _internals22.readCuratorSummary(directory);
+    const priorSummary = await _internals23.readCuratorSummary(directory);
     if (priorSummary?.phase_digests.some((d) => d.phase === phase)) {
       const existingDigest = priorSummary.phase_digests.find((d) => d.phase === phase);
       return {
@@ -19551,10 +19595,10 @@ async function runCuratorPhase(directory, phase, agentsDispatched, config, knowl
       };
     }
     const eventsJsonlContent = await readSwarmFileAsync(directory, "events.jsonl");
-    const phaseEvents = eventsJsonlContent ? _internals22.filterPhaseEvents(eventsJsonlContent, phase) : [];
+    const phaseEvents = eventsJsonlContent ? _internals23.filterPhaseEvents(eventsJsonlContent, phase) : [];
     const contextMd = await readSwarmFileAsync(directory, "context.md");
     const requiredAgents = ["reviewer", "test_engineer"];
-    const complianceObservations = _internals22.checkPhaseCompliance(phaseEvents, agentsDispatched, requiredAgents, phase);
+    const complianceObservations = _internals23.checkPhaseCompliance(phaseEvents, agentsDispatched, requiredAgents, phase);
     const plan = await loadPlanJsonOnly(directory);
     const phaseData = plan?.phases.find((p) => p.id === phase);
     const tasksCompleted = phaseData ? phaseData.tasks.filter((t) => t.status === "completed").length : 0;
@@ -19578,7 +19622,7 @@ async function runCuratorPhase(directory, phase, agentsDispatched, config, knowl
       timestamp: new Date().toISOString(),
       summary: `Phase ${phase} completed. ${tasksCompleted}/${tasksTotal} tasks completed. ${complianceObservations.length} compliance observations.`,
       agents_used: [
-        ...new Set(agentsDispatched.map((a) => _internals22.normalizeAgentName(a)))
+        ...new Set(agentsDispatched.map((a) => _internals23.normalizeAgentName(a)))
       ],
       tasks_completed: tasksCompleted,
       tasks_total: tasksTotal,
@@ -19630,7 +19674,7 @@ async function runCuratorPhase(directory, phase, agentsDispatched, config, knowl
           clearTimeout(timer);
         }
         if (llmOutput?.trim()) {
-          const parsed = _internals22.parseKnowledgeRecommendationsWithDiagnostics(llmOutput);
+          const parsed = _internals23.parseKnowledgeRecommendationsWithDiagnostics(llmOutput);
           for (const diagnostic of parsed.diagnostics) {
             warn("[curator] skipped malformed recommendation line", {
               phase,
@@ -19675,7 +19719,7 @@ async function runCuratorPhase(directory, phase, agentsDispatched, config, knowl
     }
     const sessionId = `session-${Date.now()}`;
     const now = new Date().toISOString();
-    const summaryUpdated = await _internals22.mergeCuratorPhaseSummary(directory, {
+    const summaryUpdated = await _internals23.mergeCuratorPhaseSummary(directory, {
       phase,
       phaseDigest,
       complianceObservations,
@@ -19706,7 +19750,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-8gtq1ajr.js");
+        const skillModule = await import("./skill-generator-ybncj9et.js");
         for (const cand of skillCandidates) {
           if (cand.confidence < (config.min_skill_confidence ?? DEFAULT_SKILL_MIN_CONFIDENCE)) {
             continue;
@@ -19724,8 +19768,8 @@ async function runCuratorPhase(directory, phase, agentsDispatched, config, knowl
     }
     const revisedSlugs = new Set;
     try {
-      const skillListResult = await _internals22.listSkills(directory);
-      const usageEntries = _internals22.readSkillUsageEntries(directory);
+      const skillListResult = await _internals23.listSkills(directory);
+      const usageEntries = _internals23.readSkillUsageEntries(directory);
       let revisionCallsThisPhase = 0;
       for (const active of skillListResult.active) {
         if (revisionCallsThisPhase >= MAX_REVISION_CALLS_PER_PHASE)
@@ -19749,8 +19793,8 @@ async function runCuratorPhase(directory, phase, agentsDispatched, config, knowl
         const violations = skillUsage.filter((e) => e.complianceVerdict === "violated").length;
         const violationRate = violations / skillUsage.length;
         if (violationRate > REVISION_VIOLATION_THRESHOLD && violationRate <= 0.3) {
-          const content = await _internals22.readFileAsync(active.path, "utf-8");
-          const fm = _internals22.parseDraftFrontmatter(content);
+          const content = await _internals23.readFileAsync(active.path, "utf-8");
+          const fm = _internals23.parseDraftFrontmatter(content);
           if (fm && fm.skillOrigin === "promoted_external")
             continue;
           const currentVersion = fm?.version ?? 1;
@@ -19761,7 +19805,7 @@ async function runCuratorPhase(directory, phase, agentsDispatched, config, knowl
             reviewerNotes: e.reviewerNotes,
             timestamp: e.timestamp
           }));
-          const result2 = await _internals22.reviseSkill({
+          const result2 = await _internals23.reviseSkill({
             directory,
             slug: active.slug,
             skillPath: active.path,
@@ -19781,12 +19825,12 @@ async function runCuratorPhase(directory, phase, agentsDispatched, config, knowl
       warn(`[curator] skill revision check failed: ${revisionErr instanceof Error ? revisionErr.message : String(revisionErr)}`);
     }
     try {
-      const peSkillList = await _internals22.listSkills(directory);
-      const peUsageEntries = _internals22.readSkillUsageEntries(directory);
+      const peSkillList = await _internals23.listSkills(directory);
+      const peUsageEntries = _internals23.readSkillUsageEntries(directory);
       const peRetirementMinAgeDays = 60;
       for (const active of peSkillList.active) {
-        const content = await _internals22.readFileAsync(active.path, "utf-8");
-        const fm = _internals22.parseDraftFrontmatter(content);
+        const content = await _internals23.readFileAsync(active.path, "utf-8");
+        const fm = _internals23.parseDraftFrontmatter(content);
         if (!fm || fm.skillOrigin !== "promoted_external")
           continue;
         const skillUsage = peUsageEntries.filter((e) => {
@@ -19839,7 +19883,7 @@ async function runCuratorPhase(directory, phase, agentsDispatched, config, knowl
     } catch (peErr) {
       warn(`[curator] promoted-external staleness check failed: ${peErr instanceof Error ? peErr.message : String(peErr)}`);
     }
-    const autoRetireObservations = await _internals22.autoRetireSkills(directory, curatorKnowledgePath, revisedSlugs);
+    const autoRetireObservations = await _internals23.autoRetireSkills(directory, curatorKnowledgePath, revisedSlugs);
     if (autoRetireObservations.length > 0) {
       const retireNote = ` [${autoRetireObservations.length} skill(s) auto-retired]`;
       phaseDigest.summary += retireNote;
@@ -19976,7 +20020,7 @@ async function applyCuratorKnowledgeUpdates(directory, recommendations, knowledg
   const authorizedRevisions = new Map;
   let preSnapshot = [];
   if (validRecommendations.length > 0) {
-    preSnapshot = await _internals22.readKnowledge(knowledgePath);
+    preSnapshot = await _internals23.readKnowledge(knowledgePath);
     const authorizedRecs = [];
     for (const rec of validRecommendations) {
       if (rec.action !== "archive" && rec.action !== "rewrite") {
@@ -20005,7 +20049,7 @@ async function applyCuratorKnowledgeUpdates(directory, recommendations, knowledg
     }
     validRecommendations = authorizedRecs;
   }
-  const dedupCheck = await _internals22.checkRecommendations(directory, validRecommendations.map((rec) => buildCuratorRecommendationCandidate(canonicalizeRecommendationEntryId(rec, preSnapshot))));
+  const dedupCheck = await _internals23.checkRecommendations(directory, validRecommendations.map((rec) => buildCuratorRecommendationCandidate(canonicalizeRecommendationEntryId(rec, preSnapshot))));
   if (!dedupCheck.degraded) {
     const keptRecommendations = [];
     for (const decision of dedupCheck.decisions) {
@@ -20166,7 +20210,7 @@ async function applyCuratorKnowledgeUpdates(directory, recommendations, knowledg
     } catch {}
   }
   if (contradictedEntries.length > 0 && knowledgeConfig.contradiction_threshold_action === "quarantine") {
-    const { maybeQuarantineOnContradiction } = await import("./knowledge-escalator-h7fspgph.js");
+    const { maybeQuarantineOnContradiction } = await import("./knowledge-escalator-2xe8z24p.js");
     for (const { id } of contradictedEntries) {
       try {
         await maybeQuarantineOnContradiction(directory, id, knowledgeConfig.contradiction_quarantine_threshold, knowledgeConfig.contradiction_quarantine_window_days);
@@ -20279,7 +20323,7 @@ async function applyCuratorKnowledgeUpdates(directory, recommendations, knowledg
     currentLessons.push(lesson);
     emittedCandidates.push(buildCuratorRecommendationCandidate(rec));
   }
-  await _internals22.recordEmittedRecommendations(directory, emittedCandidates);
+  await _internals23.recordEmittedRecommendations(directory, emittedCandidates);
   return { applied, skipped };
 }
 
@@ -20550,18 +20594,18 @@ async function executePostMortemActions(directory, parsed, options, generation)
     proposals_rejected: 0,
     proposals_skipped: 0
   };
-  const knowledgeConfig = options.knowledgeConfig ?? await _internals23.loadDefaultKnowledgeConfig(directory);
+  const knowledgeConfig = options.knowledgeConfig ?? await _internals24.loadDefaultKnowledgeConfig(directory);
   if (parsed.recommendations.length > 0) {
     try {
-      const knowledgeResult = await _internals23.applyCuratorKnowledgeUpdates(directory, parsed.recommendations, knowledgeConfig, generation);
+      const knowledgeResult = await _internals24.applyCuratorKnowledgeUpdates(directory, parsed.recommendations, knowledgeConfig, generation);
       result.knowledge_applied = knowledgeResult.applied;
       result.knowledge_skipped = knowledgeResult.skipped;
     } catch (err) {
       warnings.push(`Post-mortem knowledge actions failed: ${err instanceof Error ? err.message : String(err)}`);
     }
     try {
-      const entries = await _internals23.readSwarmKnowledge(directory);
-      const hiveResult = await _internals23.checkHivePromotions(entries, knowledgeConfig, directory);
+      const entries = await _internals24.readSwarmKnowledge(directory);
+      const hiveResult = await _internals24.checkHivePromotions(entries, knowledgeConfig, directory);
       result.hive_promotions = hiveResult.new_promotions;
       result.hive_encounters_incremented = hiveResult.encounters_incremented;
       result.hive_advancements = hiveResult.advancements;
@@ -20571,7 +20615,7 @@ async function executePostMortemActions(directory, parsed, options, generation)
   }
   if (parsed.queueTriage.length > 0) {
     try {
-      const proposalResult = await _internals23.applyProposalTriage(directory, parsed.queueTriage);
+      const proposalResult = await _internals24.applyProposalTriage(directory, parsed.queueTriage);
       result.proposals_approved = proposalResult.approved.length;
       result.proposals_rejected = proposalResult.rejected.length;
       result.proposals_skipped = proposalResult.skipped.length;
@@ -20584,7 +20628,7 @@ async function executePostMortemActions(directory, parsed, options, generation)
 async function verifyPostMortemKnowledgeActions(directory, recommendations) {
   if (recommendations.length === 0)
     return [];
-  const entries = await _internals23.readSwarmKnowledge(directory);
+  const entries = await _internals24.readSwarmKnowledge(directory);
   const activeEntries = entries.filter((entry) => isActiveStatus(entry.status));
   const exactIds = new Set(activeEntries.map((entry) => entry.id));
   const prefixMatches = new Map;
@@ -20685,7 +20729,7 @@ async function repairPostMortemActions(llmOutput, diagnostics, options) {
     ].join(`
 `);
     const repaired = await options.llmDelegate("", repairPrompt, ac.signal);
-    const parsed = _internals23.parsePostMortemActions(repaired);
+    const parsed = _internals24.parsePostMortemActions(repaired);
     if (parsed.diagnostics.length === 0) {
       return parsed;
     }
@@ -20738,7 +20782,7 @@ function collectRetrospectives(directory) {
 }
 async function collectDriftReports(directory) {
   try {
-    const reports = await _internals23.readPriorDriftReports(directory);
+    const reports = await _internals24.readPriorDriftReports(directory);
     return reports.slice(-MAX_DRIFT_REPORTS).map((report) => JSON.stringify(report, null, 2));
   } catch {
     return [];
@@ -20963,7 +21007,7 @@ async function runCuratorPostMortem(directory, options = {}) {
       warnings
     };
   }
-  const lock = await _internals23.acquirePostMortemLock(directory, effectivePlanId);
+  const lock = await _internals24.acquirePostMortemLock(directory, effectivePlanId);
   if (!lock.acquired) {
     return {
       success: false,
@@ -20985,7 +21029,7 @@ async function runCuratorPostMortem(directory, options = {}) {
       warnings.push("Failed to collect knowledge summary.");
     }
     try {
-      const { getScanStatus } = await import("./scan-cursor-xbkae12h.js");
+      const { getScanStatus } = await import("./scan-cursor-yzj9n225.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.`);
@@ -21044,20 +21088,20 @@ async function runCuratorPostMortem(directory, options = {}) {
         } finally {
           clearTimeout(timer);
         }
-        let parsedActions = _internals23.parsePostMortemActions(llmOutput);
+        let parsedActions = _internals24.parsePostMortemActions(llmOutput);
         if (parsedActions.diagnostics.length > 0) {
           warnings.push(`Post-mortem structured action parse diagnostics: ${parsedActions.diagnostics.join("; ")}`);
-          const repaired = await _internals23.repairPostMortemActions(llmOutput, parsedActions.diagnostics, options);
+          const repaired = await _internals24.repairPostMortemActions(llmOutput, parsedActions.diagnostics, options);
           if (repaired) {
             parsedActions = repaired;
             warnings.push("Post-mortem structured actions repaired by LLM.");
           }
         }
         llmSummary = parsedActions.summary;
-        const executed = await _internals23.executePostMortemActions(directory, parsedActions, options, scanCursor.generation);
+        const executed = await _internals24.executePostMortemActions(directory, parsedActions, options, scanCursor.generation);
         actionResult = executed.result;
         warnings.push(...executed.warnings);
-        const knowledgeVerification = await _internals23.verifyPostMortemKnowledgeActions(directory, parsedActions.recommendations);
+        const knowledgeVerification = await _internals24.verifyPostMortemKnowledgeActions(directory, parsedActions.recommendations);
         for (const item of knowledgeVerification) {
           if (item.status === "not_found" || item.status === "ambiguous_prefix" || item.status === "missing_entry_id") {
             warnings.push(`Post-mortem knowledge action ${item.action} for '${item.input_entry_id ?? "new"}' ${item.status}: ${item.reason}`);
@@ -21096,10 +21140,10 @@ ${actionSummary}`;
       } catch (err) {
         const msg = err instanceof Error ? err.message : String(err);
         warnings.push(`LLM delegate failed, falling back to data-only report: ${msg}`);
-        reportContent = _internals23.buildDataOnlyReport(effectivePlanId, planSummary, knowledgeSummary, curatorDigest, proposals, unactionable, retrospectives, driftReports, { scope, sessionID: options.sessionID, planLoaded });
+        reportContent = _internals24.buildDataOnlyReport(effectivePlanId, planSummary, knowledgeSummary, curatorDigest, proposals, unactionable, retrospectives, driftReports, { scope, sessionID: options.sessionID, planLoaded });
       }
     } else {
-      reportContent = _internals23.buildDataOnlyReport(effectivePlanId, planSummary, knowledgeSummary, curatorDigest, proposals, unactionable, retrospectives, driftReports, { scope, sessionID: options.sessionID, planLoaded });
+      reportContent = _internals24.buildDataOnlyReport(effectivePlanId, planSummary, knowledgeSummary, curatorDigest, proposals, unactionable, retrospectives, driftReports, { scope, sessionID: options.sessionID, planLoaded });
     }
     try {
       const { mkdirSync: mkdirSync12 } = await import("fs");
@@ -21140,7 +21184,7 @@ ${actionSummary}`;
     }
   }
 }
-var _internals23 = {
+var _internals24 = {
   acquirePostMortemLock,
   collectKnowledgeSummary,
   collectRetrospectives,
@@ -21157,9 +21201,9 @@ var _internals23 = {
   verifyPostMortemKnowledgeActions,
   repairPostMortemActions,
   loadDefaultKnowledgeConfig: async (directory) => {
-    const { KnowledgeConfigSchema: KnowledgeConfigSchema2 } = await import("./schema-7jm70cab.js");
+    const { KnowledgeConfigSchema: KnowledgeConfigSchema2 } = await import("./schema-cr1nr1w0.js");
     try {
-      const { loadPluginConfigWithMeta: loadPluginConfigWithMeta2 } = await import("./index-rtgqy0yg.js");
+      const { loadPluginConfigWithMeta: loadPluginConfigWithMeta2 } = await import("./index-bqan4y2y.js");
       const loaded = loadPluginConfigWithMeta2(directory);
       return KnowledgeConfigSchema2.parse(loaded.config.knowledge ?? {});
     } catch {
@@ -21167,11 +21211,11 @@ var _internals23 = {
     }
   },
   applyCuratorKnowledgeUpdates: async (directory, recommendations, knowledgeConfig, generation) => {
-    const { applyCuratorKnowledgeUpdates: applyCuratorKnowledgeUpdates2 } = await import("./curator-36dxw38r.js");
+    const { applyCuratorKnowledgeUpdates: applyCuratorKnowledgeUpdates2 } = await import("./curator-jc5cc980.js");
     return applyCuratorKnowledgeUpdates2(directory, recommendations, knowledgeConfig, generation);
   },
   checkHivePromotions: async (entries, knowledgeConfig, directory) => {
-    const { checkHivePromotions } = await import("./hive-promoter-daxrn62p.js");
+    const { checkHivePromotions } = await import("./hive-promoter-wyejhz8b.js");
     return checkHivePromotions(entries, knowledgeConfig, directory);
   },
   applyProposalTriage: async (directory, triage) => {
@@ -21180,7 +21224,7 @@ var _internals23 = {
       activateProposal,
       listSkills: listSkills2,
       sanitizeSlug
-    } = await import("./skill-generator-8gtq1ajr.js");
+    } = await import("./skill-generator-ybncj9et.js");
     const result = {
       approved: [],
       rejected: [],
@@ -21328,10 +21372,10 @@ var HIVE_LOCK_RETRIES = {
   retries: { retries: 5, minTimeout: 100, maxTimeout: 500 }
 };
 async function transactHiveStore(mutate) {
-  const dataDir = _internals24.resolveHiveDataDir();
-  const hivePath = _internals24.resolveHiveKnowledgePath();
-  const rejectedPath = _internals24.resolveHiveRejectedPath();
-  const eventsPath = _internals24.resolveHiveEventsPath();
+  const dataDir = _internals25.resolveHiveDataDir();
+  const hivePath = _internals25.resolveHiveKnowledgePath();
+  const rejectedPath = _internals25.resolveHiveRejectedPath();
+  const eventsPath = _internals25.resolveHiveEventsPath();
   const diagnostics = [];
   try {
     await mkdir8(dataDir, { recursive: true });
@@ -21342,7 +21386,7 @@ async function transactHiveStore(mutate) {
   let release = null;
   try {
     try {
-      release = await _internals24.lockfile.lock(dataDir, {
+      release = await _internals25.lockfile.lock(dataDir, {
         ...HIVE_LOCK_RETRIES,
         stale: HIVE_LOCK_STALE_MS
       });
@@ -21350,7 +21394,7 @@ async function transactHiveStore(mutate) {
       diagnostics.push(`hive lock acquire failed: ${err instanceof Error ? err.message : String(err)}`);
       return { committed: false, return: undefined, diagnostics };
     }
-    const entries = await _internals24.readKnowledge(hivePath);
+    const entries = await _internals25.readKnowledge(hivePath);
     const outcome = await mutate({ entries });
     if (outcome.kind === "noop") {
       return { committed: false, return: outcome.return, diagnostics };
@@ -21371,12 +21415,12 @@ async function transactHiveStore(mutate) {
       return { committed: false, return: undefined, diagnostics };
     }
     if (typeof outcome.maxEntries === "number" && committedEntries.length > outcome.maxEntries) {
-      committedEntries = _internals24.selectKnowledgeCapSurvivors(committedEntries, outcome.maxEntries);
+      committedEntries = _internals25.selectKnowledgeCapSurvivors(committedEntries, outcome.maxEntries);
     }
     const content = committedEntries.map((e) => JSON.stringify(e)).join(`
 `) + (committedEntries.length > 0 ? `
 ` : "");
-    await _internals24.atomicWriteFile(hivePath, content);
+    await _internals25.atomicWriteFile(hivePath, content);
     if (outcome.rejects && outcome.rejects.length > 0) {
       const rejectBlock = `${outcome.rejects.map((r) => JSON.stringify(r)).join(`
 `)}
@@ -21418,7 +21462,7 @@ async function trimHiveEventsUnderLock(eventsPath) {
 `)}
 `);
 }
-var _internals24 = {
+var _internals25 = {
   lockfile: import_proper_lockfile3.default,
   readKnowledge,
   atomicWriteFile,
@@ -21588,8 +21632,8 @@ async function checkHivePromotions(swarmEntries, config, directory) {
   if (config.hive_enabled === false) {
     return empty;
   }
-  const sourceCohort = await _internals25.resolveCohortId(directory);
-  const evidence2 = await _internals25.loadPromotionEvidence(directory);
+  const sourceCohort = await _internals26.resolveCohortId(directory);
+  const evidence2 = await _internals26.loadPromotionEvidence(directory);
   const diagnostics = [];
   const activeSwarm = swarmEntries.filter((e) => isActiveStatus(e.status));
   const activeSwarmBigrams = activeSwarm.map((e) => typeof e.lesson === "string" ? wordBigrams(e.lesson) : new Set);
@@ -21609,7 +21653,7 @@ async function checkHivePromotions(swarmEntries, config, directory) {
       diagnostics.push(`skip promote '${swarmEntry.lesson.slice(0, 40)}\u2026': ${decision.reason}`);
       continue;
     }
-    const validationResult = _internals25.validateLesson(swarmEntry.lesson, [], {
+    const validationResult = _internals26.validateLesson(swarmEntry.lesson, [], {
       category: swarmEntry.category,
       scope: swarmEntry.scope,
       confidence: swarmEntry.confidence
@@ -21631,7 +21675,7 @@ async function checkHivePromotions(swarmEntries, config, directory) {
     });
   }
   const hiveDir = resolveHiveDataDir();
-  const result = await _internals25.transactHiveStore(async (ctx) => {
+  const result = await _internals26.transactHiveStore(async (ctx) => {
     let newPromotions = 0;
     let encounters = 0;
     let advancements = 0;
@@ -21857,7 +21901,7 @@ async function authorizeAndRecordHiveMerge(args) {
   let authorized = true;
   let basis = "config-skipped-unlinked";
   try {
-    const decision = await _internals25.authorizeCuration({
+    const decision = await _internals26.authorizeCuration({
       directory: hiveDir,
       action: "merge",
       entryId: survivingEntry.id,
@@ -21887,7 +21931,7 @@ async function authorizeAndRecordHiveMerge(args) {
     authorizationBasis: basis
   });
 }
-var _internals25 = {
+var _internals26 = {
   readSwarmEntries: (directory) => readKnowledge(resolveSwarmKnowledgePath(directory)),
   checkHivePromotions,
   readCuratorSummary,
@@ -21901,15 +21945,15 @@ var _internals25 = {
 };
 function createHivePromoterHook(directory, config) {
   const hook = async (_input, _output) => {
-    const swarmEntries = await _internals25.readSwarmEntries(directory);
-    const promotionSummary = await _internals25.checkHivePromotions(swarmEntries, config, directory);
-    const curatorSummary = await _internals25.readCuratorSummary(directory);
+    const swarmEntries = await _internals26.readSwarmEntries(directory);
+    const promotionSummary = await _internals26.checkHivePromotions(swarmEntries, config, directory);
+    const curatorSummary = await _internals26.readCuratorSummary(directory);
     if (!curatorSummary)
       return;
     const hasActivity = promotionSummary.new_promotions > 0 || promotionSummary.encounters_incremented > 0 || promotionSummary.advancements > 0;
     if (!hasActivity)
       return;
-    await _internals25.appendCuratorRecommendation(directory, {
+    await _internals26.appendCuratorRecommendation(directory, {
       action: "promote",
       lesson: `Hive promotion: ${promotionSummary.new_promotions} new, ${promotionSummary.encounters_incremented} encounters, ${promotionSummary.advancements} advancements, ${promotionSummary.total_hive_entries} total entries`,
       reason: JSON.stringify({
@@ -21947,16 +21991,16 @@ function normalizeManualActionability(fields) {
 async function promoteToHive(directory, lesson, category, options, config, actionable) {
   const trimmedLesson = lesson.trim();
   const actionableFields = normalizeManualActionability(actionable);
-  const sourceCohort = await _internals25.resolveCohortId(directory);
-  const policyConfig = config ?? _internals25.loadDefaultKnowledgeConfig();
-  const result = await _internals25.transactHiveStore(async (ctx) => {
+  const sourceCohort = await _internals26.resolveCohortId(directory);
+  const policyConfig = config ?? _internals26.loadDefaultKnowledgeConfig();
+  const result = await _internals26.transactHiveStore(async (ctx) => {
     if (findNearDuplicate(trimmedLesson, ctx.entries, policyConfig.dedup_threshold)) {
       return {
         kind: "noop",
         return: `Lesson already exists in hive (near-duplicate).`
       };
     }
-    const validationResult = _internals25.validateLesson(trimmedLesson, ctx.entries.map((e) => e.lesson), {
+    const validationResult = _internals26.validateLesson(trimmedLesson, ctx.entries.map((e) => e.lesson), {
       category: category || "process",
       scope: "global",
       confidence: 1
@@ -22067,16 +22111,16 @@ async function promoteFromSwarm(directory, lessonId, options, config) {
   if (!swarmEntry) {
     throw new Error(`Lesson ${lessonId} not found in .swarm/knowledge.jsonl`);
   }
-  const sourceCohort = await _internals25.resolveCohortId(directory);
-  const policyConfig = config ?? _internals25.loadDefaultKnowledgeConfig();
-  const result = await _internals25.transactHiveStore(async (ctx) => {
+  const sourceCohort = await _internals26.resolveCohortId(directory);
+  const policyConfig = config ?? _internals26.loadDefaultKnowledgeConfig();
+  const result = await _internals26.transactHiveStore(async (ctx) => {
     if (findNearDuplicate(swarmEntry.lesson, ctx.entries, policyConfig.dedup_threshold)) {
       return {
         kind: "noop",
         return: `Lesson already exists in hive (near-duplicate).`
       };
     }
-    const validationResult = _internals25.validateLesson(swarmEntry.lesson, ctx.entries.map((e) => e.lesson), {
+    const validationResult = _internals26.validateLesson(swarmEntry.lesson, ctx.entries.map((e) => e.lesson), {
       category: swarmEntry.category,
       scope: swarmEntry.scope,
       confidence: swarmEntry.confidence
@@ -22411,7 +22455,7 @@ var SKILL_AUDIENCE_RUNNER_PATTERN = /^runner:(opencode|claude|codex)$/;
 var WORKFLOW_BOOST_MIN_CONTEXT = 0.05;
 var RECENCY_DECAY_MS = 30 * 24 * 60 * 60 * 1000;
 var SKILL_FRONTMATTER_READ_BYTES = 16 * 1024;
-var _internals26 = {
+var _internals27 = {
   computeSkillRelevanceScore: null,
   rankSkillsForContext: null,
   getSkillStats: null,
@@ -22778,7 +22822,7 @@ function rankSkillsForContext(skills, taskContext, directory) {
   const results = [];
   for (const skillPath of skills) {
     const skillEntries = allEntries.filter((e) => e.skillPath === skillPath);
-    const metadata = _internals26.readSkillMetadata(skillPath, directory);
+    const metadata = _internals27.readSkillMetadata(skillPath, directory);
     const score = computeSkillRelevanceScore(skillPath, taskContext, skillEntries, metadata);
     const entriesWithVerdict = skillEntries.filter((e) => e.complianceVerdict !== undefined && e.complianceVerdict !== "not_checked");
     const compliantCount = entriesWithVerdict.filter((e) => e.complianceVerdict === "compliant").length;
@@ -22837,7 +22881,7 @@ function formatSkillIndexWithContext(skills, directory, metadataBySkillPath) {
   } catch {}
   if (!hasHistory) {
     return skills.map((sp) => {
-      const meta = metadataBySkillPath?.get(sp) ?? _internals26.readSkillMetadata(sp, directory);
+      const meta = metadataBySkillPath?.get(sp) ?? _internals27.readSkillMetadata(sp, directory);
       return `  - file:${meta.path} - ${meta.name}: ${meta.description}`;
     }).join(`
 `);
@@ -22845,7 +22889,7 @@ function formatSkillIndexWithContext(skills, directory, metadataBySkillPath) {
   const lines = [];
   for (const skillPath of skills) {
     const stats = getSkillStats(skillPath, directory);
-    const meta = metadataBySkillPath?.get(skillPath) ?? _internals26.readSkillMetadata(skillPath, directory);
+    const meta = metadataBySkillPath?.get(skillPath) ?? _internals27.readSkillMetadata(skillPath, directory);
     const compliancePct = Math.round(stats.complianceRate * 100);
     const topAgentNames = stats.topAgents.slice(0, 3).map((a) => a.agent).join(", ");
     lines.push(`  - file:${meta.path} - ${meta.name}: ${meta.description} (used: ${stats.totalUsage}, compliance: ${compliancePct}%)` + (stats.topAgents.length > 0 ? ` \u2192 ${topAgentNames}` : ""));
@@ -22853,16 +22897,16 @@ function formatSkillIndexWithContext(skills, directory, metadataBySkillPath) {
   return lines.join(`
 `);
 }
-_internals26.computeSkillRelevanceScore = computeSkillRelevanceScore;
-_internals26.rankSkillsForContext = rankSkillsForContext;
-_internals26.getSkillStats = getSkillStats;
-_internals26.formatSkillIndexWithContext = formatSkillIndexWithContext;
-_internals26.parseSkillFrontmatter = parseSkillFrontmatter;
-_internals26.readSkillMetadata = readSkillMetadata;
-_internals26.extractSkillName = extractSkillName;
-_internals26.computeRecencyScore = computeRecencyScore;
-_internals26.computeContextMatchScore = computeContextMatchScore;
-_internals26.computeTriggerMatchBoost = computeTriggerMatchBoost;
+_internals27.computeSkillRelevanceScore = computeSkillRelevanceScore;
+_internals27.rankSkillsForContext = rankSkillsForContext;
+_internals27.getSkillStats = getSkillStats;
+_internals27.formatSkillIndexWithContext = formatSkillIndexWithContext;
+_internals27.parseSkillFrontmatter = parseSkillFrontmatter;
+_internals27.readSkillMetadata = readSkillMetadata;
+_internals27.extractSkillName = extractSkillName;
+_internals27.computeRecencyScore = computeRecencyScore;
+_internals27.computeContextMatchScore = computeContextMatchScore;
+_internals27.computeTriggerMatchBoost = computeTriggerMatchBoost;
 
 // src/hooks/skill-propagation-gate.ts
 function parseSimpleYaml(content) {
@@ -22964,10 +23008,10 @@ function parseYamlValue(value) {
 }
 function loadRoutingSkills(directory, targetAgent) {
   const routingPath = path37.join(directory, ".opencode", "skill-routing.yaml");
-  if (!_internals27.existsSync(routingPath))
+  if (!_internals28.existsSync(routingPath))
     return [];
   try {
-    const content = _internals27.readFileSync(routingPath, "utf-8");
+    const content = _internals28.readFileSync(routingPath, "utf-8");
     const config = parseSimpleYaml(content);
     if (!config?.routing)
       return [];
@@ -22994,7 +23038,7 @@ var SKILL_SEARCH_ROOTS = [
   ".claude/skills"
 ];
 var MAX_SCORING_SESSION_ENTRIES = 500;
-var _internals27 = {
+var _internals28 = {
   readdirSync: fs13.readdirSync.bind(fs13),
   existsSync: fs13.existsSync.bind(fs13),
   statSync: fs13.statSync.bind(fs13),
@@ -23027,11 +23071,11 @@ function discoverAvailableSkills(directory) {
   const results = [];
   for (const root of SKILL_SEARCH_ROOTS) {
     const rootPath = path37.join(directory, root);
-    if (!_internals27.existsSync(rootPath))
+    if (!_internals28.existsSync(rootPath))
       continue;
     let entries;
     try {
-      entries = _internals27.readdirSync(rootPath);
+      entries = _internals28.readdirSync(rootPath);
     } catch {
       continue;
     }
@@ -23039,11 +23083,11 @@ function discoverAvailableSkills(directory) {
       if (entry.startsWith("."))
         continue;
       const skillDir = path37.join(rootPath, entry);
-      if (_internals27.existsSync(path37.join(skillDir, "retired.marker")) || _internals27.existsSync(path37.join(skillDir, "stale.marker")))
+      if (_internals28.existsSync(path37.join(skillDir, "retired.marker")) || _internals28.existsSync(path37.join(skillDir, "stale.marker")))
         continue;
       const skillFile = path37.join(skillDir, "SKILL.md");
       try {
-        if (_internals27.statSync(skillDir).isDirectory() && _internals27.existsSync(skillFile)) {
+        if (_internals28.statSync(skillDir).isDirectory() && _internals28.existsSync(skillFile)) {
           results.push(path37.join(root, entry, "SKILL.md").replace(/\\/g, "/"));
         }
       } catch (err) {
@@ -23075,7 +23119,7 @@ function parseDelegationArgs(args) {
   }
   if (!targetAgent)
     return null;
-  const skillsField = prompt ? _internals27.extractSkillsFieldFromPrompt(prompt) : "";
+  const skillsField = prompt ? _internals28.extractSkillsFieldFromPrompt(prompt) : "";
   return { targetAgent, skillsField };
 }
 function extractSkillsFieldFromPrompt(prompt) {
@@ -23116,10 +23160,10 @@ function writeWarnEvent(directory, record) {
   const filePath = path37.join(directory, ".swarm", "events.jsonl");
   try {
     const dir = path37.dirname(filePath);
-    if (!_internals27.existsSync(dir)) {
-      _internals27.mkdirSync(dir, { recursive: true });
+    if (!_internals28.existsSync(dir)) {
+      _internals28.mkdirSync(dir, { recursive: true });
     }
-    _internals27.appendFileSync(filePath, `${JSON.stringify(record)}
+    _internals28.appendFileSync(filePath, `${JSON.stringify(record)}
 `, "utf-8");
   } catch (err) {
     warn(`[skill-propagation-gate] failed to write warning event: ${err instanceof Error ? err.message : String(err)}`);
@@ -23174,7 +23218,7 @@ function validateSkillReference(directory, reference, context, options) {
     };
   }
   try {
-    const root = _internals27.realpathSync(directory);
+    const root = _internals28.realpathSync(directory);
     const lexicalPath = path37.resolve(root, withoutPrefix);
     if (!isWithinRoot(root, lexicalPath)) {
       return {
@@ -23182,10 +23226,10 @@ function validateSkillReference(directory, reference, context, options) {
         reason: "skill path resolves outside the project"
       };
     }
-    if (!_internals27.existsSync(lexicalPath) || !_internals27.statSync(lexicalPath).isFile()) {
+    if (!_internals28.existsSync(lexicalPath) || !_internals28.statSync(lexicalPath).isFile()) {
       return { valid: false, reason: "skill file does not exist" };
     }
-    const realPath = _internals27.realpathSync(lexicalPath);
+    const realPath = _internals28.realpathSync(lexicalPath);
     if (!isWithinRoot(root, realPath)) {
       return {
         valid: false,
@@ -23194,7 +23238,7 @@ function validateSkillReference(directory, reference, context, options) {
     }
     const normalizedPath = withoutPrefix.replace(/^\.\//, "");
     const validatedMetadataPath = path37.relative(root, realPath).replace(/\\/g, "/");
-    const metadata = _internals27.readSkillMetadata(validatedMetadataPath, root);
+    const metadata = _internals28.readSkillMetadata(validatedMetadataPath, root);
     if (metadata.frontmatterStatus !== "valid" && metadata.frontmatterStatus !== "absent") {
       return {
         valid: false,
@@ -23226,18 +23270,18 @@ async function validateExplicitSkillReferencesBefore(directory, input, config) {
   if (!agentRaw || stripKnownSwarmPrefix(agentRaw) !== "architect") {
     return { blocked: false, reason: null };
   }
-  const parsed = _internals27.parseDelegationArgs(input.args);
+  const parsed = _internals28.parseDelegationArgs(input.args);
   if (!parsed)
     return { blocked: false, reason: null };
   const targetBase = stripKnownSwarmPrefix(parsed.targetAgent);
-  if (!_internals27.SKILL_CAPABLE_AGENTS.has(targetBase)) {
+  if (!_internals28.SKILL_CAPABLE_AGENTS.has(targetBase)) {
     return { blocked: false, reason: null };
   }
   const skillsValue = parsed.skillsField.trim();
   if (!skillsValue || skillsValue.toLowerCase() === "none") {
     return { blocked: false, reason: null };
   }
-  const fileReferences = _internals27.extractFileSkillReferences(skillsValue);
+  const fileReferences = _internals28.extractFileSkillReferences(skillsValue);
   if (fileReferences.length === 0) {
     return { blocked: false, reason: null, validatedSkillPaths: [] };
   }
@@ -23250,7 +23294,7 @@ async function validateExplicitSkillReferencesBefore(directory, input, config) {
   const context = resolveSkillAudienceContext(config);
   const validatedSkillPaths = [];
   for (const reference of fileReferences) {
-    const result = _internals27.validateSkillReference(directory, reference, context, {
+    const result = _internals28.validateSkillReference(directory, reference, context, {
       enforceAudience: true
     });
     if (!result.valid) {
@@ -23295,18 +23339,18 @@ async function skillPropagationGateBefore(directory, input, config) {
   const baseAgent = stripKnownSwarmPrefix(agentRaw);
   if (baseAgent !== "architect")
     return { blocked: false, reason: null, recommendedSkills: undefined };
-  const parsed = _internals27.parseDelegationArgs(input.args);
+  const parsed = _internals28.parseDelegationArgs(input.args);
   if (!parsed)
     return { blocked: false, reason: null, recommendedSkills: undefined };
   const targetBase = stripKnownSwarmPrefix(parsed.targetAgent);
-  if (!_internals27.SKILL_CAPABLE_AGENTS.has(targetBase))
+  if (!_internals28.SKILL_CAPABLE_AGENTS.has(targetBase))
     return { blocked: false, reason: null, recommendedSkills: undefined };
   const sessionID = typeof input.sessionID === "string" ? input.sessionID : "unknown";
   const audienceContext = resolveSkillAudienceContext(config);
   const availableSkills = [];
   const metadataBySkillPath = new Map;
-  for (const skillPath of _internals27.discoverAvailableSkills(directory)) {
-    const validation = _internals27.validateSkillReference(directory, skillPath, audienceContext, { enforceAudience: true, requireFilePrefix: false });
+  for (const skillPath of _internals28.discoverAvailableSkills(directory)) {
+    const validation = _internals28.validateSkillReference(directory, skillPath, audienceContext, { enforceAudience: true, requireFilePrefix: false });
     if (!validation.valid || !validation.skillPath)
       continue;
     availableSkills.push(validation.skillPath);
@@ -23317,7 +23361,7 @@ async function skillPropagationGateBefore(directory, input, config) {
   const skillsValue = parsed.skillsField.trim();
   if (skillsValue && skillsValue.toLowerCase() !== "none") {
     const prompt = typeof input.args?.prompt === "string" ? String(input.args.prompt) : "";
-    const taskId = _internals27.extractTaskIdFromPrompt(prompt);
+    const taskId = _internals28.extractTaskIdFromPrompt(prompt);
     const skillPaths = explicitIntegrity.validatedSkillPaths ?? [];
     let coderSkillPaths = [];
     if (prompt) {
@@ -23326,19 +23370,19 @@ async function skillPropagationGateBefore(directory, input, config) {
         const trimmed = line.trim();
         if (trimmed.startsWith("SKILLS_USED_BY_CODER:")) {
           const fieldVal = trimmed.slice("SKILLS_USED_BY_CODER:".length).trim();
-          coderSkillPaths = _internals27.parseSkillPaths(fieldVal);
+          coderSkillPaths = _internals28.parseSkillPaths(fieldVal);
           break;
         }
       }
     }
     const safeCoderSkillPaths = coderSkillPaths.flatMap((skillPath) => {
-      const validation = _internals27.validateSkillReference(directory, skillPath, audienceContext, { enforceAudience: false });
+      const validation = _internals28.validateSkillReference(directory, skillPath, audienceContext, { enforceAudience: false });
       return validation.valid && validation.skillPath ? [validation.skillPath] : [];
     });
     const allPaths = [...new Set([...skillPaths, ...safeCoderSkillPaths])];
     for (const skillPath of allPaths) {
       try {
-        _internals27.appendSkillUsageEntry(directory, {
+        _internals28.appendSkillUsageEntry(directory, {
           skillPath,
           agentName: targetBase,
           taskID: taskId,
@@ -23355,18 +23399,18 @@ async function skillPropagationGateBefore(directory, input, config) {
   let scored = [];
   if (skillsValue.toLowerCase() !== "none" && availableSkills.length > 0) {
     try {
-      const sessionEntries = _internals27.readSkillUsageEntriesTail(directory, {
+      const sessionEntries = _internals28.readSkillUsageEntriesTail(directory, {
         sessionID
       });
-      if (sessionEntries.length > _internals27.MAX_SCORING_SESSION_ENTRIES) {
+      if (sessionEntries.length > _internals28.MAX_SCORING_SESSION_ENTRIES) {
         scoringSkipped = true;
-        warn(`[skill-propagation-gate] skipping scoring \u2014 tail window has ${sessionEntries.length} session entries (limit: ${_internals27.MAX_SCORING_SESSION_ENTRIES})`);
+        warn(`[skill-propagation-gate] skipping scoring \u2014 tail window has ${sessionEntries.length} session entries (limit: ${_internals28.MAX_SCORING_SESSION_ENTRIES})`);
       } else {
         const prompt = typeof input.args?.prompt === "string" ? String(input.args.prompt) : "";
         scored = availableSkills.map((skillPath) => {
           const skillEntries = sessionEntries.filter((e) => e.skillPath === skillPath);
-          const metadata = metadataBySkillPath.get(skillPath) ?? _internals27.readSkillMetadata(skillPath, directory);
-          const score = _internals27.computeSkillRelevanceScore(skillPath, prompt, skillEntries, metadata);
+          const metadata = metadataBySkillPath.get(skillPath) ?? _internals28.readSkillMetadata(skillPath, directory);
+          const score = _internals28.computeSkillRelevanceScore(skillPath, prompt, skillEntries, metadata);
           return { skillPath, score, usageCount: skillEntries.length };
         }).sort((a, b) => b.score - a.score || b.usageCount - a.usageCount);
         if (scored.length > 0) {
@@ -23380,11 +23424,11 @@ async function skillPropagationGateBefore(directory, input, config) {
     }
   }
   try {
-    const routingPaths = _internals27.loadRoutingSkills(directory, targetBase);
+    const routingPaths = _internals28.loadRoutingSkills(directory, targetBase);
     if (routingPaths.length > 0) {
       const existingPaths = new Set(scored.map((s) => s.skillPath));
       for (const routingPath of routingPaths) {
-        const validation = _internals27.validateSkillReference(directory, routingPath, audienceContext, { enforceAudience: true, requireFilePrefix: false });
+        const validation = _internals28.validateSkillReference(directory, routingPath, audienceContext, { enforceAudience: true, requireFilePrefix: false });
         if (!validation.valid || !validation.skillPath)
           continue;
         const eligibleRoutingPath = validation.skillPath;
@@ -23392,7 +23436,7 @@ async function skillPropagationGateBefore(directory, input, config) {
           metadataBySkillPath.set(eligibleRoutingPath, validation.metadata);
         }
         const routedSkillDir = path37.dirname(path37.join(directory, eligibleRoutingPath));
-        if (_internals27.existsSync(path37.join(routedSkillDir, "retired.marker")) || _internals27.existsSync(path37.join(routedSkillDir, "stale.marker")))
+        if (_internals28.existsSync(path37.join(routedSkillDir, "retired.marker")) || _internals28.existsSync(path37.join(routedSkillDir, "stale.marker")))
           continue;
         if (!existingPaths.has(eligibleRoutingPath)) {
           scored.push({
@@ -23418,12 +23462,12 @@ async function skillPropagationGateBefore(directory, input, config) {
       } else if (typeof scored !== "undefined" && scored.length > 0) {
         skillsForIndex = scored.map((r) => r.skillPath);
       }
-      const formattedIndex = _internals27.formatSkillIndexWithContext(skillsForIndex, directory, metadataBySkillPath);
+      const formattedIndex = _internals28.formatSkillIndexWithContext(skillsForIndex, directory, metadataBySkillPath);
       if (formattedIndex.length > 0) {
         const contextPath = path37.join(directory, ".swarm", "context.md");
         let existingContent = "";
-        if (_internals27.existsSync(contextPath)) {
-          existingContent = _internals27.readFileSync(contextPath, "utf-8");
+        if (_internals28.existsSync(contextPath)) {
+          existingContent = _internals28.readFileSync(contextPath, "utf-8");
         }
         const sectionHeader = "## Available Skills";
         const newSection = `${sectionHeader}
@@ -23443,10 +23487,10 @@ ${newSection}`;
           }
         }
         const swarmDir = path37.dirname(contextPath);
-        if (!_internals27.existsSync(swarmDir)) {
-          _internals27.mkdirSync(swarmDir, { recursive: true });
+        if (!_internals28.existsSync(swarmDir)) {
+          _internals28.mkdirSync(swarmDir, { recursive: true });
         }
-        _internals27.writeFileSync(contextPath, updatedContent, "utf-8");
+        _internals28.writeFileSync(contextPath, updatedContent, "utf-8");
       }
     } catch (err) {
       warn(`[skill-propagation-gate] failed to write skill index to context.md: ${err instanceof Error ? err.message : String(err)}`);
@@ -23472,7 +23516,7 @@ ${newSection}`;
   });
   const warningMsg = `Skill propagation warning: Delegating to ${targetBase} without SKILLS field. ` + `Available skills: ${skillNames.join(", ")}`;
   try {
-    _internals27.writeWarnEvent(directory, {
+    _internals28.writeWarnEvent(directory, {
       type: "skill_propagation_warn",
       timestamp: new Date().toISOString(),
       tool: toolName,
@@ -23504,17 +23548,17 @@ async function skillPropagationTransformScan(directory, output, sessionID, confi
   const validatedProvenancePaths = (fieldValue) => {
     if (remainingProvenanceValidationBudget <= 0)
       return [];
-    const references = _internals27.parseSkillPaths(fieldValue).slice(0, remainingProvenanceValidationBudget);
+    const references = _internals28.parseSkillPaths(fieldValue).slice(0, remainingProvenanceValidationBudget);
     remainingProvenanceValidationBudget -= references.length;
     return references.flatMap((reference) => {
-      const validation = _internals27.validateSkillReference(directory, reference, audienceContext, { enforceAudience: true });
+      const validation = _internals28.validateSkillReference(directory, reference, audienceContext, { enforceAudience: true });
       return validation.valid && validation.skillPath ? [validation.skillPath] : [];
     });
   };
   let dedupKeys = new Set;
   let existingEntries = [];
   try {
-    existingEntries = _internals27.readSkillUsageEntriesTail(directory, {
+    existingEntries = _internals28.readSkillUsageEntriesTail(directory, {
       sessionID
     });
     dedupKeys = new Set(existingEntries.map((e, i) => {
@@ -23585,7 +23629,7 @@ async function skillPropagationTransformScan(directory, output, sessionID, confi
         if (isDuplicate(skillPath, "reviewer", resolvedTaskID))
           continue;
         try {
-          _internals27.appendSkillUsageEntry(directory, {
+          _internals28.appendSkillUsageEntry(directory, {
             skillPath,
             agentName: "reviewer",
             taskID: resolvedTaskID,
@@ -23630,14 +23674,14 @@ async function skillPropagationTransformScan(directory, output, sessionID, confi
       }
       if (currentTargetAgent && skillsField && skillsField.toLowerCase() !== "none") {
         const skillPaths = validatedProvenancePaths(skillsField);
-        const taskId = _internals27.extractTaskIdFromPrompt(text);
+        const taskId = _internals28.extractTaskIdFromPrompt(text);
         for (const skillPath of skillPaths) {
           if (hadRecordingError)
             break;
           if (isDuplicate(skillPath, currentTargetAgent, taskId))
             continue;
           try {
-            _internals27.appendSkillUsageEntry(directory, {
+            _internals28.appendSkillUsageEntry(directory, {
               skillPath,
               agentName: currentTargetAgent,
               taskID: taskId,
@@ -23657,18 +23701,18 @@ async function skillPropagationTransformScan(directory, output, sessionID, confi
     break;
   }
 }
-_internals27.skillPropagationGateBefore = skillPropagationGateBefore;
-_internals27.skillPropagationTransformScan = skillPropagationTransformScan;
-_internals27.writeWarnEvent = writeWarnEvent;
-_internals27.discoverAvailableSkills = discoverAvailableSkills;
-_internals27.parseDelegationArgs = parseDelegationArgs;
-_internals27.parseSkillPaths = parseSkillPaths;
-_internals27.extractFileSkillReferences = extractFileSkillReferences;
-_internals27.validateSkillReference = validateSkillReference;
-_internals27.extractTaskIdFromPrompt = extractTaskIdFromPrompt;
-_internals27.extractSkillsFieldFromPrompt = extractSkillsFieldFromPrompt;
-_internals27.formatSkillIndexWithContext = formatSkillIndexWithContext;
-_internals27.loadRoutingSkills = loadRoutingSkills;
+_internals28.skillPropagationGateBefore = skillPropagationGateBefore;
+_internals28.skillPropagationTransformScan = skillPropagationTransformScan;
+_internals28.writeWarnEvent = writeWarnEvent;
+_internals28.discoverAvailableSkills = discoverAvailableSkills;
+_internals28.parseDelegationArgs = parseDelegationArgs;
+_internals28.parseSkillPaths = parseSkillPaths;
+_internals28.extractFileSkillReferences = extractFileSkillReferences;
+_internals28.validateSkillReference = validateSkillReference;
+_internals28.extractTaskIdFromPrompt = extractTaskIdFromPrompt;
+_internals28.extractSkillsFieldFromPrompt = extractSkillsFieldFromPrompt;
+_internals28.formatSkillIndexWithContext = formatSkillIndexWithContext;
+_internals28.loadRoutingSkills = loadRoutingSkills;
 
 // src/hooks/micro-reflector.ts
 var REFLECT_OUTCOMES = new Set([
@@ -23807,9 +23851,9 @@ function hashContent(content) {
   return createHash9("sha1").update(content).digest("hex");
 }
 async function loadConfigForPolicyCurator(directory) {
-  const { KnowledgeConfigSchema: KnowledgeConfigSchema2 } = await import("./schema-7jm70cab.js");
+  const { KnowledgeConfigSchema: KnowledgeConfigSchema2 } = await import("./schema-cr1nr1w0.js");
   try {
-    const { loadPluginConfigWithMeta: loadPluginConfigWithMeta2 } = await import("./index-rtgqy0yg.js");
+    const { loadPluginConfigWithMeta: loadPluginConfigWithMeta2 } = await import("./index-bqan4y2y.js");
     const { config: loadedConfig } = loadPluginConfigWithMeta2(directory);
     return KnowledgeConfigSchema2.parse(loadedConfig.knowledge ?? {});
   } catch {
@@ -23819,7 +23863,7 @@ async function loadConfigForPolicyCurator(directory) {
 async function canonicalExistingPath(candidate) {
   let resolved = path39.resolve(candidate);
   try {
-    resolved = await _internals28.realpath(resolved);
+    resolved = await _internals29.realpath(resolved);
   } catch {}
   return resolved;
 }
@@ -24654,9 +24698,9 @@ async function curateAndStoreSwarm(lessons, projectName, phaseInfo, directory, c
     } catch {}
   }
   if (!options?.skipAutoPromotion) {
-    await _internals28.runAutoPromotion(directory, config);
+    await _internals29.runAutoPromotion(directory, config);
     if (phaseInfo.phase_number > 0) {
-      await _internals28.runAutoDemotion(directory, config, phaseInfo.phase_number);
+      await _internals29.runAutoDemotion(directory, config, phaseInfo.phase_number);
     }
   }
   return { stored, reinforced, skipped, rejected, quarantined };
@@ -24771,7 +24815,7 @@ function createKnowledgeCuratorHook(directory, config, options = {}) {
         }
         inFlightEvidenceEntries.add(evidenceKey);
         try {
-          await _internals28.curateAndStoreSwarm(batch.lessons, batch.projectName, { phase_number: batch.phaseNumber }, directory, config, {
+          await _internals29.curateAndStoreSwarm(batch.lessons, batch.projectName, { phase_number: batch.phaseNumber }, directory, config, {
             llmDelegate: options.llmDelegateFactory?.(trigger.sessionID),
             enrichmentQuota: options.enrichmentQuota
           });
@@ -24803,14 +24847,14 @@ function createKnowledgeCuratorHook(directory, config, options = {}) {
     const projectName = projectNameMatch ? projectNameMatch[1].trim() : "unknown";
     const phaseMatch = /^Phase:\s*(\d+)/m.exec(planContent);
     const phaseNumber = phaseMatch ? parseInt(phaseMatch[1], 10) : 1;
-    await _internals28.curateAndStoreSwarm(normalLessons, projectName, { phase_number: phaseNumber }, directory, config, {
+    await _internals29.curateAndStoreSwarm(normalLessons, projectName, { phase_number: phaseNumber }, directory, config, {
       llmDelegate: options.llmDelegateFactory?.(trigger.sessionID),
       enrichmentQuota: options.enrichmentQuota
     });
   };
   return safeHook(handler);
 }
-var _internals28 = {
+var _internals29 = {
   isWriteToEvidenceFile,
   curateAndStoreSwarm,
   runAutoPromotion,
@@ -24850,7 +24894,7 @@ async function runFinalizeRewardSweep(args) {
     }
     const timestamp = args.timestamp ?? new Date().toISOString();
     const vettedRoot = resolveVettedMemoryRoot(directory, memoryConfig);
-    const provider = _internals29.createConfiguredMemoryProviderForRoot(vettedRoot, memoryConfig);
+    const provider = _internals30.createConfiguredMemoryProviderForRoot(vettedRoot, memoryConfig);
     try {
       result.swept = true;
       for (const taskId of taskIds) {
@@ -24870,7 +24914,7 @@ async function runFinalizeRewardSweep(args) {
         }
         let taskRewarded = 0;
         for (const runId of runIds) {
-          const { memoriesRewarded } = await _internals29.applyCouncilReward(provider, {
+          const { memoriesRewarded } = await _internals30.applyCouncilReward(provider, {
             runId,
             unitId: taskId,
             reward: FINALIZE_NEGATIVE_TERMINAL_REWARD,
@@ -24896,7 +24940,7 @@ async function runFinalizeRewardSweep(args) {
   }
   return result;
 }
-var _internals29 = {
+var _internals30 = {
   createConfiguredMemoryProvider,
   createConfiguredMemoryProviderForRoot,
   applyCouncilReward
@@ -25552,9 +25596,9 @@ async function writeMotifProposals(directory, opts = {}) {
       return result;
     const max = opts.maxProposals ?? 10;
     const selected = motifs.slice(0, max);
-    const producedAt = _internals30.now().toISOString();
+    const producedAt = _internals31.now().toISOString();
     const candidates = selected.map((motif) => buildMotifCandidate(motif, opts.sessionId));
-    const dedupCheck = await _internals30.checkRecommendations(directory, candidates);
+    const dedupCheck = await _internals31.checkRecommendations(directory, candidates);
     const emitted = dedupCheck.decisions.filter((decision) => decision.emit);
     result.duplicatesSuppressed = dedupCheck.decisions.length - emitted.length;
     if (emitted.length === 0)
@@ -25576,7 +25620,7 @@ async function writeMotifProposals(directory, opts = {}) {
       result.proposalsWritten.push(filePath);
       written.push(candidate);
     }
-    await _internals30.recordEmittedRecommendations(directory, written, {
+    await _internals31.recordEmittedRecommendations(directory, written, {
       producedAt
     });
     return result;
@@ -25742,9 +25786,9 @@ async function writeSuccessMotifProposals(directory, opts = {}) {
       return result;
     const max = opts.maxProposals ?? 10;
     const selected = motifs.slice(0, max);
-    const producedAt = _internals30.now().toISOString();
+    const producedAt = _internals31.now().toISOString();
     const candidates = selected.map((motif) => buildWorkflowCandidate(motif, opts.sessionId));
-    const dedupCheck = await _internals30.checkRecommendations(directory, candidates);
+    const dedupCheck = await _internals31.checkRecommendations(directory, candidates);
     const emitted = dedupCheck.decisions.filter((decision) => decision.emit);
     result.duplicatesSuppressed = dedupCheck.decisions.length - emitted.length;
     if (emitted.length === 0)
@@ -25766,7 +25810,7 @@ async function writeSuccessMotifProposals(directory, opts = {}) {
       result.proposalsWritten.push(filePath);
       written.push(candidate);
     }
-    await _internals30.recordEmittedRecommendations(directory, written, {
+    await _internals31.recordEmittedRecommendations(directory, written, {
       producedAt
     });
     return result;
@@ -25775,7 +25819,7 @@ async function writeSuccessMotifProposals(directory, opts = {}) {
     return result;
   }
 }
-var _internals30 = {
+var _internals31 = {
   now: () => new Date,
   checkRecommendations,
   recordEmittedRecommendations
@@ -26104,7 +26148,7 @@ async function reconcileStaleActiveSkills(directory, options = {}) {
       continue;
     }
     try {
-      const regen = await _internals31.regenerateSkill(directory, skill.slug, {
+      const regen = await _internals32.regenerateSkill(directory, skill.slug, {
         evaluate: false
       });
       if (regen.regenerated) {
@@ -26360,7 +26404,7 @@ async function runSkillImprover(req) {
     autoApply
   };
 }
-var _internals31 = {
+var _internals32 = {
   runSkillImprover,
   buildDeterministicProposal,
   buildLLMProposalFrame,
@@ -26722,13 +26766,13 @@ var write_retro = createSwarmTool({
         task_id: args.task_id !== undefined ? String(args.task_id) : undefined,
         metadata: args.metadata
       };
-      return await _internals32.executeWriteRetro(writeRetroArgs, directory);
+      return await _internals33.executeWriteRetro(writeRetroArgs, directory);
     } catch {
       return JSON.stringify({ success: false, phase: rawPhase, message: "Invalid arguments" }, null, 2);
     }
   }
 });
-var _internals32 = {
+var _internals33 = {
   executeWriteRetro,
   write_retro
 };
@@ -27034,8 +27078,8 @@ async function runFinalizeStage(ctx) {
   ];
   ctx.curationSucceeded = false;
   try {
-    ctx.curationResult = await _internals33.curateAndStoreSwarm(ctx.allLessons, ctx.projectName, { phase_number: 0 }, ctx.directory, ctx.config, {
-      llmDelegate: _internals33.createCuratorLLMDelegate(ctx.directory, "phase", ctx.options.sessionID),
+    ctx.curationResult = await _internals34.curateAndStoreSwarm(ctx.allLessons, ctx.projectName, { phase_number: 0 }, ctx.directory, ctx.config, {
+      llmDelegate: _internals34.createCuratorLLMDelegate(ctx.directory, "phase", ctx.options.sessionID),
       enrichmentQuota: {
         maxCalls: ctx.config.enrichment.max_calls_per_day,
         window: ctx.config.enrichment.quota_window
@@ -27054,7 +27098,7 @@ async function runFinalizeStage(ctx) {
     if (ctx.config.hive_enabled === false) {} else {
       try {
         const entries = await readKnowledge(resolveSwarmKnowledgePath(ctx.directory));
-        const result = await _internals33.checkHivePromotions(entries, ctx.config, ctx.directory);
+        const result = await _internals34.checkHivePromotions(entries, ctx.config, ctx.directory);
         ctx.hivePromoted = result.new_promotions;
       } catch (hiveErr) {
         const msg = hiveErr instanceof Error ? hiveErr.message : String(hiveErr);
@@ -27075,7 +27119,7 @@ async function runFinalizeStage(ctx) {
   ctx.knowledgeSkillHint = ctx.sessionKnowledgeCreated > 0 ? `${ctx.sessionKnowledgeCreated} knowledge entries created this session. Consider running skill_improve or skill_generate to compile mature entries into skills.` : "";
   if (ctx.runSkillReview) {
     try {
-      const { config: loadedConfig } = _internals33.loadPluginConfigWithMeta(ctx.directory);
+      const { config: loadedConfig } = _internals34.loadPluginConfigWithMeta(ctx.directory);
       const skillImproverConfig = SkillImproverConfigSchema.parse(loadedConfig.skill_improver ?? {});
       const skillReviewResult = await runAbortableSkillReview({
         directory: ctx.directory,
@@ -27138,7 +27182,7 @@ async function runFinalizeStage(ctx) {
     }
     if (!ctx.planAlreadyDone || ctx.guaranteeResult.closedPhaseIds.length > 0 || ctx.guaranteeResult.closedTaskIds.length > 0) {
       try {
-        await _internals33.closePlanTerminalState(ctx.directory, ctx.planData, {
+        await _internals34.closePlanTerminalState(ctx.directory, ctx.planData, {
           closedPhaseIds: ctx.guaranteeResult.closedPhaseIds,
           closedTaskIds: ctx.guaranteeResult.closedTaskIds,
           originalStatuses: ctx.originalStatuses
@@ -27154,12 +27198,12 @@ async function runFinalizeStage(ctx) {
     }
   }
   try {
-    const { CuratorConfigSchema: CCS } = await import("./schema-7jm70cab.js");
-    const { config: pmLoadedConfig } = _internals33.loadPluginConfigWithMeta(ctx.directory);
+    const { CuratorConfigSchema: CCS } = await import("./schema-cr1nr1w0.js");
+    const { config: pmLoadedConfig } = _internals34.loadPluginConfigWithMeta(ctx.directory);
     const curatorCfg = CCS.parse(pmLoadedConfig.curator ?? {});
     if (curatorCfg.enabled && curatorCfg.postmortem_enabled) {
-      const pmResult = await _internals33.runCuratorPostMortem(ctx.directory, {
-        llmDelegate: _internals33.createCuratorLLMDelegate(ctx.directory, "postmortem", ctx.options.sessionID),
+      const pmResult = await _internals34.runCuratorPostMortem(ctx.directory, {
+        llmDelegate: _internals34.createCuratorLLMDelegate(ctx.directory, "postmortem", ctx.options.sessionID),
         scope: "project",
         sessionID: ctx.options.sessionID
       });
@@ -27185,7 +27229,7 @@ async function copySqliteSafe(srcPath, destPath, laneEnv) {
   }
   let checkpointVerified = false;
   try {
-    const result = _internals33.spawnSync("sqlite3", [srcPath, "PRAGMA wal_checkpoint(TRUNCATE);"], {
+    const result = _internals34.spawnSync("sqlite3", [srcPath, "PRAGMA wal_checkpoint(TRUNCATE);"], {
       cwd: path44.dirname(srcPath),
       encoding: "utf-8",
       stdio: ["ignore", "pipe", "pipe"],
@@ -27354,7 +27398,7 @@ async function runArchiveEvidenceRetention(ctx) {
   let cacheMaxBytes;
   let cacheMaxRecords;
   try {
-    const { config: evidenceLoadedConfig } = _internals33.loadPluginConfigWithMeta(ctx.directory);
+    const { config: evidenceLoadedConfig } = _internals34.loadPluginConfigWithMeta(ctx.directory);
     const evidenceCfg = evidenceLoadedConfig.evidence ?? {};
     if (typeof evidenceCfg.max_age_days === "number") {
       maxAgeDays = evidenceCfg.max_age_days;
@@ -27370,7 +27414,7 @@ async function runArchiveEvidenceRetention(ctx) {
     }
   } catch {}
   try {
-    await _internals33.archiveEvidence(ctx.directory, maxAgeDays, maxBundles, {
+    await _internals34.archiveEvidence(ctx.directory, maxAgeDays, maxBundles, {
       report: true,
       cacheMaxBytes,
       cacheMaxRecords
@@ -27577,9 +27621,9 @@ async function runAlignStage(ctx) {
   const pruneBranches = ctx.args.includes("--prune-branches");
   let gitAlignResult = "";
   const prunedBranches = [];
-  const gitStatus = _internals33.getGitRepositoryStatus(ctx.directory);
+  const gitStatus = _internals34.getGitRepositoryStatus(ctx.directory);
   if (gitStatus.isRepo) {
-    const aggressiveResult = await _internals33.resetToMainAfterMerge(ctx.directory, {
+    const aggressiveResult = await _internals34.resetToMainAfterMerge(ctx.directory, {
       pruneBranches
     });
     if (aggressiveResult.success) {
@@ -27591,7 +27635,7 @@ async function runAlignStage(ctx) {
         ctx.warnings.push("Uncommitted changes were discarded during git alignment");
       }
     } else {
-      const alignResult = await _internals33.resetToRemoteBranch(ctx.directory, {
+      const alignResult = await _internals34.resetToRemoteBranch(ctx.directory, {
         pruneBranches
       });
       gitAlignResult = alignResult.message;
@@ -27627,7 +27671,7 @@ async function runFinalizeDryRun(directory, swarmDir, planData, planExists) {
   const wouldArchiveDirs = ACTIVE_STATE_DIRS_TO_CLEAN.filter(existsInSwarm);
   const wouldRemoveTerminal = TERMINAL_STATE_FILES.filter(existsInSwarm);
   const wouldCleanFiles = ACTIVE_STATE_TO_CLEAN.filter((f) => existsInSwarm(f) && !TERMINAL_STATE_FILES.includes(f));
-  const gitStatus = _internals33.getGitRepositoryStatus(directory);
+  const gitStatus = _internals34.getGitRepositoryStatus(directory);
   const gitNote = gitStatus.isRepo ? "would align the working tree to main/remote (git reset), pruning merged branches only with --prune-branches" : "would skip git alignment (not a git repository / git unavailable)";
   const lines = [
     "## /swarm finalize \u2014 DRY RUN (no changes made)",
@@ -27699,12 +27743,12 @@ async function handleCloseCommand(directory, args, options = {}) {
     }
   }
   if (args.includes("--dry-run")) {
-    return _internals33.runFinalizeDryRun(directory, swarmDir, planData, planExists);
+    return _internals34.runFinalizeDryRun(directory, swarmDir, planData, planExists);
   }
   let finalizeLock = {
     acquired: false
   };
-  finalizeLock = await _internals33.acquireFinalizeLock(directory);
+  finalizeLock = await _internals34.acquireFinalizeLock(directory);
   if (!finalizeLock.acquired) {
     return `\u274C Another /swarm finalize is already running for this project. If you are certain no other run is active, wait for the lock to expire or remove the stale lock and retry.`;
   }
@@ -27735,7 +27779,7 @@ This project was already finalized in a previous /swarm close run. The plan has
     if (planExists) {
       planAlreadyDone = phases.length > 0 && phases.every((p) => p.status === "complete" || p.status === "completed" || p.status === "blocked" || p.status === "closed");
     }
-    const { config: loadedConfig } = _internals33.loadPluginConfigWithMeta(directory);
+    const { config: loadedConfig } = _internals34.loadPluginConfigWithMeta(directory);
     const config = KnowledgeConfigSchema.parse(loadedConfig.knowledge ?? {});
     const ctx = {
       directory,
@@ -27779,7 +27823,7 @@ This project was already finalized in a previous /swarm close run. The plan has
       args
     };
     await runFinalizeStage(ctx);
-    await _internals33.runFinalizeRewardSweep({
+    await _internals34.runFinalizeRewardSweep({
       directory,
       closedTaskIds: ctx.guaranteeResult.closedTaskIds,
       memoryConfig: loadedConfig.memory
@@ -27861,9 +27905,9 @@ This project was already finalized in a previous /swarm close run. The plan has
     try {
       const sessionIdsToEnd = [...swarmState.agentSessions.keys()];
       for (const sessionId of sessionIdsToEnd) {
-        _internals33.endAgentSession(sessionId);
+        _internals34.endAgentSession(sessionId);
       }
-      _internals33.resetSwarmStatePreservingSingletons();
+      _internals34.resetSwarmStatePreservingSingletons();
     } catch (teardownError) {
       const msg = teardownError instanceof Error ? teardownError.message : String(teardownError);
       ctx.warnings.push(`Session teardown encountered an error after finalization completed (state may not be fully reset): ${msg}`);
@@ -27937,7 +27981,7 @@ async function acquireFinalizeLock(directory) {
   }
   return { acquired: false };
 }
-var _internals33 = {
+var _internals34 = {
   ACTIVE_STATE_DIRS_TO_CLEAN,
   countSessionKnowledgeEntries,
   CLOSE_SKILL_REVIEW_TIMEOUT_MS,
@@ -28435,7 +28479,7 @@ function isValidTelemetryEntry(value) {
   const obj = value;
   return typeof obj.timestamp === "string" && typeof obj.task_id === "string" && typeof obj.agent_role === "string" && typeof obj.delegation_reason === "string" && typeof obj.token_estimate === "number" && typeof obj.cache_hits === "number" && typeof obj.cache_misses === "number" && typeof obj.stale_entries === "number" && typeof obj.recommended_reads === "number" && typeof obj.skipped_reads === "number" && typeof obj.success === "boolean";
 }
-var _internals34 = {
+var _internals35 = {
   appendFileSync: fs16.appendFileSync,
   readFileSync: fs16.readFileSync,
   existsSync: fs16.existsSync,
@@ -28448,10 +28492,10 @@ function readTelemetry(directory) {
   const filePath = telemetryFilePath(directory);
   const entries = [];
   try {
-    if (!_internals34.existsSync(filePath)) {
+    if (!_internals35.existsSync(filePath)) {
       return entries;
     }
-    const raw = _internals34.readFileSync(filePath, "utf-8");
+    const raw = _internals35.readFileSync(filePath, "utf-8");
     const lines = raw.split(`
 `);
     for (const line of lines) {
@@ -28888,9 +28932,9 @@ async function detectDarkMatter(directory, options) {
   } catch {
     return [];
   }
-  const commitMap = await _internals35.parseGitLog(directory, maxCommitsToAnalyze);
-  const matrix = _internals35.buildCoChangeMatrix(commitMap, maxFilesPerCommit);
-  const staticEdges = await _internals35.getStaticEdges(directory);
+  const commitMap = await _internals36.parseGitLog(directory, maxCommitsToAnalyze);
+  const matrix = _internals36.buildCoChangeMatrix(commitMap, maxFilesPerCommit);
+  const staticEdges = await _internals36.getStaticEdges(directory);
   const results = [];
   for (const entry of matrix.values()) {
     const key = `${entry.fileA}::${entry.fileB}`;
@@ -29006,11 +29050,11 @@ var co_change_analyzer = createSwarmTool({
       npmiThreshold,
       maxCommitsToAnalyze
     };
-    const pairs = await _internals35.detectDarkMatter(directory, options);
-    return _internals35.formatDarkMatterOutput(pairs);
+    const pairs = await _internals36.detectDarkMatter(directory, options);
+    return _internals36.formatDarkMatterOutput(pairs);
   }
 });
-var _internals35 = {
+var _internals36 = {
   parseGitLog,
   buildCoChangeMatrix,
   getStaticEdges,
@@ -29027,7 +29071,7 @@ var DEFAULT_MAX_COMMITS = 500;
 var cache = new Map;
 async function readGitHead(directory) {
   try {
-    const { stdout } = await _internals36.execFile("git", ["rev-parse", "HEAD"], {
+    const { stdout } = await _internals37.execFile("git", ["rev-parse", "HEAD"], {
       cwd: directory,
       timeout: GIT_HEAD_TIMEOUT_MS
     });
@@ -29053,9 +29097,9 @@ async function getCoChangeData(directory, options) {
   let entries;
   let commitsObserved;
   try {
-    const commitMap = await _internals36.parseGitLog(directory, maxCommits);
+    const commitMap = await _internals37.parseGitLog(directory, maxCommits);
     commitsObserved = commitMap.size;
-    const matrix = _internals36.buildCoChangeMatrix(commitMap);
+    const matrix = _internals37.buildCoChangeMatrix(commitMap);
     entries = Array.from(matrix.values());
   } catch {
     return { pairs: [], commitsObserved: 0 };
@@ -29079,10 +29123,10 @@ async function getCoChangePairs(directory, options) {
   const data = await getCoChangeData(directory, options);
   return data.pairs;
 }
-var _internals36 = {
+var _internals37 = {
   execFile: execFileAsync,
-  parseGitLog: _internals35.parseGitLog,
-  buildCoChangeMatrix: _internals35.buildCoChangeMatrix
+  parseGitLog: _internals36.parseGitLog,
+  buildCoChangeMatrix: _internals36.buildCoChangeMatrix
 };
 
 // src/turbo/epic/coupling-report.ts
@@ -29306,7 +29350,7 @@ async function handleCouplingCommand(directory, args) {
 
 Usage: /swarm coupling [--phase <n>] [--threshold <-1..1>] [--min-co-changes <n>] [--format markdown|json] [--persist]`;
   }
-  const plan = await _internals37.loadPlanJsonOnly(directory);
+  const plan = await _internals38.loadPlanJsonOnly(directory);
   if (plan === null) {
     return "No plan found at `.swarm/plan.json`. Run `/swarm plan` to create one before measuring coupling.";
   }
@@ -29330,7 +29374,7 @@ Usage: /swarm coupling [--phase <n>] [--threshold <-1..1>] [--min-co-changes <n>
     const scope = scopeFiles ?? task.files_touched ?? [];
     return { id: task.id, scope };
   });
-  const cochangePairs = await _internals37.getCoChangePairs(directory);
+  const cochangePairs = await _internals38.getCoChangePairs(directory);
   const report = computeCouplingReport(tasks, cochangePairs, {
     npmi: parsed.threshold,
     minCoChanges: parsed.minCoChanges
@@ -29369,14 +29413,14 @@ _Warning: failed to persist report (${persistStatus.error})._`;
   }
   return `${formatCouplingReportMarkdown(report)}${persistTrailer}`;
 }
-var _internals37 = {
+var _internals38 = {
   loadPlanJsonOnly,
   getCoChangePairs
 };
 
 // src/commands/curate.ts
 init_schema();
-var _internals38 = {
+var _internals39 = {
   checkHivePromotions,
   readKnowledge,
   resolveSwarmKnowledgePath,
@@ -29384,9 +29428,9 @@ var _internals38 = {
   loadPluginConfigWithMeta,
   loadCuratorDeps: async () => {
     const [{ CuratorConfigSchema }, curator, { createCuratorLLMDelegate: createCuratorLLMDelegate2 }] = await Promise.all([
-      import("./schema-7jm70cab.js"),
-      import("./curator-36dxw38r.js"),
-      import("./curator-llm-factory-k2a7cv41.js")
+      import("./schema-cr1nr1w0.js"),
+      import("./curator-jc5cc980.js"),
+      import("./curator-llm-factory-atfnhbn6.js")
     ]);
     return { CuratorConfigSchema, curator, createCuratorLLMDelegate: createCuratorLLMDelegate2 };
   }
@@ -29395,20 +29439,20 @@ async function handleCurateCommand(directory, _args, options) {
   try {
     let config;
     try {
-      const { config: loadedConfig } = _internals38.loadPluginConfigWithMeta(directory);
+      const { config: loadedConfig } = _internals39.loadPluginConfigWithMeta(directory);
       config = KnowledgeConfigSchema.parse(loadedConfig.knowledge ?? {});
     } catch {
       config = KnowledgeConfigSchema.parse({});
     }
-    const swarmPath = _internals38.resolveSwarmKnowledgePath(directory);
-    const swarmEntries = await _internals38.readKnowledge(swarmPath) ?? [];
-    const summary = await _internals38.checkHivePromotions(swarmEntries, config, directory);
+    const swarmPath = _internals39.resolveSwarmKnowledgePath(directory);
+    const swarmEntries = await _internals39.readKnowledge(swarmPath) ?? [];
+    const summary = await _internals39.checkHivePromotions(swarmEntries, config, directory);
     if (options?.sessionID) {
       let onDemandPhase = 1;
       try {
-        const { CuratorConfigSchema, curator, createCuratorLLMDelegate: createCuratorLLMDelegate2 } = await _internals38.loadCuratorDeps();
+        const { CuratorConfigSchema, curator, createCuratorLLMDelegate: createCuratorLLMDelegate2 } = await _internals39.loadCuratorDeps();
         const curatorConfig = CuratorConfigSchema.parse({});
-        const priorSummary = await _internals38.readSwarmFileAsync(directory, "curator-summary.json");
+        const priorSummary = await _internals39.readSwarmFileAsync(directory, "curator-summary.json");
         if (priorSummary) {
           try {
             const parsed = JSON.parse(priorSummary);
@@ -29419,7 +29463,7 @@ async function handleCurateCommand(directory, _args, options) {
         }
         let planPhaseCount = Infinity;
         try {
-          const planRaw = await _internals38.readSwarmFileAsync(directory, "plan.json");
+          const planRaw = await _internals39.readSwarmFileAsync(directory, "plan.json");
           if (planRaw) {
             const plan = JSON.parse(planRaw);
             if (Array.isArray(plan.phases))
@@ -29438,8 +29482,8 @@ async function handleCurateCommand(directory, _args, options) {
           summary.knowledge_skipped = applied.skipped;
           summary.curator_phase = onDemandPhase;
           try {
-            const updatedEntries = await _internals38.readKnowledge(swarmPath) ?? [];
-            const postUpdateHive = await _internals38.checkHivePromotions(updatedEntries, config, directory);
+            const updatedEntries = await _internals39.readKnowledge(swarmPath) ?? [];
+            const postUpdateHive = await _internals39.checkHivePromotions(updatedEntries, config, directory);
             summary.new_promotions += postUpdateHive.new_promotions;
             summary.encounters_incremented += postUpdateHive.encounters_incremented;
             summary.advancements += postUpdateHive.advancements;
@@ -29505,7 +29549,7 @@ async function handleDarkMatterCommand(directory, args) {
   }
   let pairs;
   try {
-    pairs = await _internals35.detectDarkMatter(directory, options);
+    pairs = await _internals36.detectDarkMatter(directory, options);
   } catch (err) {
     const errMsg = err instanceof Error ? err.message : String(err);
     return `## Dark Matter Analysis Failed
@@ -29770,7 +29814,7 @@ ${USAGE7}`;
 // src/commands/design-docs.ts
 init_warning_buffer();
 var MAX_DESC_LEN = 2000;
-var _internals39 = { loadPluginConfigWithMeta };
+var _internals40 = { loadPluginConfigWithMeta };
 var USAGE8 = `Usage: /swarm design-docs <description> [--out <dir>] [--lang <name>] [--update]
 
 Generate or sync language-agnostic design docs for the project under build:
@@ -29866,7 +29910,7 @@ async function handleDesignDocsCommand(directory, args) {
 ${USAGE8}`;
   }
   try {
-    const { config } = _internals39.loadPluginConfigWithMeta(directory);
+    const { config } = _internals40.loadPluginConfigWithMeta(directory);
     if (config.design_docs?.enabled !== true) {
       return "Error: design docs are disabled. Set `design_docs.enabled: true` in " + `opencode-swarm.json to enable the docs_design agent and this command.
 
@@ -30227,18 +30271,21 @@ function computeMemoryCohortDiagnostics(directory) {
         const cohortConfigPath = join43(resolveLinkDir(pointer.linkId), "memory", "memory-cohort-config.json");
         if (existsSync28(cohortConfigPath)) {
           const stored = JSON.parse(readFileSync18(cohortConfigPath, "utf-8"));
-          const expected = computeMemoryCohortFingerprint(buildMemoryCohortFingerprintInput({
-            provider: cfg.memory.provider ?? "sqlite",
-            redaction: {
-              rejectDurableSecrets: cfg.memory.redaction?.rejectDurableSecrets ?? true
-            },
-            embeddings: {
-              model: cfg.memory.embeddings?.model ?? "Xenova/all-MiniLM-L6-v2",
-              dimension: cfg.memory.embeddings?.dimension ?? 384,
-              version: cfg.memory.embeddings?.version
-            }
-          }));
-          configFingerprintMatch = stored.fingerprint === expected;
+          const versionCheck = classifyStoredFingerprintAlgorithmVersion(stored.algorithm_version);
+          if (versionCheck.status === "comparable" && typeof stored.fingerprint === "string") {
+            const expected = computeMemoryCohortFingerprint(buildMemoryCohortFingerprintInput({
+              provider: cfg.memory.provider ?? "sqlite",
+              redaction: {
+                rejectDurableSecrets: cfg.memory.redaction?.rejectDurableSecrets ?? true
+              },
+              embeddings: {
+                model: cfg.memory.embeddings?.model ?? "Xenova/all-MiniLM-L6-v2",
+                dimension: cfg.memory.embeddings?.dimension ?? 384,
+                version: cfg.memory.embeddings?.version
+              }
+            }));
+            configFingerprintMatch = stored.fingerprint === expected;
+          }
         }
       }
     } catch {}
@@ -30288,7 +30335,7 @@ async function computeCurationDiagnostics(directory, entries) {
   let scanCompleted = false;
   let scanRemaining = 0;
   try {
-    const { getScanStatus } = await import("./scan-cursor-xbkae12h.js");
+    const { getScanStatus } = await import("./scan-cursor-yzj9n225.js");
     const status = await getScanStatus(directory);
     scanGeneration = status.generation;
     scanCompleted = status.completed;
@@ -30298,17 +30345,17 @@ async function computeCurationDiagnostics(directory, entries) {
   try {
     const { isLinked: isLinked2 } = await import("./knowledge-link-zr40rnwr.js");
     if (isLinked2(directory)) {
-      const { KnowledgeConfigSchema: KnowledgeConfigSchema2 } = await import("./schema-7jm70cab.js");
+      const { KnowledgeConfigSchema: KnowledgeConfigSchema2 } = await import("./schema-cr1nr1w0.js");
       let config;
       try {
-        const { loadPluginConfigWithMeta: loadPluginConfigWithMeta2 } = await import("./index-rtgqy0yg.js");
+        const { loadPluginConfigWithMeta: loadPluginConfigWithMeta2 } = await import("./index-bqan4y2y.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-zhyttjpa.js");
+      const { buildConfigFingerprintInput: buildConfigFingerprintInput2, readCohortConfigFingerprint } = await import("./curation-policy-c4g08bg1.js");
       const currentFp = cohortConfigFingerprint2(buildConfigFingerprintInput2(config));
       const cohortFp = await readCohortConfigFingerprint(directory);
       configMatch = cohortFp === null ? null : currentFp === cohortFp;
@@ -30470,7 +30517,7 @@ function resolveCachePackageRoot(cachePath) {
   const nestedPackageRoot = path52.join(cachePath, "node_modules", "opencode-swarm");
   return existsSync29(nestedPackageRoot) ? nestedPackageRoot : cachePath;
 }
-var _internals40 = {
+var _internals41 = {
   detectSandboxCapability: () => sandboxCapabilityProbe.detect(),
   getSandboxExecutor: getExecutor
 };
@@ -31054,9 +31101,9 @@ async function checkCurator(directory) {
 }
 async function getSandboxStatus() {
   try {
-    const capability = await _internals40.detectSandboxCapability();
+    const capability = await _internals41.detectSandboxCapability();
     const mechanism = capability.mechanism ?? "none";
-    const executor = await _internals40.getSandboxExecutor();
+    const executor = await _internals41.getSandboxExecutor();
     const hasExecutor = executor !== null;
     if (hasExecutor) {
       const executorStrength = executor?.strength;
@@ -31519,7 +31566,7 @@ async function handleDoctorCommand(directory, args) {
   const result = runConfigDoctor(config, directory);
   let output;
   if (enableAutoFix && result.hasAutoFixableIssues) {
-    const { runConfigDoctorWithFixes } = await import("./config-doctor-g71mz50j.js");
+    const { runConfigDoctorWithFixes } = await import("./config-doctor-n3hatm9d.js");
     const fixResult = await runConfigDoctorWithFixes(directory, config, true, {
       applyLossy: true
     });
@@ -31864,7 +31911,7 @@ function readPromotionEvidence(directory) {
 }
 
 // src/commands/epic.ts
-var _internals41 = {
+var _internals42 = {
   loadPluginConfigWithMeta,
   loadPlanJsonOnly,
   getCoChangeData,
@@ -31886,7 +31933,7 @@ async function handleEpicCommand(directory, args, sessionID) {
   if (!sessionID || sessionID.trim() === "") {
     return "Error: No active session context. Epic Mode requires an active session. Use /swarm epic from within an OpenCode session.";
   }
-  const session = _internals41.ensureAgentSession(sessionID, undefined, directory);
+  const session = _internals42.ensureAgentSession(sessionID, undefined, directory);
   const arg0 = args[0]?.toLowerCase();
   switch (arg0) {
     case "status":
@@ -31913,7 +31960,7 @@ Usage:
 }
 function enableAndAck(directory, sessionID, session) {
   try {
-    _internals41.enableEpicMode(directory, sessionID);
+    _internals42.enableEpicMode(directory, sessionID);
   } catch (err) {
     return `Error enabling Epic Mode: ${err instanceof Error ? err.message : String(err)}`;
   }
@@ -31929,7 +31976,7 @@ function enableAndAck(directory, sessionID, session) {
 }
 function disableAndAck(directory, sessionID, session) {
   try {
-    _internals41.disableEpicMode(directory, sessionID);
+    _internals42.disableEpicMode(directory, sessionID);
   } catch (err) {
     return `Error disabling Epic Mode: ${err instanceof Error ? err.message : String(err)}`;
   }
@@ -31938,12 +31985,12 @@ function disableAndAck(directory, sessionID, session) {
 }
 function renderStatus(directory, sessionID) {
   const lines = ["## Epic Mode \u2014 Status", ""];
-  if (_internals41.isStateUnreadable(directory)) {
+  if (_internals42.isStateUnreadable(directory)) {
     lines.push("**Epic Mode state is unreadable** (`.swarm/epic-state.json` is corrupt or has an unexpected shape). Status cannot be reported until the file is repaired or removed. The fail-closed marker means `epic_decide_phase` will refuse to compute a verdict in this state.");
     return lines.join(`
 `);
   }
-  const state = _internals41.loadEpicSessionState(directory, sessionID);
+  const state = _internals42.loadEpicSessionState(directory, sessionID);
   if (!state) {
     lines.push("Epic Mode has not been toggled for this session.");
     return lines.join(`
@@ -31995,7 +32042,7 @@ function formatGreenfieldDetail(input) {
 function renderLast(directory) {
   let records;
   try {
-    records = _internals41.readPromotionEvidence(directory);
+    records = _internals42.readPromotionEvidence(directory);
   } catch (err) {
     return `Error reading epic-promotions.jsonl: ${err instanceof Error ? err.message : String(err)}`;
   }
@@ -32050,7 +32097,7 @@ function renderLast(directory) {
 `);
 }
 function renderCalibration(directory) {
-  if (_internals41.isCalibrationStateUnreadable(directory)) {
+  if (_internals42.isCalibrationStateUnreadable(directory)) {
     return [
       "## Epic Mode \u2014 Calibration",
       "",
@@ -32062,11 +32109,11 @@ function renderCalibration(directory) {
   }
   let state;
   try {
-    state = _internals41.loadCalibrationState(directory);
+    state = _internals42.loadCalibrationState(directory);
   } catch (err) {
     return `Error reading calibration state: ${err instanceof Error ? err.message : String(err)}`;
   }
-  const { config } = _internals41.loadPluginConfigWithMeta(directory);
+  const { config } = _internals42.loadPluginConfigWithMeta(directory);
   const staticThreshold = config.turbo?.epic?.mode?.activation_threshold ?? 0.3;
   const calibrationCfg = config.turbo?.epic?.calibration;
   const loosenWindow = calibrationCfg?.loosen_window ?? 10;
@@ -32114,7 +32161,7 @@ function renderCalibration(directory) {
   lines.push("");
   let recentDivergent = [];
   try {
-    const all = _internals41.readDivergenceHistory(directory, { limit: 50 });
+    const all = _internals42.readDivergenceHistory(directory, { limit: 50 });
     recentDivergent = all.filter((r) => !r.isClean).slice(-5);
   } catch {}
   lines.push("### Recent divergent tasks (tightened the threshold)");
@@ -32131,11 +32178,11 @@ function renderCalibration(directory) {
 `);
 }
 async function renderDecide(directory) {
-  const plan = await _internals41.loadPlanJsonOnly(directory);
+  const plan = await _internals42.loadPlanJsonOnly(directory);
   if (!plan) {
     return "No plan found at `.swarm/plan.json`. Run `/swarm plan` first.";
   }
-  const { config } = _internals41.loadPluginConfigWithMeta(directory);
+  const { config } = _internals42.loadPluginConfigWithMeta(directory);
   const modeCfg = config.turbo?.epic?.mode;
   const cochangeCfg = config.turbo?.epic?.cochange;
   const activationThreshold = modeCfg?.activation_threshold ?? 0.3;
@@ -32145,20 +32192,20 @@ async function renderDecide(directory) {
   const tasks = [];
   for (const phase of plan.phases) {
     for (const task of phase.tasks) {
-      const scopeFiles = _internals41.readTaskScopes(directory, task.id);
+      const scopeFiles = _internals42.readTaskScopes(directory, task.id);
       const scope = scopeFiles ?? task.files_touched ?? [];
       tasks.push({ id: task.id, scope });
     }
   }
-  const { pairs, commitsObserved } = await _internals41.getCoChangeData(directory);
+  const { pairs, commitsObserved } = await _internals42.getCoChangeData(directory);
   const isGitProject = (() => {
     try {
-      return _internals41.isGitRepo(directory);
+      return _internals42.isGitRepo(directory);
     } catch {
       return false;
     }
   })();
-  const verdict = _internals41.decideEpicActivation(tasks, pairs, commitsObserved, {
+  const verdict = _internals42.decideEpicActivation(tasks, pairs, commitsObserved, {
     activationThreshold,
     minCommitsForSignal,
     cochangeNpmiThreshold,
@@ -32202,7 +32249,7 @@ function formatVerdict(verdict) {
 }
 
 // src/services/evidence-service.ts
-var _internals42 = {
+var _internals43 = {
   loadEvidence,
   listEvidenceTaskIds
 };
@@ -32247,7 +32294,7 @@ function getVerdictEmoji(verdict) {
   return getVerdictIcon(verdict);
 }
 async function getTaskEvidenceData(directory, taskId) {
-  const result = await _internals42.loadEvidence(directory, taskId);
+  const result = await _internals43.loadEvidence(directory, taskId);
   if (result.status !== "found") {
     return {
       hasEvidence: false,
@@ -32270,13 +32317,13 @@ async function getTaskEvidenceData(directory, taskId) {
   };
 }
 async function getEvidenceListData(directory) {
-  const taskIds = await _internals42.listEvidenceTaskIds(directory);
+  const taskIds = await _internals43.listEvidenceTaskIds(directory);
   if (taskIds.length === 0) {
     return { hasEvidence: false, tasks: [] };
   }
   const tasks = [];
   for (const taskId of taskIds) {
-    const result = await _internals42.loadEvidence(directory, taskId);
+    const result = await _internals43.loadEvidence(directory, taskId);
     if (result.status === "found") {
       tasks.push({
         taskId,
@@ -33016,7 +33063,7 @@ function isStaticallyEquivalent(originalCode, mutatedCode) {
   const strippedMutated = stripCode(mutatedCode);
   return strippedOriginal === strippedMutated;
 }
-var _internals43 = {
+var _internals44 = {
   isStaticallyEquivalent,
   checkEquivalence,
   batchCheckEquivalence
@@ -33056,7 +33103,7 @@ async function batchCheckEquivalence(patches, llmJudge) {
   const results = [];
   for (const { patch, originalCode, mutatedCode } of patches) {
     try {
-      const result = await _internals43.checkEquivalence(patch, originalCode, mutatedCode, llmJudge);
+      const result = await _internals44.checkEquivalence(patch, originalCode, mutatedCode, llmJudge);
       results.push(result);
     } catch (err) {
       results.push({
@@ -33130,10 +33177,10 @@ function isMissingExecutableFailure(message) {
   return /\bENOENT\b/i.test(message) || /\bexecutable\b[^\r\n]*\bnot found\b/i.test(message) || /\bnot found in (?:the )?\$?PATH\b/i.test(message);
 }
 var runMutationCommand = async (args) => {
-  const resolvedExecutable = _internals44.resolveExecutableFromPath([
+  const resolvedExecutable = _internals45.resolveExecutableFromPath([
     args.executable
   ]);
-  const result = await _internals44.runExternalTool({
+  const result = await _internals45.runExternalTool({
     executable: resolvedExecutable ?? args.executable,
     args: args.args,
     cwd: args.cwd,
@@ -33152,7 +33199,7 @@ var runMutationCommand = async (args) => {
 };
 var runLegacyTestSeam = async (args) => {
   try {
-    const result = _internals44.spawnSync(args.executable, args.args, {
+    const result = _internals45.spawnSync(args.executable, args.args, {
       cwd: args.cwd,
       timeout: args.timeoutMs,
       stdio: "pipe"
@@ -33186,11 +33233,11 @@ var runLegacyTestSeam = async (args) => {
 function selectRunner(options) {
   if (options.runner)
     return options.runner;
-  if (_internals44.spawnSync !== defaultLegacySpawnSync)
+  if (_internals45.spawnSync !== defaultLegacySpawnSync)
     return runLegacyTestSeam;
-  return _internals44.runCommand;
+  return _internals45.runCommand;
 }
-var _internals44 = {
+var _internals45 = {
   executeMutation,
   computeReport,
   executeMutationSuite,
@@ -34434,11 +34481,11 @@ var quality_budget = createSwarmTool({
     }).optional().describe("Quality budget thresholds")
   },
   async execute(args, directory) {
-    const result = await _internals45.qualityBudget(args, directory);
+    const result = await _internals46.qualityBudget(args, directory);
     return JSON.stringify(result);
   }
 });
-var _internals45 = {
+var _internals46 = {
   qualityBudget
 };
 
@@ -35307,7 +35354,7 @@ var DEFAULT_RULES_DIR = ".swarm/semgrep-rules";
 var DEFAULT_TIMEOUT_MS2 = 30000;
 var MAX_OUTPUT_BYTES = 10 * 1024 * 1024;
 var KILL_GRACE_MS = 2000;
-var _internals46 = {
+var _internals47 = {
   isSemgrepAvailable,
   checkSemgrepAvailable,
   resetSemgrepCache,
@@ -35333,7 +35380,7 @@ function isSemgrepAvailable() {
   }
 }
 async function checkSemgrepAvailable() {
-  return _internals46.isSemgrepAvailable();
+  return _internals47.isSemgrepAvailable();
 }
 function resetSemgrepCache() {
   semgrepAvailableCache = null;
@@ -35520,12 +35567,12 @@ async function runSemgrep(options) {
   const timeoutMs = options.timeoutMs || DEFAULT_TIMEOUT_MS2;
   if (files.length === 0) {
     return {
-      available: _internals46.isSemgrepAvailable(),
+      available: _internals47.isSemgrepAvailable(),
       findings: [],
       engine: "tier_a"
     };
   }
-  if (!_internals46.isSemgrepAvailable()) {
+  if (!_internals47.isSemgrepAvailable()) {
     return {
       available: false,
       findings: [],
@@ -35687,7 +35734,7 @@ function assignOccurrenceIndices(findings, directory) {
     }
     const occIdx = countMap.get(baseKey) ?? 0;
     countMap.set(baseKey, occIdx + 1);
-    const fp = _internals47.fingerprintFinding(finding, directory, occIdx);
+    const fp = _internals48.fingerprintFinding(finding, directory, occIdx);
     return {
       finding,
       index: occIdx,
@@ -35756,7 +35803,7 @@ async function captureOrMergeBaseline(directory, phase, findings, engine, scanne
       }
     } catch {}
     const scannedRelFiles = new Set(scannedFiles.map((f) => normalizeFindingPath(directory, f)));
-    const indexed = _internals47.assignOccurrenceIndices(findings, directory);
+    const indexed = _internals48.assignOccurrenceIndices(findings, directory);
     if (existing && !opts?.force) {
       const prunedFingerprints = existing.fingerprints.filter((fp) => {
         const relFile = fp.slice(0, fp.indexOf("|"));
@@ -35896,7 +35943,7 @@ function loadBaseline(directory, phase) {
     };
   }
 }
-var _internals47 = {
+var _internals48 = {
   fingerprintFinding,
   assignOccurrenceIndices,
   captureOrMergeBaseline,
@@ -36010,7 +36057,7 @@ async function sastScan(input, directory, config) {
   let filesScanned = 0;
   let _filesSkipped = 0;
   const scannedFilePaths = [];
-  const semgrepAvailable = !offline_only && _internals48.isSemgrepAvailable();
+  const semgrepAvailable = !offline_only && _internals49.isSemgrepAvailable();
   const engine = semgrepAvailable ? "tier_a+tier_b" : "tier_a";
   const filesByLanguage = new Map;
   for (const filePath of changed_files) {
@@ -36073,13 +36120,13 @@ async function sastScan(input, directory, config) {
         let semgrepResult;
         if (bucketKey.startsWith("auto:")) {
           const lang = bucketKey.slice("auto:".length);
-          semgrepResult = await _internals48.runSemgrep({
+          semgrepResult = await _internals49.runSemgrep({
             files: bucketFiles,
             lang,
             useAutoConfig: true
           });
         } else {
-          semgrepResult = await _internals48.runSemgrep({
+          semgrepResult = await _internals49.runSemgrep({
             files: bucketFiles
           });
         }
@@ -36321,11 +36368,11 @@ var sast_scan = createSwarmTool({
       capture_baseline: safeArgs.capture_baseline,
       phase: safeArgs.phase
     };
-    const result = await _internals48.sastScan(input, directory);
+    const result = await _internals49.sastScan(input, directory);
     return JSON.stringify(result, null, 2);
   }
 });
-var _internals48 = {
+var _internals49 = {
   sastScan,
   sast_scan,
   isSemgrepAvailable: () => isSemgrepAvailable(),
@@ -37155,7 +37202,7 @@ function extractCurrentPhaseFromPlan2(plan) {
   if (!plan) {
     return { currentPhase: null, currentTask: null, incompleteTasks: [] };
   }
-  if (!_internals49.validatePlanPhases(plan)) {
+  if (!_internals50.validatePlanPhases(plan)) {
     return { currentPhase: null, currentTask: null, incompleteTasks: [] };
   }
   let currentPhase = null;
@@ -37297,9 +37344,9 @@ function extractPhaseMetrics(content) {
 async function getHandoffData(directory) {
   const now = new Date().toISOString();
   const sessionContent = await readSwarmFileAsync(directory, "session/state.json");
-  const sessionState = _internals49.parseSessionState(sessionContent);
+  const sessionState = _internals50.parseSessionState(sessionContent);
   const plan = await loadPlanJsonOnly(directory);
-  const planInfo = _internals49.extractCurrentPhaseFromPlan(plan);
+  const planInfo = _internals50.extractCurrentPhaseFromPlan(plan);
   if (!plan) {
     const planMdContent = await readSwarmFileAsync(directory, "plan.md");
     if (planMdContent) {
@@ -37318,8 +37365,8 @@ async function getHandoffData(directory) {
     }
   }
   const contextContent = await readSwarmFileAsync(directory, "context.md");
-  const recentDecisions = _internals49.extractDecisions(contextContent);
-  const rawPhaseMetrics = _internals49.extractPhaseMetrics(contextContent);
+  const recentDecisions = _internals50.extractDecisions(contextContent);
+  const rawPhaseMetrics = _internals50.extractPhaseMetrics(contextContent);
   const phaseMetrics = sanitizeString(rawPhaseMetrics, 1000);
   let delegationState = null;
   if (sessionState?.delegationState) {
@@ -37483,7 +37530,7 @@ ${lines.join(`
 `)}
 \`\`\``;
 }
-var _internals49 = {
+var _internals50 = {
   getHandoffData,
   formatHandoffMarkdown,
   formatContinuationPrompt,
@@ -37650,15 +37697,15 @@ async function writeSnapshot(directory, state) {
 }
 function createSnapshotWriterHook(directory) {
   return (_input, _output) => {
-    _writeInFlight = _writeInFlight.then(() => _internals50.writeSnapshot(directory, swarmState), () => _internals50.writeSnapshot(directory, swarmState));
+    _writeInFlight = _writeInFlight.then(() => _internals51.writeSnapshot(directory, swarmState), () => _internals51.writeSnapshot(directory, swarmState));
     return _writeInFlight;
   };
 }
 async function flushPendingSnapshot(directory) {
-  _writeInFlight = _writeInFlight.then(() => _internals50.writeSnapshot(directory, swarmState), () => _internals50.writeSnapshot(directory, swarmState));
+  _writeInFlight = _writeInFlight.then(() => _internals51.writeSnapshot(directory, swarmState), () => _internals51.writeSnapshot(directory, swarmState));
   await _writeInFlight;
 }
-var _internals50 = {
+var _internals51 = {
   writeSnapshot,
   createSnapshotWriterHook,
   flushPendingSnapshot
@@ -37943,7 +37990,7 @@ function parseIssueRef(input, directory) {
   }
   return null;
 }
-var _internals51 = {
+var _internals52 = {
   writeFileSync: fs28.writeFileSync,
   mkdirSync: fs28.mkdirSync,
   renameSync: fs28.renameSync,
@@ -37954,18 +38001,18 @@ var _internals51 = {
 function atomicWriteFileSync(dir, filename, content) {
   const tmpPath = path66.join(dir, `.tmp-${filename}-${Date.now()}-${process.pid}`);
   const finalPath = path66.join(dir, filename);
-  _internals51.writeFileSync(tmpPath, content, "utf-8");
+  _internals52.writeFileSync(tmpPath, content, "utf-8");
   try {
-    _internals51.renameSync(tmpPath, finalPath);
+    _internals52.renameSync(tmpPath, finalPath);
   } catch {
     try {
-      _internals51.unlinkSync(finalPath);
+      _internals52.unlinkSync(finalPath);
     } catch {}
     try {
-      _internals51.renameSync(tmpPath, finalPath);
+      _internals52.renameSync(tmpPath, finalPath);
     } catch (retryErr) {
       try {
-        _internals51.unlinkSync(tmpPath);
+        _internals52.unlinkSync(tmpPath);
       } catch {}
       throw retryErr;
     }
@@ -38018,10 +38065,10 @@ ${USAGE9}`;
   };
   let oldTraceState = null;
   try {
-    oldTraceState = _internals51.readFileSync(path66.join(swarmDir, "issue-trace-state.json"), "utf-8");
+    oldTraceState = _internals52.readFileSync(path66.join(swarmDir, "issue-trace-state.json"), "utf-8");
   } catch {}
   try {
-    _internals51.mkdirSync(swarmDir, { recursive: true });
+    _internals52.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) {
@@ -38031,11 +38078,11 @@ ${USAGE9}`;
       } catch {}
     } else {
       try {
-        _internals51.unlinkSync(path66.join(swarmDir, "issue-trace-state.json"));
+        _internals52.unlinkSync(path66.join(swarmDir, "issue-trace-state.json"));
       } catch {}
     }
     try {
-      _internals51.unlinkSync(path66.join(swarmDir, "issue-reference.json"));
+      _internals52.unlinkSync(path66.join(swarmDir, "issue-reference.json"));
     } catch {}
     const errMsg = e instanceof Error ? e.message : String(e);
     return `Error: Failed to persist issue reference durably: ${errMsg}
@@ -38068,7 +38115,7 @@ init_knowledge_types();
 async function migrateKnowledgeToExternal(_directory, _config) {
   const externalSentinelPath = path67.join(_directory, ".swarm", ".knowledge-external-migrated");
   const contextPath = path67.join(_directory, ".swarm", "context.md");
-  if (_internals52.existsSync(externalSentinelPath)) {
+  if (_internals53.existsSync(externalSentinelPath)) {
     return {
       migrated: false,
       entriesMigrated: 0,
@@ -38077,7 +38124,7 @@ async function migrateKnowledgeToExternal(_directory, _config) {
       skippedReason: "external-sentinel-exists"
     };
   }
-  if (!_internals52.existsSync(contextPath)) {
+  if (!_internals53.existsSync(contextPath)) {
     return {
       migrated: false,
       entriesMigrated: 0,
@@ -38086,7 +38133,7 @@ async function migrateKnowledgeToExternal(_directory, _config) {
       skippedReason: "no-context-file"
     };
   }
-  const contextContent = await _internals52.readFile(contextPath, "utf-8");
+  const contextContent = await _internals53.readFile(contextPath, "utf-8");
   if (contextContent.trim().length === 0) {
     return {
       migrated: false,
@@ -38104,7 +38151,7 @@ async function migrateKnowledgeToExternal(_directory, _config) {
       entriesCount++;
     }
   }
-  await _internals52.writeSentinel(externalSentinelPath, entriesCount, entriesCount);
+  await _internals53.writeSentinel(externalSentinelPath, entriesCount, entriesCount);
   return {
     migrated: true,
     entriesMigrated: entriesCount,
@@ -38112,7 +38159,7 @@ async function migrateKnowledgeToExternal(_directory, _config) {
     entriesTotal: entriesCount
   };
 }
-var _internals52 = {
+var _internals53 = {
   appendKnowledge,
   migrateContextToKnowledge,
   migrateKnowledgeToExternal,
@@ -38163,9 +38210,9 @@ async function migrateContextToKnowledge(directory, config) {
       skippedReason: "empty-context"
     };
   }
-  const rawEntries = _internals52.parseContextMd(contextContent);
+  const rawEntries = _internals53.parseContextMd(contextContent);
   if (rawEntries.length === 0) {
-    await _internals52.writeSentinel(sentinelPath, 0, 0);
+    await _internals53.writeSentinel(sentinelPath, 0, 0);
     return {
       migrated: true,
       entriesMigrated: 0,
@@ -38176,10 +38223,10 @@ async function migrateContextToKnowledge(directory, config) {
   const existing = await readKnowledge(knowledgePath);
   let migrated = 0;
   let dropped = 0;
-  const projectName = _internals52.inferProjectName(directory);
+  const projectName = _internals53.inferProjectName(directory);
   for (const raw of rawEntries) {
     if (config.validation_enabled !== false) {
-      const category = raw.categoryHint ?? _internals52.inferCategoryFromText(raw.text);
+      const category = raw.categoryHint ?? _internals53.inferCategoryFromText(raw.text);
       const result = validateLesson(raw.text, existing.map((e) => e.lesson), {
         category,
         scope: "global",
@@ -38199,8 +38246,8 @@ async function migrateContextToKnowledge(directory, config) {
     const entry = {
       id: randomUUID8(),
       tier: "swarm",
-      lesson: _internals52.truncateLesson(raw.text),
-      category: raw.categoryHint ?? _internals52.inferCategoryFromText(raw.text),
+      lesson: _internals53.truncateLesson(raw.text),
+      category: raw.categoryHint ?? _internals53.inferCategoryFromText(raw.text),
       tags: [...inferredTags, `migration:${raw.sourceSection}`],
       scope: "global",
       confidence: 0.3,
@@ -38223,7 +38270,7 @@ async function migrateContextToKnowledge(directory, config) {
   if (migrated > 0) {
     await rewriteKnowledge(knowledgePath, existing);
   }
-  await _internals52.writeSentinel(sentinelPath, migrated, dropped);
+  await _internals53.writeSentinel(sentinelPath, migrated, dropped);
   log(`[knowledge-migrator] Migrated ${migrated} entries, dropped ${dropped}`);
   return {
     migrated: true,
@@ -38233,7 +38280,7 @@ async function migrateContextToKnowledge(directory, config) {
   };
 }
 async function migrateHiveKnowledgeLegacy(config) {
-  const legacyHivePath = _internals52.resolveLegacyHiveKnowledgePath();
+  const legacyHivePath = _internals53.resolveLegacyHiveKnowledgePath();
   const canonicalHivePath = resolveHiveKnowledgePath2();
   const sentinelPath = path67.join(path67.dirname(canonicalHivePath), ".hive-knowledge-migrated");
   if (existsSync38(sentinelPath)) {
@@ -38256,7 +38303,7 @@ async function migrateHiveKnowledgeLegacy(config) {
   }
   const legacyEntries = await readKnowledge(legacyHivePath);
   if (legacyEntries.length === 0) {
-    await _internals52.writeSentinel(sentinelPath, 0, 0);
+    await _internals53.writeSentinel(sentinelPath, 0, 0);
     return {
       migrated: true,
       entriesMigrated: 0,
@@ -38304,7 +38351,7 @@ async function migrateHiveKnowledgeLegacy(config) {
       const newHiveEntry = {
         id: resolvedId,
         tier: "hive",
-        lesson: _internals52.truncateLesson(lesson),
+        lesson: _internals53.truncateLesson(lesson),
         category,
         tags: ["migration:legacy-hive"],
         scope: scopeTag,
@@ -38323,7 +38370,7 @@ async function migrateHiveKnowledgeLegacy(config) {
         encounter_score: 1
       };
       try {
-        await _internals52.appendKnowledge(canonicalHivePath, newHiveEntry);
+        await _internals53.appendKnowledge(canonicalHivePath, newHiveEntry);
         existingHiveEntries.push(newHiveEntry);
         migrated++;
       } catch (appendError) {
@@ -38339,7 +38386,7 @@ async function migrateHiveKnowledgeLegacy(config) {
       dropped++;
     }
   }
-  await _internals52.writeSentinel(sentinelPath, migrated, dropped);
+  await _internals53.writeSentinel(sentinelPath, migrated, dropped);
   log(`[knowledge-migrator] Migrated ${migrated} legacy hive entries, dropped ${dropped}`);
   return {
     migrated: true,
@@ -38350,7 +38397,7 @@ async function migrateHiveKnowledgeLegacy(config) {
   };
 }
 function parseContextMd(content) {
-  const sections = _internals52.splitIntoSections(content);
+  const sections = _internals53.splitIntoSections(content);
   const entries = [];
   const seen = new Set;
   const sectionPatterns = [
@@ -38366,7 +38413,7 @@ function parseContextMd(content) {
     const match = sectionPatterns.find((sp) => sp.pattern.test(section.heading));
     if (!match)
       continue;
-    const bullets = _internals52.extractBullets(section.body);
+    const bullets = _internals53.extractBullets(section.body);
     for (const bullet of bullets) {
       if (bullet.length < 15)
         continue;
@@ -38375,9 +38422,9 @@ function parseContextMd(content) {
         continue;
       seen.add(normalized);
       entries.push({
-        text: _internals52.truncateLesson(bullet),
+        text: _internals53.truncateLesson(bullet),
         sourceSection: match.sourceSection,
-        categoryHint: _internals52.inferCategoryFromText(bullet)
+        categoryHint: _internals53.inferCategoryFromText(bullet)
       });
     }
   }
@@ -38467,8 +38514,8 @@ async function writeSentinel(sentinelPath, migrated, dropped) {
     schema_version: 1,
     migration_tool: "knowledge-migrator.ts"
   };
-  await _internals52.mkdir(path67.dirname(sentinelPath), { recursive: true });
-  await _internals52.writeFile(sentinelPath, JSON.stringify(sentinel, null, 2), "utf-8");
+  await _internals53.mkdir(path67.dirname(sentinelPath), { recursive: true });
+  await _internals53.writeFile(sentinelPath, JSON.stringify(sentinel, null, 2), "utf-8");
 }
 function resolveLegacyHiveKnowledgePath() {
   const platform = process.platform;
@@ -38880,7 +38927,7 @@ function timeoutMessage(timeoutMs) {
 async function computeWithTimeout(directory, currentPhase, timeoutMs) {
   const controller = new AbortController;
   let timeout;
-  const metricsPromise = _internals53.computeLearningMetrics(directory, {
+  const metricsPromise = _internals54.computeLearningMetrics(directory, {
     currentPhase,
     signal: controller.signal
   });
@@ -38937,7 +38984,7 @@ ${JSON.stringify({
     return `Error computing learning metrics: ${message}. Run /swarm diagnose to check .swarm/ health.`;
   }
 }
-var _internals53 = {
+var _internals54 = {
   computeLearningMetrics
 };
 
@@ -39458,7 +39505,7 @@ async function readLatestLoopState(directory) {
     return null;
   }
 }
-var _internals54 = {
+var _internals55 = {
   readLatestLoopState
 };
 var USAGE10 = `Usage: /swarm loop <objective> [--max-cycles 1..5] [--autonomy checkpoint|auto] [--depth standard|exhaustive] [--resume]
@@ -39571,7 +39618,7 @@ ${USAGE10}`;
   }
   let autonomy = parsed.autonomy;
   if (parsed.resume && !parsed.autonomyExplicit) {
-    const state = await _internals54.readLatestLoopState(_directory);
+    const state = await _internals55.readLatestLoopState(_directory);
     if (state?.autonomy && AUTONOMY_LEVELS.has(state.autonomy)) {
       autonomy = state.autonomy;
     }
@@ -41053,6 +41100,7 @@ ${formatStatus2(directory)}`;
     const fingerprint = computeMemoryCohortFingerprint(fingerprintInput);
     await writeFile15(path74.join(cohortRoot.cohortRoot, "memory-cohort-config.json"), JSON.stringify({
       fingerprint,
+      algorithm_version: FINGERPRINT_ALGORITHM_VERSION,
       config: fingerprintInput,
       updated_at: new Date().toISOString()
     }, null, 2), "utf-8");
@@ -41124,15 +41172,15 @@ async function handleMemoryUnlinkCommand(directory, args) {
 }
 
 // src/services/plan-service.ts
-var _internals55 = {
+var _internals56 = {
   loadPlanJsonOnly,
   derivePlanMarkdown,
   readSwarmFileAsync
 };
 async function getPlanData(directory, phaseArg) {
-  const plan = await _internals55.loadPlanJsonOnly(directory);
+  const plan = await _internals56.loadPlanJsonOnly(directory);
   if (plan) {
-    const fullMarkdown = _internals55.derivePlanMarkdown(plan);
+    const fullMarkdown = _internals56.derivePlanMarkdown(plan);
     if (phaseArg === undefined || phaseArg === null || phaseArg === "") {
       return {
         hasPlan: true,
@@ -41175,7 +41223,7 @@ async function getPlanData(directory, phaseArg) {
       isLegacy: false
     };
   }
-  const planContent = await _internals55.readSwarmFileAsync(directory, "plan.md");
+  const planContent = await _internals56.readSwarmFileAsync(directory, "plan.md");
   if (!planContent) {
     return {
       hasPlan: false,
@@ -41272,7 +41320,7 @@ async function handlePlanCommand(directory, args) {
   return formatPlanMarkdown(planData);
 }
 // src/commands/post-mortem.ts
-var _internals56 = {
+var _internals57 = {
   createCuratorLLMDelegate,
   runCuratorPostMortem
 };
@@ -41320,10 +41368,10 @@ async function handlePostMortemCommand(directory, args, options) {
     };
     if (options?.sessionID) {
       try {
-        pmOptions.llmDelegate = _internals56.createCuratorLLMDelegate(directory, "postmortem", options.sessionID);
+        pmOptions.llmDelegate = _internals57.createCuratorLLMDelegate(directory, "postmortem", options.sessionID);
       } catch {}
     }
-    const result = await _internals56.runCuratorPostMortem(directory, pmOptions);
+    const result = await _internals57.runCuratorPostMortem(directory, pmOptions);
     const lines = [];
     if (result.success) {
       lines.push("## Post-Mortem Report Generated");
@@ -41581,7 +41629,7 @@ function formatMergeGroupStatus(status, conclusion, htmlUrl) {
   }
   return parts.join(" ");
 }
-var _internals57 = {
+var _internals58 = {
   formatRelativeTime,
   formatMergeGroupStatus,
   listActive,
@@ -41589,7 +41637,7 @@ var _internals57 = {
   parseMergeGroupRuns
 };
 async function handlePrMonitorStatusCommand(directory, _args, sessionID, source) {
-  const allActive = await _internals57.listActive(directory);
+  const allActive = await _internals58.listActive(directory);
   const allSessions = source === "cli";
   const subs = allSessions ? allActive : allActive.filter((record) => record.sessionID === sessionID);
   if (subs.length === 0) {
@@ -41605,7 +41653,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 _internals57.listMergeGroupRuns(directory, sub.repoFullName, sub.prNumber);
+    const mergeGroupRuns = await _internals58.listMergeGroupRuns(directory, sub.repoFullName, sub.prNumber);
     if (mergeGroupRuns.runs.length > 0) {
       lines.push("     Merge-group runs:");
       for (const run of mergeGroupRuns.runs) {
@@ -41746,7 +41794,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 = _internals58.loadPluginConfig(directory);
+    const config = _internals59.loadPluginConfig(directory);
     const prMonitorConfig = config.pr_monitor;
     if (!prMonitorConfig?.enabled) {
       return [
@@ -41756,7 +41804,7 @@ async function handlePrSubscribeCommand(directory, args, sessionID) {
       ].join(`
 `);
     }
-    await _internals58.subscribe(directory, {
+    await _internals59.subscribe(directory, {
       sessionID,
       prNumber: prInfo.number,
       repoFullName,
@@ -41784,7 +41832,7 @@ async function handlePrSubscribeCommand(directory, args, sessionID) {
 `);
   }
 }
-var _internals58 = {
+var _internals59 = {
   loadPluginConfig,
   subscribe
 };
@@ -41807,9 +41855,9 @@ async function handlePrUnsubscribeCommand(directory, args, sessionID) {
 `);
   }
   const refToken = rest[0];
-  const prInfo = _internals59.parsePrRef(refToken, directory);
+  const prInfo = _internals60.parsePrRef(refToken, directory);
   if (!prInfo) {
-    if (_internals59.looksLikePrRef(refToken)) {
+    if (_internals60.looksLikePrRef(refToken)) {
       return [
         `Error: Could not resolve PR reference from "${refToken}".`,
         "",
@@ -41830,8 +41878,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 = _internals59.buildCorrelationId(sessionID, repoFullName, prInfo.number);
-    const result = await _internals59.unsubscribe(directory, correlationId);
+    const correlationId = _internals60.buildCorrelationId(sessionID, repoFullName, prInfo.number);
+    const result = await _internals60.unsubscribe(directory, correlationId);
     if (!result) {
       return [
         `Not subscribed to ${prUrl}`,
@@ -41858,7 +41906,7 @@ async function handlePrUnsubscribeCommand(directory, args, sessionID) {
 `);
   }
 }
-var _internals59 = {
+var _internals60 = {
   unsubscribe,
   buildCorrelationId,
   parsePrRef,
@@ -42298,15 +42346,15 @@ var lint = createSwarmTool({
     }
     const { mode } = args;
     const cwd = directory;
-    const linter = await _internals60.detectAvailableLinter(directory);
+    const linter = await _internals61.detectAvailableLinter(directory);
     if (linter) {
-      const result = await _internals60.runLint(linter, mode, directory);
+      const result = await _internals61.runLint(linter, mode, directory);
       return JSON.stringify(result, null, 2);
     }
-    const additionalLinter = _internals60.detectAdditionalLinter(cwd);
+    const additionalLinter = _internals61.detectAdditionalLinter(cwd);
     if (additionalLinter) {
       warn(`[lint] Using ${additionalLinter} linter for this project`);
-      const result = await _internals60.runAdditionalLint(additionalLinter, mode, cwd);
+      const result = await _internals61.runAdditionalLint(additionalLinter, mode, cwd);
       return JSON.stringify(result, null, 2);
     }
     const errorResult = {
@@ -42320,7 +42368,7 @@ For Rust: rustup component add clippy`
     return JSON.stringify(errorResult, null, 2);
   }
 });
-var _internals60 = {
+var _internals61 = {
   detectAvailableLinter,
   runLint,
   detectAdditionalLinter,
@@ -43009,7 +43057,7 @@ var secretscan = createSwarmTool({
 });
 async function runSecretscan(directory) {
   try {
-    const result = await _internals61.secretscan.execute({ directory }, {});
+    const result = await _internals62.secretscan.execute({ directory }, {});
     const jsonStr = typeof result === "string" ? result : result.output;
     return JSON.parse(jsonStr);
   } catch (e) {
@@ -43081,7 +43129,7 @@ async function runSecretscanOnFiles(files, directory) {
     };
   }
 }
-var _internals61 = {
+var _internals62 = {
   secretscan,
   runSecretscan,
   runSecretscanOnFiles,
@@ -43357,7 +43405,7 @@ async function buildImpactMapInternal(cwd) {
   }
   return impactMap;
 }
-var _internals62 = {
+var _internals63 = {
   validateProjectRoot,
   normalizePath: normalizePath2,
   isCacheStale,
@@ -43372,8 +43420,8 @@ var _internals62 = {
   _clearGoModuleCache
 };
 async function buildImpactMap(cwd) {
-  const impactMap = await _internals62.buildImpactMapInternal(cwd);
-  await _internals62.saveImpactMap(cwd, impactMap);
+  const impactMap = await _internals63.buildImpactMapInternal(cwd);
+  await _internals63.saveImpactMap(cwd, impactMap);
   return impactMap;
 }
 async function loadImpactMap(cwd, options) {
@@ -43387,7 +43435,7 @@ async function loadImpactMap(cwd, options) {
         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 (!_internals62.isCacheStale(map, generatedAt)) {
+          if (!_internals63.isCacheStale(map, generatedAt)) {
             return map;
           }
           if (options?.skipRebuild) {
@@ -43407,13 +43455,13 @@ async function loadImpactMap(cwd, options) {
   if (options?.skipRebuild) {
     return {};
   }
-  return _internals62.buildImpactMap(cwd);
+  return _internals63.buildImpactMap(cwd);
 }
 async function saveImpactMap(cwd, impactMap) {
   if (!path77.isAbsolute(cwd)) {
     throw new Error(`saveImpactMap requires an absolute project root path, got: "${cwd}"`);
   }
-  _internals62.validateProjectRoot(cwd);
+  _internals63.validateProjectRoot(cwd);
   const cacheDir2 = path77.join(cwd, ".swarm", "cache");
   const cachePath = path77.join(cacheDir2, "impact-map.json");
   if (!fs32.existsSync(cacheDir2)) {
@@ -43437,7 +43485,7 @@ async function analyzeImpact(changedFiles, cwd, budget) {
     };
   }
   const validFiles = changedFiles.filter((f) => typeof f === "string" && f.length > 0 && !f.includes("\x00"));
-  const impactMap = await _internals62.loadImpactMap(cwd);
+  const impactMap = await _internals63.loadImpactMap(cwd);
   const impactedTestsSet = new Set;
   const untestedFiles = [];
   let visitedCount = 0;
@@ -43714,7 +43762,7 @@ function batchAppendTestRuns(records, workingDir) {
   }
   const historyPath = getHistoryPath(workingDir);
   const historyDir = path78.dirname(historyPath);
-  _internals63.validateProjectRoot(workingDir);
+  _internals64.validateProjectRoot(workingDir);
   if (!fs33.existsSync(historyDir)) {
     fs33.mkdirSync(historyDir, { recursive: true });
   }
@@ -43837,7 +43885,7 @@ function getAllHistory(workingDir) {
   records.sort((a, b) => new Date(a.timestamp).getTime() - new Date(b.timestamp).getTime());
   return records;
 }
-var _internals63 = {
+var _internals64 = {
   validateProjectRoot
 };
 
@@ -43929,7 +43977,7 @@ var MAX_SAFE_TEST_FILES = 50;
 var MAX_SAFE_SOURCE_FILES = 1;
 async function estimateFanOut(sourceFiles, cwd) {
   try {
-    const impactMap = await _internals64.loadImpactMap(cwd, {
+    const impactMap = await _internals65.loadImpactMap(cwd, {
       skipRebuild: true
     });
     const uniqueTestFiles = new Set;
@@ -44019,45 +44067,45 @@ function hasDevDependency(devDeps, ...patterns) {
   return hasPackageJsonDependency(devDeps, ...patterns);
 }
 function detectGoTest(cwd) {
-  return _internals64.existsSync(path80.join(cwd, "go.mod")) && _internals64.isCommandAvailable("go");
+  return _internals65.existsSync(path80.join(cwd, "go.mod")) && _internals65.isCommandAvailable("go");
 }
 function detectJavaMaven(cwd) {
-  return _internals64.existsSync(path80.join(cwd, "pom.xml")) && _internals64.isCommandAvailable("mvn");
+  return _internals65.existsSync(path80.join(cwd, "pom.xml")) && _internals65.isCommandAvailable("mvn");
 }
 function detectGradle(cwd) {
-  const hasBuildFile = _internals64.existsSync(path80.join(cwd, "build.gradle")) || _internals64.existsSync(path80.join(cwd, "build.gradle.kts"));
-  const hasGradlew = _internals64.existsSync(path80.join(cwd, "gradlew")) || _internals64.existsSync(path80.join(cwd, "gradlew.bat"));
-  return hasBuildFile && (hasGradlew || _internals64.isCommandAvailable("gradle"));
+  const hasBuildFile = _internals65.existsSync(path80.join(cwd, "build.gradle")) || _internals65.existsSync(path80.join(cwd, "build.gradle.kts"));
+  const hasGradlew = _internals65.existsSync(path80.join(cwd, "gradlew")) || _internals65.existsSync(path80.join(cwd, "gradlew.bat"));
+  return hasBuildFile && (hasGradlew || _internals65.isCommandAvailable("gradle"));
 }
 function detectDotnetTest(cwd) {
   try {
-    const files = _internals64.readdirSync(cwd);
+    const files = _internals65.readdirSync(cwd);
     const hasCsproj = files.some((f) => f.endsWith(".csproj"));
-    return hasCsproj && _internals64.isCommandAvailable("dotnet");
+    return hasCsproj && _internals65.isCommandAvailable("dotnet");
   } catch {
     return false;
   }
 }
 function detectCTest(cwd) {
-  const hasSource = _internals64.existsSync(path80.join(cwd, "CMakeLists.txt"));
-  const hasBuildCache = _internals64.existsSync(path80.join(cwd, "CMakeCache.txt")) || _internals64.existsSync(path80.join(cwd, "build", "CMakeCache.txt"));
-  return (hasSource || hasBuildCache) && _internals64.isCommandAvailable("ctest");
+  const hasSource = _internals65.existsSync(path80.join(cwd, "CMakeLists.txt"));
+  const hasBuildCache = _internals65.existsSync(path80.join(cwd, "CMakeCache.txt")) || _internals65.existsSync(path80.join(cwd, "build", "CMakeCache.txt"));
+  return (hasSource || hasBuildCache) && _internals65.isCommandAvailable("ctest");
 }
 function detectSwiftTest(cwd) {
-  return _internals64.existsSync(path80.join(cwd, "Package.swift")) && _internals64.isCommandAvailable("swift");
+  return _internals65.existsSync(path80.join(cwd, "Package.swift")) && _internals65.isCommandAvailable("swift");
 }
 function detectDartTest(cwd) {
-  return _internals64.existsSync(path80.join(cwd, "pubspec.yaml")) && (_internals64.isCommandAvailable("dart") || _internals64.isCommandAvailable("flutter"));
+  return _internals65.existsSync(path80.join(cwd, "pubspec.yaml")) && (_internals65.isCommandAvailable("dart") || _internals65.isCommandAvailable("flutter"));
 }
 function detectRSpec(cwd) {
-  const hasRSpecFile = _internals64.existsSync(path80.join(cwd, ".rspec"));
-  const hasGemfile = _internals64.existsSync(path80.join(cwd, "Gemfile"));
-  const hasSpecDir = _internals64.existsSync(path80.join(cwd, "spec"));
+  const hasRSpecFile = _internals65.existsSync(path80.join(cwd, ".rspec"));
+  const hasGemfile = _internals65.existsSync(path80.join(cwd, "Gemfile"));
+  const hasSpecDir = _internals65.existsSync(path80.join(cwd, "spec"));
   const hasRSpec = hasRSpecFile || hasGemfile && hasSpecDir;
-  return hasRSpec && (_internals64.isCommandAvailable("bundle") || _internals64.isCommandAvailable("rspec"));
+  return hasRSpec && (_internals65.isCommandAvailable("bundle") || _internals65.isCommandAvailable("rspec"));
 }
 function detectMinitest(cwd) {
-  return _internals64.existsSync(path80.join(cwd, "test")) && (_internals64.existsSync(path80.join(cwd, "Gemfile")) || _internals64.existsSync(path80.join(cwd, "Rakefile"))) && _internals64.isCommandAvailable("ruby");
+  return _internals65.existsSync(path80.join(cwd, "test")) && (_internals65.existsSync(path80.join(cwd, "Gemfile")) || _internals65.existsSync(path80.join(cwd, "Rakefile"))) && _internals65.isCommandAvailable("ruby");
 }
 var DISPATCH_FRAMEWORK_MAP = {
   bun: "bun",
@@ -44148,8 +44196,8 @@ async function detectTestFramework(cwd) {
   const baseDir = cwd;
   try {
     const packageJsonPath = path80.join(baseDir, "package.json");
-    if (_internals64.existsSync(packageJsonPath)) {
-      const content = _internals64.readFileSync(packageJsonPath, "utf-8");
+    if (_internals65.existsSync(packageJsonPath)) {
+      const content = _internals65.readFileSync(packageJsonPath, "utf-8");
       const pkg = JSON.parse(content);
       const _deps = pkg.dependencies || {};
       const devDeps = pkg.devDependencies || {};
@@ -44168,7 +44216,7 @@ async function detectTestFramework(cwd) {
         return "jest";
       if (hasDevDependency(devDeps, "mocha", "@types/mocha"))
         return "mocha";
-      if (_internals64.existsSync(path80.join(baseDir, "bun.lockb")) || _internals64.existsSync(path80.join(baseDir, "bun.lock"))) {
+      if (_internals65.existsSync(path80.join(baseDir, "bun.lockb")) || _internals65.existsSync(path80.join(baseDir, "bun.lock"))) {
         if (scripts.test?.includes("bun"))
           return "bun";
       }
@@ -44178,28 +44226,28 @@ async function detectTestFramework(cwd) {
     const pyprojectTomlPath = path80.join(baseDir, "pyproject.toml");
     const setupCfgPath = path80.join(baseDir, "setup.cfg");
     const requirementsTxtPath = path80.join(baseDir, "requirements.txt");
-    if (_internals64.existsSync(pyprojectTomlPath)) {
-      const content = _internals64.readFileSync(pyprojectTomlPath, "utf-8");
+    if (_internals65.existsSync(pyprojectTomlPath)) {
+      const content = _internals65.readFileSync(pyprojectTomlPath, "utf-8");
       if (content.includes("[tool.pytest"))
         return "pytest";
       if (content.includes("pytest"))
         return "pytest";
     }
-    if (_internals64.existsSync(setupCfgPath)) {
-      const content = _internals64.readFileSync(setupCfgPath, "utf-8");
+    if (_internals65.existsSync(setupCfgPath)) {
+      const content = _internals65.readFileSync(setupCfgPath, "utf-8");
       if (content.includes("[pytest]"))
         return "pytest";
     }
-    if (_internals64.existsSync(requirementsTxtPath)) {
-      const content = _internals64.readFileSync(requirementsTxtPath, "utf-8");
+    if (_internals65.existsSync(requirementsTxtPath)) {
+      const content = _internals65.readFileSync(requirementsTxtPath, "utf-8");
       if (content.includes("pytest"))
         return "pytest";
     }
   } catch {}
   try {
     const cargoTomlPath = path80.join(baseDir, "Cargo.toml");
-    if (_internals64.existsSync(cargoTomlPath)) {
-      const content = _internals64.readFileSync(cargoTomlPath, "utf-8");
+    if (_internals65.existsSync(cargoTomlPath)) {
+      const content = _internals65.readFileSync(cargoTomlPath, "utf-8");
       if (content.includes("[dev-dependencies]")) {
         if (content.includes("tokio") || content.includes("mockall") || content.includes("pretty_assertions")) {
           return "cargo";
@@ -44211,7 +44259,7 @@ async function detectTestFramework(cwd) {
     const pesterConfigPath = path80.join(baseDir, "pester.config.ps1");
     const pesterConfigJsonPath = path80.join(baseDir, "pester.config.ps1.json");
     const pesterPs1Path = path80.join(baseDir, "tests.ps1");
-    if (_internals64.existsSync(pesterConfigPath) || _internals64.existsSync(pesterConfigJsonPath) || _internals64.existsSync(pesterPs1Path)) {
+    if (_internals65.existsSync(pesterConfigPath) || _internals65.existsSync(pesterConfigJsonPath) || _internals65.existsSync(pesterPs1Path)) {
       return "pester";
     }
   } catch {}
@@ -44239,12 +44287,12 @@ async function detectTestFramework(cwd) {
   return "none";
 }
 function detectPhpTest(cwd) {
-  if (_internals64.existsSync(path80.join(cwd, "artisan")) && _internals64.existsSync(path80.join(cwd, "composer.json"))) {
+  if (_internals65.existsSync(path80.join(cwd, "artisan")) && _internals65.existsSync(path80.join(cwd, "composer.json"))) {
     return "php-artisan";
   }
-  if (_internals64.existsSync(path80.join(cwd, "Pest.php")))
+  if (_internals65.existsSync(path80.join(cwd, "Pest.php")))
     return "pest";
-  if (_internals64.existsSync(path80.join(cwd, "phpunit.xml")) || _internals64.existsSync(path80.join(cwd, "phpunit.xml.dist"))) {
+  if (_internals65.existsSync(path80.join(cwd, "phpunit.xml")) || _internals65.existsSync(path80.join(cwd, "phpunit.xml.dist"))) {
     return "phpunit";
   }
   return null;
@@ -44626,9 +44674,9 @@ function buildTestCommand(framework, scope, files, coverage, baseDir, bail) {
     case "swift-test":
       return ["swift", "test"];
     case "dart-test":
-      return _internals64.isCommandAvailable("flutter") ? ["flutter", "test", ...files] : ["dart", "test", ...files];
+      return _internals65.isCommandAvailable("flutter") ? ["flutter", "test", ...files] : ["dart", "test", ...files];
     case "rspec": {
-      const args = _internals64.isCommandAvailable("bundle") ? ["bundle", "exec", "rspec"] : ["rspec"];
+      const args = _internals65.isCommandAvailable("bundle") ? ["bundle", "exec", "rspec"] : ["rspec"];
       if (bail)
         args.push("--fail-fast");
       if (scope !== "all" && files.length > 0) {
@@ -45641,7 +45689,7 @@ var test_runner = createSwarmTool({
         return JSON.stringify(errorResult, null, 2);
       }
       try {
-        const impactResult = await _internals64.analyzeImpact(sourceFiles, workingDir, MAX_SAFE_TEST_FILES);
+        const impactResult = await _internals65.analyzeImpact(sourceFiles, workingDir, MAX_SAFE_TEST_FILES);
         if (impactResult.budgetExceeded) {
           const errorResult = {
             success: false,
@@ -45731,7 +45779,7 @@ var test_runner = createSwarmTool({
     return JSON.stringify(result, null, 2);
   }
 });
-var _internals64 = {
+var _internals65 = {
   analyzeImpact,
   loadImpactMap,
   isCommandAvailable,
@@ -45826,9 +45874,9 @@ function getVersionFileVersion(dir) {
 async function runVersionCheck(dir, _timeoutMs) {
   const startTime = Date.now();
   try {
-    const packageVersion = _internals65.getPackageVersion(dir);
-    const changelogVersion = _internals65.getChangelogVersion(dir);
-    const versionFileVersion = _internals65.getVersionFileVersion(dir);
+    const packageVersion = _internals66.getPackageVersion(dir);
+    const changelogVersion = _internals66.getChangelogVersion(dir);
+    const versionFileVersion = _internals66.getVersionFileVersion(dir);
     const versions = [];
     if (packageVersion)
       versions.push(`package.json: ${packageVersion}`);
@@ -46192,7 +46240,7 @@ async function runPreflight(dir, phase, config) {
   const reportId = `preflight-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
   let validatedDir;
   try {
-    validatedDir = _internals65.validateDirectoryPath(dir);
+    validatedDir = _internals66.validateDirectoryPath(dir);
   } catch (error2) {
     return {
       id: reportId,
@@ -46212,7 +46260,7 @@ async function runPreflight(dir, phase, config) {
   }
   let validatedTimeout;
   try {
-    validatedTimeout = _internals65.validateTimeout(config?.checkTimeoutMs, DEFAULT_CONFIG.checkTimeoutMs);
+    validatedTimeout = _internals66.validateTimeout(config?.checkTimeoutMs, DEFAULT_CONFIG.checkTimeoutMs);
   } catch (error2) {
     return {
       id: reportId,
@@ -46253,12 +46301,12 @@ async function runPreflight(dir, phase, config) {
   });
   const checks = [];
   log("[Preflight] Running lint check...");
-  const lintResult = await _internals65.runLintCheck(validatedDir, cfg.linter, cfg.checkTimeoutMs);
+  const lintResult = await _internals66.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 _internals65.runTestsCheck(validatedDir, cfg.testScope, cfg.checkTimeoutMs);
+    const testsResult = await _internals66.runTestsCheck(validatedDir, cfg.testScope, cfg.checkTimeoutMs);
     checks.push(testsResult);
     log(`[Preflight] Tests check: ${testsResult.status} ${testsResult.message}`);
   } else {
@@ -46270,7 +46318,7 @@ async function runPreflight(dir, phase, config) {
   }
   if (!cfg.skipSecrets) {
     log("[Preflight] Running secrets check...");
-    const secretsResult = await _internals65.runSecretsCheck(validatedDir, cfg.checkTimeoutMs);
+    const secretsResult = await _internals66.runSecretsCheck(validatedDir, cfg.checkTimeoutMs);
     checks.push(secretsResult);
     log(`[Preflight] Secrets check: ${secretsResult.status} ${secretsResult.message}`);
   } else {
@@ -46282,7 +46330,7 @@ async function runPreflight(dir, phase, config) {
   }
   if (!cfg.skipEvidence) {
     log("[Preflight] Running evidence check...");
-    const evidenceResult = await _internals65.runEvidenceCheck(validatedDir);
+    const evidenceResult = await _internals66.runEvidenceCheck(validatedDir);
     checks.push(evidenceResult);
     log(`[Preflight] Evidence check: ${evidenceResult.status} ${evidenceResult.message}`);
   } else {
@@ -46293,12 +46341,12 @@ async function runPreflight(dir, phase, config) {
     });
   }
   log("[Preflight] Running requirement coverage check...");
-  const reqCoverageResult = await _internals65.runRequirementCoverageCheck(validatedDir, phase);
+  const reqCoverageResult = await _internals66.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 _internals65.runVersionCheck(validatedDir, cfg.checkTimeoutMs);
+    const versionResult = await _internals66.runVersionCheck(validatedDir, cfg.checkTimeoutMs);
     checks.push(versionResult);
     log(`[Preflight] Version check: ${versionResult.status} ${versionResult.message}`);
   } else {
@@ -46361,10 +46409,10 @@ function formatPreflightMarkdown(report) {
 async function handlePreflightCommand(directory, _args) {
   const plan = await loadPlan(directory);
   const phase = plan?.current_phase ?? 1;
-  const report = await _internals65.runPreflight(directory, phase);
-  return _internals65.formatPreflightMarkdown(report);
+  const report = await _internals66.runPreflight(directory, phase);
+  return _internals66.formatPreflightMarkdown(report);
 }
-var _internals65 = {
+var _internals66 = {
   runPreflight,
   formatPreflightMarkdown,
   handlePreflightCommand,
@@ -47357,7 +47405,7 @@ function pruneOldResetBackups(backupsRoot, warnings) {
 }
 
 // src/commands/reset.ts
-var _internals66 = {
+var _internals67 = {
   backupSwarmStateBeforeReset
 };
 async function handleResetCommand(directory, args) {
@@ -47391,7 +47439,7 @@ async function handleResetCommand(directory, args) {
   ];
   const results = [];
   try {
-    const backup = _internals66.backupSwarmStateBeforeReset(directory, "reset", [
+    const backup = _internals67.backupSwarmStateBeforeReset(directory, "reset", [
       ...filesToReset,
       "summaries"
     ]);
@@ -47943,7 +47991,7 @@ async function recordReplayEntry(artifactPath, sessionID, entry) {
 }
 
 // src/prm/index.ts
-var _internals67 = {
+var _internals68 = {
   getAgentSession,
   readTrajectory,
   getInMemoryTrajectory,
@@ -47971,12 +48019,12 @@ function resetPrmSessionState(session, sessionId) {
   session.prmInjectedAdvisoryKeys = new Set;
   session.replayArtifactPath = null;
   if (sessionId) {
-    _internals67.clearTrajectoryCache(sessionId);
+    _internals68.clearTrajectoryCache(sessionId);
   }
 }
 
 // src/commands/reset-session.ts
-var _internals68 = {
+var _internals69 = {
   cleanupOrphanedBranches,
   backupSwarmStateBeforeReset
 };
@@ -47988,7 +48036,7 @@ function errorMessage(err) {
 async function handleResetSessionCommand(directory, _args) {
   const results = [];
   try {
-    const backup = _internals68.backupSwarmStateBeforeReset(directory, "reset-session", ["session"]);
+    const backup = _internals69.backupSwarmStateBeforeReset(directory, "reset-session", ["session"]);
     if (backup.backupDir && backup.copied.length > 0) {
       const rel = path85.relative(directory, backup.backupDir);
       results.push(`\uD83D\uDCE6 Backed up session state to ${rel}/ (restore by copying files back into .swarm/session/)`);
@@ -48055,7 +48103,7 @@ async function handleResetSessionCommand(directory, _args) {
     results.push(`\u26A0\uFE0F Failed to remove .swarm-worktrees/: ${errorMessage(err)}`);
   }
   try {
-    const branchResult = await _internals68.cleanupOrphanedBranches(directory, []);
+    const branchResult = await _internals69.cleanupOrphanedBranches(directory, []);
     if (branchResult.removed.length > 0) {
       results.push(`\u2705 Removed ${branchResult.removed.length} orphan swarm-lane branch(es)`);
     }
@@ -48214,7 +48262,7 @@ function resolveReceiptsDir(directory) {
 function resolveReceiptIndexPath(directory) {
   return path87.join(resolveReceiptsDir(directory), "index.json");
 }
-var _internals69 = {
+var _internals70 = {
   openSync: fs41.openSync,
   lstatBigIntSync: (path88) => fs41.lstatSync(path88, { bigint: true }),
   fstatBigIntSync: (fd) => fs41.fstatSync(fd, { bigint: true })
@@ -48226,7 +48274,7 @@ function pathsEqual(left, right) {
 }
 function captureCanonicalDirectory(directory, label, expected) {
   const resolved = path87.resolve(directory);
-  const stat6 = _internals69.lstatBigIntSync(resolved);
+  const stat6 = _internals70.lstatBigIntSync(resolved);
   if (!stat6.isDirectory() || stat6.isSymbolicLink()) {
     throw new Error(`${label} must be a real directory`);
   }
@@ -48312,7 +48360,7 @@ function assertDirectReceiptFile(context, filePath, mustExist) {
     throw new Error("review receipt file escapes its expected directory");
   }
   try {
-    const stat6 = _internals69.lstatBigIntSync(resolved);
+    const stat6 = _internals70.lstatBigIntSync(resolved);
     if (!stat6.isFile() || stat6.isSymbolicLink()) {
       throw new Error("review receipt path must be a real file");
     }
@@ -48336,7 +48384,7 @@ function readReviewReceiptText(directory, receiptPath, maxBytes = 1048576) {
     const resolved = assertDirectReceiptFile(context, receiptPath, true);
     if (path87.extname(resolved) !== ".json")
       return null;
-    const pathBeforeOpen = _internals69.lstatBigIntSync(resolved);
+    const pathBeforeOpen = _internals70.lstatBigIntSync(resolved);
     if (!pathBeforeOpen.isFile() || pathBeforeOpen.isSymbolicLink() || pathBeforeOpen.size < 0n || pathBeforeOpen.size > BigInt(maxBytes)) {
       return null;
     }
@@ -48344,10 +48392,10 @@ function readReviewReceiptText(directory, receiptPath, maxBytes = 1048576) {
     if (!pathsEqual(canonicalBeforeOpen, resolved))
       return null;
     assertReceiptContextCurrent(context);
-    descriptor = _internals69.openSync(canonicalBeforeOpen, "r");
-    const openedBeforeRead = _internals69.fstatBigIntSync(descriptor);
+    descriptor = _internals70.openSync(canonicalBeforeOpen, "r");
+    const openedBeforeRead = _internals70.fstatBigIntSync(descriptor);
     assertReceiptContextCurrent(context);
-    const pathAfterOpen = _internals69.lstatBigIntSync(resolved);
+    const pathAfterOpen = _internals70.lstatBigIntSync(resolved);
     const canonicalAfterOpen = fs41.realpathSync(resolved);
     if (!openedBeforeRead.isFile() || openedBeforeRead.size < 0n || openedBeforeRead.size > BigInt(maxBytes) || !sameFileSnapshot2(pathBeforeOpen, openedBeforeRead) || !sameFileSnapshot2(openedBeforeRead, pathAfterOpen) || !pathsEqual(canonicalBeforeOpen, canonicalAfterOpen)) {
       return null;
@@ -48360,9 +48408,9 @@ function readReviewReceiptText(directory, receiptPath, maxBytes = 1048576) {
         break;
       bytesRead += count;
     }
-    const openedAfterRead = _internals69.fstatBigIntSync(descriptor);
+    const openedAfterRead = _internals70.fstatBigIntSync(descriptor);
     assertReceiptContextCurrent(context);
-    const pathAfterRead = _internals69.lstatBigIntSync(resolved);
+    const pathAfterRead = _internals70.lstatBigIntSync(resolved);
     const canonicalAfterRead = fs41.realpathSync(resolved);
     if (bytesRead !== buffer.length || !sameFileSnapshot2(openedBeforeRead, openedAfterRead) || !sameFileSnapshot2(openedAfterRead, pathAfterRead) || !pathsEqual(canonicalBeforeOpen, canonicalAfterRead)) {
       return null;
@@ -48906,7 +48954,7 @@ var HEAD_TIMEOUT_MS = 5000;
 var HEAD_OUTPUT_BYTES = 256;
 var HEAD_SHA_PATTERN = /^[0-9a-f]{40,64}$/i;
 var REVIEWER_TASK_SCOPE_DESCRIPTION = "reviewer-task-files-v1";
-var _internals70 = {
+var _internals71 = {
   spawn: child_process8.spawn,
   realpath: fs42.promises.realpath,
   lstatBigInt: (path89) => fs42.promises.lstat(path89, { bigint: true }),
@@ -48946,7 +48994,7 @@ async function missingPathParentIsContained(root, absolutePath2) {
   let current = path88.dirname(absolutePath2);
   for (;; ) {
     try {
-      const canonical = await _internals70.realpath(current);
+      const canonical = await _internals71.realpath(current);
       return samePath2(root, canonical) || isContained2(root, canonical);
     } catch (error2) {
       if (error2.code !== "ENOENT")
@@ -48973,7 +49021,7 @@ async function resolveHeadSha(directory) {
   let child;
   let timeoutHandle;
   try {
-    child = _internals70.spawn("git", ["rev-parse", "--verify", "HEAD"], {
+    child = _internals71.spawn("git", ["rev-parse", "--verify", "HEAD"], {
       cwd: directory,
       stdio: ["ignore", "pipe", "ignore"],
       timeout: HEAD_TIMEOUT_MS,
@@ -49036,7 +49084,7 @@ async function buildReviewerTaskScope(directory, modifiedFiles, maxBytes = DEFAU
   let realRoot;
   try {
     lexicalRoot = path88.resolve(directory);
-    realRoot = await _internals70.realpath(lexicalRoot);
+    realRoot = await _internals71.realpath(lexicalRoot);
   } catch {
     return null;
   }
@@ -49077,7 +49125,7 @@ async function buildReviewerTaskScope(directory, modifiedFiles, maxBytes = DEFAU
   for (const candidate of ordered) {
     let before;
     try {
-      before = await _internals70.lstatBigInt(candidate.absolutePath);
+      before = await _internals71.lstatBigInt(candidate.absolutePath);
     } catch (error2) {
       if (error2.code === "ENOENT") {
         if (!await missingPathParentIsContained(realRoot, candidate.absolutePath)) {
@@ -49096,7 +49144,7 @@ async function buildReviewerTaskScope(directory, modifiedFiles, maxBytes = DEFAU
       return null;
     let realCandidate;
     try {
-      realCandidate = await _internals70.realpath(candidate.absolutePath);
+      realCandidate = await _internals71.realpath(candidate.absolutePath);
     } catch {
       return null;
     }
@@ -49108,15 +49156,15 @@ async function buildReviewerTaskScope(directory, modifiedFiles, maxBytes = DEFAU
     let bytes;
     let openedBefore;
     try {
-      handle = await _internals70.open(realCandidate, "r");
-      openedBefore = await _internals70.fileHandleStatBigInt(handle);
-      const canonicalAfterOpen = await _internals70.realpath(candidate.absolutePath);
+      handle = await _internals71.open(realCandidate, "r");
+      openedBefore = await _internals71.fileHandleStatBigInt(handle);
+      const canonicalAfterOpen = await _internals71.realpath(candidate.absolutePath);
       if (!openedBefore.isFile() || !sameFileSnapshot3(before, openedBefore) || !samePath2(realCandidate, canonicalAfterOpen) || !isContained2(realRoot, canonicalAfterOpen)) {
         return null;
       }
       bytes = await readBoundedHandle(handle, maxBytes - totalBytes);
-      const openedAfter = await _internals70.fileHandleStatBigInt(handle);
-      const canonicalAfterRead = await _internals70.realpath(candidate.absolutePath);
+      const openedAfter = await _internals71.fileHandleStatBigInt(handle);
+      const canonicalAfterRead = await _internals71.realpath(candidate.absolutePath);
       if (!sameFileSnapshot3(openedBefore, openedAfter) || !samePath2(realCandidate, canonicalAfterRead) || !isContained2(realRoot, canonicalAfterRead) || BigInt(bytes.byteLength) !== openedBefore.size) {
         return null;
       }
@@ -49140,8 +49188,8 @@ async function buildReviewerTaskScope(directory, modifiedFiles, maxBytes = DEFAU
   }
   for (const stable of stableFiles) {
     try {
-      const current = await _internals70.lstatBigInt(stable.absolutePath);
-      const canonical = await _internals70.realpath(stable.absolutePath);
+      const current = await _internals71.lstatBigInt(stable.absolutePath);
+      const canonical = await _internals71.realpath(stable.absolutePath);
       if (!current.isFile() || current.isSymbolicLink() || !sameFileSnapshot3(stable.stat, current) || !samePath2(stable.canonicalPath, canonical) || !isContained2(realRoot, canonical)) {
         return null;
       }
@@ -49151,7 +49199,7 @@ async function buildReviewerTaskScope(directory, modifiedFiles, maxBytes = DEFAU
   }
   for (const deletedPath of deletedPaths) {
     try {
-      await _internals70.lstatBigInt(deletedPath);
+      await _internals71.lstatBigInt(deletedPath);
       return null;
     } catch (error2) {
       if (error2.code !== "ENOENT" || !await missingPathParentIsContained(realRoot, deletedPath)) {
@@ -49314,7 +49362,7 @@ function parseReviewerOutput(text, options = {}) {
     outputMode: "legacy"
   };
 }
-var _internals71 = {
+var _internals72 = {
   delegationEnd: telemetry.delegationEnd,
   resolveReviewerTaskScope,
   buildReviewerTaskScope,
@@ -49519,7 +49567,7 @@ function scopeFreshnessMismatches(reviewed, current) {
 }
 function createScopeVerifier(input, reviewed, maxBytes) {
   return async () => {
-    const current = await _internals72.collectReviewDiff({
+    const current = await _internals73.collectReviewDiff({
       directory: input.directory,
       selector: input.selector,
       maxBytes
@@ -49528,7 +49576,7 @@ function createScopeVerifier(input, reviewed, maxBytes) {
   };
 }
 async function stalePersistenceResult(input, maxBytes, message, modelCalls) {
-  const current = await _internals72.collectReviewDiff({
+  const current = await _internals73.collectReviewDiff({
     directory: input.directory,
     selector: input.selector,
     maxBytes
@@ -49907,7 +49955,7 @@ async function persistErrorResult(input, diff, result, error2, dispatches, promp
   evidence2.review.error = error2;
   addCost(evidence2, dispatches);
   try {
-    result.evidencePath = await _internals72.persistEvidence(input.directory, evidence2);
+    result.evidencePath = await _internals73.persistEvidence(input.directory, evidence2);
   } catch {
     if (input.config.final_review.mode === "gate") {
       result.blocked = true;
@@ -49923,7 +49971,7 @@ async function runReviewEngine(input) {
   const gateMode = input.config.final_review.mode === "gate";
   const maxBytes = input.trigger === "task_completion" ? input.config.max_diff_kb * 1024 : input.config.final_review.max_diff_bytes;
   const timeoutMs = input.trigger === "task_completion" ? input.config.timeout_ms : input.config.final_review.timeout_ms;
-  const diff = await _internals72.collectReviewDiff({
+  const diff = await _internals73.collectReviewDiff({
     directory: input.directory,
     selector: input.selector,
     maxBytes
@@ -49937,7 +49985,7 @@ async function runReviewEngine(input) {
     const evidence3 = baseEvidence(input, diff, "clean");
     let evidencePath2;
     try {
-      evidencePath2 = await _internals72.persistEvidence(input.directory, evidence3, { verifyCurrent: createScopeVerifier(input, diff, maxBytes) });
+      evidencePath2 = await _internals73.persistEvidence(input.directory, evidence3, { verifyCurrent: createScopeVerifier(input, diff, maxBytes) });
     } catch (error2) {
       if (error2 instanceof ReviewScopeStaleError) {
         return stalePersistenceResult(input, maxBytes, "Review scope changed before clean evidence could be committed.", 0);
@@ -49959,7 +50007,7 @@ async function runReviewEngine(input) {
     phase: input.phase
   });
   if (input.phase !== undefined && (input.trigger === "phase_completion" || input.trigger === "plan_completion")) {
-    const existing = _internals72.readPhaseEvidence(input.directory, input.phase);
+    const existing = _internals73.readPhaseEvidence(input.directory, input.phase);
     const integrity = existing ? validateAutoReviewEvidenceIntegrity(input.directory, existing, {
       scopeHash: diff.scopeHash,
       phase: input.phase,
@@ -50085,7 +50133,7 @@ async function runReviewEngine(input) {
       validation: byId.get(finding.finding_id)
     }));
   }
-  const currentScope = await _internals72.collectReviewDiff({
+  const currentScope = await _internals73.collectReviewDiff({
     directory: input.directory,
     selector: input.selector,
     maxBytes
@@ -50164,7 +50212,7 @@ async function runReviewEngine(input) {
       findingValidations: findings.map((finding) => finding.validation).filter((item) => Boolean(item))
     });
     receiptId = receipt.id;
-    receiptPath = await _internals72.persistReceipt(input.directory, receipt, {
+    receiptPath = await _internals73.persistReceipt(input.directory, receipt, {
       verifyCurrent: createScopeVerifier(input, diff, maxBytes)
     });
     evidence2.receipt_path = receiptPath;
@@ -50194,7 +50242,7 @@ async function runReviewEngine(input) {
   }
   let evidencePath;
   try {
-    evidencePath = await _internals72.persistEvidence(input.directory, evidence2, {
+    evidencePath = await _internals73.persistEvidence(input.directory, evidence2, {
       verifyCurrent: createScopeVerifier(input, diff, maxBytes)
     });
   } catch (error2) {
@@ -50231,7 +50279,7 @@ async function runReviewEngine(input) {
   input.injectAdvisory?.(input.sessionID, advisoryMessage(input, result));
   return result;
 }
-var _internals72 = {
+var _internals73 = {
   collectReviewDiff,
   persistEvidence: persistAutoReviewEvidence,
   persistReceipt: persistReviewReceipt,
@@ -50502,7 +50550,7 @@ async function handleReviewCommand(ctx) {
   } catch (error2) {
     return `Review configuration error: ${error2 instanceof Error ? error2.message : String(error2)}`;
   }
-  const result = await _internals73.runReviewEngine({
+  const result = await _internals74.runReviewEngine({
     directory: ctx.directory,
     sessionID: ctx.sessionID,
     trigger: "manual",
@@ -50516,10 +50564,10 @@ async function handleReviewCommand(ctx) {
     validatorModel,
     validatorFallbackModels
   });
-  const evidence2 = _internals73.readEvidence(result.evidencePath, ctx.directory);
+  const evidence2 = _internals74.readEvidence(result.evidencePath, ctx.directory);
   return parsed.json ? renderJson(result, evidence2, parsed.selector) : renderHuman(result, evidence2, parsed.selector);
 }
-var _internals73 = {
+var _internals74 = {
   runReviewEngine,
   readEvidence
 };
@@ -50764,7 +50812,7 @@ async function handleRollbackCommand(directory, args) {
 // src/commands/sdd.ts
 import * as fs47 from "fs";
 import * as path93 from "path";
-var _internals74 = {
+var _internals75 = {
   writeProjectedSpecSync
 };
 var SWARM_SPEC_REL = path93.join(".swarm", "spec.md");
@@ -51160,7 +51208,7 @@ ${USAGE12}`;
 
 ${USAGE12}`;
     }
-    const result2 = _internals74.writeProjectedSpecSync(directory, {
+    const result2 = _internals75.writeProjectedSpecSync(directory, {
       source: "speckit",
       feature: resolution.feature,
       dryRun: parsed.dryRun,
@@ -51218,7 +51266,7 @@ ${formatList(result2.projection.warnings)}` : ""
     ].join(`
 `);
   }
-  const result = _internals74.writeProjectedSpecSync(directory, {
+  const result = _internals75.writeProjectedSpecSync(directory, {
     changeId: parsed.changeId,
     dryRun: parsed.dryRun,
     overwrite: parsed.overwrite
@@ -51299,7 +51347,7 @@ async function handleSimulateCommand(directory, args) {
   }
   let darkMatterPairs;
   try {
-    darkMatterPairs = await _internals35.detectDarkMatter(directory, options);
+    darkMatterPairs = await _internals36.detectDarkMatter(directory, options);
   } catch (err) {
     const errMsg = err instanceof Error ? err.message : String(err);
     return `## Simulate Report
@@ -51457,7 +51505,7 @@ function writeFileFsyncedThenRename(tempPath, targetPath, data) {
     throw err;
   }
 }
-var _internals75 = {
+var _internals76 = {
   withEvidenceLock,
   writeFileFsyncedThenRename,
   writeFileSync: writeFileSyncAsync,
@@ -51476,7 +51524,7 @@ async function appendEvent(directory, eventInput) {
   }
   const filePath = ledgerPath(directory, eventInput.skillSlug, eventInput.candidateId);
   ensureCandidateDir(directory, eventInput.skillSlug, eventInput.candidateId);
-  return _internals75.withEvidenceLock(directory, path94.join(".swarm", "evolution", "skills", eventInput.skillSlug, eventInput.candidateId, "lifecycle.jsonl"), "skill-opt-ledger", "append-skill-opt-event", async () => {
+  return _internals76.withEvidenceLock(directory, path94.join(".swarm", "evolution", "skills", eventInput.skillSlug, eventInput.candidateId, "lifecycle.jsonl"), "skill-opt-ledger", "append-skill-opt-event", async () => {
     const existing = existsSync52(filePath) ? readFileSync39(filePath, "utf8") : "";
     const events = parseEventsFromText(existing);
     const nextSeq = events.length === 0 ? 1 : events[events.length - 1].seq + 1;
@@ -51507,8 +51555,8 @@ async function appendEvent(directory, eventInput) {
     const validContent = events.map((e) => JSON.stringify(e)).join(`
 `) + (events.length > 0 ? `
 ` : "");
-    _internals75.writeFileFsyncedThenRename(tempPath, filePath, validContent + line);
-    const verify = parseEventsFromText(_internals75.readFileSync(filePath, "utf8"));
+    _internals76.writeFileFsyncedThenRename(tempPath, filePath, validContent + line);
+    const verify = parseEventsFromText(_internals76.readFileSync(filePath, "utf8"));
     const last = verify.length > 0 ? verify[verify.length - 1] : null;
     if (!last || last.seq !== event.seq || last.hashAfter !== event.hashAfter) {
       throw new Error(`skill-opt ledger append verification failed for candidate ${event.candidateId} seq ${event.seq}`);
@@ -51610,14 +51658,14 @@ function writeStateProjection(directory, skillSlug, candidateId2, replay) {
     updatedAt: new Date().toISOString()
   };
   const tempPath = `${target}.tmp.${Date.now()}.${Math.floor(Math.random() * 1e9)}`;
-  _internals75.writeFileFsyncedThenRename(tempPath, target, `${JSON.stringify(projection, null, 2)}
+  _internals76.writeFileFsyncedThenRename(tempPath, target, `${JSON.stringify(projection, null, 2)}
 `);
 }
 function writeArtifact(directory, skillSlug, candidateId2, fileName, content) {
   const dir = ensureCandidateDir(directory, skillSlug, candidateId2);
   const target = path94.join(dir, fileName);
   const tempPath = `${target}.tmp.${Date.now()}.${Math.floor(Math.random() * 1e9)}`;
-  _internals75.writeFileFsyncedThenRename(tempPath, target, content);
+  _internals76.writeFileFsyncedThenRename(tempPath, target, content);
   return target;
 }
 function readArtifact(directory, skillSlug, candidateId2, fileName) {
@@ -51710,16 +51758,16 @@ function currentCandidateState(directory, skillSlug, candidateId2) {
 function writeSkillFileAtomic(targetPath, content) {
   const tempPath = `${targetPath}.tmp.${Date.now()}.${Math.floor(Math.random() * 1e9)}`;
   try {
-    _internals76.writeFileSync(tempPath, content, "utf8");
-    _internals76.renameSync(tempPath, targetPath);
+    _internals77.writeFileSync(tempPath, content, "utf8");
+    _internals77.renameSync(tempPath, targetPath);
   } finally {
     try {
       if (existsSync53(tempPath))
-        _internals76.unlinkSync(tempPath);
+        _internals77.unlinkSync(tempPath);
     } catch {}
   }
 }
-var _internals76 = {
+var _internals77 = {
   writeFileSync: writeFileSync18,
   renameSync: renameSync18,
   unlinkSync: unlinkSync21
@@ -52065,7 +52113,7 @@ function buildGeneratorInputs(args) {
     }
   };
 }
-var _internals77 = {
+var _internals78 = {
   draftDeterministic: defaultDeterministicDraft
 };
 function defaultDeterministicDraft(inputs) {
@@ -52135,7 +52183,7 @@ function countChangedLines(a, b) {
   return changed;
 }
 function draftCandidate(inputs) {
-  const candidate = _internals77.draftDeterministic(inputs);
+  const candidate = _internals78.draftDeterministic(inputs);
   enforceTrustRegion(candidate, inputs.budget);
   return candidate;
 }
@@ -52178,7 +52226,7 @@ import * as path96 from "path";
 // src/hooks/spawn-helper.ts
 import * as child_process9 from "child_process";
 var WIN32_CMD_BINARIES = new Set(["npm", "npx", "pnpm", "yarn"]);
-var _internals78 = {
+var _internals79 = {
   spawn: child_process9.spawn
 };
 function spawnAsync(command, cwd, timeoutMs) {
@@ -52186,7 +52234,7 @@ function spawnAsync(command, cwd, timeoutMs) {
     try {
       const [rawCmd, ...args] = command;
       const cmd = process.platform === "win32" && WIN32_CMD_BINARIES.has(rawCmd) && !rawCmd.includes(".") ? `${rawCmd}.cmd` : rawCmd;
-      const proc = _internals78.spawn(cmd, args, {
+      const proc = _internals79.spawn(cmd, args, {
         cwd,
         stdio: ["ignore", "pipe", "pipe"]
       });
@@ -52252,7 +52300,7 @@ function spawnAsync(command, cwd, timeoutMs) {
 }
 
 // src/services/skill-optimizer/smoke.ts
-var _internals79 = {
+var _internals80 = {
   validateSkillPath,
   isSymbolicLink: (p) => {
     try {
@@ -52273,7 +52321,7 @@ var _internals79 = {
 async function validateSkillSmoke(input) {
   const notes = [];
   const repoRel = path96.join(".opencode", "skills", "generated", input.skillSlug, "SKILL.md");
-  if (!_internals79.validateSkillPath(repoRel)) {
+  if (!_internals80.validateSkillPath(repoRel)) {
     return {
       ok: false,
       verdict: "VIOLATED",
@@ -52282,16 +52330,16 @@ async function validateSkillSmoke(input) {
   }
   const skillRoot = path96.join(input.directory, ".opencode", "skills", "generated", input.skillSlug);
   if (existsSync54(skillRoot)) {
-    if (_internals79.isSymbolicLink(skillRoot)) {
+    if (_internals80.isSymbolicLink(skillRoot)) {
       return {
         ok: false,
         verdict: "VIOLATED",
         notes: ["skill root is a symlink (reparse denied)"]
       };
     }
-    const realRoot = _internals79.realpath(skillRoot);
-    const realProjectDir = _internals79.realpath(input.directory);
-    if (_internals79.escapedRoot(realProjectDir, realRoot)) {
+    const realRoot = _internals80.realpath(skillRoot);
+    const realProjectDir = _internals80.realpath(input.directory);
+    if (_internals80.escapedRoot(realProjectDir, realRoot)) {
       return {
         ok: false,
         verdict: "VIOLATED",
@@ -52309,7 +52357,7 @@ async function validateSkillSmoke(input) {
       notes: [`frontmatter: ${fmError}`]
     };
   }
-  const rejected = await _internals79.isRejectedSkillContent(input.directory, input.skillSlug, input.candidateContent);
+  const rejected = await _internals80.isRejectedSkillContent(input.directory, input.skillSlug, input.candidateContent);
   if (rejected) {
     return {
       ok: false,
@@ -52319,7 +52367,7 @@ async function validateSkillSmoke(input) {
       ]
     };
   }
-  const evalResult = await _internals79.evaluateSkillChange({
+  const evalResult = await _internals80.evaluateSkillChange({
     directory: input.directory,
     slug: input.skillSlug,
     candidateContent: input.candidateContent,
@@ -52338,7 +52386,7 @@ async function validateSkillSmoke(input) {
     notes.push(`phrase-eval passed (score ${evalResult.candidateScore.toFixed(2)})`);
   }
   if (input.checkCommand && input.checkCommand.length > 0) {
-    const cmdResult = await _internals79.spawnAsync(input.checkCommand, input.directory, input.checkTimeoutMs ?? 60000);
+    const cmdResult = await _internals80.spawnAsync(input.checkCommand, input.directory, input.checkTimeoutMs ?? 60000);
     if (!cmdResult || cmdResult.exitCode !== 0) {
       return {
         ok: false,
@@ -52408,14 +52456,14 @@ async function prepareCandidatePayloads(inputRoot, candidateId2, skillSlug, base
   candidate.contentHash = await computeCandidateInputContentHash2(inputRoot, candidate);
   return { baseline, candidate };
 }
-var _internals80 = {
+var _internals81 = {
   tryAcquireLock,
   emitTelemetry: emit,
   evaluateCandidateV1,
   prepareCandidatePayloads
 };
 async function acquireProjectLock(directory) {
-  const result = await _internals80.tryAcquireLock(directory, PROJECT_LOCK_PATH, "skill-opt-controller", "project-run");
+  const result = await _internals81.tryAcquireLock(directory, PROJECT_LOCK_PATH, "skill-opt-controller", "project-run");
   if (!result.acquired)
     return null;
   return async () => {
@@ -52428,7 +52476,7 @@ async function acquireProjectLock(directory) {
 }
 async function acquireSkillLock(directory, skillSlug) {
   const lockPath = path97.join(".swarm", "evolution", "skills", skillSlug, ".skill.lock");
-  const result = await _internals80.tryAcquireLock(directory, lockPath, "skill-opt-controller", `skill-${skillSlug}`);
+  const result = await _internals81.tryAcquireLock(directory, lockPath, "skill-opt-controller", `skill-${skillSlug}`);
   if (!result.acquired)
     return null;
   return async () => {
@@ -52625,13 +52673,13 @@ async function runValidationWithTransientRetry(input, candidateContent, baseline
   while (true) {
     try {
       const evalInputRoot = input.inputRoot ?? input.directory;
-      const { baseline, candidate } = await _internals80.prepareCandidatePayloads(evalInputRoot, candidateId2, input.skillSlug, input.baselineModel, input.candidateModel, baselineContent, candidateContent);
+      const { baseline, candidate } = await _internals81.prepareCandidatePayloads(evalInputRoot, candidateId2, input.skillSlug, input.baselineModel, input.candidateModel, baselineContent, candidateContent);
       if (!input.dispatcher) {
         throw new Error("no evaluation dispatcher available (cannot run validation)");
       }
       const { createModelEvaluationExecutor } = await import("./runner-deeswadt.js");
       const executor = createModelEvaluationExecutor(input.dispatcher, input.sessionId);
-      const result = await _internals80.evaluateCandidateV1({
+      const result = await _internals81.evaluateCandidateV1({
         projectRoot: input.directory,
         inputRoot: input.inputRoot ?? input.directory,
         tasks: input.validationTasks,
@@ -52689,7 +52737,7 @@ async function runValidationWithTransientRetry(input, candidateContent, baseline
           deadband: input.config.deadband
         };
       }
-      _internals80.emitTelemetry?.("loop_detected", {
+      _internals81.emitTelemetry?.("loop_detected", {
         skillSlug: input.skillSlug,
         reason: message.slice(0, 160),
         source: "skill-opt-controller"
@@ -53541,7 +53589,7 @@ var DEFAULT_CONTEXT_BUDGET_CONFIG = {
 };
 
 // src/services/status-service.ts
-var _internals81 = {
+var _internals82 = {
   loadLeanTurboRunState,
   hasActiveLeanTurbo,
   hasActiveFullAuto,
@@ -53691,8 +53739,11 @@ async function getStatusData(directory, agents, sessionId) {
         const cohortConfigPath = path102.join(resolveLinkDir(memoryPointer.linkId), "memory", "memory-cohort-config.json");
         if (fsSync3.existsSync(cohortConfigPath)) {
           const stored = JSON.parse(fsSync3.readFileSync(cohortConfigPath, "utf-8"));
-          const expected = computeMemoryCohortFingerprint(buildMemoryCohortFingerprintInput(memoryConfig));
-          configFingerprintMatch = stored.fingerprint === expected;
+          const versionCheck = classifyStoredFingerprintAlgorithmVersion(stored.algorithm_version);
+          if (versionCheck.status === "comparable" && typeof stored.fingerprint === "string") {
+            const expected = computeMemoryCohortFingerprint(buildMemoryCohortFingerprintInput(memoryConfig));
+            configFingerprintMatch = stored.fingerprint === expected;
+          }
         }
       }
     } catch {}
@@ -53714,11 +53765,11 @@ async function getStatusData(directory, agents, sessionId) {
   } catch {
     status.memoryCohort = { linked: false };
   }
-  status.fullAutoActive = _internals81.hasActiveFullAuto();
+  status.fullAutoActive = _internals82.hasActiveFullAuto();
   if (status.fullAutoActive) {
-    const sid = _internals81.getActiveFullAutoSessionID();
+    const sid = _internals82.getActiveFullAutoSessionID();
     if (sid) {
-      const runState = _internals81.loadFullAutoRunState(directory, sid);
+      const runState = _internals82.loadFullAutoRunState(directory, sid);
       if (runState?.lastEscalation) {
         status.fullAutoEscalation = {
           reason: runState.lastEscalation.reason,
@@ -53752,7 +53803,7 @@ async function getStatusData(directory, agents, sessionId) {
 }
 function enrichWithLeanTurbo(status, directory) {
   const turboMode = hasActiveTurboMode();
-  const leanActive = _internals81.hasActiveLeanTurbo();
+  const leanActive = _internals82.hasActiveLeanTurbo();
   let turboStrategy = "off";
   if (leanActive) {
     turboStrategy = "lean";
@@ -53783,7 +53834,7 @@ function enrichWithLeanTurbo(status, directory) {
     }
   }
   if (leanSessionID) {
-    const runState = _internals81.loadLeanTurboRunState(directory, leanSessionID);
+    const runState = _internals82.loadLeanTurboRunState(directory, leanSessionID);
     if (runState) {
       status.leanTurboPhase = runState.phase;
       status.leanMaxParallelCoders = runState.maxParallelCoders;
@@ -54034,7 +54085,7 @@ init_logger();
 var TURBO_BYPASS_DISCLOSURE = "Bypassed: Stage B (reviewer + test_engineer) for Tier 0-2 tasks; phase_complete Gates 1-5 " + "(completion-verify, drift-verifier, hallucination-guard, mutation-gate, phase-council). " + "Still enforced: Stage A (lint, imports, pre_check_batch); Tier 3 Stage B; Gate 5b " + "(architecture-supervisor); Gate 6 (final-council); Gate 7 (full-auto).";
 
 // src/commands/turbo.ts
-var _internals82 = {
+var _internals83 = {
   loadPluginConfigWithMeta
 };
 async function handleTurboCommand(directory, args, sessionID) {
@@ -54094,7 +54145,7 @@ async function handleTurboCommand(directory, args, sessionID) {
   if (arg0 === "on") {
     let strategy = "standard";
     try {
-      const { config } = _internals82.loadPluginConfigWithMeta(directory);
+      const { config } = _internals83.loadPluginConfigWithMeta(directory);
       if (config.turbo?.strategy === "lean") {
         strategy = "lean";
       }
@@ -54191,7 +54242,7 @@ function enableLeanTurbo(session, directory, sessionID) {
   let maxParallelCoders = 4;
   let conflictPolicy = "serialize";
   try {
-    const { config } = _internals82.loadPluginConfigWithMeta(directory);
+    const { config } = _internals83.loadPluginConfigWithMeta(directory);
     const leanConfig = config.turbo?.lean;
     if (leanConfig) {
       maxParallelCoders = leanConfig.max_parallel_coders ?? 4;
@@ -54396,7 +54447,7 @@ function findSimilarCommands(query) {
   }
   const scored = VALID_COMMANDS.map((cmd) => {
     const cmdLower = cmd.toLowerCase();
-    const fullScore = _internals13.levenshteinDistance(q, cmdLower);
+    const fullScore = _internals14.levenshteinDistance(q, cmdLower);
     let tokenScore = Infinity;
     if (cmd.includes(" ") || cmd.includes("-")) {
       const qTokens = q.split(/[\s-]+/);
@@ -54409,7 +54460,7 @@ function findSimilarCommands(query) {
         for (const ct of cmdTokens) {
           if (ct.length === 0)
             continue;
-          const dist = _internals13.levenshteinDistance(qt, ct);
+          const dist = _internals14.levenshteinDistance(qt, ct);
           if (dist < minDist)
             minDist = dist;
         }
@@ -54419,7 +54470,7 @@ function findSimilarCommands(query) {
     }
     const dashStrippedQ = q.replace(/-/g, "");
     const dashStrippedCmd = cmdLower.replace(/-/g, "");
-    const dashScore = _internals13.levenshteinDistance(dashStrippedQ, dashStrippedCmd);
+    const dashScore = _internals14.levenshteinDistance(dashStrippedQ, dashStrippedCmd);
     const score = Math.min(fullScore, tokenScore, dashScore);
     return { cmd, score };
   });
@@ -54454,16 +54505,16 @@ function buildDetailedHelp(commandName, entry) {
 async function handleHelpCommand(ctx) {
   const targetCommand = ctx.args.join(" ");
   if (!targetCommand) {
-    const { buildHelpText } = await import("./index-g2kpqpvh.js");
+    const { buildHelpText } = await import("./index-xvcctb2t.js");
     return buildHelpText();
   }
   const tokens = targetCommand.split(/\s+/);
-  const resolved = _internals13.resolveCommand(tokens);
+  const resolved = _internals14.resolveCommand(tokens);
   if (resolved) {
-    return _internals13.buildDetailedHelp(resolved.key, resolved.entry);
+    return _internals14.buildDetailedHelp(resolved.key, resolved.entry);
   }
-  const similar = _internals13.findSimilarCommands(targetCommand);
-  const { buildHelpText: fullHelp } = await import("./index-g2kpqpvh.js");
+  const similar = _internals14.findSimilarCommands(targetCommand);
+  const { buildHelpText: fullHelp } = await import("./index-xvcctb2t.js");
   if (similar.length > 0) {
     return `Command '/swarm ${targetCommand}' not found.
 
@@ -54571,7 +54622,7 @@ var COMMAND_REGISTRY = {
     toolNoArgs: true
   },
   help: {
-    handler: (ctx) => _internals13.handleHelpCommand(ctx),
+    handler: (ctx) => _internals14.handleHelpCommand(ctx),
     description: "Show help for swarm commands",
     category: "core",
     args: "[command]",
@@ -54640,7 +54691,7 @@ var COMMAND_REGISTRY = {
   },
   "guardrail explain": {
     handler: async (ctx) => {
-      const { handleGuardrailExplain } = await import("./guardrail-explain-1k337z5d.js");
+      const { handleGuardrailExplain } = await import("./guardrail-explain-v6f8efve.js");
       return handleGuardrailExplain(ctx.directory, ctx.args);
     },
     description: "Dry-run: show what the guardrails would do to a command or write target (executes nothing)",
@@ -54650,7 +54701,7 @@ var COMMAND_REGISTRY = {
   },
   "guardrail-explain": {
     handler: async (ctx) => {
-      const { handleGuardrailExplain } = await import("./guardrail-explain-1k337z5d.js");
+      const { handleGuardrailExplain } = await import("./guardrail-explain-v6f8efve.js");
       return handleGuardrailExplain(ctx.directory, ctx.args);
     },
     description: "Dry-run: show what the guardrails would do to a command or write target (executes nothing)",
@@ -54660,7 +54711,7 @@ var COMMAND_REGISTRY = {
   },
   "guardrail-log": {
     handler: async (ctx) => {
-      const { handleGuardrailLog } = await import("./guardrail-log-xbc9bvdt.js");
+      const { handleGuardrailLog } = await import("./guardrail-log-0mrq14g9.js");
       return handleGuardrailLog(ctx.directory, ctx.args);
     },
     description: "Read the guardrail decision log (use --blocks-only for blocks)",
@@ -55641,7 +55692,7 @@ function validateToolPolicy() {
   }
   return { valid: warnings.length === 0, warnings };
 }
-var _internals13 = {
+var _internals14 = {
   handleHelpCommand,
   validateAliases,
   validateToolPolicy,
@@ -55651,16 +55702,16 @@ var _internals13 = {
   findSimilarCommands,
   buildDetailedHelp
 };
-var validation = _internals13.validateAliases();
+var validation = _internals14.validateAliases();
 if (!validation.valid) {
   throw new Error(`COMMAND_REGISTRY alias validation failed:
 ${validation.errors.join(`
 `)}`);
 }
-_internals13.emitValidationWarnings("COMMAND_REGISTRY alias warnings", validation.warnings);
+_internals14.emitValidationWarnings("COMMAND_REGISTRY alias warnings", validation.warnings);
 try {
-  const toolPolicyValidation = _internals13.validateToolPolicy();
-  _internals13.emitValidationWarnings("COMMAND_REGISTRY toolPolicy warnings", toolPolicyValidation.warnings);
+  const toolPolicyValidation = _internals14.validateToolPolicy();
+  _internals14.emitValidationWarnings("COMMAND_REGISTRY toolPolicy warnings", toolPolicyValidation.warnings);
 } catch (e) {
   warn(`COMMAND_REGISTRY toolPolicy validation failed (non-fatal): ${e.message}`);
 }
@@ -58237,4 +58288,4 @@ function createCuratorLLMDelegate(directory, mode = "init", sessionId) {
   };
 }
 
-export { handleAcknowledgeSpecDriftCommand, handleAgentsCommand, handleAnalyzeCommand, 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, handleArchiveCommand, handleAutoProceedCommand, handleBenchmarkCommand, handleBrainstormCommand, handleCheckpointCommand, handleCiSimulateCommand, handleClarifyCommand, createCuratorLLMDelegate, _internals22 as _internals, normalizeRecommendationEntryIdToken, parseKnowledgeRecommendations, parseKnowledgeRecommendationsWithDiagnostics, parseStructuredCuratorBlocks, readCuratorSummary, writeCuratorSummary, appendCuratorRecommendation, mergeCuratorPhaseSummary, filterPhaseEvents, checkPhaseCompliance, runCuratorInit, runCuratorPhase, applyCuratorKnowledgeUpdates, isHiveEligible, countDistinctProjects, checkHivePromotions, _internals25 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, handleReviewCommand, handleRollbackCommand, handleSddStatusCommand, handleSddValidateCommand, handleSddProjectCommand, handleSddCommand, handleSimulateCommand, handleSpecifyCommand, handleStatusCommand, handleSyncPlanCommand, handleTurboCommand, handleUnlinkCommand, handleWriteRetroCommand, handleHelpCommand, COMMAND_REGISTRY, VALID_COMMANDS, _internals13 as _internals2, resolveCommand };
+export { handleAcknowledgeSpecDriftCommand, handleAgentsCommand, handleAnalyzeCommand, 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, handleArchiveCommand, handleAutoProceedCommand, handleBenchmarkCommand, handleBrainstormCommand, handleCheckpointCommand, handleCiSimulateCommand, handleClarifyCommand, createCuratorLLMDelegate, _internals23 as _internals, normalizeRecommendationEntryIdToken, parseKnowledgeRecommendations, parseKnowledgeRecommendationsWithDiagnostics, parseStructuredCuratorBlocks, readCuratorSummary, writeCuratorSummary, appendCuratorRecommendation, mergeCuratorPhaseSummary, filterPhaseEvents, checkPhaseCompliance, runCuratorInit, runCuratorPhase, applyCuratorKnowledgeUpdates, isHiveEligible, countDistinctProjects, checkHivePromotions, _internals26 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, handleReviewCommand, handleRollbackCommand, handleSddStatusCommand, handleSddValidateCommand, handleSddProjectCommand, handleSddCommand, handleSimulateCommand, handleSpecifyCommand, handleStatusCommand, handleSyncPlanCommand, handleTurboCommand, handleUnlinkCommand, handleWriteRetroCommand, handleHelpCommand, COMMAND_REGISTRY, VALID_COMMANDS, _internals14 as _internals2, resolveCommand };